Repository: markdwags/Razor
Branch: master
Commit: d1c7b2404da9
Files: 378
Total size: 5.9 MB

Directory structure:
gitextract_9zwc60cb/

├── .github/
│   ├── ISSUE_TEMPLATE/
│   │   ├── bug_report.md
│   │   └── feature_request.md
│   └── workflows/
│       ├── build-only.yml
│       ├── build-site.yml
│       └── build.yml
├── .gitignore
├── .gitmodules
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── Crypt/
│   ├── Crypt.cpp
│   ├── Crypt.def
│   ├── Crypt.h
│   ├── Crypt.rc
│   ├── Crypt.vcxproj
│   ├── Crypt.vcxproj.filters
│   ├── LoginEncryption.cpp
│   ├── LoginEncryption.h
│   ├── MemFinder.cpp
│   ├── MemFinder.h
│   ├── OSIEncryption.cpp
│   ├── OSIEncryption.h
│   ├── OldStatusBar.cpp
│   ├── PacketInfo.cpp
│   ├── PacketInfo.h
│   ├── UOArt.cpp
│   ├── debug.h
│   ├── platform.h
│   ├── resource.h
│   ├── stdafx.cpp
│   ├── stdafx.h
│   ├── table.h
│   ├── trees.cpp
│   ├── twofish.c
│   ├── twofish.h
│   ├── uo_huffman.cpp
│   └── uo_huffman.h
├── FastColoredTextBox/
│   ├── AutocompleteItem.cs
│   ├── AutocompleteMenu.cs
│   ├── Bookmarks.cs
│   ├── Char.cs
│   ├── CommandManager.cs
│   ├── Commands.cs
│   ├── DocumentMap.cs
│   ├── EncodingDetector.cs
│   ├── ExportToHTML.cs
│   ├── ExportToRTF.cs
│   ├── FCTB_key.snk
│   ├── FastColoredTextBox.cs
│   ├── FastColoredTextBox.csproj
│   ├── FastColoredTextBox.resx
│   ├── FastColoredTextBox.xml
│   ├── FileTextSource.cs
│   ├── FindForm.Designer.cs
│   ├── FindForm.cs
│   ├── FindForm.resx
│   ├── GoToForm.Designer.cs
│   ├── GoToForm.cs
│   ├── GoToForm.resx
│   ├── Hints.cs
│   ├── Hotkeys.cs
│   ├── HotkeysEditorForm.Designer.cs
│   ├── HotkeysEditorForm.cs
│   ├── HotkeysEditorForm.resx
│   ├── LimitedStack.cs
│   ├── Line.cs
│   ├── LinesAccessor.cs
│   ├── MacrosManager.cs
│   ├── NativeMethods.cs
│   ├── Place.cs
│   ├── PlatformType.cs
│   ├── Properties/
│   │   └── AssemblyInfo.cs
│   ├── Range.cs
│   ├── ReplaceForm.Designer.cs
│   ├── ReplaceForm.cs
│   ├── ReplaceForm.resx
│   ├── Ruler.Designer.cs
│   ├── Ruler.cs
│   ├── Style.cs
│   ├── SyntaxDescriptor.cs
│   ├── SyntaxHighlighter.cs
│   ├── TextSource.cs
│   ├── TypeDescriptor.cs
│   ├── UnfocusablePanel.cs
│   └── VisualMarker.cs
├── INSTALL.md
├── LICENSE.md
├── Loader/
│   ├── Loader.cpp
│   ├── Loader.def
│   ├── Loader.h
│   ├── Loader.rc
│   ├── Loader.vcxproj
│   ├── Loader.vcxproj.filters
│   ├── resource.h
│   ├── stdafx.cpp
│   └── stdafx.h
├── Notepad++UDL.xml
├── Platform/
│   ├── Platform.cpp
│   ├── Platform.def
│   ├── Platform.h
│   ├── Platform.vcxproj
│   └── Platform.vcxproj.filters
├── README.md
├── Razor/
│   ├── Agents/
│   │   ├── Agents.cs
│   │   ├── BuyAgent.cs
│   │   ├── IgnoreAgent.cs
│   │   ├── OrganizerAgent.cs
│   │   ├── RestockAgent.cs
│   │   ├── ScavengerAgent.cs
│   │   ├── SearchExemptionAgent.cs
│   │   ├── SellAgent.cs
│   │   └── UseOnceAgent.cs
│   ├── Boat/
│   │   ├── BoatWindow.Designer.cs
│   │   ├── BoatWindow.cs
│   │   └── BoatWindow.resx
│   ├── Client/
│   │   ├── ClassicUO.cs
│   │   ├── Client.cs
│   │   ├── OSI.cs
│   │   └── UOAssist.cs
│   ├── Core/
│   │   ├── ActionQueue.cs
│   │   ├── BandageTimer.cs
│   │   ├── BodCapture.cs
│   │   ├── BuffDebuffManager.cs
│   │   ├── ClassicUOManager.cs
│   │   ├── Commands.cs
│   │   ├── ContainerLabels.cs
│   │   ├── CooldownManager.cs
│   │   ├── Counters.cs
│   │   ├── DamageTracker.cs
│   │   ├── Dress.cs
│   │   ├── DressList.cs
│   │   ├── EncodedSpeech.cs
│   │   ├── FriendsManager.cs
│   │   ├── GateTimer.cs
│   │   ├── Geometry.cs
│   │   ├── GoldPerHourTimer.cs
│   │   ├── Item.cs
│   │   ├── ItemID.cs
│   │   ├── Main.cs
│   │   ├── Map.cs
│   │   ├── MemHelper.cs
│   │   ├── MessageInBottleCapture.cs
│   │   ├── MessageManager.cs
│   │   ├── Mobile.cs
│   │   ├── MsgQueue.cs
│   │   ├── ObjectPropertyList.cs
│   │   ├── OverheadManager.cs
│   │   ├── Overrides.cs
│   │   ├── PasswordMemory.cs
│   │   ├── Ping.cs
│   │   ├── Player.cs
│   │   ├── ScreenCapture.cs
│   │   ├── Serial.cs
│   │   ├── SkillTimer.cs
│   │   ├── Spells.cs
│   │   ├── StaffToolsManager.cs
│   │   ├── StealthSteps.cs
│   │   ├── SystemMessages.cs
│   │   ├── Targeting.cs
│   │   ├── TargetingClosest.cs
│   │   ├── TargetingNextPrevious.cs
│   │   ├── TargetingRandom.cs
│   │   ├── TextFilterManager.cs
│   │   ├── Timer.cs
│   │   ├── UOEntity.cs
│   │   ├── Utility.cs
│   │   ├── WaypointManager.cs
│   │   ├── World.cs
│   │   └── ZLib.cs
│   ├── Filters/
│   │   ├── Death.cs
│   │   ├── Filter.cs
│   │   ├── Light.cs
│   │   ├── MessageFilter.cs
│   │   ├── MobileFilter.cs
│   │   ├── SoundFilters.cs
│   │   ├── SoundMusicManager.cs
│   │   ├── StaffItems.cs
│   │   ├── TargetFilterManager.cs
│   │   ├── VetRewardGump.cs
│   │   ├── WallStaticFilter.cs
│   │   └── Weather.cs
│   ├── Gumps/
│   │   ├── Gump.cs
│   │   ├── GumpButtonType.cs
│   │   ├── GumpCollection.cs
│   │   ├── GumpElement.cs
│   │   ├── GumpPage.cs
│   │   ├── GumpType.cs
│   │   └── Internal/
│   │       ├── AgentsGump.cs
│   │       ├── BoatControlGump.cs
│   │       ├── BuffGump.cs
│   │       ├── CooldownGump.cs
│   │       ├── DamageTrackerGump.cs
│   │       ├── DamageTrackerListGump.cs
│   │       ├── HotKeyGump.cs
│   │       ├── InputDialogGump.cs
│   │       ├── ItemInfoGump.cs
│   │       ├── MobileInfoGump.cs
│   │       ├── SystemMessagesGump.cs
│   │       └── TestMessageGump.cs
│   ├── HotKeys/
│   │   ├── Counters.cs
│   │   ├── HotKeys.cs
│   │   ├── Misc.cs
│   │   ├── SkillHotKeys.cs
│   │   ├── SpecialMoves.cs
│   │   └── Undress.cs
│   ├── Macros/
│   │   ├── Actions.cs
│   │   ├── Actions.resx
│   │   ├── Macro.cs
│   │   ├── MacroManager.cs
│   │   └── MacroVariables.cs
│   ├── Map/
│   │   ├── MapWindow.cs
│   │   ├── MapWindow.resx
│   │   ├── Region.cs
│   │   ├── UOMapControl.cs
│   │   ├── UOMapControl.resx
│   │   └── UOMapRuneButton.cs
│   ├── Network/
│   │   ├── Handlers.cs
│   │   ├── Loader.cs
│   │   ├── Packet.cs
│   │   ├── PacketHandler.cs
│   │   ├── PacketTable.cs
│   │   ├── PacketWriter.cs
│   │   └── Packets.cs
│   ├── Platform.cs
│   ├── Properties/
│   │   ├── AssemblyInfo.cs
│   │   ├── Resources.Designer.cs
│   │   └── Resources.resx
│   ├── Razor.csproj
│   ├── Razor.manifest
│   ├── Scripts/
│   │   ├── AgentCommands.cs
│   │   ├── Aliases.cs
│   │   ├── Commands.cs
│   │   ├── Engine/
│   │   │   ├── Interpreter.cs
│   │   │   ├── Lexer.cs
│   │   │   └── TextParser.cs
│   │   ├── Expressions.cs
│   │   ├── Helpers/
│   │   │   └── CommandHelper.cs
│   │   ├── RazorScript.cs
│   │   ├── ScriptManager.cs
│   │   ├── ScriptVariables.cs
│   │   ├── SpeechCommands.cs
│   │   └── TargetCommands.cs
│   ├── UI/
│   │   ├── AddCounter.cs
│   │   ├── AddCounter.resx
│   │   ├── ArtViewer.Designer.cs
│   │   ├── ArtViewer.cs
│   │   ├── BuffDebuffOptions.Designer.cs
│   │   ├── BuffDebuffOptions.cs
│   │   ├── BuffDebuffOptions.resx
│   │   ├── Config.cs
│   │   ├── ContainerLabels.Designer.cs
│   │   ├── ContainerLabels.cs
│   │   ├── ContainerLabels.resx
│   │   ├── Ext.cs
│   │   ├── HueEntry.cs
│   │   ├── HueEntry.resx
│   │   ├── InputBox.cs
│   │   ├── InputBox.resx
│   │   ├── InputDropdown.cs
│   │   ├── InputDropdown.resx
│   │   ├── Languages.cs
│   │   ├── MacroInsertDoWhile.cs
│   │   ├── MacroInsertDoWhile.resx
│   │   ├── MacroInsertIf.cs
│   │   ├── MacroInsertIf.resx
│   │   ├── MacroInsertWait.cs
│   │   ├── MacroInsertWait.resx
│   │   ├── MacroInsertWhile.cs
│   │   ├── MacroInsertWhile.resx
│   │   ├── MessageDialog.cs
│   │   ├── MessageDialog.resx
│   │   ├── Razor.Designer.cs
│   │   ├── Razor.cs
│   │   ├── Razor.resx
│   │   ├── SoundEntry.cs
│   │   ├── SoundEntry.resx
│   │   ├── SplashScreen.cs
│   │   ├── SplashScreen.resx
│   │   ├── WelcomeForm.cs
│   │   └── WelcomeForm.resx
│   ├── UltimaSDK/
│   │   ├── ASCIIFont.cs
│   │   ├── AnimationEdit.cs
│   │   ├── Animations.cs
│   │   ├── Animdata.cs
│   │   ├── Art.cs
│   │   ├── BwtDecompress.cs
│   │   ├── CalibrationInfo.cs
│   │   ├── Client.cs
│   │   ├── ClientHandles.cs
│   │   ├── FileIndex.cs
│   │   ├── Files.cs
│   │   ├── Gumps.cs
│   │   ├── Hues.cs
│   │   ├── Light.cs
│   │   ├── LocationPointer.cs
│   │   ├── Map.cs
│   │   ├── MultiMap.cs
│   │   ├── Multis.cs
│   │   ├── NativeMethods.cs
│   │   ├── ProcessStream.cs
│   │   ├── RadarCol.cs
│   │   ├── SkillGroups.cs
│   │   ├── Skills.cs
│   │   ├── Sound.cs
│   │   ├── SpeechList.cs
│   │   ├── StackDataReader.cs
│   │   ├── StringEntry.cs
│   │   ├── StringHelper.cs
│   │   ├── StringList.cs
│   │   ├── Textures.cs
│   │   ├── TileData.cs
│   │   ├── TileList.cs
│   │   ├── TileMatrix.cs
│   │   ├── TileMatrixPatch.cs
│   │   ├── UnicodeFont.cs
│   │   ├── ValueStringBuilder.cs
│   │   ├── Verdata.cs
│   │   └── WindowProcessStream.cs
│   ├── app.config
│   └── packages.config
├── Razor.sln
├── etc/
│   ├── Language/
│   │   ├── Razor_lang.CHS
│   │   ├── Razor_lang.PTB
│   │   ├── Razor_lang.bg
│   │   ├── Razor_lang.cht
│   │   ├── Razor_lang.deu
│   │   ├── Razor_lang.enu
│   │   ├── Razor_lang.esp
│   │   ├── Razor_lang.ita
│   │   ├── Razor_lang.pl
│   │   ├── Razor_lang.rus
│   │   ├── Razor_lang.swe
│   │   └── Razor_lang.tur
│   ├── Razor.nsi
│   ├── animdata.csv
│   ├── counters.xml
│   ├── doors.xml
│   ├── dotNet.nsh
│   ├── guardlines.def
│   ├── items.xml
│   ├── license.txt
│   ├── overrides.def
│   ├── spells.def
│   └── uorguardlines.def
└── help/
    ├── docs/
    │   ├── download.md
    │   ├── faq.md
    │   ├── guide/
    │   │   ├── commands.md
    │   │   ├── comments.md
    │   │   ├── expressions.md
    │   │   ├── index.md
    │   │   ├── keywords.md
    │   │   ├── layers.md
    │   │   └── variables.md
    │   ├── help/
    │   │   ├── advanced.md
    │   │   ├── agents.md
    │   │   ├── armdress.md
    │   │   ├── displaycounters.md
    │   │   ├── filters.md
    │   │   ├── friends.md
    │   │   ├── general.md
    │   │   ├── hotkeys.md
    │   │   ├── index.md
    │   │   ├── macros.md
    │   │   ├── options.md
    │   │   ├── screenshots.md
    │   │   ├── scripts.md
    │   │   └── skills.md
    │   ├── history.md
    │   ├── index.md
    │   ├── install/
    │   │   ├── linux.md
    │   │   └── windows.md
    │   ├── releasenotes.md
    │   ├── stylesheets/
    │   │   └── extra.css
    │   └── uoaapi.md
    ├── mkdocs.yml
    ├── overrides/
    │   └── main.html
    ├── pygments.lexers.razor
    ├── pygments.mapping.razor
    └── pygments.styles.razor

================================================
FILE CONTENTS
================================================

================================================
FILE: .github/ISSUE_TEMPLATE/bug_report.md
================================================
---
name: Bug report
about: Create a report to help Razor improve
title: "[BUG]"
labels: bug
assignees: ''

---

**Please include if you are using the standard OSI client or using ClassicUO.**

Remember, **Great Bug Reports** tend to have:

- A quick summary and/or background of the issue
- Steps to reproduce
  - Be specific! This can be challenging at times in a game like UO, but the more specific you are, the easier it is to fix
  - Include screenshots, gifs, videos if possible. Free apps like ShareX and Greenshot make it easy.
- What you expected would happen
- What actually happens
- Notes (possibly including why you think this might be happening, or stuff you tried that didn't work)


================================================
FILE: .github/ISSUE_TEMPLATE/feature_request.md
================================================
---
name: Feature request
about: Suggest an idea for Razor
title: "[FEATURE]"
labels: enhancement
assignees: ''

---

All feature requests will be considered, but not all will be implemented but please don't let that discourage you from submitting more.

**Is your feature request related to a problem? Please describe.**
A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]

**Describe the solution you'd like**
A clear and concise description of what you want to happen.

**Describe alternatives you've considered**
A clear and concise description of any alternative solutions or features you've considered.

**Additional context**
Add any other context or screenshots about the feature request here.


================================================
FILE: .github/workflows/build-only.yml
================================================
name: Build Only

on:
  pull_request:
    branches:
      - master
    paths-ignore:
      - 'help/**'
      - '**/build-site.yml'     

jobs:

  build:

    strategy:
      matrix:
        configuration: [Release]

    runs-on: windows-2022

    env:
      Solution_Name: Razor.sln       

    steps:
    - name: Checkout
      uses: actions/checkout@v2
      with:
        fetch-depth: 0
    
    - name: Install .NET
      uses: actions/setup-dotnet@v1
      with:
        dotnet-version: 6.0.x

    - name: Setup MSBuild.exe
      uses: microsoft/setup-msbuild@v1.1

    - name: Restore Razor
      run: msbuild $env:Solution_Name /t:Restore /p:Configuration=$env:Configuration
      env:
        Configuration: ${{ matrix.configuration }}

    - name: Build Razor
      run: msbuild $env:Solution_Name /t:Build /p:Configuration=$env:Configuration
      env:
        Configuration: ${{ matrix.configuration }}




================================================
FILE: .github/workflows/build-site.yml
================================================
name: Build Site

on:
  push:
    branches:
      - master
    paths:
    - 'help/**'
    - '**/build-site.yml'
  pull_request:
    branches:
      - master
    paths:
    - 'help/**'
    - '**/build-site.yml'

jobs:
  build:
    runs-on: ubuntu-latest
    defaults:
      run:
        working-directory: ./help
    strategy:
      matrix:
        python-version: [3.10.9]
    
    steps:
      - uses: actions/checkout@v3
      - name: Set up Python ${{ matrix.python-version }}
        uses: actions/setup-python@v4
        with:
          python-version: ${{ matrix.python-version }}
          
      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install mkdocs
          pip install mkdocs-material                    
          pip install mkdocs-git-revision-date-localized-plugin
          pip install pillow
          pip install cairosvg 
          sudo apt-get install -y libcairo2-dev libfreetype6-dev libffi-dev libjpeg-dev libpng-dev libz-dev
      
      - name: Install and modify Pygments
        run: |

          git clone https://github.com/pygments/pygments.git
          
          # Replace with Razor files
          rm ./pygments/pygments/lexers/_mapping.py
          cp pygments.mapping.razor ./pygments/pygments/lexers/_mapping.py
          
          cp pygments.lexers.razor ./pygments/pygments/lexers/razor.py          
          cp pygments.styles.razor ./pygments/pygments/styles/razor.py

          pip install -e ./pygments/          

      # Runs a single command using the runners shell
      - name: Build site
        run: mkdocs build

      - name: Generate robots.txt
        run: |
          cat > ./site/robots.txt <<EOF
          User-agent: *
          Allow: /

          Sitemap: https://www.razorce.com/sitemap.xml
          EOF          

      # Setup AWS
      - name: Configure AWS Credentials
        uses: aws-actions/configure-aws-credentials@v1
        with:
          aws-access-key-id: ${{ secrets.AWS_ACCESS_ID }}
          aws-secret-access-key: ${{ secrets.AWS_SECRET_KEY }}
          aws-region: us-east-1

      - name: Deploy static site to S3 bucket
        run: aws s3 sync ./site s3://www.razorce.com

      # Invalidate the distributons
      - name: Create CloudFront Invalidation
        run: |
          aws cloudfront create-invalidation --distribution-id ${{ secrets.DISTRIBUTION_A }} --paths "/*" 
          aws cloudfront create-invalidation --distribution-id ${{ secrets.DISTRIBUTION_B }} --paths "/*" 

================================================
FILE: .github/workflows/build.yml
================================================
name: Build Dev Preview

on:
  push:
    branches:
      - master
    paths-ignore:
      - 'help/**'
      - '**/build-site.yml'

jobs:

  build:

    strategy:
      matrix:
        configuration: [Release]

    runs-on: windows-2022

    env:
      Solution_Name: Razor.sln       

    steps:
    - name: Checkout
      uses: actions/checkout@v2
      with:
        fetch-depth: 0
    
    - name: Install .NET
      uses: actions/setup-dotnet@v1
      with:
        dotnet-version: 6.0.x

    - name: Setup MSBuild.exe
      uses: microsoft/setup-msbuild@v1.1

    - name: Restore Razor
      run: msbuild $env:Solution_Name /t:Restore /p:Configuration=$env:Configuration
      env:
        Configuration: ${{ matrix.configuration }}
        
    - name: Set AssemblyInfo
      uses: dannevesdantas/set-version-assemblyinfo@v.1.0.0
      with:                     
        version: '1.10.${{ github.run_number }}.0'

    - name: Build Razor (x86)
      run: msbuild $env:Solution_Name /t:Build /p:Configuration=$env:Configuration /p:Platform="Any CPU"
      env:
        Configuration: ${{ matrix.configuration }}

    - name: Build Razor (x64)
      run: msbuild $env:Solution_Name /t:Build /p:Configuration=$env:Configuration /p:Platform=x64
      env:
        Configuration: ${{ matrix.configuration }}

    - name: Archive Razor x86 build artifacts      
      run: |
        cd bin/Win32/Release/
        7z a -tzip "Razor-dev-x86-preview.zip" "*"

    - name: Archive Razor x64 build artifacts      
      run: |
        cd bin/x64/Release/
        7z a -tzip "Razor-dev-x64-preview.zip" "*"

    - name: Delete Dev Release
      uses: dev-drprasad/delete-tag-and-release@v0.2.1
      with:
        delete_release: true
        tag_name: Razor-dev-preview
        github_token: ${{ secrets.GITHUB_TOKEN }}
      env:
        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

    - name: Create Dev Release
      uses: ncipollo/release-action@v1
      with:
        name: "Razor Dev Preview"
        body: "This is built automatically after each commit to master, so it may contain bugs and/or unfinished features but is generally considered stable. Use at your own risk."
        artifacts: "bin/Win32/Release/Razor-dev-x86-preview.zip,bin/x64/Release/Razor-dev-x64-preview.zip"          
        prerelease: true
        tag: Razor-dev-preview
        token: ${{ secrets.GITHUB_TOKEN }}



================================================
FILE: .gitignore
================================================
# Visual Studio
*.vs
*.vscode
*.vcxproj.user
*.csproj.user
.vscode
packages/

# Rider
.idea

# Build Output
[Dd]ebug/
[Rr]elease/
/Crypt.quick
/wiki-github.txt
/Razor.sln.DotSettings.user
/Razor.sln.DotSettings
CSharpGuidelines.Layer.DotSettings
/help/site
/help/pygments
.cache


================================================
FILE: .gitmodules
================================================
[submodule "ScriptEngine/Steam"]
	path = ScriptEngine/Steam
	url = https://github.com/jaedan/steam-engine


================================================
FILE: CODE_OF_CONDUCT.md
================================================
## Code of Conduct

### Our Pledge

In the interest of fostering an open and welcoming environment, we as
contributors and maintainers pledge to making participation in our project and
our community a harassment-free experience for everyone, regardless of age, body
size, disability, ethnicity, gender identity and expression, level of experience,
nationality, personal appearance, race, religion, or sexual identity and
orientation.

### Our Standards

Examples of behavior that contributes to creating a positive environment
include:

* Using welcoming and inclusive language
* Being respectful of differing viewpoints and experiences
* Gracefully accepting constructive criticism
* Focusing on what is best for the project and community
* Showing empathy towards other community members

Examples of unacceptable behavior by participants include:

* The use of sexualized language or imagery and unwelcome sexual attention or
advances
* Trolling, insulting/derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others' private information, such as a physical or electronic
  address, without explicit permission
* Other conduct which could reasonably be considered inappropriate in a
  professional setting

### Our Responsibilities

Project maintainers are responsible for clarifying the standards of acceptable
behavior and are expected to take appropriate and fair corrective action in
response to any instances of unacceptable behavior.

Project maintainers have the right and responsibility to remove, edit, or
reject comments, commits, code, wiki edits, issues, and other contributions
that are not aligned to this Code of Conduct, or to ban temporarily or
permanently any contributor for other behaviors that they deem inappropriate,
threatening, offensive, or harmful.

### Scope

This Code of Conduct applies both within project spaces and in public spaces
when an individual is representing the project or its community. Examples of
representing a project or community include using an official project e-mail
address, posting via an official social media account, or acting as an appointed
representative at an online or offline event. Representation of a project may be
further defined and clarified by project maintainers.

### Enforcement

Instances of abusive, harassing, or otherwise unacceptable behavior may be
reported by contacting the project team. All
complaints will be reviewed and investigated and will result in a response that
is deemed necessary and appropriate to the circumstances. The project team is
obligated to maintain confidentiality with regard to the reporter of an incident.
Further details of specific enforcement policies may be posted separately.

Project maintainers who do not follow or enforce the Code of Conduct in good
faith may face temporary or permanent repercussions as determined by other
members of the project's leadership.

### Attribution

This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
available at [http://contributor-covenant.org/version/1/4][version]

[homepage]: http://contributor-covenant.org
[version]: http://contributor-covenant.org/version/1/4/

================================================
FILE: CONTRIBUTING.md
================================================
# Contributing

We want to make contributing to this project as easy and transparent as possible, whether it's:

- Reporting a bug
- Discussing the current state of the code
- Submitting a fix
- Proposing new features
- Testing the compiled version

When contributing to this repository, either through a bug report or a pull request, please first discuss the change or bug via Discord or any other method with the owners of this repository.

[![Chat on Discord status](https://img.shields.io/discord/458277173208547350.svg?logo=discord)](https://discord.gg/VdyCpjQ)

Please note we have a [code of conduct](CODE_OF_CONDUCT.md), please follow it in all your interactions with this project.

### Pull Request Process

1. Fork the repo and create your own branch from master
2. Make your code changes. If you plan on adding multiple changes, please create commits for each change instead of one commit with all the changes.
3. Create a pull request based on your branch

The pull request will be reviewed, tested and a decision to merge or not will be made.

### Your Contributions

When you submit code changes, your submissions are understood to be under the same [GPLv3](LICENSE) that covers the project.

================================================
FILE: Crypt/Crypt.cpp
================================================
#include "stdafx.h"
#include "Crypt.h"
#include "uo_huffman.h"
#include "PacketInfo.h"
#include "OSIEncryption.h"
#include "LoginEncryption.h"
#include "MemFinder.h"

//*************************************************************************************
//**************************************Variables**************************************
//*************************************************************************************
HHOOK hWndProcRetHook = NULL;
HHOOK hGetMsgHook = NULL;
HWND hUOWindow = NULL;
HWND hRazorWnd = NULL;
HWND hMapWnd = NULL;
DWORD UOProcId = 0;

HANDLE hFileMap = NULL;
HMODULE hInstance = NULL;
SOCKET CurrentConnection = 0;

HANDLE CommMutex = NULL;

char *tempBuff = NULL;

SharedMemory *pShared = NULL;

LARGE_INTEGER PerfFreq, Counter;

HWND hUOAWnd = NULL;

SIZE DesiredSize = {800,600};

unsigned long OldRecv, OldSend, OldConnect, OldCloseSocket, OldSelect, OldCreateFileA;
unsigned long RecvAddress, SendAddress, ConnectAddress, CloseSocketAddress, SelectAddress, CreateFileAAddress;

bool Seeded = false;
bool FirstRecv = true;
bool FirstSend = true;
bool LoginServer = false;
bool Active = true;
bool SmartCPU = false;
bool ServerNegotiated = false;
bool InGame = false;
bool CopyFailed = true;
bool Forwarding = false;
bool Forwarded = false;
bool ClientEncrypted = false;
bool ServerEncrypted = false;

enum CLIENT_TYPE { TWOD = 1, THREED = 2 };
CLIENT_TYPE ClientType = TWOD;

//**************************************OSI Only Stuff*********************************
DWORD CryptSeed = 0x7f000001;
OSIEncryption *ClientCrypt = NULL;
OSIEncryption *ServerCrypt = NULL;
LoginEncryption *ClientLogin = NULL;
LoginEncryption *ServerLogin = NULL;
//*************************************************************************************

//*************************************************************************************
//**************************************Functions**************************************
//*************************************************************************************
LRESULT CALLBACK WndProcRetHookFunc( int, WPARAM, LPARAM );
LRESULT CALLBACK GetMsgHookFunc( int, WPARAM, LPARAM );

bool HookFunction( const char *, const char *, int, unsigned long, unsigned long *, unsigned long * );
void FlushSendData();

bool CreateSharedMemory();
void CloseSharedMemory();

//Hooks:
int HookRecv( SOCKET, char *, int, int );
int HookSend( SOCKET, char *, int, int );
int HookConnect( SOCKET, const sockaddr *, int );
int HookCloseSocket( SOCKET );
int HookSelect( int, fd_set*, fd_set*, fd_set*, const struct timeval * );

typedef int (*NetIOFunc)(SOCKET, char *, int, int);
typedef int (*ConnFunc)(SOCKET, const sockaddr *, int);
typedef int (*CLSFunc)(SOCKET);
typedef int (*SelectFunc)( int, fd_set*, fd_set*, fd_set*, const struct timeval* );
typedef HANDLE (*CreateFileAFunc)(LPCTSTR,DWORD,DWORD,LPSECURITY_ATTRIBUTES,DWORD,DWORD,HANDLE);
typedef char *(__cdecl *GetUOVersionFunc)();

GetUOVersionFunc NativeGetUOVersion = NULL;

BOOL APIENTRY DllMain( HANDLE hModule, DWORD dwReason, LPVOID )
{
	DWORD postID, thisID;

	hInstance = (HMODULE)hModule;
	switch (dwReason)
	{
	case DLL_PROCESS_ATTACH:
		DisableThreadLibraryCalls( hInstance );
		QueryPerformanceFrequency( &PerfFreq );
		QueryPerformanceCounter( &Counter );
		break;

	case DLL_PROCESS_DETACH:
		postID = 0;
		thisID = GetCurrentProcessId();
		if ( IsWindow( hRazorWnd ) )
			GetWindowThreadProcessId( hRazorWnd, &postID );

		if ( thisID == postID || thisID == UOProcId )
		{
			if ( IsWindow( hRazorWnd ) )
				PostMessage( hRazorWnd, WM_UONETEVENT, CLOSE, 0 );

			if ( IsWindow( hUOWindow ) )
			{
				PostMessage( hUOWindow, WM_QUIT, 0, 0 );
				SetForegroundWindow( hUOWindow );
				SetFocus( hUOWindow );
			}

			CloseSharedMemory();
		}
		break;

	case DLL_THREAD_ATTACH:
	case DLL_THREAD_DETACH:
		break;
	}

	return TRUE;
}

DLLFUNCTION void *GetSharedAddress()
{
	Log( "Get shared address [0x%x]", pShared );
	return pShared;
}

DLLFUNCTION HWND FindUOWindow( void )
{
	if ( hUOWindow == NULL || !IsWindow(hUOWindow) )
	{
		HWND hWnd = FindWindow( "Ultima Online", NULL );
		if (hWnd == NULL)
			hWnd = FindWindow( "Ultima Online Third Dawn", NULL );
		return hWnd;
	}
	else
	{
		return hUOWindow;
	}
}

DLLFUNCTION void SetDataPath( const char *path )
{
	WaitForSingleObject( CommMutex, INFINITE );
	strncpy( pShared->DataPath, path, MAX_PATH);
	ReleaseMutex( CommMutex );
}

DLLFUNCTION int InstallLibrary( HWND PostWindow, DWORD pid, int flags )
{
	DWORD UOTId = 0;

	Log( "Initialize library..." );

	HWND hWnd = NULL;
	if ( pid != 0 )
	{
		hWnd = FindWindow( "Ultima Online", NULL );
		while ( hWnd != NULL )
		{
			UOTId = GetWindowThreadProcessId( hWnd, &UOProcId );
			if ( UOProcId == pid )
				break;
			hWnd = FindWindowEx( NULL, hWnd, "Ultima Online", NULL );
		}

		if ( UOProcId != pid || hWnd == NULL )
		{
			hWnd = FindWindow( "Ultima Online Third Dawn", NULL );
			while ( hWnd != NULL )
			{
				UOTId = GetWindowThreadProcessId( hWnd, &UOProcId );
				if (UOProcId == pid)
					break;
				hWnd = FindWindowEx( NULL, hWnd, "Ultima Online Third Dawn", NULL );
			}
		}

		if ( UOProcId != pid )
			return NO_TID;
	}
	else
	{
		hWnd = FindUOWindow();
		if ( hWnd != NULL )
			UOTId = GetWindowThreadProcessId( hWnd, &UOProcId );
	}

	hUOWindow = hWnd;
	hRazorWnd = PostWindow;

	if ( hUOWindow == NULL )
		return NO_UOWND;

	if ( !UOTId || !UOProcId )
		return NO_TID;

	if ( !CreateSharedMemory() )
		return NO_SHAREMEM;

	pShared->Reserved0 = false;

	hWndProcRetHook = SetWindowsHookEx( WH_CALLWNDPROCRET, WndProcRetHookFunc, hInstance, UOTId );
	if ( !hWndProcRetHook )
		return NO_HOOK;

	hGetMsgHook = SetWindowsHookEx( WH_GETMESSAGE, GetMsgHookFunc, hInstance, UOTId );
	if ( !hGetMsgHook )
		return NO_HOOK;

	WNDCLASS wc;
	wc.style = 0;
	wc.lpfnWndProc = (WNDPROC)UOAWndProc;
	wc.cbClsExtra = 0;
	wc.cbWndExtra = 0;
	wc.hInstance = hInstance;
	wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
	wc.hCursor = LoadCursor(NULL, IDC_ARROW);
	wc.hbrBackground = NULL;
	wc.lpszMenuName = NULL;
	wc.lpszClassName = "UOASSIST-TP-MSG-WND";
	RegisterClass(&wc);
	DWORD error = GetLastError();

	hUOAWnd = CreateWindow("UOASSIST-TP-MSG-WND", "UOASSIST-TP-MSG-WND", WS_OVERLAPPEDWINDOW, 0, 0, 50, 50, NULL, NULL, hInstance, 0);
	if (hUOAWnd)
		ShowWindow(hUOAWnd, FALSE);

	ServerEncrypted = (flags&0x10) != 0;
	ClientEncrypted = (flags&0x08) != 0;

	PostMessage( hUOWindow, WM_PROCREADY, (WPARAM)flags, (LPARAM)hRazorWnd );
	return SUCCESS;
}

DLLFUNCTION void WaitForWindow( DWORD pid )
{
	DWORD UOTId = 0;
	DWORD exitCode;
	HANDLE hProc = OpenProcess( PROCESS_QUERY_INFORMATION, FALSE, pid );

	UOProcId = 0;

	do
	{
		Sleep( 10 );
		HWND hWnd = FindWindow( "Ultima Online", NULL );
		while ( hWnd != NULL )
		{
			UOTId = GetWindowThreadProcessId( hWnd, &UOProcId );
			if ( UOProcId == pid )
				break;
			hWnd = FindWindowEx( NULL, hWnd, "Ultima Online", NULL );
		}

		if ( UOProcId != pid || hWnd == NULL )
		{
			hWnd = FindWindow( "Ultima Online Third Dawn", NULL );
			while ( hWnd != NULL )
			{
				UOTId = GetWindowThreadProcessId( hWnd, &UOProcId );
				if (UOProcId == pid)
					break;
				hWnd = FindWindowEx( NULL, hWnd, "Ultima Online Third Dawn", NULL );
			}
		}

		GetExitCodeProcess( hProc, &exitCode );
	} while ( UOProcId != pid && exitCode == STILL_ACTIVE );

	CloseHandle( hProc );
}

DLLFUNCTION void Shutdown( bool close )
{
	Log( "Shutdown" );

	if (hUOAWnd && IsWindow(hUOAWnd))
	{
		UnregisterClass("UOASSIST-TP-MSG-WND", hInstance);
		SendMessage(hUOAWnd, WM_CLOSE, 0, 0);
		hUOAWnd = NULL;
	}

	if ( hUOWindow && IsWindow( hUOWindow ) )
		PostMessage( hUOWindow, WM_QUIT, 0, 0 );
}

DLLFUNCTION int GetUOProcId()
{
	return UOProcId;
}

DLLFUNCTION HANDLE GetCommMutex()
{
	return CommMutex;
}

// totalsend and totalrecv are NOT mutex sync'd
DLLFUNCTION unsigned int TotalOut()
{
	if ( pShared )
		return pShared->TotalSend;
	else
		return 0;
}

DLLFUNCTION unsigned int TotalIn()
{
	if ( pShared )
		return pShared->TotalRecv;
	else
		return 0;
}

DLLFUNCTION void CalibratePosition( uint16_t x, uint16_t y, uint16_t z )
{
	Position pos;
	COPYDATASTRUCT copydata;

	pos.x = x;
	pos.y = y;
	pos.z = z;

	copydata.dwData = (ULONG_PTR)UONET_MESSAGE_COPYDATA::POSITION;
	copydata.cbData = sizeof(pos);
	copydata.lpData = &pos;

	SendMessage(hUOWindow, WM_COPYDATA, (WPARAM)hRazorWnd, (LPARAM)&copydata);
}

/* These variables are used in the UO client process address space */

/* 7.0.15.1 Client, Modified for Outlands
   Located at 0x00A72BD8 */
#pragma pack(1)
struct PositionOutlands {
	uint16_t x;
	uint16_t y;
	uint16_t z;
};
static_assert(sizeof(struct PositionOutlands) == 6, "Incorrect size\n");

/* 5.0.8.3 Client, UO Renaissance
   Located at address 0x007D7C58 */
#pragma pack(1)
struct PositionUOR {
	uint32_t z;
	uint32_t y;
	uint32_t x;
};
static_assert(sizeof(struct PositionUOR) == 12, "Incorrect size\n");
// UOR client this is at 0x007D7C60 (x is)

// Fall back search. Not always reliable.
#pragma pack(1)
struct PositionGeneric {
	uint32_t z;
	uint32_t y;
	uint32_t x;
};
static_assert(sizeof(struct PositionGeneric) == 12, "Incorrect size\n");

Position g_TestPosition = {};
Position g_LastPosition = {};
void *g_ClientMem = nullptr;

static void CheckPosition()
{
	if (g_ClientMem == nullptr) {
		if (strncmp(pShared->UOVersion, "5.0.8.3", sizeof(pShared->UOVersion)) == 0) {
			/* On UOR, we know exactly where the position is. */
			g_ClientMem = (void *)(0x007D7C60);
		}
		else if (strncmp(pShared->UOVersion, "7.0.15.1", sizeof(pShared->UOVersion)) == 0) {
			/* Similarly on Outlands, we know where the position is. */
			g_ClientMem = (void *)(0x00A72BD8);
		} else {
			/* Scan the region of memory in the client known to hold the player's position */
			for (uintptr_t addr = 0x00500000; addr < 0x00C00000; addr += 2)
			{
				if (IsBadReadPtr((void*)addr, sizeof(PositionGeneric))) {
					break;
				}

				PositionGeneric* mem = (PositionGeneric*)addr;

				if (mem->x == g_TestPosition.x && mem->y == g_TestPosition.y && mem->z == g_TestPosition.z) {
					g_ClientMem = mem;
					break;
				}
			}
		}
	}

	if (g_ClientMem != nullptr) {
		Position pos;
		if (strncmp(pShared->UOVersion, "5.0.8.3", sizeof(pShared->UOVersion)) == 0) {
			PositionUOR *mem = (PositionUOR*)g_ClientMem;
			pos.x = mem->x;
			pos.y = mem->y;
			pos.z = mem->z;
		} else if (strncmp(pShared->UOVersion, "7.0.15.1", sizeof(pShared->UOVersion)) == 0) {
			/* Similarly on Outlands, we know where the position is. */
			PositionOutlands *mem = (PositionOutlands*)g_ClientMem;
			pos.x = mem->x;
			pos.y = mem->y;
			pos.z = mem->z;
		} else {
			PositionGeneric *mem = (PositionGeneric*)g_ClientMem;
			pos.x = mem->x;
			pos.y = mem->y;
			pos.z = mem->z;
		}

		if (pos.x != g_LastPosition.x || pos.y != g_LastPosition.y || pos.z != g_LastPosition.z) {
			/* Inform Razor of a position change */

			COPYDATASTRUCT copydata;

			copydata.dwData = (ULONG_PTR)UONET_MESSAGE_COPYDATA::POSITION;
			copydata.cbData = sizeof(pos);
			copydata.lpData = &pos;

			SendMessage(hRazorWnd, WM_COPYDATA, (WPARAM)hUOWindow, (LPARAM)&copydata);
		}

		g_LastPosition = pos;
	}
}

VOID CALLBACK OnTick(HWND hwnd, UINT Message, UINT TimerId, DWORD dwTime) {
	/* Scan client memory for position updates */
	CheckPosition();

	/* Post a message to Razor to indicate a game loop tick.*/
	PostMessage(hRazorWnd, WM_UONETEVENT, ON_TICK, 0);
}

SIZE *SizePtr = NULL;
void OnSetUOWindowSize( int width )
{
	if ( width != 800 && width != 600 ) // in case it actually the height for some reason
	{
		SizePtr->cx = 640;
		SizePtr->cy = 480;
	}
	else
	{
		*SizePtr = DesiredSize;
	}
}

DLLFUNCTION void OnAttach( void *params, int paramsLen )
{
	int count = 0;
	DWORD addr = 0, oldProt;
	MemFinder mf;

	UOProcId = GetCurrentProcessId();

	if ( !CreateSharedMemory() )
		return;

		CopyFailed = false;
		mf.AddEntry("UoClientApp", 12, 0x00500000);
		mf.AddEntry("report\0", 8, 0x00500000);
		mf.AddEntry("Another copy of ", 16, 0x00500000);
		mf.AddEntry("\x00\x68\x88\x13\x00\x00\x56\xE8", 8);
		mf.AddEntry("\x68\x88\x13\x00\x00", 5, 16, 0x00400000); // (end of a push offset), push 5000, push esi
		mf.AddEntry("Electronic Arts Inc.", 20);
		mf.AddEntry("intro.bik", 10);
		mf.AddEntry("osilogo.bik", 12);
		mf.AddEntry("\x80\x02\x00\x00\xE0\x01\x00\x00", 8, 0x00500000); // current screen size
		mf.AddEntry("\x8B\x44\x24\x04\xBA\x80\x02\x00\x00\x3B\xC2\xB9\xE0\x01\x00\x00", 16); // resize screen function
		mf.AddEntry("\x57\x56\x6A\x00\x6A\x00\xE8", 7); // redraw screen/edge function
		mf.AddEntry(PACKET_TBL_STR, PACKET_TS_LEN, 10, 0x00500000);
		mf.AddEntry(CRYPT_KEY_STR, CRYPT_KEY_LEN);
		mf.AddEntry(CRYPT_KEY_STR_3D, CRYPT_KEY_3D_LEN);
		mf.AddEntry(CRYPT_KEY_STR_NEW, CRYPT_KEY_NEW_LEN);
		mf.AddEntry(CRYPT_KEY_STR_MORE_NEW, CRYPT_KEY_MORE_NEW_LEN);
		mf.AddEntry("UO Version %s", 12);
		mf.AddEntry("Multiple Instances Running", 26, 0x00500000);

		memcpy( pShared->PacketTable, StaticPacketTable, 256*sizeof(short) );

		mf.Execute();

		SizePtr = (SIZE*)mf.GetAddress("\x80\x02\x00\x00\xE0\x01\x00\x00", 8);
		if (SizePtr)
		{
			addr = mf.GetAddress("\x8B\x44\x24\x04\xBA\x80\x02\x00\x00\x3B\xC2\xB9\xE0\x01\x00\x00", 16);
			if (addr)
			{
				int i;
				DWORD origAddr = addr;

				VirtualProtect((void*)origAddr, 128, PAGE_EXECUTE_READWRITE, &oldProt);
				for (i = 16; i < 128; i++)
				{
					if (*((BYTE*)(addr + i)) == 0xE9) // find the first jmp
					{
						memset((void*)addr, 0x90, i); // nop

						// mov eax, dword [esp+4]
						*((BYTE*)(addr + 0)) = 0x8B; // mov
						*((BYTE*)(addr + 1)) = 0x44; //  eax
						*((BYTE*)(addr + 2)) = 0x24; //  [esp
						*((BYTE*)(addr + 3)) = 0x04; //      +4]
						addr += 4;

						*((BYTE*)addr) = 0x50; // push eax
						addr++;
						// call OnSetUOWindowSize
						*((BYTE*)addr) = 0xE8;
						*((DWORD*)(addr + 1)) = ((DWORD)OnSetUOWindowSize) - (addr + 5);
						addr += 5;
						break;
					}
				}
				VirtualProtect((void*)origAddr, 128, oldProt, &oldProt);
			}
		}

		int i = 0;
		while ((addr = mf.GetAddress(PACKET_TBL_STR, PACKET_TS_LEN, i++)) != 0)
		{
			memset(pShared->PacketTable, 0xFF, 512);

			addr += PACKET_TBL_OFFSET;
			if (IsBadReadPtr((void*)addr, sizeof(ClientPacketInfo) * 128))
				continue;
			ClientPacketInfo *tbl = (ClientPacketInfo*)addr;

			if (tbl[0].Id == 1 || tbl[0].Id == 2 || tbl[0].Id >= 256)
				continue;

			// this one isnt in order because OSI are idiots (0xF8)
			pShared->PacketTable[tbl[0].Id] = tbl[0].Length;

			int idx = 1;
			bool got1 = false, got2 = false;
			for (int prev = 0; prev < 255 && idx < 256; idx++)
			{
				if (IsBadReadPtr((void*)(tbl + idx), sizeof(ClientPacketInfo)) ||
					tbl[idx].Id <= prev || tbl[idx].Id >= 256)
				{
					break;
				}

				got1 |= tbl[idx].Id == 1 && tbl[idx].Length == StaticPacketTable[1];
				got2 |= tbl[idx].Id == 2 && tbl[idx].Length == StaticPacketTable[2];

				prev = tbl[idx].Id;
				if (pShared->PacketTable[prev] == 0xFFFF)
					pShared->PacketTable[prev] = tbl[idx].Length;
			}

			if (idx < 128 || !got1 || !got2)
				continue;
			else
				break;
		}

		if (!addr)
			CopyFailed = true;

		addr = mf.GetAddress(CRYPT_KEY_STR, CRYPT_KEY_LEN);
		if (!addr)
		{
			addr = mf.GetAddress(CRYPT_KEY_STR_NEW, CRYPT_KEY_NEW_LEN);

			if (!addr)
			{
				addr = mf.GetAddress(CRYPT_KEY_STR_MORE_NEW, CRYPT_KEY_MORE_NEW_LEN);
				if (!addr)
				{
					addr = mf.GetAddress(CRYPT_KEY_STR_3D, CRYPT_KEY_3D_LEN);
					if (addr)
					{
						LoginEncryption::SetKeys((const DWORD*)(addr + CRYPT_KEY_3D_LEN), (const DWORD*)(addr + CRYPT_KEY_3D_LEN + 19));
						ClientType = THREED;
					}
					else
					{
					CopyFailed = true;
					}
				}
				else
				{
					addr += CRYPT_KEY_MORE_NEW_LEN;

					const DWORD *pKey1 = *((DWORD**)addr);
					const DWORD *pKey2 = pKey1 + 1;
					if (IsBadReadPtr(pKey2, 4) || IsBadReadPtr(pKey1, 4))
						CopyFailed = true;
					else
						LoginEncryption::SetKeys(pKey1, pKey2);
				}
			}
			else
			{
				addr += CRYPT_KEY_NEW_LEN;

				const DWORD *pKey1 = *((DWORD**)addr);
				const DWORD *pKey2 = pKey1 - 1;
				if (IsBadReadPtr(pKey2, 4) || IsBadReadPtr(pKey1, 4))
					CopyFailed = true;
				else
					LoginEncryption::SetKeys(pKey1, pKey2);
			}
		}
		else
		{
			LoginEncryption::SetKeys((const DWORD*)(addr + CRYPT_KEY_LEN), (const DWORD*)(addr + CRYPT_KEY_LEN + 6));
		}

		// Multi UO
		addr = mf.GetAddress("UoClientApp", 12);
		if (addr)
		{
			VirtualProtect((void*)addr, 12, PAGE_READWRITE, &oldProt);
			_snprintf((char*)addr, 12, "UoApp%d", UOProcId);
			VirtualProtect((void*)addr, 12, oldProt, &oldProt);
		}

		addr = mf.GetAddress("Another copy of ", 16);
		if (addr)
		{
			char buff[5];

			buff[0] = 0x68; // push
			*((DWORD*)(&buff[1])) = addr;

			addr = 0x00400000;
			do {
				addr = MemFinder::Find(buff, 5, addr, 0x00600000);
				if (addr)
				{
					if ((*((unsigned char*)(addr - 5))) == 0x74) // jz?
						MemoryPatch(addr - 5, 0xEB, 1); // change to jmp
					addr += 5; // skip ahead to find the next instance
				}
			} while (addr > 0 && addr < 0x00600000);
		}

		addr = mf.GetAddress("Multiple Instances Running", 26);
		if (addr)
		{
			char buff[5];

			buff[0] = 0x68; // push
			*((DWORD*)(&buff[1])) = addr;

			addr = 0x00400000;
			do {
				addr = MemFinder::Find(buff, 5, addr, 0x00600000);
				if (addr)
				{
					char in = (*((unsigned char*)(addr - 4)));
					if (in == 0x74 || in == 0x75) { // jz or jnz
						MemoryPatch(addr - 4, 0xEB, 1); // change to jmp
					}
					addr += 5; // skip ahead to find the next instance
				}
			} while (addr > 0 && addr < 0x00600000);
		}

		addr = mf.GetAddress("report\0", 8);
		if (addr)
		{
			VirtualProtect((void*)addr, 12, PAGE_READWRITE, &oldProt);
			_snprintf((char*)addr, 8, "r%d", UOProcId);
			VirtualProtect((void*)addr, 12, oldProt, &oldProt);
		}

		// Splash screen crap:
		for (int i = 0; i < 16; i++)
		{
			addr = mf.GetAddress("\x68\x88\x13\x00\x00", 5, i);
			if (!addr)
				break;
			for (int e = 5; e < 24; e++)
			{
				if (*((BYTE*)(addr + e)) == 0x8B && *((BYTE*)(addr + e + 1)) == 0x3D)
				{
					MemoryPatch(addr + 1, 0x00000001); // change 5000ms to 1ms
					i = 99;
					break;
				}
			}
		}
		addr = mf.GetAddress("intro.bik", 10);
		if (addr)
			MemoryPatch(addr, "intro.SUX", 10);
		addr = mf.GetAddress("ostlogo.bik", 12);
		if (addr)
			MemoryPatch(addr, "osilogo.SUX", 12);

		addr = mf.GetAddress("Electronic Arts Inc.", 20);
		if (addr)
		{
			addr -= 7;
			VirtualProtect((void*)addr, 52, PAGE_EXECUTE_READWRITE, &oldProt);
			strncpy((char*)addr, "[Powered by Razor - The cutting edge UO Assistant]\0", 52);
			VirtualProtect((void*)addr, 52, oldProt, &oldProt);
		}

		NativeGetUOVersion = NULL;
		if (ClientType == TWOD)
		{
			addr = mf.GetAddress("UO Version %s", 12);
			if (addr)
			{
				char temp[8];
				temp[0] = 0x68;
				*((DWORD*)&temp[1]) = addr;

				addr = MemFinder::Find(temp, 5);

				if (addr)
				{
					count = 0;
					while (*((BYTE*)addr) != 0xE8 && count < 128)
					{
						addr--;
						count++;
					}

					if (*((BYTE*)addr) == 0xE8)
						NativeGetUOVersion = (GetUOVersionFunc)((addr + 5) + *((DWORD*)(addr + 1)));
				}
			}
		}
}

DLLFUNCTION void SetServer( unsigned int addr, unsigned short port )
{
	if (pShared)
	{
		pShared->ServerIP = addr;
		pShared->ServerPort = port;
	}
}

DLLFUNCTION const char *GetUOVersion()
{
	if ( pShared )
		return pShared->UOVersion;
	else
		return "";
}

bool CreateSharedMemory()
{
	if (pShared)
		return true;

	char name[256];

	CommMutex = NULL;
	hFileMap = NULL;
	pShared = NULL;

	Log( "Creating shared mem, proc: %x", UOProcId );

	sprintf( name, "UONetSharedCOMM_%x", UOProcId );

	CommMutex = CreateMutex( NULL, FALSE, name );
	if ( !CommMutex )
		return false;

	for (int i = 0; i < 30; i++) {
		sprintf(name, "UONetSharedFM_%x%d", UOProcId, i);
		hFileMap = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, sizeof(SharedMemory), name);
		if (!hFileMap || hFileMap == INVALID_HANDLE_VALUE) {
			auto err = GetLastError();
			continue;
		}

		pShared = (SharedMemory*)MapViewOfFile(hFileMap, FILE_MAP_ALL_ACCESS, 0, 0, sizeof(SharedMemory));
		if (!pShared) {
			auto err = GetLastError();
			continue;
		}

		break;
	}

	if (!pShared) {
		return false;
	}

	//memset( pShared, 0, sizeof(SharedMemory) );

	return true;
}

void CloseSharedMemory()
{
	Log( "Close shared memory" );

	if ( hWndProcRetHook )
		UnhookWindowsHookEx( hWndProcRetHook );
	if ( hGetMsgHook )
		UnhookWindowsHookEx( hGetMsgHook );

	if ( CommMutex )
		CloseHandle( CommMutex );
	CommMutex = NULL;
	if ( pShared )
		UnmapViewOfFile( pShared );
	pShared = NULL;
	if ( hFileMap )
		CloseHandle( hFileMap );
	hFileMap = NULL;

	//these are shared vars
	hWndProcRetHook = NULL;
	hGetMsgHook = NULL;

	FreeArt();

	delete ClientCrypt;
	delete ClientLogin;
	delete ServerCrypt;
	delete ServerLogin;

	ClientCrypt = NULL;
	ClientLogin = NULL;
	ServerCrypt = NULL;
	ServerLogin = NULL;
}

void CreateEncryption()
{
	delete ClientCrypt;
	delete ClientLogin;
	delete ServerCrypt;
	delete ServerLogin;

	if ( ClientEncrypted )
	{
		ClientCrypt = new OSIEncryption();
		ClientLogin = new LoginEncryption();
	}

	if ( ServerEncrypted )
	{
		ServerCrypt = new OSIEncryption();
		ServerLogin = new LoginEncryption();
	}
}

inline void Maintenance( Buffer &buff )
{
	if ( buff.Length <= 0 )
	{
		buff.Start = 0;
		buff.Length = 0;
	}
	else if ( buff.Start > SHARED_BUFF_SIZE / 2 )
	{
		//shift all the data to the begining of the buffer
		memmove( buff.Buff, &buff.Buff[buff.Start], buff.Length );
		buff.Start = 0;
	}
}

int RecvData()
{
	int len = SHARED_BUFF_SIZE;
	char buff[SHARED_BUFF_SIZE];

	int ackLen = (*(NetIOFunc)OldRecv)(CurrentConnection,buff,len,0);

	if ( ackLen == SOCKET_ERROR )
	{
		if ( WSAGetLastError() != WSAEWOULDBLOCK )
		{
			WaitForSingleObject( CommMutex, INFINITE );
			pShared->ForceDisconn = true;
			ReleaseMutex( CommMutex );
		}
		else
		{
			WSASetLastError( WSAEWOULDBLOCK );
		}

		ackLen = -1;
	}
	else if ( ackLen > 0 )
	{
		if ( FirstRecv )
		{
			Compression::Reset();
			FirstRecv = false;
		}

		WaitForSingleObject( CommMutex, INFINITE );

		pShared->TotalRecv += ackLen;

		if ( LoginServer )
		{
			memcpy( &pShared->InRecv.Buff[pShared->InRecv.Start+pShared->InRecv.Length], buff, ackLen );
			pShared->InRecv.Length += ackLen;
		}
		else
		{
			if ( ServerEncrypted )
				ServerCrypt->DecryptFromServer( (BYTE*)buff, (BYTE*)buff, ackLen );

			int blen = Compression::Decompress( (char*)&pShared->InRecv.Buff[pShared->InRecv.Start+pShared->InRecv.Length], buff, ackLen );
			pShared->InRecv.Length += blen;

			if ( !ServerNegotiated && !InGame && pShared && pShared->AllowNegotiate )
			{
				int pos = pShared->InRecv.Start;
				unsigned char *p_buff = &pShared->InRecv.Buff[pos];

				while ( pos < pShared->InRecv.Length )
				{
					int left = pShared->InRecv.Length - pos;
					int p_len = GetPacketLength( p_buff, left );

					if ( *p_buff == 0xA9 && p_len >= 1+2+1+30+30 && p_len <= left )
					{
						// character list

						unsigned char hash[16], test[16];

						memcpy( pShared->AuthBits, p_buff + 1+2+1+30+1, 8 );

						if ( p_buff[3] > 1 )
							memcpy( hash, p_buff + 1+2+1+30+30+30+1, 16 );
						else
							memcpy( hash, p_buff + 1+2+1+30+1+8, 16 );

						for ( int i = 0; i < p_buff[3]; i++ )
							memset( p_buff + 1+2+1+ 30 + 60*i, 0, 30 );

						if ( memcmp( hash, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", 16 ) != 0 )
						{
							OSIEncryption::MD5( p_buff, p_len, test );

							ServerNegotiated = memcmp( hash, test, 16 ) == 0;
						}

						if ( !ServerNegotiated )
							memset( pShared->AuthBits, 0, 8 );

						Forwarding = Forwarded = false;

						break;
					}

					if ( p_len <= 0 )
					{
						break;
					}
					else
					{
						pos += p_len;
						p_buff += p_len;
					}
				}
			}
		}

		ReleaseMutex( CommMutex );

		SendMessage( hRazorWnd, WM_UONETEVENT, RECV, 0 );
	}

	return ackLen;
}

int HookRecv( SOCKET sock, char *buff, int len, int flags )
{
	int ackLen;

	if ( sock == CurrentConnection && CurrentConnection )
	{
		WaitForSingleObject( CommMutex, INFINITE );
		if ( pShared->ForceDisconn && pShared->OutRecv.Length <= 0 )
		{
			ReleaseMutex( CommMutex );
			WSASetLastError( WSAECONNRESET );
			return -1;
		}

		if ( LoginServer )
		{
			if ( pShared->OutRecv.Length > 0 )
			{
				ackLen = pShared->OutRecv.Length;
				memcpy( buff, &pShared->OutRecv.Buff[pShared->OutRecv.Start], ackLen );

				if ( ((BYTE)buff[0]) == 0x8C )
					LoginServer = false;

				if ( Forwarding )
					Seeded = Forwarded = true;

				pShared->OutRecv.Start += ackLen;
				pShared->OutRecv.Length -= ackLen;
			}
			else
			{
				ackLen = 0;
			}
		}
		else
		{
			ackLen = 0;
			while ( pShared->OutRecv.Length > 0 )
			{
				int blen = GetPacketLength( &pShared->OutRecv.Buff[pShared->OutRecv.Start], pShared->OutRecv.Length );

				if ( blen <= 0 || blen > pShared->OutRecv.Length || ackLen+blen > len )
					break;

				ackLen += Compression::Compress( &buff[ackLen], (char*)&pShared->OutRecv.Buff[pShared->OutRecv.Start], blen );

				pShared->OutRecv.Start += blen;
				pShared->OutRecv.Length -= blen;
			}

			if ( ClientEncrypted && ackLen > 0 )
				ClientCrypt->EncryptForClient( (BYTE*)buff, (BYTE*)buff, ackLen );
		}

		Maintenance( pShared->InRecv );
		Maintenance( pShared->OutRecv );

		ReleaseMutex( CommMutex );

		if ( ackLen == 0 )
		{
			WSASetLastError( WSAEWOULDBLOCK );
			return -1;
		}
		else
		{
			return ackLen;
		}
	}
	else
	{
		return (*(NetIOFunc)OldRecv)(sock,buff,len,flags);
	}
}

int SkipSendData = 0;
int HookSend( SOCKET sock, char *buff, int len, int flags )
{
	int ackLen;

	if ( sock == CurrentConnection && CurrentConnection )
	{
		if ( !Seeded )
		{
			if ( len > 0 && ((BYTE)*buff) == ((BYTE)0xEF) )
				SkipSendData = 16;

			if ( len >= 4 )
			{
				Seeded = true;

				CryptSeed = *((DWORD*)buff);

				if ( ServerEncrypted )
				{
					ServerCrypt->Initialize( CryptSeed );
					ServerLogin->Initialize( (BYTE*)&CryptSeed );
				}

				if ( ClientEncrypted )
				{
					ClientCrypt->Initialize( CryptSeed );
					ClientLogin->Initialize( (BYTE*)&CryptSeed );
				}

				Compression::Reset();
			}

			ackLen = (*(NetIOFunc)OldSend)(sock,buff,len,flags);
			pShared->TotalSend += len;
		}
		else if ( SkipSendData < len )
		{
			SkipSendData = 0;

			if ( FirstSend )
			{
				FirstSend = false;

				if ( ClientEncrypted )
					LoginServer = ClientLogin->TestForLogin( (BYTE)buff[0] );
				else
					LoginServer = LoginEncryption::IsLoginByte( (BYTE)buff[0] );

				if ( LoginServer )
					Forwarding = Forwarded = false;
			}

			WaitForSingleObject( CommMutex, INFINITE );

			if (ClientEncrypted)
			{
				if ( Forwarded )
				{
					CryptSeed = LoginEncryption::GenerateBadSeed( CryptSeed );

					ClientCrypt->Initialize( CryptSeed );

					ClientCrypt->DecryptFromClient( (BYTE*)buff, (BYTE*)(&pShared->InSend.Buff[pShared->InSend.Start+pShared->InSend.Length]), len );
					ClientLogin->Decrypt( (BYTE*)(&pShared->InSend.Buff[pShared->InSend.Start+pShared->InSend.Length]), (BYTE*)(&pShared->InSend.Buff[pShared->InSend.Start+pShared->InSend.Length]), len );

					LoginServer = Forwarding = Forwarded = false;
				}
				else
				{
					if ( LoginServer )
					{
						ClientLogin->Decrypt( (BYTE*)(buff), (BYTE*)(&pShared->InSend.Buff[pShared->InSend.Start+pShared->InSend.Length]), len );

						if ( ((BYTE)pShared->InSend.Buff[pShared->InSend.Start+pShared->InSend.Length]) == 0xA0 )
							Forwarding = true;
					}
					else
					{
						ClientCrypt->DecryptFromClient((BYTE*)(buff), (BYTE*)(&pShared->InSend.Buff[pShared->InSend.Start + pShared->InSend.Length]), len);
					}
				}
			}
			else
				memcpy( &pShared->InSend.Buff[pShared->InSend.Start+pShared->InSend.Length], buff, len );

			pShared->InSend.Length += len;
			ReleaseMutex( CommMutex );

			SendMessage( hRazorWnd, WM_UONETEVENT, SEND, 0 );

			WaitForSingleObject( CommMutex, INFINITE );
			FlushSendData();
			Maintenance( pShared->InSend );
			ReleaseMutex( CommMutex );

			ackLen = len;//lie and say we sent it all -- or should we tell the truth? (probably not since then it could try to send it again..)
		}
		else
		{
			ackLen = (*(NetIOFunc)OldSend)(sock,buff,len,flags);
			pShared->TotalSend += len;
			SkipSendData -= len;
		}
	}
	else
	{
		ackLen = (*(NetIOFunc)OldSend)(sock,buff,len,flags);
	}

	return ackLen;
}

#define RAZOR_ID_KEY "\x9\x11\x83+\x4\x17\x83\x5\x24\x85\x7\x17\x87\x6\x19\x88"
#define RAZOR_ID_KEY_LEN 16

void FlushSendData()
{
	WaitForSingleObject( CommMutex, INFINITE );
	if ( pShared->OutSend.Length > 0 && CurrentConnection )
	{
		int ackLen = 0;
		int outLen = pShared->OutSend.Length;

		if ( !InGame && !LoginServer )
		{
			int pos = pShared->OutSend.Start;
			unsigned char *buff = &pShared->OutSend.Buff[pos];

			while ( pos < outLen )
			{
				int left = pShared->OutSend.Length - pos;
				int len = GetPacketLength( buff, left );

				if ( *buff == 0x5D && len >= 1+4+30+30 && len <= left )
				{
					// play character
					if ( pShared->AllowNegotiate && ServerNegotiated )
					{
						// the first 2 bytes are 0
						// the next 4 bytes are "flags" which say the user's client type (lbr,t2a,aos,etc)
						// the rest are ignored, so we can use them for auth
						memcpy( buff + 1 + 4 + 30 + 2 + 4, pShared->AuthBits, 8 );
						memcpy( buff + 1 + 4 + 30 + 2 + 4 + 8, RAZOR_ID_KEY, RAZOR_ID_KEY_LEN );
					}

					InGame = true;
					break;
				}
				else if ( *buff == 0x00 && (*((DWORD*)&buff[1])) == 0xEDEDEDED && len >= 1+4+4+1+30+30 && len <= left )
				{
					// char creation
					if ( pShared->AllowNegotiate && ServerNegotiated )
					{
						memcpy( buff + 1 + 4 + 4 + 1 + 30 + 15, pShared->AuthBits, 8 );
						memcpy( buff + 1 + 4 + 4 + 1 + 30 + 15 + 8, RAZOR_ID_KEY, min( 7, RAZOR_ID_KEY_LEN ) );
					}

					InGame = true;
					break;
				}

				if ( len <= 0 )
				{
					break;
				}
				else
				{
					pos += len;
					buff += len;
				}
			} // END while
		} // END if ( !InGame && !LoginServer

		if ( ServerEncrypted )
		{
			if ( tempBuff == NULL )
				tempBuff = new char[SHARED_BUFF_SIZE];

			if ( LoginServer )
				ServerLogin->Encrypt( (BYTE*)&pShared->OutSend.Buff[pShared->OutSend.Start], (BYTE*)tempBuff, outLen );
			else
				ServerCrypt->EncryptForServer( (BYTE*)&pShared->OutSend.Buff[pShared->OutSend.Start], (BYTE*)tempBuff, outLen );

			ackLen = (*(NetIOFunc)OldSend)(CurrentConnection,tempBuff,outLen,0);
		}
		else
		{
			ackLen = (*(NetIOFunc)OldSend)(CurrentConnection,(char*)&pShared->OutSend.Buff[pShared->OutSend.Start],outLen,0);
		}

		if ( ackLen == SOCKET_ERROR )
		{
			if ( WSAGetLastError() != WSAEWOULDBLOCK )
				pShared->ForceDisconn = true;
		}
		else //if ( ackLen >= 0 )
		{
			pShared->TotalSend += ackLen;

			pShared->OutSend.Start += ackLen;
			pShared->OutSend.Length -= ackLen;
		}
	}

	Maintenance( pShared->OutSend );
	ReleaseMutex( CommMutex );
}

int HookConnect( SOCKET sock, const sockaddr *addr, int addrlen )
{
	int retVal;

	if ( addr && addrlen >= sizeof(sockaddr_in) )
	{
		const sockaddr_in *old_addr = (const sockaddr_in *)addr;
		sockaddr_in useAddr;

		memcpy( &useAddr, old_addr, sizeof(sockaddr_in) );

		if ( !Forwarded && pShared->ServerIP != 0 )
		{
			useAddr.sin_addr.S_un.S_addr = pShared->ServerIP;
			useAddr.sin_port = htons( pShared->ServerPort );
		}

		retVal = (*(ConnFunc)OldConnect)( sock, (sockaddr*)&useAddr, sizeof(sockaddr_in) );

		if ( retVal != SOCKET_ERROR )
		{
			Log( "Connecting to %i", sock );

			CreateEncryption();

			Seeded = false;
			LoginServer = false;
			FirstRecv = true;
			FirstSend = true;
			Forwarding = Forwarded = false;

			WaitForSingleObject( CommMutex, INFINITE );
			CurrentConnection = sock;
			pShared->OutRecv.Length = pShared->InRecv.Length = pShared->OutSend.Length = pShared->InSend.Length = 0;
			pShared->ForceDisconn = false;
			ReleaseMutex( CommMutex );

			PostMessage( hRazorWnd, WM_UONETEVENT, CONNECT, useAddr.sin_addr.S_un.S_addr );
		}
	}
	else
	{
		retVal = (*(ConnFunc)OldConnect)( sock, addr, addrlen );
	}

	return retVal;
}

int HookCloseSocket( SOCKET sock )
{
	int retVal = (*(CLSFunc)OldCloseSocket)( sock );

	if ( sock == CurrentConnection && sock != 0 )
	{
		Log( "Closing socket %i", sock );
		CurrentConnection = 0;

		WaitForSingleObject( CommMutex, INFINITE );
		pShared->OutRecv.Length = pShared->InRecv.Length = pShared->OutSend.Length = pShared->InSend.Length = 0;
		pShared->TotalSend = pShared->TotalRecv = 0;
		pShared->ForceDisconn = false;
		ReleaseMutex( CommMutex );

		ServerNegotiated = false;
		InGame = false;

		memset( pShared->AuthBits, 0, 8 );

		PostMessage( hRazorWnd, WM_UONETEVENT, DISCONNECT, 0 );
	}

	return retVal;
}

int HookSelect( int ndfs, fd_set *readfd, fd_set *writefd, fd_set *exceptfd, const struct timeval *timeout )
{
	bool checkRecv = false;
	bool checkErr = false;
	bool modified = false;
	int realRet = 0;
	int myRet = 0;

	if ( CurrentConnection )
	{
		if ( readfd != NULL )
			checkRecv = FD_ISSET( CurrentConnection, readfd );

		if ( exceptfd != NULL )
			checkErr = FD_ISSET( CurrentConnection, exceptfd );
	}

	timeval myTimeout;

	if ( SmartCPU )
	{
		int length = 0;

		if ( Active )
		{
			LARGE_INTEGER end;
			QueryPerformanceCounter( &end );

			length = int( 1000000.0 * ((end.QuadPart-Counter.QuadPart)/double(PerfFreq.QuadPart)) );
		}

		if ( length < 33333 )
		{
			myTimeout.tv_sec = 0;
			myTimeout.tv_usec = 33333 - length;
			timeout = &myTimeout;
		}
	}

	realRet = (*(SelectFunc)OldSelect)( ndfs, readfd, writefd, exceptfd, timeout );

	if ( SmartCPU )
		QueryPerformanceCounter( &Counter );

	if ( checkRecv )
	{
		if ( FD_ISSET( CurrentConnection, readfd ) )
		{
			FD_CLR( CurrentConnection, readfd );
			RecvData();
			realRet--;
		}

		WaitForSingleObject( CommMutex, INFINITE );
		if ( pShared->OutRecv.Length > 0 || ( pShared->ForceDisconn ) )
		{
			FD_SET( CurrentConnection, readfd );
			myRet++;
		}
		ReleaseMutex( CommMutex );
	}

	if ( checkErr && !FD_ISSET( CurrentConnection, exceptfd ) )
	{
		WaitForSingleObject( CommMutex, INFINITE );
		if ( pShared->ForceDisconn && pShared->OutRecv.Length <= 0 )
		{
			FD_SET( CurrentConnection, exceptfd );
			myRet++;
		}
		ReleaseMutex( CommMutex );
	}

	if ( realRet < 0 )
	{
		return myRet;
	}
	else
	{
		return realRet + myRet;
	}
}

bool HookFunction( const char *Dll, const char *FuncName, int Ordinal, unsigned long NewAddr,
				  unsigned long *OldAddr, unsigned long *PatchAddr )
{
	DWORD baseAddr = (DWORD)GetModuleHandle(NULL);
	if ( !baseAddr )
		return false;

	IMAGE_DOS_HEADER *idh = (IMAGE_DOS_HEADER *)baseAddr;

	IMAGE_FILE_HEADER *ifh = (IMAGE_FILE_HEADER *)(baseAddr + idh->e_lfanew + sizeof(DWORD));

	IMAGE_OPTIONAL_HEADER *ioh = (IMAGE_OPTIONAL_HEADER *)((DWORD)(ifh) + sizeof(IMAGE_FILE_HEADER));

	IMAGE_IMPORT_DESCRIPTOR *iid = (IMAGE_IMPORT_DESCRIPTOR *)(baseAddr + ioh->DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);

	while( iid->Name )
	{
		if( _stricmp( Dll, (char *)(baseAddr + iid->Name) ) == 0 )
		{
			IMAGE_THUNK_DATA * pThunk = (IMAGE_THUNK_DATA *)((DWORD)iid->OriginalFirstThunk + baseAddr);
			IMAGE_THUNK_DATA * pThunk2 = (IMAGE_THUNK_DATA *)((DWORD)iid->FirstThunk + baseAddr);

			while( pThunk->u1.AddressOfData )
			{
				char *name = NULL;
				int ord;

				if( pThunk->u1.Ordinal & 0x80000000 )
				{
					// Imported by ordinal only:
					ord = pThunk->u1.Ordinal & 0xFFFF;
				}
				else
				{
					// Imported by name (with ordinal hint)
					IMAGE_IMPORT_BY_NAME * pName = (IMAGE_IMPORT_BY_NAME *)((DWORD)pThunk->u1.AddressOfData + baseAddr);
					ord = pName->Hint;
					name = (char *)pName->Name;
				}

				if ( ord == Ordinal || ( name && FuncName && !strcmp( name, FuncName ) ) )
				{
					*OldAddr = (unsigned long)pThunk2->u1.Function;
					*PatchAddr = (unsigned long)(&pThunk2->u1.Function);
					MemoryPatch( *PatchAddr, NewAddr );

					return true;
				}

				pThunk++;
				pThunk2++;
			}
		}
		iid++;
	}

	return false;
}


bool FindFunction( const char *Dll, const char *FuncName, int Ordinal, unsigned long *ImpAddr, unsigned long *CallAddr )
{
	DWORD baseAddr = (DWORD)GetModuleHandle(NULL);
	if ( !baseAddr )
		return false;

	IMAGE_DOS_HEADER *idh = (IMAGE_DOS_HEADER *)baseAddr;

	IMAGE_FILE_HEADER *ifh = (IMAGE_FILE_HEADER *)(baseAddr + idh->e_lfanew + sizeof(DWORD));

	IMAGE_OPTIONAL_HEADER *ioh = (IMAGE_OPTIONAL_HEADER *)((DWORD)(ifh) + sizeof(IMAGE_FILE_HEADER));

	IMAGE_IMPORT_DESCRIPTOR *iid = (IMAGE_IMPORT_DESCRIPTOR *)(baseAddr + ioh->DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);

	while( iid->Name )
	{
		if( _stricmp( Dll, (char *)(baseAddr + iid->Name) ) == 0 )
		{
			IMAGE_THUNK_DATA * pThunk = (IMAGE_THUNK_DATA *)((DWORD)iid->OriginalFirstThunk + baseAddr);
			IMAGE_THUNK_DATA * pThunk2 = (IMAGE_THUNK_DATA *)((DWORD)iid->FirstThunk + baseAddr);

			while( pThunk->u1.AddressOfData )
			{
				char *name = NULL;
				int ord;

				if( pThunk->u1.Ordinal & 0x80000000 )
				{
					// Imported by ordinal only:
					ord = pThunk->u1.Ordinal & 0xFFFF;
				}
				else
				{
					// Imported by name (with ordinal hint)
					IMAGE_IMPORT_BY_NAME * pName = (IMAGE_IMPORT_BY_NAME *)((DWORD)pThunk->u1.AddressOfData + baseAddr);
					ord = pName->Hint;
					name = (char *)pName->Name;
				}

				if ( ord == Ordinal || ( name && FuncName && !strcmp( name, FuncName ) ) )
				{
					*ImpAddr = (unsigned long)pThunk2->u1.Function;
					*CallAddr = (unsigned long)(&pThunk2->u1.Function);

					return true;
				}

				pThunk++;
				pThunk2++;
			}
		}
		iid++;
	}

	return false;
}

#define NOTO_HUE_STR "\0\0\0\0\x59\0\0\0\x3F\0\0\0\xb2\x03\0\0"
#define NOTO_HUE_LEN 16

DWORD NotoLoc = 0;
void SetCustomNotoHue( int hue )
{
	if ( !NotoLoc )
	{
		NotoLoc = MemFinder::Find( NOTO_HUE_STR, NOTO_HUE_LEN );
		if ( !NotoLoc )
			NotoLoc = 0xFFFFFFFF;
	}

	if ( NotoLoc != 0xFFFFFFFF )
		*((int*)(NotoLoc + 8*4)) = hue;
}

bool PatchMemory( void )
{
	Log( "Patching client functions." );

	return
		HookFunction( "wsock32.dll", "closesocket", 3, (unsigned long)HookCloseSocket, &OldCloseSocket, &CloseSocketAddress ) &&
		HookFunction( "wsock32.dll", "connect", 4, (unsigned long)HookConnect, &OldConnect, &ConnectAddress ) &&
		HookFunction( "wsock32.dll", "recv", 16, (unsigned long)HookRecv, &OldRecv, &RecvAddress ) &&
		HookFunction( "wsock32.dll", "select", 18, (unsigned long)HookSelect, &OldSelect, &SelectAddress ) &&
		HookFunction( "wsock32.dll", "send", 19, (unsigned long)HookSend, &OldSend, &SendAddress )
		;
}

void MemoryPatch( unsigned long Address, unsigned long value )
{
	MemoryPatch( Address, &value, 4 ); // sizeof(int)
}

void MemoryPatch( unsigned long Address, int value, int numBytes )
{
	MemoryPatch( Address, &value, numBytes );
}

void MemoryPatch( unsigned long Address, const void *value, int length )
{
	DWORD OldProtect;
	if ( !VirtualProtect( (void *)Address, length, PAGE_READWRITE, &OldProtect ) )
		return;

	memcpy( (void *)Address, value, length );

	VirtualProtect( (void *)Address, length, OldProtect, &OldProtect );
}

bool CheckParent( HWND hCheck, HWND hComp )
{
	hCheck = GetParent( hCheck );
	while ( hCheck != hComp && hCheck != NULL )
		hCheck = GetParent( hCheck );

	return ( hCheck == hComp );
}

void MessageProc( HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam, MSG *pMsg )
{
	HWND hFore;

	switch ( nMsg )
	{
		// Custom messages
	case WM_PROCREADY:
		hRazorWnd = (HWND)lParam;
		UOProcId = GetCurrentProcessId();
		hUOWindow = hWnd;

		if (!pShared) // If this failed the first time or was not run at all, try it once more before panicing
			OnAttach(NULL, 0);

		ClientEncrypted = (wParam & 0x08) != 0;
		ServerEncrypted = (wParam & 0x10) != 0;

		InitThemes();

		if (pShared)
		{
			pShared->AllowNegotiate = (wParam & 0x04) != 0;

			pShared->UOVersion[0] = 0;

			if (NativeGetUOVersion != NULL)
				strncpy(pShared->UOVersion, NativeGetUOVersion(), 16);
		}

		if ( !pShared )
			PostMessage( hRazorWnd, WM_UONETEVENT, NOT_READY, NO_SHAREMEM );
		else if ( CopyFailed )
			PostMessage( hRazorWnd, WM_UONETEVENT, NOT_READY, NO_COPY );
		else if ( !PatchMemory() )
			PostMessage( hRazorWnd, WM_UONETEVENT, NOT_READY, NO_PATCH );
		else
			PostMessage( hRazorWnd, WM_UONETEVENT, READY, SUCCESS );

		/* Start a timer that will call a callback each tick. We use this to implement
		 * timers as well as scan client memory for position updates. */
		SetTimer(hUOWindow, (UINT_PTR)0xAA, 25, OnTick);

		break;

	case WM_UONETEVENT:
		switch ( LOWORD(wParam) )
		{
		case SEND:
			FlushSendData();
			break;
		case STAT_BAR:
			PatchStatusBar( (BOOL)lParam );
			break;
		case NOTO_HUE:
			SetCustomNotoHue( (int)lParam );
			break;

		case SETWNDSIZE:
			DesiredSize.cx = LOWORD(lParam);
			DesiredSize.cy = HIWORD(lParam);
			break;

		case SMART_CPU:
			SmartCPU = lParam;
			break;

		case NEGOTIATE:
			if ( pShared )
				pShared->AllowNegotiate = (lParam != 0);
			break;

		case SET_MAP_HWND:
			hMapWnd = (HWND)lParam;
			break;
		}
		break;

	case WM_COPYDATA: {
		COPYDATASTRUCT *copydata = (COPYDATASTRUCT *)lParam;

		switch ((UONET_MESSAGE_COPYDATA)copydata->dwData) {
		case UONET_MESSAGE_COPYDATA::POSITION:
			g_TestPosition = *(Position *)copydata->lpData;
			break;

		}
		break;
	}

		// Macro stuff
	case WM_SYSKEYDOWN:
	case WM_KEYDOWN:
		if ( pMsg && !SendMessage( hRazorWnd, WM_UONETEVENT, KEYDOWN, wParam ) )
		{
			// dont give the key to the client
			pMsg->message = WM_NULL;
			pMsg->lParam = 0;
			pMsg->wParam = 0;
		}
		break;

	case WM_SYSKEYUP:
	case WM_KEYUP:
		if ( pMsg && wParam == VK_SNAPSHOT ) // VK_SNAPSHOT (Print Screen) Doesn't seem to send a KeyDown message
			SendMessage( hRazorWnd, WM_UONETEVENT, KEYDOWN, wParam );
		break;

	case WM_MOUSEWHEEL:
		PostMessage( hRazorWnd, WM_UONETEVENT, MOUSE, MAKELONG( 0, (((short)HIWORD(wParam)) < 0 ? -1 : 1) ) );
		break;
	case WM_MBUTTONDOWN:
		PostMessage( hRazorWnd, WM_UONETEVENT, MOUSE, MAKELONG( 1, 0 ) );
		break;
	case WM_XBUTTONDOWN:
		PostMessage( hRazorWnd, WM_UONETEVENT, MOUSE, MAKELONG( HIWORD(wParam) + 1, 0 ) );
		break;

		//Activation tracking :
	case WM_ACTIVATE:
		Active = wParam;
		PostMessage( hRazorWnd, WM_UONETEVENT, ACTIVATE, wParam );
		break;
	case WM_KILLFOCUS:
		hFore = GetForegroundWindow();
		if ( ((HWND)wParam) != hRazorWnd && hFore != hRazorWnd && ((HWND)wParam) != hMapWnd && hFore != hMapWnd
			&& !CheckParent( hFore, hRazorWnd ) )
		{
			PostMessage( hRazorWnd, WM_UONETEVENT, FOCUS, FALSE );
		}
		break;
	case WM_SETFOCUS:
		PostMessage( hRazorWnd, WM_UONETEVENT, FOCUS, TRUE );
		break;

		//Custom title bar:
	case WM_NCACTIVATE:
		Active = wParam;
		//fallthrough
	case WM_NCPAINT:
	case WM_GETICON:
	case WM_SETTEXT:
	case WM_CUSTOMTITLE:
		CheckTitlebarAttr(hWnd);
		RedrawTitleBar( hWnd, Active );
		break;
	}
}

LRESULT CALLBACK GetMsgHookFunc( int Code, WPARAM Flag, LPARAM pMsg )
{
	if ( Code >= 0 && Flag != PM_NOREMOVE ) //dont process messages until they are removed from the queue
	{
		MSG *Msg = (MSG*)pMsg;
		/*
		Msg->message ^= 0x11;
		Msg->message ^= Disabled * 101;
		Msg->message *= !(Disabled * 020);
		Msg->message ^= 0x11;
		*/
		if ( Msg->hwnd == hUOWindow || ( hUOWindow == NULL && Msg->message == WM_PROCREADY ) )
			MessageProc( Msg->hwnd, Msg->message, Msg->wParam, Msg->lParam, Msg );
	}

	return CallNextHookEx( NULL, Code, Flag, pMsg );
}

LRESULT CALLBACK WndProcRetHookFunc( int Code, WPARAM Flag, LPARAM pMsg )
{
	if ( Code >= 0 )
	{
		CWPRETSTRUCT *Msg = (CWPRETSTRUCT *)(pMsg);
		/*
		Msg->message ^= 0x11;
		Msg->message ^= Disabled * 101;
		Msg->message *= !(Disabled * 020);
		Msg->message ^= 0x11;
		*/
		if ( Msg->hwnd == hUOWindow || ( hUOWindow == NULL && Msg->message == WM_PROCREADY ) )
			MessageProc( Msg->hwnd, Msg->message, Msg->wParam, Msg->lParam, NULL );
	}

	return CallNextHookEx( NULL, Code, Flag, pMsg );
}

LRESULT CALLBACK UOAWndProc(HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam)
{
	if (nMsg >= WM_USER + 200 && nMsg < WM_USER + 315)
	   return SendMessage(hRazorWnd, nMsg, wParam, lParam);
	else
	   return DefWindowProc(hWnd, nMsg, wParam, lParam);
}

void Log( const char *format, ... )
{
#ifdef _DEBUG
#ifdef LOGGING
	FILE *log = fopen( "Crypt.log", "a" );
	if ( log )
	{
		char timeStr[256];
		struct tm *newtime;
		time_t aclock;

		time( &aclock );
		newtime = localtime( &aclock );
		strncpy( timeStr, asctime( newtime ), 256 );
		int len = (int)strlen( timeStr );
		if ( timeStr[len-1] == '\n' )
			timeStr[len-1] = 0;

		char OutTxt[512];
		va_list argList;
		va_start( argList, format );
		_vsnprintf( OutTxt, 512, format, argList );
		va_end( argList );

		fprintf( log, "%s: %s\n", timeStr, OutTxt );
		fclose( log );
	}
#endif
#endif
}



================================================
FILE: Crypt/Crypt.def
================================================
LIBRARY	Crypt

EXPORTS
	InstallLibrary
	Shutdown
	FindUOWindow
	GetSharedAddress
	GetPacketLength
	IsDynLength
	GetUOProcId
	GetCommMutex
	TotalIn
	TotalOut
	WaitForWindow
	SetDataPath
	CalibratePosition
	OnAttach
	SetServer
	GetUOVersion


================================================
FILE: Crypt/Crypt.h
================================================
#pragma once
#pragma pack(1)

#include <stdint.h>

#define DLL_VERSION "1.4.1"

#define DLLFUNCTION __declspec(dllexport)
#define DLLVAR DLLFUNCTION

#ifdef _DEBUG
//#define LOGGING
#endif

enum IError
{
	SUCCESS,
	NO_UOWND,
	NO_TID,
	NO_HOOK,
	NO_SHAREMEM,
	LIB_DISABLED,
	NO_PATCH,
	NO_COPY,
	INVALID_PARAMS,

	UNKNOWN,
};

enum UONET_MESSAGE
{
	SEND = 1,
	RECV = 2,
	READY = 3,
	NOT_READY = 4,
	CONNECT = 5,
	DISCONNECT = 6,
	KEYDOWN = 7,
	MOUSE = 8,

	ACTIVATE = 9,
	FOCUS = 10,

	CLOSE = 11,
	STAT_BAR = 12,
	NOTO_HUE = 13,
	DLL_ERROR = 14,

	SETWNDSIZE = 19,

	SMART_CPU = 21,
	NEGOTIATE = 22,
	SET_MAP_HWND = 23,

	ON_TICK = 24,
};

enum class UONET_MESSAGE_COPYDATA
{
	POSITION = 1,
};

//#define SHARED_BUFF_SIZE 0x80000 // Client's buffers are 500k
#define SHARED_BUFF_SIZE 524288 // 262144 // 250k
struct Buffer
{
	int Length;
	int Start;
	BYTE Buff[SHARED_BUFF_SIZE];
};

#pragma pack(1)
struct Position {
	uint16_t x;
	uint16_t y;
	uint16_t z;
};
static_assert(sizeof(struct Position) == 6, "Incorrect size\n");

struct SharedMemory
{
	// Do *not* mess with this struct.  Really.  I mean it.
	Buffer InRecv;
	Buffer OutRecv;
	Buffer InSend;
	Buffer OutSend;

	char TitleBar[1024];
	bool ForceDisconn;
	unsigned int TotalSend;
	unsigned int TotalRecv;
	unsigned short PacketTable[256];
	char DataPath[256];
	bool AllowNegotiate;
	unsigned char AuthBits[16];
	bool Reserved0;
	unsigned int ServerIP;
	unsigned short ServerPort;
	char UOVersion[16];
};

class PatchInfo
{
public:
	PatchInfo( DWORD addr, int len )
	{
		Address = addr;
		Length = len;
		Data = new char[Length];
		memcpy( Data, (const void*)Address, Length );
	}

	~PatchInfo()
	{
		delete[] Data;
	}

	DWORD Address;
	int Length;
	char *Data;
};

#define WM_PROCREADY WM_USER
#define WM_UONETEVENT WM_USER+1
#define WM_CUSTOMTITLE WM_USER+2

#ifndef WM_XBUTTONDOWN
#define WM_XBUTTONDOWN                  0x020B
#endif

extern HWND hUOWindow;
extern HINSTANCE hInstance;
extern SharedMemory *pShared;
extern HANDLE CommMutex;

DLLFUNCTION int InstallLibrary( HWND PostWindow, DWORD pId );
DLLFUNCTION void Shutdown( bool closeClient );
DLLFUNCTION HWND FindUOWindow();
DLLFUNCTION void *GetSharedAddress();
DLLFUNCTION int GetPacketLength( unsigned char *data, int len );
DLLFUNCTION bool IsDynLength( unsigned char packet );
DLLFUNCTION int GetUOProcId();
DLLFUNCTION HANDLE GetCommMutex();
DLLFUNCTION unsigned int TotalIn();
DLLFUNCTION unsigned int TotalOut();
DLLFUNCTION void CalibratePosition(uint16_t x, uint16_t y, uint16_t z);
DLLFUNCTION void OnAttach(void *params, int paramsLen);
DLLFUNCTION void SetServer(unsigned int addr, unsigned short port);
DLLFUNCTION const char *GetUOVersion();


LRESULT CALLBACK UOAWndProc( HWND, UINT, WPARAM, LPARAM );
void Log( const char *format, ... );
void MemoryPatch( unsigned long, unsigned long );
void MemoryPatch( unsigned long, int, int );
void MemoryPatch( unsigned long, const void *, int );
void RedrawTitleBar( HWND, bool );
void CheckTitlebarAttr(HWND);
void FreeArt();
void InitThemes();
bool PatchStatusBar( BOOL preAOS );

//#define PACKET_TBL_STR "Got Logout OK packet!\0\0\0"
//#define PACKET_TS_LEN 24
#define PACKET_TBL_STR "\x07\0\0\0\x03\0\0\0"
#define PACKET_TS_LEN 8
#define PACKET_TBL_OFFSET (0-(8+12+12))

//search disassembly for
//static key1 C1 E2 1F D1 E8 D1 E9 0B C6 0B CA 35 static key2 81 F1 dynamic key 4D
#define CRYPT_KEY_STR "\xC1\xE2\x1F\xD1\xE8\xD1\xE9\x0B\xC6\x0B\xCA\x35"
#define CRYPT_KEY_LEN 12

//static key1 D1 E8 0B C6 C1 E2 1F 35 static key2 D1 E9 89 83 F0 00 42 00 8B 45 08 0B CA 81 F1 dynamic key 48
#define CRYPT_KEY_STR_3D "\xD1\xE8\x0B\xC6\xC1\xE2\x1F\x35"
#define CRYPT_KEY_3D_LEN 8

/* To calculate login keys:
key1 = ( Major << 23 ) | ( Minor << 14 ) | ( Revision << 4 );
key1 ^= ( Revision * Revision ) << 9;
key1 ^= ( Minor * Minor );
key1 ^= ( Minor * 11 ) << 24;
key1 ^= ( Revision * 7 ) << 19;
key1 ^= 0x2C13A5FD;
key2 = ( Major << 22 ) | ( Revision << 13 ) | ( Minor << 3 );
key2 ^= ( Revision * Revision * 3 ) << 10;
key2 ^= ( Minor * Minor );
key2 ^= ( Minor * 13 ) << 23;
key2 ^= ( Revision * 7 ) << 18;
key2 ^= 0xA31D527F;
*/
/*
.text:0041AA2F C1 E6 1F                          shl     esi, 31
.text:0041AA32 D1 E8                             shr     eax, 1
.text:0041AA34 0B C6                             or      eax, esi
.text:0041AA36 47                                inc     edi
.text:0041AA37 33 05 BC 29 6B 00                 xor     eax, LoginKey_2
.text:0041AA3D C1 E2 1F                          shl     edx, 31
.text:0041AA40 89 83 F8 00 0A 00                 mov     [ebx+0A00F8h], eax
.text:0041AA46 D1 E8                             shr     eax, 1
.text:0041AA48 0B C6                             or      eax, esi
.text:0041AA4A 8B 35 BC 29 6B 00                 mov     esi, LoginKey_2
.text:0041AA50 33 C6                             xor     eax, esi
.text:0041AA52 D1 E9                             shr     ecx, 1
.text:0041AA54 89 83 F8 00 0A 00                 mov     [ebx+0A00F8h], eax
.text:0041AA5A 0B CA                             or      ecx, edx
.text:0041AA5C 8B 15 B8 29 6B 00                 mov     edx, LoginKey_1
*/
// -- -- -- -- -- --
// 1F D1 E8 0B C6 47 33 05 memoryloc_2 C1 E2 1F 89 83 F8 00 0A 00 D1 E8 0B C6 8B 35 memoryloc_2 33 C6 D1 E9 89 83 F8 00 0A 00 0B Ca 8b 15 memoryloc_1 33 CA
#define CRYPT_KEY_STR_NEW "\x1F\xD1\xE8\x0B\xC6\x47\x33\x05"
#define CRYPT_KEY_NEW_LEN 8

/*
.text:0041C599 8B F0                             mov     esi, eax
.text:0041C59B 8B FA                             mov     edi, edx
.text:0041C59D D1 E8                             shr     eax, 1
.text:0041C59F C1 E7 1F                          shl     edi, 31
.text:0041C5A2 0B C7                             or      eax, edi
.text:0041C5A4 33 05 FC AB 6C 00                 xor     eax, dword_6CABFC
.text:0041C5AA D1 EA                             shr     edx, 1
.text:0041C5AC D1 E8                             shr     eax, 1
.text:0041C5AE C1 E6 1F                          shl     esi, 31
.text:0041C5B1 0B C7                             or      eax, edi
.text:0041C5B3 33 05 FC AB 6C 00                 xor     eax, dword_6CABFC
.text:0041C5B9 0B D6                             or      edx, esi
.text:0041C5BB 33 15 00 AC 6C 00                 xor     edx, dword_6CAC00
.text:0041C5C1 83 EB 01                          sub     ebx, 1
.text:0041C5C4 83 C5 01                          add     ebp, 1
.text:0041C5C7 85 DB                             test    ebx, ebx
*/
// E8 C1 E7 1F 0B C7 33 05 memoryloc_2
#define CRYPT_KEY_STR_MORE_NEW "\xE8\xC1\xE7\x1F\x0B\xC7\x33\x05"
#define CRYPT_KEY_MORE_NEW_LEN 8


================================================
FILE: Crypt/Crypt.vcxproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup Label="ProjectConfigurations">
    <ProjectConfiguration Include="Debug|Win32">
      <Configuration>Debug</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|Win32">
      <Configuration>Release</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
  </ItemGroup>
  <PropertyGroup Label="Globals">
    <ProjectGuid>{B32A4D9E-3AF1-4C75-989D-D62C4E8F08B1}</ProjectGuid>
    <RootNamespace>Crypt</RootNamespace>
    <Keyword>Win32Proj</Keyword>
    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
  <PropertyGroup>
    <ConfigurationType>DynamicLibrary</ConfigurationType>
    <PlatformToolset>v143</PlatformToolset>
    <CharacterSet>MultiByte</CharacterSet>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
  <ImportGroup Label="ExtensionSettings">
  </ImportGroup>
  <ImportGroup Label="PropertySheets">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
    <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />
  </ImportGroup>
  <PropertyGroup Label="UserMacros" />
  <PropertyGroup>
    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
  </PropertyGroup>
  <PropertyGroup>
    <OutDir>$(SolutionDir)bin\$(Platform)\$(Configuration)\</OutDir>
  </PropertyGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <ClCompile>
      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;CRYPT_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <WarningLevel>Level3</WarningLevel>
      <Optimization>Disabled</Optimization>
      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
      <CallingConvention>StdCall</CallingConvention>
    </ClCompile>
    <Link>
      <AdditionalDependencies>ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
      <ModuleDefinitionFile>Crypt.def</ModuleDefinitionFile>
      <GenerateDebugInformation>true</GenerateDebugInformation>
      <SubSystem>Windows</SubSystem>
      <TargetMachine>MachineX86</TargetMachine>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <ClCompile>
      <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;WIN32;NDEBUG;_WINDOWS;_USRDLL;CRYPT_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <WarningLevel>Level3</WarningLevel>
      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
      <CallingConvention>StdCall</CallingConvention>
    </ClCompile>
    <Link>
      <AdditionalDependencies>ws2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
      <ModuleDefinitionFile>Crypt.def</ModuleDefinitionFile>
      <GenerateDebugInformation>false</GenerateDebugInformation>
      <SubSystem>Windows</SubSystem>
      <OptimizeReferences>true</OptimizeReferences>
      <TargetMachine>MachineX86</TargetMachine>
    </Link>
  </ItemDefinitionGroup>
  <ItemGroup>
    <ClCompile Include="Crypt.cpp" />
    <ClCompile Include="LoginEncryption.cpp" />
    <ClCompile Include="MemFinder.cpp" />
    <ClCompile Include="OldStatusBar.cpp" />
    <ClCompile Include="OSIEncryption.cpp" />
    <ClCompile Include="PacketInfo.cpp" />
    <ClCompile Include="stdafx.cpp" />
    <ClCompile Include="twofish.c" />
    <ClCompile Include="uo_huffman.cpp" />
    <ClCompile Include="UOArt.cpp" />
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="Crypt.h" />
    <ClInclude Include="debug.h" />
    <ClInclude Include="LoginEncryption.h" />
    <ClInclude Include="MemFinder.h" />
    <ClInclude Include="OSIEncryption.h" />
    <ClInclude Include="PacketInfo.h" />
    <ClInclude Include="platform.h" />
    <ClInclude Include="resource.h" />
    <ClInclude Include="stdafx.h" />
    <ClInclude Include="table.h" />
    <ClInclude Include="twofish.h" />
    <ClInclude Include="uo_huffman.h" />
  </ItemGroup>
  <ItemGroup>
    <None Include="Crypt.def" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\Razor\Razor.csproj">
      <Project>{b24e4fb1-4936-4544-9e88-f3ff9b04fdba}</Project>
      <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <Image Include="App.ico" />
  </ItemGroup>
  <ItemGroup>
    <ResourceCompile Include="Crypt.rc" />
  </ItemGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
  <ImportGroup Label="ExtensionTargets">
  </ImportGroup>
</Project>

================================================
FILE: Crypt/Crypt.vcxproj.filters
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup>
    <Filter Include="Source Files">
      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
      <Extensions>cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
    </Filter>
    <Filter Include="Header Files">
      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
    </Filter>
    <Filter Include="Resource Files">
      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx</Extensions>
    </Filter>
  </ItemGroup>
  <ItemGroup>
    <ClCompile Include="Crypt.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="LoginEncryption.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="MemFinder.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="OldStatusBar.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="OSIEncryption.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="PacketInfo.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="stdafx.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="twofish.c">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="uo_huffman.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="UOArt.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="Crypt.h">
      <Filter>Header Files</Filter>
    </ClInclude>
    <ClInclude Include="debug.h">
      <Filter>Header Files</Filter>
    </ClInclude>
    <ClInclude Include="LoginEncryption.h">
      <Filter>Header Files</Filter>
    </ClInclude>
    <ClInclude Include="MemFinder.h">
      <Filter>Header Files</Filter>
    </ClInclude>
    <ClInclude Include="OSIEncryption.h">
      <Filter>Header Files</Filter>
    </ClInclude>
    <ClInclude Include="PacketInfo.h">
      <Filter>Header Files</Filter>
    </ClInclude>
    <ClInclude Include="platform.h">
      <Filter>Header Files</Filter>
    </ClInclude>
    <ClInclude Include="resource.h">
      <Filter>Header Files</Filter>
    </ClInclude>
    <ClInclude Include="stdafx.h">
      <Filter>Header Files</Filter>
    </ClInclude>
    <ClInclude Include="table.h">
      <Filter>Header Files</Filter>
    </ClInclude>
    <ClInclude Include="twofish.h">
      <Filter>Header Files</Filter>
    </ClInclude>
    <ClInclude Include="uo_huffman.h">
      <Filter>Header Files</Filter>
    </ClInclude>
  </ItemGroup>
  <ItemGroup>
    <None Include="Crypt.def">
      <Filter>Source Files</Filter>
    </None>
  </ItemGroup>
  <ItemGroup>
    <Image Include="App.ico">
      <Filter>Resource Files</Filter>
    </Image>
  </ItemGroup>
  <ItemGroup>
    <ResourceCompile Include="Crypt.rc">
      <Filter>Resource Files</Filter>
    </ResourceCompile>
  </ItemGroup>
</Project>

================================================
FILE: Crypt/LoginEncryption.cpp
================================================
#include "stdafx.h"

#include "Crypt.h"
#include "LoginEncryption.h"

#define N2L(C, LL) \
    LL  = ((unsigned int)(*((C)++))) << 24, \
    LL |= ((unsigned int)(*((C)++))) << 16, \
    LL |= ((unsigned int)(*((C)++))) << 8, \
    LL |= ((unsigned int)(*((C)++)))

DWORD zero = 0;

const DWORD *LoginEncryption::Key1 = &zero;
const DWORD *LoginEncryption::Key2 = &zero;

LoginEncryption::LoginEncryption()
{
	m_Table[0] = m_Table[1] = 0;
}

void LoginEncryption::SetKeys( const DWORD *k1, const DWORD *k2 )
{
	//LoginEncryption::StaticKey1  = *((DWORD*)sk1);
	LoginEncryption::Key1 = k1;
	LoginEncryption::Key2 = k2;
}

void LoginEncryption::Initialize( const BYTE *pSeed )
{
	DWORD seed;
    N2L(pSeed, seed);

	/*char temp[256];
	sprintf( temp, "Key1 = %08x, Key2 = %08x", *Key1, *Key2 );
	MessageBox( NULL, temp, "Keys", MB_OK );*/

    m_Table[0] = (((~seed) ^ 0x00001357) << 16) | ((seed ^ 0xffffaaaa) & 0x0000ffff);
    m_Table[1] = ((seed ^ 0x43210000) >> 16) | (((~seed) ^ 0xabcdffff) & 0xffff0000);
}

void LoginEncryption::Encrypt( const BYTE *in, BYTE *out, int len )
{
	for (int i=0;i<len;i++)
		out[i] = Crypt( in[i] );
}

void LoginEncryption::Decrypt( const BYTE *in, BYTE *out, int len )
{
	for (int i=0;i<len;i++)
		out[i] = Crypt( in[i] );
}

BYTE LoginEncryption::Crypt( BYTE in )
{
	//m_Table[1] = (((((pt1 >> 1) | (pt0 << 31)) ^ LOGIN_KEY_1) >> 1) | (pt0<<31)) ^ LOGIN_KEY_1;
	//m_Table[0] = ((pt0 >> 1) | (pt1 << 31)) ^ LOGIN_KEY_2;
	
	BYTE out = in ^ ((unsigned char)m_Table[0]);

	DWORD OldT1 = m_Table[1];
	m_Table[1] = ((((m_Table[1] >> 1) | (m_Table[0] << 31)) ^ ((*Key1)-1)) >> 1 | (m_Table[0] << 31)) ^ (*Key1);
	m_Table[0] = ((m_Table[0]>>1) | (OldT1<<31)) ^ (*Key2);
	
	return out;
}

bool LoginEncryption::TestForLogin( BYTE encrypted )
{
	return IsLoginByte( (BYTE)( encrypted ^ ((BYTE)m_Table[0]) ) );
}

bool LoginEncryption::IsLoginByte( BYTE unencrypted )
{
	return unencrypted == ((BYTE)0x80) || unencrypted == ((BYTE)0x48);
}

DWORD LoginEncryption::GenerateBadSeed( DWORD oldSeed )
{
	DWORD newSeed = (*Key1) ^ (*Key2);
	newSeed = ((newSeed >> 24) & 0xFF) | ((newSeed >> 8) & 0xFF00) | ((newSeed << 8) & 0xFF0000) | ((newSeed << 24) & 0xFF000000);
	return htonl( newSeed ^ htonl( oldSeed ) );
}


================================================
FILE: Crypt/LoginEncryption.h
================================================
#pragma once

class LoginEncryption
{
public:
	LoginEncryption();

	void Initialize( const BYTE *pSeed );

	static void SetKeys( const DWORD *k1, const DWORD *k2 );

	void Encrypt( const BYTE *in, BYTE *out, int len );
	void Decrypt( const BYTE *in, BYTE *out, int len );

	bool TestForLogin( BYTE encrypted );

	static DWORD GenerateBadSeed( DWORD oldSeed );

	static bool IsLoginByte( BYTE unencrypted );

private:
	static const DWORD *Key1, *Key2;

	BYTE Crypt( BYTE );

	DWORD m_Table[2];
};



================================================
FILE: Crypt/MemFinder.cpp
================================================
#include "stdafx.h"
#include "MemFinder.h"

DWORD MemFinder::Find(const void *data, int length, DWORD addressHint, DWORD addressMax)
{
	for (DWORD addr = addressHint; addr < addressMax; addr++)
	{
		if (IsBadReadPtr((void*)addr, length)) {
			continue;
		}

		__try
		{
			if (memcmp((const void*)addr, data, length) == 0)
				return addr;
		}
		__except (EXCEPTION_ACCESS_VIOLATION)
		{
			continue;
		}
	}

	return 0;
}

MemFinder::MemFinder()
{
	Clear();
}

MemFinder::~MemFinder()
{
	Clear();
}

void MemFinder::Clear()
{
	_Executed = false;
	_StartPos = 0xFFFFFFFF;

	for (unsigned int i = 0; i<_Entries.size(); i++)
		delete[] _Entries[i].Data;

	_Entries.clear();
}


void MemFinder::AddEntry(const void *data, int length, unsigned int maxResults, DWORD hint)
{
	Entry ent;

	ent.Data = new char[length];
	memcpy(ent.Data, data, length);

	ent.Length = length;
	ent.MaxResults = maxResults;
	ent.PositionHint = hint;

	if (hint < _StartPos)
		_StartPos = hint;

	_Entries.push_back(ent);
}

DWORD MemFinder::GetAddress(const void *data, int length, unsigned int idx)
{
	if (!_Executed)
		return 0;

	for (unsigned int i = 0; i < _Entries.size(); i++)
	{
		if (_Entries[i].Length != length)
			continue;

		if (!memcmp(data, _Entries[i].Data, length))
		{
			if (idx < _Entries[i].Results.size())
				return _Entries[i].Results[idx];
			else
				return 0;
		}
	}

	return 0;
}

void MemFinder::Execute()
{
	bool allDone = false;
	for (DWORD pos = _StartPos; pos < 0x02000000 && !allDone; pos++)
	{
		__try
		{
			allDone = true;
			for (unsigned int i = 0; i < _Entries.size(); i++)
			{
				Entry &e = _Entries[i];

				if (e.Results.size() >= e.MaxResults) {
					/* Already found this entry */
					continue;
				}

				if (IsBadReadPtr((void*)pos, e.Length)) {
					continue;
				}

				allDone = false;

				if (e.PositionHint > pos) {
					/* This entry always appears in memory after this position */
					continue;
				}

				if (!memcmp((void*)pos, e.Data, e.Length)) {
					e.Results.push_back(pos);
				}
			}
		}
		__except (EXCEPTION_ACCESS_VIOLATION)
		{
			break;
		}
	}

	_Executed = true;
}



================================================
FILE: Crypt/MemFinder.h
================================================
#pragma pack(1)
#pragma once

#include <vector>
using std::vector;

class MemFinder
{
public:
	static DWORD Find( const void *data, int length, DWORD hint = 0x00400000, DWORD addressMax = 0x01000000 );

	MemFinder();
	~MemFinder();

	void AddEntry( const void *data, int length, unsigned int maxResults, DWORD hint );
	void AddEntry( const void *data, int length, DWORD hint = 0x00400000 ) { AddEntry( data, length, 1, hint ); }

	DWORD GetAddress( const void *data, int length, unsigned int idx = 0 );

	void Execute();

	void Clear();

private:
	struct Entry
	{
		char *Data;
		int Length;
		DWORD PositionHint;
		unsigned int MaxResults;
		vector<DWORD> Results;
	};

	vector<Entry> _Entries;
	bool _Executed;
	DWORD _StartPos;
};


================================================
FILE: Crypt/OSIEncryption.cpp
================================================
#include "stdafx.h"

#include "Crypt.h"
#include "OSIEncryption.h"
#include "TwoFish.h"

OSIEncryption::OSIEncryption()
{
	memset( &m_Key, 0, sizeof(m_Key) );
	memset( &m_Cipher, 0, sizeof(m_Cipher) );
	memset( m_TFTable, 0, 256 );
	memset( m_XORTable, 0, 16 );

	Log( "XT: %X", m_XORTable );

	m_XORPos = m_TFPos = 0;
}

void OSIEncryption::Initialize( DWORD Seed )
{
	memset( &m_Key, 0, sizeof(m_Key) );
	memset( &m_Cipher, 0, sizeof(m_Cipher) );
	memset( m_TFTable, 0, 256 );

	makeKey( &m_Key, DIR_DECRYPT, 0x80, NULL );
	m_Key.key32[0] = m_Key.key32[1] = m_Key.key32[2] = m_Key.key32[3] = Seed;
	reKey( &m_Key );
	cipherInit( &m_Cipher, MODE_ECB, NULL );
	for(int i=0;i<256;i++)
		m_TFTable[i] = i;
	ReinitTFTable();

	MD5( m_TFTable, 256, m_XORTable );
	m_XORPos = 0;
}

void OSIEncryption::ReinitTFTable()
{
	unsigned char tmpBuff[256];
	blockEncrypt( &m_Cipher, &m_Key, m_TFTable, 256*8, tmpBuff );
	memcpy( m_TFTable, tmpBuff, 256 );
	m_TFPos = 0;
}

void OSIEncryption::Hash( BYTE *field, const BYTE *param )
{
	unsigned int a = *((unsigned int *)(field +  0));
	unsigned int b = *((unsigned int *)(field +  4));
	unsigned int c = *((unsigned int *)(field +  8));
	unsigned int d = *((unsigned int *)(field + 12));

	a = ((b & c) | (~b & d)) + *((unsigned int *)(param + 0x00)) + a - 0x28955B88;
	a = ((a << 0x07) | (a >> 0x19)) + b;
	d = ((a & b) | (~a & c)) + *((unsigned int *)(param + 0x04)) + d - 0x173848AA;
	d = ((d << 0x0c) | (d >> 0x14)) + a;
	c = ((d & a) | (~d & b)) + *((unsigned int *)(param + 0x08)) + c + 0x242070DB;
	c = ((c << 0x11) | (c >> 0x0f)) + d;
	b = ((c & d) | (~c & a)) + *((unsigned int *)(param + 0x0c)) + b - 0x3E423112;
	b = ((b << 0x16) | (b >> 0x0a)) + c;
	a = ((b & c) | (~b & d)) + *((unsigned int *)(param + 0x10)) + a - 0x0A83F051;
	a = ((a << 0x07) | (a >> 0x19)) + b;
	d = ((a & b) | (~a & c)) + *((unsigned int *)(param + 0x14)) + d + 0x4787C62A;
	d = ((d << 0x0c) | (d >> 0x14)) + a;
	c = ((d & a) | (~d & b)) + *((unsigned int *)(param + 0x18)) + c - 0x57CFB9ED;
	c = ((c << 0x11) | (c >> 0x0f)) + d;
	b = ((c & d) | (~c & a)) + *((unsigned int *)(param + 0x1c)) + b - 0x02B96AFF;
	b = ((b << 0x16) | (b >> 0x0a)) + c;
	a = ((b & c) | (~b & d)) + *((unsigned int *)(param + 0x20)) + a + 0x698098D8;
	a = ((a << 0x07) | (a >> 0x19)) + b;
	d = ((a & b) | (~a & c)) + *((unsigned int *)(param + 0x24)) + d - 0x74BB0851;
	d = ((d << 0x0c) | (d >> 0x14)) + a;
	c = ((d & a) | (~d & b)) + *((unsigned int *)(param + 0x28)) + c - 0x0000A44F;
	c = ((c << 0x11) | (c >> 0x0f)) + d;
	b = ((c & d) | (~c & a)) + *((unsigned int *)(param + 0x2C)) + b - 0x76A32842;
	b = ((b << 0x16) | (b >> 0x0a)) + c;
	a = ((b & c) | (~b & d)) + *((unsigned int *)(param + 0x30)) + a + 0x6B901122;
	a = ((a << 0x07) | (a >> 0x19)) + b;
	d = ((a & b) | (~a & c)) + *((unsigned int *)(param + 0x34)) + d - 0x02678E6D;
	d = ((d << 0x0c) | (d >> 0x14)) + a;
	c = ((d & a) | (~d & b)) + *((unsigned int *)(param + 0x38)) + c - 0x5986BC72;
	c = ((c << 0x11) | (c >> 0x0f)) + d;
	b = ((c & d) | (~c & a)) + *((unsigned int *)(param + 0x3c)) + b + 0x49B40821;
	b = ((b << 0x16) | (b >> 0x0a)) + c;

	a = ((b & d) | (~d & c)) + *((unsigned int *)(param + 0x04)) + a - 0x09E1DA9E;
	a = ((a << 0x05) | (a >> 0x1b)) + b;
	d = ((a & c) | (~c & b)) + *((unsigned int *)(param + 0x18)) + d - 0x3FBF4CC0;
	d = ((d << 0x09) | (d >> 0x17)) + a;
	c = ((d & b) | (~b & a)) + *((unsigned int *)(param + 0x2c)) + c + 0x265E5A51;
	c = ((c << 0x0e) | (c >> 0x12)) + d;
	b = ((c & a) | (~a & d)) + *((unsigned int *)(param + 0x00)) + b - 0x16493856;
	b = ((b << 0x14) | (b >> 0x0c)) + c;
	a = ((b & d) | (~d & c)) + *((unsigned int *)(param + 0x14)) + a - 0x29D0EFA3;
	a = ((a << 0x05) | (a >> 0x1b)) + b;
	d = ((a & c) | (~c & b)) + *((unsigned int *)(param + 0x28)) + d + 0x02441453;
	d = ((d << 0x09) | (d >> 0x17)) + a;
	c = ((d & b) | (~b & a)) + *((unsigned int *)(param + 0x3c)) + c - 0x275E197F;
	c = ((c << 0x0e) | (c >> 0x12)) + d;
	b = ((c & a) | (~a & d)) + *((unsigned int *)(param + 0x10)) + b - 0x182C0438;
	b = ((b << 0x14) | (b >> 0x0c)) + c;
	a = ((b & d) | (~d & c)) + *((unsigned int *)(param + 0x24)) + a + 0x21E1CDE6;
	a = ((a << 0x05) | (a >> 0x1b)) + b;
	d = ((a & c) | (~c & b)) + *((unsigned int *)(param + 0x38)) + d - 0x3CC8F82A;
	d = ((d << 0x09) | (d >> 0x17)) + a;
	c = ((d & b) | (~b & a)) + *((unsigned int *)(param + 0x0c)) + c - 0x0B2AF279;
	c = ((c << 0x0e) | (c >> 0x12)) + d;
	b = ((c & a) | (~a & d)) + *((unsigned int *)(param + 0x20)) + b + 0x455A14ED;
	b = ((b << 0x14) | (b >> 0x0c)) + c;
	a = ((b & d) | (~d & c)) + *((unsigned int *)(param + 0x34)) + a - 0x561C16FB;
	a = ((a << 0x05) | (a >> 0x1b)) + b;
	d = ((a & c) | (~c & b)) + *((unsigned int *)(param + 0x08)) + d - 0x03105C08;
	d = ((d << 0x09) | (d >> 0x17)) + a;
	c = ((d & b) | (~b & a)) + *((unsigned int *)(param + 0x1c)) + c + 0x676F02D9;
	c = ((c << 0x0e) | (c >> 0x12)) + d;
	b = ((c & a) | (~a & d)) + *((unsigned int *)(param + 0x30)) + b - 0x72D5B376;
	b = ((b << 0x14) | (b >> 0x0c)) + c;

	a = (b ^ c ^ d) + *((unsigned int *)(param + 0x14)) + a - 0x0005C6BE;
	a = ((a << 0x04) | (a >> 0x1c)) + b;
	d = (a ^ b ^ c) + *((unsigned int *)(param + 0x20)) + d - 0x788E097F;
	d = ((d << 0x0b) | (d >> 0x15)) + a;
	c = (d ^ a ^ b) + *((unsigned int *)(param + 0x2c)) + c + 0x6D9D6122;
	c = ((c << 0x10) | (c >> 0x10)) + d;
	b = (c ^ d ^ a) + *((unsigned int *)(param + 0x38)) + b - 0x021AC7F4;
	b = ((b << 0x17) | (b >> 0x09)) + c;
	a = (b ^ c ^ d) + *((unsigned int *)(param + 0x04)) + a - 0x5B4115BC;
	a = ((a << 0x04) | (a >> 0x1c)) + b;
	d = (a ^ b ^ c) + *((unsigned int *)(param + 0x10)) + d + 0x4BDECFA9;
	d = ((d << 0x0b) | (d >> 0x15)) + a;
	c = (d ^ a ^ b) + *((unsigned int *)(param + 0x1c)) + c - 0x0944B4A0;
	c = ((c << 0x10) | (c >> 0x10)) + d;
	b = (c ^ d ^ a) + *((unsigned int *)(param + 0x28)) + b - 0x41404390;
	b = ((b << 0x17) | (b >> 0x09)) + c;
	a = (b ^ c ^ d) + *((unsigned int *)(param + 0x34)) + a + 0x289B7EC6;
	a = ((a << 0x04) | (a >> 0x1c)) + b;
	d = (a ^ b ^ c) + *((unsigned int *)(param + 0x00)) + d - 0x155ED806;
	d = ((d << 0x0b) | (d >> 0x15)) + a;
	c = (d ^ a ^ b) + *((unsigned int *)(param + 0x0c)) + c - 0x2B10CF7B;
	c = ((c << 0x10) | (c >> 0x10)) + d;
	b = (c ^ d ^ a) + *((unsigned int *)(param + 0x18)) + b + 0x04881D05;
	b = ((b << 0x17) | (b >> 0x09)) + c;
	a = (b ^ c ^ d) + *((unsigned int *)(param + 0x24)) + a - 0x262B2FC7;
	a = ((a << 0x04) | (a >> 0x1c)) + b;
	d = (a ^ b ^ c) + *((unsigned int *)(param + 0x30)) + d - 0x1924661B;
	d = ((d << 0x0b) | (d >> 0x15)) + a;
	c = (d ^ a ^ b) + *((unsigned int *)(param + 0x3c)) + c + 0x1fa27cf8;
	c = ((c << 0x10) | (c >> 0x10)) + d;
	b = (c ^ d ^ a) + *((unsigned int *)(param + 0x08)) + b - 0x3B53A99B;
	b = ((b << 0x17) | (b >> 0x09)) + c;

	a = ((~d | b) ^ c)  + *((unsigned int *)(param + 0x00)) + a - 0x0BD6DDBC;
	a = ((a << 0x06) | (a >> 0x1a)) + b; 
	d = ((~c | a) ^ b)  + *((unsigned int *)(param + 0x1c)) + d + 0x432AFF97;
	d = ((d << 0x0a) | (d >> 0x16)) + a; 
	c = ((~b | d) ^ a)  + *((unsigned int *)(param + 0x38)) + c - 0x546BDC59;
	c = ((c << 0x0f) | (c >> 0x11)) + d; 
	b = ((~a | c) ^ d)  + *((unsigned int *)(param + 0x14)) + b - 0x036C5FC7;
	b = ((b << 0x15) | (b >> 0x0b)) + c; 
	a = ((~d | b) ^ c)  + *((unsigned int *)(param + 0x30)) + a + 0x655B59C3;
	a = ((a << 0x06) | (a >> 0x1a)) + b; 
	d = ((~c | a) ^ b)  + *((unsigned int *)(param + 0x0C)) + d - 0x70F3336E;
	d = ((d << 0x0a) | (d >> 0x16)) + a; 
	c = ((~b | d) ^ a)  + *((unsigned int *)(param + 0x28)) + c - 0x00100B83;
	c = ((c << 0x0f) | (c >> 0x11)) + d; 
	b = ((~a | c) ^ d)  + *((unsigned int *)(param + 0x04)) + b - 0x7A7BA22F;
	b = ((b << 0x15) | (b >> 0x0b)) + c; 
	a = ((~d | b) ^ c)  + *((unsigned int *)(param + 0x20)) + a + 0x6FA87E4F;
	a = ((a << 0x06) | (a >> 0x1a)) + b; 
	d = ((~c | a) ^ b)  + *((unsigned int *)(param + 0x3c)) + d - 0x01D31920;
	d = ((d << 0x0a) | (d >> 0x16)) + a; 
	c = ((~b | d) ^ a)  + *((unsigned int *)(param + 0x18)) + c - 0x5CFEBCEC;
	c = ((c << 0x0f) | (c >> 0x11)) + d; 
	b = ((~a | c) ^ d)  + *((unsigned int *)(param + 0x34)) + b + 0x4E0811A1;
	b = ((b << 0x15) | (b >> 0x0b)) + c; 
	a = ((~d | b) ^ c)  + *((unsigned int *)(param + 0x10)) + a - 0x08AC817E;
	a = ((a << 0x06) | (a >> 0x1a)) + b; 
	d = ((~c | a) ^ b)  + *((unsigned int *)(param + 0x2c)) + d - 0x42C50DCB;
	d = ((d << 0x0a) | (d >> 0x16)) + a; 
	c = ((~b | d) ^ a)  + *((unsigned int *)(param + 0x08)) + c + 0x2AD7D2BB;
	c = ((c << 0x0f) | (c >> 0x11)) + d; 
	b = ((~a | c) ^ d)  + *((unsigned int *)(param + 0x24)) + b - 0x14792C6F;
	b = ((b << 0x15) | (b >> 0x0b)) + c;

	*((unsigned int *)(field +  0)) += a;
	*((unsigned int *)(field +  4)) += b;
	*((unsigned int *)(field +  8)) += c;
	*((unsigned int *)(field + 12)) += d;
}

void OSIEncryption::CallHash( BYTE *key, const BYTE *challenge, unsigned int len )
{
	unsigned int *ptr1, *ptr2;
	unsigned int a, b, c;

	ptr1 = (unsigned int *)(key + 16);
	ptr2 = (unsigned int *)(key + 20);

	a = *ptr1;
	b = (a >> 3) & 0x3f;
	a += len * 8;
	*ptr1 = a;

	if ( a < (len << 3) )
		ptr2 += 4;

	*ptr2 = *ptr2 + (len >> 0x1d);

	a = 64 - b;
	c = 0;

	if ( a <= len )
	{
		memcpy( key + b + 24, challenge, a );
		Hash( key, key + 24 );

		c = a;
		a += 0x3F;

		while ( a < len )
		{
			Hash( key, challenge + a - 0x3f );
			a += 64;
			c += 64;
		}

		b = 0;
	}

	memcpy( key + b + 24, challenge + c, len - c );
}

void OSIEncryption::CalcResponse( BYTE *result, BYTE *field )
{
	BYTE buf1[0x80];
	BYTE buf2[0x80];
	int i;

	memset( buf1, 0, 0x80 );

	*buf1 = 0x80;

	memcpy( buf2, field + 16, 8 );

	i = ( int(*((unsigned int *)(buf2))) >> 3 ) & 0x3f;

	if ( i < 56 )
		i = 56 - i;
	else
		i = 120 - i;

	CallHash( field, buf1, i );
	CallHash( field, buf2, 8 );

	memcpy( result, field, 16 );
}

void OSIEncryption::MD5( const BYTE *input, int inLen, BYTE *output )
{
	BYTE field[0x80];

	memset( field, 0, 0x80 );

	field[0x0] = 0x01;
	field[0x1] = 0x23;
	field[0x2] = 0x45;
	field[0x3] = 0x67;
	field[0x4] = 0x89;
	field[0x5] = 0xAB;
	field[0x6] = 0xCD;
	field[0x7] = 0xEF;
	field[0x8] = 0xFE;
	field[0x9] = 0xDC;
	field[0xA] = 0xBA;
	field[0xB] = 0x98;
	field[0xC] = 0x76;
	field[0xD] = 0x54;
	field[0xE] = 0x32;
	field[0xF] = 0x10;

	CallHash( field, input, inLen );
	CalcResponse( output, field );
}

//going TO the client uses rotating XOR, going FROM the client uses TwoFish

void OSIEncryption::XORCrypt( const BYTE *in, BYTE *out, int len )
{
	for (int i=0;i<len;i++)
	{
		out[i] = in[i] ^ m_XORTable[m_XORPos%16];
		m_XORPos++;
	}
}

void OSIEncryption::TwoFishCrypt( const BYTE *in, BYTE *out, int len )
{
	for(int i=0;i<len;i++)
	{
		if( m_TFPos >= 256 )
			ReinitTFTable();
		out[i] = in[i] ^ m_TFTable[m_TFPos++];
	}
}

//server -> us
void OSIEncryption::DecryptFromServer( const BYTE *in, BYTE *out, int len )
{
	XORCrypt( in, out, len );
}

//us -> client
void OSIEncryption::EncryptForClient( const BYTE *in, BYTE *out, int len )
{
	XORCrypt( in, out, len );
}

//us -> server
void OSIEncryption::EncryptForServer( const BYTE *in, BYTE *out, int len )
{
	TwoFishCrypt( in, out, len );
}

//client -> us
void OSIEncryption::DecryptFromClient( const BYTE *in, BYTE *out, int len )
{
	TwoFishCrypt( in, out, len );
}




================================================
FILE: Crypt/OSIEncryption.h
================================================
#pragma once

#include "TwoFish.h"

class OSIEncryption
{
public:
	OSIEncryption();

	void Initialize( DWORD dwSeed );

	void DecryptFromServer( const BYTE *in, BYTE *out, int len );
	void DecryptFromClient( const BYTE *in, BYTE *out, int len );

	void EncryptForServer( const BYTE *in, BYTE *out, int len );
	void EncryptForClient( const BYTE *in, BYTE *out, int len );

	static void MD5( const BYTE *input, int inLen, BYTE *output );

private:
	void TwoFishCrypt( const BYTE *in, BYTE *out, int len );
	void ReinitTFTable();

	void XORCrypt( const BYTE *in, BYTE *out, int len );
	void InitializeXORTable( const BYTE* data, int dataLen );
	static void Hash( BYTE *field, const BYTE *param );
	static void CallHash( BYTE *key, const BYTE *challenge, unsigned int len );
	static void CalcResponse( BYTE *result, BYTE *field );

	keyInstance m_Key; 
	cipherInstance m_Cipher; 
	unsigned int m_TFPos;
	unsigned char m_XORPos;
	BYTE m_TFTable[256];
	BYTE m_XORTable[16];
};



================================================
FILE: Crypt/OldStatusBar.cpp
================================================
#include "StdAfx.h"
#include "Crypt.h"
#include "MemFinder.h"

DWORD GumpOutV28( DWORD OutFuncAddr, int esiOff, char TwoFourOff, DWORD CurAddr, int x, int y )
{
	int count = 0;

	memcpy( (void*)(CurAddr+count), "\x8D\x44\x24\x20", 4 ); // lea    eax, [esp+70h+var_50]
	count += 4;
	memcpy( (void*)(CurAddr+count), "\x50", 1 ); // push    eax
	count ++;

	memcpy( (void*)(CurAddr+count), "\x8B\x46", 2 ); // mov    eax, [esi+24h]
	count += 2;
	*((unsigned char*)(CurAddr+count)) = 0x24+TwoFourOff;//+esiOff;
	count ++;
	memcpy( (void*)(CurAddr+count), "\x50", 1 ); // push    eax
	count ++;

	memcpy( (void*)(CurAddr+count), "\x8B\x56", 2 ); // mov     edx, [esi+44h]
	count += 2;
	*((unsigned char*)(CurAddr+count)) = 0x44+esiOff;
	count ++;
	memcpy( (void*)(CurAddr+count), "\x8B\x42\x14", 3 ); // mov     eax, [edx+14h]
	count += 3;
	memcpy( (void*)(CurAddr+count), "\x83\xC0\x04", 3 ); // add     eax, 4
	count += 3;
	memcpy( (void*)(CurAddr+count), "\x50", 1 ); // push    eax
	count ++;

	memcpy( (void*)(CurAddr+count), "\x8D\x44\x24\x54", 4 ); // lea    eax, [esp+7Ch+var_28]
	count += 4;
	memcpy( (void*)(CurAddr+count), "\x50", 1 ); // push    eax
	count ++;

	memcpy( (void*)(CurAddr+count), "\x68\x86\x03\x00\x00", 5 ); // push    386h
	count += 5;

	memcpy( (void*)(CurAddr+count), "\x6A\x01", 2 ); // push    1
	count += 2;

	// push    y
	if ( y < 0x80 )
	{
		*((unsigned char*)(CurAddr+count)) = 0x6A;
		count ++;
		*((unsigned char*)(CurAddr+count)) = (unsigned char)y;
		count ++;
	}
	else
	{
		*((unsigned char*)(CurAddr+count)) = 0x68;
		count ++;
		*((int*)(CurAddr+count)) = y;
		count += 4;
	}

	// push    x
	if ( x < 0x80 )
	{
		*((unsigned char*)(CurAddr+count)) = 0x6A;
		count ++;
		*((unsigned char*)(CurAddr+count)) = (unsigned char)x;
		count ++;
	}
	else
	{
		*((unsigned char*)(CurAddr+count)) = 0x68;
		count ++;
		*((int*)(CurAddr+count)) = x;
		count += 4;
	}

	// call theFunction
	*((unsigned char*)(CurAddr+count)) = 0xE8;
	count ++;
	*((int*)(CurAddr+count)) = OutFuncAddr - (CurAddr+count+4);
	count += 4;

	memcpy( (void*)(CurAddr+count), "\x83\xC4\x20", 3 ); // add    esp, 20h
	count += 3;

	return count;
}

DWORD Sprintf1UV28( DWORD sprintfAddr, DWORD fmtAddr, DWORD CurAddr, int esiOffset )
{
	int count = 0;

	memcpy( (void*)(CurAddr+count), "\x33\xC9", 2 ); // xor     ecx, ecx
	count += 2;

	memcpy( (void*)(CurAddr+count), "\x8D\x54\x24\x48", 4 ); // lea     edx, [esp+70h+var_28]
	count += 4;

	memcpy( (void*)(CurAddr+count), "\x66\x8B\x8E", 3 ); // mov     cx, [esi+___]
	count += 3;
	*((int*)(CurAddr+count)) = esiOffset;
	count += 4;

	memcpy( (void*)(CurAddr+count), "\x51", 1 ); // push    ecx
	count ++;

	// push offset fmtAddr
	*((unsigned char*)(CurAddr+count)) = 0x68;
	count ++;
	*((int*)(CurAddr+count)) = fmtAddr;
	count += 4;

	memcpy( (void*)(CurAddr+count), "\x52", 1 ); // push    edx
	count ++;

	// call    _sprintf
	*((unsigned char*)(CurAddr+count)) = 0xE8;
	count ++;
	*((int*)(CurAddr+count)) = sprintfAddr - (CurAddr+count+4);
	count += 4;

	memcpy( (void*)(CurAddr+count), "\x83\xC4\x0C", 3 ); // add    esp, 0Ch
	count += 3;

	return count;
}

DWORD Sprintf2UV28_Byte( DWORD sprintfAddr, DWORD fmtAddr, DWORD CurAddr, int offset1, int offset2 )
{
	int count = 0;

	memcpy( (void*)(CurAddr+count), "\x33\xC0", 2 ); // xor     eax, eax
	count += 2;

	memcpy( (void*)(CurAddr+count), "\x8A\x86", 2 ); // mov     al, [esi+___]
	count += 2;
	*((int*)(CurAddr+count)) = offset2;
	count += 4;

	memcpy( (void*)(CurAddr+count), "\x50", 1 ); // push    eax
	count ++;

	memcpy( (void*)(CurAddr+count), "\x33\xC9", 2 ); // xor     ecx, ecx
	count += 2;

	memcpy( (void*)(CurAddr+count), "\x8D\x54\x24\x4C", 4 ); // lea     edx, [esp+70h+var_28]
	count += 4;

	memcpy( (void*)(CurAddr+count), "\x8A\x8E", 2 ); // mov     cl, [esi+___]
	count += 2;
	*((int*)(CurAddr+count)) = offset1;
	count += 4;

	memcpy( (void*)(CurAddr+count), "\x51", 1 ); // push    ecx
	count ++;

	// push offset fmtAddr
	*((unsigned char*)(CurAddr+count)) = 0x68;
	count ++;
	*((int*)(CurAddr+count)) = fmtAddr;
	count += 4;

	memcpy( (void*)(CurAddr+count), "\x52", 1 ); // push    edx
	count ++;

	// call    _sprintf
	*((unsigned char*)(CurAddr+count)) = 0xE8;
	count ++;
	*((int*)(CurAddr+count)) = sprintfAddr - (CurAddr+count+4);
	count += 4;

	memcpy( (void*)(CurAddr+count), "\x83\xC4\x10", 3 ); // add    esp, 10h
	count += 3;

	return count;
}

DWORD Sprintf2UV28( DWORD sprintfAddr, DWORD fmtAddr, DWORD CurAddr, int offset1, int offset2 )
{
	int count = 0;

	memcpy( (void*)(CurAddr+count), "\x33\xC0", 2 ); // xor     eax, eax
	count += 2;

	memcpy( (void*)(CurAddr+count), "\x66\x8B\x86", 3 ); // mov     ax, [esi+___]
	count += 3;
	*((int*)(CurAddr+count)) = offset2;
	count += 4;

	memcpy( (void*)(CurAddr+count), "\x50", 1 ); // push    eax
	count ++;

	memcpy( (void*)(CurAddr+count), "\x33\xC9", 2 ); // xor     ecx, ecx
	count += 2;

	memcpy( (void*)(CurAddr+count), "\x8D\x54\x24\x4C", 4 ); // lea     edx, [esp+70h+var_28]
	count += 4;

	memcpy( (void*)(CurAddr+count), "\x66\x8B\x8E", 3 ); // mov     cx, [esi+___]
	count += 3;
	*((int*)(CurAddr+count)) = offset1;
	count += 4;

	memcpy( (void*)(CurAddr+count), "\x51", 1 ); // push    ecx
	count ++;

	// push offset fmtAddr
	*((unsigned char*)(CurAddr+count)) = 0x68;
	count ++;
	*((int*)(CurAddr+count)) = fmtAddr;
	count += 4;

	memcpy( (void*)(CurAddr+count), "\x52", 1 ); // push    edx
	count ++;

	// call    _sprintf
	*((unsigned char*)(CurAddr+count)) = 0xE8;
	count ++;
	*((int*)(CurAddr+count)) = sprintfAddr - (CurAddr+count+4);
	count += 4;

	memcpy( (void*)(CurAddr+count), "\x83\xC4\x10", 3 ); // add    esp, 10h
	count += 3;

	return count;
}

/*#define STATCODE_BEG "\x8D\x54\x24\x48\x8B\xC3\x2B\xD3\x8A\x08\x88\x0C\x02\x40\x84\xC9\x75\xF6"
#define STATCODE_B_LEN 18
#define STATCODE_START_OFF (STATCODE_B_LEN+0x15)
#define STACK_OFFSET -3
#define STACK_BASE 0x28
*/
#define STATCODE_BEG "\x68\x86\x03\x00\x00\x6A\x01\x6A\x32\x6A\x28\xE8"
#define STATCODE_B_LEN 12
#define STATCODE_START_OFF (-0x1E)
#define STACK_OFFSET 6
#define STACK_BASE 0x28

#define STATCODE_END "\x51\x52\x68\x86\x03\x00\x00\x6A\x01\x68\x8F\x00\x00\x00\x00"
#define STATCODE_E_LEN 14
#define STATCODE_END_OFFSET 9

#define GUMP_STRING1 "\x53\x55\x8B\x6C\x24\x1C\x56\x57\x8B\xFD\x83\xC9\xFF\x33\xC0\xF2"
#define GS1_LEN 16
#define GS1_OFFSET 0x29

#define GID_REPL "\x6C\x2A\x00\x00"
#define GID_R_LEN 4

#define SPRINTF_STR "\x55\x8B\xEC\x83\xEC\x20\x8B\x45\x08\x56\x89\x45\xE8\x89\x45\xE0\x8D\x45\x10\xC7\x45\xEC\x42\x00\x00\x00\x50\x8D\x45\xE0\xFF\x75\x0C\xC7\x45\xE4\xFF\xFF\xFF\x7F\x50\xE8"
#define SPRINTF_LEN 42

#define LOCK_STR_1 "\x6A\x4E\x6A\x28"
#define LOCK_STR_2 "\x6A\x69\x6A\x28"
#define LOCK_STR_3 "\x68\x85\x00\x00\x00\x6A\x28"
#define LOCK_LEN_1 4
#define LOCK_LEN_2 4
#define LOCK_LEN_3 7

#define MIN_STR "\x68\xA8\x00\x00\x00\x68\x98\x01\x00\x00\x68\x92\x00\x00\x00\x68\x81\x01\x00\x00"
#define MIN_STR_LEN 20

vector<PatchInfo *> *PatchVec = NULL;
bool PatchStatusBar( BOOL preAOS )
{
	if ( !preAOS )
	{
		if ( PatchVec == NULL )
			return true;

		for(unsigned int i=0;i<PatchVec->size();i++)
		{
			PatchInfo *patch = (*PatchVec)[i];
			MemoryPatch( patch->Address, patch->Data, patch->Length );
			delete patch;
		}
		delete PatchVec;
		PatchVec = NULL;
		return true;
	}

	if ( PatchVec != NULL )
		return true;

	const unsigned int NewGumpID = 0x00000802;

	MemFinder mf;

	mf.AddEntry( GUMP_STRING1, GS1_LEN );
	mf.AddEntry( "%u/%u", 6 );
	mf.AddEntry( MIN_STR, MIN_STR_LEN );
	mf.AddEntry( STATCODE_BEG, STATCODE_B_LEN );
	mf.AddEntry( SPRINTF_STR, SPRINTF_LEN );
	mf.AddEntry( LOCK_STR_1, LOCK_LEN_1 );
	mf.AddEntry( GID_REPL, GID_R_LEN );

	mf.Execute();

	DWORD GumpString1 = mf.GetAddress( GUMP_STRING1, GS1_LEN );
	if ( !GumpString1 ) 
		return false;
	GumpString1 -= GS1_OFFSET;

	DWORD uuFmt = mf.GetAddress( "%u/%u", 6 );
	if ( !uuFmt ) 
		return false;
	DWORD uFmt = uuFmt + 3;

	DWORD MinLoc = mf.GetAddress( MIN_STR, MIN_STR_LEN );
	if ( !MinLoc ) 
		return false;
	MinLoc += 1;

	DWORD Start = mf.GetAddress( STATCODE_BEG, STATCODE_B_LEN );
	if ( !Start ) 
		return false;
	Start += STATCODE_START_OFF;

	DWORD End = Start;

	do {
		End = MemFinder::Find( STATCODE_END, STATCODE_E_LEN, End + 1 );
	} while ( End && *((unsigned char*)(End+STATCODE_E_LEN+1)) != 0xE8 );

	if ( !End )
		return false;

	End += STATCODE_E_LEN + STATCODE_END_OFFSET;

	DWORD sprintfAddr = mf.GetAddress( SPRINTF_STR, SPRINTF_LEN );
	DWORD LockLoc = mf.GetAddress( LOCK_STR_1, LOCK_LEN_1 );
	DWORD CurPos = mf.GetAddress( GID_REPL, GID_R_LEN );

	if ( !( sprintfAddr && LockLoc && CurPos ) )
		return false;

	PatchVec = new vector<PatchInfo*>();

	PatchVec->push_back( new PatchInfo( CurPos, 4 ) );
	MemoryPatch( CurPos, NewGumpID );
	CurPos = MemFinder::Find( GID_REPL, GID_R_LEN, CurPos+4 );
	if ( CurPos )
	{
		PatchVec->push_back( new PatchInfo( CurPos, 4 ) );
		MemoryPatch( CurPos, NewGumpID );
	}

	PatchVec->push_back( new PatchInfo( LockLoc+0x01, 1 ) );
	PatchVec->push_back( new PatchInfo( LockLoc+0x03, 1 ) );
	MemoryPatch( LockLoc+0x01, 0x3E, 1 );
	MemoryPatch( LockLoc+0x03, 0x26, 1 );

	LockLoc = MemFinder::Find( LOCK_STR_2, LOCK_LEN_2, LockLoc );
	if ( LockLoc )
	{
		PatchVec->push_back( new PatchInfo( LockLoc+0x01, 1 ) );
		PatchVec->push_back( new PatchInfo( LockLoc+0x03, 1 ) );
		MemoryPatch( LockLoc+0x01, 0x4A, 1 );
		MemoryPatch( LockLoc+0x03, 0x26, 1 );

		LockLoc = MemFinder::Find( LOCK_STR_3, LOCK_LEN_3, LockLoc );
		if ( LockLoc )
		{
			PatchVec->push_back( new PatchInfo( LockLoc+0x01, 4 ) );
			PatchVec->push_back( new PatchInfo( LockLoc+0x06, 1 ) );
			MemoryPatch( LockLoc+0x01, 0x56, 4 );
			MemoryPatch( LockLoc+0x06, 0x26, 1 );
		}
	}

	PatchVec->push_back( new PatchInfo( MinLoc+ 0, 4 ) );
	PatchVec->push_back( new PatchInfo( MinLoc+ 5, 4 ) );
	PatchVec->push_back( new PatchInfo( MinLoc+10, 4 ) );
	PatchVec->push_back( new PatchInfo( MinLoc+15, 4 ) );
	MemoryPatch( MinLoc+ 0, 137 );
	MemoryPatch( MinLoc+ 5, 263 );
	MemoryPatch( MinLoc+10, 111 );
	MemoryPatch( MinLoc+15, 239 );

	int len = End - Start;

	PatchVec->push_back( new PatchInfo( Start, len ) );

	DWORD OldProtect;
	if ( !VirtualProtect( (void *)(Start), len, PAGE_EXECUTE_READWRITE, &OldProtect ) )
		return false;

	CurPos = Start;

	int statOffset = *((unsigned char*)(Start + 0x31 + 0x18 + 3));
	int esiOffset = statOffset - 0xD4;
	int stackChange = STACK_BASE - *((unsigned char*)(Start + STACK_OFFSET));
	int twoFourOff = *((unsigned char*)(Start + 0x31 + 2)) - 0x24;

	bool client5 = false;
	char uuPush[5];
	uuPush[0] = 0x68;
	*((DWORD*)&uuPush[1]) = uuFmt;

	DWORD uuSP = MemFinder::Find( uuPush, 5, Start );
	if ( uuSP )
		client5 = ( *((int*)(uuSP - 10)) != (statOffset + 0x1F) );

	if ( stackChange != 0  )
	{
		memcpy( (void*)CurPos, "\x83\xC4", 2 ); // add    esp, __h
		CurPos += 2;
		*((char*)CurPos) = (char)stackChange;
		CurPos++;
	}

	if ( *((unsigned char*)(Start + 11)) != 0x46 ) // was reg is it in?
	{
		memcpy( (void*)CurPos, "\x8B\xF5", 2 ); // mov     esi, ebp
		CurPos += 2;
	}

	// name
	CurPos += GumpOutV28( GumpString1, esiOffset, twoFourOff, CurPos, 86, 53 );

	if ( stackChange != 0  )
	{
		memcpy( (void*)CurPos, "\x83\xC4", 2 ); // add    esp, __h
		CurPos += 2;
		*((char*)CurPos) = -stackChange;
		CurPos++;
	}

	memset( (void*)CurPos, 0x90, (Start+0x31) - CurPos );

	CurPos = Start + 0x31 + 0x12;

	if ( stackChange != 0  )
	{
		memcpy( (void*)CurPos, "\x83\xC4", 2 ); // add    esp, __h
		CurPos += 2;
		*((char*)CurPos) = (char)stackChange;
		CurPos++;
	}

	if ( *((unsigned char*)(Start + 11)) != 0x46 ) // was reg is it in?
	{
		memcpy( (void*)CurPos, "\x8B\xF5", 2 ); // mov     esi, ebp
		CurPos += 2;
	}

	// str
	CurPos += Sprintf1UV28( sprintfAddr, uFmt, CurPos, statOffset+0x00 );
	CurPos += GumpOutV28( GumpString1, esiOffset, twoFourOff, CurPos, 86, 72 );

	// dex
	CurPos += Sprintf1UV28( sprintfAddr, uFmt, CurPos, statOffset+0x02 );
	CurPos += GumpOutV28( GumpString1, esiOffset, twoFourOff, CurPos, 86, 84 );

	// int
	CurPos += Sprintf1UV28( sprintfAddr, uFmt, CurPos, statOffset+0x04 );
	CurPos += GumpOutV28( GumpString1, esiOffset, twoFourOff, CurPos, 86, 96 );

	// sex?
	//memcpy( (void*)(CurPos), "\xC7\x44\x24\x48Yes", 8 ); // mov     [esp+70h+var_28], __
	//CurPos += 8;
	//CurPos += GumpOutV28( GumpString1, esiOffset, twoFourOff, CurPos, 86, 108 );

	// followers:
	if ( client5 )
	{
		CurPos += Sprintf2UV28_Byte( sprintfAddr, uuFmt, CurPos, statOffset+2+0x1E, statOffset+2+0x1F );
		CurPos += GumpOutV28( GumpString1, esiOffset, twoFourOff, CurPos, 86, 108 );
	}
	else
	{
		CurPos += Sprintf2UV28_Byte( sprintfAddr, uuFmt, CurPos, statOffset+0x1E, statOffset+0x1F );
		CurPos += GumpOutV28( GumpString1, esiOffset, twoFourOff, CurPos, 86, 108 );
	}

	// AR
	if ( client5 )
		CurPos += Sprintf1UV28( sprintfAddr, uFmt, CurPos, statOffset+0x1C );
	else
		CurPos += Sprintf1UV28( sprintfAddr, uFmt, CurPos, statOffset+0x1A );

	CurPos += GumpOutV28( GumpString1, esiOffset, twoFourOff, CurPos, 86, 120 );

	// hits
	CurPos += Sprintf2UV28( sprintfAddr, uuFmt, CurPos, statOffset+0x06, statOffset+0x08 );
	CurPos += GumpOutV28( GumpString1, esiOffset, twoFourOff, CurPos, 174, 72 );

	// stam
	CurPos += Sprintf2UV28( sprintfAddr, uuFmt, CurPos, statOffset+0x0A, statOffset+0x0C );
	CurPos += GumpOutV28( GumpString1, esiOffset, twoFourOff, CurPos, 174, 96 );

	// mana
	CurPos += Sprintf2UV28( sprintfAddr, uuFmt, CurPos, statOffset+0x0E, statOffset+0x10 );
	CurPos += GumpOutV28( GumpString1, esiOffset, twoFourOff, CurPos, 174, 84 );

	// gold
	CurPos += Sprintf1UV28( sprintfAddr, uFmt, CurPos, statOffset+0x14 );
	CurPos += GumpOutV28( GumpString1, esiOffset, twoFourOff, CurPos, 174, 108 );

	if ( client5 )
	{
		CurPos += Sprintf2UV28( sprintfAddr, uuFmt, CurPos, statOffset+0x18, statOffset+0x1A );
		CurPos += GumpOutV28( GumpString1, esiOffset, twoFourOff, CurPos, 174, 120 );
	}
	else
	{
		// Weight:
		memcpy( (void*)CurPos, "\x33\xC9", 2 ); // xor     ecx, ecx
		CurPos += 2;
		memcpy( (void*)CurPos, "\x66\x8B\x8E", 3 ); // mov     cx, [esi+___]
		CurPos += 3;
		*((int*)CurPos) = statOffset+0x00; // str
		CurPos += 4;
		memcpy( (void*)CurPos, "\x8D\x04\xCD\x00\x00\x00\x00\x2B\xC1\x99\x2B\xC2\xD1\xF8\x83\xC0\x28", 17 ); // eax = ecx*3.5 + 40
		CurPos += 17;
		memcpy( (void*)CurPos, "\x50", 1 ); // push    eax
		CurPos ++;

		memcpy( (void*)CurPos, "\x33\xC9", 2 ); // xor     ecx, ecx
		CurPos += 2;
		memcpy( (void*)CurPos, "\x8D\x54\x24\x4C", 4 ); // lea     edx, [esp+74h+var_28]
		CurPos += 4;
		memcpy( (void*)CurPos, "\x66\x8B\x8E", 3 ); // mov     cx, [esi+___]
		CurPos += 3;
		*((int*)CurPos) = statOffset+0x18; // weight
		CurPos += 4;
		memcpy( (void*)CurPos, "\x51", 1 ); // push    ecx
		CurPos ++;

		// push offset fmtAddr
		*((unsigned char*)CurPos) = 0x68;
		CurPos ++;
		*((int*)CurPos) = uuFmt;
		CurPos += 4;

		memcpy( (void*)CurPos, "\x52", 1 ); // push    edx
		CurPos ++;

		// call    _sprintf
		*((unsigned char*)CurPos) = 0xE8;
		CurPos ++;
		*((int*)CurPos) = sprintfAddr - (CurPos+4);
		CurPos += 4;

		memcpy( (void*)CurPos, "\x83\xC4\x10", 3 ); // add    esp, 10h
		CurPos += 3;

		CurPos += GumpOutV28( GumpString1, esiOffset, twoFourOff, CurPos, 174, 120 );
	}

	if ( stackChange != 0  )
	{
		memcpy( (void*)CurPos, "\x83\xC4", 2 ); // add    esp, __h
		CurPos += 2;
		*((char*)CurPos) = -stackChange;
		CurPos++;
	}

	memset( (void*)CurPos, 0x90, End-CurPos );

	VirtualProtect( (void *)(Start), len, OldProtect, &OldProtect );

	return true;
}



================================================
FILE: Crypt/PacketInfo.cpp
================================================
#include "stdafx.h"
#include "Crypt.h"

#include "PacketInfo.h"

DLLFUNCTION int GetPacketLength( unsigned char *packet, int len )
{
	if ( pShared != NULL )
	{
		int packetLen = pShared->PacketTable[(unsigned char)packet[0]];

		if ( packetLen >= 0x4000 )
		{
			if ( len < 3 )
				return 0;
			else
				return packet[1]<<8 | packet[2];
		}
		else
		{
			return packetLen;
		}
	}
	else if ( len >= 3 )
	{
		//attempt to auto detect an undefined packet
		return packet[1]<<8 | packet[2];
	}
	else
	{
		return -1;
	}
}

DLLFUNCTION bool IsDynLength( BYTE packet )
{
	if ( pShared != NULL )
		return pShared->PacketTable[packet] >= 0x8000;
	else
		return true;
}


================================================
FILE: Crypt/PacketInfo.h
================================================
#pragma once
#pragma pack(1)

struct ClientPacketInfo // 12 bytes
{
	int Id;
	int Unk;
	unsigned short Length;
	short Unk0000;
};

const unsigned short StaticPacketTable[] =
{
	0x0068, // 0x00
	0x0005, // 0x01
	0x0007, // 0x02
	0x8000, // 0x03
	0x0002, // 0x04
	0x0005, // 0x05
	0x0005, // 0x06
	0x0007, // 0x07
	0x000F, // 0x08
	0x0005, // 0x09
	0x000B, // 0x0A
	0x0007, // 0x0B
	0x8000, // 0x0C
	0x0003, // 0x0D
	0x8000, // 0x0E
	0x003D, // 0x0F
	0x00D7, // 0x10
	0x8000, // 0x11
	0x8000, // 0x12
	0x000A, // 0x13
	0x0006, // 0x14
	0x0009, // 0x15
	0x8000, // 0x16
	0x8000, // 0x17
	0x8000, // 0x18
	0x8000, // 0x19
	0x8000, // 0x1A
	0x0025, // 0x1B
	0x8000, // 0x1C
	0x0005, // 0x1D
	0x0004, // 0x1E
	0x0008, // 0x1F
	0x0013, // 0x20
	0x0008, // 0x21
	0x0003, // 0x22
	0x001A, // 0x23
	0x0007, // 0x24
	0x0015, // 0x25
	0x0005, // 0x26
	0x0002, // 0x27
	0x0005, // 0x28
	0x0001, // 0x29
	0x0005, // 0x2A
	0x0002, // 0x2B
	0x0002, // 0x2C
	0x0011, // 0x2D
	0x000F, // 0x2E
	0x000A, // 0x2F
	0x0005, // 0x30
	0x8000, // 0x31
	0x0002, // 0x32
	0x0002, // 0x33
	0x000A, // 0x34
	0x028D, // 0x35
	0x8000, // 0x36
	0x0008, // 0x37
	0x0007, // 0x38
	0x0009, // 0x39
	0x8000, // 0x3A
	0x8000, // 0x3B
	0x8000, // 0x3C
	0x0002, // 0x3D
	0x0025, // 0x3E
	0x8000, // 0x3F
	0x00C9, // 0x40
	0x8000, // 0x41
	0x8000, // 0x42
	0x0229, // 0x43
	0x02C9, // 0x44
	0x0005, // 0x45
	0x8000, // 0x46
	0x000B, // 0x47
	0x0049, // 0x48
	0x005D, // 0x49
	0x0005, // 0x4A
	0x0009, // 0x4B
	0x8000, // 0x4C
	0x8000, // 0x4D
	0x0006, // 0x4E
	0x0002, // 0x4F
	0x8000, // 0x50
	0x8000, // 0x51
	0x8000, // 0x52
	0x0002, // 0x53
	0x000C, // 0x54
	0x0001, // 0x55
	0x000B, // 0x56
	0x006E, // 0x57
	0x006A, // 0x58
	0x8000, // 0x59
	0x8000, // 0x5A
	0x0004, // 0x5B
	0x0002, // 0x5C
	0x0049, // 0x5D
	0x8000, // 0x5E
	0x0031, // 0x5F
	0x0005, // 0x60
	0x0009, // 0x61
	0x000F, // 0x62
	0x000D, // 0x63
	0x0001, // 0x64
	0x0004, // 0x65
	0x8000, // 0x66
	0x0015, // 0x67
	0x8000, // 0x68
	0x8000, // 0x69
	0x0003, // 0x6A
	0x0009, // 0x6B
	0x0013, // 0x6C
	0x0003, // 0x6D
	0x000E, // 0x6E
	0x8000, // 0x6F
	0x001C, // 0x70
	0x8000, // 0x71
	0x0005, // 0x72
	0x0002, // 0x73
	0x8000, // 0x74
	0x0023, // 0x75
	0x0010, // 0x76
	0x0011, // 0x77
	0x8000, // 0x78
	0x0009, // 0x79
	0x8000, // 0x7A
	0x0002, // 0x7B
	0x8000, // 0x7C
	0x000D, // 0x7D
	0x0002, // 0x7E
	0x8000, // 0x7F
	0x003E, // 0x80
	0x8000, // 0x81
	0x0002, // 0x82
	0x0027, // 0x83
	0x0045, // 0x84
	0x0002, // 0x85
	0x8000, // 0x86
	0x8000, // 0x87
	0x0042, // 0x88
	0x8000, // 0x89
	0x8000, // 0x8A
	0x8000, // 0x8B
	0x000B, // 0x8C
	0x8000, // 0x8D
	0x8000, // 0x8E
	0x8000, // 0x8F
	0x0013, // 0x90
	0x0041, // 0x91
	0x8000, // 0x92
	0x0063, // 0x93
	0x8000, // 0x94
	0x0009, // 0x95
	0x8000, // 0x96
	0x0002, // 0x97
	0x8000, // 0x98
	0x001A, // 0x99
	0x8000, // 0x9A
	0x0102, // 0x9B
	0x0135, // 0x9C
	0x0033, // 0x9D
	0x8000, // 0x9E
	0x8000, // 0x9F
	0x0003, // 0xA0
	0x0009, // 0xA1
	0x0009, // 0xA2
	0x0009, // 0xA3
	0x0095, // 0xA4
	0x8000, // 0xA5
	0x8000, // 0xA6
	0x0004, // 0xA7
	0x8000, // 0xA8
	0x8000, // 0xA9
	0x0005, // 0xAA
	0x8000, // 0xAB
	0x8000, // 0xAC
	0x8000, // 0xAD
	0x8000, // 0xAE
	0x000D, // 0xAF
	0x8000, // 0xB0
	0x8000, // 0xB1
	0x8000, // 0xB2
	0x8000, // 0xB3
	0x8000, // 0xB4
	0x0040, // 0xB5
	0x0009, // 0xB6
	0x8000, // 0xB7
	0x8000, // 0xB8
	0x0005, // 0xB9
	0x0006, // 0xBA
	0x0009, // 0xBB
	0x0003, // 0xBC
	0x8000, // 0xBD
	0x8000, // 0xBE
	0x8000, // 0xBF
	0x0024, // 0xC0
	0x8000, // 0xC1
	0x8000, // 0xC2
	0x8000, // 0xC3
	0x0006, // 0xC4
	0x00CB, // 0xC5
	0x0001, // 0xC6
	0x0031, // 0xC7
	0x0002, // 0xC8
	0x0006, // 0xC9
	0x0006, // 0xCA
	0x0007, // 0xCB
	0x8000, // 0xCC
	0x0001, // 0xCD
	0x8000, // 0xCE
	0x004E, // 0xCF
	0x8000, // 0xD0
	0x0002, // 0xD1
	0x0019, // 0xD2
	0x8000, // 0xD3
	0x8000, // 0xD4
	0x8000, // 0xD5
	0x8000, // 0xD6
	0x8000, // 0xD7
	0x8000, // 0xD8
	0x010C, // 0xD9
	0x8000, // 0xDA
	0x8000, // 0xDB
	0x0009, // 0xDC
	0x8000, // 0xDD
	0x8000, // 0xDE
	0x8000, // 0xDF
	0x8000, // 0xE0 
	0x8000, // 0xE1
	0x000A, // 0xE2
	0x8000, // 0xE3
	0x8000, // 0xE4
	0x8000, // 0xE5
	0x0005, // 0xE6
	0x000C, // 0xE7
	0x000D, // 0xE8
	0x004B, // 0xE9
	0x0003, // 0xEA
	0x8000, // 0xEB
	0x8000, // 0xEC
	0x8000, // 0xED
	0x8000, // 0xEE
	0x0015, // 0xEF
	0x8000, // 0xF0
	0x8000, // 0xF1
	0x8000, // 0xF2
	0x0018, // 0xF3
	0x8000, // 0xF4
	0x0015, // 0xF5
	0x8000, // 0xF6
	0x8000, // 0xF7
	0x006A, // 0xF8
	0x8000, // 0xF9
	0x8000, // 0xFA
	0x8000, // 0xFB
	0x8000, // 0xFC
	0x8000, // 0xFD
	0x0008, // 0xFE
	0x8000, // 0xFF
};

================================================
FILE: Crypt/UOArt.cpp
================================================
#include "stdafx.h"
#include "Crypt.h"
#include "Resource.h"
#include <uxtheme.h>
#include <vssym32.h>
#include <dwmapi.h>

#define Color16to32(c16) (((c16) & 0x7C00) >> 7) | (((c16) & 0x3E0) << 6) | (((c16) & 0x1F) << 19)

struct UOItem
{
    int RealWidth;
    int RealHeight;

    int Left;
    int Top;
    int Bottom;
    int Right;

    int GetWidth() const { return Right - Left; }
    int GetHeight() const { return Bottom - Top; }

    unsigned short **Data; // [ReadlWidth][RealHeight] 32bit color data

    int ItemID;
    UOItem *pNext;
};

struct ArtIdx
{
    long FilePos;
    long Length;
    long Unused;
};

struct ArtHeader
{
    long Unknown;
    short Width;
    short Height;
    //followed by short LookupTable
};

UOItem *ArtCache = NULL;
unsigned short **Hues = NULL;
int NumHues = 0;

inline int Round(float n)
{
	int i = (int)n;
	return i + (n - i >= 0.5 ? 1 : 0);
}

unsigned short *GetHue(int index)
{
	if (Hues == NULL)
	{
		if (!pShared)
			return NULL;

		char str[512];
		int length, blockCount, index;
		FILE *huesMul = NULL;

		WaitForSingleObject(CommMutex, INFINITE);
		sprintf(str, "%s/hues.mul", pShared->DataPath);
		ReleaseMutex(CommMutex);

		huesMul = fopen(str, "rb");
		if (!huesMul)
		{
			Hues = new unsigned short *[1];
			Hues[0] = new unsigned short[34];
			memset(Hues[0], 0, 34 * 2);
			NumHues = 1;
			return NULL;
		}

		fseek(huesMul, 0, SEEK_END);
		length = (int)ftell(huesMul);
		fseek(huesMul, 0, SEEK_SET);
		blockCount = length / 708;
		if (blockCount > 375)
			blockCount = 375;
		NumHues = blockCount * 8;

		Hues = new unsigned short *[NumHues];

		index = 0;
		for (int b = 0; b < blockCount; b++)
		{
			fseek(huesMul, 4, SEEK_CUR);

			for (int i = 0; i < 8; i++, index++)
			{
				Hues[index] = new unsigned short[34];
				for (int c = 0; c < 34; c++)
				{
					unsigned short color;
					fread(&color, 2, 1, huesMul);
					Hues[index][c] = color | 0x8000;
				}

				fseek(huesMul, 20, SEEK_CUR); // ignore name
			}
		}
		fclose(huesMul);
	}

	if (index > 0 && index <= NumHues)
		return Hues[index - 1];
	else
		return NULL;
}

unsigned short ApplyHueToPixel(unsigned short *hue, unsigned short pix)
{
	if (hue)
		return hue[(pix >> 10) & 31];
	else
		return pix;
}

UOItem *ReadUOItem(int item, int bh)
{
	if (item == 0 || item >= 0xFFFF || !pShared)
		return NULL;

	char str[512];
	short *Lookup;
	unsigned short *Run;

	FILE *idxMul, *artMul;
	ArtIdx idx;
	ArtHeader header;
	memset(&header, 0, sizeof(ArtHeader));

	WaitForSingleObject(CommMutex, INFINITE);
	sprintf(str, "%s/artidx.mul", pShared->DataPath);
	ReleaseMutex(CommMutex);

	idxMul = fopen(str, "rb");
	if (!idxMul)
		return NULL;
	fseek(idxMul, item * sizeof(ArtIdx), SEEK_SET);
	fread(&idx, sizeof(ArtIdx), 1, idxMul);
	fclose(idxMul);
	if (idx.FilePos == -1 || idx.Length == -1)
		return NULL;

	WaitForSingleObject(CommMutex, INFINITE);
	sprintf(str, "%s/art.mul", pShared->DataPath);
	ReleaseMutex(CommMutex);

	artMul = fopen(str, "rb");
	if (!artMul)
	{
		fclose(idxMul);
		return NULL;
	}
	fseek(artMul, idx.FilePos, SEEK_SET);
	fread(&header, sizeof(ArtHeader), 1, artMul);
	if (header.Height <= 0 || header.Width <= 0 || header.Height >= 1024 || header.Width >= 1024 || header.Unknown > 0xFFFF || header.Unknown == 0)
	{
		fclose(artMul);
		return NULL;
	}

	Run = new unsigned short[header.Width]; // it should never be wider than the whole image!
	Lookup = new short[header.Height];
	fread(Lookup, header.Height * 2, 1, artMul);
	long dataStart = ftell(artMul);

	UOItem *pNew = new UOItem;
	pNew->ItemID = item;
	pNew->pNext = ArtCache;
	ArtCache = pNew;

	unsigned short **Image = new unsigned short *[header.Width];
	for (int i = 0; i < header.Width; i++)
	{
		Image[i] = new unsigned short[header.Height];
		memset(Image[i], 0, header.Height * 2);
	}

	pNew->Left = pNew->Top = 0x7FFFFFFF;
	pNew->Right = pNew->Bottom = 0;
	for (int y = 0; y < header.Height; y++)
	{
		int x = 0;

		fseek(artMul, dataStart + Lookup[y] * 2, SEEK_SET);
		do
		{
			short RunOffset = 0, RunLength = 0;

			fread(&RunOffset, 2, 1, artMul);
			fread(&RunLength, 2, 1, artMul);

			if (RunLength <= 0 || RunOffset < 0 || RunOffset + RunLength >= 2048 || RunLength > header.Width)
				break;

			if (y > pNew->Bottom)
				pNew->Bottom = y;
			if (y < pNew->Top)
				pNew->Top = y;

			x += RunOffset;
			if (x < pNew->Left)
				pNew->Left = x;

			fread(Run, RunLength * 2, 1, artMul);
			for (int o = 0; o < RunLength; o++, x++)
				Image[x][y] = Run[o];

			if (x > pNew->Right)
				pNew->Right = x;
		} while (true);
	}
	fclose(artMul);

	delete[] Run;
	delete[] Lookup;

	float scale = float(bh) / float(pNew->GetHeight());
	if (scale > 1 || scale <= 0)
		scale = 1;

	pNew->RealHeight = (int)(header.Height * scale + 1);
	pNew->RealWidth = (int)(header.Width * scale + 1);
	pNew->Data = new unsigned short *[pNew->RealWidth];
	for (int x = 0; x < pNew->RealWidth; x++)
	{
		pNew->Data[x] = new unsigned short[pNew->RealHeight];
		memset(pNew->Data[x], 0, 2 * pNew->RealHeight);
	}

	for (int x = 0; x < header.Width; x++)
	{
		for (int y = 0; y < header.Height; y++)
			pNew->Data[(int)(x * scale)][(int)(y * scale)] |= Image[x][y];
	}

	pNew->Top = (int)(pNew->Top * scale);
	pNew->Left = (int)(pNew->Left * scale);
	pNew->Bottom = (int)(pNew->Bottom * scale);
	pNew->Right = (int)(pNew->Right * scale);

	for (int x = 0; x < header.Width; x++)
		delete[] Image[x];
	delete[] Image;

	return pNew;
}

UOItem *FindItem(int item)
{
	UOItem *node = ArtCache;
	while (node != NULL)
	{
		if (node->ItemID == item)
			return node;
		else
			node = node->pNext;
	}

	return NULL;
}

inline COLORREF Brightness(int shift, COLORREF c)
{
	return RGB(min(255, GetRValue(c) + shift), min(255, GetGValue(c) + shift), min(255, GetBValue(c) + shift));
}

int DrawUOItem(HDC hDC, RECT rect, int item, int hueIdx)
{
	item |= 0x4000;

	rect.top++;
	rect.bottom--;
	int maxHeight = rect.bottom - rect.top;

	UOItem *i = FindItem(item);
	if (i == NULL)
		i = ReadUOItem(item, maxHeight);

	if (i == NULL)
		return 0;

	if (i->GetHeight() < maxHeight)
		rect.top += (maxHeight - i->GetHeight()) / 2;

	unsigned short *hue = GetHue(hueIdx);
	for (int x = i->Left; x <= i->Right; x++)
	{
		for (int y = i->Top; y <= i->Bottom; y++)
		{
			if (i->Data[x][y] != 0)
				SetPixel(hDC, rect.left + x - i->Left, rect.top + y - i->Top, Brightness(0x30, Color16to32(ApplyHueToPixel(hue, i->Data[x][y]))));
		}
	}

	return i->GetWidth() + 3;
}

void FreeItem(UOItem *node)
{
	if (node != NULL)
	{
		FreeItem(node->pNext);
		for (int i = 0; i < node->RealWidth; i++)
			delete[] node->Data[i];
		delete[] node->Data;
		delete node;
	}
}

void FreeArt()
{
	FreeItem(ArtCache);
	if (Hues && NumHues > 0)
	{
		for (int i = 0; i < NumHues; i++)
			delete[] Hues[i];
		delete[] Hues;
	}
}

int DrawUOItem(HDC, RECT, int, int);

typedef HTHEME(__stdcall *OPENTHEMEDATA)(HWND, LPCWSTR);
OPENTHEMEDATA zOpenThemeData = NULL;
typedef HRESULT(__stdcall *DRAWTHEMEBACKGROUND)(HTHEME, HDC, int, int, const RECT *, OPTIONAL const RECT *);
DRAWTHEMEBACKGROUND zDrawThemeBackground = NULL;
typedef HRESULT(__stdcall *CLOSETHEMEDATA)(HTHEME);
CLOSETHEMEDATA zCloseThemeData = NULL;
typedef HRESULT(__stdcall *GETTHEMESYSFONT)(HTHEME, int, OUT LOGFONTW *);
GETTHEMESYSFONT zGetThemeSysFont = NULL;
typedef COLORREF(__stdcall *GETTHEMESYSCOLOR)(HTHEME, int);
GETTHEMESYSCOLOR zGetThemeSysColor = NULL;
typedef HRESULT(__stdcall *GETTHEMEMETRIC)(HTHEME, HDC, int, int, int, int *);
GETTHEMEMETRIC zGetThemeMetric = NULL;
typedef HRESULT(__stdcall *DWMSETWINDOWATTRIBUTE)(HWND, DWORD, LPCVOID, DWORD);
DWMSETWINDOWATTRIBUTE zDwmSetWindowAttribute = NULL;
HMODULE hThemes = NULL;
HMODULE hDwmApi = NULL;

void InitThemes()
{
	hThemes = LoadLibrary("UXTHEME.DLL");
	if (hThemes)
	{
		zOpenThemeData = (OPENTHEMEDATA)GetProcAddress(hThemes, "OpenThemeData");
		zDrawThemeBackground = (DRAWTHEMEBACKGROUND)GetProcAddress(hThemes, "DrawThemeBackground");
		zCloseThemeData = (CLOSETHEMEDATA)GetProcAddress(hThemes, "CloseThemeData");
		zGetThemeSysColor = (GETTHEMESYSCOLOR)GetProcAddress(hThemes, "GetThemeSysColor");
		zGetThemeSysFont = (GETTHEMESYSFONT)GetProcAddress(hThemes, "GetThemeSysFont");
		zGetThemeMetric = (GETTHEMEMETRIC)GetProcAddress(hThemes, "GetThemeMetric");
	}

	hDwmApi = LoadLibrary("DWMAPI.DLL");
	if (hDwmApi)
	{
		zDwmSetWindowAttribute = (DWMSETWINDOWATTRIBUTE)GetProcAddress(hDwmApi, "DwmSetWindowAttribute");
	}
}

inline int GetHex2(LPCSTR hex)
{
	int num = 0;
	if (!isxdigit(hex[0]) || !isxdigit(hex[1]))
		return -1;

	num = isdigit(hex[1]) ? (hex[1] - '0') : (tolower(hex[1]) - 'a' + 10);
	num += (isdigit(hex[0]) ? (hex[0] - '0') : (tolower(hex[0]) - 'a' + 10)) * 16;

	return num;
}

inline int GetHex4(LPCSTR hex)
{
	return (GetHex2(hex) << 8) | GetHex2(&hex[2]);
}

void DoStat(HDC hDC, int v, int t, int l, int h, int w)
{
	if (w <= 0)
		return;
	RECT fill;
	fill.top = t;
	fill.left = l;
	fill.bottom = t + h;
	fill.right = l + w;
	HBRUSH hBr = NULL;

	if (v == 0xFF)                                //poisoned
		hBr = CreateSolidBrush(RGB(255, 128, 0)); // orange
	else if (v <= 25)
		hBr = CreateSolidBrush(RGB(255, 0, 0)); // red
	else if (v <= 75)
		hBr = CreateSolidBrush(RGB(255, 255, 0)); // yellow
	else
		hBr = CreateSolidBrush(RGB(0, 255, 0)); // green

	FillRect(hDC, &fill, hBr);
	DeleteObject(hBr);
}

int DrawStatBar(HDC hDC, RECT rect, int width, int status, int hp, int mn, int st)
{
	HGDIOBJ hOld = NULL;
	POINT pt[2];
	rect.right = rect.left + width + 2;

	int o = (rect.bottom - rect.top - 20) / 2;
	if (o > 0)
		rect.top += o;
	rect.bottom = rect.top + 6 + 6 + 6 + 1;

	hOld = SelectObject(hDC, GetStockObject(BLACK_PEN));
	FrameRect(hDC, &rect, (HBRUSH)GetStockObject(BLACK_BRUSH));

	pt[0].x = rect.left;
	pt[1].x = rect.right;

	pt[0].y = rect.top + 6;
	pt[1].y = rect.top + 6;
	Polyline(hDC, pt, 2);

	pt[0].y = rect.top + 6 + 6;
	pt[1].y = rect.top + 6 + 6;
	Polyline(hDC, pt, 2);

	if (status == 1) // poisoned
		DoStat(hDC, 0xFF, rect.top + 1, rect.left + 1, 5, (int)((double(hp + 1) / 100.0) * width));
	else
		DoStat(hDC, hp, rect.top + 1, rect.left + 1, 5, (int)((double(hp + 1) / 100.0) * width));

	DoStat(hDC, mn, rect.top + 1 + 6, rect.left + 1, 5, (int)((double(mn + 1) / 100) * width));
	DoStat(hDC, st, rect.top + 2 + 6 + 5, rect.left + 1, 5, (int)((double(st + 1) / 100) * width));

	SelectObject(hDC, hOld);
	return width + 2;
}

void CheckTitlebarAttr(HWND hWnd)
{
	static bool curNCRP = true;
	bool newNCRP = !pShared || pShared->TitleBar[0] == '\0';

	if (curNCRP != newNCRP && zDwmSetWindowAttribute)
	{
		DWMNCRENDERINGPOLICY policy = newNCRP ? DWMNCRP_ENABLED : DWMNCRP_DISABLED;
		zDwmSetWindowAttribute(hWnd, DWMWA_NCRENDERING_POLICY, &policy, sizeof(policy));
		curNCRP = newNCRP;
	}
}

void DrawColorTitleBar(HTHEME hTheme, HWND hWnd, HDC hOutDC, bool active, bool maximized, LPCSTR str, int len, RECT orig)
{
	const COLORREF def = GetSysColor(active ? COLOR_CAPTIONTEXT : COLOR_INACTIVECAPTIONTEXT);
	COLORREF color = def;

	RECT rect;
	RECT window;
	GetWindowRect(hWnd, &window);
	rect.left = rect.top = 0;
	rect.right = window.right - window.left;
	rect.bottom = (orig.bottom - orig.top);

	HDC hDC = CreateCompatibleDC(hOutDC);
	HBITMAP hBmp = CreateCompatibleBitmap(hOutDC, rect.right, rect.bottom);
	SelectObject(hDC, hBmp);

	bool needRegFill = true;
	HFONT hFont = NULL;

	if (hThemes)
	{
		LOGFONTW lf;

		if (maximized)
		{
			needRegFill = zDrawThemeBackground(hTheme, hDC, WP_MAXCAPTION, active ? MXCS_ACTIVE : MXCS_INACTIVE, &rect, NULL) != S_OK;
		}
		else
		{
			int modTop = GetSystemMetrics(SM_CYFRAME);
			rect.top -= modTop;
			needRegFill = zDrawThemeBackground(hTheme, hDC, WP_CAPTION, active ? CS_ACTIVE : CS_INACTIVE, &rect, NULL) != S_OK;
			rect.top += modTop;
		}

		if (zGetThemeSysFont(hTheme, TMT_CAPTIONFONT, &lf) == S_OK)
		{
			hFont = CreateFontIndirectW(&lf);
			SelectObject(hDC, hFont);
		}
	}

	if (needRegFill)
		FillRect(hDC, &rect, GetSysColorBrush(active ? COLOR_ACTIVECAPTION : COLOR_INACTIVECAPTION));

	if (hFont == NULL)
		SelectObject(hDC, GetStockObject(ANSI_VAR_FONT));

	rect.left = orig.left;

	int start = 0;
	int dlen = 0;
	int t;
	SetBkMode(hDC, TRANSPARENT);
	for (int i = 0; i < len; i++)
	{
		if (rect.left >= rect.right)
			break;

		if (str[i] == '~')
		{
			switch (str[i + 1])
			{
			case '#':
				if (dlen > 0)
				{
					SetTextColor(hDC, color);
					DrawText(hDC, &str[start], dlen, &rect, DT_LEFT | DT_VCENTER | DT_SINGLELINE);
					SIZE ext;
					GetTextExtentPoint32(hDC, &str[start], dlen, &ext);
					rect.left += ext.cx;
				}
				dlen = 0;

				if (str[i + 2] == '~')
				{
					color = def;
					SetBkMode(hDC, TRANSPARENT);
					start = i + 3;
					i += 2;
				}
				else
				{
					color = RGB(GetHex2(&str[i + 2]), GetHex2(&str[i + 4]), GetHex2(&str[i + 6]));
					start = i + 8;
					i += 7;
				}

				break;
			case 'S':
			case 's':
				// ~SSFRRGGBB
				if (dlen > 0)
				{
					SetTextColor(hDC, color);
					DrawText(hDC, &str[start], dlen, &rect, DT_LEFT | DT_VCENTER | DT_SINGLELINE);
					SIZE ext;
					GetTextExtentPoint32(hDC, &str[start], dlen, &ext);
					rect.left += ext.cx;
				}
				dlen = 0;

				t = 30;
				switch (toupper(str[i + 2]))
				{
				case 'S':
					t = 15;
					break;
					//case 'R': w = 30; break;
				case 'M':
					t = 45;
					break;
				case 'L':
					t = 60;
					break;
				case 'X':
					t = 75;
					break;
				}

				rect.left += 1;
				rect.left += DrawStatBar(hDC, rect, t, str[i + 3] - '0', GetHex2(&str[i + 4]), GetHex2(&str[i + 6]), GetHex2(&str[i + 8]));
				rect.left += 1;

				start = i + 10;
				i += 9;

				break;
			case 'I':
			case 'i':
				if (dlen > 0)
				{
					SetTextColor(hDC, color);
					DrawText(hDC, &str[start], dlen, &rect, DT_LEFT | DT_VCENTER | DT_SINGLELINE);
					SIZE ext;
					GetTextExtentPoint32(hDC, &str[start], dlen, &ext);
					rect.left += ext.cx;
				}
				dlen = 0;
				if (str[i + 6] == '~')
				{
					rect.left += DrawUOItem(hDC, rect, GetHex4(&str[i + 2]), 0);
					start = i + 7;
					i += 6;
				}
				else
				{
					rect.left += DrawUOItem(hDC, rect, GetHex4(&str[i + 2]), GetHex4(&str[i + 6]));
					start = i + 10;
					i += 9;
				}
				break;
			case '^':
				if (dlen > 0)
				{
					SetTextColor(hDC, color);
					DrawText(hDC, &str[start], dlen, &rect, DT_LEFT | DT_VCENTER | DT_SINGLELINE);
					SIZE ext;
					GetTextExtentPoint32(hDC, &str[start], dlen, &ext);
					rect.left += ext.cx;
				}
				dlen = 0;

				color = RGB(0, 0, 0);
				SetBkMode(hDC, OPAQUE);
				SetBkColor(hDC, RGB(GetHex2(&str[i + 2]), GetHex2(&str[i + 4]), GetHex2(&str[i + 6])));

				start = i + 8;
				i += 7;
				break;
			case 'B':
			case 'b': // skip bold identifier
				i++;
				break;
			}
		}
		else
		{
			dlen++;
		}
	}

	if (dlen > 0)
	{
		SetTextColor(hDC, color);
		DrawText(hDC, &str[start], dlen, &rect, DT_LEFT | DT_VCENTER | DT_SINGLELINE);
	}

	BitBlt(hOutDC, orig.left, orig.top, (orig.right - orig.left), (orig.bottom - orig.top) - 1, hDC, orig.left, 0, SRCCOPY);
	DeleteDC(hDC);
	DeleteObject(hBmp);
	if (hFont)
		DeleteObject(hFont);
}

void RedrawTitleBar(HWND hWnd, bool active)
{
	if (!pShared)
		return;

	WaitForSingleObject(CommMutex, INFINITE);
	if (pShared->TitleBar[0] == 0)
	{
		ReleaseMutex(CommMutex);
		return;
	}

	int len = (int)strlen(pShared->TitleBar);
	if (len >= 1024)
		len = 1023;

	WINDOWPLACEMENT place;
	RECT rect;
	HDC hDC = GetWindowDC(hWnd); //WINDOW dc allows us to draw on the non client area

	GetWindowPlacement(hWnd, &place);
	GetWindowRect(hWnd, &rect);

	// Change the coords (believe me, okay?)
	rect.top = GetSystemMetrics(SM_CYFRAME);
	rect.bottom = rect.top + GetSystemMetrics(SM_CYCAPTION);

	rect.right = (rect.right - rect.left) - (4 * GetSystemMetrics(SM_CXSIZE) + GetSystemMetrics(SM_CXFRAME));
	rect.left = GetSystemMetrics(SM_CXSIZEFRAME) + GetSystemMetrics(SM_CXSMICON) + 5;

	if (hThemes)
	{
		HTHEME hTheme = zOpenThemeData(hWnd, L"WINDOW");
		DrawColorTitleBar(hTheme, hWnd, hDC, active, place.showCmd == SW_MAXIMIZE, pShared->TitleBar, len, rect);
		zCloseThemeData(hTheme);
	}
	else
	{
		rect.left += GetSystemMetrics(SM_CXFRAME);
		DrawColorTitleBar(NULL, hWnd, hDC, active, place.showCmd == SW_MAXIMIZE, pShared->TitleBar, len, rect);
	}

	ReleaseDC(hWnd, hDC);
	ReleaseMutex(CommMutex);
}


================================================
FILE: Crypt/debug.h
================================================
#ifdef DEBUG    /* keep these macros common so they are same for both versions */
CONST int debugCompile  =   1;
extern  int debug;
extern  void DebugIO(CONST char *s);    /* display the debug output */

#define DebugDump(x,s,R,XOR,doRot,showT,needBswap)  \
    { if (debug) _Dump(x,s,R,XOR,doRot,showT,needBswap,t0,t1); }
#define DebugDumpKey(key) { if (debug) _DumpKey(key); }
#define IV_ROUND    -100
    
void _Dump(CONST void *p,CONST char *s,int R,int XOR,int doRot,int showT,int needBswap,
           DWORD t0,DWORD t1)
    {
    char line[512]; /* build output here */
    int  i,n;
    DWORD q[4];

    if (R == IV_ROUND)
        sprintf(line,"%sIV:    ",s);
    else
        sprintf(line,"%sR[%2d]: ",s,R);
    for (n=0;line[n];n++) ;
    
    for (i=0;i<4;i++)
        {
        q[i]=((CONST DWORD *)p)[i^(XOR)];
        if (needBswap) q[i]=Bswap(q[i]);
        }

    sprintf(line+n,"x= %08lX  %08lX  %08lX  %08lX.",
            ROR(q[0],doRot*(R  )/2),
            ROL(q[1],doRot*(R  )/2),
            ROR(q[2],doRot*(R+1)/2),
            ROL(q[3],doRot*(R+1)/2));
    for (;line[n];n++) ;

    if (showT)
        sprintf(line+n,"    t0=%08lX. t1=%08lX.",t0,t1);
    for (;line[n];n++) ;

    sprintf(line+n,"\n");
    DebugIO(line);
    }

void _DumpKey(CONST keyInstance *key)
    {
    char    line[512];
    int     i;
    int     k64Cnt=(key->keyLen+63)/64; /* round up to next multiple of 64 bits */
    int     subkeyCnt = ROUND_SUBKEYS + 2*key->numRounds;

    sprintf(line,";\n;makeKey:   Input key            -->  S-box key     [%s]\n",
           (key->direction == DIR_ENCRYPT) ? "Encrypt" : "Decrypt");
    DebugIO(line);
    for (i=0;i<k64Cnt;i++)  /* display in RS format */
        {
        sprintf(line,";%12s %08lX %08lX  -->  %08lX\n","",
               key->key32[2*i+1],key->key32[2*i],key->sboxKeys[k64Cnt-1-i]);
        DebugIO(line);
        }
    sprintf(line,";%11sSubkeys\n","");
    DebugIO(line);
    for (i=0;i<subkeyCnt/2;i++)
        {
        sprintf(line,";%12s %08lX %08lX%s\n","",key->subKeys[2*i],key->subKeys[2*i+1],
              (2*i ==  INPUT_WHITEN) ? "   Input whiten" :
              (2*i == OUTPUT_WHITEN) ? "  Output whiten" :
              (2*i == ROUND_SUBKEYS) ? "  Round subkeys" : "");
        DebugIO(line);
        }
    DebugIO(";\n");
    }
#else
CONST int debugCompile  =   0;
#define DebugDump(x,s,R,XOR,doRot,showT,needBswap)
#define DebugDumpKey(key)
#endif


================================================
FILE: Crypt/platform.h
================================================
/***************************************************************************
    PLATFORM.H  -- Platform-specific defines for TWOFISH code

    Submitters:
        Bruce Schneier, Counterpane Systems
        Doug Whiting,   Hi/fn
        John Kelsey,    Counterpane Systems
        Chris Hall,     Counterpane Systems
        David Wagner,   UC Berkeley
            
    Code Author:        Doug Whiting,   Hi/fn
        
    Version  1.00       April 1998
        
    Copyright 1998, Hi/fn and Counterpane Systems.  All rights reserved.
        
    Notes:
        *   Tab size is set to 4 characters in this file

***************************************************************************/

/* use intrinsic rotate if possible */
#ifndef ROL
#define ROL(x,n) (((x) << ((n) & 0x1F)) | ((x) >> (32-((n) & 0x1F))))
#define ROR(x,n) (((x) >> ((n) & 0x1F)) | ((x) << (32-((n) & 0x1F))))
#endif

#if (0) && defined(__BORLANDC__) && (__BORLANDC__ >= 0x462)
#error "!!!This does not work for some reason!!!"
#include    <stdlib.h>                  /* get prototype for _lrotl() , _lrotr() */
#pragma inline __lrotl__
#pragma inline __lrotr__
#undef  ROL                             /* get rid of inefficient definitions */
#undef  ROR
#define ROL(x,n)    __lrotl__(x,n)      /* use compiler intrinsic rotations */
#define ROR(x,n)    __lrotr__(x,n)
#endif

#ifdef _MSC_VER
#include    <stdlib.h>                  /* get prototypes for rotation functions */
#undef  ROL
#undef  ROR
#pragma intrinsic(_lrotl,_lrotr)        /* use intrinsic compiler rotations */
#define ROL(x,n)    _lrotl(x,n)         
#define ROR(x,n)    _lrotr(x,n)
#endif

#ifndef _M_IX86
#ifdef  __BORLANDC__
#define _M_IX86                 300     /* make sure this is defined for Intel CPUs */
#endif
#endif

#ifdef _M_IX86
#define     LittleEndian        1       /* e.g., 1 for Pentium, 0 for 68K */
#define     ALIGN32             0       /* need dword alignment? (no for Pentium) */
#else   /* non-Intel platforms */
#define     LittleEndian        0       /* (assume big endian */
#define     ALIGN32             1       /* (assume need alignment for non-Intel) */
#endif

#if LittleEndian
#define     Bswap(x)            (x)     /* NOP for little-endian machines */
#define     ADDR_XOR            0       /* NOP for little-endian machines */
#else
#define     Bswap(x)            ((ROR(x,8) & 0xFF00FF00) | (ROL(x,8) & 0x00FF00FF))
#define     ADDR_XOR            3       /* convert byte address in dword */
#endif

/*  Macros for extracting bytes from dwords (correct for endianness) */
#define _b(x,N) (((BYTE *)&x)[((N) & 3) ^ ADDR_XOR]) /* pick bytes out of a dword */

#define     b0(x)           _b(x,0)     /* extract LSB of DWORD */
#define     b1(x)           _b(x,1)
#define     b2(x)           _b(x,2)
#define     b3(x)           _b(x,3)     /* extract MSB of DWORD */



================================================
FILE: Crypt/resource.h
================================================
//{{NO_DEPENDENCIES}}
// Microsoft Visual C++ generated include file.
// Used by Crypt.rc
//
#define IDI_ICON1                       101
#define IDI_RAZOR                       101

// Next default values for new objects
// 
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE        102
#define _APS_NEXT_COMMAND_VALUE         40001
#define _APS_NEXT_CONTROL_VALUE         1001
#define _APS_NEXT_SYMED_VALUE           101
#endif
#endif


================================================
FILE: Crypt/stdafx.cpp
================================================
// stdafx.cpp : source file that includes just the standard includes
// Crypt.pch will be the pre-compiled header
// stdafx.obj will contain the pre-compiled type information

#include "stdafx.h"

// TODO: reference any additional headers you need in STDAFX.H
// and not in this file


================================================
FILE: Crypt/stdafx.h
================================================
// stdafx.h : include file for standard system include files,
// or project specific include files that are used frequently, but
// are changed infrequently
//

#pragma once
#pragma warning(disable: 4309)
#pragma warning(disable: 4311)
#pragma warning(disable: 4312)
#pragma warning(disable: 4800)
#pragma warning(disable: 4530)
#pragma warning(disable: 4996)
#pragma comment(lib, "ws2_32.lib")

#define WIN32_LEAN_AND_MEAN		// Exclude rarely-used stuff from Windows headers
// Windows Header Files:
#include <windows.h>

#pragma pack(1)

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <winsock2.h>
#include <time.h>
#include <zmouse.h>

//#include <vector>
//#include <string>
//using std::vector;
//using std::string;


================================================
FILE: Crypt/table.h
================================================
/***************************************************************************
    TABLE.H -- Tables, macros, constants for Twofish S-boxes and MDS matrix

    Submitters:
        Bruce Schneier, Counterpane Systems
        Doug Whiting,   Hi/fn
        John Kelsey,    Counterpane Systems
        Chris Hall,     Counterpane Systems
        David Wagner,   UC Berkeley
            
    Code Author:        Doug Whiting,   Hi/fn
        
    Version  1.00       April 1998
        
    Copyright 1998, Hi/fn and Counterpane Systems.  All rights reserved.
        
    Notes:
        *   Tab size is set to 4 characters in this file
        *   These definitions should be used in optimized and unoptimized
            versions to insure consistency.

***************************************************************************/

/* for computing subkeys */
#define SK_STEP         0x02020202u
#define SK_BUMP         0x01010101u
#define SK_ROTL         9

/* Reed-Solomon code parameters: (12,8) reversible code
    g(x) = x**4 + (a + 1/a) x**3 + a x**2 + (a + 1/a) x + 1
   where a = primitive root of field generator 0x14D */
#define RS_GF_FDBK      0x14D       /* field generator */
#define RS_rem(x)       \
    { BYTE  b  = (BYTE) (x >> 24);                                           \
      DWORD g2 = ((b << 1) ^ ((b & 0x80) ? RS_GF_FDBK : 0 )) & 0xFF;         \
      DWORD g3 = ((b >> 1) & 0x7F) ^ ((b & 1) ? RS_GF_FDBK >> 1 : 0 ) ^ g2 ; \
      x = (x << 8) ^ (g3 << 24) ^ (g2 << 16) ^ (g3 << 8) ^ b;                \
    }

/*  Macros for the MDS matrix
*   The MDS matrix is (using primitive polynomial 169):
*      01  EF  5B  5B
*      5B  EF  EF  01
*      EF  5B  01  EF
*      EF  01  EF  5B
*----------------------------------------------------------------
* More statistical properties of this matrix (from MDS.EXE output):
*
* Min Hamming weight (one byte difference) =  8. Max=26.  Total =  1020.
* Prob[8]:      7    23    42    20    52    95    88    94   121   128    91
*             102    76    41    24     8     4     1     3     0     0     0
* Runs[8]:      2     4     5     6     7     8     9    11
* MSBs[8]:      1     4    15     8    18    38    40    43
* HW= 8: 05040705 0A080E0A 14101C14 28203828 50407050 01499101 A080E0A0 
* HW= 9: 04050707 080A0E0E 10141C1C 20283838 40507070 80A0E0E0 C6432020 07070504 
*        0E0E0A08 1C1C1410 38382820 70705040 E0E0A080 202043C6 05070407 0A0E080E 
*        141C101C 28382038 50704070 A0E080E0 4320C620 02924B02 089A4508 
* Min Hamming weight (two byte difference) =  3. Max=28.  Total = 390150.
* Prob[3]:      7    18    55   149   270   914  2185  5761 11363 20719 32079
*           43492 51612 53851 52098 42015 31117 20854 11538  6223  2492  1033
* MDS OK, ROR:   6+  7+  8+  9+ 10+ 11+ 12+ 13+ 14+ 15+ 16+
*               17+ 18+ 19+ 20+ 21+ 22+ 23+ 24+ 25+ 26+
*/
#define MDS_GF_FDBK     0x169   /* primitive polynomial for GF(256)*/
#define LFSR1(x) ( ((x) >> 1)  ^ (((x) & 0x01) ?   MDS_GF_FDBK/2 : 0))
#define LFSR2(x) ( ((x) >> 2)  ^ (((x) & 0x02) ?   MDS_GF_FDBK/2 : 0)  \
                               ^ (((x) & 0x01) ?   MDS_GF_FDBK/4 : 0))

#define Mx_1(x) ((DWORD)  (x))      /* force result to dword so << will work */
#define Mx_X(x) ((DWORD) ((x) ^            LFSR2(x)))   /* 5B */
#define Mx_Y(x) ((DWORD) ((x) ^ LFSR1(x) ^ LFSR2(x)))   /* EF */

#define M00     Mul_1
#define M01     Mul_Y
#define M02     Mul_X
#define M03     Mul_X

#define M10     Mul_X
#define M11     Mul_Y
#define M12     Mul_Y
#define M13     Mul_1

#define M20     Mul_Y
#define M21     Mul_X
#define M22     Mul_1
#define M23     Mul_Y

#define M30     Mul_Y
#define M31     Mul_1
#define M32     Mul_Y
#define M33     Mul_X

#define Mul_1   Mx_1
#define Mul_X   Mx_X
#define Mul_Y   Mx_Y

/*  Define the fixed p0/p1 permutations used in keyed S-box lookup.  
    By changing the following constant definitions for P_ij, the S-boxes will
    automatically get changed in all the Twofish source code. Note that P_i0 is
    the "outermost" 8x8 permutation applied.  See the f32() function to see
    how these constants are to be  used.
*/
#define P_00    1                   /* "outermost" permutation */
#define P_01    0
#define P_02    0
#define P_03    (P_01^1)            /* "extend" to larger key sizes */
#define P_04    1

#define P_10    0
#define P_11    0
#define P_12    1
#define P_13    (P_11^1)
#define P_14    0

#define P_20    1
#define P_21    1
#define P_22    0
#define P_23    (P_21^1)
#define P_24    0

#define P_30    0
#define P_31    1
#define P_32    1
#define P_33    (P_31^1)
#define P_34    1

#define p8(N)   P8x8[P_##N]         /* some syntax shorthand */

/* fixed 8x8 permutation S-boxes */

/***********************************************************************
*  07:07:14  05/30/98  [4x4]  TestCnt=256. keySize=128. CRC=4BD14D9E.
* maxKeyed:  dpMax = 18. lpMax =100. fixPt =  8. skXor =  0. skDup =  6. 
* log2(dpMax[ 6..18])=   --- 15.42  1.33  0.89  4.05  7.98 12.05
* log2(lpMax[ 7..12])=  9.32  1.01  1.16  4.23  8.02 12.45
* log2(fixPt[ 0.. 8])=  1.44  1.44  2.44  4.06  6.01  8.21 11.07 14.09 17.00
* log2(skXor[ 0.. 0])
* log2(skDup[ 0.. 6])=   ---  2.37  0.44  3.94  8.36 13.04 17.99
***********************************************************************/
CONST BYTE P8x8[2][256]=
    {
/*  p0:   */
/*  dpMax      = 10.  lpMax      = 64.  cycleCnt=   1  1  1  0.         */
/* 817D6F320B59ECA4.ECB81235F4A6709D.BA5E6D90C8F32471.D7F4126E9B3085CA. */
/* Karnaugh maps:
*  0111 0001 0011 1010. 0001 1001 1100 1111. 1001 1110 0011 1110. 1101 0101 1111 1001. 
*  0101 1111 1100 0100. 1011 0101 0010 0000. 0101 1000 1100 0101. 1000 0111 0011 0010. 
*  0000 1001 1110 1101. 1011 1000 1010 0011. 0011 1001 0101 0000. 0100 0010 0101 1011. 
*  0111 0100 0001 0110. 1000 1011 1110 1001. 0011 0011 1001 1101. 1101 0101 0000 1100. 
*/
    {
    0xA9, 0x67, 0xB3, 0xE8, 0x04, 0xFD, 0xA3, 0x76, 
    0x9A, 0x92, 0x80, 0x78, 0xE4, 0xDD, 0xD1, 0x38, 
    0x0D, 0xC6, 0x35, 0x98, 0x18, 0xF7, 0xEC, 0x6C, 
    0x43, 0x75, 0x37, 0x26, 0xFA, 0x13, 0x94, 0x48, 
    0xF2, 0xD0, 0x8B, 0x30, 0x84, 0x54, 0xDF, 0x23, 
    0x19, 0x5B, 0x3D, 0x59, 0xF3, 0xAE, 0xA2, 0x82, 
    0x63, 0x01, 0x83, 0x2E, 0xD9, 0x51, 0x9B, 0x7C, 
    0xA6, 0xEB, 0xA5, 0xBE, 0x16, 0x0C, 0xE3, 0x61, 
    0xC0, 0x8C, 0x3A, 0xF5, 0x73, 0x2C, 0x25, 0x0B, 
    0xBB, 0x4E, 0x89, 0x6B, 0x53, 0x6A, 0xB4, 0xF1, 
    0xE1, 0xE6, 0xBD, 0x45, 0xE2, 0xF4, 0xB6, 0x66, 
    0xCC, 0x95, 0x03, 0x56, 0xD4, 0x1C, 0x1E, 0xD7, 
    0xFB, 0xC3, 0x8E, 0xB5, 0xE9, 0xCF, 0xBF, 0xBA, 
    0xEA, 0x77, 0x39, 0xAF, 0x33, 0xC9, 0x62, 0x71, 
    0x81, 0x79, 0x09, 0xAD, 0x24, 0xCD, 0xF9, 0xD8, 
    0xE5, 0xC5, 0xB9, 0x4D, 0x44, 0x08, 0x86, 0xE7, 
    0xA1, 0x1D, 0xAA, 0xED, 0x06, 0x70, 0xB2, 0xD2, 
    0x41, 0x7B, 0xA0, 0x11, 0x31, 0xC2, 0x27, 0x90, 
    0x20, 0xF6, 0x60, 0xFF, 0x96, 0x5C, 0xB1, 0xAB, 
    0x9E, 0x9C, 0x52, 0x1B, 0x5F, 0x93, 0x0A, 0xEF, 
    0x91, 0x85, 0x49, 0xEE, 0x2D, 0x4F, 0x8F, 0x3B, 
    0x47, 0x87, 0x6D, 0x46, 0xD6, 0x3E, 0x69, 0x64, 
    0x2A, 0xCE, 0xCB, 0x2F, 0xFC, 0x97, 0x05, 0x7A, 
    0xAC, 0x7F, 0xD5, 0x1A, 0x4B, 0x0E, 0xA7, 0x5A, 
    0x28, 0x14, 0x3F, 0x29, 0x88, 0x3C, 0x4C, 0x02, 
    0xB8, 0xDA, 0xB0, 0x17, 0x55, 0x1F, 0x8A, 0x7D, 
    0x57, 0xC7, 0x8D, 0x74, 0xB7, 0xC4, 0x9F, 0x72, 
    0x7E, 0x15, 0x22, 0x12, 0x58, 0x07, 0x99, 0x34, 
    0x6E, 0x50, 0xDE, 0x68, 0x65, 0xBC, 0xDB, 0xF8, 
    0xC8, 0xA8, 0x2B, 0x40, 0xDC, 0xFE, 0x32, 0xA4, 
    0xCA, 0x10, 0x21, 0xF0, 0xD3, 0x5D, 0x0F, 0x00, 
    0x6F, 0x9D, 0x36, 0x42, 0x4A, 0x5E, 0xC1, 0xE0
    },
/*  p1:   */
/*  dpMax      = 10.  lpMax      = 64.  cycleCnt=   2  0  0  1.         */
/* 28BDF76E31940AC5.1E2B4C376DA5F908.4C75169A0ED82B3F.B951C3DE647F208A. */
/* Karnaugh maps:
*  0011 1001 0010 0111. 1010 0111 0100 0110. 0011 0001 1111 0100. 1111 1000 0001 1100. 
*  1100 1111 1111 1010. 0011 0011 1110 0100. 1001 0110 0100 0011. 0101 0110 1011 1011. 
*  0010 0100 0011 0101. 1100 1000 1000 1110. 0111 1111 0010 0110. 0000 1010 0000 0011. 
*  1101 1000 0010 0001. 0110 1001 1110 0101. 0001 0100 0101 0111. 0011 1011 1111 0010. 
*/
    {
    0x75, 0xF3, 0xC6, 0xF4, 0xDB, 0x7B, 0xFB, 0xC8, 
    0x4A, 0xD3, 0xE6, 0x6B, 0x45, 0x7D, 0xE8, 0x4B, 
    0xD6, 0x32, 0xD8, 0xFD, 0x37, 0x71, 0xF1, 0xE1, 
    0x30, 0x0F, 0xF8, 0x1B, 0x87, 0xFA, 0x06, 0x3F, 
    0x5E, 0xBA, 0xAE, 0x5B, 0x8A, 0x00, 0xBC, 0x9D, 
    0x6D, 0xC1, 0xB1, 0x0E, 0x80, 0x5D, 0xD2, 0xD5, 
    0xA0, 0x84, 0x07, 0x14, 0xB5, 0x90, 0x2C, 0xA3, 
    0xB2, 0x73, 0x4C, 0x54, 0x92, 0x74, 0x36, 0x51, 
    0x38, 0xB0, 0xBD, 0x5A, 0xFC, 0x60, 0x62, 0x96, 
    0x6C, 0x42, 0xF7, 0x10, 0x7C, 0x28, 0x27, 0x8C, 
    0x13, 0x95, 0x9C, 0xC7, 0x24, 0x46, 0x3B, 0x70, 
    0xCA, 0xE3, 0x85, 0xCB, 0x11, 0xD0, 0x93, 0xB8, 
    0xA6, 0x83, 0x20, 0xFF, 0x9F, 0x77, 0xC3, 0xCC, 
    0x03, 0x6F, 0x08, 0xBF, 0x40, 0xE7, 0x2B, 0xE2, 
    0x79, 0x0C, 0xAA, 0x82, 0x41, 0x3A, 0xEA, 0xB9, 
    0xE4, 0x9A, 0xA4, 0x97, 0x7E, 0xDA, 0x7A, 0x17, 
    0x66, 0x94, 0xA1, 0x1D, 0x3D, 0xF0, 0xDE, 0xB3, 
    0x0B, 0x72, 0xA7, 0x1C, 0xEF, 0xD1, 0x53, 0x3E, 
    0x8F, 0x33, 0x26, 0x5F, 0xEC, 0x76, 0x2A, 0x49, 
    0x81, 0x88, 0xEE, 0x21, 0xC4, 0x1A, 0xEB, 0xD9, 
    0xC5, 0x39, 0x99, 0xCD, 0xAD, 0x31, 0x8B, 0x01, 
    0x18, 0x23, 0xDD, 0x1F, 0x4E, 0x2D, 0xF9, 0x48, 
    0x4F, 0xF2, 0x65, 0x8E, 0x78, 0x5C, 0x58, 0x19, 
    0x8D, 0xE5, 0x98, 0x57, 0x67, 0x7F, 0x05, 0x64, 
    0xAF, 0x63, 0xB6, 0xFE, 0xF5, 0xB7, 0x3C, 0xA5, 
    0xCE, 0xE9, 0x68, 0x44, 0xE0, 0x4D, 0x43, 0x69, 
    0x29, 0x2E, 0xAC, 0x15, 0x59, 0xA8, 0x0A, 0x9E, 
    0x6E, 0x47, 0xDF, 0x34, 0x35, 0x6A, 0xCF, 0xDC, 
    0x22, 0xC9, 0xC0, 0x9B, 0x89, 0xD4, 0xED, 0xAB, 
    0x12, 0xA2, 0x0D, 0x52, 0xBB, 0x02, 0x2F, 0xA9, 
    0xD7, 0x61, 0x1E, 0xB4, 0x50, 0x04, 0xF6, 0xC2, 
    0x16, 0x25, 0x86, 0x56, 0x55, 0x09, 0xBE, 0x91
    }
    };


================================================
FILE: Crypt/trees.cpp
================================================

int Trees[] = {
	0x4CCA, 0x4CCB, 0x4CCC, 0x4CCD, 0x4CD0, 0x4CD3, 0x4CD6, 0x4CD8,
	0x4CDA, 0x4CDD, 0x4CE0, 0x4CE3, 0x4CE6, 0x4CF8, 0x4CFB, 0x4CFE,
	0x4D01, 0x4D41, 0x4D42, 0x4D43, 0x4D44, 0x4D57, 0x4D58, 0x4D59,
	0x4D5A, 0x4D5B, 0x4D6E, 0x4D6F, 0x4D70, 0x4D71, 0x4D72, 0x4D84,
	0x4D85, 0x4D86, 0x52B5, 0x52B6, 0x52B7, 0x52B8, 0x52B9, 0x52BA,
	0x52BB, 0x52BC, 0x52BD,
};

int Leaves[] = {
	0x4CCE, 0x4CCF, 0x4CD1, 0x4CD2, 0x4CD4, 0x4CD5, 0x4CD7, 0x4CD9,
	0x4CDB, 0x4CDC, 0x4CDE, 0x4CDF, 0x4CE1, 0x4CE2, 0x4CE4, 0x4CE5,
	0x4CE7, 0x4CE8, 0x4CF9, 0x4CFA, 0x4CFC, 0x4CFD, 0x4CFF, 0x4D00,
	0x4D02, 0x4D03, 0x4D45, 0x4D46, 0x4D47, 0x4D48, 0x4D49, 0x4D4A,
	0x4D4B, 0x4D4C, 0x4D4D, 0x4D4E, 0x4D4F, 0x4D50, 0x4D51, 0x4D52,
	0x4D53, 0x4D5C, 0x4D5D, 0x4D5E, 0x4D5F, 0x4D60, 0x4D61, 0x4D62,
	0x4D63, 0x4D64, 0x4D65, 0x4D66, 0x4D67, 0x4D68, 0x4D69, 0x4D73,
	0x4D74, 0x4D75, 0x4D76, 0x4D77, 0x4D78, 0x4D79, 0x4D7A, 0x4D7B,
	0x4D7C, 0x4D7D, 0x4D7E, 0x4D7F, 0x4D87, 0x4D88, 0x4D89, 0x4D8A,
	0x4D8B, 0x4D8C, 0x4D8D, 0x4D8E, 0x4D8F, 0x4D90, 0x4D95, 0x4D96,
	0x4D97, 0x4D99, 0x4D9A, 0x4D9B, 0x4D9D, 0x4D9E, 0x4D9F, 0x4DA1,
	0x4DA2, 0x4DA3, 0x4DA5, 0x4DA6, 0x4DA7, 0x4DA9, 0x4DAA, 0x4DAB,
	0x52BE, 0x52BF, 0x52C0, 0x52C1, 0x52C2, 0x52C3, 0x52C4, 0x52C5,
	0x52C6, 0x52C7
};

HANDLE WINAPI NewCreateFile( LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode,
							 LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition,
                             DWORD dwFlagsAndAttributes, HANDLE hTemplateFile )
{
	strlwr( (char*)lpFileName );
	if ( strstr( lpFileName, "artidx.mul" ) && (dwDesiredAccess & GENERIC_READ) != 0 )
	{
		char path[MAX_PATH];
		GetTempPath( MAX_PATH, path );
		strcat( path, "/razor_art.tmp" );
		CopyFile( lpFileName, path, FALSE );

		int stump[3], none[3];
		FILE *f = fopen( path, "rb" );
		fseek( f, 12*0xE57, SEEK_SET );
		fread( stump, 12, 1, f );
		fseek( f, 12*0x115E, SEEK_SET );
		fread( none, 12, 1, f );
		fclose( f );

		f = fopen( path, "wb" );
		for(int i=0;Trees[i] != 0;i++)
		{
			fseek( f, 12*Trees[i], SEEK_SET );
			fwrite( stump, 12, 1, f );
		}
		for(int i=0;Leaves[i] != 0;i++)
		{
			fseek( f, 12*Leaves[i], SEEK_SET );
			fwrite( none, 12, 1, f );
		}
		fclose( f );

		return CreateFile( path, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile );
	}
	else
	{
		return CreateFile( lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile );
	}
}

#define CREATE_FILE_LOC "\x68\x00\x00\x00\xC0\x50\xFF\x15\xF8\x71\x56\x00\x83\xF8\xFF"
#define CFL_LEN 15

void PatchCreateFile()
{
	DWORD CurPos = FindInMemory( 0x00400000, CREATE_FILE_LOC, CFL_LEN );
	if ( !CurPos ) 
		return;
	CurPos += 6;
	*((unsigned char*)(CurPos)) = 0xE8; // call
	*((unsigned int*)(CurPos+1)) = int(NewCreateFile) - (CurPos+4);
	*((unsigned char*)(CurPos+5)) = 0x90; // nop
}

void PatchStartup( DWORD ProcID )
{
	HANDLE hProc = OpenProcess( PROCESS_ALL_ACCESS, FALSE, ProcID );
	if ( !hProc )
		return;

	DWORD image_base = ???; 
    IMAGE_DOS_HEADER *idh = (IMAGE_DOS_HEADER *)image_base;
    IMAGE_FILE_HEADER *ifh = (IMAGE_FILE_HEADER *)(image_base + idh->e_lfanew + sizeof(DWORD));
    IMAGE_OPTIONAL_HEADER *ioh = (IMAGE_OPTIONAL_HEADER *)((DWORD)(ifh) + sizeof(IMAGE_FILE_HEADER));

	DWORD acc = 0;
	void *addr = VirtualAllocEx( hProc, NULL, 512, MEM_COMMIT, PAGE_EXECUTE_READWRITE );
	DWORD Pos = (DWORD)addr;

	char file[256];
	acc = GetModuleFileName( GetModuleHandle(NULL), file, 256 );
	WriteProcessMemory( hProc, (void*)Pos, file, acc, &acc );
	DWORD FileLoc = Pos;
	Pos += acc;
	strcpy( file, "AttachedStart" );
	WriteProcessMemory( hProc, (void*)Pos, file, strlen(file)+1, &acc );
	DWORD ProcLoc = Pos;
	Pos += acc;

	unsigned char LoadFunc[] = {
		0x55,					// push ebp
		0x8B, 0xEC,				// mov ebp, esp
		0x53,					// push ebx
		0x56,					// push esi
		0x57,					// push edi
		0x68, 0, 0, 0, 0,		// push _address_
		0xFF,0x15,0xB8,0x71,0x56,0x00, // call ds:LoadLibraryA
		0x68, 0, 0, 0, 0,		// push _address_
		0x50,					// push eax
		0x8B, 0xF0,				// mov esi, eax
		0xFF,0x15,0xBC,0x71,0x56,0x00, // call ds:GetProcAddress
		0xFF, 0xD0,				// call eax
		//0x56,					// push esi             ; hLibModule
		//0xFF,0x15,0xC0,0x71,0x56,0x00, // call ds:FreeLibrary
		0x5F,					// pop edi
		0x5E,					// pop esi
		0x5B,					// pop ebx
		0x5D,					// pop ebp
		0xE9, 0, 0, 0, 0,		// jmp _addressoffset_
		0x90,					// nop
		0x90,					// nop
	};
	const int len = 44;

	*((int*)(LoadFunc+7)) = FileLoc - (Pos+7+4);
	*((int*)(LoadFunc+18)) = ProcLoc - (Pos+18+4);
	*((int*)(LoadFunc+38)) = (ioh->ImageBase + ioh->AddressOfEntryPoint) - (Pos+38+4);

	WriteProcessMemory( hProc, (void*)Pos, LoadFunc, len, &acc );
	ioh->AddressOfEntryPoint = Pos;
	CloseHandle( hProc );
}


================================================
FILE: Crypt/twofish.c
================================================
/***************************************************************************
    TWOFISH2.C  -- Optimized C API calls for TWOFISH AES submission

    Submitters:
        Bruce Schneier, Counterpane Systems
        Doug Whiting,   Hi/fn
        John Kelsey,    Counterpane Systems
        Chris Hall,     Counterpane Systems
        David Wagner,   UC Berkeley
            
    Code Author:        Doug Whiting,   Hi/fn
        
    Version  1.00       April 1998
        
    Copyright 1998, Hi/fn and Counterpane Systems.  All rights reserved.
        
    Notes:
        *   Optimized version
        *   Tab size is set to 4 characters in this file

***************************************************************************/

#pragma pack(1)

#include <memory.h>
#include    "twofish.h"
#include    "table.h"

#pragma warning(disable: 4005)//ignore macro re-definitions

#if   defined(min_key)  && !defined(MIN_KEY)
#define MIN_KEY     1           /* toupper() */
#elif defined(part_key) && !defined(PART_KEY)
#define PART_KEY    1
#elif defined(zero_key) && !defined(ZERO_KEY)
#define ZERO_KEY    1
#endif


#ifdef USE_ASM
extern  int useAsm;             /* ok to use ASM code? */

typedef int cdecl CipherProc
   (cipherInstance *cipher, keyInstance *key,BYTE *input,int inputLen,BYTE *outBuffer);
typedef int cdecl KeySetupProc(keyInstance *key);

extern CipherProc   *blockEncrypt_86;   /* ptr to ASM functions */
extern CipherProc   *blockDecrypt_86;
extern KeySetupProc *reKey_86;
extern DWORD        cdecl TwofishAsmCodeSize(void);
#endif

/*
+*****************************************************************************
*           Constants/Macros/Tables
-****************************************************************************/

#define     CONST                   /* help syntax from C++, NOP here */

CONST       fullSbox MDStab;        /* not actually const.  Initialized ONE time */
int         needToBuildMDS=1;       /* is MDStab initialized yet? */

#define     BIG_TAB     0

#if BIG_TAB
BYTE        bigTab[4][256][256];    /* pre-computed S-box */
#endif

/* number of rounds for various key sizes:  128, 192, 256 */
/* (ignored for now in optimized code!) */
CONST int   numRounds[4]= {0,ROUNDS_128,ROUNDS_192,ROUNDS_256};

#if REENTRANT
#define     _sBox_   key->sBox8x32
#else
static      fullSbox _sBox_;        /* permuted MDStab based on keys */
#endif
#define _sBox8_(N) (((BYTE *) _sBox_) + (N)*256)

/*------- see what level of S-box precomputation we need to do -----*/
#if   defined(ZERO_KEY)
#define MOD_STRING  "(Zero S-box keying)"
#define Fe32_128(x,R)   \
    (   MDStab[0][p8(01)[p8(02)[_b(x,R  )]^b0(SKEY[1])]^b0(SKEY[0])] ^  \
        MDStab[1][p8(11)[p8(12)[_b(x,R+1)]^b1(SKEY[1])]^b1(SKEY[0])] ^  \
        MDStab[2][p8(21)[p8(22)[_b(x,R+2)]^b2(SKEY[1])]^b2(SKEY[0])] ^  \
        MDStab[3][p8(31)[p8(32)[_b(x,R+3)]^b3(SKEY[1])]^b3(SKEY[0])] )
#define Fe32_192(x,R)   \
    (   MDStab[0][p8(01)[p8(02)[p8(03)[_b(x,R  )]^b0(SKEY[2])]^b0(SKEY[1])]^b0(SKEY[0])] ^ \
        MDStab[1][p8(11)[p8(12)[p8(13)[_b(x,R+1)]^b1(SKEY[2])]^b1(SKEY[1])]^b1(SKEY[0])] ^ \
        MDStab[2][p8(21)[p8(22)[p8(23)[_b(x,R+2)]^b2(SKEY[2])]^b2(SKEY[1])]^b2(SKEY[0])] ^ \
        MDStab[3][p8(31)[p8(32)[p8(33)[_b(x,R+3)]^b3(SKEY[2])]^b3(SKEY[1])]^b3(SKEY[0])] )
#define Fe32_256(x,R)   \
    (   MDStab[0][p8(01)[p8(02)[p8(03)[p8(04)[_b(x,R  )]^b0(SKEY[3])]^b0(SKEY[2])]^b0(SKEY[1])]^b0(SKEY[0])] ^ \
        MDStab[1][p8(11)[p8(12)[p8(13)[p8(14)[_b(x,R+1)]^b1(SKEY[3])]^b1(SKEY[2])]^b1(SKEY[1])]^b1(SKEY[0])] ^ \
        MDStab[2][p8(21)[p8(22)[p8(23)[p8(24)[_b(x,R+2)]^b2(SKEY[3])]^b2(SKEY[2])]^b2(SKEY[1])]^b2(SKEY[0])] ^ \
        MDStab[3][p8(31)[p8(32)[p8(33)[p8(34)[_b(x,R+3)]^b3(SKEY[3])]^b3(SKEY[2])]^b3(SKEY[1])]^b3(SKEY[0])] )

#define GetSboxKey  DWORD SKEY[4];  /* local copy */ \
                    memcpy(SKEY,key->sboxKeys,sizeof(SKEY));
/*----------------------------------------------------------------*/
#elif defined(MIN_KEY)
#define MOD_STRING  "(Minimal keying)"
#define Fe32_(x,R)(MDStab[0][p8(01)[_sBox8_(0)[_b(x,R  )]] ^ b0(SKEY0)] ^ \
                   MDStab[1][p8(11)[_sBox8_(1)[_b(x,R+1)]] ^ b1(SKEY0)] ^ \
                   MDStab[2][p8(21)[_sBox8_(2)[_b(x,R+2)]] ^ b2(SKEY0)] ^ \
                   MDStab[3][p8(31)[_sBox8_(3)[_b(x,R+3)]] ^ b3(SKEY0)])
#define sbSet(N,i,J,v) { _sBox8_(N)[i+J] = v; }
#define GetSboxKey  DWORD SKEY0 = key->sboxKeys[0]      /* local copy */
/*----------------------------------------------------------------*/
#elif defined(PART_KEY) 
#define MOD_STRING  "(Partial keying)"
#define Fe32_(x,R)(MDStab[0][_sBox8_(0)[_b(x,R  )]] ^ \
                   MDStab[1][_sBox8_(1)[_b(x,R+1)]] ^ \
                   MDStab[2][_sBox8_(2)[_b(x,R+2)]] ^ \
                   MDStab[3][_sBox8_(3)[_b(x,R+3)]])
#define sbSet(N,i,J,v) { _sBox8_(N)[i+J] = v; }
#define GetSboxKey  
/*----------------------------------------------------------------*/
#else   /* default is FULL_KEY */
#ifndef FULL_KEY
#define FULL_KEY    1
#endif
#if BIG_TAB
#define TAB_STR     " (Big table)"
#else
#define TAB_STR
#endif
#ifdef COMPILE_KEY
#define MOD_STRING  "(Compiled subkeys)" TAB_STR
#else
#define MOD_STRING  "(Full keying)" TAB_STR
#endif
/* Fe32_ does a full S-box + MDS lookup.  Need to #define _sBox_ before use.
   Note that we "interleave" 0,1, and 2,3 to avoid cache bank collisions
   in optimized assembly language.
*/
#define Fe32_(x,R) (_sBox_[0][2*_b(x,R  )] ^ _sBox_[0][2*_b(x,R+1)+1] ^ \
                    _sBox_[2][2*_b(x,R+2)] ^ _sBox_[2][2*_b(x,R+3)+1])
        /* set a single S-box value, given the input byte */
#define sbSet(N,i,J,v) { _sBox_[N&2][2*i+(N&1)+2*J]=MDStab[N][v]; }
#define GetSboxKey  
#endif

CONST       char *moduleDescription ="Optimized C ";
CONST       char *modeString        =MOD_STRING;


/* macro(s) for debugging help */
#define     CHECK_TABLE     0       /* nonzero --> compare against "slow" table */
#define     VALIDATE_PARMS  0       /* disable for full speed */

#include    "debug.h"               /* debug display macros */

/* end of debug macros */

#ifdef GetCodeSize
extern DWORD Here(DWORD x);         /* return caller's address! */
DWORD TwofishCodeStart(void) { return Here(0); }
#endif

/*
+*****************************************************************************
*
* Function Name:    TableOp
*
* Function:         Handle table use checking
*
* Arguments:        op  =   what to do  (see TAB_* defns in AES.H)
*
* Return:           TRUE --> done (for TAB_QUERY)       
*
* Notes: This routine is for use in generating the tables KAT file.
*        For this optimized version, we don't actually track table usage,
*        since it would make the macros incredibly ugly.  Instead we just
*        run for a fixed number of queries and then say we're done.
*
-****************************************************************************/
int TableOp(int op)
    {
    static int queryCnt=0;

    switch (op)
        {
        case TAB_DISABLE:
            break;
        case TAB_ENABLE:
            break;
        case TAB_RESET:
            queryCnt=0;
            break;
        case TAB_QUERY:
            queryCnt++;
            if (queryCnt < TAB_MIN_QUERY)
                return FALSE;
        }
    return TRUE;
    }


/*
+*****************************************************************************
*
* Function Name:    ParseHexDword
*
* Function:         Parse ASCII hex nibbles and fill in key/iv dwords
*
* Arguments:        bit         =   # bits to read
*                   srcTxt      =   ASCII source
*                   d           =   ptr to dwords to fill in
*                   dstTxt      =   where to make a copy of ASCII source
*                                   (NULL ok)
*
* Return:           Zero if no error.  Nonzero --> invalid hex or length
*
* Notes:  Note that the parameter d is a DWORD array, not a byte array.
*   This routine is coded to work both for little-endian and big-endian
*   architectures.  The character stream is interpreted as a LITTLE-ENDIAN
*   byte stream, since that is how the Pentium works, but the conversion
*   happens automatically below. 
*
-****************************************************************************/
int ParseHexDword(int bits,CONST char *srcTxt,DWORD *d,char *dstTxt)
    {
    int i;
    char c;
    DWORD b;

    union   /* make sure LittleEndian is defined correctly */
        {
        BYTE  b[4];
        DWORD d[1];
        } v;
    v.d[0]=1;
    if (v.b[0 ^ ADDR_XOR] != 1)
        return BAD_ENDIAN;      /* make sure compile-time switch is set ok */

#if VALIDATE_PARMS
  #if ALIGN32
    if (((int)d) & 3)
        return BAD_ALIGN32; 
  #endif
#endif

    for (i=0;i*32<bits;i++)
        d[i]=0;                 /* first, zero the field */

    for (i=0;i*4<bits;i++)      /* parse one nibble at a time */
        {                       /* case out the hexadecimal characters */
        c=srcTxt[i];
        if (dstTxt) dstTxt[i]=c;
        if ((c >= '0') && (c <= '9'))
            b=c-'0';
        else if ((c >= 'a') && (c <= 'f'))
            b=c-'a'+10;
        else if ((c >= 'A') && (c <= 'F'))
            b=c-'A'+10;
        else
            return BAD_KEY_MAT; /* invalid hex character */
        /* works for big and little endian! */
        d[i/8] |= b << (4*((i^1)&7));       
        }

    return 0;                   /* no error */
    }


#if CHECK_TABLE
/*
+*****************************************************************************
*
* Function Name:    f32
*
* Function:         Run four bytes through keyed S-boxes and apply MDS matrix
*
* Arguments:        x           =   input to f function
*                   k32         =   pointer to key dwords
*                   keyLen      =   total key length (k32 --> keyLey/2 bits)
*
* Return:           The output of the keyed permutation applied to x.
*
* Notes:
*   This function is a keyed 32-bit permutation.  It is the major building
*   block for the Twofish round function, including the four keyed 8x8 
*   permutations and the 4x4 MDS matrix multiply.  This function is used
*   both for generating round subkeys and within the round function on the
*   block being encrypted.  
*
*   This version is fairly slow and pedagogical, although a smartcard would
*   probably perform the operation exactly this way in firmware.   For
*   ultimate performance, the entire operation can be completed with four
*   lookups into four 256x32-bit tables, with three dword xors.
*
*   The MDS matrix is defined in TABLE.H.  To multiply by Mij, just use the
*   macro Mij(x).
*
-****************************************************************************/
DWORD f32(DWORD x,CONST DWORD *k32,int keyLen)
    {
    BYTE  b[4];
    
    /* Run each byte thru 8x8 S-boxes, xoring with key byte at each stage. */
    /* Note that each byte goes through a different combination of S-boxes.*/

    *((DWORD *)b) = Bswap(x);   /* make b[0] = LSB, b[3] = MSB */
    switch (((keyLen + 63)/64) & 3)
        {
        case 0:     /* 256 bits of key */
            b[0] = p8(04)[b[0]] ^ b0(k32[3]);
            b[1] = p8(14)[b[1]] ^ b1(k32[3]);
            b[2] = p8(24)[b[2]] ^ b2(k32[3]);
            b[3] = p8(34)[b[3]] ^ b3(k32[3]);
            /* fall thru, having pre-processed b[0]..b[3] with k32[3] */
        case 3:     /* 192 bits of key */
            b[0] = p8(03)[b[0]] ^ b0(k32[2]);
            b[1] = p8(13)[b[1]] ^ b1(k32[2]);
            b[2] = p8(23)[b[2]] ^ b2(k32[2]);
            b[3] = p8(33)[b[3]] ^ b3(k32[2]);
            /* fall thru, having pre-processed b[0]..b[3] with k32[2] */
        case 2:     /* 128 bits of key */
            b[0] = p8(00)[p8(01)[p8(02)[b[0]] ^ b0(k32[1])] ^ b0(k32[0])];
            b[1] = p8(10)[p8(11)[p8(12)[b[1]] ^ b1(k32[1])] ^ b1(k32[0])];
            b[2] = p8(20)[p8(21)[p8(22)[b[2]] ^ b2(k32[1])] ^ b2(k32[0])];
            b[3] = p8(30)[p8(31)[p8(32)[b[3]] ^ b3(k32[1])] ^ b3(k32[0])];
        }

    /* Now perform the MDS matrix multiply inline. */
    return  ((M00(b[0]) ^ M01(b[1]) ^ M02(b[2]) ^ M03(b[3]))      ) ^
            ((M10(b[0]) ^ M11(b[1]) ^ M12(b[2]) ^ M13(b[3])) <<  8) ^
            ((M20(b[0]) ^ M21(b[1]) ^ M22(b[2]) ^ M23(b[3])) << 16) ^
            ((M30(b[0]) ^ M31(b[1]) ^ M32(b[2]) ^ M33(b[3])) << 24) ;
    }
#endif  /* CHECK_TABLE */


/*
+*****************************************************************************
*
* Function Name:    RS_MDS_encode
*
* Function:         Use (12,8) Reed-Solomon code over GF(256) to produce
*                   a key S-box dword from two key material dwords.
*
* Arguments:        k0  =   1st dword
*                   k1  =   2nd dword
*
* Return:           Remainder polynomial generated using RS code
*
* Notes:
*   Since this computation is done only once per reKey per 64 bits of key,
*   the performance impact of this routine is imperceptible. The RS code
*   chosen has "simple" coefficients to allow smartcard/hardware implementation
*   without lookup tables.
*
-****************************************************************************/
DWORD RS_MDS_Encode(DWORD k0,DWORD k1)
    {
    int i,j;
    DWORD r;

    for (i=r=0;i<2;i++)
        {
        r ^= (i) ? k0 : k1;         /* merge in 32 more key bits */
        for (j=0;j<4;j++)           /* shift one byte at a time */
            RS_rem(r);              
        }
    return r;
    }


/*
+*****************************************************************************
*
* Function Name:    BuildMDS
*
* Function:         Initialize the MDStab array
*
* Arguments:        None.
*
* Return:           None.
*
* Notes:
*   Here we precompute all the fixed MDS table.  This only needs to be done
*   one time at initialization, after which the table is "CONST".
*
-****************************************************************************/
void BuildMDS(void)
    {
    int i;
    DWORD d;
    BYTE m1[2],mX[2],mY[4];

    for (i=0;i<256;i++)
        {
        m1[0]=P8x8[0][i];       /* compute all the matrix elements */
        mX[0]=(BYTE) Mul_X(m1[0]);
        mY[0]=(BYTE) Mul_Y(m1[0]);

        m1[1]=P8x8[1][i];
        mX[1]=(BYTE) Mul_X(m1[1]);
        mY[1]=(BYTE) Mul_Y(m1[1]);

#undef  Mul_1                   /* change what the pre-processor does with Mij */
#undef  Mul_X
#undef  Mul_Y
#define Mul_1   m1              /* It will now access m01[], m5B[], and mEF[] */
#define Mul_X   mX              
#define Mul_Y   mY

#define SetMDS(N)                   \
        b0(d) = M0##N[P_##N##0];    \
        b1(d) = M1##N[P_##N##0];    \
        b2(d) = M2##N[P_##N##0];    \
        b3(d) = M3##N[P_##N##0];    \
        MDStab[N][i] = d;

        SetMDS(0);              /* fill in the matrix with elements computed above */
        SetMDS(1);
        SetMDS(2);
        SetMDS(3);
        }
#undef  Mul_1
#undef  Mul_X
#undef  Mul_Y
#define Mul_1   Mx_1            /* re-enable true multiply */
#define Mul_X   Mx_X
#define Mul_Y   Mx_Y
    
#if BIG_TAB
    {
    int j,k;
    BYTE *q0,*q1;

    for (i=0;i<4;i++)
        {
        switch (i)
            {
            case 0: q0=p8(01); q1=p8(02);   break;
            case 1: q0=p8(11); q1=p8(12);   break;
            case 2: q0=p8(21); q1=p8(22);   break;
            case 3: q0=p8(31); q1=p8(32);   break;
            }
        for (j=0;j<256;j++)
            for (k=0;k<256;k++)
                bigTab[i][j][k]=q0[q1[k]^j];
        }
    }
#endif

    needToBuildMDS=0;           /* NEVER modify the table again! */
    }

/*
+*****************************************************************************
*
* Function Name:    ReverseRoundSubkeys
*
* Function:         Reverse order of round subkeys to switch between encrypt/decrypt
*
* Arguments:        key     =   ptr to keyInstance to be reversed
*                   newDir  =   new direction value
*
* Return:           None.
*
* Notes:
*   This optimization allows both blockEncrypt and blockDecrypt to use the same
*   "fallthru" switch statement based on the number of rounds.
*   Note that key->numRounds must be even and >= 2 here.
*
-****************************************************************************/
void ReverseRoundSubkeys(keyInstance *key,BYTE newDir)
    {
    DWORD t0,t1;
    register DWORD *r0=key->subKeys+ROUND_SUBKEYS;
    register DWORD *r1=r0 + 2*key->numRounds - 2;

    for (;r0 < r1;r0+=2,r1-=2)
        {
        t0=r0[0];           /* swap the order */
        t1=r0[1];
        r0[0]=r1[0];        /* but keep relative order within pairs */
        r0[1]=r1[1];
        r1[0]=t0;
        r1[1]=t1;
        }

    key->direction=newDir;
    }

/*
+*****************************************************************************
*
* Function Name:    Xor256
*
* Function:         Copy an 8-bit permutation (256 bytes), xoring with a byte
*
* Arguments:        dst     =   where to put result
*                   src     =   where to get data (can be same asa dst)
*                   b       =   byte to xor
*
* Return:           None
*
* Notes:
*   BorlandC's optimization is terrible!  When we put the code inline,
*   it generates fairly good code in the *following* segment (not in the Xor256
*   code itself).  If the call is made, the code following the call is awful!
*   The penalty is nearly 50%!  So we take the code size hit for inlining for
*   Borland, while Microsoft happily works with a call.
*
-****************************************************************************/
#if defined(__BORLANDC__)   /* do it inline */
#define Xor32(dst,src,i) { ((DWORD *)dst)[i] = ((DWORD *)src)[i] ^ tmpX; } 
#define Xor256(dst,src,b)               \
    {                                   \
    register DWORD tmpX=0x01010101u * b;\
    for (i=0;i<64;i+=4)                 \
        { Xor32(dst,src,i  ); Xor32(dst,src,i+1); Xor32(dst,src,i+2); Xor32(dst,src,i+3); } \
    }
#else                       /* do it as a function call */
void Xor256(void *dst,void *src,BYTE b)
    {
    register DWORD  x=b*0x01010101u;    /* replicate byte to all four bytes */
    register DWORD *d=(DWORD *)dst;
    register DWORD *s=(DWORD *)src;
#define X_8(N)  { d[N]=s[N] ^ x; d[N+1]=s[N+1] ^ x; }
#define X_32(N) { X_8(N); X_8(N+2); X_8(N+4); X_8(N+6); }
    X_32(0 ); X_32( 8); X_32(16); X_32(24); /* all inline */
    d+=32;  /* keep offsets small! */
    s+=32;
    X_32(0 ); X_32( 8); X_32(16); X_32(24); /* all inline */
    }
#endif

/*
+*****************************************************************************
*
* Function Name:    reKey
*
* Function:         Initialize the Twofish key schedule from key32
*
* Arguments:        key         =   ptr to keyInstance to be initialized
*
* Return:           TRUE on success
*
* Notes:
*   Here we precompute all the round subkeys, although that is not actually
*   required.  For example, on a smartcard, the round subkeys can 
*   be generated on-the-fly using f32()
*
-****************************************************************************/
int reKey(keyInstance *key)
    {
    int     i,j,k64Cnt,keyLen;
    int     subkeyCnt;
    DWORD   A=0,B=0,q;
    DWORD   sKey[MAX_KEY_BITS/64],k32e[MAX_KEY_BITS/64],k32o[MAX_KEY_BITS/64];
    BYTE    L0[256],L1[256];    /* small local 8-bit permutations */

#if VALIDATE_PARMS
  #if ALIGN32
    if (((int)key) & 3)
        return BAD_ALIGN32;
    if ((key->keyLen % 64) || (key->keyLen < MIN_KEY_BITS))
        return BAD_KEY_INSTANCE;
  #endif
#endif

    if (needToBuildMDS)         /* do this one time only */
        BuildMDS();

#define F32(res,x,k32)  \
    {                                                           \
    DWORD t=x;                                                  \
    switch (k64Cnt & 3)                                         \
        {                                                       \
        case 0:  /* same as 4 */                                \
                    b0(t)   = p8(04)[b0(t)] ^ b0(k32[3]);       \
                    b1(t)   = p8(14)[b1(t)] ^ b1(k32[3]);       \
                    b2(t)   = p8(24)[b2(t)] ^ b2(k32[3]);       \
                    b3(t)   = p8(34)[b3(t)] ^ b3(k32[3]);       \
                 /* fall thru, having pre-processed t */        \
        case 3:     b0(t)   = p8(03)[b0(t)] ^ b0(k32[2]);       \
                    b1(t)   = p8(13)[b1(t)] ^ b1(k32[2]);       \
                    b2(t)   = p8(23)[b2(t)] ^ b2(k32[2]);       \
                    b3(t)   = p8(33)[b3(t)] ^ b3(k32[2]);       \
                 /* fall thru, having pre-processed t */        \
        case 2:  /* 128-bit keys (optimize for this case) */    \
            res=    MDStab[0][p8(01)[p8(02)[b0(t)] ^ b0(k32[1])] ^ b0(k32[0])] ^    \
                    MDStab[1][p8(11)[p8(12)[b1(t)] ^ b1(k32[1])] ^ b1(k32[0])] ^    \
                    MDStab[2][p8(21)[p8(22)[b2(t)] ^ b2(k32[1])] ^ b2(k32[0])] ^    \
                    MDStab[3][p8(31)[p8(32)[b3(t)] ^ b3(k32[1])] ^ b3(k32[0])] ;    \
        }                                                       \
    }


#if !CHECK_TABLE
#if defined(USE_ASM)                /* only do this if not using assember */
if (!(useAsm & 4))
#endif
#endif
    {
    subkeyCnt = ROUND_SUBKEYS + 2*key->numRounds;
    keyLen=key->keyLen;
    k64Cnt=(keyLen+63)/64;          /* number of 64-bit key words */
    for (i=0,j=k64Cnt-1;i<k64Cnt;i++,j--)
        {                           /* split into even/odd key dwords */
        k32e[i]=key->key32[2*i  ];
        k32o[i]=key->key32[2*i+1];
        /* compute S-box keys using (12,8) Reed-Solomon code over GF(256) */
        sKey[j]=key->sboxKeys[j]=RS_MDS_Encode(k32e[i],k32o[i]);    /* reverse order */
        }
    }

#ifdef USE_ASM
if (useAsm & 4)
    {
    #if defined(COMPILE_KEY) && defined(USE_ASM)
        key->keySig     = VALID_SIG;            /* show that we are initialized */
        key->codeSize   = sizeof(key->compiledCode);    /* set size */
    #endif
    reKey_86(key);
    }
else
#endif
    {
    for (i=q=0;i<subkeyCnt/2;i++,q+=SK_STEP)    
        {                           /* compute round subkeys for PHT */
        F32(A,q        ,k32e);      /* A uses even key dwords */
        F32(B,q+SK_BUMP,k32o);      /* B uses odd  key dwords */
        B = ROL(B,8);
        key->subKeys[2*i  ] = A+B;  /* combine with a PHT */
        B = A + 2*B;
        key->subKeys[2*i+1] = ROL(B,SK_ROTL);
        }
#if !defined(ZERO_KEY)
    switch (keyLen) /* case out key length for speed in generating S-boxes */
        {
        case 128:
        #if defined(FULL_KEY) || defined(PART_KEY)
#if BIG_TAB
            #define one128(N,J) sbSet(N,i,J,L0[i+J])
            #define sb128(N) {                      \
                BYTE *qq=bigTab[N][b##N(sKey[1])];  \
                Xor256(L0,qq,b##N(sKey[0]));        \
                for (i=0;i<256;i+=2) { one128(N,0); one128(N,1); } }
#else
            #define one128(N,J) sbSet(N,i,J,p8(N##1)[L0[i+J]]^k0)
            #define sb128(N) {                  \
                Xor256(L0,p8(N##2),b##N(sKey[1]));  \
                { register DWORD k0=b##N(sKey[0]);  \
                for (i=0;i<256;i+=2) { one128(N,0); one128(N,1); } } }
#endif
        #elif defined(MIN_KEY)
            #define sb128(N) Xor256(_sBox8_(N),p8(N##2),b##N(sKey[1]))
        #endif
            sb128(0); sb128(1); sb128(2); sb128(3);
            break;
        case 192:
        #if defined(FULL_KEY) || defined(PART_KEY)
            #define one192(N,J) sbSet(N,i,J,p8(N##1)[p8(N##2)[L0[i+J]]^k1]^k0)
            #define sb192(N) {                      \
                Xor256(L0,p8(N##3),b##N(sKey[2]));  \
                { register DWORD k0=b##N(sKey[0]);  \
                  register DWORD k1=b##N(sKey[1]);  \
                  for (i=0;i<256;i+=2) { one192(N,0); one192(N,1); } } }
        #elif defined(MIN_KEY)
            #define one192(N,J) sbSet(N,i,J,p8(N##2)[L0[i+J]]^k1)
            #define sb192(N) {                      \
                Xor256(L0,p8(N##3),b##N(sKey[2]));  \
                { register DWORD k1=b##N(sKey[1]);  \
                  for (i=0;i<256;i+=2) { one192(N,0); one192(N,1); } } }
        #endif
            sb192(0); sb192(1); sb192(2); sb192(3);
            break;
        case 256:
        #if defined(FULL_KEY) || defined(PART_KEY)
            #define one256(N,J) sbSet(N,i,J,p8(N##1)[p8(N##2)[L0[i+J]]^k1]^k0)
            #define sb256(N) {                                      \
                Xor256(L1,p8(N##4),b##N(sKey[3]));                  \
                for (i=0;i<256;i+=2) {L0[i  ]=p8(N##3)[L1[i]];      \
                                      L0[i+1]=p8(N##3)[L1[i+1]]; }  \
                Xor256(L0,L0,b##N(sKey[2]));                        \
                { register DWORD k0=b##N(sKey[0]);                  \
                  register DWORD k1=b##N(sKey[1]);                  \
                  for (i=0;i<256;i+=2) { one256(N,0); one256(N,1); } } }
        #elif defined(MIN_KEY)
            #define one256(N,J) sbSet(N,i,J,p8(N##2)[L0[i+J]]^k1)
            #define sb256(N) {                                      \
                Xor256(L1,p8(N##4),b##N(sKey[3]));                  \
                for (i=0;i<256;i+=2) {L0[i  ]=p8(N##3)[L1[i]];      \
                                      L0[i+1]=p8(N##3)[L1[i+1]]; }  \
                Xor256(L0,L0,b##N(sKey[2]));                        \
                { register DWORD k1=b##N(sKey[1]);                  \
                  for (i=0;i<256;i+=2) { one256(N,0); one256(N,1); } } }
        #endif
            sb256(0); sb256(1); sb256(2); sb256(3);
            break;
        }
#endif
    }

#if CHECK_TABLE                     /* sanity check  vs. pedagogical code*/
    {
    GetSboxKey;
    for (i=0;i<subkeyCnt/2;i++)
        {
        A = f32(i*SK_STEP        ,k32e,keyLen); /* A uses even key dwords */
        B = f32(i*SK_STEP+SK_BUMP,k32o,keyLen); /* B uses odd  key dwords */
        B = ROL(B,8);
        assert(key->subKeys[2*i  ] == A+  B);
        assert(key->subKeys[2*i+1] == ROL(A+2*B,SK_ROTL));
        }
  #if !defined(ZERO_KEY)            /* any S-boxes to check? */
    for (i=q=0;i<256;i++,q+=0x01010101)
        assert(f32(q,key->sboxKeys,keyLen) == Fe32_(q,0));
  #endif
    }
#endif /* CHECK_TABLE */

    DebugDumpKey(key);

    if (key->direction == DIR_ENCRYPT)  
        ReverseRoundSubkeys(key,DIR_ENCRYPT);   /* reverse the round subkey order */

    return TRUE;
    }
/*
+*****************************************************************************
*
* Function Name:    makeKey
*
* Function:         Initialize the Twofish key schedule
*
* Arguments:        key         =   ptr to keyInstance to be initialized
*                   direction   =   DIR_ENCRYPT or DIR_DECRYPT
*                   keyLen      =   # bits of key text at *keyMaterial
*                   keyMaterial =   ptr to hex ASCII chars representing key bits
*
* Return:           TRUE on success
*                   else error code (e.g., BAD_KEY_DIR)
*
* Notes:    This parses the key bits from keyMaterial.  Zeroes out unused key bits
*
-****************************************************************************/
int makeKey(keyInstance *key, BYTE direction, int keyLen,CONST char *keyMaterial)
    {
#if VALIDATE_PARMS              /* first, sanity check on parameters */
    if (key == NULL)            
        return BAD_KEY_INSTANCE;/* must have a keyInstance to initialize */
    if ((direction != DIR_ENCRYPT) && (direction != DIR_DECRYPT))
        return BAD_KEY_DIR;     /* must have valid direction */
    if ((keyLen > MAX_KEY_BITS) || (keyLen < 8) || (keyLen & 0x3F))
        return BAD_KEY_MAT;     /* length must be valid */
    key->keySig = VALID_SIG;    /* show that we are initialized */
  #if ALIGN32
    if ((((int)key) & 3) || (((int)key->key32) & 3))
        return BAD_ALIGN32;
  #endif
#endif

    key->direction  = direction;/* set our cipher direction */
    key->keyLen     = (keyLen+63) & ~63;        /* round up to multiple of 64 */
    key->numRounds  = numRounds[(keyLen-1)/64];
    memset(key->key32,0,sizeof(key->key32));    /* zero unused bits */
    key->keyMaterial[MAX_KEY_SIZE]=0;   /* terminate ASCII string */

    if ((keyMaterial == NULL) || (keyMaterial[0]==0))
        return TRUE;            /* allow a "dummy" call */
        
    if (ParseHexDword(keyLen,keyMaterial,key->key32,key->keyMaterial))
        return BAD_KEY_MAT; 

    return reKey(key);          /* generate round subkeys */
    }


/*
+*****************************************************************************
*
* Function Name:    cipherInit
*
* Function:         Initialize the Twofish cipher in a given mode
*
* Arguments:        cipher      =   ptr to cipherInstance to be initialized
*                   mode        =   MODE_ECB, MODE_CBC, or MODE_CFB1
*                   IV          =   ptr to hex ASCII test representing IV bytes
*
* Return:           TRUE on success
*                   else error code (e.g., BAD_CIPHER_MODE)
*
-****************************************************************************/
int cipherInit(cipherInstance *cipher, BYTE mode,CONST char *IV)
    {
    int i;
#if VALIDATE_PARMS              /* first, sanity check on parameters */
    if (cipher == NULL)         
        return BAD_PARAMS;      /* must have a cipherInstance to initialize */
    if ((mode != MODE_ECB) && (mode != MODE_CBC) && (mode != MODE_CFB1))
        return BAD_CIPHER_MODE; /* must have valid cipher mode */
    cipher->cipherSig   =   VALID_SIG;
  #if ALIGN32
    if ((((int)cipher) & 3) || (((int)cipher->IV) & 3) || (((int)cipher->iv32) & 3))
        return BAD_ALIGN32;
  #endif
#endif

    if ((mode != MODE_ECB) && (IV)) /* parse the IV */
        {
        if (ParseHexDword(BLOCK_SIZE,IV,cipher->iv32,NULL))
            return BAD_IV_MAT;
        for (i=0;i<BLOCK_SIZE/32;i++)   /* make byte-oriented copy for CFB1 */
            ((DWORD *)cipher->IV)[i] = Bswap(cipher->iv32[i]);
        }

    cipher->mode        =   mode;

    return TRUE;
    }

/*
+*****************************************************************************
*
* Function Name:    blockEncrypt
*
* Function:         Encrypt block(s) of data using Twofish
*
* Arguments:        cipher      =   ptr to already initialized cipherInstance
*                   key         =   ptr to already initialized keyInstance
*                   input       =   ptr to data blocks to be encrypted
*                   inputLen    =   # bits to encrypt (multiple of blockSize)
*                   outBuffer   =   ptr to where to put encrypted blocks
*
* Return:           # bits ciphered (>= 0)
*                   else error code (e.g., BAD_CIPHER_STATE, BAD_KEY_MATERIAL)
*
* Notes: The only supported block size for ECB/CBC modes is BLOCK_SIZE bits.
*        If inputLen is not a multiple of BLOCK_SIZE bits in those modes,
*        an error BAD_INPUT_LEN is returned.  In CFB1 mode, all block 
*        sizes can be supported.
*
-****************************************************************************/
int blockEncrypt(cipherInstance *cipher, keyInstance *key,CONST BYTE *input,
                int inputLen, BYTE *outBuffer)
    {
    int   i,n;                      /* loop counters */
    DWORD x[BLOCK_SIZE/32];         /* block being encrypted */
    DWORD t0,t1;                    /* temp variables */
    int   rounds=key->numRounds;    /* number of rounds */
    BYTE  bit,bit0,ctBit,carry;     /* temps for CFB */

    /* make local copies of things for faster access */
    int   mode = cipher->mode;
    DWORD sk[TOTAL_SUBKEYS];
    DWORD IV[BLOCK_SIZE/32];

    GetSboxKey;

#if VALIDATE_PARMS
    if ((cipher == NULL) || (cipher->cipherSig != VALID_SIG))
        return BAD_CIPHER_STATE;
    if ((key == NULL) || (key->keySig != VALID_SIG))
        return BAD_KEY_INSTANCE;
    if ((rounds < 2) || (rounds > MAX_ROUNDS) || (rounds&1))
        return BAD_KEY_INSTANCE;
    if ((mode != MODE_CFB1) && (inputLen % BLOCK_SIZE))
        return BAD_INPUT_LEN;
  #if ALIGN32
    if ( (((int)cipher) & 3) || (((int)key      ) & 3) ||
         (((int)input ) & 3) || (((int)outBuffer) & 3))
        return BAD_ALIGN32;
  #endif
#endif

    if (mode == MODE_CFB1)
        {   /* use recursion here to handle CFB, one block at a time */
        cipher->mode = MODE_ECB;    /* do encryption in ECB */
        for (n=0;n<inputLen;n++)
            {
            blockEncrypt(cipher,key,cipher->IV,BLOCK_SIZE,(BYTE *)x);
            bit0  = 0x80 >> (n & 7);/* which bit position in byte */
            ctBit = (input[n/8] & bit0) ^ ((((BYTE *) x)[0] & 0x80) >> (n&7));
            outBuffer[n/8] = (outBuffer[n/8] & ~ bit0) | ctBit;
            carry = ctBit >> (7 - (n&7));
            for (i=BLOCK_SIZE/8-1;i>=0;i--)
                {
                bit = cipher->IV[i] >> 7;   /* save next "carry" from shift */
                cipher->IV[i] = (cipher->IV[i] << 1) ^ carry;
                carry = bit;
                }
            }
        cipher->mode = MODE_CFB1;   /* restore mode for next time */
        return inputLen;
        }

    /* here for ECB, CBC modes */
    if (key->direction != DIR_ENCRYPT)
        ReverseRoundSubkeys(key,DIR_ENCRYPT);   /* reverse the round subkey order */

#ifdef USE_ASM
    if ((useAsm & 1) && (inputLen))
  #ifdef COMPILE_KEY
        if (key->keySig == VALID_SIG)
            return ((CipherProc *)(key->encryptFuncPtr))(cipher,key,input,inputLen,outBuffer);
  #else 
        return (*blockEncrypt_86)(cipher,key,input,inputLen,outBuffer);
  #endif
#endif
    /* make local copy of subkeys for speed */
    memcpy(sk,key->subKeys,sizeof(DWORD)*(ROUND_SUBKEYS+2*rounds));
    if (mode == MODE_CBC)
        BlockCopy(IV,cipher->iv32)
    else
        IV[0]=IV[1]=IV[2]=IV[3]=0;

    for (n=0;n<inputLen;n+=BLOCK_SIZE,input+=BLOCK_SIZE/8,outBuffer+=BLOCK_SIZE/8)
        {
#ifdef DEBUG
        DebugDump(input,"\n",-1,0,0,0,1);
        if (cipher->mode == MODE_CBC)
            DebugDump(cipher->iv32,"",IV_ROUND,0,0,0,0);
#endif
#define LoadBlockE(N)  x[N]=Bswap(((DWORD *)input)[N]) ^ sk[INPUT_WHITEN+N] ^ IV[N]
        LoadBlockE(0);  LoadBlockE(1);  LoadBlockE(2);  LoadBlockE(3);
        DebugDump(x,"",0,0,0,0,0);
#define EncryptRound(K,R,id)    \
            t0     = Fe32##id(x[K  ],0);                    \
            t1     = Fe32##id(x[K^1],3);                    \
            x[K^3] = ROL(x[K^3],1);                         \
            x[K^2]^= t0 +   t1 + sk[ROUND_SUBKEYS+2*(R)  ]; \
            x[K^3]^= t0 + 2*t1 + sk[ROUND_SUBKEYS+2*(R)+1]; \
            x[K^2] = ROR(x[K^2],1);                         \
            DebugDump(x,"",rounds-(R),0,0,1,0);
#define     Encrypt2(R,id)  { EncryptRound(0,R+1,id); EncryptRound(2,R,id); }

#if defined(ZERO_KEY)
        switch (key->keyLen)
            {
            case 128:
                for (i=rounds-2;i>=0;i-=2)
                    Encrypt2(i,_128);
                break;
            case 192:
                for (i=rounds-2;i>=0;i-=2)
                    Encrypt2(i,_192);
                break;
            case 256:
                for (i=rounds-2;i>=0;i-=2)
                    Encrypt2(i,_256);
                break;
            }
#else
        Encrypt2(14,_);
        Encrypt2(12,_);
        Encrypt2(10,_);
        Encrypt2( 8,_);
        Encrypt2( 6,_);
        Encrypt2( 4,_);
        Encrypt2( 2,_);
        Encrypt2( 0,_);
#endif

        /* need to do (or undo, depending on your point of view) final swap */
#if LittleEndian
#define StoreBlockE(N)  ((DWORD *)outBuffer)[N]=x[N^2] ^ sk[OUTPUT_WHITEN+N]
#else
#define StoreBlockE(N)  { t0=x[N^2] ^ sk[OUTPUT_WHITEN+N]; ((DWORD *)outBuffer)[N]=Bswap(t0); }
#endif
        StoreBlockE(0); StoreBlockE(1); StoreBlockE(2); StoreBlockE(3);
        if (mode == MODE_CBC)
            {
            IV[0]=Bswap(((DWORD *)outBuffer)[0]);
            IV[1]=Bswap(((DWORD *)outBuffer)[1]);
            IV[2]=Bswap(((DWORD *)outBuffer)[2]);
            IV[3]=Bswap(((DWORD *)outBuffer)[3]);
            }
#ifdef DEBUG
        DebugDump(outBuffer,"",rounds+1,0,0,0,1);
        if (cipher->mode == MODE_CBC)
            DebugDump(cipher->iv32,"",IV_ROUND,0,0,0,0);
#endif
        }

    if (mode == MODE_CBC)
        BlockCopy(cipher->iv32,IV);

    return inputLen;
    }

/*
+*****************************************************************************
*
* Function Name:    blockDecrypt
*
* Function:         Decrypt block(s) of data using Twofish
*
* Arguments:        cipher      =   ptr to already initialized cipherInstance
*                   key         =   ptr to already initialized keyInstance
*                   input       =   ptr to data blocks to be decrypted
*                   inputLen    =   # bits to encrypt (multiple of blockSize)
*                   outBuffer   =   ptr to where to put decrypted blocks
*
* Return:           # bits ciphered (>= 0)
*                   else error code (e.g., BAD_CIPHER_STATE, BAD_KEY_MATERIAL)
*
* Notes: The only supported block size for ECB/CBC modes is BLOCK_SIZE bits.
*        If inputLen is not a multiple of BLOCK_SIZE bits in those modes,
*        an error BAD_INPUT_LEN is returned.  In CFB1 mode, all block 
*        sizes can be supported.
*
-****************************************************************************/
int blockDecrypt(cipherInstance *cipher, keyInstance *key,CONST BYTE *input,
                int inputLen, BYTE *outBuffer)
    {
    int   i,n;                      /* loop counters */
    DWORD x[BLOCK_SIZE/32];         /* block being encrypted */
    DWORD t0,t1;                    /* temp variables */
    int   rounds=key->numRounds;    /* number of rounds */
    BYTE  bit,bit0,ctBit,carry;     /* temps for CFB */

    /* make local copies of things for faster access */
    int   mode = cipher->mode;
    DWORD sk[TOTAL_SUBKEYS];
    DWORD IV[BLOCK_SIZE/32];

    GetSboxKey;

#if VALIDATE_PARMS
    if ((cipher == NULL) || (cipher->cipherSig != VALID_SIG))
        return BAD_CIPHER_STATE;
    if ((key == NULL) || (key->keySig != VALID_SIG))
        return BAD_KEY_INSTANCE;
    if ((rounds < 2) || (rounds > MAX_ROUNDS) || (rounds&1))
        return BAD_KEY_INSTANCE;
    if ((cipher->mode != MODE_CFB1) && (inputLen % BLOCK_SIZE))
        return BAD_INPUT_LEN;
  #if ALIGN32
    if ( (((int)cipher) & 3) || (((int)key      ) & 3) ||
         (((int)input)  & 3) || (((int)outBuffer) & 3))
        return BAD_ALIGN32;
  #endif
#endif

    if (cipher->mode == MODE_CFB1)
        {   /* use blockEncrypt here to handle CFB, one block at a time */
        cipher->mode = MODE_ECB;    /* do encryption in ECB */
        for (n=0;n<inputLen;n++)
            {
            blockEncrypt(cipher,key,cipher->IV,BLOCK_SIZE,(BYTE *)x);
            bit0  = 0x80 >> (n & 7);
            ctBit = input[n/8] & bit0;
            outBuffer[n/8] = (outBuffer[n/8] & ~ bit0) |
                             (ctBit ^ ((((BYTE *) x)[0] & 0x80) >> (n&7)));
            carry = ctBit >> (7 - (n&7));
            for (i=BLOCK_SIZE/8-1;i>=0;i--)
                {
                bit = cipher->IV[i] >> 7;   /* save next "carry" from shift */
                cipher->IV[i] = (cipher->IV[i] << 1) ^ carry;
                carry = bit;
                }
            }
        cipher->mode = MODE_CFB1;   /* restore mode for next time */
        return inputLen;
        }

    /* here for ECB, CBC modes */
    if (key->direction != DIR_DECRYPT)
        ReverseRoundSubkeys(key,DIR_DECRYPT);   /* reverse the round subkey order */
#ifdef USE_ASM
    if ((useAsm & 2) && (inputLen))
  #ifdef COMPILE_KEY
        if (key->keySig == VALID_SIG)
            return ((CipherProc *)(key->decryptFuncPtr))(cipher,key,input,inputLen,outBuffer);
  #else 
        return (*blockDecrypt_86)(cipher,key,input,inputLen,outBuffer);
  #endif
#endif
    /* make local copy of subkeys for speed */
    memcpy(sk,key->subKeys,sizeof(DWORD)*(ROUND_SUBKEYS+2*rounds));
    if (mode == MODE_CBC)
        BlockCopy(IV,cipher->iv32)
    else
        IV[0]=IV[1]=IV[2]=IV[3]=0;

    for (n=0;n<inputLen;n+=BLOCK_SIZE,input+=BLOCK_SIZE/8,outBuffer+=BLOCK_SIZE/8)
        {
        DebugDump(input,"\n",rounds+1,0,0,0,1);
#define LoadBlockD(N) x[N^2]=Bswap(((DWORD *)input)[N]) ^ sk[OUTPUT_WHITEN+N]
        LoadBlockD(0);  LoadBlockD(1);  LoadBlockD(2);  LoadBlockD(3);

#define DecryptRound(K,R,id)                                \
            t0     = Fe32##id(x[K  ],0);                    \
            t1     = Fe32##id(x[K^1],3);                    \
            DebugDump(x,"",(R)+1,0,0,1,0);                  \
            x[K^2] = ROL (x[K^2],1);                        \
            x[K^2]^= t0 +   t1 + sk[ROUND_SUBKEYS+2*(R)  ]; \
            x[K^3]^= t0 + 2*t1 + sk[ROUND_SUBKEYS+2*(R)+1]; \
            x[K^3] = ROR (x[K^3],1);                        \

#define     Decrypt2(R,id)  { DecryptRound(2,R+1,id); DecryptRound(0,R,id); }

#if defined(ZERO_KEY)
        switch (key->keyLen)
            {
            case 128:
                for (i=rounds-2;i>=0;i-=2)
                    Decrypt2(i,_128);
                break;
            case 192:
                for (i=rounds-2;i>=0;i-=2)
                    Decrypt2(i,_192);
                break;
            case 256:
                for (i=rounds-2;i>=0;i-=2)
                    Decrypt2(i,_256);
                break;
            }
#else
        {
        Decrypt2(14,_);
        Decrypt2(12,_);
        Decrypt2(10,_);
        Decrypt2( 8,_);
        Decrypt2( 6,_);
        Decrypt2( 4,_);
        Decrypt2( 2,_);
        Decrypt2( 0,_);
        }
#endif
        DebugDump(x,"",0,0,0,0,0);
        if (cipher->mode == MODE_ECB)
            {
#if LittleEndian
#define StoreBlockD(N)  ((DWORD *)outBuffer)[N] = x[N] ^ sk[INPUT_WHITEN+N]
#else
#define StoreBlockD(N)  { t0=x[N]^sk[INPUT_WHITEN+N]; ((DWORD *)outBuffer)[N] = Bswap(t0); }
#endif
            StoreBlockD(0); StoreBlockD(1); StoreBlockD(2); StoreBlockD(3);
#undef  StoreBlockD
            DebugDump(outBuffer,"",-1,0,0,0,1);
            continue;
            }
        else
            {
#define StoreBlockD(N)  x[N]   ^= sk[INPUT_WHITEN+N] ^ IV[N];   \
                        IV[N]   = Bswap(((DWORD *)input)[N]);   \
                        ((DWORD *)outBuffer)[N] = Bswap(x[N]);
            StoreBlockD(0); StoreBlockD(1); StoreBlockD(2); StoreBlockD(3);
#undef  StoreBlockD
            DebugDump(outBuffer,"",-1,0,0,0,1);
            }
        }
    if (mode == MODE_CBC)   /* restore iv32 to cipher */
        BlockCopy(cipher->iv32,IV)

    return inputLen;
    }

#ifdef GetCodeSize
DWORD TwofishCodeSize(void)
    {
    DWORD x= Here(0);
#ifdef USE_ASM
    if (useAsm & 3)
        return TwofishAsmCodeSize();
#endif
    return x - TwofishCodeStart();
    };
#endif



================================================
FILE: Crypt/twofish.h
================================================
/* aes.h */

/* ---------- See examples at end of this file for typical usage -------- */

/* AES Cipher header file for ANSI C Submissions
    Lawrence E. Bassham III
    Computer Security Division
    National Institute of Standards and Technology

    This sample is to assist implementers developing to the
Cryptographic API Profile for AES Candidate Algorithm Submissions.
Please consult this document as a cross-reference.
    
    ANY CHANGES, WHERE APPROPRIATE, TO INFORMATION PROVIDED IN THIS FILE
MUST BE DOCUMENTED. CHANGES ARE ONLY APPROPRIATE WHERE SPECIFIED WITH
THE STRING "CHANGE POSSIBLE". FUNCTION CALLS AND THEIR PARAMETERS
CANNOT BE CHANGED. STRUCTURES CAN BE ALTERED TO ALLOW IMPLEMENTERS TO
INCLUDE IMPLEMENTATION SPECIFIC INFORMATION.
*/

/* Includes:
    Standard include files
*/

#pragma once
#pragma pack(1)

#include    <stdio.h>
#include    "platform.h"            /* platform-specific defines */

/*  Defines:
        Add any additional defines you need
*/

#define     DIR_ENCRYPT     0       /* Are we encrpyting? */
#define     DIR_DECRYPT     1       /* Are we decrpyting? */
#define     MODE_ECB        1       /* Are we ciphering in ECB mode? */
#define     MODE_CBC        2       /* Are we ciphering in CBC mode? */
#define     MODE_CFB1       3       /* Are we ciphering in 1-bit CFB mode? */

#define     TRUE            1
#define     FALSE           0

#define     BAD_KEY_DIR         -1  /* Key direction is invalid (unknown value) */
#define     BAD_KEY_MAT         -2  /* Key material not of correct length */
#define     BAD_KEY_INSTANCE    -3  /* Key passed is not valid */
#define     BAD_CIPHER_MODE     -4  /* Params struct passed to cipherInit invalid */
#define     BAD_CIPHER_STATE    -5  /* Cipher in wrong state (e.g., not initialized) */

/* CHANGE POSSIBLE: inclusion of algorithm specific defines */
/* TWOFISH specific definitions */
#define     MAX_KEY_SIZE        64  /* # of ASCII chars needed to represent a key */
#define     MAX_IV_SIZE         16  /* # of bytes needed to represent an IV */
#define     BAD_INPUT_LEN       -6  /* inputLen not a multiple of block size */
#define     BAD_PARAMS          -7  /* invalid parameters */
#define     BAD_IV_MAT          -8  /* invalid IV text */
#define     BAD_ENDIAN          -9  /* incorrect endianness define */
#define     BAD_ALIGN32         -10 /* incorrect 32-bit alignment */

#define     BLOCK_SIZE          128 /* number of bits per block */
#define     MAX_ROUNDS           16 /* max # rounds (for allocating subkey array) */
#define     ROUNDS_128           16 /* default number of rounds for 128-bit keys*/
#define     ROUNDS_192           16 /* default number of rounds for 192-bit keys*/
#define     ROUNDS_256           16 /* default number of rounds for 256-bit keys*/
#define     MAX_KEY_BITS        256 /* max number of bits of key */
#define     MIN_KEY_BITS        128 /* min number of bits of key (zero pad) */
#define     VALID_SIG    0x48534946 /* initialization signature ('FISH') */
#define     MCT_OUTER           400 /* MCT outer loop */
#define     MCT_INNER         10000 /* MCT inner loop */
#define     REENTRANT             1 /* nonzero forces reentrant code (slightly slower) */

#define     INPUT_WHITEN        0   /* subkey array indices */
#define     OUTPUT_WHITEN       ( INPUT_WHITEN + BLOCK_SIZE/32)
#define     ROUND_SUBKEYS       (OUTPUT_WHITEN + BLOCK_SIZE/32) /* use 2 * (# rounds) */
#define     TOTAL_SUBKEYS       (ROUND_SUBKEYS + 2*MAX_ROUNDS)

/* Typedefs:
    Typedef'ed data storage elements. Add any algorithm specific
    parameters at the bottom of the structs as appropriate.
*/

typedef unsigned char BYTE;
typedef unsigned long DWORD;        /* 32-bit unsigned quantity */
typedef DWORD fullSbox[4][256];

/* The structure for key information */
typedef struct 
    {
    BYTE direction;                 /* Key used for encrypting or decrypting? */
#if ALIGN32
    BYTE dummyAlign[3];             /* keep 32-bit alignment */
#endif
    int  keyLen;                    /* Length of the key */
    char keyMaterial[MAX_KEY_SIZE+4];/* Raw key data in ASCII */

    /* Twofish-specific parameters: */
    DWORD keySig;                   /* set to VALID_SIG by makeKey() */
    int   numRounds;                /* number of rounds in cipher */
    DWORD key32[MAX_KEY_BITS/32];   /* actual key bits, in dwords */
    DWORD sboxKeys[MAX_KEY_BITS/64];/* key bits used for S-boxes */
    DWORD subKeys[TOTAL_SUBKEYS];   /* round subkeys, input/output whitening bits */
#if REENTRANT
    fullSbox sBox8x32;              /* fully expanded S-box */
  #if defined(COMPILE_KEY) && defined(USE_ASM)
#undef  VALID_SIG
#define VALID_SIG    0x504D4F43     /* 'COMP':  C is compiled with -DCOMPILE_KEY */
    DWORD cSig1;                    /* set after first "compile" (zero at "init") */
    void *encryptFuncPtr;           /* ptr to asm encrypt function */
    void *decryptFuncPtr;           /* ptr to asm decrypt function */
    DWORD codeSize;                 /* size of compiledCode */
    DWORD cSig2;                    /* set after first "compile" */
    BYTE  compiledCode[5000];       /* make room for the code itself */
  #endif
#endif
    } keyInstance;

/* The structure for cipher information */
typedef struct 
    {
    BYTE  mode;                     /* MODE_ECB, MODE_CBC, or MODE_CFB1 */
#if ALIGN32
    BYTE dummyAlign[3];             /* keep 32-bit alignment */
#endif
    BYTE  IV[MAX_IV_SIZE];          /* CFB1 iv bytes  (CBC uses iv32) */

    /* Twofish-specific parameters: */
    DWORD cipherSig;                /* set to VALID_SIG by cipherInit() */
    DWORD iv32[BLOCK_SIZE/32];      /* CBC IV bytes arranged as dwords */
    } cipherInstance;

/* Function protoypes */

#ifdef __cplusplus
extern "C"{
#endif

int makeKey(keyInstance *key, BYTE direction, int keyLen, char *keyMaterial);

int cipherInit(cipherInstance *cipher, BYTE mode, char *IV);

int blockEncrypt(cipherInstance *cipher, keyInstance *key, BYTE *input,
                int inputLen, BYTE *outBuffer);

int blockDecrypt(cipherInstance *cipher, keyInstance *key, BYTE *input,
                int inputLen, BYTE *outBuffer);

int reKey(keyInstance *key);    /* do key schedule using modified key.keyDwords */
#ifdef __cplusplus
}
#endif
/* API to check table usage, for use in ECB_TBL KAT */
#define     TAB_DISABLE         0
#define     TAB_ENABLE          1
#define     TAB_RESET           2
#define     TAB_QUERY           3
#define     TAB_MIN_QUERY       50
int TableOp(int op);

#ifndef CONST
#define     CONST               /* helpful C++ syntax sugar, NOP for ANSI C */
#endif

#if BLOCK_SIZE == 128           /* optimize block copies */
#define     Copy1(d,s,N)    ((DWORD *)(d))[N] = ((DWORD *)(s))[N]
#define     BlockCopy(d,s)  { Copy1(d,s,0);Copy1(d,s,1);Copy1(d,s,2);Copy1(d,s,3); }
#else
#define     BlockCopy(d,s)  { memcpy(d,s,BLOCK_SIZE/8); }
#endif


================================================
FILE: Crypt/uo_huffman.cpp
================================================
////////////////////////////////////////////////////////////////////////////////
//
// uo_huffman.cpp
//
//
// Decompression code based	on:
// Ultimate	Melange. Client	for	UO-Emulators
// Copyright (C) 2000 Axel Kittenberger
//
// This	program	is free	software; you can redistribute it and/or modify
// it under	the	terms of the GNU General Public	License	as published by
// the Free	Software Foundation; either	version	2 of the License, or
// (at your	option)	any	later version.
//
////////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "uo_huffman.h"


/*
Decompression Table
This is	a static huffman tree that is walked down for decompression,
negative nodes (and	0) are final values,
positive nodes point to	other nodes.
If drawn this tree is sorted from up to	down (layer	by layer)
and	left to	right.
*/
int Compression::DecompressionTree[] =
{
    /*   0*/     1, 2,
    /*   1*/     3, 4,
    /*   2*/     5, 0,
    /*   3*/     6, 7,
    /*   4*/     8, 9,
    /*   5*/    10,   11,
    /*   6*/    12,   13,
    /*   7*/  -256,   14,
    /*   8*/    15,   16,
    /*   9*/    17,   18,
    /*  10*/    19,   20,
    /*  11*/    21,   22,
    /*  12*/    -1,   23,
    /*  13*/    24,   25,
    /*  14*/    26,   27,
    /*  15*/    28,   29,
    /*  16*/    30,   31,
    /*  17*/    32,   33,
    /*  18*/    34,   35,
    /*  19*/    36,   37,
    /*  20*/    38,   39,
    /*  21*/    40,  -64,
    /*  22*/    41,   42,
    /*  23*/    43,   44,
    /*  24*/    -6,   45,
    /*  25*/    46,   47,
    /*  26*/    48,   49,
    /*  27*/    50,   51,
    /*  28*/  -119,   52,
    /*  29*/   -32,   53,
    /*  30*/    54,  -14,
    /*  31*/    55,   -5,
    /*  32*/    56,   57,
    /*  33*/    58,   59,
    /*  34*/    60,   -2,
    /*  35*/    61,   62,
    /*  36*/    63,   64,
    /*  37*/    65,   66,
    /*  38*/    67,   68,
    /*  39*/    69,   70,
    /*  40*/    71,   72,
    /*  41*/   -51,   73,
    /*  42*/    74,   75,
    /*  43*/    76,   77,
    /*  44*/  -101, -111,
    /*  45*/    -4,  -97,
    /*  46*/    78,   79,
    /*  47*/  -110,   80,
    /*  48*/    81, -116,
    /*  49*/    82,   83,
    /*  50*/    84, -255,
    /*  51*/    85,   86,
    /*  52*/    87,   88,
    /*  53*/    89,   90,
    /*  54*/   -15,  -10,
    /*  55*/    91,   92,
    /*  56*/   -21,   93,
    /*  57*/  -117,   94,
    /*  58*/    95,   96,
    /*  59*/    97,   98,
    /*  60*/    99,  100,
    /*  61*/  -114,  101,
    /*  62*/  -105,  102,
    /*  63*/   -26,  103,
    /*  64*/   104,  105,
    /*  65*/   106,  107,
    /*  66*/   108,  109,
    /*  67*/   110,  111,
    /*  68*/   112,   -3,
    /*  69*/   113,   -7,
    /*  70*/   114, -131,
    /*  71*/   115, -144,
    /*  72*/   116,  117,
    /*  73*/   -20,  118,
    /*  74*/   119,  120,
    /*  75*/   121,  122,
    /*  76*/   123,  124,
    /*  77*/   125,  126,
    /*  78*/   127,  128,
    /*  79*/   129, -100 ,
    /*  80*/   130,   -8,
    /*  81*/   131,  132,
    /*  82*/   133,  134,
    /*  83*/  -120,  135,
    /*  84*/   136,  -31,
    /*  85*/   137,  138,
    /*  86*/  -109, -234,
    /*  87*/   139,  140,
    /*  88*/   141,  142,
    /*  89*/   143,  144,
    /*  90*/  -112,  145,
    /*  91*/   -19,  146,
    /*  92*/   147,  148,
    /*  93*/   149,  -66,
    /*  94*/   150, -145,
    /*  95*/   -13,  -65,
    /*  96*/   151,  152,
    /*  97*/   153,  154,
    /*  98*/   -30,  155,
    /*  99*/   156,  157,
    /* 100*/   -99,  158,
    /* 101*/   159,  160,
    /* 102*/   161,  162,
    /* 103*/   -23,  163,
    /* 104*/   -29,  164,
    /* 105*/   -11,  165,
    /* 106*/   166, -115,
    /* 107*/   167,  168,
    /* 108*/   169,  170,
    /* 109*/   -16,  171,
    /* 110*/   -34,  172,
    /* 111*/   173, -132,
    /* 112*/   174, -108,
    /* 113*/   175,  -22,
    /* 114*/   176,   -9,
    /* 115*/   177,  -84,
    /* 116*/   -17,  -37,
    /* 117*/   -28,  178,
    /* 118*/   179,  180,
    /* 119*/   181,  182,
    /* 120*/   183,  184,
    /* 121*/   185,  186,
    /* 122*/   187, -104,
    /* 123*/   188,  -78,
    /* 124*/   189,  -61,
    /* 125*/   -79, -178,
    /* 126*/   -59, -134,
    /* 127*/   190,  -25,
    /* 128*/   -83,  -18,
    /* 129*/   191,  -57,
    /* 130*/   -67,  192,
    /* 131*/   -98,  193,
    /* 132*/   -12,  -68,
    /* 133*/   194,  195,
    /* 134*/   -55, -128,
    /* 135*/   -24,  -50,
    /* 136*/   -70,  196,
    /* 137*/   -94,  -33,
    /* 138*/   197, -129,
    /* 139*/   -74,  198,
    /* 140*/   -82,  199,
    /* 141*/   -56,  -87,
    /* 142*/   -44,  200,
    /* 143*/  -248,  201,
    /* 144*/  -163,  -81,
    /* 145*/   -52, -123,
    /* 146*/   202, -113,
    /* 147*/   -48,  -41,
    /* 148*/  -122,  -40,
    /* 149*/   203,  -90,
    /* 150*/   -54,  204,
    /* 151*/   -86, -192,
    /* 152*/   205,  206,
    /* 153*/   207, -130,
    /* 154*/   -53,  208,
    /* 155*/  -133,  -45,
    /* 156*/   209,  210,
    /* 157*/   211,  -91,
    /* 158*/   212,  213,
    /* 159*/  -106,  -88,
    /* 160*/   214,  215,
    /* 161*/   216,  217,
    /* 162*/   218,  -49,
    /* 163*/   219,  220,
    /* 164*/   221,  222,
    /* 165*/   223,  224,
    /* 166*/   225,  226,
    /* 167*/   227, -102,
    /* 168*/  -160,  228,
    /* 169*/   -46,  229,
    /* 170*/  -127,  230,
    /* 171*/  -103,  231,
    /* 172*/   232,  233,
    /* 173*/   -60,  234,
    /* 174*/   235,  -76,
    /* 175*/   236, -121,
    /* 176*/   237,  -73,
    /* 177*/  -149,  238,
    /* 178*/   239, -107,
    /* 179*/   -35,  240,
    /* 180*/   -71,  -27,
    /* 181*/   -69,  241,
    /* 182*/   -89,  -77,
    /* 183*/   -62, -118,
    /* 184*/   -75,  -85,
    /* 185*/   -72,  -58,
    /* 186*/   -63,  -80,
    /* 187*/   242,  -42,
    /* 188*/  -150, -157,
    /* 189*/  -139, -236,
    /* 190*/  -126, -243,
    /* 191*/  -142, -214,
    /* 192*/  -138, -206,
    /* 193*/  -240, -146,
    /* 194*/  -204, -147,
    /* 195*/  -152, -201,
    /* 196*/  -227, -207,
    /* 197*/  -154, -209,
    /* 198*/  -153, -254,
    /* 199*/  -176, -156,
    /* 200*/  -165, -210,
    /* 201*/  -172, -185,
    /* 202*/  -195, -170,
    /* 203*/  -232, -211,
    /* 204*/  -219, -239,
    /* 205*/  -200, -177,
    /* 206*/  -175, -212,
    /* 207*/  -244, -143,
    /* 208*/  -246, -171,
    /* 209*/  -203, -221,
    /* 210*/  -202, -181,
    /* 211*/  -173, -250,
    /* 212*/  -184, -164,
    /* 213*/  -193, -218,
    /* 214*/  -199, -220,
    /* 215*/  -190, -249,
    /* 216*/  -230, -217,
    /* 217*/  -169, -216,
    /* 218*/  -191, -197,
    /* 219*/   -47,  243,
    /* 220*/   244,  245,
    /* 221*/   246,  247,
    /* 222*/  -148, -159,
    /* 223*/   248,  249,
    /* 224*/   -92,  -93,
    /* 225*/   -96, -225,
    /* 226*/  -151,  -95,
    /* 227*/   250,  251,
    /* 228*/  -241,  252,
    /* 229*/  -161,  -36,
    /* 230*/   253,  254,
    /* 231*/  -135,  -39,
    /* 232*/  -187, -124,
    /* 233*/   255, -251,
    /* 234*/  -162, -238,
    /* 235*/  -242,  -38,
    /* 236*/   -43, -125,
    /* 237*/  -215, -253,
    /* 238*/  -140, -208,
    /* 239*/  -137, -235,
    /* 240*/  -158, -237,
    /* 241*/  -136, -205,
    /* 242*/  -155, -141,
    /* 243*/  -228, -229,
    /* 244*/  -213, -168,
    /* 245*/  -224, -194,
    /* 246*/  -196, -226,
    /* 247*/  -183, -233,
    /* 248*/  -231, -167,
    /* 249*/  -174, -189,
    /* 250*/  -252, -166,
    /* 251*/  -198, -222,
    /* 252*/  -188, -179,
    /* 253*/  -223, -182,
    /* 254*/  -180, -186,
    /* 255*/  -245, -247,
};

int Compression::CompressionTable[] = 
{
	0x2, 0x000,	0x5, 0x01F,	0x6, 0x022,	0x7, 0x034,	0x7, 0x075,	0x6, 0x028,	0x6, 0x03B,	0x7, 0x032,
	0x8, 0x0E0,	0x8, 0x062,	0x7, 0x056,	0x8, 0x079,	0x9, 0x19D,	0x8, 0x097,	0x6, 0x02A,	0x7, 0x057,
	0x8, 0x071,	0x8, 0x05B,	0x9, 0x1CC,	0x8, 0x0A7,	0x7, 0x025,	0x7, 0x04F,	0x8, 0x066,	0x8, 0x07D,
	0x9, 0x191,	0x9, 0x1CE,	0x7, 0x03F,	0x9, 0x090,	0x8, 0x059,	0x8, 0x07B,	0x8, 0x091,	0x8, 0x0C6,
	0x6, 0x02D,	0x9, 0x186,	0x8, 0x06F,	0x9, 0x093,	0xA, 0x1CC,	0x8, 0x05A,	0xA, 0x1AE,	0xA, 0x1C0,
	0x9, 0x148,	0x9, 0x14A,	0x9, 0x082,	0xA, 0x19F,	0x9, 0x171,	0x9, 0x120,	0x9, 0x0E7,	0xA, 0x1F3,
	0x9, 0x14B,	0x9, 0x100,	0x9, 0x190,	0x6, 0x013,	0x9, 0x161,	0x9, 0x125,	0x9, 0x133,	0x9, 0x195,
	0x9, 0x173,	0x9, 0x1CA,	0x9, 0x086,	0x9, 0x1E9,	0x9, 0x0DB,	0x9, 0x1EC,	0x9, 0x08B,	0x9, 0x085,
	0x5, 0x00A,	0x8, 0x096,	0x8, 0x09C,	0x9, 0x1C3,	0x9, 0x19C,	0x9, 0x08F,	0x9, 0x18F,	0x9, 0x091,
	0x9, 0x087,	0x9, 0x0C6,	0x9, 0x177,	0x9, 0x089,	0x9, 0x0D6,	0x9, 0x08C,	0x9, 0x1EE,	0x9, 0x1EB,
	0x9, 0x084,	0x9, 0x164,	0x9, 0x175,	0x9, 0x1CD,	0x8, 0x05E,	0x9, 0x088,	0x9, 0x12B,	0x9, 0x172,
	0x9, 0x10A,	0x9, 0x08D,	0x9, 0x13A,	0x9, 0x11C,	0xA, 0x1E1,	0xA, 0x1E0,	0x9, 0x187,	0xA, 0x1DC,
	0xA, 0x1DF,	0x7, 0x074,	0x9, 0x19F,	0x8, 0x08D,	0x8, 0x0E4,	0x7, 0x079,	0x9, 0x0EA,	0x9, 0x0E1,
	0x8, 0x040,	0x7, 0x041,	0x9, 0x10B,	0x9, 0x0B0,	0x8, 0x06A,	0x8, 0x0C1,	0x7, 0x071,	0x7, 0x078,
	0x8, 0x0B1,	0x9, 0x14C,	0x7, 0x043,	0x8, 0x076,	0x7, 0x066,	0x7, 0x04D,	0x9, 0x08A,	0x6, 0x02F,
	0x8, 0x0C9,	0x9, 0x0CE,	0x9, 0x149,	0x9, 0x160,	0xA, 0x1BA,	0xA, 0x19E,	0xA, 0x39F,	0x9, 0x0E5,
	0x9, 0x194,	0x9, 0x184,	0x9, 0x126,	0x7, 0x030,	0x8, 0x06C,	0x9, 0x121,	0x9, 0x1E8,	0xA, 0x1C1,
	0xA, 0x11D,	0xA, 0x163,	0xA, 0x385,	0xA, 0x3DB,	0xA, 0x17D,	0xA, 0x106,	0xA, 0x397,	0xA, 0x24E,
	0x7, 0x02E,	0x8, 0x098,	0xA, 0x33C,	0xA, 0x32E,	0xA, 0x1E9,	0x9, 0x0BF,	0xA, 0x3DF,	0xA, 0x1DD,
	0xA, 0x32D,	0xA, 0x2ED,	0xA, 0x30B,	0xA, 0x107,	0xA, 0x2E8,	0xA, 0x3DE,	0xA, 0x125,	0xA, 0x1E8,
	0x9, 0x0E9,	0xA, 0x1CD,	0xA, 0x1B5,	0x9, 0x165,	0xA, 0x232,	0xA, 0x2E1,	0xB, 0x3AE,	0xB, 0x3C6,
	0xB, 0x3E2,	0xA, 0x205,	0xA, 0x29A,	0xA, 0x248,	0xA, 0x2CD,	0xA, 0x23B,	0xB, 0x3C5,	0xA, 0x251,
	0xA, 0x2E9,	0xA, 0x252,	0x9, 0x1EA,	0xB, 0x3A0,	0xB, 0x391,	0xA, 0x23C,	0xB, 0x392,	0xB, 0x3D5,
	0xA, 0x233,	0xA, 0x2CC,	0xB, 0x390,	0xA, 0x1BB,	0xB, 0x3A1,	0xB, 0x3C4,	0xA, 0x211,	0xA, 0x203,
	0x9, 0x12A,	0xA, 0x231,	0xB, 0x3E0,	0xA, 0x29B,	0xB, 0x3D7,	0xA, 0x202,	0xB, 0x3AD,	0xA, 0x213,
	0xA, 0x253,	0xA, 0x32C,	0xA, 0x23D,	0xA, 0x23F,	0xA, 0x32F,	0xA, 0x11C,	0xA, 0x384,	0xA, 0x31C,
	0xA, 0x17C,	0xA, 0x30A,	0xA, 0x2E0,	0xA, 0x276,	0xA, 0x250,	0xB, 0x3E3,	0xA, 0x396,	0xA, 0x18F,
	0xA, 0x204,	0xA, 0x206,	0xA, 0x230,	0xA, 0x265,	0xA, 0x212,	0xA, 0x23E,	0xB, 0x3AC,	0xB, 0x393,
	0xB, 0x3E1,	0xA, 0x1DE,	0xB, 0x3D6,	0xA, 0x31D,	0xB, 0x3E5,	0xB, 0x3E4,	0xA, 0x207,	0xB, 0x3C7,
	0xA, 0x277,	0xB, 0x3D4,	0x8, 0x0C0,	0xA, 0x162,	0xA, 0x3DA,	0xA, 0x124,	0xA, 0x1B4,	0xA, 0x264,
	0xA, 0x33D,	0xA, 0x1D1,	0xA, 0x1AF,	0xA, 0x39E,	0xA, 0x24F,	0xB, 0x373,	0xA, 0x249,	0xB, 0x372,
	0x9, 0x167,	0xA, 0x210,	0xA, 0x23A,	0xA, 0x1B8,	0xB, 0x3AF,	0xA, 0x18E,	0xA, 0x2EC,	0x7, 0x062,
	0x4, 0x00D
};

int Compression::bit_num = 8, Compression::treepos = 0;
int Compression::value, Compression::mask;

int Compression::Compress( char *out_buff, const char *in_buff, int length )
{
	const unsigned char *input = (const unsigned char*)in_buff;
	unsigned char *output = (unsigned char *)out_buff;

	int holdCount = 0;
	int holdValue = 0;

	int packCount = 0;
	int packValue = 0;

	int byteValue = 0;

	int inputLength = length;
	int inputIndex = 0;

	int outputCount = 0;

	while ( inputIndex < inputLength )
	{
		byteValue = input[inputIndex++] << 1;

		packCount = CompressionTable[byteValue];
		packValue = CompressionTable[byteValue | 1];

		holdValue <<= packCount;
		holdValue  |= packValue;
		holdCount  += packCount;

		while ( holdCount >= 8 )
		{
			holdCount -= 8;

			output[outputCount++] = (unsigned char)(holdValue >> holdCount);
		}
	}

	packCount = CompressionTable[0x200];
	packValue = CompressionTable[0x201];

	holdValue <<= packCount;
	holdValue  |= packValue;
	holdCount  += packCount;

	while ( holdCount >= 8 )
	{
		holdCount -= 8;

		output[outputCount++] = (unsigned char)(holdValue >> holdCount);
	}

	if ( holdCount > 0 )
		output[outputCount++] = (unsigned char)(holdValue << (8 - holdCount));

	return outputCount;
}

void Compression::Reset()
{
	bit_num = 8;
	treepos = 0;
}

int Compression::Decompress( char *output, const char *input, int length )
{
	unsigned char *	pdest =	reinterpret_cast<unsigned char *>(output);
	const unsigned char	* psrc = reinterpret_cast<const	unsigned char *>(input);
    int len = length; // len will decrease
    int dest_index = 0;

    while(true)
    {
        if(bit_num == 8)
        {
            // End of input.
            if(len == 0)
                return dest_index;

            len--;
            value = *psrc++;
            bit_num = 0;
            mask = 0x80;
        }
        if(value & mask)
            treepos = DecompressionTree[treepos * 2];
        else
            treepos = DecompressionTree[treepos * 2 + 1];
        mask >>= 1; // shift on reck
        bit_num++;

        if(treepos <= 0) // this is a leaf.
        {
            if(treepos == -256) // special flush character
            {
                bit_num = 8; // flush rest of byte
                treepos = 0; // start on tree top again
                continue;
            }

            pdest[dest_index++] = -treepos;   // data is negative value
            treepos = 0;      // start on tree top again
        }
    }

	return 0;
}


================================================
FILE: Crypt/uo_huffman.h
================================================
#pragma once

class Compression
{
public:
	static int Compress( char *out, const char *in, int inlen );
	static int Decompress( char *out, const char *in, int inlen );

	static void Reset();

protected:
	static int bit_num, treepos;
	static int value, mask;

	static int CompressionTable[];
	static int DecompressionTree[];
};



================================================
FILE: FastColoredTextBox/AutocompleteItem.cs
================================================
using System;
using System.Drawing;
using System.Drawing.Printing;

namespace FastColoredTextBoxNS
{
    /// <summary>
    /// Item of autocomplete menu
    /// </summary>
    public class AutocompleteItem
    {
        public string Text;
        public int ImageIndex = -1;
        public object Tag;
        string toolTipTitle;
        string toolTipText;
        string menuText;
        public AutocompleteMenu Parent { get; internal set; }


        public AutocompleteItem()
        {
        }

        public AutocompleteItem(string text)
        {
            Text = text;
        }

        public AutocompleteItem(string text, int imageIndex)
            : this(text)
        {
            this.ImageIndex = imageIndex;
        }

        public AutocompleteItem(string text, int imageIndex, string menuText)
            : this(text, imageIndex)
        {
            this.menuText = menuText;
        }

        public AutocompleteItem(string text, int imageIndex, string menuText, string toolTipTitle, string toolTipText)
            : this(text, imageIndex, menuText)
        {
            this.toolTipTitle = toolTipTitle;
            this.toolTipText = toolTipText;
        }

        /// <summary>
        /// Returns text for inserting into Textbox
        /// </summary>
        public virtual string GetTextForReplace()
        {
            return Text;
        }

        /// <summary>
        /// Compares fragment text with this item
        /// </summary>
        public virtual CompareResult Compare(string fragmentText)
        {
            if (Text.StartsWith(fragmentText, StringComparison.InvariantCultureIgnoreCase) &&
                Text != fragmentText)
                return CompareResult.VisibleAndSelected;

            return CompareResult.Hidden;
        }

        /// <summary>
        /// Returns text for display into popup menu
        /// </summary>
        public override string ToString()
        {
            return menuText ?? Text;
        }

        /// <summary>
        /// This method is called after item inserted into text
        /// </summary>
        public virtual void OnSelected(AutocompleteMenu popupMenu, SelectedEventArgs e)
        {
            ;
        }

        /// <summary>
        /// Title for tooltip.
        /// </summary>
        /// <remarks>Return null for disable tooltip for this item</remarks>
        public virtual string ToolTipTitle
        {
            get { return toolTipTitle; }
            set { toolTipTitle = value; }
        }

        /// <summary>
        /// Tooltip text.
        /// </summary>
        /// <remarks>For display tooltip text, ToolTipTitle must be not null</remarks>
        public virtual string ToolTipText
        {
            get { return toolTipText; }
            set { toolTipText = value; }
        }

        /// <summary>
        /// Menu text. This text is displayed in the drop-down menu.
        /// </summary>
        public virtual string MenuText
        {
            get { return menuText; }
            set { menuText = value; }
        }

        /// <summary>
        /// Fore color of text of item
        /// </summary>
        public virtual Color ForeColor
        {
            get { return Color.Transparent; }
            set { throw new NotImplementedException("Override this property to change color"); }
        }

        /// <summary>
        /// Back color of item
        /// </summary>
        public virtual Color BackColor
        {
            get { return Color.Transparent; }
            set { throw new NotImplementedException("Override this property to change color"); }
        }
    }

    public enum CompareResult
    {
        /// <summary>
        /// Item do not appears
        /// </summary>
        Hidden,

        /// <summary>
        /// Item appears
        /// </summary>
        Visible,

        /// <summary>
        /// Item appears and will selected
        /// </summary>
        VisibleAndSelected
    }

    /// <summary>
    /// Autocomplete item for code snippets
    /// </summary>
    /// <remarks>Snippet can contain special char ^ for caret position.</remarks>
    public class SnippetAutocompleteItem : AutocompleteItem
    {
        public SnippetAutocompleteItem(string snippet)
        {
            Text = snippet.Replace("\r", "");
            ToolTipTitle = "Code snippet:";
            ToolTipText = Text;
        }

        public override string ToString()
        {
            return MenuText ?? Text.Replace("\n", " ").Replace("^", "");
        }

        public override string GetTextForReplace()
        {
            return Text;
        }

        public override void OnSelected(AutocompleteMenu popupMenu, SelectedEventArgs e)
        {
            e.Tb.BeginUpdate();
            e.Tb.Selection.BeginUpdate();
            //remember places
            var p1 = popupMenu.Fragment.Start;
            var p2 = e.Tb.Selection.Start;
            //do auto indent
            if (e.Tb.AutoIndent)
            {
                for (int iLine = p1.iLine + 1; iLine <= p2.iLine; iLine++)
                {
                    e.Tb.Selection.Start = new Place(0, iLine);
                    e.Tb.DoAutoIndent(iLine);
                }
            }

            e.Tb.Selection.Start = p1;
            //move caret position right and find char ^
            while (e.Tb.Selection.CharBeforeStart != '^')
                if (!e.Tb.Selection.GoRightThroughFolded())
                    break;
            //remove char ^
            e.Tb.Selection.GoLeft(true);
            e.Tb.InsertText("");
            //
            e.Tb.Selection.EndUpdate();
            e.Tb.EndUpdate();
        }

        /// <summary>
        /// Compares fragment text with this item
        /// </summary>
        public override CompareResult Compare(string fragmentText)
        {
            if (Text.StartsWith(fragmentText, StringComparison.InvariantCultureIgnoreCase) &&
                Text != fragmentText)
                return CompareResult.Visible;

            return CompareResult.Hidden;
        }
    }

    /// <summary>
    /// This autocomplete item appears after dot
    /// </summary>
    public class MethodAutocompleteItem : AutocompleteItem
    {
        string firstPart;
        string lowercaseText;

        public MethodAutocompleteItem(string text)
            : base(text)
        {
            lowercaseText = Text.ToLower();
        }

        public override CompareResult Compare(string fragmentText)
        {
            int i = fragmentText.LastIndexOf(' ');
            if (i < 0)
                return CompareResult.Hidden;
            string lastPart = fragmentText.Substring(i + 1);
            firstPart = fragmentText.Substring(0, i);

            if (lastPart == "") return CompareResult.Visible;
            if (Text.StartsWith(lastPart, StringComparison.InvariantCultureIgnoreCase))
                return CompareResult.VisibleAndSelected;
            if (lowercaseText.Contains(lastPart.ToLower()))
                return CompareResult.Visible;

            return CompareResult.Hidden;
        }

        public override string GetTextForReplace()
        {
            return firstPart + " " + Text;
        }
    }

    /// <summary>
    /// This Item does not check correspondence to current text fragment.
    /// SuggestItem is intended for dynamic menus.
    /// </summary>
    public class SuggestItem : AutocompleteItem
    {
        public SuggestItem(string text, int imageIndex) : base(text, imageIndex)
        {
        }

        public override CompareResult Compare(string fragmentText)
        {
            return CompareResult.Visible;
        }
    }
}

================================================
FILE: FastColoredTextBox/AutocompleteMenu.cs
================================================
using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Drawing;
using System.ComponentModel;
using System.Drawing.Drawing2D;
using System.Text.RegularExpressions;

namespace FastColoredTextBoxNS
{
    /// <summary>
    /// Popup menu for autocomplete
    /// </summary>
    [Browsable(false)]
    public class AutocompleteMenu : UserControl, IDisposable
    {
        AutocompleteListView listView;
        public Range Fragment { get; internal set; }

        /// <summary>
        /// Regex pattern for serach fragment around caret
        /// </summary>
        public string SearchPattern { get; set; }

        /// <summary>
        /// Minimum fragment length for popup
        /// </summary>
        public int MinFragmentLength { get; set; }

        /// <summary>
        /// User selects item
        /// </summary>
        public event EventHandler<SelectingEventArgs> Selecting;

        /// <summary>
        /// It fires after item inserting
        /// </summary>
        public event EventHandler<SelectedEventArgs> Selected;

        /// <summary>
        /// Occurs when popup menu is opening
        /// </summary>
        public new event EventHandler<CancelEventArgs> Opening;

        /// <summary>
        /// Allow TAB for select menu item
        /// </summary>
        public bool AllowTabKey
        {
            get { return listView.AllowTabKey; }
            set { listView.AllowTabKey = value; }
        }

        /// <summary>
        /// Interval of menu appear (ms)
        /// </summary>
        public int AppearInterval
        {
            get { return listView.AppearInterval; }
            set { listView.AppearInterval = value; }
        }

        /// <summary>
        /// Sets the max tooltip window size
        /// </summary>
        public Size MaxTooltipSize
        {
            get { return listView.MaxToolTipSize; }
            set { listView.MaxToolTipSize = value; }
        }

        /// <summary>
        /// Tooltip will perm show and duration will be ignored
        /// </summary>
        public bool AlwaysShowTooltip
        {
            get { return listView.AlwaysShowTooltip; }
            set { listView.AlwaysShowTooltip = value; }
        }

        /// <summary>
        /// Back color of selected item
        /// </summary>
        [DefaultValue(typeof(Color), "Orange")]
        public Color SelectedColor
        {
            get { return listView.SelectedColor; }
            set { listView.SelectedColor = value; }
        }

        /// <summary>
        /// Border color of hovered item
        /// </summary>
        [DefaultValue(typeof(Color), "Red")]
        public Color HoveredColor
        {
            get { return listView.HoveredColor; }
            set { listView.HoveredColor = value; }
        }

        public AutocompleteMenu(FastColoredTextBox tb)
        {
            // create a new popup and add the list view to it
            Visible = false;
            BorderStyle = BorderStyle.FixedSingle;
            AutoSize = false;
            Margin = Padding.Empty;
            Padding = Padding.Empty;
            BackColor = Color.White;
            listView = new AutocompleteListView(tb);
           
            CalcSize();
            listView.Parent = this;
            SearchPattern = @"[\w\.]";
            MinFragmentLength = 2;
        }


        public new Font Font
        {
            get { return listView.Font; }
            set { listView.Font = value; }
        }

        new internal void OnOpening(CancelEventArgs args)
        {
            if (Opening != null)
                Opening(this, args);
        }

        public new void Close()
        {
            listView.toolTip.Hide(listView);
            Hide();
        }

        internal void CalcSize()
        {
            Size = new System.Drawing.Size(listView.Size.Width + 4, listView.Size.Height + 4);
        }

        public virtual void OnSelecting()
        {
            listView.OnSelecting();
        }

        public void SelectNext(int shift)
        {
            listView.SelectNext(shift);
        }

        internal void OnSelecting(SelectingEventArgs args)
        {
            if (Selecting != null)
                Selecting(this, args);
        }

        public void OnSelected(SelectedEventArgs args)
        {
            if (Selected != null)
                Selected(this, args);
        }

        public new AutocompleteListView Items
        {
            get { return listView; }
        }

        /// <summary>
        /// Shows popup menu immediately
        /// </summary>
        /// <param name="forced">If True - MinFragmentLength will be ignored</param>
        public void Show(bool forced)
        {
            Items.DoAutocomplete(forced);
        }

        /// <summary>
        /// Minimal size of menu
        /// </summary>
        public new Size MinimumSize
        {
            get { return Items.MinimumSize; }
            set { Items.MinimumSize = value; }
        }

        /// <summary>
        /// Image list of menu
        /// </summary>
        public new ImageList ImageList
        {
            get { return Items.ImageList; }
            set { Items.ImageList = value; }
        }

        /// <summary>
        /// Tooltip duration (ms)
        /// </summary>
        public int ToolTipDuration
        {
            get { return Items.ToolTipDuration; }
            set { Items.ToolTipDuration = value; }
        }

        /// <summary>
        /// Tooltip
        /// </summary>
        public ToolTip ToolTip
        {
            get { return Items.toolTip; }
            set { Items.toolTip = value; }
        }

        protected override void Dispose(bool disposing)
        {
            base.Dispose(disposing);
            if (listView != null && !listView.IsDisposed)
                listView.Dispose();
        }
    }

    [System.ComponentModel.ToolboxItem(false)]
    public class AutocompleteListView : UserControl, IDisposable
    {
        public event EventHandler FocussedItemIndexChanged;

        internal List<AutocompleteItem> visibleItems;
        IEnumerable<AutocompleteItem> sourceItems = new List<AutocompleteItem>();
        int focussedItemIndex = 0;
        int hoveredItemIndex = -1;

        private int ItemHeight
        {
            get { return Font.Height + 2; }
        }

        AutocompleteMenu Menu
        {
            get { return Parent as AutocompleteMenu; }
        }

        int oldItemCount = 0;
        FastColoredTextBox tb;
        internal ToolTip toolTip = new ToolTip();
        System.Windows.Forms.Timer timer = new System.Windows.Forms.Timer();

        internal bool AllowTabKey { get; set; }
        public ImageList ImageList { get; set; }

        internal int AppearInterval
        {
            get { return timer.Interval; }
            set { timer.Interval = value; }
        }

        internal int ToolTipDuration { get; set; }
        internal Size MaxToolTipSize { get; set; }

        internal bool AlwaysShowTooltip
        {
            get { return toolTip.ShowAlways; }
            set { toolTip.ShowAlways = value; }
        }

        public Color SelectedColor { get; set; }
        public Color HoveredColor { get; set; }

        public int FocussedItemIndex
        {
            get { return focussedItemIndex; }
            set
            {
                if (focussedItemIndex != value)
                {
                    focussedItemIndex = value;
                    if (FocussedItemIndexChanged != null)
                        FocussedItemIndexChanged(this, EventArgs.Empty);
                }
            }
        }

        public AutocompleteItem FocussedItem
        {
            get
            {
                if (FocussedItemIndex >= 0 && focussedItemIndex < visibleItems.Count)
                    return visibleItems[focussedItemIndex];
                return null;
            }
            set { FocussedItemIndex = visibleItems.IndexOf(value); }
        }

        internal AutocompleteListView(FastColoredTextBox tb)
        {
            SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.OptimizedDoubleBuffer | ControlStyles.UserPaint,
                true);
            base.Font = new Font(FontFamily.GenericSansSerif, 9);
            visibleItems = new List<AutocompleteItem>();
            VerticalScroll.SmallChange = ItemHeight;
            MaximumSize = new Size(Size.Width, 180);
            toolTip.ShowAlways = false;
            AppearInterval = 500;
            timer.Tick += new EventHandler(timer_Tick);
            SelectedColor = Color.Orange;
            HoveredColor = Color.Red;
            ToolTipDuration = 3000;
            toolTip.Popup += ToolTip_Popup;

            MouseDown += new MouseEventHandler(ListMouseDown);

            this.tb = tb;

            tb.KeyDown += new KeyEventHandler(tb_KeyDown);
            tb.SelectionChanged += new EventHandler(tb_SelectionChanged);
            tb.KeyPressed += new KeyPressEventHandler(tb_KeyPressed);

            Form form = tb.FindForm();
            if (form != null)
            {
                form.LocationChanged += delegate { SafetyClose(); };
                form.ResizeBegin += delegate { SafetyClose(); };
                form.FormClosing += delegate { SafetyClose(); };
                form.LostFocus += delegate { SafetyClose(); };
            }

            tb.LostFocus += (o, e) =>
            {
                if (Menu != null && !Menu.IsDisposed)
                    if (!Menu.Focused)
                        SafetyClose();
            };

            tb.Scroll += delegate { SafetyClose(); };

            this.VisibleChanged += (o, e) =>
            {
                if (this.Visible)
                    DoSelectedVisible();
            };
        }

        private void ListMouseDown(object sender, MouseEventArgs e)
        {
            DoAutocomplete(false);
        }

        private void ToolTip_Popup(object sender, PopupEventArgs e)
        {
            if (MaxToolTipSize.Height > 0 && MaxToolTipSize.Width > 0)
                e.ToolTipSize = MaxToolTipSize;
        }

        protected override void Dispose(bool disposing)
        {
            if (toolTip != null)
            {
                toolTip.Popup -= ToolTip_Popup;
                toolTip.Dispose();
            }

            if (tb != null)
            {
                tb.KeyDown -= tb_KeyDown;
                tb.KeyPress -= tb_KeyPressed;
                tb.SelectionChanged -= tb_SelectionChanged;
            }

            if (timer != null)
            {
                timer.Stop();
                timer.Tick -= timer_Tick;
                timer.Dispose();
            }

            base.Dispose(disposing);
        }

        void SafetyClose()
        {
            if (Menu != null && !Menu.IsDisposed)
                Menu.Close();
        }

        void tb_KeyPressed(object sender, KeyPressEventArgs e)
        {
            bool backspaceORdel = e.KeyChar == '\b' || e.KeyChar == 0xff;

            /*
            if (backspaceORdel)
                prevSelection = tb.Selection.Start;*/

            if (Menu.Visible && !backspaceORdel)
                DoAutocomplete(false);
            else
                ResetTimer(timer);
        }

        void timer_Tick(object sender, EventArgs e)
        {
            timer.Stop();
            DoAutocomplete(false);
        }

        void ResetTimer(System.Windows.Forms.Timer timer)
        {
            timer.Stop();
            timer.Start();
        }

        internal void DoAutocomplete()
        {
            DoAutocomplete(false);
        }

        internal void DoAutocomplete(bool forced)
        {
            if (!Menu.Enabled)
            {
                Menu.Close();
                return;
            }

            visibleItems.Clear();
            FocussedItemIndex = 0;
            VerticalScroll.Value = 0;
            //some magic for update scrolls
            AutoScrollMinSize -= new Size(1, 0);
            AutoScrollMinSize += new Size(1, 0);
            //get fragment around caret
            Range fragment = tb.Selection.GetFragment(Menu.SearchPattern);
            string text = fragment.Text;
            //calc screen point for popup menu
            Point point = tb.PlaceToPoint(fragment.End);
            point.Offset(2, tb.CharHeight);
            //
            if (forced || (text.Length >= Menu.MinFragmentLength
                           && tb.Selection.IsEmpty /*pops up only if selected range is empty*/
                           && (tb.Selection.Start > fragment.Start ||
                               text.Length == 0 /*pops up only if caret is after first letter*/)))
            {
                Menu.Fragment = fragment;
                bool foundSelected = false;
                //build popup menu
                foreach (var item in sourceItems)
                {
                    item.Parent = Menu;
                    CompareResult res = item.Compare(text);
                    if (res != CompareResult.Hidden)
                        visibleItems.Add(item);
                    if (res == CompareResult.VisibleAndSelected && !foundSelected)
                    {
                        foundSelected = true;
                        FocussedItemIndex = visibleItems.Count - 1;
                    }
                }

                if (foundSelected)
                {
                    AdjustScroll();
                }
            }

            //show popup menu
            if (Count > 0)
            {
                if (!Menu.Visible)
                {
                    CancelEventArgs args = new CancelEventArgs();
                    Menu.OnOpening(args);
                    if (!args.Cancel)
                    {
                        Menu.Location = point;
                        Menu.Parent = tb;
                        Menu.Show();
                    }
                }

                DoSelectedVisible();
                Invalidate();
            }
            else
                Menu.Close();
        }

        void tb_SelectionChanged(object sender, EventArgs e)
        {
            /*
            FastColoredTextBox tb = sender as FastColoredTextBox;

            if (Math.Abs(prevSelection.iChar - tb.Selection.Start.iChar) > 1 ||
                        prevSelection.iLine != tb.Selection.Start.iLine)
                Menu.Close();
            prevSelection = tb.Selection.Start;*/
            if (Menu.Visible)
            {
                bool needClose = false;

                if (!tb.Selection.IsEmpty)
                    needClose = true;
                else if (!Menu.Fragment.Contains(tb.Selection.Start))
                {
                    if (tb.Selection.Start.iLine == Menu.Fragment.End.iLine &&
                        tb.Selection.Start.iChar == Menu.Fragment.End.iChar + 1)
                    {
                        //user press key at end of fragment
                        char c = tb.Selection.CharBeforeStart;
                        if (!Regex.IsMatch(c.ToString(), Menu.SearchPattern)) //check char
                            needClose = true;
                    }
                    else
                        needClose = true;
                }

                if (needClose)
                    Menu.Close();
            }
        }

        void tb_KeyDown(object sender, KeyEventArgs e)
        {
            var tb = sender as FastColoredTextBox;

            if (Menu.Visible)
                if (ProcessKey(e.KeyCode, e.Modifiers))
                    e.Handled = true;

            if (!Menu.Visible)
            {
                if (tb.HotkeysMapping.ContainsKey(e.KeyData) &&
                    tb.HotkeysMapping[e.KeyData] == FCTBAction.AutocompleteMenu)
                {
                    DoAutocomplete();
                    e.Handled = true;
                }
                else
                {
                    if (e.KeyCode == Keys.Escape && timer.Enabled)
                        timer.Stop();
                }
            }
        }

        void AdjustScroll()
        {
            if (oldItemCount == visibleItems.Count)
                return;

            int needHeight = ItemHeight * visibleItems.Count + 1;
            Height = Math.Min(needHeight, MaximumSize.Height);
            Menu.CalcSize();

            AutoScrollMinSize = new Size(0, needHeight);
            oldItemCount = visibleItems.Count;
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            AdjustScroll();

            var itemHeight = ItemHeight;
            int startI = VerticalScroll.Value / itemHeight - 1;
            int finishI = (VerticalScroll.Value + ClientSize.Height) / itemHeight + 1;
            startI = Math.Max(startI, 0);
            finishI = Math.Min(finishI, visibleItems.Count);
            int y = 0;
            int leftPadding = 18;
            for (int i = startI; i < finishI; i++)
            {
                y = i * itemHeight - VerticalScroll.Value;

                var item = visibleItems[i];

                if (item.BackColor != Color.Transparent)
                    using (var brush = new SolidBrush(item.BackColor))
                        e.Graphics.FillRectangle(brush, 1, y, ClientSize.Width - 1 - 1, itemHeight - 1);

                if (ImageList != null && visibleItems[i].ImageIndex >= 0)
                    e.Graphics.DrawImage(ImageList.Images[item.ImageIndex], 1, y);

                if (i == FocussedItemIndex)
                    using (var selectedBrush = new LinearGradientBrush(new Point(0, y - 3),
                        new Point(0, y + itemHeight), Color.Transparent, SelectedColor))
                    using (var pen = new Pen(SelectedColor))
                    {
                        e.Graphics.FillRectangle(selectedBrush, leftPadding, y, ClientSize.Width - 1 - leftPadding,
                            itemHeight - 1);
                        e.Graphics.DrawRectangle(pen, leftPadding, y, ClientSize.Width - 1 - leftPadding,
                            itemHeight - 1);
                    }

                if (i == hoveredItemIndex)
                    using (var pen = new Pen(HoveredColor))
                        e.Graphics.DrawRectangle(pen, leftPadding, y, ClientSize.Width - 1 - leftPadding,
                            itemHeight - 1);

                using (var brush = new SolidBrush(item.ForeColor != Color.Transparent ? item.ForeColor : ForeColor))
                    e.Graphics.DrawString(item.ToString(), Font, brush, leftPadding, y);
            }
        }

        public override Color ForeColor { get { return Color.Black; } set { }
        }

        protected override void OnScroll(ScrollEventArgs se)
        {
            base.OnScroll(se);
            Invalidate();
        }

        protected override void OnMouseClick(MouseEventArgs e)
        {
            base.OnMouseClick(e);

            if (e.Button == System.Windows.Forms.MouseButtons.Left || Environment.OSVersion.Platform == PlatformID.Unix)
            {
                FocussedItemIndex = PointToItemIndex(e.Location);
                DoSelectedVisible();
                Invalidate();
            }
        }

        protected override void OnMouseDoubleClick(MouseEventArgs e)
        {
            base.OnMouseDoubleClick(e);
            FocussedItemIndex = PointToItemIndex(e.Location);
            Invalidate();
            OnSelecting();
        }

        internal virtual void OnSelecting()
        {
            if (FocussedItemIndex < 0 || FocussedItemIndex >= visibleItems.Count)
                return;
            tb.TextSource.Manager.BeginAutoUndoCommands();
            try
            {
                AutocompleteItem item = FocussedItem;
                SelectingEventArgs args = new SelectingEventArgs()
                {
                    Item = item,
                    SelectedIndex = FocussedItemIndex
                };

                Menu.OnSelecting(args);

                if (args.Cancel)
                {
                    FocussedItemIndex = args.SelectedIndex;
                    Invalidate();
                    return;
                }

                if (!args.Handled)
                {
                    var fragment = Menu.Fragment;
                    DoAutocomplete(item, fragment);
                }

                Menu.Close();
                //
                SelectedEventArgs args2 = new SelectedEventArgs()
                {
                    Item = item,
                    Tb = Menu.Fragment.tb
                };
                item.OnSelected(Menu, args2);
                Menu.OnSelected(args2);
            }
            finally
            {
                tb.TextSource.Manager.EndAutoUndoCommands();
            }
        }

        private void DoAutocomplete(AutocompleteItem item, Range fragment)
        {
            string newText = fragment.Text;
            int last = newText.LastIndexOf('.');
            if (last > 0)
            {
                newText = newText.Substring(0, last + 1);
            }
            else
            {
                newText = "";
            }

            newText = newText + item;
            if (item.ToolTipText != null)
            {
                newText = newText + " ";
            }

            //replace text of fragment
            var tb = fragment.tb;

            tb.BeginAutoUndo();
            tb.TextSource.Manager.ExecuteCommand(new SelectCommand(tb.TextSource));
            if (tb.Selection.ColumnSelectionMode)
            {
                var start = tb.Selection.Start;
                var end = tb.Selection.End;
                start.iChar = fragment.Start.iChar;
                end.iChar = fragment.End.iChar;
                tb.Selection.Start = start;
                tb.Selection.End = end;
            }
            else
            {
                tb.Selection.Start = fragment.Start;
                tb.Selection.End = fragment.End;
            }

            tb.InsertText(newText);
            tb.TextSource.Manager.ExecuteCommand(new SelectCommand(tb.TextSource));
            tb.EndAutoUndo();
            tb.Focus();
        }

        int PointToItemIndex(Point p)
        {
            return (p.Y + VerticalScroll.Value) / ItemHeight;
        }

        protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
        {
            ProcessKey(keyData, Keys.None);

            return base.ProcessCmdKey(ref msg, keyData);
        }

        private bool ProcessKey(Keys keyData, Keys keyModifiers)
        {
            if (keyModifiers == Keys.None)
                switch (keyData)
                {
                    case Keys.Down:
                        SelectNext(+1);
                        return true;
                    case Keys.PageDown:
                        SelectNext(+10);
                        return true;
                    case Keys.Up:
                        SelectNext(-1);
                        return true;
                    case Keys.PageUp:
                        SelectNext(-10);
                        return true;
                    case Keys.Enter:
                        OnSelecting();
                        return true;
                    case Keys.Tab:
                        if (!AllowTabKey)
                            break;
                        OnSelecting();
                        return true;
                    case Keys.Escape:
                        Menu.Close();
                        return true;
                }

            return false;
        }

        public void SelectNext(int shift)
        {
            FocussedItemIndex = Math.Max(0, Math.Min(FocussedItemIndex + shift, visibleItems.Count - 1));
            DoSelectedVisible();
            Invalidate();
        }

        private void DoSelectedVisible()
        {
            if (FocussedItem != null)
                SetToolTip(FocussedItem);

            var y = FocussedItemIndex * ItemHeight - VerticalScroll.Value;
            if (y < 0)
                VerticalScroll.Value = FocussedItemIndex * ItemHeight;
            if (y > ClientSize.Height - ItemHeight)
                VerticalScroll.Value = Math.Min(VerticalScroll.Maximum,
                    FocussedItemIndex * ItemHeight - ClientSize.Height + ItemHeight);
            //some magic for update scrolls
            AutoScrollMinSize -= new Size(1, 0);
            AutoScrollMinSize += new Size(1, 0);
        }

        private void SetToolTip(AutocompleteItem autocompleteItem)
        {
            var title = autocompleteItem.ToolTipTitle;
            var text = autocompleteItem.ToolTipText;

            if (string.IsNullOrEmpty(title))
            {
                toolTip.ToolTipTitle = null;
                toolTip.SetToolTip(this, null);
                return;
            }

            if (this.Parent != null)
            {
                IWin32Window window = this.Parent ?? this;
               /* Point location;

                if ((this.PointToScreen(this.Location).X + MaxToolTipSize.Width + 105) <
                    Screen.FromControl(this.Parent).WorkingArea.Right)
                    location = new Point(Right + 5, 0);
                else
                    location = new Point(Left - 105 - MaximumSize.Width, 0);*/
                var location = new Point(Right + 3 + Menu.Left, Menu.Top);

                if (string.IsNullOrEmpty(text))
                    toolTip.ToolTipTitle = null;
                else
                    toolTip.ToolTipTitle = title;

                toolTip.Show(text, window, location.X, location.Y, ToolTipDuration);
            }
        }

        public int Count
        {
            get { return visibleItems.Count; }
        }

        public void SetAutocompleteItems(ICollection<string> items)
        {
            List<AutocompleteItem> list = new List<AutocompleteItem>(items.Count);
            foreach (var item in items)
                list.Add(new AutocompleteItem(item));
            SetAutocompleteItems(list);
        }

        public void SetAutocompleteItems(IEnumerable<AutocompleteItem> items)
        {
            sourceItems = items;
        }
    }

    public class SelectingEventArgs : EventArgs
    {
        public AutocompleteItem Item { get; internal set; }
        public bool Cancel { get; set; }
        public int SelectedIndex { get; set; }
        public bool Handled { get; set; }
    }

    public class SelectedEventArgs : EventArgs
    {
        public AutocompleteItem Item { get; internal set; }
        public FastColoredTextBox Tb { get; set; }
    }
}

================================================
FILE: FastColoredTextBox/Bookmarks.cs
================================================
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Text;

namespace FastColoredTextBoxNS
{
    /// <summary>
    /// Base class for bookmark collection
    /// </summary>
    public abstract class BaseBookmarks : ICollection<Bookmark>, IDisposable
    {
        #region ICollection

        public abstract void Add(Bookmark item);
        public abstract void Clear();
        public abstract bool Contains(Bookmark item);
        public abstract void CopyTo(Bookmark[] array, int arrayIndex);
        public abstract int Count { get; }
        public abstract bool IsReadOnly { get; }
        public abstract bool Remove(Bookmark item);
        public abstract IEnumerator<Bookmark> GetEnumerator();

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        #endregion

        #region IDisposable

        public abstract void Dispose();

        #endregion

        #region Additional properties

        public abstract void Add(int lineIndex, string bookmarkName);
        public abstract void Add(int lineIndex);
        public abstract bool Contains(int lineIndex);
        public abstract bool Remove(int lineIndex);
        public abstract Bookmark GetBookmark(int i);

        #endregion
    }

    /// <summary>
    /// Collection of bookmarks
    /// </summary>
    public class Bookmarks : BaseBookmarks
    {
        protected FastColoredTextBox tb;
        protected List<Bookmark> items = new List<Bookmark>();
        protected int counter;

        public Bookmarks(FastColoredTextBox tb)
        {
            this.tb = tb;
            tb.LineInserted += tb_LineInserted;
            tb.LineRemoved += tb_LineRemoved;
        }

        protected virtual void tb_LineRemoved(object sender, LineRemovedEventArgs e)
        {
            for (int i = 0; i < Count; i++)
                if (items[i].LineIndex >= e.Index)
                {
                    if (items[i].LineIndex >= e.Index + e.Count)
                    {
                        items[i].LineIndex = items[i].LineIndex - e.Count;
                        continue;
                    }

                    var was = e.Index <= 0;
                    foreach (var b in items)
                        if (b.LineIndex == e.Index - 1)
                            was = true;

                    if (was)
                    {
                        items.RemoveAt(i);
                        i--;
                    }
                    else
                        items[i].LineIndex = e.Index - 1;

                    //if (items[i].LineIndex == e.Index + e.Count - 1)
                    //{
                    //    items[i].LineIndex = items[i].LineIndex - e.Count;
                    //    continue;
                    //}
                    //
                    //items.RemoveAt(i);
                    //i--;
                }
        }

        protected virtual void tb_LineInserted(object sender, LineInsertedEventArgs e)
        {
            for (int i = 0; i < Count; i++)
                if (items[i].LineIndex >= e.Index)
                {
                    items[i].LineIndex = items[i].LineIndex + e.Count;
                }
                else if (items[i].LineIndex == e.Index - 1 && e.Count == 1)
                {
                    if (tb[e.Index - 1].StartSpacesCount == tb[e.Index - 1].Count)
                        items[i].LineIndex = items[i].LineIndex + e.Count;
                }
        }

        public override void Dispose()
        {
            tb.LineInserted -= tb_LineInserted;
            tb.LineRemoved -= tb_LineRemoved;
        }

        public override IEnumerator<Bookmark> GetEnumerator()
        {
            foreach (var item in items)
                yield return item;
        }

        public override void Add(int lineIndex, string bookmarkName)
        {
            Add(new Bookmark(tb, bookmarkName ?? "Bookmark " + counter, lineIndex));
        }

        public override void Add(int lineIndex)
        {
            Add(new Bookmark(tb, "Bookmark " + counter, lineIndex));
        }

        public override void Clear()
        {
            items.Clear();
            counter = 0;
        }

        public override void Add(Bookmark bookmark)
        {
            foreach (var bm in items)
                if (bm.LineIndex == bookmark.LineIndex)
                    return;

            items.Add(bookmark);
            counter++;
            tb.Invalidate();
        }

        public override bool Contains(Bookmark item)
        {
            return items.Contains(item);
        }

        public override bool Contains(int lineIndex)
        {
            foreach (var item in items)
                if (item.LineIndex == lineIndex)
                    return true;
            return false;
        }

        public override void CopyTo(Bookmark[] array, int arrayIndex)
        {
            items.CopyTo(array, arrayIndex);
        }

        public override int Count
        {
            get { return items.Count; }
        }

        public override bool IsReadOnly
        {
            get { return false; }
        }

        public override bool Remove(Bookmark item)
        {
            tb.Invalidate();
            return items.Remove(item);
        }

        /// <summary>
        /// Removes bookmark by line index
        /// </summary>
        public override bool Remove(int lineIndex)
        {
            bool was = false;
            for (int i = 0; i < Count; i++)
                if (items[i].LineIndex == lineIndex)
                {
                    items.RemoveAt(i);
                    i--;
                    was = true;
                }

            tb.Invalidate();

            return was;
        }

        /// <summary>
        /// Returns Bookmark by index.
        /// </summary>
        public override Bookmark GetBookmark(int i)
        {
            return items[i];
        }
    }

    /// <summary>
    /// Bookmark of FastColoredTextbox
    /// </summary>
    public class Bookmark
    {
        public FastColoredTextBox TB { get; private set; }

        /// <summary>
        /// Name of bookmark
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// Line index
        /// </summary>
        public int LineIndex { get; set; }

        /// <summary>
        /// Color of bookmark sign
        /// </summary>
        public Color Color { get; set; }

        /// <summary>
        /// Scroll textbox to the bookmark
        /// </summary>
        public virtual void DoVisible()
        {
            TB.Selection.Start = new Place(0, LineIndex);
            TB.DoRangeVisible(TB.Selection, true);
            TB.Invalidate();
        }

        public Bookmark(FastColoredTextBox tb, string name, int lineIndex)
        {
            this.TB = tb;
            this.Name = name;
            this.LineIndex = lineIndex;
            Color = tb.BookmarkColor;
        }

        public virtual void Paint(Graphics gr, Rectangle lineRect)
        {
            var size = TB.CharHeight - 1;
            using (var brush =
                new LinearGradientBrush(new Rectangle(0, lineRect.Top, size, size), Color.White, Color, 45))
                gr.FillEllipse(brush, 0, lineRect.Top, size, size);
            using (var pen = new Pen(Color))
                gr.DrawEllipse(pen, 0, lineRect.Top, size, size);
        }
    }
}

================================================
FILE: FastColoredTextBox/Char.cs
================================================
using System;

namespace FastColoredTextBoxNS
{
    /// <summary>
    /// Char and style
    /// </summary>
    public struct Char
    {
        /// <summary>
        /// Unicode character
        /// </summary>
        public char c;

        /// <summary>
        /// Style bit mask
        /// </summary>
        /// <remarks>Bit 1 in position n means that this char will rendering by FastColoredTextBox.Styles[n]</remarks>
        public StyleIndex style;

        public Char(char c)
        {
            this.c = c;
            style = StyleIndex.None;
        }
    }
}

================================================
FILE: FastColoredTextBox/CommandManager.cs
================================================
using System.Collections.Generic;
using System;

namespace FastColoredTextBoxNS
{
    public class CommandManager
    {
        readonly int maxHistoryLength = 200;
        LimitedStack<UndoableCommand> history;
        Stack<UndoableCommand> redoStack = new Stack<UndoableCommand>();
        public TextSource TextSource { get; private set; }
        public bool UndoRedoStackIsEnabled { get; set; }

        public event EventHandler RedoCompleted = delegate { };

        public CommandManager(TextSource ts)
        {
            history = new LimitedStack<UndoableCommand>(maxHistoryLength);
            TextSource = ts;
            UndoRedoStackIsEnabled = true;
        }

        public virtual void ExecuteCommand(Command cmd)
        {
            if (disabledCommands > 0)
                return;

            //multirange ?
            if (cmd.ts.CurrentTB.Selection.ColumnSelectionMode)
                if (cmd is UndoableCommand)
                    //make wrapper
                    cmd = new MultiRangeCommand((UndoableCommand) cmd);


            if (cmd is UndoableCommand)
            {
                //if range is ColumnRange, then create wrapper
                (cmd as UndoableCommand).autoUndo = autoUndoCommands > 0;
                history.Push(cmd as UndoableCommand);
            }

            try
            {
                cmd.Execute();
            }
            catch (ArgumentOutOfRangeException)
            {
                //OnTextChanging cancels enter of the text
                if (cmd is UndoableCommand)
                    history.Pop();
            }

            //
            if (!UndoRedoStackIsEnabled)
                ClearHistory();
            //
            redoStack.Clear();
            //
            TextSource.CurrentTB.OnUndoRedoStateChanged();
        }

        public void Undo()
        {
            if (history.Count > 0)
            {
                var cmd = history.Pop();
                //
                BeginDisableCommands(); //prevent text changing into handlers
                try
                {
                    cmd.Undo();
                }
                finally
                {
                    EndDisableCommands();
                }

                //
                redoStack.Push(cmd);
            }

            //undo next autoUndo command
            if (history.Count > 0)
            {
                if (history.Peek().autoUndo)
                    Undo();
            }

            TextSource.CurrentTB.OnUndoRedoStateChanged();
        }

        protected int disabledCommands = 0;

        private void EndDisableCommands()
        {
            disabledCommands--;
        }

        private void BeginDisableCommands()
        {
            disabledCommands++;
        }

        int autoUndoCommands = 0;

        public void EndAutoUndoCommands()
        {
            autoUndoCommands--;
            if (autoUndoCommands == 0)
                if (history.Count > 0)
                    history.Peek().autoUndo = false;
        }

        public void BeginAutoUndoCommands()
        {
            autoUndoCommands++;
        }

        internal void ClearHistory()
        {
            history.Clear();
            redoStack.Clear();
            TextSource.CurrentTB.OnUndoRedoStateChanged();
        }

        internal void Redo()
        {
            if (redoStack.Count == 0)
                return;
            UndoableCommand cmd;
            BeginDisableCommands(); //prevent text changing into handlers
            try
            {
                cmd = redoStack.Pop();
                if (TextSource.CurrentTB.Selection.ColumnSelectionMode)
                    TextSource.CurrentTB.Selection.ColumnSelectionMode = false;
                TextSource.CurrentTB.Selection.Start = cmd.sel.Start;
                TextSource.CurrentTB.Selection.End = cmd.sel.End;
                cmd.Execute();
                history.Push(cmd);
            }
            finally
            {
                EndDisableCommands();
            }

            //call event
            RedoCompleted(this, EventArgs.Empty);

            //redo command after autoUndoable command
            if (cmd.autoUndo)
                Redo();

            TextSource.CurrentTB.OnUndoRedoStateChanged();
        }

        public bool UndoEnabled
        {
            get { return history.Count > 0; }
        }

        public bool RedoEnabled
        {
            get { return redoStack.Count > 0; }
        }
    }

    public abstract class Command
    {
        public TextSource ts;
        public abstract void Execute();
    }

    internal class RangeInfo
    {
        public Place Start { get; set; }
        public Place End { get; set; }

        public RangeInfo(Range r)
        {
            Start = r.Start;
            End = r.End;
        }

        internal int FromX
        {
            get
            {
                if (End.iLine < Start.iLine) return End.iChar;
                if (End.iLine > Start.iLine) return Start.iChar;
                return Math.Min(End.iChar, Start.iChar);
            }
        }
    }

    public abstract class UndoableCommand : Command
    {
        internal RangeInfo sel;
        internal RangeInfo lastSel;
        internal bool autoUndo;

        public UndoableCommand(TextSource ts)
        {
            this.ts = ts;
            sel = new RangeInfo(ts.CurrentTB.Selection);
        }

        public virtual void Undo()
        {
            OnTextChanged(true);
        }

        public override void Execute()
        {
            lastSel = new RangeInfo(ts.CurrentTB.Selection);
            OnTextChanged(false);
        }

        protected virtual void OnTextChanged(bool invert)
        {
            bool b = sel.Start.iLine < lastSel.Start.iLine;
            if (invert)
            {
                if (b)
                    ts.OnTextChanged(sel.Start.iLine, sel.Start.iLine);
                else
                    ts.OnTextChanged(sel.Start.iLine, lastSel.Start.iLine);
            }
            else
            {
                if (b)
                    ts.OnTextChanged(sel.Start.iLine, lastSel.Start.iLine);
                else
                    ts.OnTextChanged(lastSel.Start.iLine, lastSel.Start.iLine);
            }
        }

        public abstract UndoableCommand Clone();
    }
}

================================================
FILE: FastColoredTextBox/Commands.cs
================================================
using System;
using System.Collections.Generic;

namespace FastColoredTextBoxNS
{
    /// <summary>
    /// Insert single char
    /// </summary>
    /// <remarks>This operation includes also insertion of new line and removing char by backspace</remarks>
    public class InsertCharCommand : UndoableCommand
    {
        public char c;
        char deletedChar = '\x0';

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="tb">Underlaying textbox</param>
        /// <param name="c">Inserting char</param>
        public InsertCharCommand(TextSource ts, char c) : base(ts)
        {
            this.c = c;
        }

        /// <summary>
        /// Undo operation
        /// </summary>
        public override void Undo()
        {
            ts.OnTextChanging();
            switch (c)
            {
                case '\n':
                    MergeLines(sel.Start.iLine, ts);
                    break;
                case '\r': break;
                case '\b':
                    ts.CurrentTB.Selection.Start = lastSel.Start;
                    char cc = '\x0';
                    if (deletedChar != '\x0')
                    {
                        ts.CurrentTB.ExpandBlock(ts.CurrentTB.Selection.Start.iLine);
                        InsertChar(deletedChar, ref cc, ts);
                    }

                    break;
                case '\t':
                    ts.CurrentTB.ExpandBlock(sel.Start.iLine);
                    for (int i = sel.FromX; i < lastSel.FromX; i++)
                        ts[sel.Start.iLine].RemoveAt(sel.Start.iChar);
                    ts.CurrentTB.Selection.Start = sel.Start;
                    break;
                default:
                    ts.CurrentTB.ExpandBlock(sel.Start.iLine);
                    ts[sel.Start.iLine].RemoveAt(sel.Start.iChar);
                    ts.CurrentTB.Selection.Start = sel.Start;
                    break;
            }

            ts.NeedRecalc(new TextSource.TextChangedEventArgs(sel.Start.iLine, sel.Start.iLine));

            base.Undo();
        }

        /// <summary>
        /// Execute operation
        /// </summary>
        public override void Execute()
        {
            ts.CurrentTB.ExpandBlock(ts.CurrentTB.Selection.Start.iLine);
            string s = c.ToString();
            ts.OnTextChanging(ref s);
            if (s.Length == 1)
                c = s[0];

            if (String.IsNullOrEmpty(s))
                throw new ArgumentOutOfRangeException();


            if (ts.Count == 0)
                InsertLine(ts);
            InsertChar(c, ref deletedChar, ts);

            ts.NeedRecalc(new TextSource.TextChangedEventArgs(ts.CurrentTB.Selection.Start.iLine,
                ts.CurrentTB.Selection.Start.iLine));
            base.Execute();
        }

        internal static void InsertChar(char c, ref char deletedChar, TextSource ts)
        {
            var tb = ts.CurrentTB;

            switch (c)
            {
                case '\n':
                    if (!ts.CurrentTB.AllowInsertRemoveLines)
                        throw new ArgumentOutOfRangeException("Cant insert this char in ColumnRange mode");
                    if (ts.Count == 0)
                        InsertLine(ts);
                    InsertLine(ts);
                    break;
                case '\r': break;
                case '\b': //backspace
                    if (tb.Selection.Start.iChar == 0 && tb.Selection.Start.iLine == 0)
                        return;
                    if (tb.Selection.Start.iChar == 0)
                    {
                        if (!ts.CurrentTB.AllowInsertRemoveLines)
                            throw new ArgumentOutOfRangeException("Cant insert this char in ColumnRange mode");
                        if (tb.LineInfos[tb.Selection.Start.iLine - 1].VisibleState != VisibleState.Visible)
                            tb.ExpandBlock(tb.Selection.Start.iLine - 1);
                        deletedChar = '\n';
                        MergeLines(tb.Selection.Start.iLine - 1, ts);
                    }
                    else
                    {
                        deletedChar = ts[tb.Selection.Start.iLine][tb.Selection.Start.iChar - 1].c;
                        ts[tb.Selection.Start.iLine].RemoveAt(tb.Selection.Start.iChar - 1);
                        tb.Selection.Start = new Place(tb.Selection.Start.iChar - 1, tb.Selection.Start.iLine);
                    }

                    break;
                case '\t':
                    int spaceCountNextTabStop = tb.TabLength - (tb.Selection.Start.iChar % tb.TabLength);
                    if (spaceCountNextTabStop == 0)
                        spaceCountNextTabStop = tb.TabLength;

                    for (int i = 0; i < spaceCountNextTabStop; i++)
                        ts[tb.Selection.Start.iLine].Insert(tb.Selection.Start.iChar, new Char(' '));

                    tb.Selection.Start = new Place(tb.Selection.Start.iChar + spaceCountNextTabStop,
                        tb.Selection.Start.iLine);
                    break;
                default:
                    ts[tb.Selection.Start.iLine].Insert(tb.Selection.Start.iChar, new Char(c));
                    tb.Selection.Start = new Place(tb.Selection.Start.iChar + 1, tb.Selection.Start.iLine);
                    break;
            }
        }

        internal static void InsertLine(TextSource ts)
        {
            var tb = ts.CurrentTB;

            if (!tb.Multiline && tb.LinesCount > 0)
                return;

            if (ts.Count == 0)
                ts.InsertLine(0, ts.CreateLine());
            else
                BreakLines(tb.Selection.Start.iLine, tb.Selection.Start.iChar, ts);

            tb.Selection.Start = new Place(0, tb.Selection.Start.iLine + 1);
            ts.NeedRecalc(new TextSource.TextChangedEventArgs(0, 1));
        }

        /// <summary>
        /// Merge lines i and i+1
        /// </summary>
        internal static void MergeLines(int i, TextSource ts)
        {
            var tb = ts.CurrentTB;

            if (i + 1 >= ts.Count)
                return;
            tb.ExpandBlock(i);
            tb.ExpandBlock(i + 1);
            int pos = ts[i].Count;
            //
            /*
            if(ts[i].Count == 0)
                ts.RemoveLine(i);
            else*/
            if (ts[i + 1].Count == 0)
                ts.RemoveLine(i + 1);
            else
            {
                ts[i].AddRange(ts[i + 1]);
                ts.RemoveLine(i + 1);
            }

            tb.Selection.Start = new Place(pos, i);
            ts.NeedRecalc(new TextSource.TextChangedEventArgs(0, 1));
        }

        internal static void BreakLines(int iLine, int pos, TextSource ts)
        {
            Line newLine = ts.CreateLine();
            for (int i = pos; i < ts[iLine].Count; i++)
                newLine.Add(ts[iLine][i]);
            ts[iLine].RemoveRange(pos, ts[iLine].Count - pos);
            //
            ts.InsertLine(iLine + 1, newLine);
        }

        public override UndoableCommand Clone()
        {
            return new InsertCharCommand(ts, c);
        }
    }

    /// <summary>
    /// Insert text
    /// </summary>
    public class InsertTextCommand : UndoableCommand
    {
        public string InsertedText;

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="tb">Underlaying textbox</param>
        /// <param name="insertedText">Text for inserting</param>
        public InsertTextCommand(TextSource ts, string insertedText) : base(ts)
        {
            this.InsertedText = insertedText;
        }

        /// <summary>
        /// Undo operation
        /// </summary>
        public override void Undo()
        {
            ts.CurrentTB.Selection.Start = sel.Start;
            ts.CurrentTB.Selection.End = lastSel.Start;
            ts.OnTextChanging();
            ClearSelectedCommand.ClearSelected(ts);
            base.Undo();
        }

        /// <summary>
        /// Execute operation
        /// </summary>
        public override void Execute()
        {
            ts.OnTextChanging(ref InsertedText);
            InsertText(InsertedText, ts);
            base.Execute();
        }

        internal static void InsertText(string insertedText, TextSource ts)
        {
            var tb = ts.CurrentTB;
            try
            {
                tb.Selection.BeginUpdate();
                char cc = '\x0';

                if (ts.Count == 0)
                {
                    InsertCharCommand.InsertLine(ts);
                    tb.Selection.Start = Place.Empty;
                }

                tb.ExpandBlock(tb.Selection.Start.iLine);
                var len = insertedText.Length;
                for (int i = 0; i < len; i++)
                {
                    var c = insertedText[i];
                    if (c == '\r' && (i >= len - 1 || insertedText[i + 1] != '\n'))
                        InsertCharCommand.InsertChar('\n', ref cc, ts);
                    else
                        InsertCharCommand.InsertChar(c, ref cc, ts);
                }

                ts.NeedRecalc(new TextSource.TextChangedEventArgs(0, 1));
            }
            finally
            {
                tb.Selection.EndUpdate();
            }
        }

        public override UndoableCommand Clone()
        {
            return new InsertTextCommand(ts, InsertedText);
        }
    }

    /// <summary>
    /// Insert text into given ranges
    /// </summary>
    public class ReplaceTextCommand : UndoableCommand
    {
        string insertedText;
        List<Range> ranges;
        List<string> prevText = new List<string>();

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="tb">Underlaying textbox</param>
        /// <param name="ranges">List of ranges for replace</param>
        /// <param name="insertedText">Text for inserting</param>
        public ReplaceTextCommand(TextSource ts, List<Range> ranges, string insertedText)
            : base(ts)
        {
            //sort ranges by place
            ranges.Sort((r1, r2) =>
            {
                if (r1.Start.iLine == r2.Start.iLine)
                    return r1.Start.iChar.CompareTo(r2.Start.iChar);
                return r1.Start.iLine.CompareTo(r2.Start.iLine);
            });
            //
            this.ranges = ranges;
            this.insertedText = insertedText;
            lastSel = sel = new RangeInfo(ts.CurrentTB.Selection);
        }

        /// <summary>
        /// Undo operation
        /// </summary>
        public override void Undo()
        {
            var tb = ts.CurrentTB;

            ts.OnTextChanging();
            tb.BeginUpdate();

            tb.Selection.BeginUpdate();
            for (int i = 0; i < ranges.Count; i++)
            {
                tb.Selection.Start = ranges[i].Start;
                for (int j = 0; j < insertedText.Length; j++)
                    tb.Selection.GoRight(true);
                ClearSelected(ts);
                InsertTextCommand.InsertText(prevText[prevText.Count - i - 1], ts);
            }

            tb.Selection.EndUpdate();
            tb.EndUpdate();

            if (ranges.Count > 0)
                ts.OnTextChanged(ranges[0].Start.iLine, ranges[ranges.Count - 1].End.iLine);

            ts.NeedRecalc(new TextSource.TextChangedEventArgs(0, 1));
        }

        /// <summary>
        /// Execute operation
        /// </summary>
        public override void Execute()
        {
            var tb = ts.CurrentTB;
            prevText.Clear();

            ts.OnTextChanging(ref insertedText);

            tb.Selection.BeginUpdate();
            tb.BeginUpdate();
            for (int i = ranges.Count - 1; i >= 0; i--)
            {
                tb.Selection.Start = ranges[i].Start;
                tb.Selection.End = ranges[i].End;
                prevText.Add(tb.Selection.Text);
                ClearSelected(ts);
                if (insertedText != "")
                    InsertTextCommand.InsertText(insertedText, ts);
            }

            if (ranges.Count > 0)
                ts.OnTextChanged(ranges[0].Start.iLine, ranges[ranges.Count - 1].End.iLine);
            tb.EndUpdate();
            tb.Selection.EndUpdate();
            ts.NeedRecalc(new TextSource.TextChangedEventArgs(0, 1));

            lastSel = new RangeInfo(tb.Selection);
        }

        public override UndoableCommand Clone()
        {
            return new ReplaceTextCommand(ts, new List<Range>(ranges), insertedText);
        }

        internal static void ClearSelected(TextSource ts)
        {
            var tb = ts.CurrentTB;

            tb.Selection.Normalize();

            Place start = tb.Selection.Start;
            Place end = tb.Selection.End;
            int fromLine = Math.Min(end.iLine, start.iLine);
            int toLine = Math.Max(end.iLine, start.iLine);
            int fromChar = tb.Selection.FromX;
            int toChar = tb.Selection.ToX;
            if (fromLine < 0) return;
            //
            if (fromLine == toLine)
                ts[fromLine].RemoveRange(fromChar, toChar - fromChar);
            else
            {
                ts[fromLine].RemoveRange(fromChar, ts[fromLine].Count - fromChar);
                ts[toLine].RemoveRange(0, toChar);
                ts.RemoveLine(fromLine + 1, toLine - fromLine - 1);
                InsertCharCommand.MergeLines(fromLine, ts);
            }
        }
    }

    /// <summary>
    /// Clear selected text
    /// </summary>
    public class ClearSelectedCommand : UndoableCommand
    {
        string deletedText;

        /// <summary>
        /// Construstor
        /// </summary>
        /// <param name="tb">Underlaying textbox</param>
        public ClearSelectedCommand(TextSource ts) : base(ts)
        {
        }

        /// <summary>
        /// Undo operation
        /// </summary>
        public override void Undo()
        {
            ts.CurrentTB.Selection.Start = new Place(sel.FromX, Math.Min(sel.Start.iLine, sel.End.iLine));
            ts.OnTextChanging();
            InsertTextCommand.InsertText(deletedText, ts);
            ts.OnTextChanged(sel.Start.iLine, sel.End.iLine);
            ts.CurrentTB.Selection.Start = sel.Start;
            ts.CurrentTB.Selection.End = sel.End;
        }

        /// <summary>
        /// Execute operation
        /// </summary>
        public override void Execute()
        {
            var tb = ts.CurrentTB;

            string temp = null;
            ts.OnTextChanging(ref temp);
            if (temp == "")
                throw new ArgumentOutOfRangeException();

            deletedText = tb.Selection.Text;
            ClearSelected(ts);
            lastSel = new RangeInfo(tb.Selection);
            ts.OnTextChanged(lastSel.Start.iLine, lastSel.Start.iLine);
        }

        internal static void ClearSelected(TextSource ts)
        {
            var tb = ts.CurrentTB;

            Place start = tb.Selection.Start;
            Place end = tb.Selection.End;
            int fromLine = Math.Min(end.iLine, start.iLine);
            int toLine = Math.Max(end.iLine, start.iLine);
            int fromChar = tb.Selection.FromX;
            int toChar = tb.Selection.ToX;
            if (fromLine < 0) return;
            //
            if (fromLine == toLine)
                ts[fromLine].RemoveRange(fromChar, toChar - fromChar);
            else
            {
                ts[fromLine].RemoveRange(fromChar, ts[fromLine].Count - fromChar);
                ts[toLine].RemoveRange(0, toChar);
                ts.RemoveLine(fromLine + 1, toLine - fromLine - 1);
                InsertCharCommand.MergeLines(fromLine, ts);
            }

            //
            tb.Selection.Start = new Place(fromChar, fromLine);
            //
            ts.NeedRecalc(new TextSource.TextChangedEventArgs(fromLine, toLine));
        }

        public override UndoableCommand Clone()
        {
            return new ClearSelectedCommand(ts);
        }
    }

    /// <summary>
    /// Replaces text
    /// </summary>
    public class ReplaceMultipleTextCommand : UndoableCommand
    {
        List<ReplaceRange> ranges;
        List<string> prevText = new List<string>();

        public class ReplaceRange
        {
            public Range ReplacedRange { get; set; }
            public String ReplaceText { get; set; }
        }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="ts">Underlaying textsource</param>
        /// <param name="ranges">List of ranges for replace</param>
        public ReplaceMultipleTextCommand(TextSource ts, List<ReplaceRange> ranges)
            : base(ts)
        {
            //sort ranges by place
            ranges.Sort((r1, r2) =>
            {
                if (r1.ReplacedRange.Start.iLine == r2.ReplacedRange.Start.iLine)
                    return r1.ReplacedRange.Start.iChar.CompareTo(r2.ReplacedRange.Start.iChar);
                return r1.ReplacedRange.Start.iLine.CompareTo(r2.ReplacedRange.Start.iLine);
            });
            //
            this.ranges = ranges;
            lastSel = sel = new RangeInfo(ts.CurrentTB.Selection);
        }

        /// <summary>
        /// Undo operation
        /// </summary>
        public override void Undo()
        {
            var tb = ts.CurrentTB;

            ts.OnTextChanging();

            tb.Selection.BeginUpdate();
            for (int i = 0; i < ranges.Count; i++)
            {
                tb.Selection.Start = ranges[i].ReplacedRange.Start;
                for (int j = 0; j < ranges[i].ReplaceText.Length; j++)
                    tb.Selection.GoRight(true);
                ClearSelectedCommand.ClearSelected(ts);
                var prevTextIndex = ranges.Count - 1 - i;
                InsertTextCommand.InsertText(prevText[prevTextIndex], ts);
                ts.OnTextChanged(ranges[i].ReplacedRange.Start.iLine, ranges[i].ReplacedRange.Start.iLine);
            }

            tb.Selection.EndUpdate();

            ts.NeedRecalc(new TextSource.TextChangedEventArgs(0, 1));
        }

        /// <summary>
        /// Execute operation
        /// </summary>
        public override void Execute()
        {
            var tb = ts.CurrentTB;
            prevText.Clear();

            ts.OnTextChanging();

            tb.Selection.BeginUpdate();
            for (int i = ranges.Count - 1; i >= 0; i--)
            {
                tb.Selection.Start = ranges[i].ReplacedRange.Start;
                tb.Selection.End = ranges[i].ReplacedRange.End;
                prevText.Add(tb.Selection.Text);
                ClearSelectedCommand.ClearSelected(ts);
                InsertTextCommand.InsertText(ranges[i].ReplaceText, ts);
                ts.OnTextChanged(ranges[i].ReplacedRange.Start.iLine, ranges[i].ReplacedRange.End.iLine);
            }

            tb.Selection.EndUpdate();
            ts.NeedRecalc(new TextSource.TextChangedEventArgs(0, 1));

            lastSel = new RangeInfo(tb.Selection);
        }

        public override UndoableCommand Clone()
        {
            return new ReplaceMultipleTextCommand(ts, new List<ReplaceRange>(ranges));
        }
    }

    /// <summary>
    /// Removes lines
    /// </summary>
    public class RemoveLinesCommand : UndoableCommand
    {
        List<int> iLines;
        List<string> prevText = new List<string>();

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="tb">Underlaying textbox</param>
        /// <param name="ranges">List of ranges for replace</param>
        /// <param name="insertedText">Text for inserting</param>
        public RemoveLinesCommand(TextSource ts, List<int> iLines)
            : base(ts)
        {
            //sort iLines
            iLines.Sort();
            //
            this.iLines = iLines;
            lastSel = sel = new RangeInfo(ts.CurrentTB.Selection);
        }

        /// <summary>
        /// Undo operation
        /// </summary>
        public override void Undo()
        {
            var tb = ts.CurrentTB;

            ts.OnTextChanging();

            tb.Selection.BeginUpdate();
            //tb.BeginUpdate();
            for (int i = 0; i < iLines.Count; i++)
            {
                var iLine = iLines[i];

                if (iLine < ts.Count)
                    tb.Selection.Start = new Place(0, iLine);
                else
                    tb.Selection.Start = new Place(ts[ts.Count - 1].Count, ts.Count - 1);

                InsertCharCommand.InsertLine(ts);
                tb.Selection.Start = new Place(0, iLine);
                var text = prevText[prevText.Count - i - 1];
                InsertTextCommand.InsertText(text, ts);
                ts[iLine].IsChanged = true;
                if (iLine < ts.Count - 1)
                    ts[iLine + 1].IsChanged = true;
                else
                    ts[iLine - 1].IsChanged = true;
                if (text.Trim() != string.Empty)
                    ts.OnTextChanged(iLine, iLine);
            }

            //tb.EndUpdate();
            tb.Selection.EndUpdate();

            ts.NeedRecalc(new TextSource.TextChangedEventArgs(0, 1));
        }

        /// <summary>
        /// Execute operation
        /// </summary>
        public override void Execute()
        {
            var tb = ts.CurrentTB;
            prevText.Clear();

            ts.OnTextChanging();

            tb.Selection.BeginUpdate();
            for (int i = iLines.Count - 1; i >= 0; i--)
            {
                var iLine = iLines[i];

                prevText.Add(ts[iLine].Text); //backward
                ts.RemoveLine(iLine);
                //ts.OnTextChanged(ranges[i].Start.iLine, ranges[i].End.iLine);
            }

            tb.Selection.Start = new Place(0, 0);
            tb.Selection.EndUpdate();
            ts.NeedRecalc(new TextSource.TextChangedEventArgs(0, 1));

            lastSel = new RangeInfo(tb.Selection);
        }

        public override UndoableCommand Clone()
        {
            return new RemoveLinesCommand(ts, new List<int>(iLines));
        }
    }

    /// <summary>
    /// Wrapper for multirange commands
    /// </summary>
    public class MultiRangeCommand : UndoableCommand
    {
        private UndoableCommand cmd;
        private Range range;
        private List<UndoableCommand> commandsByRanges = new List<UndoableCommand>();

        public MultiRangeCommand(UndoableCommand command) : base(command.ts)
        {
            this.cmd = command;
            range = ts.CurrentTB.Selection.Clone();
        }

        public override void Execute()
        {
            commandsByRanges.Clear();
            var prevSelection = range.Clone();
            var iChar = -1;
            var iStartLine = prevSelection.Start.iLine;
            var iEndLine = prevSelection.End.iLine;
            ts.CurrentTB.Selection.ColumnSelectionMode = false;
            ts.CurrentTB.Selection.BeginUpdate();
            ts.CurrentTB.BeginUpdate();
            ts.CurrentTB.AllowInsertRemoveLines = false;
            try
            {
                if (cmd is InsertTextCommand)
                    ExecuteInsertTextCommand(ref iChar, (cmd as InsertTextCommand).InsertedText);
                else if (cmd is InsertCharCommand && (cmd as InsertCharCommand).c != '\x0' &&
                         (cmd as InsertCharCommand).c != '\b') //if not DEL or BACKSPACE
                    ExecuteInsertTextCommand(ref iChar, (cmd as InsertCharCommand).c.ToString());
                else
                    ExecuteCommand(ref iChar);
            }
            catch (ArgumentOutOfRangeException)
            {
            }
            finally
            {
                ts.CurrentTB.AllowInsertRemoveLines = true;
                ts.CurrentTB.EndUpdate();

                ts.CurrentTB.Selection = range;
                if (iChar >= 0)
                {
                    ts.CurrentTB.Selection.Start = new Place(iChar, iStartLine);
                    ts.CurrentTB.Selection.End = new Place(iChar, iEndLine);
                }

                ts.CurrentTB.Selection.ColumnSelectionMode = true;
                ts.CurrentTB.Selection.EndUpdate();
            }
        }

        private void ExecuteInsertTextCommand(ref int iChar, string text)
        {
            var lines = text.Split('\n');
            var iLine = 0;
            foreach (var r in range.GetSubRanges(true))
            {
                var line = ts.CurrentTB[r.Start.iLine];
                var lineIsEmpty = r.End < r.Start && line.StartSpacesCount == line.Count;
                if (!lineIsEmpty)
                {
                    var insertedText = lines[iLine % lines.Length];
                    if (r.End < r.Start && insertedText != "")
                    {
                        //add forwarding spaces
                        insertedText = new string(' ', r.Start.iChar - r.End.iChar) + insertedText;
                        r.Start = r.End;
                    }

                    ts.CurrentTB.Selection = r;
                    var c = new InsertTextCommand(ts, insertedText);
                    c.Execute();
                    if (ts.CurrentTB.Selection.End.iChar > iChar)
                        iChar = ts.CurrentTB.Selection.End.iChar;
                    commandsByRanges.Add(c);
                }

                iLine++;
            }
        }

        private void ExecuteCommand(ref int iChar)
        {
            foreach (var r in range.GetSubRanges(false))
            {
                ts.CurrentTB.Selection = r;
                var c = cmd.Clone();
                c.Execute();
                if (ts.CurrentTB.Selection.End.iChar > iChar)
                    iChar = ts.CurrentTB.Selection.End.iChar;
                commandsByRanges.Add(c);
            }
        }

        public override void Undo()
        {
            ts.CurrentTB.BeginUpdate();
            ts.CurrentTB.Selection.BeginUpdate();
            try
            {
                for (int i = commandsByRanges.Count - 1; i >= 0; i--)
                    commandsByRanges[i].Undo();
            }
            finally
            {
                ts.CurrentTB.Selection.EndUpdate();
                ts.CurrentTB.EndUpdate();
            }

            ts.CurrentTB.Selection = range.Clone();
            ts.CurrentTB.OnTextChanged(range);
            ts.CurrentTB.OnSelectionChanged();
            ts.CurrentTB.Selection.ColumnSelectionMode = true;
        }

        public override UndoableCommand Clone()
        {
            throw new NotImplementedException();
        }
    }

    /// <summary>
    /// Remembers current selection and restore it after Undo
    /// </summary>
    public class SelectCommand : UndoableCommand
    {
        public SelectCommand(TextSource ts) : base(ts)
        {
        }

        public override void Execute()
        {
            //remember selection
            lastSel = new RangeInfo(ts.CurrentTB.Selection);
        }

        protected override void OnTextChanged(bool invert)
        {
        }

        public override void Undo()
        {
            //restore selection
            ts.CurrentTB.Selection = new Range(ts.CurrentTB, lastSel.Start, lastSel.End);
        }

        public override UndoableCommand Clone()
        {
            var result = new SelectCommand(ts);
            if (lastSel != null)
                result.lastSel = new RangeInfo(new Range(ts.CurrentTB, lastSel.Start, lastSel.End));
            return result;
        }
    }
}

================================================
FILE: FastColoredTextBox/DocumentMap.cs
================================================
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Drawing.Drawing2D;
using System.Text;
using System.Windows.Forms;

namespace FastColoredTextBoxNS
{
    /// <summary>
    /// Shows document map of FCTB
    /// </summary>
    public class DocumentMap : Control
    {
        public EventHandler TargetChanged;

        FastColoredTextBox target;
        private float scale = 0.3f;
        private bool needRepaint = true;
        private Place startPlace = Place.Empty;
        private bool scrollbarVisible = true;

        [Description("Target FastColoredTextBox")]
        public FastColoredTextBox Target
        {
            get { return target; }
            set
            {
                if (target != null)
                    UnSubscribe(target);

                target = value;
                if (value != null)
                {
                    Subscribe(target);
                }

                OnTargetChanged();
            }
        }

        /// <summary>
        /// Scale
        /// </summary>
        public float GetScale()
        {
            return scale;
        }

        /// <summary>
        /// Scale
        /// </summary>
        public void SetScale(float value)
        {
            scale = value;
            NeedRepaint();
        }

        /// <summary>
        /// Scrollbar visibility
        /// </summary>
        [Description("Scrollbar visibility")]
        [DefaultValue(true)]
        public bool ScrollbarVisible
        {
            get { return scrollbarVisible; }
            set
            {
                scrollbarVisible = value;
                NeedRepaint();
            }
        }

        public DocumentMap()
        {
            ForeColor = Color.Maroon;
            SetStyle(
                ControlStyles.AllPaintingInWmPaint | ControlStyles.OptimizedDoubleBuffer | ControlStyles.UserPaint |
                ControlStyles.ResizeRedraw, true);
            Application.Idle += Application_Idle;
        }

        void Application_Idle(object sender, EventArgs e)
        {
            if (needRepaint)
                Invalidate();
        }

        protected virtual void OnTargetChanged()
        {
            NeedRepaint();

            if (TargetChanged != null)
                TargetChanged(this, EventArgs.Empty);
        }

        protected virtual void UnSubscribe(FastColoredTextBox target)
        {
            target.Scroll -= new ScrollEventHandler(Target_Scroll);
            target.SelectionChangedDelayed -= new EventHandler(Target_SelectionChanged);
            target.VisibleRangeChanged -= new EventHandler(Target_VisibleRangeChanged);
        }

        protected virtual void Subscribe(FastColoredTextBox target)
        {
            target.Scroll += new ScrollEventHandler(Target_Scroll);
            target.SelectionChangedDelayed += new EventHandler(Target_SelectionChanged);
            target.VisibleRangeChanged += new EventHandler(Target_VisibleRangeChanged);
        }

        protected virtual void Target_VisibleRangeChanged(object sender, EventArgs e)
        {
            NeedRepaint();
        }

        protected virtual void Target_SelectionChanged(object sender, EventArgs e)
        {
            NeedRepaint();
        }

        protected virtual void Target_Scroll(object sender, ScrollEventArgs e)
        {
            NeedRepaint();
        }

        protected override void OnResize(EventArgs e)
        {
            base.OnResize(e);
            NeedRepaint();
        }

        public void NeedRepaint()
        {
            needRepaint = true;
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            if (target == null)
                return;

            var zoom = this.GetScale() * 100 / target.Zoom;

            if (zoom <= float.Epsilon)
                return;

            //calc startPlace
            var r = target.VisibleRange;
            if (startPlace.iLine > r.Start.iLine)
                startPlace.iLine = r.Start.iLine;
            else
            {
                var endP = target.PlaceToPoint(r.End);
                endP.Offset(0, -(int) (ClientSize.Height / zoom) + target.CharHeight);
                var pp = target.PointToPlace(endP);
                if (pp.iLine > startPlace.iLine)
                    startPlace.iLine = pp.iLine;
            }

            startPlace.iChar = 0;
            //calc scroll pos
            var linesCount = target.Lines.Count;
            var sp1 = (float) r.Start.iLine / linesCount;
            var sp2 = (float) r.End.iLine / linesCount;

            //scale graphics
            e.Graphics.ScaleTransform(zoom, zoom);
            //draw text
            var size = new SizeF(ClientSize.Width / zoom, ClientSize.Height / zoom);
            target.DrawText(e.Graphics, startPlace, size.ToSize());

            //draw visible rect
            var p0 = target.PlaceToPoint(startPlace);
            var p1 = target.PlaceToPoint(r.Start);
            var p2 = target.PlaceToPoint(r.End);
            var y1 = p1.Y - p0.Y;
            var y2 = p2.Y + target.CharHeight - p0.Y;

            e.Graphics.SmoothingMode = SmoothingMode.HighQuality;

            using (var brush = new SolidBrush(Color.FromArgb(50, ForeColor)))
            using (var pen = new Pen(brush, 1 / zoom))
            {
                var rect = new Rectangle(0, y1, (int) ((ClientSize.Width - 1) / zoom), y2 - y1);
                e.Graphics.FillRectangle(brush, rect);
                e.Graphics.DrawRectangle(pen, rect);
            }

            //draw scrollbar
            if (scrollbarVisible)
            {
                e.Graphics.ResetTransform();
                e.Graphics.SmoothingMode = SmoothingMode.None;

                using (var brush = new SolidBrush(Color.FromArgb(200, ForeColor)))
                {
                    var rect = new RectangleF(ClientSize.Width - 3, ClientSize.Height * sp1, 2,
                        ClientSize.Height * (sp2 - sp1));
                    e.Graphics.FillRectangle(brush, rect);
                }
            }

            needRepaint = false;
        }

        protected override void OnMouseDown(MouseEventArgs e)
        {
            if (e.Button == System.Windows.Forms.MouseButtons.Left)
                Scroll(e.Location);
            base.OnMouseDown(e);
        }

        protected override void OnMouseMove(MouseEventArgs e)
        {
            if (e.Button == System.Windows.Forms.MouseButtons.Left)
                Scroll(e.Location);
            base.OnMouseMove(e);
        }

        private void Scroll(Point point)
        {
            if (target == null)
                return;

            var zoom = this.GetScale() * 100 / target.Zoom;

            if (zoom <= float.Epsilon)
                return;

            var p0 = target.PlaceToPoint(startPlace);
            p0 = new Point(0, p0.Y + (int) (point.Y / zoom));
            var pp = target.PointToPlace(p0);
            target.DoRangeVisible(new Range(target, pp, pp), true);
            BeginInvoke((MethodInvoker) OnScroll);
        }

        private void OnScroll()
        {
            Refresh();
            target.Refresh();
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                Application.Idle -= Application_Idle;
                if (target != null)
                    UnSubscribe(target);
            }

            base.Dispose(disposing);
        }
    }
}

================================================
FILE: FastColoredTextBox/EncodingDetector.cs
================================================
//          Copyright Tao Klerks, 2010-2012, tao@klerks.biz         
//          Licensed under the modified BSD license.


using System;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;

namespace FastColoredTextBoxNS
{
    public static class EncodingDetector
    {
        const long
            _defaultHeuristicSampleSize =
                0x10000; //completely arbitrary - inappropriate for high numbers of files / high speed requirements

        public static Encoding DetectTextFileEncoding(string InputFilename)
        {
            using (FileStream textfileStream = File.OpenRead(InputFilename))
            {
                return DetectTextFileEncoding(textfileStream, _defaultHeuristicSampleSize);
            }
        }

        public static Encoding DetectTextFileEncoding(FileStream InputFileStream, long HeuristicSampleSize)
        {
            bool uselessBool = false;
            return DetectTextFileEncoding(InputFileStream, _defaultHeuristicSampleSize, out uselessBool);
        }

        public static Encoding DetectTextFileEncoding(FileStream InputFileStream, long HeuristicSampleSize,
            out bool HasBOM)
        {
            Encoding encodingFound = null;

            long originalPos = InputFileStream.Position;

            InputFileStream.Position = 0;


            //First read only what we need for BOM detection
            byte[] bomBytes = new byte[InputFileStream.Length > 4 ? 4 : InputFileStream.Length];
            InputFileStream.Read(bomBytes, 0, bomBytes.Length);

            encodingFound = DetectBOMBytes(bomBytes);

            if (encodingFound != null)
            {
                InputFileStream.Position = originalPos;
                HasBOM = true;
                return encodingFound;
            }


            //BOM Detection failed, going for heuristics now.
            //  create sample byte array and populate it
            byte[] sampleBytes = new byte[HeuristicSampleSize > InputFileStream.Length
                ? InputFileStream.Length
                : HeuristicSampleSize];
            Array.Copy(bomBytes, sampleBytes, bomBytes.Length);
            if (InputFileStream.Length > bomBytes.Length)
                InputFileStream.Read(sampleBytes, bomBytes.Length, sampleBytes.Length - bomBytes.Length);
            InputFileStream.Position = originalPos;

            //test byte array content
            encodingFound = DetectUnicodeInByteSampleByHeuristics(sampleBytes);

            HasBOM = false;
            return encodingFound;
        }

        public static Encoding DetectBOMBytes(byte[] BOMBytes)
        {
            if (BOMBytes.Length < 2)
                return null;

            if (BOMBytes[0] == 0xff
                && BOMBytes[1] == 0xfe
                && (BOMBytes.Length < 4
                    || BOMBytes[2] != 0
                    || BOMBytes[3] != 0
                )
            )
                return Encoding.Unicode;

            if (BOMBytes[0] == 0xfe
                && BOMBytes[1] == 0xff
            )
                return Encoding.BigEndianUnicode;

            if (BOMBytes.Length < 3)
                return null;

            if (BOMBytes[0] == 0xef && BOMBytes[1] == 0xbb && BOMBytes[2] == 0xbf)
                return Encoding.UTF8;

            if (BOMBytes[0] == 0x2b && BOMBytes[1] == 0x2f && BOMBytes[2] == 0x76)
                return Encoding.UTF7;

            if (BOMBytes.Length < 4)
                return null;

            if (BOMBytes[0] == 0xff && BOMBytes[1] == 0xfe && BOMBytes[2] == 0 && BOMBytes[3] == 0)
                return Encoding.UTF32;

            if (BOMBytes[0] == 0 && BOMBytes[1] == 0 && BOMBytes[2] == 0xfe && BOMBytes[3] == 0xff)
                return Encoding.GetEncoding(12001);

            return null;
        }

        public static Encoding DetectUnicodeInByteSampleByHeuristics(byte[] SampleBytes)
        {
            long oddBinaryNullsInSample = 0;
            long evenBinaryNullsInSample = 0;
            long suspiciousUTF8SequenceCount = 0;
            long suspiciousUTF8BytesTotal = 0;
            long likelyUSASCIIBytesInSample = 0;

            //Cycle through, keeping count of binary null positions, possible UTF-8 
            //  sequences from upper ranges of Windows-1252, and probable US-ASCII 
            //  character counts.

            long currentPos = 0;
            int skipUTF8Bytes = 0;

            while (currentPos < SampleBytes.Length)
            {
                //binary null distribution
                if (SampleBytes[currentPos] == 0)
                {
                    if (currentPos % 2 == 0)
                        evenBinaryNullsInSample++;
                    else
                        oddBinaryNullsInSample++;
                }

                //likely US-ASCII characters
                if (IsCommonUSASCIIByte(SampleBytes[currentPos]))
                    likelyUSASCIIBytesInSample++;

                //suspicious sequences (look like UTF-8)
                if (skipUTF8Bytes == 0)
                {
                    int lengthFound = DetectSuspiciousUTF8SequenceLength(SampleBytes, currentPos);

                    if (lengthFound > 0)
                    {
                        suspiciousUTF8SequenceCount++;
                        suspiciousUTF8BytesTotal += lengthFound;
                        skipUTF8Bytes = lengthFound - 1;
                    }
                }
                else
                {
                    skipUTF8Bytes--;
                }

                currentPos++;
            }

            //1: UTF-16 LE - in english / european environments, this is usually characterized by a 
            //  high proportion of odd binary nulls (starting at 0), with (as this is text) a low 
            //  proportion of even binary nulls.
            //  The thresholds here used (less than 20% nulls where you expect non-nulls, and more than
            //  60% nulls where you do expect nulls) are completely arbitrary.

            if (((evenBinaryNullsInSample * 2.0) / SampleBytes.Length) < 0.2
                && ((oddBinaryNullsInSample * 2.0) / SampleBytes.Length) > 0.6
            )
                return Encoding.Unicode;


            //2: UTF-16 BE - in english / european environments, this is usually characterized by a 
            //  high proportion of even binary nulls (starting at 0), with (as this is text) a low 
            //  proportion of odd binary nulls.
            //  The thresholds here used (less than 20% nulls where you expect non-nulls, and more than
            //  60% nulls where you do expect nulls) are completely arbitrary.

            if (((oddBinaryNullsInSample * 2.0) / SampleBytes.Length) < 0.2
                && ((evenBinaryNullsInSample * 2.0) / SampleBytes.Length) > 0.6
            )
                return Encoding.BigEndianUnicode;


            //3: UTF-8 - Martin Dürst outlines a method for detecting whether something CAN be UTF-8 content 
            //  using regexp, in his w3c.org unicode FAQ entry: 
            //  http://www.w3.org/International/questions/qa-forms-utf-8
            //  adapted here for C#.
            string potentiallyMangledString = Encoding.ASCII.GetString(SampleBytes);
            Regex UTF8Validator = new Regex(@"\A("
                                            + @"[\x09\x0A\x0D\x20-\x7E]"
                                            + @"|[\xC2-\xDF][\x80-\xBF]"
                                            + @"|\xE0[\xA0-\xBF][\x80-\xBF]"
                                            + @"|[\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}"
                                            + @"|\xED[\x80-\x9F][\x80-\xBF]"
                                            + @"|\xF0[\x90-\xBF][\x80-\xBF]{2}"
                                            + @"|[\xF1-\xF3][\x80-\xBF]{3}"
                                            + @"|\xF4[\x80-\x8F][\x80-\xBF]{2}"
                                            + @")*\z");
            if (UTF8Validator.IsMatch(potentiallyMangledString))
            {
                //Unfortunately, just the fact that it CAN be UTF-8 doesn't tell you much about probabilities.
                //If all the characters are in the 0-127 range, no harm done, most western charsets are same as UTF-8 in these ranges.
                //If some of the characters were in the upper range (western accented characters), however, they would likely be mangled to 2-byte by the UTF-8 encoding process.
                // So, we need to play stats.

                // The "Random" likelihood of any pair of randomly generated characters being one 
                //   of these "suspicious" character sequences is:
                //     128 / (256 * 256) = 0.2%.
                //
                // In western text data, that is SIGNIFICANTLY reduced - most text data stays in the <127 
                //   character range, so we assume that more than 1 in 500,000 of these character 
                //   sequences indicates UTF-8. The number 500,000 is completely arbitrary - so sue me.
                //
                // We can only assume these character sequences will be rare if we ALSO assume that this
                //   IS in fact western text - in which case the bulk of the UTF-8 encoded data (that is 
                //   not already suspicious sequences) should be plain US-ASCII bytes. This, I 
                //   arbitrarily decided, should be 80% (a random distribution, eg binary data, would yield 
                //   approx 40%, so the chances of hitting this threshold by accident in random data are 
                //   VERY low). 

                if ((suspiciousUTF8SequenceCount * 500000.0 / SampleBytes.Length >= 1) //suspicious sequences
                    && (
                        //all suspicious, so cannot evaluate proportion of US-Ascii
                        SampleBytes.Length - suspiciousUTF8BytesTotal == 0
                        ||
                        likelyUSASCIIBytesInSample * 1.0 / (SampleBytes.Length - suspiciousUTF8BytesTotal) >= 0.8
                    )
                )
                    return Encoding.UTF8;
            }

            return null;
        }

        private static bool IsCommonUSASCIIByte(byte testByte)
        {
            if (testByte == 0x0A //lf
                || testByte == 0x0D //cr
                || testByte == 0x09 //tab
                || (testByte >= 0x20 && testByte <= 0x2F) //common punctuation
                || (testByte >= 0x30 && testByte <= 0x39) //digits
                || (testByte >= 0x3A && testByte <= 0x40) //common punctuation
                || (testByte >= 0x41 && testByte <= 0x5A) //capital letters
                || (testByte >= 0x5B && testByte <= 0x60) //common punctuation
                || (testByte >= 0x61 && testByte <= 0x7A) //lowercase letters
                || (testByte >= 0x7B && testByte <= 0x7E) //common punctuation
            )
                return true;
            else
                return false;
        }

        private static int DetectSuspiciousUTF8SequenceLength(byte[] SampleBytes, long currentPos)
        {
            int lengthFound = 0;

            if (SampleBytes.Length >= currentPos + 1
                && SampleBytes[currentPos] == 0xC2
            )
            {
                if (SampleBytes[currentPos + 1] == 0x81
                    || SampleBytes[currentPos + 1] == 0x8D
                    || SampleBytes[currentPos + 1] == 0x8F
                )
                    lengthFound = 2;
                else if (SampleBytes[currentPos + 1] == 0x90
                         || SampleBytes[currentPos + 1] == 0x9D
                )
                    lengthFound = 2;
                else if (SampleBytes[currentPos + 1] >= 0xA0
                         && SampleBytes[currentPos + 1] <= 0xBF
                )
                    lengthFound = 2;
            }
            else if (SampleBytes.Length >= currentPos + 1
                     && SampleBytes[currentPos] == 0xC3
            )
            {
                if (SampleBytes[currentPos + 1] >= 0x80
                    && SampleBytes[currentPos + 1] <= 0xBF
                )
                    lengthFound = 2;
            }
            else if (SampleBytes.Length >= currentPos + 1
                     && SampleBytes[currentPos] == 0xC5
            )
            {
                if (SampleBytes[currentPos + 1] == 0x92
                    || SampleBytes[currentPos + 1] == 0x93
                )
                    lengthFound = 2;
                else if (SampleBytes[currentPos + 1] == 0xA0
                         || SampleBytes[currentPos + 1] == 0xA1
                )
                    lengthFound = 2;
                else if (SampleBytes[currentPos + 1] == 0xB8
                         || SampleBytes[currentPos + 1] == 0xBD
                         || SampleBytes[currentPos + 1] == 0xBE
                )
                    lengthFound = 2;
            }
            else if (SampleBytes.Length >= currentPos + 1
                     && SampleBytes[currentPos] == 0xC6
            )
            {
                if (SampleBytes[currentPos + 1] == 0x92)
                    lengthFound = 2;
            }
            else if (SampleBytes.Length >= currentPos + 1
                     && SampleBytes[currentPos] == 0xCB
            )
            {
                if (SampleBytes[currentPos + 1] == 0x86
                    || SampleBytes[currentPos + 1] == 0x9C
                )
                    lengthFound = 2;
            }
            else if (SampleBytes.Length >= currentPos + 2
                     && SampleBytes[currentPos] == 0xE2
            )
            {
                if (SampleBytes[currentPos + 1] == 0x80)
                {
                    if (SampleBytes[currentPos + 2] == 0x93
                        || SampleBytes[currentPos + 2] == 0x94
                    )
                        lengthFound = 3;
                    if (SampleBytes[currentPos + 2] == 0x98
                        || SampleBytes[currentPos + 2] == 0x99
                        || SampleBytes[currentPos + 2] == 0x9A
                    )
                        lengthFound = 3;
                    if (SampleBytes[currentPos + 2] == 0x9C
                        || SampleBytes[currentPos + 2] == 0x9D
                        || SampleBytes[currentPos + 2] == 0x9E
                    )
                        lengthFound = 3;
                    if (SampleBytes[currentPos + 2] == 0xA0
                        || SampleBytes[currentPos + 2] == 0xA1
                        || SampleBytes[currentPos + 2] == 0xA2
                    )
                        lengthFound = 3;
                    if (SampleBytes[currentPos + 2] == 0xA6)
                        lengthFound = 3;
                    if (SampleBytes[currentPos + 2] == 0xB0)
                        lengthFound = 3;
                    if (SampleBytes[currentPos + 2] == 0xB9
                        || SampleBytes[currentPos + 2] == 0xBA
                    )
                        lengthFound = 3;
                }
                else if (SampleBytes[currentPos + 1] == 0x82
                         && SampleBytes[currentPos + 2] == 0xAC
                )
                    lengthFound = 3;
                else if (SampleBytes[currentPos + 1] == 0x84
                         && SampleBytes[currentPos + 2] == 0xA2
                )
                    lengthFound = 3;
            }

            return lengthFound;
        }
    }
}

================================================
FILE: FastColoredTextBox/ExportToHTML.cs
================================================
using System.Text;
using System.Drawing;
using System.Collections.Generic;

namespace FastColoredTextBoxNS
{
    /// <summary>
    /// Exports colored text as HTML
    /// </summary>
    /// <remarks>At this time only TextStyle renderer is supported. Other styles is not exported.</remarks>
    public class ExportToHTML
    {
        public string LineNumbersCSS =
            "<style type=\"text/css\"> .lineNumber{font-family : monospace; font-size : small; font-style : normal; font-weight : normal; color : Teal; background-color : ThreedFace;} </style>";

        /// <summary>
        /// Use nbsp; instead space
        /// </summary>
        public bool UseNbsp { get; set; }

        /// <summary>
        /// Use nbsp; instead space in beginning of line
        /// </summary>
        public bool UseForwardNbsp { get; set; }

        /// <summary>
        /// Use original font
        /// </summary>
        public bool UseOriginalFont { get; set; }

        /// <summary>
        /// Use style tag instead style attribute
        /// </summary>
        public bool UseStyleTag { get; set; }

        /// <summary>
        /// Use 'br' tag instead of '\n'
        /// </summary>
        public bool UseBr { get; set; }

        /// <summary>
        /// Includes line numbers
        /// </summary>
        public bool IncludeLineNumbers { get; set; }

        FastColoredTextBox tb;

        public ExportToHTML()
        {
            UseNbsp = true;
            UseOriginalFont = true;
            UseStyleTag = true;
            UseBr = true;
        }

        public string GetHtml(FastColoredTextBox tb)
        {
            this.tb = tb;
            Range sel = new Range(tb);
            sel.SelectAll();
            return GetHtml(sel);
        }

        public string GetHtml(Range r)
        {
            this.tb = r.tb;
            Dictionary<StyleIndex, object> styles = new Dictionary<StyleIndex, object>();
            StringBuilder sb = new StringBuilder();
            StringBuilder tempSB = new StringBuilder();
            StyleIndex currentStyleId = StyleIndex.None;
            r.Normalize();
            int currentLine = r.Start.iLine;
            styles[currentStyleId] = null;
            //
            if (UseOriginalFont)
                sb.AppendFormat("<font style=\"font-family: {0}, monospace; font-size: {1}pt; line-height: {2}px;\">",
                    r.tb.Font.Name, r.tb.Font.SizeInPoints, r.tb.CharHeight);

            //
            if (IncludeLineNumbers)
                tempSB.AppendFormat("<span class=lineNumber>{0}</span>  ", currentLine + 1);
            //
            bool hasNonSpace = false;
            foreach (Place p in r)
            {
                Char c = r.tb[p.iLine][p.iChar];
                if (c.style != currentStyleId)
                {
                    Flush(sb, tempSB, currentStyleId);
                    currentStyleId = c.style;
                    styles[currentStyleId] = null;
                }

                if (p.iLine != currentLine)
                {
                    for (int i = currentLine; i < p.iLine; i++)
                    {
                        tempSB.Append(UseBr ? "<br>" : "\r\n");
                        if (IncludeLineNumbers)
                            tempSB.AppendFormat("<span class=lineNumber>{0}</span>  ", i + 2);
                    }

                    currentLine = p.iLine;
                    hasNonSpace = false;
                }

                switch (c.c)
                {
                    case ' ':
                        if ((hasNonSpace || !UseForwardNbsp) && !UseNbsp)
                            goto default;

                        tempSB.Append("&nbsp;");
                        break;
                    case '<':
                        tempSB.Append("&lt;");
                        break;
                    case '>':
                        tempSB.Append("&gt;");
                        break;
                    case '&':
                        tempSB.Append("&amp;");
                        break;
                    default:
                        hasNonSpace = true;
                        tempSB.Append(c.c);
                        break;
                }
            }

            Flush(sb, tempSB, currentStyleId);

            if (UseOriginalFont)
                sb.Append("</font>");

            //build styles
            if (UseStyleTag)
            {
                tempSB.Length = 0;
                tempSB.Append("<style type=\"text/css\">");
                foreach (var styleId in styles.Keys)
                    tempSB.AppendFormat(".fctb{0}{{ {1} }}\r\n", GetStyleName(styleId), GetCss(styleId));
                tempSB.Append("</style>");

                sb.Insert(0, tempSB.ToString());
            }

            if (IncludeLineNumbers)
                sb.Insert(0, LineNumbersCSS);

            return sb.ToString();
        }

        private string GetCss(StyleIndex styleIndex)
        {
            List<Style> styles = new List<Style>();
            //find text renderer
            TextStyle textStyle = null;
            int mask = 1;
            bool hasTextStyle = false;
            for (int i = 0; i < tb.Styles.Length; i++)
            {
                if (tb.Styles[i] != null && ((int) styleIndex & mask) != 0)
                    if (tb.Styles[i].IsExportable)
                    {
                        var style = tb.Styles[i];
                        styles.Add(style);

                        bool isTextStyle = style is TextStyle;
                        if (isTextStyle)
                            if (!hasTextStyle || tb.AllowSeveralTextStyleDrawing)
                            {
                                hasTextStyle = true;
                                textStyle = style as TextStyle;
                            }
                    }

                mask = mask << 1;
            }

            //add TextStyle css
            string result = "";

            if (!hasTextStyle)
            {
                //draw by default renderer
                result = tb.DefaultStyle.GetCSS();
            }
            else
            {
                result = textStyle.GetCSS();
            }

            //add no TextStyle css
            foreach (var style in styles)
//            if (style != textStyle)
                if (!(style is TextStyle))
                    result += style.GetCSS();

            return result;
        }

        public static string GetColorAsString(Color color)
        {
            if (color == Color.Transparent)
                return "";
            return string.Format("#{0:x2}{1:x2}{2:x2}", color.R, color.G, color.B);
        }

        string GetStyleName(StyleIndex styleIndex)
        {
            return styleIndex.ToString().Replace(" ", "").Replace(",", "");
        }

        private void Flush(StringBuilder sb, StringBuilder tempSB, StyleIndex currentStyle)
        {
            //find textRenderer
            if (tempSB.Length == 0)
                return;
            if (UseStyleTag)
                sb.AppendFormat("<font class=fctb{0}>{1}</font>", GetStyleName(currentStyle), tempSB.ToString());
            else
            {
                string css = GetCss(currentStyle);
                if (css != "")
                    sb.AppendFormat("<font style=\"{0}\">", css);
                sb.Append(tempSB.ToString());
                if (css != "")
                    sb.Append("</font>");
            }

            tempSB.Length = 0;
        }
    }
}

================================================
FILE: FastColoredTextBox/ExportToRTF.cs
================================================
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Text;

namespace FastColoredTextBoxNS
{
    /// <summary>
    /// Exports colored text as RTF
    /// </summary>
    /// <remarks>At this time only TextStyle renderer is supported. Other styles are not exported.</remarks>
    public class ExportToRTF
    {
        /// <summary>
        /// Includes line numbers
        /// </summary>
        public bool IncludeLineNumbers { get; set; }

        /// <summary>
        /// Use original font
        /// </summary>
        public bool UseOriginalFont { get; set; }

        FastColoredTextBox tb;
        Dictionary<Color, int> colorTable = new Dictionary<Color, int>();

        public ExportToRTF()
        {
            UseOriginalFont = true;
        }

        public string GetRtf(FastColoredTextBox tb)
        {
            this.tb = tb;
            Range sel = new Range(tb);
            sel.SelectAll();
            return GetRtf(sel);
        }

        public string GetRtf(Range r)
        {
            this.tb = r.tb;
            var styles = new Dictionary<StyleIndex, object>();
            var sb = new StringBuilder();
            var tempSB = new StringBuilder();
            var currentStyleId = StyleIndex.None;
            r.Normalize();
            int currentLine = r.Start.iLine;
            styles[currentStyleId] = null;
            colorTable.Clear();
            //
            var lineNumberColor = GetColorTableNumber(r.tb.LineNumberColor);

            if (IncludeLineNumbers)
                tempSB.AppendFormat(@"{{\cf{1} {0}}}\tab", currentLine + 1, lineNumberColor);
            //
            foreach (Place p in r)
            {
                Char c = r.tb[p.iLine][p.iChar];
                if (c.style != currentStyleId)
                {
                    Flush(sb, tempSB, currentStyleId);
                    currentStyleId = c.style;
                    styles[currentStyleId] = null;
                }

                if (p.iLine != currentLine)
                {
                    for (int i = currentLine; i < p.iLine; i++)
                    {
                        tempSB.AppendLine(@"\line");
                        if (IncludeLineNumbers)
                            tempSB.AppendFormat(@"{{\cf{1} {0}}}\tab", i + 2, lineNumberColor);
                    }

                    currentLine = p.iLine;
                }

                switch (c.c)
                {
                    case '\\':
                        tempSB.Append(@"\\");
                        break;
                    case '{':
                        tempSB.Append(@"\{");
                        break;
                    case '}':
                        tempSB.Append(@"\}");
                        break;
                    default:
                        var ch = c.c;
                        var code = (int) ch;
                        if (code < 128)
                            tempSB.Append(c.c);
                        else
                            tempSB.AppendFormat(@"{{\u{0}}}", code);
                        break;
                }
            }

            Flush(sb, tempSB, currentStyleId);

            //build color table
            var list = new SortedList<int, Color>();
            foreach (var pair in colorTable)
                list.Add(pair.Value, pair.Key);

            tempSB.Length = 0;
            tempSB.AppendFormat(@"{{\colortbl;");

            foreach (var pair in list)
                tempSB.Append(GetColorAsString(pair.Value) + ";");
            tempSB.AppendLine("}");

            //
            if (UseOriginalFont)
            {
                sb.Insert(0, string.Format(@"{{\fonttbl{{\f0\fmodern {0};}}}}{{\fs{1} ",
                    tb.Font.Name, (int) (2 * tb.Font.SizeInPoints), tb.CharHeight));
                sb.AppendLine(@"}");
            }

            sb.Insert(0, tempSB.ToString());

            sb.Insert(0, @"{\rtf1\ud\deff0");
            sb.AppendLine(@"}");

            return sb.ToString();
        }

        private RTFStyleDescriptor GetRtfDescriptor(StyleIndex styleIndex)
        {
            List<Style> styles = new List<Style>();
            //find text renderer
            TextStyle textStyle = null;
            int mask = 1;
            bool hasTextStyle = false;
            for (int i = 0; i < tb.Styles.Length; i++)
            {
                if (tb.Styles[i] != null && ((int) styleIndex & mask) != 0)
                    if (tb.Styles[i].IsExportable)
                    {
                        var style = tb.Styles[i];
                        styles.Add(style);

                        bool isTextStyle = style is TextStyle;
                        if (isTextStyle)
                            if (!hasTextStyle || tb.AllowSeveralTextStyleDrawing)
                            {
                                hasTextStyle = true;
                                textStyle = style as TextStyle;
                            }
                    }

                mask = mask << 1;
            }

            //add TextStyle css
            RTFStyleDescriptor result = null;

            if (!hasTextStyle)
            {
                //draw by default renderer
                result = tb.DefaultStyle.GetRTF();
            }
            else
            {
                result = textStyle.GetRTF();
            }

            return result;
        }

        public static string GetColorAsString(Color color)
        {
            if (color == Color.Transparent)
                return "";
            return string.Format(@"\red{0}\green{1}\blue{2}", color.R, color.G, color.B);
        }

        private void Flush(StringBuilder sb, StringBuilder tempSB, StyleIndex currentStyle)
        {
            //find textRenderer
            if (tempSB.Length == 0)
                return;

            var desc = GetRtfDescriptor(currentStyle);
            var cf = GetColorTableNumber(desc.ForeColor);
            var cb = GetColorTableNumber(desc.BackColor);
            var tags = new StringBuilder();
            if (cf >= 0)
                tags.AppendFormat(@"\cf{0}", cf);
            if (cb >= 0)
                tags.AppendFormat(@"\highlight{0}", cb);
            if (!string.IsNullOrEmpty(desc.AdditionalTags))
                tags.Append(desc.AdditionalTags.Trim());

            if (tags.Length > 0)
                sb.AppendFormat(@"{{{0} {1}}}", tags, tempSB.ToString());
            else
                sb.Append(tempSB.ToString());
            tempSB.Length = 0;
        }

        private int GetColorTableNumber(Color color)
        {
            if (color.A == 0)
                return -1;

            if (!colorTable.ContainsKey(color))
                colorTable[color] = colorTable.Count + 1;

            return colorTable[color];
        }
    }

    public class RTFStyleDescriptor
    {
        public Color ForeColor { get; set; }
        public Color BackColor { get; set; }
        public string AdditionalTags { get; set; }
    }
}

================================================
FILE: FastColoredTextBox/FastColoredTextBox.cs
================================================
//
//  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
//  KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
//  IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
//  PURPOSE.
//
//  License: GNU Lesser General Public License (LGPLv3)
//
//  Email: pavel_torgashov@ukr.net
//
//  Copyright (C) Pavel Torgashov, 2011-2016. 

// #define debug


// -------------------------------------------------------------------------------
// By default the FastColoredTextbox supports no more 16 styles at the same time.
// This restriction saves memory.
// However, you can to compile FCTB with 32 styles supporting.
// Uncomment following definition if you need 32 styles instead of 16:
//
// #define Styles32

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Design;
using System.Drawing.Drawing2D;
using System.IO;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Windows.Forms;
using System.Windows.Forms.Design;
using Microsoft.Win32;
using Timer = System.Windows.Forms.Timer;

namespace FastColoredTextBoxNS
{
    /// <summary>
    /// Fast colored textbox
    /// </summary>
    public partial class FastColoredTextBox : UserControl, ISupportInitialize
    {
        internal const int minLeftIndent = 8;
        private const int maxBracketSearchIterations = 1000;
        private const int maxLinesForFolding = 3000;
        private const int minLinesForAccuracy = 100000;
        private const int WM_IME_SETCONTEXT = 0x0281;
        private const int WM_HSCROLL = 0x114;
        private const int WM_VSCROLL = 0x115;
        private const int SB_ENDSCROLL = 0x8;

        public readonly List<LineInfo> LineInfos = new List<LineInfo>();
        private readonly Range selection;
        private readonly Timer timer = new Timer();
        private readonly Timer timer2 = new Timer();
        private readonly Timer timer3 = new Timer();
        private readonly List<VisualMarker> visibleMarkers = new List<VisualMarker>();
        public int TextHeight;
        public bool AllowInsertRemoveLines = true;
        private Brush backBrush;
        private BaseBookmarks bookmarks;
        private bool caretVisible;
        private Color changedLineColor;
        private int charHeight;
        private Color currentLineColor;
        private Cursor defaultCursor;
        private Range delayedTextChangedRange;
        private string descriptionFile;
        private int endFoldingLine = -1;
        private Color foldingIndicatorColor;
        protected Dictionary<int, int> foldingPairs = new Dictionary<int, int>();
        private bool handledChar;
        private bool highlightFoldingIndicator;
        private Hints hints;
        private Color indentBackColor;
        private bool isChanged;
        private bool isLineSelect;
        private bool isReplaceMode;
        private Language language;
        private Keys lastModifiers;
        private Point lastMouseCoord;
        private DateTime lastNavigatedDateTime;
        private Range leftBracketPosition;
        private Range leftBracketPosition2;
        private int leftPadding;
        private int lineInterval;
        private Color lineNumberColor;
        private uint lineNumberStartValue;
        private int lineSelectFrom;
        private TextSource lines;
        private IntPtr m_hImc;
        private int maxLineLength;
        private bool mouseIsDrag;
        private bool mouseIsDragDrop;
        private bool multiline;
        protected bool needRecalc;
        protected bool needRecalcWordWrap;
        private Point needRecalcWordWrapInterval;
        private bool needRecalcFoldingLines;
        private bool needRiseSelectionChangedDelayed;
        private bool needRiseTextChangedDelayed;
        private bool needRiseVisibleRangeChangedDelayed;
        private Color paddingBackColor;
        private int preferredLineWidth;
        private Range rightBracketPosition;
        private Range rightBracketPosition2;
        private bool scrollBars;
        private Color selectionColor;
        private Color serviceLinesColor;
        private bool showFoldingLines;
        private bool showLineNumbers;
        private FastColoredTextBox sourceTextBox;
        private int startFoldingLine = -1;
        private int updating;
        private Range updatingRange;
        private Range visibleRange;
        private bool wordWrap;
        private WordWrapMode wordWrapMode = WordWrapMode.WordWrapControlWidth;
        private int reservedCountOfLineNumberChars = 1;
        private int zoom = 100;
        private Size localAutoScrollMinSize;

        /// <summary>
        /// Constructor
        /// </summary>
        public FastColoredTextBox()
        {
            //register type provider
            TypeDescriptionProvider prov = TypeDescriptor.GetProvider(GetType());
            object theProvider =
                prov.GetType().GetField("Provider", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(prov);
            if (theProvider.GetType() != typeof(FCTBDescriptionProvider))
                TypeDescriptor.AddProvider(new FCTBDescriptionProvider(GetType()), GetType());
            //drawing optimization
            SetStyle(
                ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint | ControlStyles.OptimizedDoubleBuffer |
                ControlStyles.ResizeRedraw, true);
            //append monospace font
            Font = new Font(FontFamily.GenericMonospace, 9.75f);
            //create one line
            InitTextSource(CreateTextSource());
            if (lines.Count == 0)
                lines.InsertLine(0, lines.CreateLine());
            selection = new Range(this) {Start = new Place(0, 0)};
            //default settings
            Cursor = Cursors.IBeam;
            BackColor = Color.White;
            LineNumberColor = Color.Teal;
            IndentBackColor = Color.WhiteSmoke;
            ServiceLinesColor = Color.Silver;
            FoldingIndicatorColor = Color.Green;
            CurrentLineColor = Color.Transparent;
            ChangedLineColor = Color.Transparent;
            HighlightFoldingIndicator = true;
            ShowLineNumbers = true;
            TabLength = 4;
            FoldedBlockStyle = new FoldedBlockStyle(Brushes.Gray, null, FontStyle.Regular);
            SelectionColor = Color.Blue;
            BracketsStyle = new MarkerStyle(new SolidBrush(Color.FromArgb(80, Color.Lime)));
            BracketsStyle2 = new MarkerStyle(new SolidBrush(Color.FromArgb(60, Color.Red)));
            DelayedEventsInterval = 100;
            DelayedTextChangedInterval = 100;
            AllowSeveralTextStyleDrawing = false;
            LeftBracket = '\x0';
            RightBracket = '\x0';
            LeftBracket2 = '\x0';
            RightBracket2 = '\x0';
            SyntaxHighlighter = new SyntaxHighlighter(this);
            language = Language.Razor;
            PreferredLineWidth = 0;
            needRecalc = true;
            lastNavigatedDateTime = DateTime.Now;
            AutoIndent = true;
            AutoIndentExistingLines = true;
            CommentPrefix = "//";
            lineNumberStartValue = 1;
            multiline = true;
            scrollBars = true;
            AcceptsTab = true;
            AcceptsReturn = true;
            caretVisible = true;
            CaretColor = Color.Black;
            WideCaret = false;
            Paddings = new Padding(0, 0, 0, 0);
            PaddingBackColor = Color.Transparent;
            DisabledColor = Color.FromArgb(100, 180, 180, 180);
            needRecalcFoldingLines = true;
            AllowDrop = true;
            FindEndOfFoldingBlockStrategy = FindEndOfFoldingBlockStrategy.Strategy1;
            VirtualSpace = false;
            bookmarks = new Bookmarks(this);
            BookmarkColor = Color.PowderBlue;
            ToolTip = new ToolTip();
            timer3.Interval = 500;
            hints = new Hints(this);
            SelectionHighlightingForLineBreaksEnabled = true;
            textAreaBorder = TextAreaBorderType.None;
            textAreaBorderColor = Color.Black;
            macrosManager = new MacrosManager(this);
            HotkeysMapping = new HotkeysMapping();
            HotkeysMapping.InitDefault();
            WordWrapAutoIndent = true;
            FoldedBlocks = new Dictionary<int, int>();
            AutoCompleteBrackets = false;
            AutoIndentCharsPatterns = @"^\s*[\w\.]+\s*(?<range>=)\s*(?<range>[^;]+);";
            AutoIndentChars = true;
            CaretBlinking = true;
            ServiceColors = new ServiceColors();
            //
            base.AutoScroll = true;
            timer.Tick += timer_Tick;
            timer2.Tick += timer2_Tick;
            timer3.Tick += timer3_Tick;
            middleClickScrollingTimer.Tick += middleClickScrollingTimer_Tick;
        }

        private char[] autoCompleteBracketsList = {'(', ')', '{', '}', '[', ']', '"', '"', '\'', '\''};

        public char[] AutoCompleteBracketsList
        {
            get { return autoCompleteBracketsList; }
            set { autoCompleteBracketsList = value; }
        }

        /// <summary>
        /// AutoComplete brackets
        /// </summary>
        [DefaultValue(false)]
        [Description("AutoComplete brackets.")]
        public bool AutoCompleteBrackets { get; set; }

        /// <summary>
        /// Colors of some service visual markers
        /// </summary>
        [Browsable(true)]
        [Description("Colors of some service visual markers.")]
        [TypeConverter(typeof(ExpandableObjectConverter))]
        public ServiceColors ServiceColors { get; set; }

        /// <summary>
        /// Contains UniqueId of start lines of folded blocks
        /// </summary>
        /// <remarks>This dictionary remembers folding state of blocks.
        /// It is needed to restore child folding after user collapsed/expanded top-level folding block.</remarks>
        [Browsable(false)]
        public Dictionary<int, int> FoldedBlocks { get; private set; }

        /// <summary>
        /// Strategy of search of brackets to highlighting
        /// </summary>
        [DefaultValue(typeof(BracketsHighlightStrategy), "Strategy1")]
        [Description("Strategy of search of brackets to highlighting.")]
        public BracketsHighlightStrategy BracketsHighlightStrategy { get; set; }

        /// <summary>
        /// Automatically shifts secondary wordwrap lines on the shift amount of the first line
        /// </summary>
        [DefaultValue(true)]
        [Description("Automatically shifts secondary wordwrap lines on the shift amount of the first line.")]
        public bool WordWrapAutoIndent { get; set; }

        /// <summary>
        /// Indent of secondary wordwrap lines (in chars)
        /// </summary>
        [DefaultValue(0)]
        [Description("Indent of secondary wordwrap lines (in chars).")]
        public int WordWrapIndent { get; set; }

        MacrosManager macrosManager;

        /// <summary>
        /// MacrosManager records, stores and executes the macroses
        /// </summary>
        [Browsable(false)]
        public MacrosManager MacrosManager
        {
            get { return macrosManager; }
        }

        /// <summary>
        /// Allows drag and drop
        /// </summary>
        [DefaultValue(true)]
        [Description("Allows drag and drop")]
        public override bool AllowDrop
        {
            get { return base.AllowDrop; }
            set { base.AllowDrop = value; }
        }

        /// <summary>
        /// Collection of Hints.
        /// This is temporary buffer for currently displayed hints.
        /// </summary>
        /// <remarks>You can asynchronously add, remove and clear hints. Appropriate hints will be shown or hidden from the screen.</remarks>
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
         EditorBrowsable(EditorBrowsableState.Never)]
        public Hints Hints
        {
            get { return hints; }
            set { hints = value; }
        }

        /// <summary>
        /// Delay (ms) of ToolTip
        /// </summary>
        [Browsable(true)]
        [DefaultValue(500)]
        [Description("Delay(ms) of ToolTip.")]
        public int ToolTipDelay
        {
            get { return timer3.Interval; }
            set { timer3.Interval = value; }
        }

        /// <summary>
        /// ToolTip component
        /// </summary>
        [Browsable(true)]
        [Description("ToolTip component.")]
        public ToolTip ToolTip { get; set; }

        /// <summary>
        /// Color of bookmarks
        /// </summary>
        [Browsable(true)]
        [DefaultValue(typeof(Color), "PowderBlue")]
        [Description("Color of bookmarks.")]
        public Color BookmarkColor { get; set; }

        /// <summary>
        /// Bookmarks
        /// </summary>
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
         EditorBrowsable(EditorBrowsableState.Never)]
        public BaseBookmarks Bookmarks
        {
            get { return bookmarks; }
            set { bookmarks = value; }
        }

        /// <summary>
        /// Enables virtual spaces
        /// </summary>
        [DefaultValue(false)]
        [Description("Enables virtual spaces.")]
        public bool VirtualSpace { get; set; }

        /// <summary>
        /// Strategy of search of end of folding block
        /// </summary>
        [DefaultValue(FindEndOfFoldingBlockStrategy.Strategy1)]
        [Description("Strategy of search of end of folding block.")]
        public FindEndOfFoldingBlockStrategy FindEndOfFoldingBlockStrategy { get; set; }

        /// <summary>
        /// Indicates if tab characters are accepted as input
        /// </summary>
        [DefaultValue(true)]
        [Description("Indicates if tab characters are accepted as input.")]
        public bool AcceptsTab { get; set; }

        /// <summary>
        /// Indicates if return characters are accepted as input
        /// </summary>
        [DefaultValue(true)]
        [Description("Indicates if return characters are accepted as input.")]
        public bool AcceptsReturn { get; set; }

        /// <summary>
        /// Shows or hides the caret
        /// </summary>
        [DefaultValue(true)]
        [Description("Shows or hides the caret")]
        public bool CaretVisible
        {
            get { return caretVisible; }
            set
            {
                caretVisible = value;
                Invalidate();
            }
        }

        /// <summary>
        /// Enables caret blinking
        /// </summary>
        [DefaultValue(true)]
        [Description("Enables caret blinking")]
        public bool CaretBlinking { get; set; }

        /// <summary>
        /// Draw caret when the control is not focused
        /// </summary>
        [DefaultValue(true)]
        public bool ShowCaretWhenInactive { get; set; }


        Color textAreaBorderColor;

        /// <summary>
        /// Color of border of text area
        /// </summary>
        [DefaultValue(typeof(Color), "Black")]
        [Description("Color of border of text area")]
        public Color TextAreaBorderColor
        {
            get { return textAreaBorderColor; }
            set
            {
                textAreaBorderColor = value;
                Invalidate();
            }
        }

        TextAreaBorderType textAreaBorder;

        /// <summary>
        /// Type of border of text area
        /// </summary>
        [DefaultValue(typeof(TextAreaBorderType), "None")]
        [Description("Type of border of text area")]
        public TextAreaBorderType TextAreaBorder
        {
            get { return textAreaBorder; }
            set
            {
                textAreaBorder = value;
                Invalidate();
            }
        }

        /// <summary>
        /// Background color for current line
        /// </summary>
        [DefaultValue(typeof(Color), "Transparent")]
        [Description("Background color for current line. Set to Color.Transparent to hide current line highlighting")]
        public Color CurrentLineColor
        {
            get { return currentLineColor; }
            set
            {
                currentLineColor = value;
                Invalidate();
            }
        }

        /// <summary>
        /// Background color for highlighting of changed lines
        /// </summary>
        [DefaultValue(typeof(Color), "Transparent")]
        [Description(
            "Background color for highlighting of changed lines. Set to Color.Transparent to hide changed line highlighting")]
        public Color ChangedLineColor
        {
            get { return changedLineColor; }
            set
            {
                changedLineColor = value;
                Invalidate();
            }
        }

        /// <summary>
        /// Fore color (default style color)
        /// </summary>
        public override Color ForeColor
        {
            get { return base.ForeColor; }
            set
            {
                base.ForeColor = value;
                lines.InitDefaultStyle();
                Invalidate();
            }
        }

        /// <summary>
        /// Height of char in pixels (includes LineInterval)
        /// </summary>
        [Browsable(false)]
        public int CharHeight
        {
            get { return charHeight; }
            set
            {
                charHeight = value;
                NeedRecalc();
                OnCharSizeChanged();
            }
        }

        /// <summary>
        /// Interval between lines (in pixels)
        /// </summary>
        [Description("Interval between lines in pixels")]
        [DefaultValue(0)]
        public int LineInterval
        {
            get { return lineInterval; }
            set
            {
                lineInterval = value;
                SetFont(Font);
                Invalidate();
            }
        }

        /// <summary>
        /// Width of char in pixels
        /// </summary>
        [Browsable(false)]
        public int CharWidth { get; set; }

        /// <summary>
        /// Spaces count for tab
        /// </summary>
        [DefaultValue(4)]
        [Description("Spaces count for tab")]
        public int TabLength { get; set; }

        /// <summary>
        /// Text was changed
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool IsChanged
        {
            get { return isChanged; }
            set
            {
                if (!value)
                    //clear line's IsChanged property
                    lines.ClearIsChanged();

                isChanged = value;
            }
        }

        /// <summary>
        /// Text version
        /// </summary>
        /// <remarks>This counter is incremented each time changes the text</remarks>
        [Browsable(false)]
        public int TextVersion { get; private set; }

        /// <summary>
        /// Read only
        /// </summary>
        [DefaultValue(false)]
        public bool ReadOnly { get; set; }

        /// <summary>
        /// Shows line numbers.
        /// </summary>
        [DefaultValue(true)]
        [Description("Shows line numbers.")]
        public bool ShowLineNumbers
        {
            get { return showLineNumbers; }
            set
            {
                showLineNumbers = value;
                NeedRecalc();
                Invalidate();
            }
        }

        /// <summary>
        /// Shows vertical lines between folding start line and folding end line.
        /// </summary>
        [DefaultValue(false)]
        [Description("Shows vertical lines between folding start line and folding end line.")]
        public bool ShowFoldingLines
        {
            get { return showFoldingLines; }
            set
            {
                showFoldingLines = value;
                Invalidate();
            }
        }

        /// <summary>
        /// Rectangle where located text
        /// </summary>
        [Browsable(false)]
        public Rectangle TextAreaRect
        {
            get
            {
                int rightPaddingStartX = LeftIndent + maxLineLength * CharWidth + Paddings.Left + 1;
                rightPaddingStartX = Math.Max(ClientSize.Width - Paddings.Right, rightPaddingStartX);
                int bottomPaddingStartY = TextHeight + Paddings.Top;
                bottomPaddingStartY = Math.Max(ClientSize.Height - Paddings.Bottom, bottomPaddingStartY);
                var top = Math.Max(0, Paddings.Top - 1) - VerticalScroll.Value;
                var left = LeftIndent - HorizontalScroll.Value - 2 + Math.Max(0, Paddings.Left - 1);
                var rect = Rectangle.FromLTRB(left, top, rightPaddingStartX - HorizontalScroll.Value,
                    bottomPaddingStartY - VerticalScroll.Value);
                return rect;
            }
        }

        /// <summary>
        /// Color of line numbers.
        /// </summary>
        [DefaultValue(typeof(Color), "Teal")]
        [Description("Color of line numbers.")]
        public Color LineNumberColor
        {
            get { return lineNumberColor; }
            set
            {
                lineNumberColor = value;
                Invalidate();
            }
        }

        /// <summary>
        /// Start value of first line number.
        /// </summary>
        [DefaultValue(typeof(uint), "1")]
        [Description("Start value of first line number.")]
        public uint LineNumberStartValue
        {
            get { return lineNumberStartValue; }
            set
            {
                lineNumberStartValue = value;
                needRecalc = true;
                Invalidate();
            }
        }

        /// <summary>
        /// Background color of indent area
        /// </summary>
        [DefaultValue(typeof(Color), "WhiteSmoke")]
        [Description("Background color of indent area")]
        public Color IndentBackColor
        {
            get { return indentBackColor; }
            set
            {
                indentBackColor = value;
                Invalidate();
            }
        }

        /// <summary>
        /// Background color of padding area
        /// </summary>
        [DefaultValue(typeof(Color), "Transparent")]
        [Description("Background color of padding area")]
        public Color PaddingBackColor
        {
            get { return paddingBackColor; }
            set
            {
                paddingBackColor = value;
                Invalidate();
            }
        }

        /// <summary>
        /// Color of disabled component
        /// </summary>
        [DefaultValue(typeof(Color), "100;180;180;180")]
        [Description("Color of disabled component")]
        public Color DisabledColor { get; set; }

        /// <summary>
        /// Color of caret
        /// </summary>
        [DefaultValue(typeof(Color), "Black")]
        [Description("Color of caret.")]
        public Color CaretColor { get; set; }

        /// <summary>
        /// Wide caret
        /// </summary>
        [DefaultValue(false)]
        [Description("Wide caret.")]
        public bool WideCaret { get; set; }

        /// <summary>
        /// Color of service lines (folding lines, borders of blocks etc.)
        /// </summary>
        [DefaultValue(typeof(Color), "Silver")]
        [Description("Color of service lines (folding lines, borders of blocks etc.)")]
        public Color ServiceLinesColor
        {
            get { return serviceLinesColor; }
            set
            {
                serviceLinesColor = value;
                Invalidate();
            }
        }

        /// <summary>
        /// Padings of text area
        /// </summary>
        [Browsable(true)]
        [Description("Paddings of text area.")]
        public Padding Paddings { get; set; }

        /// <summary>
        /// --Do not use this property--
        /// </summary>
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
         EditorBrowsable(EditorBrowsableState.Never)]
        public new Padding Padding
        {
            get { throw new NotImplementedException(); }
            set { throw new NotImplementedException(); }
        }

        //hide RTL
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
         EditorBrowsable(EditorBrowsableState.Never)]
        public new bool RightToLeft
        {
            get { throw new NotImplementedException(); }
            set { throw new NotImplementedException(); }
        }

        /// <summary>
        /// Color of folding area indicator
        /// </summary>
        [DefaultValue(typeof(Color), "Green")]
        [Description("Color of folding area indicator.")]
        public Color FoldingIndicatorColor
        {
            get { return foldingIndicatorColor; }
            set
            {
                foldingIndicatorColor = value;
                Invalidate();
            }
        }

        /// <summary>
        /// Enables folding indicator (left vertical line between folding bounds)
        /// </summary>
        [DefaultValue(true)]
        [Description("Enables folding indicator (left vertical line between folding bounds)")]
        public bool HighlightFoldingIndicator
        {
            get { return highlightFoldingIndicator; }
            set
            {
                highlightFoldingIndicator = value;
                Invalidate();
            }
        }

        /// <summary>
        /// Left distance to text beginning
        /// </summary>
        [Browsable(false)]
        [Description("Left distance to text beginning.")]
        public int LeftIndent { get; private set; }

        /// <summary>
        /// Left padding in pixels
        /// </summary>
        [DefaultValue(0)]
        [Description("Width of left service area (in pixels)")]
        public int LeftPadding
        {
            get { return leftPadding; }
            set
            {
                leftPadding = value;
                Invalidate();
            }
        }

        /// <summary>
        /// This property draws vertical line after defined char position.
        /// Set to 0 for disable drawing of vertical line.
        /// </summary>
        [DefaultValue(0)]
        [Description(
            "This property draws vertical line after defined char position. Set to 0 for disable drawing of vertical line.")]
        public int PreferredLineWidth
        {
            get { return preferredLineWidth; }
            set
            {
                preferredLineWidth = value;
                Invalidate();
            }
        }

        /// <summary>
        /// Styles
        /// </summary>
        [Browsable(false)]
        public Style[] Styles
        {
            get { return lines.Styles; }
        }

        /// <summary>
        /// Hotkeys. Do not use this property in your code, use HotkeysMapping property.
        /// </summary>
        [Description("Here you can change hotkeys for FastColoredTextBox.")]
        [Editor(typeof(HotkeysEditor), typeof(UITypeEditor))]
        [DefaultValue(
            "Tab=IndentIncrease, Escape=ClearHints, PgUp=GoPageUp, PgDn=GoPageDown, End=GoEnd, Home=GoHome, Left=GoLeft, Up=GoUp, Right=GoRight, Down=GoDown, Ins=ReplaceMode, Del=DeleteCharRight, F3=FindNext, Shift+Tab=IndentDecrease, Shift+PgUp=GoPageUpWithSelection, Shift+PgDn=GoPageDownWithSelection, Shift+End=GoEndWithSelection, Shift+Home=GoHomeWithSelection, Shift+Left=GoLeftWithSelection, Shift+Up=GoUpWithSelection, Shift+Right=GoRightWithSelection, Shift+Down=GoDownWithSelection, Shift+Ins=Paste, Shift+Del=Cut, Ctrl+Back=ClearWordLeft, Ctrl+Space=AutocompleteMenu, Ctrl+End=GoLastLine, Ctrl+Home=GoFirstLine, Ctrl+Left=GoWordLeft, Ctrl+Up=ScrollUp, Ctrl+Right=GoWordRight, Ctrl+Down=ScrollDown, Ctrl+Ins=Copy, Ctrl+Del=ClearWordRight, Ctrl+0=ZoomNormal, Ctrl+A=SelectAll, Ctrl+B=BookmarkLine, Ctrl+C=Copy, Ctrl+E=MacroExecute, Ctrl+F=FindDialog, Ctrl+G=GoToDialog, Ctrl+H=ReplaceDialog, Ctrl+I=AutoIndentChars, Ctrl+M=MacroRecord, Ctrl+N=GoNextBookmark, Ctrl+R=Redo, Ctrl+U=UpperCase, Ctrl+V=Paste, Ctrl+X=Cut, Ctrl+Z=Undo, Ctrl+Add=ZoomIn, Ctrl+Subtract=ZoomOut, Ctrl+OemMinus=NavigateBackward, Ctrl+Shift+End=GoLastLineWithSelection, Ctrl+Shift+Home=GoFirstLineWithSelection, Ctrl+Shift+Left=GoWordLeftWithSelection, Ctrl+Shift+Right=GoWordRightWithSelection, Ctrl+Shift+B=UnbookmarkLine, Ctrl+Shift+C=CommentSelected, Ctrl+Shift+N=GoPrevBookmark, Ctrl+Shift+U=LowerCase, Ctrl+Shift+OemMinus=NavigateForward, Alt+Back=Undo, Alt+Up=MoveSelectedLinesUp, Alt+Down=MoveSelectedLinesDown, Alt+F=FindChar, Alt+Shift+Left=GoLeft_ColumnSelectionMode, Alt+Shift+Up=GoUp_ColumnSelectionMode, Alt+Shift+Right=GoRight_ColumnSelectionMode, Alt+Shift+Down=GoDown_ColumnSelectionMode")]
        public string Hotkeys
        {
            get { return HotkeysMapping.ToString(); }
            set { HotkeysMapping = HotkeysMapping.Parse(value); }
        }

        /// <summary>
        /// Hotkeys mapping
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public HotkeysMapping HotkeysMapping { get; set; }

        /// <summary>
        /// Default text style
        /// This style is using when no one other TextStyle is not defined in Char.style
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public TextStyle DefaultStyle
        {
            get { return lines.DefaultStyle; }
            set { lines.DefaultStyle = value; }
        }

        /// <summary>
        /// Style for rendering Selection area
        /// </summary>
        [Browsable(false)]
        public SelectionStyle SelectionStyle { get; set; }

        /// <summary>
        /// Style for folded block rendering
        /// </summary>
        [Browsable(false)]
        public TextStyle FoldedBlockStyle { get; set; }

        /// <summary>
        /// Style for brackets highlighting
        /// </summary>
        [Browsable(false)]
        public MarkerStyle BracketsStyle { get; set; }

        /// <summary>
        /// Style for alternative brackets highlighting
        /// </summary>
        [Browsable(false)]
        public MarkerStyle BracketsStyle2 { get; set; }

        /// <summary>
        /// Opening bracket for brackets highlighting.
        /// Set to '\x0' for disable brackets highlighting.
        /// </summary>
        [DefaultValue('\x0')]
        [Description("Opening bracket for brackets highlighting. Set to '\\x0' for disable brackets highlighting.")]
        public char LeftBracket { get; set; }

        /// <summary>
        /// Closing bracket for brackets highlighting.
        /// Set to '\x0' for disable brackets highlighting.
        /// </summary>
        [DefaultValue('\x0')]
        [Description("Closing bracket for brackets highlighting. Set to '\\x0' for disable brackets highlighting.")]
        public char RightBracket { get; set; }

        /// <summary>
        /// Alternative opening bracket for brackets highlighting.
        /// Set to '\x0' for disable brackets highlighting.
        /// </summary>
        [DefaultValue('\x0')]
        [Description(
            "Alternative opening bracket for brackets highlighting. Set to '\\x0' for disable brackets highlighting.")]
        public char LeftBracket2 { get; set; }

        /// <summary>
        /// Alternative closing bracket for brackets highlighting.
        /// Set to '\x0' for disable brackets highlighting.
        /// </summary>
        [DefaultValue('\x0')]
        [Description(
            "Alternative closing bracket for brackets highlighting. Set to '\\x0' for disable brackets highlighting.")]
        public char RightBracket2 { get; set; }

        /// <summary>
        /// Comment line prefix.
        /// </summary>
        [DefaultValue("//")]
        [Description("Comment line prefix.")]
        public string CommentPrefix { get; set; }

        /// <summary>
        /// This property specifies which part of the text will be highlighted as you type (by built-in highlighter).
        /// </summary>
        /// <remarks>When a user enters text, a component refreshes highlighting (because the text was changed).
        /// This property specifies exactly which section of the text will be re-highlighted.
        /// This can be useful to highlight multi-line comments, for example.</remarks>
        [DefaultValue(typeof(HighlightingRangeType), "ChangedRange")]
        [Description("This property specifies which part of the text will be highlighted as you type.")]
        public HighlightingRangeType HighlightingRangeType { get; set; }

        /// <summary>
        /// Is keyboard in replace mode (wide caret) ?
        /// </summary>
        [Browsable(false)]
        public bool IsReplaceMode
        {
            get
            {
                return isReplaceMode &&
                       Selection.IsEmpty &&
                       (!Selection.ColumnSelectionMode) &&
                       Selection.Start.iChar < lines[Selection.Start.iLine].Count;
            }
            set { isReplaceMode = value; }
        }

        /// <summary>
        /// Allows text rendering several styles same time.
        /// </summary>
        [Browsable(true)]
        [DefaultValue(false)]
        [Description("Allows text rendering several styles same time.")]
        public bool AllowSeveralTextStyleDrawing { get; set; }

        /// <summary>
        /// Allows to record macros.
        /// </summary>
        [Browsable(true)]
        [DefaultValue(true)]
        [Description("Allows to record macros.")]
        public bool AllowMacroRecording
        {
            get { return macrosManager.AllowMacroRecordingByUser; }
            set { macrosManager.AllowMacroRecordingByUser = value; }
        }

        /// <summary>
        /// Allows AutoIndent. Inserts spaces before new line.
        /// </summary>
        [DefaultValue(true)]
        [Description("Allows auto indent. Inserts spaces before line chars.")]
        public bool AutoIndent { get; set; }

        /// <summary>
        /// Does autoindenting in existing lines. It works only if AutoIndent is True.
        /// </summary>
        [DefaultValue(true)]
        [Description("Does autoindenting in existing lines. It works only if AutoIndent is True.")]
        public bool AutoIndentExistingLines { get; set; }

        /// <summary>
        /// Minimal delay(ms) for delayed events (except TextChangedDelayed).
        /// </summary>
        [Browsable(true)]
        [DefaultValue(100)]
        [Description("Minimal delay(ms) for delayed events (except TextChangedDelayed).")]
        public int DelayedEventsInterval
        {
            get { return timer.Interval; }
            set { timer.Interval = value; }
        }

        /// <summary>
        /// Minimal delay(ms) for TextChangedDelayed event.
        /// </summary>
        [Browsable(true)]
        [DefaultValue(100)]
        [Description("Minimal delay(ms) for TextChangedDelayed event.")]
        public int DelayedTextChangedInterval
        {
            get { return timer2.Interval; }
            set { timer2.Interval = value; }
        }

        /// <summary>
        /// Language for highlighting by built-in highlighter.
        /// </summary>
        [Browsable(true)]
        [DefaultValue(typeof(Language), "Razor")]
        [Description("Language for highlighting by built-in highlighter.")]
        public Language Language
        {
            get { return language; }
            set
            {
                language = value;
                if (SyntaxHighlighter != null)
                    SyntaxHighlighter.InitStyleSchema(language);
                Invalidate();
            }
        }

        /// <summary>
        /// Syntax Highlighter
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public SyntaxHighlighter SyntaxHighlighter { get; set; }

        /// <summary>
        /// XML file with description of syntax highlighting.
        /// This property works only with Language == Language.Custom.
        /// </summary>
        [Browsable(true)]
        [DefaultValue(null)]
        [Editor(typeof(FileNameEditor), typeof(UITypeEditor))]
        [Description(
            "XML file with description of syntax highlighting. This property works only with Language == Language.Custom."
        )]
        public string DescriptionFile
        {
            get { return descriptionFile; }
            set
            {
                descriptionFile = value;
                Invalidate();
            }
        }

        /// <summary>
        /// Position of left highlighted bracket.
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Range LeftBracketPosition
        {
            get { return leftBracketPosition; }
        }

        /// <summary>
        /// Position of right highlighted bracket.
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Range RightBracketPosition
        {
            get { return rightBracketPosition; }
        }

        /// <summary>
        /// Position of left highlighted alternative bracket.
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Range LeftBracketPosition2
        {
            get { return leftBracketPosition2; }
        }

        /// <summary>
        /// Position of right highlighted alternative bracket.
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public Range RightBracketPosition2
        {
            get { return rightBracketPosition2; }
        }

        /// <summary>
        /// Start line index of current highlighted folding area. Return -1 if start of area is not found.
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public int StartFoldingLine
        {
            get { return startFoldingLine; }
        }

        /// <summary>
        /// End line index of current highlighted folding area. Return -1 if end of area is not found.
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public int EndFoldingLine
        {
            get { return endFoldingLine; }
        }

        /// <summary>
        /// TextSource
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public TextSource TextSource
        {
            get { return lines; }
            set { InitTextSource(value); }
        }

        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public bool HasSourceTextBox
        {
            get { return SourceTextBox != null; }
        }

        /// <summary>
        /// The source of the text.
        /// Allows to get text from other FastColoredTextBox.
        /// </summary>
        [Browsable(true)]
        [DefaultValue(null)]
        [Description("Allows to get text from other FastColoredTextBox.")]
        //[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public FastColoredTextBox SourceTextBox
        {
            get { return sourceTextBox; }
            set
            {
                if (value == sourceTextBox)
                    return;

                sourceTextBox = value;

                if (sourceTextBox == null)
                {
                    InitTextSource(CreateTextSource());
                    lines.InsertLine(0, TextSource.CreateLine());
                    IsChanged = false;
                }
                else
                {
                    InitTextSource(SourceTextBox.TextSource);
                    isChanged = false;
                }

                Invalidate();
            }
        }

        /// <summary>
        /// Returns current visible range of text
        /// </summary>
        [Browsable(false)]
        public Range VisibleRange
        {
            get
            {
                if (visibleRange != null)
                    return visibleRange;
                return GetRange(
                    PointToPlace(new Point(LeftIndent, 0)),
                    PointToPlace(new Point(ClientSize.Width, ClientSize.Height))
                );
            }
        }

        /// <summary>
        /// Current selection range
        /// </summary>
        [Browsable(false)]
        public Range Selection
        {
            get { return selection; }
            set
            {
                if (value == selection)
                    return;

                selection.BeginUpdate();
                selection.Start = value.Start;
                selection.End = value.End;
                selection.EndUpdate();
                Invalidate();
            }
        }

        /// <summary>
        /// Background color.
        /// It is used if BackBrush is null.
        /// </summary>
        [DefaultValue(typeof(Color), "White")]
        [Description("Background color.")]
        public override Color BackColor
        {
            get { return base.BackColor; }
            set { base.BackColor = value; }
        }

        /// <summary>
        /// Background brush.
        /// If Null then BackColor is used.
        /// </summary>
        [Browsable(false)]
        public Brush BackBrush
        {
            get { return backBrush; }
            set
            {
                backBrush = value;
                Invalidate();
            }
        }

        [Browsable(true)]
        [DefaultValue(true)]
        [Description("Scollbars visibility.")]
        public bool ShowScrollBars
        {
            get { return scrollBars; }
            set
            {
                if (value == scrollBars) return;
                scrollBars = value;
                needRecalc = true;
                Invalidate();
            }
        }

        /// <summary>
        /// Multiline
        /// </summary>
        [Browsable(true)]
        [DefaultValue(true)]
        [Description("Multiline mode.")]
        public bool Multiline
        {
            get { return multiline; }
            set
            {
                if (multiline == value) return;
                multiline = value;
                needRecalc = true;
                if (multiline)
                {
                    base.AutoScroll = true;
                    ShowScrollBars = true;
                }
                else
                {
                    base.AutoScroll = false;
                    ShowScrollBars = false;
                    if (lines.Count > 1)
                        lines.RemoveLine(1, lines.Count - 1);
                    lines.Manager.ClearHistory();
                }

                Invalidate();
            }
        }

        /// <summary>
        /// WordWrap.
        /// </summary>
        [Browsable(true)]
        [DefaultValue(false)]
        [Description("WordWrap.")]
        public bool WordWrap
        {
            get { return wordWrap; }
            set
            {
                if (wordWrap == value) return;
                wordWrap = value;
                if (wordWrap)
                    Selection.ColumnSelectionMode = false;
                NeedRecalc(false, true);
                //RecalcWordWrap(0, LinesCount - 1);
                Invalidate();
            }
        }

        /// <summary>
        /// WordWrap mode.
        /// </summary>
        [Browsable(true)]
        [DefaultValue(typeof(WordWrapMode), "WordWrapControlWidth")]
        [Description("WordWrap mode.")]
        public WordWrapMode WordWrapMode
        {
            get { return wordWrapMode; }
            set
            {
                if (wordWrapMode == value) return;
                wordWrapMode = value;
                NeedRecalc(false, true);
                //RecalcWordWrap(0, LinesCount - 1);
                Invalidate();
            }
        }

        private bool selectionHighlightingForLineBreaksEnabled;

        /// <summary>
        /// If <c>true</c> then line breaks included into the selection will be selected too.
        /// Then line breaks will be shown as selected blank character.
        /// </summary>
        [DefaultValue(true)]
        [Description("If enabled then line ends included into the selection will be selected too. " +
                     "Then line ends will be shown as selected blank character.")]
        public bool SelectionHighlightingForLineBreaksEnabled
        {
            get { return selectionHighlightingForLineBreaksEnabled; }
            set
            {
                selectionHighlightingForLineBreaksEnabled = value;
                Invalidate();
            }
        }


        [Browsable(false)] public FindForm findForm { get; private set; }

        [Browsable(false)] public ReplaceForm replaceForm { get; private set; }

        /// <summary>
        /// Do not change this property
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public override bool AutoScroll
        {
            get { return base.AutoScroll; }
            set { ; }
        }

        /// <summary>
        /// Count of lines
        /// </summary>
        [Browsable(false)]
        public int LinesCount
        {
            get { return lines.Count; }
        }

        /// <summary>
        /// Gets or sets char and styleId for given place
        /// This property does not fire OnTextChanged event
        /// </summary>
        public Char this[Place place]
        {
            get { return lines[place.iLine][place.iChar]; }
            set { lines[place.iLine][place.iChar] = value; }
        }

        /// <summary>
        /// Gets Line
        /// </summary>
        public Line this[int iLine]
        {
            get { return lines[iLine]; }
        }

        /// <summary>
        /// Text of control
        /// </summary>
        [Browsable(true)]
        [Localizable(true)]
        [Editor(
            "System.ComponentModel.Design.MultilineStringEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"
            , typeof(UITypeEditor))]
        [SettingsBindable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
        [Description("Text of the control.")]
        [Bindable(true)]
        public override string Text
        {
            get
            {
                if (LinesCount == 0)
                    return "";
                var sel = new Range(this);
                sel.SelectAll();
                return sel.Text;
            }

            set
            {
                if (value == Text && value != "")
                    return;

                SetAsCurrentTB();

                Selection.ColumnSelectionMode = false;

                Selection.BeginUpdate();
                try
                {
                    Selection.SelectAll();
                    InsertText(value);
                    GoHome();
                }
                finally
                {
                    Selection.EndUpdate();
                }
            }
        }

        public int TextLength
        {
            get
            {
                if (LinesCount == 0)
                    return 0;
                var sel = new Range(this);
                sel.SelectAll();
                return sel.Length;
            }
        }

        /// <summary>
        /// Text lines
        /// </summary>
        [Browsable(false)]
        public IList<string> Lines
        {
            get { return lines.GetLines(); }
        }

        /// <summary>
        /// Gets colored text as HTML
        /// </summary>
        /// <remarks>For more flexibility you can use ExportToHTML class also</remarks>
        [Browsable(false)]
        public string Html
        {
            get
            {
                var exporter = new ExportToHTML();
                exporter.UseNbsp = false;
                exporter.UseStyleTag = false;
                exporter.UseBr = false;
                return "<pre>" + exporter.GetHtml(this) + "</pre>";
            }
        }

        /// <summary>
        /// Gets colored text as RTF
        /// </summary>
        /// <remarks>For more flexibility you can use ExportToRTF class also</remarks>
        [Browsable(false)]
        public string Rtf
        {
            get
            {
                var exporter = new ExportToRTF();
                return exporter.GetRtf(this);
            }
        }

        /// <summary>
        /// Text of current selection
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public string SelectedText
        {
            get { return Selection.Text; }
            set { InsertText(value); }
        }

        /// <summary>
        /// Start position of selection
        /// </summary>
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public int SelectionStart
        {
            get { return Math.Min(PlaceToPosition(Selection.Start), PlaceToPosition(Selection.End)); }
            set { Selection.Start = PositionToPlace(value); }
        }

        /// <summary>
        /// Length of selected text
        /// </summary>
        [Browsable(false)]
        [DefaultValue(0)]
        public int SelectionLength
        {
            get { return Selection.Length; }
            set
            {
                if (value > 0)
                    Selection.End = PositionToPlace(SelectionStart + value);
            }
        }

        /// <summary>
        /// Font
        /// </summary>
        /// <remarks>Use only monospaced font</remarks>
        [DefaultValue(typeof(Font), "Courier New, 9.75")]
        public override Font Font
        {
            get { return BaseFont; }
            set
            {
                originalFont = (Font) value.Clone();
                SetFont(value);
            }
        }


        Font baseFont;

        /// <summary>
        /// Font
        /// </summary>
        /// <remarks>Use only monospaced font</remarks>
        [DefaultValue(typeof(Font), "Courier New, 9.75")]
        private Font BaseFont
        {
            get { return baseFont; }
            set { baseFont = value; }
        }

        private void SetFont(Font newFont)
        {
            BaseFont = newFont;
            //check monospace font
            SizeF sizeM = GetCharSize(BaseFont, 'M');
            SizeF sizeDot = GetCharSize(BaseFont, '.');
            if (sizeM != sizeDot)
                BaseFont = new Font("Courier New", BaseFont.SizeInPoints, FontStyle.Regular, GraphicsUnit.Point);
            //clac size
            SizeF size = GetCharSize(BaseFont, 'M');
            CharWidth = (int) Math.Round(size.Width * 1f /*0.85*/) - 1 /*0*/;
            CharHeight = lineInterval + (int) Math.Round(size.Height * 1f /*0.9*/) - 1 /*0*/;
            //
            //if (wordWrap)
            //    RecalcWordWrap(0, Lines.Count - 1);
            NeedRecalc(false, wordWrap);
            //
            Invalidate();
        }

        public new Size AutoScrollMinSize
        {
            set
            {
                if (scrollBars)
                {
                    if (!base.AutoScroll)
                        base.AutoScroll = true;
                    Size newSize = value;
                    if (WordWrap && WordWrapMode != FastColoredTextBoxNS.WordWrapMode.Custom)
                    {
                        int maxWidth = GetMaxLineWordWrapedWidth();
                        newSize = new Size(Math.Min(newSize.Width, maxWidth), newSize.Height);
                    }

                    base.AutoScrollMinSize = newSize;
                }
                else
                {
                    if (base.AutoScroll)
                        base.AutoScroll = false;
                    base.AutoScrollMinSize = new Size(0, 0);
                    VerticalScroll.Visible = false;
                    HorizontalScroll.Visible = false;
                    VerticalScroll.Maximum = Math.Max(0, value.Height - ClientSize.Height);
                    HorizontalScroll.Maximum = Math.Max(0, value.Width - ClientSize.Width);
                    localAutoScrollMinSize = value;
                }
            }

            get
            {
                if (scrollBars)
                    return base.AutoScrollMinSize;
                else
                    //return new Size(HorizontalScroll.Maximum, VerticalScroll.Maximum);
                    return localAutoScrollMinSize;
            }
        }

        /// <summary>
        /// Indicates that IME is allowed (for CJK language entering)
        /// </summary>
        [Browsable(false)]
        public bool ImeAllowed
        {
            get
            {
                return ImeMode != ImeMode.Disable &&
                       ImeMode != ImeMode.Off &&
                       ImeMode != ImeMode.NoControl;
            }
        }

        /// <summary>
        /// Is undo enabled?
        /// </summary>
        [Browsable(false)]
        public bool UndoEnabled
        {
            get { return lines.Manager.UndoEnabled; }
        }

        /// <summary>
        /// Is redo enabled?
        /// </summary>
        [Browsable(false)]
        public bool RedoEnabled
        {
            get { return lines.Manager.RedoEnabled; }
        }

        private int LeftIndentLine
        {
            get { return LeftIndent - minLeftIndent / 2 - 3; }
        }

        /// <summary>
        /// Range of all text
        /// </summary>
        [Browsable(false)]
        public Range Range
        {
            get { return new Range(this, new Place(0, 0), new Place(lines[lines.Count - 1].Count, lines.Count - 1)); }
        }

        /// <summary>
        /// Color of selected area
        /// </summary>
        [DefaultValue(typeof(Color), "Blue")]
        [Description("Color of selected area.")]
        public virtual Color SelectionColor
        {
            get { return selectionColor; }
            set
            {
                selectionColor = value;
                if (selectionColor.A == 255)
                    selectionColor = Color.FromArgb(60, selectionColor);
                SelectionStyle = new SelectionStyle(new SolidBrush(selectionColor));
                Invalidate();
            }
        }

        public override Cursor Cursor
        {
            get { return base.Cursor; }
            set
            {
                defaultCursor = value;
                base.Cursor = value;
            }
        }

        /// <summary>
        /// Reserved space for line number characters.
        /// If smaller than needed (e. g. line count >= 10 and this value set to 1) this value will have no impact.
        /// If you want to reserve space, e. g. for line numbers >= 10 or >= 100 than you can set this value to 2 or 3 or higher.
        /// </summary>
        [DefaultValue(1)]
        [Description(
            "Reserved space for line number characters. If smaller than needed (e. g. line count >= 10 and " +
            "this value set to 1) this value will have no impact. If you want to reserve space, e. g. for line " +
            "numbers >= 10 or >= 100, than you can set this value to 2 or 3 or higher.")]
        public int ReservedCountOfLineNumberChars
        {
            get { return reservedCountOfLineNumberChars; }
            set
            {
                reservedCountOfLineNumberChars = value;
                NeedRecalc();
                Invalidate();
            }
        }

        /// <summary>
        /// Occurs when mouse is moving over text and tooltip is needed
        /// </summary>
        [Browsable(true)]
        [Description("Occurs when mouse is moving over text and tooltip is needed.")]
        public event EventHandler<ToolTipNeededEventArgs> ToolTipNeeded;

        /// <summary>
        /// Removes all hints
        /// </summary>
        public void ClearHints()
        {
            if (Hints != null)
                Hints.Clear();
        }

        /// <summary>
        /// Add and shows the hint
        /// </summary>
        /// <param name="range">Linked range</param>
        /// <param name="innerControl">Inner control</param>
        /// <param name="scrollToHint">Scrolls textbox to the hint</param>
        /// <param name="inline">Inlining. If True then hint will moves apart text</param>
        /// <param name="dock">Docking. If True then hint will fill whole line</param>
        public virtual Hint AddHint(Range range, Control innerControl, bool scrollToHint, bool inline, bool dock)
        {
            var hint = new Hint(range, innerControl, inline, dock);
            Hints.Add(hint);
            if (scrollToHint)
                hint.DoVisible();

            return hint;
        }

        /// <summary>
        /// Add and shows the hint
        /// </summary>
        /// <param name="range">Linked range</param>
        /// <param name="innerControl">Inner control</param>
        public Hint AddHint(Range range, Control innerControl)
        {
            return AddHint(range, innerControl, true, true, true);
        }

        /// <summary>
        /// Add and shows simple text hint
        /// </summary>
        /// <param name="range">Linked range</param>
        /// <param name="text">Text of simple hint</param>
        /// <param name="scrollToHint">Scrolls textbox to the hint</param>
        /// <param name="inline">Inlining. If True then hint will moves apart text</param>
        /// <param name="dock">Docking. If True then hint will fill whole line</param>
        public virtual Hint AddHint(Range range, string text, bool scrollToHint, bool inline, bool dock)
        {
            var hint = new Hint(range, text, inline, dock);
            Hints.Add(hint);
            if (scrollToHint)
                hint.DoVisible();

            return hint;
        }

        /// <summary>
        /// Add and shows simple text hint
        /// </summary>
        /// <param name="range">Linked range</param>
        /// <param name="text">Text of simple hint</param>
        public Hint AddHint(Range range, string text)
        {
            return AddHint(range, text, true, true, true);
        }

        /// <summary>
        /// Occurs when user click on the hint
        /// </summary>
        /// <param name="hint"></param>
        public virtual void OnHintClick(Hint hint)
        {
            if (HintClick != null)
                HintClick(this, new HintClickEventArgs(hint));
        }

        private void timer3_Tick(object sender, EventArgs e)
        {
            timer3.Stop();
            OnToolTip();
        }

        protected virtual void OnToolTip()
        {
            if (ToolTip == null)
                return;
            if (ToolTipNeeded == null)
                return;

            //get place under mouse
            Place place = PointToPlace(lastMouseCoord);

            //check distance
            Point p = PlaceToPoint(place);
            if (Math.Abs(p.X - lastMouseCoord.X) > CharWidth * 2 ||
                Math.Abs(p.Y - lastMouseCoord.Y) > CharHeight * 2)
                return;
            //get word under mouse
            var r = new Range(this, place, place);
            string hoveredWord = r.GetFragment("[a-zA-Z]").Text;
            //event handler
            var ea = new ToolTipNeededEventArgs(place, hoveredWord);
            ToolTipNeeded(this, ea);

            if (ea.ToolTipText != null)
            {
                //show tooltip
                ToolTip.ToolTipTitle = ea.ToolTipTitle;
                ToolTip.ToolTipIcon = ea.ToolTipIcon;
                //ToolTip.SetToolTip(this, ea.ToolTipText);
                ToolTip.Show(ea.ToolTipText, this, new Point(lastMouseCoord.X, lastMouseCoord.Y + CharHeight));
            }
        }

        /// <summary>
        /// Occurs when VisibleRange is changed
        /// </summary>
        public virtual void OnVisibleRangeChanged()
        {
            needRecalcFoldingLines = true;

            needRiseVisibleRangeChangedDelayed = true;
            ResetTimer(timer);
            if (VisibleRangeChanged != null)
                VisibleRangeChanged(this, new EventArgs());
        }

        /// <summary>
        /// Invalidates the entire surface of the control and causes the control to be redrawn.
        /// This method is thread safe and does not require Invoke.
        /// </summary>
        public new void Invalidate()
        {
            if (InvokeRequired)
                BeginInvoke(new MethodInvoker(Invalidate));
            else
                base.Invalidate();
        }

        protected virtual void OnCharSizeChanged()
        {
            VerticalScroll.SmallChange = charHeight;
            VerticalScroll.LargeChange = 10 * charHeight;
            HorizontalScroll.SmallChange = CharWidth;
        }

        /// <summary>
        /// HintClick event.
        /// It occurs if user click on the hint.
        /// </summary>
        [Browsable(true)]
        [Description("It occurs if user click on the hint.")]
        public event EventHandler<HintClickEventArgs> HintClick;

        /// <summary>
        /// TextChanged event.
        /// It occurs after insert, delete, clear, undo and redo operations.
        /// </summary>
        [Browsable(true)]
        [Description("It occurs after insert, delete, clear, undo and redo operations.")]
        public new event EventHandler<TextChangedEventArgs> TextChanged;

        /// <summary>
        /// Fake event for correct data binding
        /// </summary>
        [Browsable(false)]
        internal event EventHandler BindingTextChanged;

        /// <summary>
        /// Occurs when user paste text from clipboard
        /// </summary>
        [Description("Occurs when user paste text from clipboard")]
        public event EventHandler<TextChangingEventArgs> Pasting;

        /// <summary>
        /// TextChanging event.
        /// It occurs before insert, delete, clear, undo and redo operations.
        /// </summary>
        [Browsable(true)]
        [Description("It occurs before insert, delete, clear, undo and redo operations.")]
        public event EventHandler<TextChangingEventArgs> TextChanging;

        /// <summary>
        /// SelectionChanged event.
        /// It occurs after changing of selection.
        /// </summary>
        [Browsable(true)]
        [Description("It occurs after changing of selection.")]
        public event EventHandler SelectionChanged;

        /// <summary>
        /// VisibleRangeChanged event.
        /// It occurs after changing of visible range.
        /// </summary>
        [Browsable(true)]
        [Description("It occurs after changing of visible range.")]
        public event EventHandler VisibleRangeChanged;

        /// <summary>
        /// TextChangedDelayed event. 
        /// It occurs after insert, delete, clear, undo and redo operations. 
        /// This event occurs with a delay relative to TextChanged, and fires only once.
        /// </summary>
        [Browsable(true)]
        [Description(
            "It occurs after insert, delete, clear, undo and redo operations. This event occurs with a delay relative to TextChanged, and fires only once."
        )]
        public event EventHandler<TextChangedEventArgs> TextChangedDelayed;

        /// <summary>
        /// SelectionChangedDelayed event.
        /// It occurs after changing of selection.
        /// This event occurs with a delay relative to SelectionChanged, and fires only once.
        /// </summary>
        [Browsable(true)]
        [Description(
            "It occurs after changing of selection. This event occurs with a delay relative to SelectionChanged, and fires only once."
        )]
        public event EventHandler SelectionChangedDelayed;

        /// <summary>
        /// VisibleRangeChangedDelayed event.
        /// It occurs after changing of visible range.
        /// This event occurs with a delay relative to VisibleRangeChanged, and fires only once.
        /// </summary>
        [Browsable(true)]
        [Description(
            "It occurs after changing of visible range. This event occurs with a delay relative to VisibleRangeChanged, and fires only once."
        )]
        public event EventHandler VisibleRangeChangedDelayed;

        /// <summary>
        /// It occurs when user click on VisualMarker.
        /// </summary>
        [Browsable(true)]
        [Description("It occurs when user click on VisualMarker.")]
        public event EventHandler<VisualMarkerEventArgs> VisualMarkerClick;

        /// <summary>
        /// It occurs when visible char is enetering (alphabetic, digit, punctuation, DEL, BACKSPACE)
        /// </summary>
        /// <remarks>Set Handle to True for cancel key</remarks>
        [Browsable(true)]
        [Description("It occurs when visible char is enetering (alphabetic, digit, punctuation, DEL, BACKSPACE).")]
        public event KeyPressEventHandler KeyPressing;

        /// <summary>
        /// It occurs when visible char is enetered (alphabetic, digit, punctuation, DEL, BACKSPACE)
        /// </summary>
        [Browsable(true)]
        [Description("It occurs when visible char is enetered (alphabetic, digit, punctuation, DEL, BACKSPACE).")]
        public event KeyPressEventHandler KeyPressed;

        /// <summary>
        /// It occurs when calculates AutoIndent for new line
        /// </summary>
        [Browsable(true)]
        [Description("It occurs when calculates AutoIndent for new line.")]
        public event EventHandler<AutoIndentEventArgs> AutoIndentNeeded;

        /// <summary>
        /// It occurs when line background is painting
        /// </summary>
        [Browsable(true)]
        [Description("It occurs when line background is painting.")]
        public event EventHandler<PaintLineEventArgs> PaintLine;

        /// <summary>
        /// Occurs when line was inserted/added
        /// </summary>
        [Browsable(true)]
        [Description("Occurs when line was inserted/added.")]
        public event EventHandler<LineInsertedEventArgs> LineInserted;

        /// <summary>
        /// Occurs when line was removed
        /// </summary>
        [Browsable(true)]
        [Description("Occurs when line was removed.")]
        public event EventHandler<LineRemovedEventArgs> LineRemoved;

        /// <summary>
        /// Occurs when current highlighted folding area is changed.
        /// Current folding area see in StartFoldingLine and EndFoldingLine.
        /// </summary>
        /// <remarks></remarks>
        [Browsable(true)]
        [Description("Occurs when current highlighted folding area is changed.")]
        public event EventHandler<EventArgs> FoldingHighlightChanged;

        /// <summary>
        /// Occurs when undo/redo stack is changed
        /// </summary>
        /// <remarks></remarks>
        [Browsable(true)]
        [Description("Occurs when undo/redo stack is changed.")]
        public event EventHandler<EventArgs> UndoRedoStateChanged;

        /// <summary>
        /// Occurs when component was zoomed
        /// </summary>
        [Browsable(true)]
        [Description("Occurs when component was zoomed.")]
        public event EventHandler ZoomChanged;


        /// <summary>
        /// Occurs when user pressed key, that specified as CustomAction
        /// </summary>
        [Browsable(true)]
        [Description("Occurs when user pressed key, that specified as CustomAction.")]
        public event EventHandler<CustomActionEventArgs> CustomAction;

        /// <summary>
        /// Occurs when scroolbars are updated
        /// </summary>
        [Browsable(true)]
        [Description("Occurs when scroolbars are updated.")]
        public event EventHandler ScrollbarsUpdated;

        /// <summary>
        /// Occurs when custom wordwrap is needed
        /// </summary>
        [Browsable(true)]
        [Description("Occurs when custom wordwrap is needed.")]
        public event EventHandler<WordWrapNeededEventArgs> WordWrapNeeded;


        /// <summary>
        /// Returns list of styles of given place
        /// </summary>
        public List<Style> GetStylesOfChar(Place place)
        {
            var result = new List<Style>();
            if (place.iLine < LinesCount && place.iChar < this[place.iLine].Count)
            {
#if Styles32
                var s = (uint) this[place].style;
                for (int i = 0; i < 32; i++)
                    if ((s & ((uint) 1) << i) != 0)
                        result.Add(Styles[i]);
#else
                var s = (ushort) this[place].style;
                for (int i = 0; i < 16; i++)
                    if ((s & ((ushort) 1) << i) != 0)
                        result.Add(Styles[i]);
#endif
            }

            return result;
        }

        protected virtual TextSource CreateTextSource()
        {
            return new TextSource(this);
        }

        private void SetAsCurrentTB()
        {
            TextSource.CurrentTB = this;
        }

        protected virtual void InitTextSource(TextSource ts)
        {
            if (lines != null)
            {
                lines.LineInserted -= ts_LineInserted;
                lines.LineRemoved -= ts_LineRemoved;
                lines.TextChanged -= ts_TextChanged;
                lines.RecalcNeeded -= ts_RecalcNeeded;
                lines.RecalcWordWrap -= ts_RecalcWordWrap;
                lines.TextChanging -= ts_TextChanging;

                lines.Dispose();
            }

            LineInfos.Clear();
            ClearHints();
            if (Bookmarks != null)
                Bookmarks.Clear();

            lines = ts;

            if (ts != null)
            {
                ts.LineInserted += ts_LineInserted;
                ts.LineRemoved += ts_LineRemoved;
                ts.TextChanged += ts_TextChanged;
                ts.RecalcNeeded += ts_RecalcNeeded;
                ts.RecalcWordWrap += ts_RecalcWordWrap;
                ts.TextChanging += ts_TextChanging;

                while (LineInfos.Count < ts.Count)
                    LineInfos.Add(new LineInfo(-1));
            }

            isChanged = false;
            needRecalc = true;
        }

        private void ts_RecalcWordWrap(object sender, TextSource.TextChangedEventArgs e)
        {
            RecalcWordWrap(e.iFromLine, e.iToLine);
        }

        private void ts_TextChanging(object sender, TextChangingEventArgs e)
        {
            if (TextSource.CurrentTB == this)
            {
                string text = e.InsertingText;
                OnTextChanging(ref text);
                e.InsertingText = text;
            }
        }

        private void ts_RecalcNeeded(object sender, TextSource.TextChangedEventArgs e)
        {
            if (e.iFromLine == e.iToLine && !WordWrap && lines.Count > minLinesForAccuracy)
                RecalcScrollByOneLine(e.iFromLine);
            else
            {
                NeedRecalc(false, WordWrap);
                //needRecalc = true;
            }
        }

        /// <summary>
        /// Call this method if the recalc of the position of lines is needed.
        /// </summary>
        public void NeedRecalc()
        {
            NeedRecalc(false);
        }

        /// <summary>
        /// Call this method if the recalc of the position of lines is needed.
        /// </summary>
        public void NeedRecalc(bool forced)
        {
            NeedRecalc(forced, false);
        }

        /// <summary>
        /// Call this method if the recalc of the position of lines is needed.
        /// </summary>
        public void NeedRecalc(bool forced, bool wordWrapRecalc)
        {
            needRecalc = true;

            if (wordWrapRecalc)
            {
                needRecalcWordWrapInterval = new Point(0, LinesCount - 1);
                needRecalcWordWrap = true;
            }

            if (forced)
                Recalc();
        }

        private void ts_TextChanged(object sender, TextSource.TextChangedEventArgs e)
        {
            if (e.iFromLine == e.iToLine && !WordWrap)
                RecalcScrollByOneLine(e.iFromLine);
            else
                needRecalc = true;

            Invalidate();
            if (TextSource.CurrentTB == this)
                OnTextChanged(e.iFromLine, e.iToLine);
        }

        private void ts_LineRemoved(object sender, LineRemovedEventArgs e)
        {
            LineInfos.RemoveRange(e.Index, e.Count);
            OnLineRemoved(e.Index, e.Count, e.RemovedLineUniqueIds);
        }

        private void ts_LineInserted(object sender, LineInsertedEventArgs e)
        {
            VisibleState newState = VisibleState.Visible;
            if (e.Index >= 0 && e.Index < LineInfos.Count && LineInfos[e.Index].VisibleState == VisibleState.Hidden)
                newState = VisibleState.Hidden;

            if (e.Count > 100000)
                LineInfos.Capacity = LineInfos.Count + e.Count + 1000;

            var temp = new LineInfo[e.Count];
            for (int i = 0; i < e.Count; i++)
            {
                temp[i].startY = -1;
                temp[i].VisibleState = newState;
            }

            LineInfos.InsertRange(e.Index, temp);

            /* 
            for (int i = 0; i < e.Count; i++)
            {
                LineInfos.Add(new LineInfo(-1) { VisibleState = newState });//<---- needed Insert
                if(i % 1000000 == 0 && i > 0)
                    GC.Collect();
            }*/

            if (e.Count > 1000000)
                GC.Collect();

            OnLineInserted(e.Index, e.Count);
        }

        /// <summary>
        /// Navigates forward (by Line.LastVisit property)
        /// </summary>
        public bool NavigateForward()
        {
            DateTime min = DateTime.Now;
            int iLine = -1;
            for (int i = 0; i < LinesCount; i++)
                if (lines.IsLineLoaded(i))
                    if (lines[i].LastVisit > lastNavigatedDateTime && lines[i].LastVisit < min)
                    {
                        min = lines[i].LastVisit;
                        iLine = i;
                    }

            if (iLine >= 0)
            {
                Navigate(iLine);
                return true;
            }
            else
                return false;
        }

        /// <summary>
        /// Navigates backward (by Line.LastVisit property)
        /// </summary>
        public bool NavigateBackward()
        {
            var max = new DateTime();
            int iLine = -1;
            for (int i = 0; i < LinesCount; i++)
                if (lines.IsLineLoaded(i))
                    if (lines[i].LastVisit < lastNavigatedDateTime && lines[i].LastVisit > max)
                    {
                        max = lines[i].LastVisit;
                        iLine = i;
                    }

            if (iLine >= 0)
            {
                Navigate(iLine);
                return true;
            }
            else
                return false;
        }

        /// <summary>
        /// Navigates to defined line, without Line.LastVisit reseting
        /// </summary>
        public void Navigate(int iLine)
        {
            if (iLine >= LinesCount) return;
            lastNavigatedDateTime = lines[iLine].LastVisit;
            Selection.Start = new Place(0, iLine);
            DoSelectionVisible();
        }

        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);
            m_hImc = NativeMethodWrapper.ImmGetContext(Handle);
        }

        private void timer2_Tick(object sender, EventArgs e)
        {
            timer2.Enabled = false;
            if (needRiseTextChangedDelayed)
            {
                needRiseTextChangedDelayed = false;
                if (delayedTextChangedRange == null)
                    return;
                delayedTextChangedRange = Range.GetIntersectionWith(delayedTextChangedRange);
                delayedTextChangedRange.Expand();
                OnTextChangedDelayed(delayedTextChangedRange);
                delayedTextChangedRange = null;
            }
        }

        public void AddVisualMarker(VisualMarker marker)
        {
            visibleMarkers.Add(marker);
        }

        private void timer_Tick(object sender, EventArgs e)
        {
            timer.Enabled = false;
            if (needRiseSelectionChangedDelayed)
            {
                needRiseSelectionChangedDelayed = false;
                OnSelectionChangedDelayed();
            }

            if (needRiseVisibleRangeChangedDelayed)
            {
                needRiseVisibleRangeChangedDelayed = false;
                OnVisibleRangeChangedDelayed();
            }
        }

        public virtual void OnTextChangedDelayed(Range changedRange)
        {
            if (TextChangedDelayed != null)
                TextChangedDelayed(this, new TextChangedEventArgs(changedRange));
        }

        public virtual void OnSelectionChangedDelayed()
        {
            RecalcScrollByOneLine(Selection.Start.iLine);
            //highlight brackets
            ClearBracketsPositions();
            if (LeftBracket != '\x0' && RightBracket != '\x0')
                HighlightBrackets(LeftBracket, RightBracket, ref leftBracketPosition, ref rightBracketPosition);
            if (LeftBracket2 != '\x0' && RightBracket2 != '\x0')
                HighlightBrackets(LeftBracket2, RightBracket2, ref leftBracketPosition2, ref rightBracketPosition2);
            //remember last visit time
            if (Selection.IsEmpty && Selection.Start.iLine < LinesCount)
            {
                if (lastNavigatedDateTime != lines[Selection.Start.iLine].LastVisit)
                {
                    lines[Selection.Start.iLine].LastVisit = DateTime.Now;
                    lastNavigatedDateTime = lines[Selection.Start.iLine].LastVisit;
                }
            }

            if (SelectionChangedDelayed != null)
                SelectionChangedDelayed(this, new EventArgs());
        }

        public virtual void OnVisibleRangeChangedDelayed()
        {
            if (VisibleRangeChangedDelayed != null)
                VisibleRangeChangedDelayed(this, new EventArgs());
        }

        Dictionary<Timer, Timer> timersToReset = new Dictionary<Timer, Timer>();

        private void ResetTimer(Timer timer)
        {
            if (InvokeRequired)
            {
                BeginInvoke(new MethodInvoker(() => ResetTimer(timer)));
                return;
            }

            timer.Stop();
            if (IsHandleCreated)
                timer.Start();
            else
                timersToReset[timer] = timer;
        }

        protected override void OnHandleCreated(EventArgs e)
        {
            base.OnHandleCreated(e);
            foreach (var timer in new List<Timer>(timersToReset.Keys))
                ResetTimer(timer);
            timersToReset.Clear();

            OnScrollbarsUpdated();
        }

        /// <summary>
        /// Add new style
        /// </summary>
        /// <returns>Layer index of this style</returns>
        public int AddStyle(Style style)
        {
            if (style == null) return -1;

            int i = GetStyleIndex(style);
            if (i >= 0)
                return i;

            i = CheckStylesBufferSize();
            Styles[i] = style;
            return i;
        }

        /// <summary>
        /// Checks if the styles buffer has enough space to add one 
        /// more element. If not, an exception is thrown. Otherwise, 
        /// the index of a free slot is returned. 
        /// </summary>
        /// <returns>Index of free styles buffer slot</returns>
        /// <exception cref="Exception">If maximum count of styles is exceeded</exception>
        public int CheckStylesBufferSize()
        {
            int i;
            for (i = Styles.Length - 1; i >= 0; i--)
                if (Styles[i] != null)
                    break;

            i++;
            if (i >= Styles.Length)
                throw new Exception("Maximum count of Styles is exceeded.");

            return i;
        }

        /// <summary>
        /// Shows find dialog
        /// </summary>
        public virtual void ShowFindDialog()
        {
            ShowFindDialog(null);
        }

        /// <summary>
        /// Shows find dialog
        /// </summary>
        public virtual void ShowFindDialog(string findText)
        {
            if (findForm == null)
                findForm = new FindForm(this);

            if (findText != null)
                findForm.tbFind.Text = findText;
            else if (!Selection.IsEmpty && Selection.Start.iLine == Selection.End.iLine)
                findForm.tbFind.Text = Selection.Text;

            findForm.tbFind.SelectAll();
            findForm.Show();
            findForm.Focus();
        }

        /// <summary>
        /// Shows replace dialog
        /// </summary>
        public virtual void ShowReplaceDialog()
        {
            ShowReplaceDialog(null);
        }

        /// <summary>
        /// Shows replace dialog
        /// </summary>
        public virtual void ShowReplaceDialog(string findText)
        {
            if (ReadOnly)
                return;
            if (replaceForm == null)
                replaceForm = new ReplaceForm(this);

            if (findText != null)
                replaceForm.tbFind.Text = findText;
            else if (!Selection.IsEmpty && Selection.Start.iLine == Selection.End.iLine)
                replaceForm.tbFind.Text = Selection.Text;

            replaceForm.tbFind.SelectAll();
            replaceForm.Show();
            replaceForm.Focus();
        }

        /// <summary>
        /// Gets length of given line
        /// </summary>
        /// <param name="iLine">Line index</param>
        /// <returns>Length of line</returns>
        public int GetLineLength(int iLine)
        {
            if (iLine < 0 || iLine >= lines.Count)
                throw new ArgumentOutOfRangeException("Line index out of range");

            return lines[iLine].Count;
        }

        /// <summary>
        /// Get range of line
        /// </summary>
        /// <param name="iLine">Line index</param>
        public Range GetLine(int iLine)
        {
            if (iLine < 0 || iLine >= lines.Count)
                throw new ArgumentOutOfRangeException("Line index out of range");

            var sel = new Range(this);
            sel.Start = new Place(0, iLine);
            sel.End = new Place(lines[iLine].Count, iLine);
            return sel;
        }

        /// <summary>
        /// Copy selected text into Clipboard
        /// </summary>
        public virtual void Copy()
        {
            if (Selection.IsEmpty)
                Selection.Expand();
            if (!Selection.IsEmpty)
            {
                var data = new DataObject();
                OnCreateClipboardData(data);
                //
                var thread = new Thread(() => SetClipboard(data));
                thread.SetApartmentState(ApartmentState.STA);
                thread.Start();
                thread.Join();
            }
        }

        protected virtual void OnCreateClipboardData(DataObject data)
        {
            var exp = new ExportToHTML();
            exp.UseBr = false;
            exp.UseNbsp = false;
            exp.UseStyleTag = true;
            string html = "<pre>" + exp.GetHtml(Selection.Clone()) + "</pre>";

            data.SetData(DataFormats.UnicodeText, true, Selection.Text);
            data.SetData(DataFormats.Html, PrepareHtmlForClipboard(html));
            data.SetData(DataFormats.Rtf, new ExportToRTF().GetRtf(Selection.Clone()));
        }

      

        protected void SetClipboard(DataObject data)
        {
            try
            {
                /*
                while (GetOpenClipboardWindow() != IntPtr.Zero)
                    Thread.Sleep(0);*/
                NativeMethodWrapper.CloseClipboard();
                Clipboard.SetDataObject(data, true, 5, 100);
            }
            catch (ExternalException)
            {
                //occurs if some other process holds open clipboard
            }
        }

        public static MemoryStream PrepareHtmlForClipboard(string html)
        {
            Encoding enc = Encoding.UTF8;

            string begin = "Version:0.9\r\nStartHTML:{0:000000}\r\nEndHTML:{1:000000}"
                           + "\r\nStartFragment:{2:000000}\r\nEndFragment:{3:000000}\r\n";

            string html_begin = "<html>\r\n<head>\r\n"
                                + "<meta http-equiv=\"Content-Type\""
                                + " content=\"text/html; charset=" + enc.WebName + "\">\r\n"
                                + "<title>HTML clipboard</title>\r\n</head>\r\n<body>\r\n"
                                + "<!--StartFragment-->";

            string html_end = "<!--EndFragment-->\r\n</body>\r\n</html>\r\n";

            string begin_sample = String.Format(begin, 0, 0, 0, 0);

            int count_begin = enc.GetByteCount(begin_sample);
            int count_html_begin = enc.GetByteCount(html_begin);
            int count_html = enc.GetByteCount(html);
            int count_html_end = enc.GetByteCount(html_end);

            string html_total = String.Format(
                                    begin
                                    , count_begin
                                    , count_begin + count_html_begin + count_html + count_html_end
                                    , count_begin + count_html_begin
                                    , count_begin + count_html_begin + count_html
                                ) + html_begin + html + html_end;

            return new MemoryStream(enc.GetBytes(html_total));
        }


        /// <summary>
        /// Cut selected text into Clipboard
        /// </summary>
        public virtual void Cut()
        {
            if (!Selection.IsEmpty)
            {
                Copy();
                ClearSelected();
            }
            else if (LinesCount == 1)
            {
                Selection.SelectAll();
                Copy();
                ClearSelected();
            }
            else
            {
                //copy
                var data = new DataObject();
                OnCreateClipboardData(data);
                //
                var thread = new Thread(() => SetClipboard(data));
                thread.SetApartmentState(ApartmentState.STA);
                thread.Start();
                thread.Join();

                //remove current line
                if (Selection.Start.iLine >= 0 && Selection.Start.iLine < LinesCount)
                {
                    int iLine = Selection.Start.iLine;
                    RemoveLines(new List<int> {iLine});
                    Selection.Start = new Place(0, Math.Max(0, Math.Min(iLine, LinesCount - 1)));
                }
            }
        }

        /// <summary>
        /// Paste text from clipboard into selected position
        /// </summary>
        public virtual void Paste()
        {
            string text = null;
            var thread = new Thread(() =>
            {
                if (Clipboard.ContainsText())
                    text = Clipboard.GetText();
            });
            thread.SetApartmentState(ApartmentState.STA);
            thread.Start();
            thread.Join();

            if (Pasting != null)
            {
                var args = new TextChangingEventArgs
                {
                    Cancel = false,
                    InsertingText = text
                };

                Pasting(this, args);

                if (args.Cancel)
                    text = string.Empty;
                else
                    text = args.InsertingText;
            }

            if (!string.IsNullOrEmpty(text))
                InsertText(text);
        }

        /// <summary>
        /// Select all chars of text
        /// </summary>
        public void SelectAll()
        {
            Selection.SelectAll();
        }

        /// <summary>
        /// Move caret to end of text
        /// </summary>
        public void GoEnd()
        {
            if (lines.Count > 0)
                Selection.Start = new Place(lines[lines.Count - 1].Count, lines.Count - 1);
            else
                Selection.Start = new Place(0, 0);

            DoCaretVisible();
        }

        /// <summary>
        /// Move caret to first position
        /// </summary>
        public void GoHome()
        {
            Selection.Start = new Place(0, 0);

            DoCaretVisible();
            //VerticalScroll.Value = 0;
            //HorizontalScroll.Value = 0;
        }

        /// <summary>
        /// Clear text, styles, history, caches
        /// </summary>
        public virtual void Clear()
        {
            Selection.BeginUpdate();
            try
            {
                Selection.SelectAll();
                ClearSelected();
                lines.Manager.ClearHistory();
                Invalidate();
            }
            finally
            {
                Selection.EndUpdate();
            }
        }

        /// <summary>
        /// Clear buffer of styles
        /// </summary>
        public void ClearStylesBuffer()
        {
            for (int i = 0; i < Styles.Length; i++)
                Styles[i] = null;
        }

        /// <summary>
        /// Clear style of all text
        /// </summary>
        public void ClearStyle(StyleIndex styleIndex)
        {
            foreach (Line line in lines)
                line.ClearStyle(styleIndex);

            for (int i = 0; i < LineInfos.Count; i++)
                SetVisibleState(i, VisibleState.Visible);

            Invalidate();
        }


        /// <summary>
        /// Clears undo and redo stacks
        /// </summary>
        public void ClearUndo()
        {
            lines.Manager.ClearHistory();
        }

        /// <summary>
        /// Insert text into current selected position
        /// </summary>
        public virtual void InsertText(string text)
        {
            InsertText(text, true);
        }

        /// <summary>
        /// Insert text into current selected position
        /// </summary>
        /// <param name="text"></param>
        public virtual void InsertText(string text, bool jumpToCaret)
        {
            if (text == null)
                return;
            if (text == "\r")
                text = "\n";

            lines.Manager.BeginAutoUndoCommands();
            try
            {
                if (!Selection.IsEmpty)
                    lines.Manager.ExecuteCommand(new ClearSelectedCommand(TextSource));

                //insert virtual spaces
                if (this.TextSource.Count > 0)
                    if (Selection.IsEmpty && Selection.Start.iChar > GetLineLength(Selection.Start.iLine) &&
                        VirtualSpace)
                        InsertVirtualSpaces();

                lines.Manager.ExecuteCommand(new InsertTextCommand(TextSource, text));
                if (updating <= 0 && jumpToCaret)
                    DoCaretVisible();
            }
            finally
            {
                lines.Manager.EndAutoUndoCommands();
            }

            //
            Invalidate();
        }

        /// <summary>
        /// Insert text into current selection position (with predefined style)
        /// </summary>
        /// <param name="text"></param>
        public virtual Range InsertText(string text, Style style)
        {
            return InsertText(text, style, true);
        }

        /// <summary>
        /// Insert text into current selection position (with predefined style)
        /// </summary>
        public virtual Range InsertText(string text, Style style, bool jumpToCaret)
        {
            if (text == null)
                return null;

            //remember last caret position
            Place last = Selection.Start > Selection.End ? Selection.End : Selection.Start;
            //insert text
            InsertText(text, jumpToCaret);
            //get range
            var range = new Range(this, last, Selection.Start) {ColumnSelectionMode = Selection.ColumnSelectionMode};
            range = range.GetIntersectionWith(Range);
            //set style for range
            range.SetStyle(style);

            return range;
        }

        /// <summary>
        /// Insert text into replaceRange and restore previous selection
        /// </summary>
        public virtual Range InsertTextAndRestoreSelection(Range replaceRange, string text, Style style)
        {
            if (text == null)
                return null;

            var oldStart = PlaceToPosition(Selection.Start);
            var oldEnd = PlaceToPosition(Selection.End);
            var count = replaceRange.Text.Length;
            var pos = PlaceToPosition(replaceRange.Start);
            //
            Selection.BeginUpdate();
            Selection = replaceRange;
            var range = InsertText(text, style);
            //
            count = range.Text.Length - count;
            Selection.Start = PositionToPlace(oldStart + (oldStart >= pos ? count : 0));
            Selection.End = PositionToPlace(oldEnd + (oldEnd >= pos ? count : 0));
            Selection.EndUpdate();

            return range;
        }

        /// <summary>
        /// Append string to end of the Text
        /// </summary>
        public virtual void AppendText(string text)
        {
            AppendText(text, null);
        }

        /// <summary>
        /// Append string to end of the Text
        /// </summary>
        public virtual void AppendText(string text, Style style)
        {
            if (text == null)
                return;

            Selection.ColumnSelectionMode = false;

            Place oldStart = Selection.Start;
            Place oldEnd = Selection.End;

            Selection.BeginUpdate();
            lines.Manager.BeginAutoUndoCommands();
            try
            {
                if (lines.Count > 0)
                    Selection.Start = new Place(lines[lines.Count - 1].Count, lines.Count - 1);
                else
                    Selection.Start = new Place(0, 0);

                //remember last caret position
                Place last = Selection.Start;

                lines.Manager.ExecuteCommand(new InsertTextCommand(TextSource, text));

                if (style != null)
                    new Range(this, last, Selection.Start).SetStyle(style);
            }
            finally
            {
                lines.Manager.EndAutoUndoCommands();
                Selection.Start = oldStart;
                Selection.End = oldEnd;
                Selection.EndUpdate();
            }

            //
            Invalidate();
        }

        /// <summary>
        /// Returns index of the style in Styles
        /// -1 otherwise
        /// </summary>
        /// <param name="style"></param>
        /// <returns>Index of the style in Styles</returns>
        public int GetStyleIndex(Style style)
        {
            return Array.IndexOf(Styles, style);
        }

        /// <summary>
        /// Returns StyleIndex mask of given styles
        /// </summary>
        /// <param name="styles"></param>
        /// <returns>StyleIndex mask of given styles</returns>
        public StyleIndex GetStyleIndexMask(Style[] styles)
        {
            StyleIndex mask = StyleIndex.None;
            foreach (Style style in styles)
            {
                int i = GetStyleIndex(style);
                if (i >= 0)
                    mask |= Range.ToStyleIndex(i);
            }

            return mask;
        }

        internal int GetOrSetStyleLayerIndex(Style style)
        {
            int i = GetStyleIndex(style);
            if (i < 0)
                i = AddStyle(style);
            return i;
        }

        public static SizeF GetCharSize(Font font, char c)
        {
            Size sz2 = TextRenderer.MeasureText("<" + c.ToString() + ">", font);
            Size sz3 = TextRenderer.MeasureText("<>", font);

            return new SizeF(sz2.Width - sz3.Width + 1, /*sz2.Height*/font.Height);
        }

      

        protected override void WndProc(ref Message m)
        {
            if (m.Msg == WM_HSCROLL || m.Msg == WM_VSCROLL)
                if (m.WParam.ToInt32() != SB_ENDSCROLL)
                    Invalidate();

            base.WndProc(ref m);

            if (ImeAllowed)
                if (m.Msg == WM_IME_SETCONTEXT && m.WParam.ToInt32() == 1)
                {
                    NativeMethodWrapper.ImmAssociateContext(Handle, m_hImc);
                }
        }

        List<Control> tempHintsList = new List<Control>();

        void HideHints()
        {
            //temporarly remove hints
            if (!ShowScrollBars && Hints.Count > 0)
            {
                (this as Control).SuspendLayout();

                foreach (Control c in Controls)
                    tempHintsList.Add(c);

                Controls.Clear();
            }
        }

        void RestoreHints()
        {
            //restore hints
            if (!ShowScrollBars && Hints.Count > 0)
            {
                foreach (var c in tempHintsList)
                    Controls.Add(c);

                tempHintsList.Clear();

                (this as Control).ResumeLayout(false);

                if (!Focused)
                    Focus();
            }
        }

        public void OnScroll(ScrollEventArgs se, bool alignByLines)
        {
            HideHints();

            if (se.ScrollOrientation == ScrollOrientation.VerticalScroll)
            {
                //align by line height
                int newValue = se.NewValue;
                if (alignByLines)
                    newValue = (int) (Math.Ceiling(1d * newValue / CharHeight) * CharHeight);
                //
                VerticalScroll.Value = Math.Max(VerticalScroll.Minimum, Math.Min(VerticalScroll.Maximum, newValue));
            }

            if (se.ScrollOrientation == ScrollOrientation.HorizontalScroll)
                HorizontalScroll.Value =
                    Math.Max(HorizontalScroll.Minimum, Math.Min(HorizontalScroll.Maximum, se.NewValue));

            UpdateScrollbars();

            RestoreHints();

            Invalidate();
            //
            base.OnScroll(se);
            OnVisibleRangeChanged();
        }

        protected override void OnScroll(ScrollEventArgs se)
        {
            OnScroll(se, true);
        }

        protected virtual void InsertChar(char c)
        {
            lines.Manager.BeginAutoUndoCommands();
            try
            {
                if (!Selection.IsEmpty)
                    lines.Manager.ExecuteCommand(new ClearSelectedCommand(TextSource));

                //insert virtual spaces
                if (Selection.IsEmpty && Selection.Start.iChar > GetLineLength(Selection.Start.iLine) && VirtualSpace)
                    InsertVirtualSpaces();

                //insert char
                lines.Manager.ExecuteCommand(new InsertCharCommand(TextSource, c));
            }
            finally
            {
                lines.Manager.EndAutoUndoCommands();
            }

            Invalidate();
        }

        private void InsertVirtualSpaces()
        {
            int lineLength = GetLineLength(Selection.Start.iLine);
            int count = Selection.Start.iChar - lineLength;
            Selection.BeginUpdate();
            try
            {
                Selection.Start = new Place(lineLength, Selection.Start.iLine);
                lines.Manager.ExecuteCommand(new InsertTextCommand(TextSource, new string(' ', count)));
            }
            finally
            {
                Selection.EndUpdate();
            }
        }

        /// <summary>
        /// Deletes selected chars
        /// </summary>
        public virtual void ClearSelected()
        {
            if (!Selection.IsEmpty)
            {
                lines.Manager.ExecuteCommand(new ClearSelectedCommand(TextSource));
                Invalidate();
            }
        }

        /// <summary>
        /// Deletes current line(s)
        /// </summary>
        public void ClearCurrentLine()
        {
            Selection.Expand();

            lines.Manager.ExecuteCommand(new ClearSelectedCommand(TextSource));
            if (Selection.Start.iLine == 0)
                if (!Selection.GoRightThroughFolded())
                    return;
            if (Selection.Start.iLine > 0)
                lines.Manager.ExecuteCommand(new InsertCharCommand(TextSource, '\b')); //backspace
            Invalidate();
        }

        private void Recalc()
        {
            if (!needRecalc)
                return;

#if debug
            var sw = Stopwatch.StartNew();
#endif

            needRecalc = false;
            //calc min left indent
            LeftIndent = LeftPadding;
            long maxLineNumber = LinesCount + lineNumberStartValue - 1;
            int charsForLineNumber = 2 + (maxLineNumber > 0 ? (int) Math.Log10(maxLineNumber) : 0);

            // If there are reserved character for line numbers: correct this
            if (this.ReservedCountOfLineNumberChars + 1 > charsForLineNumber)
                charsForLineNumber = this.ReservedCountOfLineNumberChars + 1;

            if (Created)
            {
                if (ShowLineNumbers)
                    LeftIndent += charsForLineNumber * CharWidth + minLeftIndent + 1;

                //calc wordwrapping
                if (needRecalcWordWrap)
                {
                    RecalcWordWrap(needRecalcWordWrapInterval.X, needRecalcWordWrapInterval.Y);
                    needRecalcWordWrap = false;
                }
            }
            else
                needRecalc = true;

            //calc max line length and count of wordWrapLines
            TextHeight = 0;

            maxLineLength = RecalcMaxLineLength();

            //adjust AutoScrollMinSize
            int minWidth;
            CalcMinAutosizeWidth(out minWidth, ref maxLineLength);

            AutoScrollMinSize = new Size(minWidth, TextHeight + Paddings.Top + Paddings.Bottom);
            UpdateScrollbars();
#if debug
            sw.Stop();
            Console.WriteLine("Recalc: " + sw.ElapsedMilliseconds);
#endif
        }

        private void CalcMinAutosizeWidth(out int minWidth, ref int maxLineLength)
        {
            //adjust AutoScrollMinSize
            minWidth = LeftIndent + (maxLineLength) * CharWidth + 2 + Paddings.Left + Paddings.Right;
            if (wordWrap)
                switch (WordWrapMode)
                {
                    case WordWrapMode.WordWrapControlWidth:
                    case WordWrapMode.CharWrapControlWidth:
                        maxLineLength = Math.Min(maxLineLength,
                            (ClientSize.Width - LeftIndent - Paddings.Left - Paddings.Right) /
                            CharWidth);
                        minWidth = 0;
                        break;
                    case WordWrapMode.WordWrapPreferredWidth:
                    case WordWrapMode.CharWrapPreferredWidth:
                        maxLineLength = Math.Min(maxLineLength, PreferredLineWidth);
                        minWidth = LeftIndent + PreferredLineWidth * CharWidth + 2 + Paddings.Left + Paddings.Right;
                        break;
                }
        }

        private void RecalcScrollByOneLine(int iLine)
        {
            if (iLine >= lines.Count)
                return;

            int maxLineLength = lines[iLine].Count;
            if (this.maxLineLength < maxLineLength && !WordWrap)
                this.maxLineLength = maxLineLength;

            int minWidth;
            CalcMinAutosizeWidth(out minWidth, ref maxLineLength);

            if (AutoScrollMinSize.Width < minWidth)
                AutoScrollMinSize = new Size(minWidth, AutoScrollMinSize.Height);
        }

        private int RecalcMaxLineLength()
        {
            int maxLineLength = 0;
            TextSource lines = this.lines;
            int count = lines.Count;
            int charHeight = CharHeight;
            int topIndent = Paddings.Top;
            TextHeight = topIndent;

            for (int i = 0; i < count; i++)
            {
                int lineLength = lines.GetLineLength(i);
                LineInfo lineInfo = LineInfos[i];
                if (lineLength > maxLineLength && lineInfo.VisibleState == VisibleState.Visible)
                    maxLineLength = lineLength;
                lineInfo.startY = TextHeight;
                TextHeight += lineInfo.WordWrapStringsCount * charHeight + lineInfo.bottomPadding;
                LineInfos[i] = lineInfo;
            }

            TextHeight -= topIndent;

            return maxLineLength;
        }

        private int GetMaxLineWordWrapedWidth()
        {
            if (wordWrap)
                switch (wordWrapMode)
                {
                    case WordWrapMode.WordWrapControlWidth:
                    case WordWrapMode.CharWrapControlWidth:
                        return ClientSize.Width;
                    case WordWrapMode.WordWrapPreferredWidth:
                    case WordWrapMode.CharWrapPreferredWidth:
                        return LeftIndent + PreferredLineWidth * CharWidth + 2 + Paddings.Left + Paddings.Right;
                }

            return int.MaxValue;
        }

        private void RecalcWordWrap(int fromLine, int toLine)
        {
            int maxCharsPerLine = 0;
            bool charWrap = false;

            toLine = Math.Min(LinesCount - 1, toLine);

            switch (WordWrapMode)
            {
                case WordWrapMode.WordWrapControlWidth:
                    maxCharsPerLine = (ClientSize.Width - LeftIndent - Paddings.Left - Paddings.Right) / CharWidth;
                    break;
                case WordWrapMode.CharWrapControlWidth:
                    maxCharsPerLine = (ClientSize.Width - LeftIndent - Paddings.Left - Paddings.Right) / CharWidth;
                    charWrap = true;
                    break;
                case WordWrapMode.WordWrapPreferredWidth:
                    maxCharsPerLine = PreferredLineWidth;
                    break;
                case WordWrapMode.CharWrapPreferredWidth:
                    maxCharsPerLine = PreferredLineWidth;
                    charWrap = true;
                    break;
            }

            for (int iLine = fromLine; iLine <= toLine; iLine++)
                if (lines.IsLineLoaded(iLine))
                {
                    if (!wordWrap)
                        LineInfos[iLine].CutOffPositions.Clear();
                    else
                    {
                        LineInfo li = LineInfos[iLine];

                        li.wordWrapIndent = WordWrapAutoIndent
                            ? lines[iLine].StartSpacesCount + WordWrapIndent
                            : WordWrapIndent;

                        if (WordWrapMode == WordWrapMode.Custom)
                        {
                            if (WordWrapNeeded != null)
                                WordWrapNeeded(this,
                                    new WordWrapNeededEventArgs(li.CutOffPositions, ImeAllowed, lines[iLine]));
                        }
                        else
                            CalcCutOffs(li.CutOffPositions, maxCharsPerLine, maxCharsPerLine - li.wordWrapIndent,
                                ImeAllowed, charWrap, lines[iLine]);

                        LineInfos[iLine] = li;
                    }
                }

            needRecalc = true;
        }

        /// <summary>
        /// Calculates wordwrap cutoffs
        /// </summary>
        public static void CalcCutOffs(List<int> cutOffPositions, int maxCharsPerLine, int maxCharsPerSecondaryLine,
            bool allowIME, bool charWrap, Line line)
        {
            if (maxCharsPerSecondaryLine < 1) maxCharsPerSecondaryLine = 1;
            if (maxCharsPerLine < 1) maxCharsPerLine = 1;

            int segmentLength = 0;
            int cutOff = 0;
            cutOffPositions.Clear();

            for (int i = 0; i < line.Count - 1; i++)
            {
                char c = line[i].c;
                if (charWrap)
                {
                    //char wrapping
                    cutOff = i + 1;
                }
                else
                {
                    //word wrapping
                    if (allowIME && IsCJKLetter(c)) //in CJK languages cutoff can be in any letter
                    {
                        cutOff = i;
                    }
                    else if (!char.IsLetterOrDigit(c) && c != '_' && c != '\'' && c != '\xa0'
                             && ((c != '.' && c != ',') || !char.IsDigit(line[i + 1].c))) //dot before digit
                        cutOff = Math.Min(i + 1, line.Count - 1);
                }

                segmentLength++;

                if (segmentLength == maxCharsPerLine)
                {
                    if (cutOff == 0 || (cutOffPositions.Count > 0 &&
                                        cutOff == cutOffPositions[cutOffPositions.Count - 1]))
                        cutOff = i + 1;
                    cutOffPositions.Add(cutOff);
                    segmentLength = 1 + i - cutOff;
                    maxCharsPerLine = maxCharsPerSecondaryLine;
                }
            }
        }

        public static bool IsCJKLetter(char c)
        {
            int code = Convert.ToInt32(c);
            return
                (code >= 0x3300 && code <= 0x33FF) ||
                (code >= 0xFE30 && code <= 0xFE4F) ||
                (code >= 0xF900 && code <= 0xFAFF) ||
                (code >= 0x2E80 && code <= 0x2EFF) ||
                (code >= 0x31C0 && code <= 0x31EF) ||
                (code >= 0x4E00 && code <= 0x9FFF) ||
                (code >= 0x3400 && code <= 0x4DBF) ||
                (code >= 0x3200 && code <= 0x32FF) ||
                (code >= 0x2460 && code <= 0x24FF) ||
                (code >= 0x3040 && code <= 0x309F) ||
                (code >= 0x2F00 && code <= 0x2FDF) ||
                (code >= 0x31A0 && code <= 0x31BF) ||
                (code >= 0x4DC0 && code <= 0x4DFF) ||
                (code >= 0x3100 && code <= 0x312F) ||
                (code >= 0x30A0 && code <= 0x30FF) ||
                (code >= 0x31F0 && code <= 0x31FF) ||
                (code >= 0x2FF0 && code <= 0x2FFF) ||
                (code >= 0x1100 && code <= 0x11FF) ||
                (code >= 0xA960 && code <= 0xA97F) ||
                (code >= 0xD7B0 && code <= 0xD7FF) ||
                (code >= 0x3130 && code <= 0x318F) ||
                (code >= 0xAC00 && code <= 0xD7AF);
        }

        protected override void OnClientSizeChanged(EventArgs e)
        {
            base.OnClientSizeChanged(e);
            if (WordWrap)
            {
                //RecalcWordWrap(0, lines.Count - 1);
                NeedRecalc(false, true);
                Invalidate();
            }

            OnVisibleRangeChanged();
            UpdateScrollbars();
        }

        /// <summary>
        /// Scroll control for display defined rectangle
        /// </summary>
        /// <param name="rect"></param>
        internal void DoVisibleRectangle(Rectangle rect)
        {
            HideHints();

            int oldV = VerticalScroll.Value;
            int v = VerticalScroll.Value;
            int h = HorizontalScroll.Value;

            if (rect.Bottom > ClientRectangle.Height)
                v += rect.Bottom - ClientRectangle.Height;
            else if (rect.Top < 0)
                v += rect.Top;

            if (rect.Right > ClientRectangle.Width)
                h += rect.Right - ClientRectangle.Width;
            else if (rect.Left < LeftIndent)
                h += rect.Left - LeftIndent;
            //
            if (!Multiline)
                v = 0;
            //
            v = Math.Max(VerticalScroll.Minimum, v); // was 0
            h = Math.Max(HorizontalScroll.Minimum, h); // was 0
            //
            try
            {
                if (VerticalScroll.Visible || !ShowScrollBars)
                    VerticalScroll.Value = Math.Min(v, VerticalScroll.Maximum);
                if (HorizontalScroll.Visible || !ShowScrollBars)
                    HorizontalScroll.Value = Math.Min(h, HorizontalScroll.Maximum);
            }
            catch (ArgumentOutOfRangeException)
            {
                ;
            }

            UpdateScrollbars();
            //
            RestoreHints();
            //
            if (oldV != VerticalScroll.Value)
                OnVisibleRangeChanged();
        }

        /// <summary>
        /// Updates scrollbar position after Value changed
        /// </summary>
        public void UpdateScrollbars()
        {
            if (ShowScrollBars)
            {
                //some magic for update scrolls
                base.AutoScrollMinSize -= new Size(1, 0);
                base.AutoScrollMinSize += new Size(1, 0);
            }
            else
                PerformLayout();

            if (IsHandleCreated)
                BeginInvoke((MethodInvoker) OnScrollbarsUpdated);
        }

        protected virtual void OnScrollbarsUpdated()
        {
            if (ScrollbarsUpdated != null)
                ScrollbarsUpdated(this, EventArgs.Empty);
        }

        /// <summary>
        /// Scroll control for display caret
        /// </summary>
        public void DoCaretVisible()
        {
            Invalidate();
            Recalc();
            Point car = PlaceToPoint(Selection.Start);
            car.Offset(-CharWidth, 0);
            DoVisibleRectangle(new Rectangle(car, new Size(2 * CharWidth, 2 * CharHeight)));
        }

        /// <summary>
        /// Scroll control left
        /// </summary>
        public void ScrollLeft()
        {
            Invalidate();
            HorizontalScroll.Value = 0;
            AutoScrollMinSize -= new Size(1, 0);
            AutoScrollMinSize += new Size(1, 0);
        }

        /// <summary>
        /// Scroll control for display selection area
        /// </summary>
        public void DoSelectionVisible()
        {
            if (LineInfos[Selection.End.iLine].VisibleState != VisibleState.Visible)
                ExpandBlock(Selection.End.iLine);

            if (LineInfos[Selection.Start.iLine].VisibleState != VisibleState.Visible)
                ExpandBlock(Selection.Start.iLine);

            Recalc();
            DoVisibleRectangle(new Rectangle(PlaceToPoint(new Place(0, Selection.End.iLine)),
                new Size(2 * CharWidth, 2 * CharHeight)));

            Point car = PlaceToPoint(Selection.Start);
            Point car2 = PlaceToPoint(Selection.End);
            car.Offset(-CharWidth, -ClientSize.Height / 2);
            DoVisibleRectangle(new Rectangle(car, new Size(Math.Abs(car2.X - car.X), ClientSize.Height)));
            //Math.Abs(car2.Y-car.Y) + 2 * CharHeight

            Invalidate();
        }

        /// <summary>
        /// Scroll control for display given range
        /// </summary>
        public void DoRangeVisible(Range range)
        {
            DoRangeVisible(range, false);
        }

        /// <summary>
        /// Scroll control for display given range
        /// </summary>
        public void DoRangeVisible(Range range, bool tryToCentre)
        {
            range = range.Clone();
            range.Normalize();
            range.End = new Place(range.End.iChar,
                Math.Min(range.End.iLine, range.Start.iLine + ClientSize.Height / CharHeight));

            if (LineInfos[range.End.iLine].VisibleState != VisibleState.Visible)
                ExpandBlock(range.End.iLine);

            if (LineInfos[range.Start.iLine].VisibleState != VisibleState.Visible)
                ExpandBlock(range.Start.iLine);

            Recalc();
            int h = (1 + range.End.iLine - range.Start.iLine) * CharHeight;
            Point p = PlaceToPoint(new Place(0, range.Start.iLine));
            if (tryToCentre)
            {
                p.Offset(0, -ClientSize.Height / 2);
                h = ClientSize.Height;
            }

            DoVisibleRectangle(new Rectangle(p, new Size(2 * CharWidth, h)));

            Invalidate();
        }


        protected override void OnKeyUp(KeyEventArgs e)
        {
            base.OnKeyUp(e);

            if (e.KeyCode == Keys.ShiftKey)
                lastModifiers &= ~Keys.Shift;
            if (e.KeyCode == Keys.Alt)
                lastModifiers &= ~Keys.Alt;
            if (e.KeyCode == Keys.ControlKey)
                lastModifiers &= ~Keys.Control;
        }


        bool findCharMode;

        protected override void OnKeyDown(KeyEventArgs e)
        {
            if (middleClickScrollingActivated)
                return;

            base.OnKeyDown(e);

            if (Focused) //??? 
                lastModifiers = e.Modifiers;

            handledChar = false;

            if (e.Handled)
            {
                handledChar = true;
                return;
            }

            if (ProcessKey(e.KeyData))
                return;

            e.Handled = true;

            DoCaretVisible();
            Invalidate();
        }

        protected override bool ProcessDialogKey(Keys keyData)
        {
            if ((keyData & Keys.Alt) > 0)
            {
                if (HotkeysMapping.ContainsKey(keyData))
                {
                    ProcessKey(keyData);
                    return true;
                }
            }

            return base.ProcessDialogKey(keyData);
        }

        static Dictionary<FCTBAction, bool> scrollActions = new Dictionary<FCTBAction, bool>()
        {
            {FCTBAction.ScrollDown, true}, {FCTBAction.ScrollUp, true}, {FCTBAction.ZoomOut, true},
            {FCTBAction.ZoomIn, true}, {FCTBAction.ZoomNormal, true}
        };

        /// <summary>
        /// Process control keys
        /// </summary>
        public virtual bool ProcessKey(Keys keyData)
        {
            KeyEventArgs a = new KeyEventArgs(keyData);

            if (a.KeyCode == Keys.Tab && !AcceptsTab)
                return false;


            if (macrosManager != null)
                if (!HotkeysMapping.ContainsKey(keyData) ||
                    (HotkeysMapping[keyData] != FCTBAction.MacroExecute &&
                     HotkeysMapping[keyData] != FCTBAction.MacroRecord))
                    macrosManager.ProcessKey(keyData);

            if (HotkeysMapping.ContainsKey(keyData))
            {
                var act = HotkeysMapping[keyData];
                DoAction(act);
                if (scrollActions.ContainsKey(act))
                    return true;
                if (keyData == Keys.Tab || keyData == (Keys.Tab | Keys.Shift))
                {
                    handledChar = true;
                    return true;
                }
            }
            else
            {
                //
                if (a.KeyCode == Keys.Alt)
                    return true;

                if ((a.Modifiers & Keys.Control) != 0)
                    return true;

                if ((a.Modifiers & Keys.Alt) != 0)
                {
                    if ((MouseButtons & MouseButtons.Left) != 0)
                        CheckAndChangeSelectionType();
                    return true;
                }

                if (a.KeyCode == Keys.ShiftKey)
                    return true;
            }

            return false;
        }

        private void DoAction(FCTBAction action)
        {
            switch (action)
            {
                case FCTBAction.ZoomIn:
                    ChangeFontSize(2);
                    break;
                case FCTBAction.ZoomOut:
                    ChangeFontSize(-2);
                    break;
                case FCTBAction.ZoomNormal:
                    RestoreFontSize();
                    break;
                case FCTBAction.ScrollDown:
                    DoScrollVertical(1, -1);
                    break;

                case FCTBAction.ScrollUp:
                    DoScrollVertical(1, 1);
                    break;

                case FCTBAction.GoToDialog:
                    ShowGoToDialog();
                    break;

                case FCTBAction.FindDialog:
                    ShowFindDialog();
                    break;

                case FCTBAction.FindChar:
                    findCharMode = true;
                    break;

                case FCTBAction.FindNext:
                    if (findForm == null || findForm.tbFind.Text == "")
                        ShowFindDialog();
                    else
                        findForm.FindNext(findForm.tbFind.Text);
                    break;

                case FCTBAction.ReplaceDialog:
                    ShowReplaceDialog();
                    break;

                case FCTBAction.Copy:
                    Copy();
                    break;

                case FCTBAction.CommentSelected:
                    CommentSelected();
                    break;

                case FCTBAction.Cut:
                    if (!Selection.ReadOnly)
                        Cut();
                    break;

                case FCTBAction.Paste:
                    if (!Selection.ReadOnly)
                        Paste();
                    break;

                case FCTBAction.SelectAll:
                    Selection.SelectAll();
                    break;

                case FCTBAction.Undo:
                    if (!ReadOnly)
                        Undo();
                    break;

                case FCTBAction.Redo:
                    if (!ReadOnly)
                        Redo();
                    break;

                case FCTBAction.LowerCase:
                    if (!Selection.ReadOnly)
                        LowerCase();
                    break;

                case FCTBAction.UpperCase:
                    if (!Selection.ReadOnly)
                        UpperCase();
                    break;

                case FCTBAction.IndentDecrease:
                    if (!Selection.ReadOnly)
                    {
                        var sel = Selection.Clone();
                        if (sel.Start.iLine == sel.End.iLine)
                        {
                            var line = this[sel.Start.iLine];
                            if (sel.Start.iChar == 0 && sel.End.iChar == line.Count)
                                Selection = new Range(this, line.StartSpacesCount, sel.Start.iLine, line.Count,
                                    sel.Start.iLine);
                            else if (sel.Start.iChar == line.Count && sel.End.iChar == 0)
                                Selection = new Range(this, line.Count, sel.Start.iLine, line.StartSpacesCount,
                                    sel.Start.iLine);
                        }


                        DecreaseIndent();
                    }

                    break;

                case FCTBAction.IndentIncrease:
                    if (!Selection.ReadOnly)
                    {
                        var sel = Selection.Clone();
                        var inverted = sel.Start > sel.End;
                        sel.Normalize();
                        var spaces = this[sel.Start.iLine].StartSpacesCount;
                        if (sel.Start.iLine != sel.End.iLine || //selected several lines
                            (sel.Start.iChar <= spaces &&
                             sel.End.iChar == this[sel.Start.iLine].Count) || //selected whole line
                            sel.End.iChar <= spaces) //selected space prefix
                        {
                            IncreaseIndent();
                            if (sel.Start.iLine == sel.End.iLine && !sel.IsEmpty)
                            {
                                Selection = new Range(this, this[sel.Start.iLine].StartSpacesCount, sel.End.iLine,
                                    this[sel.Start.iLine].Count, sel.End.iLine); //select whole line
                                if (inverted)
                                    Selection.Inverse();
                            }
                        }
                        else
                            ProcessKey('\t', Keys.None);
                    }

                    break;

                case FCTBAction.AutoIndentChars:
                    if (!Selection.ReadOnly)
                        DoAutoIndentChars(Selection.Start.iLine);
                    break;

                case FCTBAction.NavigateBackward:
                    NavigateBackward();
                    break;

                case FCTBAction.NavigateForward:
                    NavigateForward();
                    break;

                case FCTBAction.UnbookmarkLine:
                    UnbookmarkLine(Selection.Start.iLine);
                    break;

                case FCTBAction.BookmarkLine:
                    BookmarkLine(Selection.Start.iLine);
                    break;

                case FCTBAction.GoNextBookmark:
                    GotoNextBookmark(Selection.Start.iLine);
                    break;

                case FCTBAction.GoPrevBookmark:
                    GotoPrevBookmark(Selection.Start.iLine);
                    break;

                case FCTBAction.ClearWordLeft:
                    if (OnKeyPressing('\b')) //KeyPress event processed key
                        break;
                    if (!Selection.ReadOnly)
                    {
                        if (!Selection.IsEmpty)
                            ClearSelected();
                        Selection.GoWordLeft(true);
                        if (!Selection.ReadOnly)
                            ClearSelected();
                    }

                    OnKeyPressed('\b');
                    break;

                case FCTBAction.ReplaceMode:
                    if (!ReadOnly)
                        isReplaceMode = !isReplaceMode;
                    break;

                case FCTBAction.DeleteCharRight:
                    if (!Selection.ReadOnly)
                    {
                        if (OnKeyPressing((char) 0xff)) //KeyPress event processed key
                            break;
                        if (!Selection.IsEmpty)
                            ClearSelected();
                        else
                        {
                            //if line contains only spaces then delete line
                            if (this[Selection.Start.iLine].StartSpacesCount == this[Selection.Start.iLine].Count)
                                RemoveSpacesAfterCaret();

                            if (!Selection.IsReadOnlyRightChar())
                                if (Selection.GoRightThroughFolded())
                                {
                                    int iLine = Selection.Start.iLine;

                                    InsertChar('\b');

                                    //if removed \n then trim spaces
                                    if (iLine != Selection.Start.iLine && AutoIndent)
                                        if (Selection.Start.iChar > 0)
                                            RemoveSpacesAfterCaret();
                                }
                        }

                        if (AutoIndentChars)
                            DoAutoIndentChars(Selection.Start.iLine);

                        OnKeyPressed((char) 0xff);
                    }

                    break;

                case FCTBAction.ClearWordRight:
                    if (OnKeyPressing((char) 0xff)) //KeyPress event processed key
                        break;
                    if (!Selection.ReadOnly)
                    {
                        if (!Selection.IsEmpty)
                            ClearSelected();
                        Selection.GoWordRight(true);
                        if (!Selection.ReadOnly)
                            ClearSelected();
                    }

                    OnKeyPressed((char) 0xff);
                    break;

                case FCTBAction.GoWordLeft:
                    Selection.GoWordLeft(false);
                    break;

                case FCTBAction.GoWordLeftWithSelection:
                    Selection.GoWordLeft(true);
                    break;

                case FCTBAction.GoLeft:
                    Selection.GoLeft(false);
                    break;

                case FCTBAction.GoLeftWithSelection:
                    Selection.GoLeft(true);
                    break;

                case FCTBAction.GoLeft_ColumnSelectionMode:
                    CheckAndChangeSelectionType();
                    if (Selection.ColumnSelectionMode)
                        Selection.GoLeft_ColumnSelectionMode();
                    Invalidate();
                    break;

                case FCTBAction.GoWordRight:
                    Selection.GoWordRight(false, true);
                    break;

                case FCTBAction.GoWordRightWithSelection:
                    Selection.GoWordRight(true, true);
                    break;

                case FCTBAction.GoRight:
                    Selection.GoRight(false);
                    break;

                case FCTBAction.GoRightWithSelection:
                    Selection.GoRight(true);
                    break;

                case FCTBAction.GoRight_ColumnSelectionMode:
                    CheckAndChangeSelectionType();
                    if (Selection.ColumnSelectionMode)
                        Selection.GoRight_ColumnSelectionMode();
                    Invalidate();
                    break;

                case FCTBAction.GoUp:
                    Selection.GoUp(false);
                    ScrollLeft();
                    break;

                case FCTBAction.GoUpWithSelection:
                    Selection.GoUp(true);
                    ScrollLeft();
                    break;

                case FCTBAction.GoUp_ColumnSelectionMode:
                    CheckAndChangeSelectionType();
                    if (Selection.ColumnSelectionMode)
                        Selection.GoUp_ColumnSelectionMode();
                    Invalidate();
                    break;

                case FCTBAction.MoveSelectedLinesUp:
                    if (!Selection.ColumnSelectionMode)
                        MoveSelectedLinesUp();
                    break;

                case FCTBAction.GoDown:
                    Selection.GoDown(false);
                    ScrollLeft();
                    break;

                case FCTBAction.GoDownWithSelection:
                    Selection.GoDown(true);
                    ScrollLeft();
                    break;

                case FCTBAction.GoDown_ColumnSelectionMode:
                    CheckAndChangeSelectionType();
                    if (Selection.ColumnSelectionMode)
                        Selection.GoDown_ColumnSelectionMode();
                    Invalidate();
                    break;

                case FCTBAction.MoveSelectedLinesDown:
                    if (!Selection.ColumnSelectionMode)
                        MoveSelectedLinesDown();
                    break;
                case FCTBAction.GoPageUp:
                    Selection.GoPageUp(false);
                    ScrollLeft();
                    break;

                case FCTBAction.GoPageUpWithSelection:
                    Selection.GoPageUp(true);
                    ScrollLeft();
                    break;

                case FCTBAction.GoPageDown:
                    Selection.GoPageDown(false);
                    ScrollLeft();
                    break;

                case FCTBAction.GoPageDownWithSelection:
                    Selection.GoPageDown(true);
                    ScrollLeft();
                    break;

                case FCTBAction.GoFirstLine:
                    Selection.GoFirst(false);
                    break;

                case FCTBAction.GoFirstLineWithSelection:
                    Selection.GoFirst(true);
                    break;

                case FCTBAction.GoHome:
                    GoHome(false);
                    ScrollLeft();
                    break;

                case FCTBAction.GoHomeWithSelection:
                    GoHome(true);
                    ScrollLeft();
                    break;

                case FCTBAction.GoLastLine:
                    Selection.GoLast(false);
                    break;

                case FCTBAction.GoLastLineWithSelection:
                    Selection.GoLast(true);
                    break;

                case FCTBAction.GoEnd:
                    Selection.GoEnd(false);
                    break;

                case FCTBAction.GoEndWithSelection:
                    Selection.GoEnd(true);
                    break;

                case FCTBAction.ClearHints:
                    ClearHints();
                    if (MacrosManager != null)
                        MacrosManager.IsRecording = false;
                    break;

                case FCTBAction.MacroRecord:
                    if (MacrosManager != null)
                    {
                        if (MacrosManager.AllowMacroRecordingByUser)
                            MacrosManager.IsRecording = !MacrosManager.IsRecording;
                        if (MacrosManager.IsRecording)
                            MacrosManager.ClearMacros();
                    }

                    break;

                case FCTBAction.MacroExecute:
                    if (MacrosManager != null)
                    {
                        MacrosManager.IsRecording = false;
                        MacrosManager.ExecuteMacros();
                    }

                    break;
                case FCTBAction.CustomAction1:
                case FCTBAction.CustomAction2:
                case FCTBAction.CustomAction3:
                case FCTBAction.CustomAction4:
                case FCTBAction.CustomAction5:
                case FCTBAction.CustomAction6:
                case FCTBAction.CustomAction7:
                case FCTBAction.CustomAction8:
                case FCTBAction.CustomAction9:
                case FCTBAction.CustomAction10:
                case FCTBAction.CustomAction11:
                case FCTBAction.CustomAction12:
                case FCTBAction.CustomAction13:
                case FCTBAction.CustomAction14:
                case FCTBAction.CustomAction15:
                case FCTBAction.CustomAction16:
                case FCTBAction.CustomAction17:
                case FCTBAction.CustomAction18:
                case FCTBAction.CustomAction19:
                case FCTBAction.CustomAction20:
                    OnCustomAction(new CustomActionEventArgs(action));
                    break;
            }
        }

        protected virtual void OnCustomAction(CustomActionEventArgs e)
        {
            if (CustomAction != null)
                CustomAction(this, e);
        }

        Font originalFont;

        private void RestoreFontSize()
        {
            Zoom = 100;
        }

        /// <summary>
        /// Scrolls to nearest bookmark or to first bookmark
        /// </summary>
        /// <param name="iLine">Current bookmark line index</param>
        public bool GotoNextBookmark(int iLine)
        {
            Bookmark nearestBookmark = null;
            int minNextLineIndex = int.MaxValue;
            Bookmark minBookmark = null;
            int minLineIndex = int.MaxValue;
            foreach (Bookmark bookmark in bookmarks)
            {
                if (bookmark.LineIndex < minLineIndex)
                {
                    minLineIndex = bookmark.LineIndex;
                    minBookmark = bookmark;
                }

                if (bookmark.LineIndex > iLine && bookmark.LineIndex < minNextLineIndex)
                {
                    minNextLineIndex = bookmark.LineIndex;
                    nearestBookmark = bookmark;
                }
            }

            if (nearestBookmark != null)
            {
                nearestBookmark.DoVisible();
                return true;
            }
            else if (minBookmark != null)
            {
                minBookmark.DoVisible();
                return true;
            }

            return false;
        }

        /// <summary>
        /// Scrolls to nearest previous bookmark or to last bookmark
        /// </summary>
        /// <param name="iLine">Current bookmark line index</param>
        public bool GotoPrevBookmark(int iLine)
        {
            Bookmark nearestBookmark = null;
            int maxPrevLineIndex = -1;
            Bookmark maxBookmark = null;
            int maxLineIndex = -1;
            foreach (Bookmark bookmark in bookmarks)
            {
                if (bookmark.LineIndex > maxLineIndex)
                {
                    maxLineIndex = bookmark.LineIndex;
                    maxBookmark = bookmark;
                }

                if (bookmark.LineIndex < iLine && bookmark.LineIndex > maxPrevLineIndex)
                {
                    maxPrevLineIndex = bookmark.LineIndex;
                    nearestBookmark = bookmark;
                }
            }

            if (nearestBookmark != null)
            {
                nearestBookmark.DoVisible();
                return true;
            }
            else if (maxBookmark != null)
            {
                maxBookmark.DoVisible();
                return true;
            }

            return false;
        }

        /// <summary>
        /// Bookmarks line
        /// </summary>
        public virtual void BookmarkLine(int iLine)
        {
            if (!bookmarks.Contains(iLine))
                bookmarks.Add(iLine);
        }

        /// <summary>
        /// Unbookmarks current line
        /// </summary>
        public virtual void UnbookmarkLine(int iLine)
        {
            bookmarks.Remove(iLine);
        }

        /// <summary>
        /// Moves selected lines down
        /// </summary>
        public virtual void MoveSelectedLinesDown()
        {
            Range prevSelection = Selection.Clone();
            Selection.Expand();
            if (!Selection.ReadOnly)
            {
                int iLine = Selection.Start.iLine;
                if (Selection.End.iLine >= LinesCount - 1)
                {
                    Selection = prevSelection;
                    return;
                }

                string text = SelectedText;
                var temp = new List<int>();
                for (int i = Selection.Start.iLine; i <= Selection.End.iLine; i++)
                    temp.Add(i);
                RemoveLines(temp);
                Selection.Start = new Place(GetLineLength(iLine), iLine);
                SelectedText = "\n" + text;
                Selection.Start = new Place(prevSelection.Start.iChar, prevSelection.Start.iLine + 1);
                Selection.End = new Place(prevSelection.End.iChar, prevSelection.End.iLine + 1);
            }
            else
                Selection = prevSelection;
        }

        /// <summary>
        /// Moves selected lines up
        /// </summary>
        public virtual void MoveSelectedLinesUp()
        {
            Range prevSelection = Selection.Clone();
            Selection.Expand();
            if (!Selection.ReadOnly)
            {
                int iLine = Selection.Start.iLine;
                if (iLine == 0)
                {
                    Selection = prevSelection;
                    return;
                }

                string text = SelectedText;
                var temp = new List<int>();
                for (int i = Selection.Start.iLine; i <= Selection.End.iLine; i++)
                    temp.Add(i);
                RemoveLines(temp);
                Selection.Start = new Place(0, iLine - 1);
                SelectedText = text + "\n";
                Selection.Start = new Place(prevSelection.Start.iChar, prevSelection.Start.iLine - 1);
                Selection.End = new Place(prevSelection.End.iChar, prevSelection.End.iLine - 1);
            }
            else
                Selection = prevSelection;
        }

        private void GoHome(bool shift)
        {
            Selection.BeginUpdate();
            try
            {
                int iLine = Selection.Start.iLine;
                int spaces = this[iLine].StartSpacesCount;
                if (Selection.Start.iChar <= spaces)
                    Selection.GoHome(shift);
                else
                {
                    Selection.GoHome(shift);
                    for (int i = 0; i < spaces; i++)
                        Selection.GoRight(shift);
                }
            }
            finally
            {
                Selection.EndUpdate();
            }
        }

        /// <summary>
        /// Convert selected text to upper case
        /// </summary>
        public virtual void UpperCase()
        {
            Range old = Selection.Clone();
            SelectedText = SelectedText.ToUpper();
            Selection.Start = old.Start;
            Selection.End = old.End;
        }

        /// <summary>
        /// Convert selected text to lower case
        /// </summary>
        public virtual void LowerCase()
        {
            Range old = Selection.Clone();
            SelectedText = SelectedText.ToLower();
            Selection.Start = old.Start;
            Selection.End = old.End;
        }

        /// <summary>
        /// Convert selected text to title case
        /// </summary>
        public virtual void TitleCase()
        {
            Range old = Selection.Clone();
            SelectedText = Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(SelectedText.ToLower());
            Selection.Start = old.Start;
            Selection.End = old.End;
        }

        /// <summary>
        /// Convert selected text to sentence case
        /// </summary>
        public virtual void SentenceCase()
        {
            Range old = Selection.Clone();
            var lowerCase = SelectedText.ToLower();
            var r = new Regex(@"(^\S)|[\.\?!:]\s+(\S)", RegexOptions.ExplicitCapture);
            SelectedText = r.Replace(lowerCase, s => s.Value.ToUpper());
            Selection.Start = old.Start;
            Selection.End = old.End;
        }

        /// <summary>
        /// Insert/remove comment prefix into selected lines
        /// </summary>
        public void CommentSelected()
        {
            CommentSelected(CommentPrefix);
        }

        /// <summary>
        /// Insert/remove comment prefix into selected lines
        /// </summary>
        public virtual void CommentSelected(string commentPrefix)
        {
            if (string.IsNullOrEmpty(commentPrefix))
                return;
            Selection.Normalize();
            bool isCommented = lines[Selection.Start.iLine].Text.TrimStart().StartsWith(commentPrefix);
            if (isCommented)
                RemoveLinePrefix(commentPrefix);
            else
                InsertLinePrefix(commentPrefix);
        }

        public void OnKeyPressing(KeyPressEventArgs args)
        {
            if (KeyPressing != null)
                KeyPressing(this, args);
        }

        private bool OnKeyPressing(char c)
        {
            if (findCharMode)
            {
                findCharMode = false;
                FindChar(c);
                return true;
            }

            var args = new KeyPressEventArgs(c);
            OnKeyPressing(args);
            return args.Handled;
        }

        public void OnKeyPressed(char c)
        {
            var args = new KeyPressEventArgs(c);
            if (KeyPressed != null)
                KeyPressed(this, args);
        }

        protected override bool ProcessMnemonic(char charCode)
        {
            if (middleClickScrollingActivated)
                return false;

            if (Focused)
                return ProcessKey(charCode, lastModifiers) || base.ProcessMnemonic(charCode);
            else
                return false;
        }

        const int WM_CHAR = 0x102;

        protected override bool ProcessKeyMessage(ref Message m)
        {
            if (m.Msg == WM_CHAR)
                ProcessMnemonic(Convert.ToChar(m.WParam.ToInt32()));

            return base.ProcessKeyMessage(ref m);
        }

        /// <summary>
        /// Process "real" keys (no control)
        /// </summary>
        public virtual bool ProcessKey(char c, Keys modifiers)
        {
            if (handledChar)
                return true;

            if (macrosManager != null)
                macrosManager.ProcessKey(c, modifiers);
            /*  !!!!
            if (c == ' ')
                return true;*/

            //backspace
            if (c == '\b' && (modifiers == Keys.None || modifiers == Keys.Shift || (modifiers & Keys.Alt) != 0))
            {
                if (ReadOnly || !Enabled)
                    return false;

                if (OnKeyPressing(c))
                    return true;

                if (Selection.ReadOnly)
                    return false;

                if (!Selection.IsEmpty)
                    ClearSelected();
                else if (!Selection.IsReadOnlyLeftChar()) //is not left char readonly?
                    InsertChar('\b');

                if (AutoIndentChars)
                    DoAutoIndentChars(Selection.Start.iLine);

                OnKeyPressed('\b');
                return true;
            }

            /* !!!!
            if (c == '\b' && (modifiers & Keys.Alt) != 0)
                return true;*/

            if (char.IsControl(c) && c != '\r' && c != '\t')
                return false;

            if (ReadOnly || !Enabled)
                return false;


            if (modifiers != Keys.None &&
                modifiers != Keys.Shift &&
                modifiers != (Keys.Control | Keys.Alt) && //ALT+CTRL is special chars (AltGr)
                modifiers != (Keys.Shift | Keys.Control | Keys.Alt) && //SHIFT + ALT + CTRL is special chars (AltGr)
                (modifiers != (Keys.Alt) || char.IsLetterOrDigit(c)) //may be ALT+LetterOrDigit is mnemonic code
            )
                return false; //do not process Ctrl+? and Alt+? keys

            char sourceC = c;
            if (OnKeyPressing(sourceC)) //KeyPress event processed key
                return true;

            //
            if (Selection.ReadOnly)
                return false;
            //
            if (c == '\r' && !AcceptsReturn)
                return false;

            //replace \r on \n
            if (c == '\r')
                c = '\n';
            //replace mode? select forward char
            if (IsReplaceMode)
            {
                Selection.GoRight(true);
                Selection.Inverse();
            }

            //insert char
            if (!Selection.ReadOnly)
            {
                if (!DoAutocompleteBrackets(c))
                    InsertChar(c);
            }

            //do autoindent
            if (c == '\n' || AutoIndentExistingLines)
                DoAutoIndentIfNeed();

            if (AutoIndentChars)
                DoAutoIndentChars(Selection.Start.iLine);

            DoCaretVisible();
            Invalidate();

            OnKeyPressed(sourceC);

            return true;
        }

        #region AutoIndentChars

        /// <summary>
        /// Enables AutoIndentChars mode
        /// </summary>
        [Description("Enables AutoIndentChars mode")]
        [DefaultValue(true)]
        public bool AutoIndentChars { get; set; }

        /// <summary>
        /// Regex patterns for AutoIndentChars (one regex per line)
        /// </summary>
        [Description("Regex patterns for AutoIndentChars (one regex per line)")]
        [Editor(
            "System.ComponentModel.Design.MultilineStringEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
            typeof(UITypeEditor))]
        [DefaultValue(@"^\s*[\w\.]+\s*(?<range>=)\s*(?<range>[^;]+);")]
        public string AutoIndentCharsPatterns { get; set; }

        /// <summary>
        /// Do AutoIndentChars
        /// </summary>
        public void DoAutoIndentChars(int iLine)
        {
            var patterns =
                AutoIndentCharsPatterns.Split(new char[] {'\r', '\n'}, StringSplitOptions.RemoveEmptyEntries);

            foreach (var pattern in patterns)
            {
                var m = Regex.Match(this[iLine].Text, pattern);
                if (m.Success)
                {
                    DoAutoIndentChars(iLine, new Regex(pattern));
                    break;
                }
            }
        }

        protected void DoAutoIndentChars(int iLine, Regex regex)
        {
            var oldSel = Selection.Clone();

            var captures = new SortedDictionary<int, CaptureCollection>();
            var texts = new SortedDictionary<int, string>();
            var maxCapturesCount = 0;

            var spaces = this[iLine].StartSpacesCount;

            for (var i = iLine; i >= 0; i--)
            {
                if (spaces != this[i].StartSpacesCount)
                    break;

                var text = this[i].Text;
                var m = regex.Match(text);
                if (m.Success)
                {
                    captures[i] = m.Groups["range"].Captures;
                    texts[i] = text;

                    if (captures[i].Count > maxCapturesCount)
                        maxCapturesCount = captures[i].Count;
                }
                else
                    break;
            }

            for (var i = iLine + 1; i < LinesCount; i++)
            {
                if (spaces != this[i].StartSpacesCount)
                    break;

                var text = this[i].Text;
                var m = regex.Match(text);
                if (m.Success)
                {
                    captures[i] = m.Groups["range"].Captures;
                    texts[i] = text;

                    if (captures[i].Count > maxCapturesCount)
                        maxCapturesCount = captures[i].Count;
                }
                else
                    break;
            }

            var changed = new Dictionary<int, bool>();
            var was = false;

            for (int iCapture = maxCapturesCount - 1; iCapture >= 0; iCapture--)
            {
                //find max dist
                var maxDist = 0;
                foreach (var i in captures.Keys)
                {
                    var caps = captures[i];
                    if (caps.Count <= iCapture)
                        continue;
                    var dist = 0;
                    var cap = caps[iCapture];

                    var index = cap.Index;

                    var text = texts[i];
                    while (index > 0 && text[index - 1] == ' ') index--;

                    if (iCapture == 0)
                        dist = index;
                    else
                        dist = index - caps[iCapture - 1].Index - 1;

                    if (dist > maxDist)
                        maxDist = dist;
                }

                //insert whitespaces
                foreach (var i in new List<int>(texts.Keys))
                {
                    if (captures[i].Count <= iCapture)
                        continue;

                    var dist = 0;
                    var cap = captures[i][iCapture];

                    if (iCapture == 0)
                        dist = cap.Index;
                    else
                        dist = cap.Index - captures[i][iCapture - 1].Index - 1;

                    var addSpaces = maxDist - dist + 1; //+1 because min space count is 1

                    if (addSpaces == 0)
                        continue;

                    if (oldSel.Start.iLine == i && oldSel.Start.iChar > cap.Index)
                        oldSel.Start = new Place(oldSel.Start.iChar + addSpaces, i);

                    if (addSpaces > 0)
                        texts[i] = texts[i].Insert(cap.Index, new string(' ', addSpaces));
                    else
                        texts[i] = texts[i].Remove(cap.Index + addSpaces, -addSpaces);

                    changed[i] = true;
                    was = true;
                }
            }

            //insert text
            if (was)
            {
                Selection.BeginUpdate();
                BeginAutoUndo();
                BeginUpdate();

                TextSource.Manager.ExecuteCommand(new SelectCommand(TextSource));

                foreach (var i in texts.Keys)
                    if (changed.ContainsKey(i))
                    {
                        Selection = new Range(this, 0, i, this[i].Count, i);
                        if (!Selection.ReadOnly)
                            InsertText(texts[i]);
                    }

                Selection = oldSel;

                EndUpdate();
                EndAutoUndo();
                Selection.EndUpdate();
            }
        }

        #endregion

        private bool DoAutocompleteBrackets(char c)
        {
            if (AutoCompleteBrackets)
            {
                if (!Selection.ColumnSelectionMode)
                    for (int i = 1; i < autoCompleteBracketsList.Length; i += 2)
                        if (c == autoCompleteBracketsList[i] && c == Selection.CharAfterStart)
                        {
                            Selection.GoRight();
                            return true;
                        }

                for (int i = 0; i < autoCompleteBracketsList.Length; i += 2)
                    if (c == autoCompleteBracketsList[i])
                    {
                        InsertBrackets(autoCompleteBracketsList[i], autoCompleteBracketsList[i + 1]);
                        return true;
                    }
            }

            return false;
        }

        private bool InsertBrackets(char left, char right)
        {
            if (Selection.ColumnSelectionMode)
            {
                var range = Selection.Clone();
                range.Normalize();
                Selection.BeginUpdate();
                BeginAutoUndo();
                Selection = new Range(this, range.Start.iChar, range.Start.iLine, range.Start.iChar, range.End.iLine)
                    {ColumnSelectionMode = true};
                InsertChar(left);
                Selection = new Range(this, range.End.iChar + 1, range.Start.iLine, range.End.iChar + 1,
                    range.End.iLine) {ColumnSelectionMode = true};
                InsertChar(right);
                if (range.IsEmpty)
                    Selection = new Range(this, range.End.iChar + 1, range.Start.iLine, range.End.iChar + 1,
                        range.End.iLine) {ColumnSelectionMode = true};
                EndAutoUndo();
                Selection.EndUpdate();
            }
            else if (Selection.IsEmpty)
            {
                InsertText(left + "" + right);
                Selection.GoLeft();
            }
            else
                InsertText(left + SelectedText + right);

            return true;
        }

        /// <summary>
        /// Finds given char after current caret position, moves the caret to found pos.
        /// </summary>
        /// <param name="c"></param>
        protected virtual void FindChar(char c)
        {
            if (c == '\r')
                c = '\n';

            var r = Selection.Clone();
            while (r.GoRight())
            {
                if (r.CharBeforeStart == c)
                {
                    Selection = r;
                    DoCaretVisible();
                    return;
                }
            }
        }

        public virtual void DoAutoIndentIfNeed()
        {
            if (Selection.ColumnSelectionMode)
                return;
            if (AutoIndent)
            {
                DoCaretVisible();
                int needSpaces = CalcAutoIndent(Selection.Start.iLine);
                if (this[Selection.Start.iLine].AutoIndentSpacesNeededCount != needSpaces)
                {
                    DoAutoIndent(Selection.Start.iLine);
                    this[Selection.Start.iLine].AutoIndentSpacesNeededCount = needSpaces;
                }
            }
        }

        private void RemoveSpacesAfterCaret()
        {
            if (!Selection.IsEmpty)
                return;
            Place end = Selection.Start;
            while (Selection.CharAfterStart == ' ')
                Selection.GoRight(true);
            ClearSelected();
        }

        /// <summary>
        /// Inserts autoindent's spaces in the line
        /// </summary>
        public virtual void DoAutoIndent(int iLine)
        {
            if (Selection.ColumnSelectionMode)
                return;
            Place oldStart = Selection.Start;
            //
            int needSpaces = CalcAutoIndent(iLine);
            //
            int spaces = lines[iLine].StartSpacesCount;
            int needToInsert = needSpaces - spaces;
            if (needToInsert < 0)
                needToInsert = -Math.Min(-needToInsert, spaces);
            //insert start spaces
            if (needToInsert == 0)
                return;
            Selection.Start = new Place(0, iLine);
            if (needToInsert > 0)
                InsertText(new String(' ', needToInsert));
            else
            {
                Selection.Start = new Place(0, iLine);
                Selection.End = new Place(-needToInsert, iLine);
                ClearSelected();
            }

            Selection.Start = new Place(Math.Min(lines[iLine].Count, Math.Max(0, oldStart.iChar + needToInsert)),
                iLine);
        }

        /// <summary>
        /// Returns needed start space count for the line
        /// </summary>
        public virtual int CalcAutoIndent(int iLine)
        {
            if (iLine < 0 || iLine >= LinesCount) return 0;


            EventHandler<AutoIndentEventArgs> calculator = AutoIndentNeeded;
            if (calculator == null)
                if (SyntaxHighlighter != null)
                    calculator = SyntaxHighlighter.AutoIndentNeeded;
                else
                    calculator = CalcAutoIndentShiftByCodeFolding;

            int needSpaces = 0;

            var stack = new Stack<AutoIndentEventArgs>();
            //calc indent for previous lines, find stable line
            int i;
            for (i = iLine - 1; i >= 0; i--)
            {
                var args = new AutoIndentEventArgs(i, lines[i].Text, i > 0 ? lines[i - 1].Text : "", TabLength, 0);
                calculator(this, args);
                stack.Push(args);
                if (args.Shift == 0 && args.AbsoluteIndentation == 0 && args.LineText.Trim() != "")
                    break;
            }

            int indent = lines[i >= 0 ? i : 0].StartSpacesCount;
            while (stack.Count != 0)
            {
                var arg = stack.Pop();
                if (arg.AbsoluteIndentation != 0)
                    indent = arg.AbsoluteIndentation + arg.ShiftNextLines;
                else
                    indent += arg.ShiftNextLines;
            }

            //clalc shift for current line
            var a = new AutoIndentEventArgs(iLine, lines[iLine].Text, iLine > 0 ? lines[iLine - 1].Text : "", TabLength,
                indent);
            calculator(this, a);
            needSpaces = a.AbsoluteIndentation + a.Shift;

            return needSpaces;
        }

        internal virtual void CalcAutoIndentShiftByCodeFolding(object sender, AutoIndentEventArgs args)
        {
            //inset TAB after start folding marker
            if (string.IsNullOrEmpty(lines[args.iLine].FoldingEndMarker) &&
                !string.IsNullOrEmpty(lines[args.iLine].FoldingStartMarker))
            {
                args.ShiftNextLines = TabLength;
                return;
            }

            //remove TAB before end folding marker
            if (!string.IsNullOrEmpty(lines[args.iLine].FoldingEndMarker) &&
                string.IsNullOrEmpty(lines[args.iLine].FoldingStartMarker))
            {
                args.Shift = -TabLength;
                args.ShiftNextLines = -TabLength;
                return;
            }
        }


        protected int GetMinStartSpacesCount(int fromLine, int toLine)
        {
            if (fromLine > toLine)
                return 0;

            int result = int.MaxValue;
            for (int i = fromLine; i <= toLine; i++)
            {
                int count = lines[i].StartSpacesCount;
                if (count < result)
                    result = count;
            }

            return result;
        }

        protected int GetMaxStartSpacesCount(int fromLine, int toLine)
        {
            if (fromLine > toLine)
                return 0;

            int result = 0;
            for (int i = fromLine; i <= toLine; i++)
            {
                int count = lines[i].StartSpacesCount;
                if (count > result)
                    result = count;
            }

            return result;
        }

        /// <summary>
        /// Undo last operation
        /// </summary>
        public virtual void Undo()
        {
            lines.Manager.Undo();
            DoCaretVisible();
            Invalidate();
        }

        /// <summary>
        /// Redo
        /// </summary>
        public virtual void Redo()
        {
            lines.Manager.Redo();
            DoCaretVisible();
            Invalidate();
        }

        protected override bool IsInputKey(Keys keyData)
        {
            if (keyData == Keys.Tab && !AcceptsTab)
                return false;
            if (keyData == Keys.Enter && !AcceptsReturn)
                return false;

            if ((keyData & Keys.Alt) == Keys.None)
            {
                Keys keys = keyData & Keys.KeyCode;
                if (keys == Keys.Return)
                    return true;
            }

            if ((keyData & Keys.Alt) != Keys.Alt)
            {
                switch ((keyData & Keys.KeyCode))
                {
                    case Keys.Prior:
                    case Keys.Next:
                    case Keys.End:
                    case Keys.Home:
                    case Keys.Left:
                    case Keys.Right:
                    case Keys.Up:
                    case Keys.Down:
                        return true;

                    case Keys.Escape:
                        return false;

                    case Keys.Tab:
                        return (keyData & Keys.Control) == Keys.None;
                }
            }

            return base.IsInputKey(keyData);
        }

     

        protected override void OnPaintBackground(PaintEventArgs e)
        {
            if (BackBrush == null)
                base.OnPaintBackground(e);
            else
                e.Graphics.FillRectangle(BackBrush, ClientRectangle);
        }

        /// <summary>
        /// Draws text to given Graphics
        /// </summary>
        /// <param name="gr"></param>
        /// <param name="start">Start place of drawing text</param>
        /// <param name="size">Size of drawing</param>
        public void DrawText(Graphics gr, Place start, Size size)
        {
            if (needRecalc)
                Recalc();

            if (needRecalcFoldingLines)
                RecalcFoldingLines();

            var startPoint = PlaceToPoint(start);
            var startY = startPoint.Y + VerticalScroll.Value;
            var startX = startPoint.X + HorizontalScroll.Value - LeftIndent - Paddings.Left;
            int firstChar = start.iChar;
            int lastChar = (startX + size.Width) / CharWidth;

            var startLine = start.iLine;
            //draw text
            for (int iLine = startLine; iLine < lines.Count; iLine++)
            {
                Line line = lines[iLine];
                LineInfo lineInfo = LineInfos[iLine];
                //
                if (lineInfo.startY > startY + size.Height)
                    break;
                if (lineInfo.startY + lineInfo.WordWrapStringsCount * CharHeight < startY)
                    continue;
                if (lineInfo.VisibleState == VisibleState.Hidden)
                    continue;

                int y = lineInfo.startY - startY;
                //
                gr.SmoothingMode = SmoothingMode.None;
                //draw line background
                if (lineInfo.VisibleState == VisibleState.Visible)
                    if (line.BackgroundBrush != null)
                        gr.FillRectangle(line.BackgroundBrush,
                            new Rectangle(0, y, size.Width, CharHeight * lineInfo.WordWrapStringsCount));
                //
                gr.SmoothingMode = SmoothingMode.AntiAlias;

                //draw wordwrap strings of line
                for (int iWordWrapLine = 0; iWordWrapLine < lineInfo.WordWrapStringsCount; iWordWrapLine++)
                {
                    y = lineInfo.startY + iWordWrapLine * CharHeight - startY;
                    //indent 
                    var indent = iWordWrapLine == 0 ? 0 : lineInfo.wordWrapIndent * CharWidth;
                    //draw chars
                    DrawLineChars(gr, firstChar, lastChar, iLine, iWordWrapLine, -startX + indent, y);
                }
            }
        }

        /// <summary>
        /// Draw control
        /// </summary>
        protected override void OnPaint(PaintEventArgs e)
        {
            if (needRecalc)
                Recalc();

            if (needRecalcFoldingLines)
                RecalcFoldingLines();
#if debug
            var sw = Stopwatch.StartNew();
#endif
            visibleMarkers.Clear();
            e.Graphics.SmoothingMode = SmoothingMode.None;
            //
            var servicePen = new Pen(ServiceLinesColor);
            Brush changedLineBrush = new SolidBrush(ChangedLineColor);
            Brush indentBrush = new SolidBrush(IndentBackColor);
            Brush paddingBrush = new SolidBrush(PaddingBackColor);
            Brush currentLineBrush =
                new SolidBrush(Color.FromArgb(CurrentLineColor.A == 255 ? 50 : CurrentLineColor.A, CurrentLineColor));
            //draw padding area
            var textAreaRect = TextAreaRect;
            //top
            e.Graphics.FillRectangle(paddingBrush, 0, -VerticalScroll.Value, ClientSize.Width,
                Math.Max(0, Paddings.Top - 1));
            //bottom
            e.Graphics.FillRectangle(paddingBrush, 0, textAreaRect.Bottom, ClientSize.Width, ClientSize.Height);
            //right
            e.Graphics.FillRectangle(paddingBrush, textAreaRect.Right, 0, ClientSize.Width, ClientSize.Height);
            //left
            e.Graphics.FillRectangle(paddingBrush, LeftIndentLine, 0, LeftIndent - LeftIndentLine - 1,
                ClientSize.Height);
            if (HorizontalScroll.Value <= Paddings.Left)
                e.Graphics.FillRectangle(paddingBrush, LeftIndent - HorizontalScroll.Value - 2, 0,
                    Math.Max(0, Paddings.Left - 1), ClientSize.Height);
            //
            int leftTextIndent = Math.Max(LeftIndent, LeftIndent + Paddings.Left - HorizontalScroll.Value);
            int textWidth = textAreaRect.Width;
            //draw indent area
            e.Graphics.FillRectangle(indentBrush, 0, 0, LeftIndentLine, ClientSize.Height);
            if (LeftIndent > minLeftIndent)
                e.Graphics.DrawLine(servicePen, LeftIndentLine, 0, LeftIndentLine, ClientSize.Height);
            //draw preferred line width
            if (PreferredLineWidth > 0)
                e.Graphics.DrawLine(servicePen,
                    new Point(
                        LeftIndent + Paddings.Left + PreferredLineWidth * CharWidth -
                        HorizontalScroll.Value + 1, textAreaRect.Top + 1),
                    new Point(
                        LeftIndent + Paddings.Left + PreferredLineWidth * CharWidth -
                        HorizontalScroll.Value + 1, textAreaRect.Bottom - 1));

            //draw text area border
            DrawTextAreaBorder(e.Graphics);
            //
            int firstChar = (Math.Max(0, HorizontalScroll.Value - Paddings.Left)) / CharWidth;
            int lastChar = (HorizontalScroll.Value + ClientSize.Width) / CharWidth;
            //
            var x = LeftIndent + Paddings.Left - HorizontalScroll.Value;
            if (x < LeftIndent)
                firstChar++;
            //create dictionary of bookmarks
            var bookmarksByLineIndex = new Dictionary<int, Bookmark>();
            foreach (Bookmark item in bookmarks)
                bookmarksByLineIndex[item.LineIndex] = item;
            //
            int startLine = YtoLineIndex(VerticalScroll.Value);
            int iLine;

            e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;

            //draw text
            for (iLine = startLine; iLine < lines.Count; iLine++)
            {
                Line line = lines[iLine];
                LineInfo lineInfo = LineInfos[iLine];
                //
                if (lineInfo.startY > VerticalScroll.Value + ClientSize.Height)
                    break;
                if (lineInfo.startY + lineInfo.WordWrapStringsCount * CharHeight < VerticalScroll.Value)
                    continue;
                if (lineInfo.VisibleState == VisibleState.Hidden)
                    continue;

                int y = lineInfo.startY - VerticalScroll.Value;
                //
                e.Graphics.SmoothingMode = SmoothingMode.None;
                //draw line background
                if (lineInfo.VisibleState == VisibleState.Visible)
                    if (line.BackgroundBrush != null)
                        e.Graphics.FillRectangle(line.BackgroundBrush,
                            new Rectangle(textAreaRect.Left, y, textAreaRect.Width,
                                CharHeight * lineInfo.WordWrapStringsCount));
                //draw current line background
                if (CurrentLineColor != Color.Transparent && iLine == Selection.Start.iLine)
                    if (Selection.IsEmpty)
                        e.Graphics.FillRectangle(currentLineBrush,
                            new Rectangle(textAreaRect.Left, y, textAreaRect.Width, CharHeight));
                //draw changed line marker
                if (ChangedLineColor != Color.Transparent && line.IsChanged)
                    e.Graphics.FillRectangle(changedLineBrush,
                        new RectangleF(-10, y, LeftIndent - minLeftIndent - 2 + 10, CharHeight + 1));
                //
                e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;
                //
                //draw bookmark
                if (bookmarksByLineIndex.ContainsKey(iLine))
                    bookmarksByLineIndex[iLine].Paint(e.Graphics,
                        new Rectangle(LeftIndent, y, Width,
                            CharHeight * lineInfo.WordWrapStringsCount));
                //OnPaintLine event
                if (lineInfo.VisibleState == VisibleState.Visible)
                    OnPaintLine(new PaintLineEventArgs(iLine,
                        new Rectangle(LeftIndent, y, Width,
                            CharHeight * lineInfo.WordWrapStringsCount),
                        e.Graphics, e.ClipRectangle));
                //draw line number
                if (ShowLineNumbers)
                    using (var lineNumberBrush = new SolidBrush(LineNumberColor))
                        e.Graphics.DrawString((iLine + lineNumberStartValue).ToString(), Font, lineNumberBrush,
                            new RectangleF(-10, y, LeftIndent - minLeftIndent - 2 + 10, CharHeight),
                            new StringFormat(StringFormatFlags.DirectionRightToLeft));
                //create markers
                if (lineInfo.VisibleState == VisibleState.StartOfHiddenBlock)
                    visibleMarkers.Add(new ExpandFoldingMarker(iLine,
                        new Rectangle(LeftIndentLine - 4, y + CharHeight / 2 - 3, 8, 8)));

                if (!string.IsNullOrEmpty(line.FoldingStartMarker) && lineInfo.VisibleState == VisibleState.Visible &&
                    string.IsNullOrEmpty(line.FoldingEndMarker))
                    visibleMarkers.Add(new CollapseFoldingMarker(iLine,
                        new Rectangle(LeftIndentLine - 4, y + CharHeight / 2 - 3, 8, 8)));

                if (lineInfo.VisibleState == VisibleState.Visible && !string.IsNullOrEmpty(line.FoldingEndMarker) &&
                    string.IsNullOrEmpty(line.FoldingStartMarker))
                    e.Graphics.DrawLine(servicePen, LeftIndentLine, y + CharHeight * lineInfo.WordWrapStringsCount - 1,
                        LeftIndentLine + 4, y + CharHeight * lineInfo.WordWrapStringsCount - 1);
                //draw wordwrap strings of line
                for (int iWordWrapLine = 0; iWordWrapLine < lineInfo.WordWrapStringsCount; iWordWrapLine++)
                {
                    y = lineInfo.startY + iWordWrapLine * CharHeight - VerticalScroll.Value;
                    //indent
                    var indent = iWordWrapLine == 0 ? 0 : lineInfo.wordWrapIndent * CharWidth;
                    //draw chars
                    DrawLineChars(e.Graphics, firstChar, lastChar, iLine, iWordWrapLine, x + indent, y);
                }
            }

            int endLine = iLine - 1;

            //draw folding lines
            if (ShowFoldingLines)
                DrawFoldingLines(e, startLine, endLine);

            //draw column selection
            if (Selection.ColumnSelectionMode)
                if (SelectionStyle.BackgroundBrush is SolidBrush)
                {
                    Color color = ((SolidBrush) SelectionStyle.BackgroundBrush).Color;
                    Point p1 = PlaceToPoint(Selection.Start);
                    Point p2 = PlaceToPoint(Selection.End);
                    using (var pen = new Pen(color))
                        e.Graphics.DrawRectangle(pen,
                            Rectangle.FromLTRB(Math.Min(p1.X, p2.X) - 1, Math.Min(p1.Y, p2.Y),
                                Math.Max(p1.X, p2.X),
                                Math.Max(p1.Y, p2.Y) + CharHeight));
                }

            //draw brackets highlighting
            if (BracketsStyle != null && leftBracketPosition != null && rightBracketPosition != null)
            {
                BracketsStyle.Draw(e.Graphics, PlaceToPoint(leftBracketPosition.Start), leftBracketPosition);
                BracketsStyle.Draw(e.Graphics, PlaceToPoint(rightBracketPosition.Start), rightBracketPosition);
            }

            if (BracketsStyle2 != null && leftBracketPosition2 != null && rightBracketPosition2 != null)
            {
                BracketsStyle2.Draw(e.Graphics, PlaceToPoint(leftBracketPosition2.Start), leftBracketPosition2);
                BracketsStyle2.Draw(e.Graphics, PlaceToPoint(rightBracketPosition2.Start), rightBracketPosition2);
            }

            //
            e.Graphics.SmoothingMode = SmoothingMode.None;
            //draw folding indicator
            if ((startFoldingLine >= 0 || endFoldingLine >= 0) && Selection.Start == Selection.End)
                if (endFoldingLine < LineInfos.Count)
                {
                    //folding indicator
                    int startFoldingY = (startFoldingLine >= 0 ? LineInfos[startFoldingLine].startY : 0) -
                                        VerticalScroll.Value + CharHeight / 2;
                    int endFoldingY = (endFoldingLine >= 0
                                          ? LineInfos[endFoldingLine].startY +
                                            (LineInfos[endFoldingLine].WordWrapStringsCount - 1) * CharHeight
                                          : TextHeight + CharHeight) - VerticalScroll.Value + CharHeight;

                    using (var indicatorPen = new Pen(Color.FromArgb(100, FoldingIndicatorColor), 4))
                        e.Graphics.DrawLine(indicatorPen, LeftIndent - 5, startFoldingY, LeftIndent - 5, endFoldingY);
                }

            //draw hint's brackets
            PaintHintBrackets(e.Graphics);
            //draw markers
            DrawMarkers(e, servicePen);
            //draw caret
            Point car = PlaceToPoint(Selection.Start);
            var caretHeight = CharHeight - lineInterval;
            car.Offset(0, lineInterval / 2);

            if ((Focused || IsDragDrop || ShowCaretWhenInactive) && car.X >= LeftIndent && CaretVisible)
            {
                int carWidth = (IsReplaceMode || WideCaret) ? CharWidth : 1;
                if (WideCaret)
                {
                    using (var brush = new SolidBrush(CaretColor))
                        e.Graphics.FillRectangle(brush, car.X, car.Y, carWidth, caretHeight + 1);
                }
                else
                    using (var pen = new Pen(CaretColor))
                        e.Graphics.DrawLine(pen, car.X, car.Y, car.X, car.Y + caretHeight);

                var caretRect = new Rectangle(HorizontalScroll.Value + car.X, VerticalScroll.Value + car.Y, carWidth,
                    caretHeight + 1);

                if (CaretBlinking)
                    if (prevCaretRect != caretRect || !ShowScrollBars)
                    {
                        NativeMethodWrapper.CreateCaret(Handle, 0, carWidth, caretHeight + 1);
                        NativeMethodWrapper.SetCaretPos(car.X, car.Y);
                        NativeMethodWrapper.ShowCaret(Handle);
                    }

                prevCaretRect = caretRect;
            }
            else
            {
                NativeMethodWrapper.HideCaret(Handle);
                prevCaretRect = Rectangle.Empty;
            }

            //draw disabled mask
            if (!Enabled)
                using (var brush = new SolidBrush(DisabledColor))
                    e.Graphics.FillRectangle(brush, ClientRectangle);

            if (MacrosManager.IsRecording)
                DrawRecordingHint(e.Graphics);

            if (middleClickScrollingActivated)
                DrawMiddleClickScrolling(e.Graphics);

            //dispose resources
            servicePen.Dispose();
            changedLineBrush.Dispose();
            indentBrush.Dispose();
            currentLineBrush.Dispose();
            paddingBrush.Dispose();
            //
#if debug
            sw.Stop();
            Console.WriteLine("OnPaint: "+ sw.ElapsedMilliseconds);
#endif
            //
            base.OnPaint(e);
        }

        private void DrawMarkers(PaintEventArgs e, Pen servicePen)
        {
            foreach (VisualMarker m in visibleMarkers)
            {
                if (m is CollapseFoldingMarker)
                    using (var bk = new SolidBrush(ServiceColors.CollapseMarkerBackColor))
                    using (var fore = new Pen(ServiceColors.CollapseMarkerForeColor))
                    using (var border = new Pen(ServiceColors.CollapseMarkerBorderColor))
                        (m as CollapseFoldingMarker).Draw(e.Graphics, border, bk, fore);
                else if (m is ExpandFoldingMarker)
                    using (var bk = new SolidBrush(ServiceColors.ExpandMarkerBackColor))
                    using (var fore = new Pen(ServiceColors.ExpandMarkerForeColor))
                    using (var border = new Pen(ServiceColors.ExpandMarkerBorderColor))
                        (m as ExpandFoldingMarker).Draw(e.Graphics, border, bk, fore);
                else
                    m.Draw(e.Graphics, servicePen);
            }
        }

        private Rectangle prevCaretRect;

        private void DrawRecordingHint(Graphics graphics)
        {
            const int w = 75;
            const int h = 13;
            var rect = new Rectangle(ClientRectangle.Right - w, ClientRectangle.Bottom - h, w, h);
            var iconRect = new Rectangle(-h / 2 + 3, -h / 2 + 3, h - 7, h - 7);
            var state = graphics.Save();
            graphics.SmoothingMode = SmoothingMode.HighQuality;
            graphics.TranslateTransform(rect.Left + h / 2, rect.Top + h / 2);
            var ts = new TimeSpan(DateTime.Now.Ticks);
            graphics.RotateTransform(180 * (DateTime.Now.Millisecond / 1000f));
            using (var pen = new Pen(Color.Red, 2))
            {
                graphics.DrawArc(pen, iconRect, 0, 90);
                graphics.DrawArc(pen, iconRect, 180, 90);
            }

            graphics.DrawEllipse(Pens.Red, iconRect);
            graphics.Restore(state);
            using (var font = new Font(FontFamily.GenericSansSerif, 8f))
                graphics.DrawString("Recording...", font, Brushes.Red, new PointF(rect.Left + h, rect.Top));
            System.Threading.Timer tm = null;
            tm = new System.Threading.Timer(
                (o) =>
                {
                    Invalidate(rect);
                    tm.Dispose();
                }, null, 200, System.Threading.Timeout.Infinite);
        }

        private void DrawTextAreaBorder(Graphics graphics)
        {
            if (TextAreaBorder == TextAreaBorderType.None)
                return;

            var rect = TextAreaRect;

            if (TextAreaBorder == TextAreaBorderType.Shadow)
            {
                const int shadowSize = 4;
                var rBottom = new Rectangle(rect.Left + shadowSize, rect.Bottom, rect.Width - shadowSize, shadowSize);
                var rCorner = new Rectangle(rect.Right, rect.Bottom, shadowSize, shadowSize);
                var rRight = new Rectangle(rect.Right, rect.Top + shadowSize, shadowSize, rect.Height - shadowSize);

                using (var brush = new SolidBrush(Color.FromArgb(80, TextAreaBorderColor)))
                {
                    graphics.FillRectangle(brush, rBottom);
                    graphics.FillRectangle(brush, rRight);
                    graphics.FillRectangle(brush, rCorner);
                }
            }

            using (Pen pen = new Pen(TextAreaBorderColor))
                graphics.DrawRectangle(pen, rect);
        }

        private void PaintHintBrackets(Graphics gr)
        {
            foreach (Hint hint in hints)
            {
                Range r = hint.Range.Clone();
                r.Normalize();
                Point p1 = PlaceToPoint(r.Start);
                Point p2 = PlaceToPoint(r.End);
                if (GetVisibleState(r.Start.iLine) != VisibleState.Visible ||
                    GetVisibleState(r.End.iLine) != VisibleState.Visible)
                    continue;

                using (var pen = new Pen(hint.BorderColor))
                {
                    pen.DashStyle = DashStyle.Dash;
                    if (r.IsEmpty)
                    {
                        p1.Offset(1, -1);
                        gr.DrawLines(pen, new[] {p1, new Point(p1.X, p1.Y + charHeight + 2)});
                    }
                    else
                    {
                        p1.Offset(-1, -1);
                        p2.Offset(1, -1);
                        gr.DrawLines(pen,
                            new[]
                            {
                                new Point(p1.X + CharWidth / 2, p1.Y), p1,
                                new Point(p1.X, p1.Y + charHeight + 2),
                                new Point(p1.X + CharWidth / 2, p1.Y + charHeight + 2)
                            });
                        gr.DrawLines(pen,
                            new[]
                            {
                                new Point(p2.X - CharWidth / 2, p2.Y), p2,
                                new Point(p2.X, p2.Y + charHeight + 2),
                                new Point(p2.X - CharWidth / 2, p2.Y + charHeight + 2)
                            });
                    }
                }
            }
        }

        protected virtual void DrawFoldingLines(PaintEventArgs e, int startLine, int endLine)
        {
            e.Graphics.SmoothingMode = SmoothingMode.None;
            using (var pen = new Pen(Color.FromArgb(200, ServiceLinesColor)) {DashStyle = DashStyle.Dot})
                foreach (var iLine in foldingPairs)
                    if (iLine.Key < endLine && iLine.Value > startLine)
                    {
                        Line line = lines[iLine.Key];
                        int y = LineInfos[iLine.Key].startY - VerticalScroll.Value + CharHeight;
                        y += y % 2;

                        int y2;

                        if (iLine.Value >= LinesCount)
                            y2 = LineInfos[LinesCount - 1].startY + CharHeight - VerticalScroll.Value;
                        else if (LineInfos[iLine.Value].VisibleState == VisibleState.Visible)
                        {
                            int d = 0;
                            int spaceCount = line.StartSpacesCount;
                            if (lines[iLine.Value].Count <= spaceCount || lines[iLine.Value][spaceCount].c == ' ')
                                d = CharHeight;
                            y2 = LineInfos[iLine.Value].startY - VerticalScroll.Value + d;
                        }
                        else
                            continue;

                        int x = LeftIndent + Paddings.Left + line.StartSpacesCount * CharWidth - HorizontalScroll.Value;
                        if (x >= LeftIndent + Paddings.Left)
                            e.Graphics.DrawLine(pen, x, y >= 0 ? y : 0, x,
                                y2 < ClientSize.Height ? y2 : ClientSize.Height);
                    }
        }

        private void DrawLineChars(Graphics gr, int firstChar, int lastChar, int iLine, int iWordWrapLine, int startX,
            int y)
        {
            Line line = lines[iLine];
            LineInfo lineInfo = LineInfos[iLine];
            int from = lineInfo.GetWordWrapStringStartPosition(iWordWrapLine);
            int to = lineInfo.GetWordWrapStringFinishPosition(iWordWrapLine, line);

            lastChar = Math.Min(to - from, lastChar);

            gr.SmoothingMode = SmoothingMode.AntiAlias;

            //folded block ?
            if (lineInfo.VisibleState == VisibleState.StartOfHiddenBlock)
            {
                //rendering by FoldedBlockStyle
                FoldedBlockStyle.Draw(gr, new Point(startX + firstChar * CharWidth, y),
                    new Range(this, from + firstChar, iLine, from + lastChar + 1, iLine));
            }
            else
            {
                //render by custom styles
                StyleIndex currentStyleIndex = StyleIndex.None;
                int iLastFlushedChar = firstChar - 1;

                for (int iChar = firstChar; iChar <= lastChar; iChar++)
                {
                    StyleIndex style = line[from + iChar].style;
                    if (currentStyleIndex != style)
                    {
                        FlushRendering(gr, currentStyleIndex,
                            new Point(startX + (iLastFlushedChar + 1) * CharWidth, y),
                            new Range(this, from + iLastFlushedChar + 1, iLine, from + iChar, iLine));
                        iLastFlushedChar = iChar - 1;
                        currentStyleIndex = style;
                    }
                }

                FlushRendering(gr, currentStyleIndex, new Point(startX + (iLastFlushedChar + 1) * CharWidth, y),
                    new Range(this, from + iLastFlushedChar + 1, iLine, from + lastChar + 1, iLine));
            }

            //draw selection
            if (SelectionHighlightingForLineBreaksEnabled && iWordWrapLine == lineInfo.WordWrapStringsCount - 1)
                lastChar++; //draw selection for CR
            if (!Selection.IsEmpty && lastChar >= firstChar)
            {
                gr.SmoothingMode = SmoothingMode.None;
                var textRange = new Range(this, from + firstChar, iLine, from + lastChar + 1, iLine);
                textRange = Selection.GetIntersectionWith(textRange);
                if (textRange != null && SelectionStyle != null)
                {
                    SelectionStyle.Draw(gr, new Point(startX + (textRange.Start.iChar - from) * CharWidth, 1 + y),
                        textRange);
                }
            }
        }

        private void FlushRendering(Graphics gr, StyleIndex styleIndex, Point pos, Range range)
        {
            if (range.End > range.Start)
            {
                int mask = 1;
                bool hasTextStyle = false;
                for (int i = 0; i < Styles.Length; i++)
                {
                    if (Styles[i] != null && ((int) styleIndex & mask) != 0)
                    {
                        Style style = Styles[i];
                        bool isTextStyle = style is TextStyle;
                        if (!hasTextStyle || !isTextStyle || AllowSeveralTextStyleDrawing)
                            //cancelling secondary rendering by TextStyle
                            style.Draw(gr, pos, range); //rendering
                        hasTextStyle |= isTextStyle;
                    }

                    mask = mask << 1;
                }

                //draw by default renderer
                if (!hasTextStyle)
                    DefaultStyle.Draw(gr, pos, range);
            }
        }

        protected override void OnEnter(EventArgs e)
        {
            base.OnEnter(e);
            mouseIsDrag = false;
            mouseIsDragDrop = false;
            draggedRange = null;
        }

        protected override void OnMouseUp(MouseEventArgs e)
        {
            base.OnMouseUp(e);
            isLineSelect = false;

            if (e.Button == System.Windows.Forms.MouseButtons.Left)
            {
                if (mouseIsDragDrop)
                    OnMouseClickText(e);
            }
        }

        protected override void OnMouseDown(MouseEventArgs e)
        {
            base.OnMouseDown(e);

            if (middleClickScrollingActivated)
            {
                DeactivateMiddleClickScrollingMode();
                mouseIsDrag = false;
                if (e.Button == System.Windows.Forms.MouseButtons.Middle)
                    RestoreScrollsAfterMiddleClickScrollingMode();
                return;
            }

            MacrosManager.IsRecording = false;

            Select();
            ActiveControl = null;

            if (e.Button == MouseButtons.Left)
            {
                VisualMarker marker = FindVisualMarkerForPoint(e.Location);
                //click on marker
                if (marker != null)
                {
                    mouseIsDrag = false;
                    mouseIsDragDrop = false;
                    draggedRange = null;
                    OnMarkerClick(e, marker);
                    return;
                }

                mouseIsDrag = true;
                mouseIsDragDrop = false;
                draggedRange = null;
                isLineSelect = (e.Location.X < LeftIndentLine);

                if (!isLineSelect)
                {
                    var p = PointToPlace(e.Location);

                    if (e.Clicks == 2)
                    {
                        mouseIsDrag = false;
                        mouseIsDragDrop = false;
                        draggedRange = null;

                        SelectWord(p);
                        return;
                    }

                    if (Selection.IsEmpty || !Selection.Contains(p) || this[p.iLine].Count <= p.iChar || ReadOnly)
                        OnMouseClickText(e);
                    else
                    {
                        mouseIsDragDrop = true;
                        mouseIsDrag = false;
                    }
                }
                else
                {
                    CheckAndChangeSelectionType();

                    Selection.BeginUpdate();
                    //select whole line
                    int iLine = PointToPlaceSimple(e.Location).iLine;
                    lineSelectFrom = iLine;
                    Selection.Start = new Place(0, iLine);
                    Selection.End = new Place(GetLineLength(iLine), iLine);
                    Selection.EndUpdate();
                    Invalidate();
                }
            }
            else if (e.Button == MouseButtons.Middle)
            {
                ActivateMiddleClickScrollingMode(e);
            }
        }

        private void OnMouseClickText(MouseEventArgs e)
        {
            //click on text
            Place oldEnd = Selection.End;
            Selection.BeginUpdate();

            if (Selection.ColumnSelectionMode)
            {
                Selection.Start = PointToPlaceSimple(e.Location);
                Selection.ColumnSelectionMode = true;
            }
            else
            {
                if (VirtualSpace)
                    Selection.Start = PointToPlaceSimple(e.Location);
                else
                    Selection.Start = PointToPlace(e.Location);
            }

            if ((lastModifiers & Keys.Shift) != 0)
                Selection.End = oldEnd;

            CheckAndChangeSelectionType();

            Selection.EndUpdate();
            Invalidate();
            return;
        }

        protected virtual void CheckAndChangeSelectionType()
        {
            //change selection type to ColumnSelectionMode
            if ((ModifierKeys & Keys.Alt) != 0 && !WordWrap)
            {
                Selection.ColumnSelectionMode = true;
            }
            else
                //change selection type to Range
            {
                Selection.ColumnSelectionMode = false;
            }
        }

        protected override void OnMouseWheel(MouseEventArgs e)
        {
            Invalidate();

            if (lastModifiers == Keys.Control)
            {
                ChangeFontSize(2 * Math.Sign(e.Delta));
                ((HandledMouseEventArgs) e).Handled = true;
            }
            else if (VerticalScroll.Visible || !ShowScrollBars)
            {
                //base.OnMouseWheel(e);

                // Determine scoll offset
                int mouseWheelScrollLinesSetting = GetControlPanelWheelScrollLinesValue();

                DoScrollVertical(mouseWheelScrollLinesSetting, e.Delta);

                ((HandledMouseEventArgs) e).Handled = true;
            }

            DeactivateMiddleClickScrollingMode();
        }

        private void DoScrollVertical(int countLines, int direction)
        {
            if (VerticalScroll.Visible || !ShowScrollBars)
            {
                int numberOfVisibleLines = ClientSize.Height / CharHeight;

                int offset;
                if ((countLines == -1) || (countLines > numberOfVisibleLines))
                    offset = CharHeight * numberOfVisibleLines;
                else
                    offset = CharHeight * countLines;

                var newScrollPos = VerticalScroll.Value - Math.Sign(direction) * offset;

                var ea =
                    new ScrollEventArgs(direction > 0 ? ScrollEventType.SmallDecrement : ScrollEventType.SmallIncrement,
                        VerticalScroll.Value,
                        newScrollPos,
                        ScrollOrientation.VerticalScroll);

                OnScroll(ea);
            }
        }

        /// <summary>
        /// Gets the value for the system control panel mouse wheel scroll settings.
        /// The value returns the number of lines that shall be scolled if the user turns the mouse wheet one step.
        /// </summary>
        /// <remarks>
        /// This methods gets the "WheelScrollLines" value our from the registry key "HKEY_CURRENT_USER\Control Panel\Desktop".
        /// If the value of this option is 0, the screen will not scroll when the mouse wheel is turned.
        /// If the value of this option is -1 or is greater than the number of lines visible in the window,
        /// the screen will scroll up or down by one page.
        /// </remarks>
        /// <returns>
        /// Number of lines to scrol l when the mouse wheel is turned
        /// </returns>
        private static int GetControlPanelWheelScrollLinesValue()
        {
            try
            {
                using (RegistryKey key = Registry.CurrentUser.OpenSubKey(@"Control Panel\Desktop", false))
                {
                    return Convert.ToInt32(key.GetValue("WheelScrollLines"));
                }
            }
            catch
            {
                // Use default value
                return 1;
            }
        }


        public void ChangeFontSize(int step)
        {
            var points = Font.SizeInPoints;
            using (var gr = Graphics.FromHwnd(Handle))
            {
                var dpi = gr.DpiY;
                var newPoints = points + step * 72f / dpi;
                if (newPoints < 1f) return;
                var k = newPoints / originalFont.SizeInPoints;
                Zoom = (int) (100 * k);
            }
        }

        /// <summary>
        /// Zooming (in percentages)
        /// </summary>
        [Browsable(false)]
        public int Zoom
        {
            get { return zoom; }
            set
            {
                zoom = value;
                DoZoom(zoom / 100f);
                OnZoomChanged();
            }
        }

        protected virtual void OnZoomChanged()
        {
            if (ZoomChanged != null)
                ZoomChanged(this, EventArgs.Empty);
        }

        private void DoZoom(float koeff)
        {
            //remmber first displayed line
            var iLine = YtoLineIndex(VerticalScroll.Value);
            //
            var points = originalFont.SizeInPoints;
            points *= koeff;

            if (points < 1f || points > 300f) return;

            var oldFont = Font;
            SetFont(new Font(Font.FontFamily, points, Font.Style, GraphicsUnit.Point));
            oldFont.Dispose();

            NeedRecalc(true);

            //restore first displayed line
            if (iLine < LinesCount)
                VerticalScroll.Value = Math.Min(VerticalScroll.Maximum, LineInfos[iLine].startY - Paddings.Top);
            UpdateScrollbars();
            //
            Invalidate();
            OnVisibleRangeChanged();
        }

        protected override void OnMouseLeave(EventArgs e)
        {
            base.OnMouseLeave(e);

            CancelToolTip();
        }

        protected Range draggedRange;

        protected override void OnMouseMove(MouseEventArgs e)
        {
            base.OnMouseMove(e);

            if (middleClickScrollingActivated)
                return;

            if (lastMouseCoord != e.Location)
            {
                //restart tooltip timer
                CancelToolTip();
                timer3.Start();
            }

            lastMouseCoord = e.Location;

            if (e.Button == MouseButtons.Left && mouseIsDragDrop)
            {
                draggedRange = Selection.Clone();
                DoDragDrop(SelectedText, DragDropEffects.Copy);
                draggedRange = null;
                return;
            }

            if (e.Button == MouseButtons.Left && mouseIsDrag)
            {
                Place place;
                if (Selection.ColumnSelectionMode || VirtualSpace)
                    place = PointToPlaceSimple(e.Location);
                else
                    place = PointToPlace(e.Location);

                if (isLineSelect)
                {
                    Selection.BeginUpdate();

                    int iLine = place.iLine;
                    if (iLine < lineSelectFrom)
                    {
                        Selection.Start = new Place(0, iLine);
                        Selection.End = new Place(GetLineLength(lineSelectFrom), lineSelectFrom);
                    }
                    else
                    {
                        Selection.Start = new Place(GetLineLength(iLine), iLine);
                        Selection.End = new Place(0, lineSelectFrom);
                    }

                    Selection.EndUpdate();
                    DoCaretVisible();
                    HorizontalScroll.Value = 0;
                    UpdateScrollbars();
                    Invalidate();
                }
                else if (place != Selection.Start)
                {
                    Place oldEnd = Selection.End;
                    Selection.BeginUpdate();
                    if (Selection.ColumnSelectionMode)
                    {
                        Selection.Start = place;
                        Selection.ColumnSelectionMode = true;
                    }
                    else
                        Selection.Start = place;

                    Selection.End = oldEnd;
                    Selection.EndUpdate();
                    DoCaretVisible();
                    Invalidate();
                    return;
                }
            }

            VisualMarker marker = FindVisualMarkerForPoint(e.Location);
            if (marker != null)
                base.Cursor = marker.Cursor;
            else
            {
                if (e.Location.X < LeftIndentLine || isLineSelect)
                    base.Cursor = Cursors.Arrow;
                else
                    base.Cursor = defaultCursor;
            }
        }

        private void CancelToolTip()
        {
            timer3.Stop();
            if (ToolTip != null && !string.IsNullOrEmpty(ToolTip.GetToolTip(this)))
            {
                ToolTip.Hide(this);
                ToolTip.SetToolTip(this, null);
            }
        }

        protected override void OnMouseDoubleClick(MouseEventArgs e)
        {
            base.OnMouseDoubleClick(e);

            var m = FindVisualMarkerForPoint(e.Location);
            if (m != null)
                OnMarkerDoubleClick(m);
        }

        private void SelectWord(Place p)
        {
            int fromX = p.iChar;
            int toX = p.iChar;

            for (int i = p.iChar; i < lines[p.iLine].Count; i++)
            {
                char c = lines[p.iLine][i].c;
                if (char.IsLetterOrDigit(c) || c == '_')
                    toX = i + 1;
                else
                    break;
            }

            for (int i = p.iChar - 1; i >= 0; i--)
            {
                char c = lines[p.iLine][i].c;
                if (char.IsLetterOrDigit(c) || c == '_')
                    fromX = i;
                else
                    break;
            }

            Selection = new Range(this, toX, p.iLine, fromX, p.iLine);
        }

        private int YtoLineIndex(int y)
        {
            int i = LineInfos.BinarySearch(new LineInfo(-10), new LineYComparer(y));
            i = i < 0 ? -i - 2 : i;
            if (i < 0) return 0;
            if (i > lines.Count - 1) return lines.Count - 1;
            return i;
        }

        /// <summary>
        /// Gets nearest line and char position from coordinates
        /// </summary>
        /// <param name="point">Point</param>
        /// <returns>Line and char position</returns>
        public Place PointToPlace(Point point)
        {
#if debug
            var sw = Stopwatch.StartNew();
#endif
            point.Offset(HorizontalScroll.Value, VerticalScroll.Value);
            point.Offset(-LeftIndent - Paddings.Left, 0);
            int iLine = YtoLineIndex(point.Y);
            if (iLine < 0)
                return Place.Empty;

            int y = 0;

            for (; iLine < lines.Count; iLine++)
            {
                y = LineInfos[iLine].startY + LineInfos[iLine].WordWrapStringsCount * CharHeight;
                if (y > point.Y && LineInfos[iLine].VisibleState == VisibleState.Visible)
                    break;
            }

            if (iLine >= lines.Count)
                iLine = lines.Count - 1;
            if (LineInfos[iLine].VisibleState != VisibleState.Visible)
                iLine = FindPrevVisibleLine(iLine);
            //
            int iWordWrapLine = LineInfos[iLine].WordWrapStringsCount;
            do
            {
                iWordWrapLine--;
                y -= CharHeight;
            } while (y > point.Y);

            if (iWordWrapLine < 0) iWordWrapLine = 0;
            //
            int start = LineInfos[iLine].GetWordWrapStringStartPosition(iWordWrapLine);
            int finish = LineInfos[iLine].GetWordWrapStringFinishPosition(iWordWrapLine, lines[iLine]);
            var x = (int) Math.Round((float) point.X / CharWidth);
            if (iWordWrapLine > 0)
                x -= LineInfos[iLine].wordWrapIndent;

            x = x < 0 ? start : start + x;
            if (x > finish)
                x = finish + 1;
            if (x > lines[iLine].Count)
                x = lines[iLine].Count;

#if debug
            Console.WriteLine("PointToPlace: " + sw.ElapsedMilliseconds);
#endif

            return new Place(x, iLine);
        }

        private Place PointToPlaceSimple(Point point)
        {
            point.Offset(HorizontalScroll.Value, VerticalScroll.Value);
            point.Offset(-LeftIndent - Paddings.Left, 0);
            int iLine = YtoLineIndex(point.Y);
            var x = (int) Math.Round((float) point.X / CharWidth);
            if (x < 0) x = 0;
            return new Place(x, iLine);
        }

        /// <summary>
        /// Gets nearest absolute text position for given point
        /// </summary>
        /// <param name="point">Point</param>
        /// <returns>Position</returns>
        public int PointToPosition(Point point)
        {
            return PlaceToPosition(PointToPlace(point));
        }

        /// <summary>
        /// Fires TextChanging event
        /// </summary>
        public virtual void OnTextChanging(ref string text)
        {
            ClearBracketsPositions();

            if (TextChanging != null)
            {
                var args = new TextChangingEventArgs {InsertingText = text};
                TextChanging(this, args);
                text = args.InsertingText;
                if (args.Cancel)
                    text = string.Empty;
            }
        }

        public virtual void OnTextChanging()
        {
            string temp = null;
            OnTextChanging(ref temp);
        }

        /// <summary>
        /// Fires TextChanged event
        /// </summary>
        public virtual void OnTextChanged()
        {
            var r = new Range(this);
            r.SelectAll();
            OnTextChanged(new TextChangedEventArgs(r));
        }

        /// <summary>
        /// Fires TextChanged event
        /// </summary>
        public virtual void OnTextChanged(int fromLine, int toLine)
        {
            var r = new Range(this);
            r.Start = new Place(0, Math.Min(fromLine, toLine));
            r.End = new Place(lines[Math.Max(fromLine, toLine)].Count, Math.Max(fromLine, toLine));
            OnTextChanged(new TextChangedEventArgs(r));
        }

        /// <summary>
        /// Fires TextChanged event
        /// </summary>
        public virtual void OnTextChanged(Range r)
        {
            OnTextChanged(new TextChangedEventArgs(r));
        }

        /// <summary>
        /// Call this method before multiple text changing
        /// </summary>
        public void BeginUpdate()
        {
            if (updating == 0)
                updatingRange = null;
            updating++;
        }

        /// <summary>
        /// Call this method after multiple text changing
        /// </summary>
        public void EndUpdate()
        {
            updating--;

            if (updating == 0 && updatingRange != null)
            {
                updatingRange.Expand();
                OnTextChanged(updatingRange);
            }
        }


        /// <summary>
        /// Fires TextChanged event
        /// </summary>
        protected virtual void OnTextChanged(TextChangedEventArgs args)
        {
            //
            args.ChangedRange.Normalize();
            //
            if (updating > 0)
            {
                if (updatingRange == null)
                    updatingRange = args.ChangedRange.Clone();
                else
                {
                    if (updatingRange.Start.iLine > args.ChangedRange.Start.iLine)
                        updatingRange.Start = new Place(0, args.ChangedRange.Start.iLine);
                    if (updatingRange.End.iLine < args.ChangedRange.End.iLine)
                        updatingRange.End = new Place(lines[args.ChangedRange.End.iLine].Count,
                            args.ChangedRange.End.iLine);
                    updatingRange = updatingRange.GetIntersectionWith(Range);
                }

                return;
            }
            //
#if debug
            var sw = Stopwatch.StartNew();
#endif
            CancelToolTip();
            ClearHints();
            IsChanged = true;
            TextVersion++;
            MarkLinesAsChanged(args.ChangedRange);
            ClearFoldingState(args.ChangedRange);
            //
            if (wordWrap)
                RecalcWordWrap(args.ChangedRange.Start.iLine, args.ChangedRange.End.iLine);
            //
            base.OnTextChanged(args);

            //dalayed event stuffs
            if (delayedTextChangedRange == null)
                delayedTextChangedRange = args.ChangedRange.Clone();
            else
                delayedTextChangedRange = delayedTextChangedRange.GetUnionWith(args.ChangedRange);

            needRiseTextChangedDelayed = true;
            ResetTimer(timer2);
            //
            OnSyntaxHighlight(args);
            //
            if (TextChanged != null)
                TextChanged(this, args);
            //
            if (BindingTextChanged != null)
                BindingTextChanged(this, EventArgs.Empty);
            //
            base.OnTextChanged(EventArgs.Empty);
            //
#if debug
            Console.WriteLine("OnTextChanged: " + sw.ElapsedMilliseconds);
#endif

            OnVisibleRangeChanged();
        }

        /// <summary>
        /// Clears folding state for range of text
        /// </summary>
        private void ClearFoldingState(Range range)
        {
            for (int iLine = range.Start.iLine; iLine <= range.End.iLine; iLine++)
                if (iLine >= 0 && iLine < lines.Count)
                    FoldedBlocks.Remove(this[iLine].UniqueId);
        }


        private void MarkLinesAsChanged(Range range)
        {
            for (int iLine = range.Start.iLine; iLine <= range.End.iLine; iLine++)
                if (iLine >= 0 && iLine < lines.Count)
                    lines[iLine].IsChanged = true;
        }

        /// <summary>
        /// Fires SelectionChanged event
        /// </summary>
        public virtual void OnSelectionChanged()
        {
#if debug
            var sw = Stopwatch.StartNew();
#endif
            //find folding markers for highlighting
            if (HighlightFoldingIndicator)
                HighlightFoldings();
            //
            needRiseSelectionChangedDelayed = true;
            ResetTimer(timer);

            if (SelectionChanged != null)
                SelectionChanged(this, new EventArgs());

#if debug
            Console.WriteLine("OnSelectionChanged: "+ sw.ElapsedMilliseconds);
#endif
        }

        //find folding markers for highlighting
        private void HighlightFoldings()
        {
            if (LinesCount == 0)
                return;
            //
            int prevStartFoldingLine = startFoldingLine;
            int prevEndFoldingLine = endFoldingLine;
            //
            startFoldingLine = -1;
            endFoldingLine = -1;
            int counter = 0;
            for (int i = Selection.Start.iLine; i >= Math.Max(Selection.Start.iLine - maxLinesForFolding, 0); i--)
            {
                bool hasStartMarker = lines.LineHasFoldingStartMarker(i);
                bool hasEndMarker = lines.LineHasFoldingEndMarker(i);

                if (hasEndMarker && hasStartMarker)
                    continue;

                if (hasStartMarker)
                {
                    counter--;
                    if (counter == -1) //found start folding
                    {
                        startFoldingLine = i;
                        break;
                    }
                }

                if (hasEndMarker && i != Selection.Start.iLine)
                    counter++;
            }

            if (startFoldingLine >= 0)
            {
                //find end of block
                endFoldingLine = FindEndOfFoldingBlock(startFoldingLine, maxLinesForFolding);
                if (endFoldingLine == startFoldingLine)
                    endFoldingLine = -1;
            }

            if (startFoldingLine != prevStartFoldingLine || endFoldingLine != prevEndFoldingLine)
                OnFoldingHighlightChanged();
        }

        protected virtual void OnFoldingHighlightChanged()
        {
            if (FoldingHighlightChanged != null)
                FoldingHighlightChanged(this, EventArgs.Empty);
        }

        protected override void OnGotFocus(EventArgs e)
        {
            SetAsCurrentTB();
            base.OnGotFocus(e);
            Invalidate();
        }

        protected override void OnLostFocus(EventArgs e)
        {
            lastModifiers = Keys.None;
            DeactivateMiddleClickScrollingMode();
            base.OnLostFocus(e);
            Invalidate();
        }

        /// <summary>
        /// Gets absolute text position from line and char position
        /// </summary>
        /// <param name="point">Line and char position</param>
        /// <returns>Point of char</returns>
        public int PlaceToPosition(Place point)
        {
            if (point.iLine < 0 || point.iLine >= lines.Count ||
                point.iChar >= lines[point.iLine].Count + Environment.NewLine.Length)
                return -1;

            int result = 0;
            for (int i = 0; i < point.iLine; i++)
                result += lines[i].Count + Environment.NewLine.Length;
            result += point.iChar;

            return result;
        }

        /// <summary>
        /// Gets line and char position from absolute text position
        /// </summary>
        public Place PositionToPlace(int pos)
        {
            if (pos < 0)
                return new Place(0, 0);

            for (int i = 0; i < lines.Count; i++)
            {
                int lineLength = lines[i].Count + Environment.NewLine.Length;
                if (pos < lines[i].Count)
                    return new Place(pos, i);
                if (pos < lineLength)
                    return new Place(lines[i].Count, i);

                pos -= lineLength;
            }

            if (lines.Count > 0)
                return new Place(lines[lines.Count - 1].Count, lines.Count - 1);
            else
                return new Place(0, 0);
            //throw new ArgumentOutOfRangeException("Position out of range");
        }

        /// <summary>
        /// Gets absolute char position from char position
        /// </summary>
        public Point PositionToPoint(int pos)
        {
            return PlaceToPoint(PositionToPlace(pos));
        }

        /// <summary>
        /// Gets point for given line and char position
        /// </summary>
        /// <param name="place">Line and char position</param>
        /// <returns>Coordiantes</returns>
        public Point PlaceToPoint(Place place)
        {
            if (place.iLine >= LineInfos.Count)
                return new Point();
            int y = LineInfos[place.iLine].startY;
            //
            int iWordWrapIndex = LineInfos[place.iLine].GetWordWrapStringIndex(place.iChar);
            y += iWordWrapIndex * CharHeight;
            int x = (place.iChar - LineInfos[place.iLine].GetWordWrapStringStartPosition(iWordWrapIndex)) * CharWidth;
            if (iWordWrapIndex > 0)
                x += LineInfos[place.iLine].wordWrapIndent * CharWidth;
            //
            y = y - VerticalScroll.Value;
            x = LeftIndent + Paddings.Left + x - HorizontalScroll.Value;

            return new Point(x, y);
        }

        /// <summary>
        /// Get range of text
        /// </summary>
        /// <param name="fromPos">Absolute start position</param>
        /// <param name="toPos">Absolute finish position</param>
        /// <returns>Range</returns>
        public Range GetRange(int fromPos, int toPos)
        {
            var sel = new Range(this);
            sel.Start = PositionToPlace(fromPos);
            sel.End = PositionToPlace(toPos);
            return sel;
        }

        /// <summary>
        /// Get range of text
        /// </summary>
        /// <param name="fromPlace">Line and char position</param>
        /// <param name="toPlace">Line and char position</param>
        /// <returns>Range</returns>
        public Range GetRange(Place fromPlace, Place toPlace)
        {
            return new Range(this, fromPlace, toPlace);
        }

        /// <summary>
        /// Finds ranges for given regex pattern
        /// </summary>
        /// <param name="regexPattern">Regex pattern</param>
        /// <returns>Enumeration of ranges</returns>
        public IEnumerable<Range> GetRanges(string regexPattern)
        {
            var range = new Range(this);
            range.SelectAll();
            //
            foreach (Range r in range.GetRanges(regexPattern, RegexOptions.None))
                yield return r;
        }

        /// <summary>
        /// Finds ranges for given regex pattern
        /// </summary>
        /// <param name="regexPattern">Regex pattern</param>
        /// <returns>Enumeration of ranges</returns>
        public IEnumerable<Range> GetRanges(string regexPattern, RegexOptions options)
        {
            var range = new Range(this);
            range.SelectAll();
            //
            foreach (Range r in range.GetRanges(regexPattern, options))
                yield return r;
        }

        /// <summary>
        /// Get text of given line
        /// </summary>
        /// <param name="iLine">Line index</param>
        /// <returns>Text</returns>
        public string GetLineText(int iLine)
        {
            if (iLine < 0 || iLine >= lines.Count)
                throw new ArgumentOutOfRangeException("Line index out of range");
            var sb = new StringBuilder(lines[iLine].Count);
            foreach (Char c in lines[iLine])
                sb.Append(c.c);
            return sb.ToString();
        }

        /// <summary>
        /// Exapnds folded block
        /// </summary>
        /// <param name="iLine">Start line</param>
        public virtual void ExpandFoldedBlock(int iLine)
        {
            if (iLine < 0 || iLine >= lines.Count)
                throw new ArgumentOutOfRangeException("Line index out of range");
            //find all hidden lines afetr iLine
            int end = iLine;
            for (; end < LinesCount - 1; end++)
            {
                if (LineInfos[end + 1].VisibleState != VisibleState.Hidden)
                    break;
            }

            ExpandBlock(iLine, end);

            FoldedBlocks.Remove(this[iLine].UniqueId); //remove folded state for this line
            AdjustFolding();
        }

        /// <summary>
        /// Collapse folding blocks using FoldedBlocks dictionary.
        /// </summary>
        public virtual void AdjustFolding()
        {
            //collapse folded blocks
            for (int iLine = 0; iLine < LinesCount; iLine++)
                if (LineInfos[iLine].VisibleState == VisibleState.Visible)
                    if (FoldedBlocks.ContainsKey(this[iLine].UniqueId))
                        CollapseFoldingBlock(iLine);
        }


        /// <summary>
        /// Expand collapsed block
        /// </summary>
        public virtual void ExpandBlock(int fromLine, int toLine)
        {
            int from = Math.Min(fromLine, toLine);
            int to = Math.Max(fromLine, toLine);
            for (int i = from; i <= to; i++)
                SetVisibleState(i, VisibleState.Visible);
            needRecalc = true;

            Invalidate();
            OnVisibleRangeChanged();
        }

        /// <summary>
        /// Expand collapsed block
        /// </summary>
        /// <param name="iLine">Any line inside collapsed block</param>
        public void ExpandBlock(int iLine)
        {
            if (LineInfos[iLine].VisibleState == VisibleState.Visible)
                return;

            for (int i = iLine; i < LinesCount; i++)
                if (LineInfos[i].VisibleState == VisibleState.Visible)
                    break;
                else
                {
                    SetVisibleState(i, VisibleState.Visible);
                    needRecalc = true;
                }

            for (int i = iLine - 1; i >= 0; i--)
                if (LineInfos[i].VisibleState == VisibleState.Visible)
                    break;
                else
                {
                    SetVisibleState(i, VisibleState.Visible);
                    needRecalc = true;
                }

            Invalidate();
            OnVisibleRangeChanged();
        }

        /// <summary>
        /// Collapses all folding blocks
        /// </summary>
        public virtual void CollapseAllFoldingBlocks()
        {
            for (int i = 0; i < LinesCount; i++)
                if (lines.LineHasFoldingStartMarker(i))
                {
                    int iFinish = FindEndOfFoldingBlock(i);
                    if (iFinish >= 0)
                    {
                        CollapseBlock(i, iFinish);
                        i = iFinish;
                    }
                }

            OnVisibleRangeChanged();
            UpdateScrollbars();
        }

        /// <summary>
        /// Exapnds all folded blocks
        /// </summary>
        /// <param name="iLine"></param>
        public virtual void ExpandAllFoldingBlocks()
        {
            for (int i = 0; i < LinesCount; i++)
                SetVisibleState(i, VisibleState.Visible);

            FoldedBlocks.Clear();

            OnVisibleRangeChanged();
            Invalidate();
            UpdateScrollbars();
        }

        /// <summary>
        /// Collapses folding block
        /// </summary>
        /// <param name="iLine">Start folding line</param>
        public virtual void CollapseFoldingBlock(int iLine)
        {
            if (iLine < 0 || iLine >= lines.Count)
                throw new ArgumentOutOfRangeException("Line index out of range");
            if (string.IsNullOrEmpty(lines[iLine].FoldingStartMarker))
                throw new ArgumentOutOfRangeException("This line is not folding start line");
            //find end of block
            int i = FindEndOfFoldingBlock(iLine);
            //collapse
            if (i >= 0)
            {
                CollapseBlock(iLine, i);
                var id = this[iLine].UniqueId;
                FoldedBlocks[id] = id; //add folded state for line
            }
        }

        private int FindEndOfFoldingBlock(int iStartLine)
        {
            return FindEndOfFoldingBlock(iStartLine, int.MaxValue);
        }

        protected virtual int FindEndOfFoldingBlock(int iStartLine, int maxLines)
        {
            //find end of block
            int i;
            string marker = lines[iStartLine].FoldingStartMarker;
            var stack = new Stack<string>();

            switch (FindEndOfFoldingBlockStrategy)
            {
                case FindEndOfFoldingBlockStrategy.Strategy1:
                    for (i = iStartLine /*+1*/; i < LinesCount; i++)
                    {
                        if (lines.LineHasFoldingStartMarker(i))
                            stack.Push(lines[i].FoldingStartMarker);

                        if (lines.LineHasFoldingEndMarker(i))
                        {
                            string m = lines[i].FoldingEndMarker;
                            while (stack.Count > 0 && stack.Pop() != m) ;
                            if (stack.Count == 0)
                                return i;
                        }

                        maxLines--;
                        if (maxLines < 0)
                            return i;
                    }

                    break;

                case FindEndOfFoldingBlockStrategy.Strategy2:
                    for (i = iStartLine /*+1*/; i < LinesCount; i++)
                    {
                        if (lines.LineHasFoldingEndMarker(i))
                        {
                            string m = lines[i].FoldingEndMarker;
                            while (stack.Count > 0 && stack.Pop() != m) ;
                            if (stack.Count == 0)
                                return i;
                        }

                        if (lines.LineHasFoldingStartMarker(i))
                            stack.Push(lines[i].FoldingStartMarker);

                        maxLines--;
                        if (maxLines < 0)
                            return i;
                    }

                    break;
            }

            //return -1;
            return LinesCount - 1;
        }

        /// <summary>
        /// Start foilding marker for the line
        /// </summary>
        public string GetLineFoldingStartMarker(int iLine)
        {
            if (lines.LineHasFoldingStartMarker(iLine))
                return lines[iLine].FoldingStartMarker;
            return null;
        }

        /// <summary>
        /// End foilding marker for the line
        /// </summary>
        public string GetLineFoldingEndMarker(int iLine)
        {
            if (lines.LineHasFoldingEndMarker(iLine))
                return lines[iLine].FoldingEndMarker;
            return null;
        }

        protected virtual void RecalcFoldingLines()
        {
            if (!needRecalcFoldingLines)
                return;
            needRecalcFoldingLines = false;
            if (!ShowFoldingLines)
                return;

            foldingPairs.Clear();
            //
            Range range = VisibleRange;
            int startLine = Math.Max(range.Start.iLine - maxLinesForFolding, 0);
            int endLine = Math.Min(range.End.iLine + maxLinesForFolding, Math.Max(range.End.iLine, LinesCount - 1));
            var stack = new Stack<int>();
            for (int i = startLine; i <= endLine; i++)
            {
                bool hasStartMarker = lines.LineHasFoldingStartMarker(i);
                bool hasEndMarker = lines.LineHasFoldingEndMarker(i);

                if (hasEndMarker && hasStartMarker)
                    continue;

                if (hasStartMarker)
                {
                    stack.Push(i);
                }

                if (hasEndMarker)
                {
                    string m = lines[i].FoldingEndMarker;
                    while (stack.Count > 0)
                    {
                        int iStartLine = stack.Pop();
                        foldingPairs[iStartLine] = i;
                        if (m == lines[iStartLine].FoldingStartMarker)
                            break;
                    }
                }
            }

            while (stack.Count > 0)
                foldingPairs[stack.Pop()] = endLine + 1;
        }

        /// <summary>
        /// Collapse text block
        /// </summary>
        public virtual void CollapseBlock(int fromLine, int toLine)
        {
            int from = Math.Min(fromLine, toLine);
            int to = Math.Max(fromLine, toLine);
            if (from == to)
                return;

            //find first non empty line
            for (; from <= to; from++)
            {
                if (GetLineText(from).Trim().Length > 0)
                {
                    //hide lines
                    for (int i = from + 1; i <= to; i++)
                        SetVisibleState(i, VisibleState.Hidden);
                    SetVisibleState(from, VisibleState.StartOfHiddenBlock);
                    Invalidate();
                    break;
                }
            }

            //Move caret outside
            from = Math.Min(fromLine, toLine);
            to = Math.Max(fromLine, toLine);
            int newLine = FindNextVisibleLine(to);
            if (newLine == to)
                newLine = FindPrevVisibleLine(from);
            Selection.Start = new Place(0, newLine);
            //
            needRecalc = true;
            Invalidate();
            OnVisibleRangeChanged();
        }


        internal int FindNextVisibleLine(int iLine)
        {
            if (iLine >= lines.Count - 1) return iLine;
            int old = iLine;
            do
                iLine++;
            while (iLine < lines.Count - 1 && LineInfos[iLine].VisibleState != VisibleState.Visible);

            if (LineInfos[iLine].VisibleState != VisibleState.Visible)
                return old;
            else
                return iLine;
        }


        internal int FindPrevVisibleLine(int iLine)
        {
            if (iLine <= 0) return iLine;
            int old = iLine;
            do
                iLine--;
            while (iLine > 0 && LineInfos[iLine].VisibleState != VisibleState.Visible);

            if (LineInfos[iLine].VisibleState != VisibleState.Visible)
                return old;
            else
                return iLine;
        }

        private VisualMarker FindVisualMarkerForPoint(Point p)
        {
            foreach (VisualMarker m in visibleMarkers)
                if (m.rectangle.Contains(p))
                    return m;
            return null;
        }

        /// <summary>
        /// Insert TAB into front of seletcted lines.
        /// </summary>
        public virtual void IncreaseIndent()
        {
            if (Selection.Start == Selection.End)
            {
                if (!Selection.ReadOnly)
                {
                    Selection.Start = new Place(this[Selection.Start.iLine].StartSpacesCount, Selection.Start.iLine);
                    //insert tab as spaces
                    int spaces = TabLength - (Selection.Start.iChar % TabLength);
                    //replace mode? select forward chars
                    if (IsReplaceMode)
                    {
                        for (int i = 0; i < spaces; i++)
                            Selection.GoRight(true);
                        Selection.Inverse();
                    }

                    InsertText(new String(' ', spaces));
                }

                return;
            }

            bool carretAtEnd = (Selection.Start > Selection.End) && !Selection.ColumnSelectionMode;

            int startChar = 0; // Only move selection when in 'ColumnSelectionMode'
            if (Selection.ColumnSelectionMode)
                startChar = Math.Min(Selection.End.iChar, Selection.Start.iChar);

            BeginUpdate();
            Selection.BeginUpdate();
            lines.Manager.BeginAutoUndoCommands();

            var old = Selection.Clone();
            lines.Manager.ExecuteCommand(new SelectCommand(TextSource)); //remember selection

            //
            Selection.Normalize();
            Range currentSelection = this.Selection.Clone();
            int from = Selection.Start.iLine;
            int to = Selection.End.iLine;

            if (!Selection.ColumnSelectionMode)
                if (Selection.End.iChar == 0)
                    to--;

            for (int i = from; i <= to; i++)
            {
                if (lines[i].Count == 0) continue;
                Selection.Start = new Place(startChar, i);
                lines.Manager.ExecuteCommand(new InsertTextCommand(TextSource, new String(' ', TabLength)));
            }

            // Restore selection
            if (Selection.ColumnSelectionMode == false)
            {
                int newSelectionStartCharacterIndex = currentSelection.Start.iChar + this.TabLength;
                int newSelectionEndCharacterIndex =
                    currentSelection.End.iChar + (currentSelection.End.iLine == to ? this.TabLength : 0);
                this.Selection.Start = new Place(newSelectionStartCharacterIndex, currentSelection.Start.iLine);
                this.Selection.End = new Place(newSelectionEndCharacterIndex, currentSelection.End.iLine);
            }
            else
            {
                Selection = old;
            }

            lines.Manager.EndAutoUndoCommands();

            if (carretAtEnd)
                Selection.Inverse();

            needRecalc = true;
            Selection.EndUpdate();
            EndUpdate();
            Invalidate();
        }

        /// <summary>
        /// Remove TAB from front of seletcted lines.
        /// </summary>
        public virtual void DecreaseIndent()
        {
            if (Selection.Start.iLine == Selection.End.iLine)
            {
                DecreaseIndentOfSingleLine();
                return;
            }

            int startCharIndex = 0;
            if (Selection.ColumnSelectionMode)
                startCharIndex = Math.Min(Selection.End.iChar, Selection.Start.iChar);

            BeginUpdate();
            Selection.BeginUpdate();
            lines.Manager.BeginAutoUndoCommands();
            var old = Selection.Clone();
            lines.Manager.ExecuteCommand(new SelectCommand(TextSource)); //remember selection

            // Remember current selection infos
            Range currentSelection = this.Selection.Clone();
            Selection.Normalize();
            int from = Selection.Start.iLine;
            int to = Selection.End.iLine;

            if (!Selection.ColumnSelectionMode)
                if (Selection.End.iChar == 0)
                    to--;

            int numberOfDeletedWhitespacesOfFirstLine = 0;
            int numberOfDeletetWhitespacesOfLastLine = 0;

            for (int i = from; i <= to; i++)
            {
                if (startCharIndex > lines[i].Count)
                    continue;
                // Select first characters from the line
                int endIndex = Math.Min(this.lines[i].Count, startCharIndex + this.TabLength);
                string wasteText = this.lines[i].Text.Substring(startCharIndex, endIndex - startCharIndex);

                // Only select the first whitespace characters
                endIndex = Math.Min(endIndex, startCharIndex + wasteText.Length - wasteText.TrimStart().Length);

                // Select the characters to remove
                this.Selection = new Range(this, new Place(startCharIndex, i), new Place(endIndex, i));

                // Remember characters to remove for first and last line
                int numberOfWhitespacesToRemove = endIndex - startCharIndex;
                if (i == currentSelection.Start.iLine)
                {
                    numberOfDeletedWhitespacesOfFirstLine = numberOfWhitespacesToRemove;
                }

                if (i == currentSelection.End.iLine)
                {
                    numberOfDeletetWhitespacesOfLastLine = numberOfWhitespacesToRemove;
                }

                // Remove marked/selected whitespace characters
                if (!Selection.IsEmpty)
                    this.ClearSelected();
            }

            // Restore selection
            if (Selection.ColumnSelectionMode == false)
            {
                int newSelectionStartCharacterIndex = Math.Max(0,
                    currentSelection.Start.iChar - numberOfDeletedWhitespacesOfFirstLine);
                int newSelectionEndCharacterIndex =
                    Math.Max(0, currentSelection.End.iChar - numberOfDeletetWhitespacesOfLastLine);
                this.Selection.Start = new Place(newSelectionStartCharacterIndex, currentSelection.Start.iLine);
                this.Selection.End = new Place(newSelectionEndCharacterIndex, currentSelection.End.iLine);
            }
            else
            {
                Selection = old;
            }

            lines.Manager.EndAutoUndoCommands();

            needRecalc = true;
            Selection.EndUpdate();
            EndUpdate();
            Invalidate();
        }

        /// <summary>
        /// Remove TAB in front of the caret ot the selected line.
        /// </summary>
        protected virtual void DecreaseIndentOfSingleLine()
        {
            if (this.Selection.Start.iLine != this.Selection.End.iLine)
                return;

            // Remeber current selection infos
            Range currentSelection = this.Selection.Clone();
            int currentLineIndex = this.Selection.Start.iLine;
            int currentLeftSelectionStartIndex = Math.Min(this.Selection.Start.iChar, this.Selection.End.iChar);

            // Determine number of whitespaces to remove
            string lineText = this.lines[currentLineIndex].Text;
            Match whitespacesLeftOfSelectionStartMatch =
                new Regex(@"\s*", RegexOptions.RightToLeft).Match(lineText, currentLeftSelectionStartIndex);
            int leftOffset = whitespacesLeftOfSelectionStartMatch.Index;
            int countOfWhitespaces = whitespacesLeftOfSelectionStartMatch.Length;
            int numberOfCharactersToRemove = 0;
            if (countOfWhitespaces > 0)
            {
                int remainder = (this.TabLength > 0)
                    ? currentLeftSelectionStartIndex % this.TabLength
                    : 0;
                numberOfCharactersToRemove = (remainder != 0)
                    ? Math.Min(remainder, countOfWhitespaces)
                    : Math.Min(this.TabLength, countOfWhitespaces);
            }

            // Remove whitespaces if available
            if (numberOfCharactersToRemove > 0)
            {
                // Start selection update
                this.BeginUpdate();
                this.Selection.BeginUpdate();
                lines.Manager.BeginAutoUndoCommands();
                lines.Manager.ExecuteCommand(new SelectCommand(TextSource)); //remember selection

                // Remove whitespaces
                this.Selection.Start = new Place(leftOffset, currentLineIndex);
                this.Selection.End = new Place(leftOffset + numberOfCharactersToRemove, currentLineIndex);
                ClearSelected();

                // Restore selection
                int newSelectionStartCharacterIndex = currentSelection.Start.iChar - numberOfCharactersToRemove;
                int newSelectionEndCharacterIndex = currentSelection.End.iChar - numberOfCharactersToRemove;
                this.Selection.Start = new Place(newSelectionStartCharacterIndex, currentLineIndex);
                this.Selection.End = new Place(newSelectionEndCharacterIndex, currentLineIndex);

                lines.Manager.ExecuteCommand(new SelectCommand(TextSource)); //remember selection
                // End selection update
                lines.Manager.EndAutoUndoCommands();
                this.Selection.EndUpdate();
                this.EndUpdate();
            }

            Invalidate();
        }


        /// <summary>
        /// Insert autoindents into selected lines
        /// </summary>
        public virtual void DoAutoIndent()
        {
            if (Selection.ColumnSelectionMode)
                return;
            Range r = Selection.Clone();
            r.Normalize();
            //
            BeginUpdate();
            Selection.BeginUpdate();
            lines.Manager.BeginAutoUndoCommands();
            //
            for (int i = r.Start.iLine; i <= r.End.iLine; i++)
                DoAutoIndent(i);
            //
            lines.Manager.EndAutoUndoCommands();
            Selection.Start = r.Start;
            Selection.End = r.End;
            Selection.Expand();
            //
            Selection.EndUpdate();
            EndUpdate();
        }

        /// <summary>
        /// Insert prefix into front of seletcted lines
        /// </summary>
        public virtual void InsertLinePrefix(string prefix)
        {
            Range old = Selection.Clone();
            int from = Math.Min(Selection.Start.iLine, Selection.End.iLine);
            int to = Math.Max(Selection.Start.iLine, Selection.End.iLine);
            BeginUpdate();
            Selection.BeginUpdate();
            lines.Manager.BeginAutoUndoCommands();
            lines.Manager.ExecuteCommand(new SelectCommand(TextSource));
            int spaces = GetMinStartSpacesCount(from, to);
            for (int i = from; i <= to; i++)
            {
                Selection.Start = new Place(spaces, i);
                lines.Manager.ExecuteCommand(new InsertTextCommand(TextSource, prefix));
            }

            Selection.Start = new Place(0, from);
            Selection.End = new Place(lines[to].Count, to);
            needRecalc = true;
            lines.Manager.EndAutoUndoCommands();
            Selection.EndUpdate();
            EndUpdate();
            Invalidate();
        }

        /// <summary>
        /// Remove prefix from front of selected lines
        /// This method ignores forward spaces of the line
        /// </summary>
        public virtual void RemoveLinePrefix(string prefix)
        {
            Range old = Selection.Clone();
            int from = Math.Min(Selection.Start.iLine, Selection.End.iLine);
            int to = Math.Max(Selection.Start.iLine, Selection.End.iLine);
            BeginUpdate();
            Selection.BeginUpdate();
            lines.Manager.BeginAutoUndoCommands();
            lines.Manager.ExecuteCommand(new SelectCommand(TextSource));
            for (int i = from; i <= to; i++)
            {
                string text = lines[i].Text;
                string trimmedText = text.TrimStart();
                if (trimmedText.StartsWith(prefix))
                {
                    int spaces = text.Length - trimmedText.Length;
                    Selection.Start = new Place(spaces, i);
                    Selection.End = new Place(spaces + prefix.Length, i);
                    ClearSelected();
                }
            }

            Selection.Start = new Place(0, from);
            Selection.End = new Place(lines[to].Count, to);
            needRecalc = true;
            lines.Manager.EndAutoUndoCommands();
            Selection.EndUpdate();
            EndUpdate();
        }

        /// <summary>
        /// Begins AutoUndo block.
        /// All changes of text between BeginAutoUndo() and EndAutoUndo() will be canceled in one operation Undo.
        /// </summary>
        public void BeginAutoUndo()
        {
            lines.Manager.BeginAutoUndoCommands();
        }

        /// <summary>
        /// Ends AutoUndo block.
        /// All changes of text between BeginAutoUndo() and EndAutoUndo() will be canceled in one operation Undo.
        /// </summary>
        public void EndAutoUndo()
        {
            lines.Manager.EndAutoUndoCommands();
        }

        public virtual void OnVisualMarkerClick(MouseEventArgs args, StyleVisualMarker marker)
        {
            if (VisualMarkerClick != null)
                VisualMarkerClick(this, new VisualMarkerEventArgs(marker.Style, marker, args));
            marker.Style.OnVisualMarkerClick(this, new VisualMarkerEventArgs(marker.Style, marker, args));
        }

        protected virtual void OnMarkerClick(MouseEventArgs args, VisualMarker marker)
        {
            if (marker is StyleVisualMarker)
            {
                OnVisualMarkerClick(args, marker as StyleVisualMarker);
                return;
            }

            if (marker is CollapseFoldingMarker)
            {
                CollapseFoldingBlock((marker as CollapseFoldingMarker).iLine);
                return;
            }

            if (marker is ExpandFoldingMarker)
            {
                ExpandFoldedBlock((marker as ExpandFoldingMarker).iLine);
                return;
            }

            if (marker is FoldedAreaMarker)
            {
                //select folded block
                int iStart = (marker as FoldedAreaMarker).iLine;
                int iEnd = FindEndOfFoldingBlock(iStart);
                if (iEnd < 0)
                    return;
                Selection.BeginUpdate();
                Selection.Start = new Place(0, iStart);
                Selection.End = new Place(lines[iEnd].Count, iEnd);
                Selection.EndUpdate();
                Invalidate();
                return;
            }
        }

        protected virtual void OnMarkerDoubleClick(VisualMarker marker)
        {
            if (marker is FoldedAreaMarker)
            {
                ExpandFoldedBlock((marker as FoldedAreaMarker).iLine);
                Invalidate();
                return;
            }
        }

        private void ClearBracketsPositions()
        {
            leftBracketPosition = null;
            rightBracketPosition = null;
            leftBracketPosition2 = null;
            rightBracketPosition2 = null;
        }

        /// <summary>
        /// Highlights brackets around caret
        /// </summary>
        private void HighlightBrackets(char LeftBracket, char RightBracket, ref Range leftBracketPosition,
            ref Range rightBracketPosition)
        {
            switch (BracketsHighlightStrategy)
            {
                case BracketsHighlightStrategy.Strategy1:
                    HighlightBrackets1(LeftBracket, RightBracket, ref leftBracketPosition, ref rightBracketPosition);
                    break;
                case BracketsHighlightStrategy.Strategy2:
                    HighlightBrackets2(LeftBracket, RightBracket, ref leftBracketPosition, ref rightBracketPosition);
                    break;
            }
        }

        private void HighlightBrackets1(char LeftBracket, char RightBracket, ref Range leftBracketPosition,
            ref Range rightBracketPosition)
        {
            if (!Selection.IsEmpty)
                return;
            if (LinesCount == 0)
                return;
            //
            Range oldLeftBracketPosition = leftBracketPosition;
            Range oldRightBracketPosition = rightBracketPosition;
            var range = GetBracketsRange(Selection.Start, LeftBracket, RightBracket, true);

            if (range != null)
            {
                leftBracketPosition = new Range(this, range.Start, new Place(range.Start.iChar + 1, range.Start.iLine));
                rightBracketPosition = new Range(this, new Place(range.End.iChar - 1, range.End.iLine), range.End);
            }

            if (oldLeftBracketPosition != leftBracketPosition ||
                oldRightBracketPosition != rightBracketPosition)
                Invalidate();
        }

        /// <summary>
        /// Returns range between brackets (or null if not found)
        /// </summary>
        public Range GetBracketsRange(Place placeInsideBrackets, char leftBracket, char rightBracket,
            bool includeBrackets)
        {
            var startRange = new Range(this, placeInsideBrackets, placeInsideBrackets);
            var range = startRange.Clone();

            Range leftBracketPosition = null;
            Range rightBracketPosition = null;

            int counter = 0;
            int maxIterations = maxBracketSearchIterations;
            while (range.GoLeftThroughFolded()) //move caret left
            {
                if (range.CharAfterStart == leftBracket) counter++;
                if (range.CharAfterStart == rightBracket) counter--;
                if (counter == 1)
                {
                    range.Start = new Place(range.Start.iChar + (!includeBrackets ? 1 : 0), range.Start.iLine);
                    leftBracketPosition = range;
                    break;
                }

                //
                maxIterations--;
                if (maxIterations <= 0) break;
            }

            //
            range = startRange.Clone();
            counter = 0;
            maxIterations = maxBracketSearchIterations;
            do
            {
                if (range.CharAfterStart == leftBracket) counter++;
                if (range.CharAfterStart == rightBracket) counter--;
                if (counter == -1)
                {
                    range.End = new Place(range.Start.iChar + (includeBrackets ? 1 : 0), range.Start.iLine);
                    rightBracketPosition = range;
                    break;
                }

                //
                maxIterations--;
                if (maxIterations <= 0) break;
            } while (range.GoRightThroughFolded()); //move caret right

            if (leftBracketPosition != null && rightBracketPosition != null)
                return new Range(this, leftBracketPosition.Start, rightBracketPosition.End);
            else
                return null;
        }

        private void HighlightBrackets2(char LeftBracket, char RightBracket, ref Range leftBracketPosition,
            ref Range rightBracketPosition)
        {
            if (!Selection.IsEmpty)
                return;
            if (LinesCount == 0)
                return;
            //
            Range oldLeftBracketPosition = leftBracketPosition;
            Range oldRightBracketPosition = rightBracketPosition;
            Range range = Selection.Clone(); //need clone because we will move caret

            bool found = false;
            int counter = 0;
            int maxIterations = maxBracketSearchIterations;
            if (range.CharBeforeStart == RightBracket)
            {
                rightBracketPosition = new Range(this, range.Start.iChar - 1, range.Start.iLine, range.Start.iChar,
                    range.Start.iLine);
                while (range.GoLeftThroughFolded()) //move caret left
                {
                    if (range.CharAfterStart == LeftBracket) counter++;
                    if (range.CharAfterStart == RightBracket) counter--;
                    if (counter == 0)
                    {
                        //highlighting
                        range.End = new Place(range.Start.iChar + 1, range.Start.iLine);
                        leftBracketPosition = range;
                        found = true;
                        break;
                    }

                    //
                    maxIterations--;
                    if (maxIterations <= 0) break;
                }
            }

            //
            range = Selection.Clone(); //need clone because we will move caret
            counter = 0;
            maxIterations = maxBracketSearchIterations;
            if (!found)
                if (range.CharAfterStart == LeftBracket)
                {
                    leftBracketPosition = new Range(this, range.Start.iChar, range.Start.iLine, range.Start.iChar + 1,
                        range.Start.iLine);
                    do
                    {
                        if (range.CharAfterStart == LeftBracket) counter++;
                        if (range.CharAfterStart == RightBracket) counter--;
                        if (counter == 0)
                        {
                            //highlighting
                            range.End = new Place(range.Start.iChar + 1, range.Start.iLine);
                            rightBracketPosition = range;
                            found = true;
                            break;
                        }

                        //
                        maxIterations--;
                        if (maxIterations <= 0) break;
                    } while (range.GoRightThroughFolded()); //move caret right
                }

            if (oldLeftBracketPosition != leftBracketPosition || oldRightBracketPosition != rightBracketPosition)
                Invalidate();
        }

        /// <summary>
        /// Selectes next fragment for given regex.
        /// </summary>
        public bool SelectNext(string regexPattern, bool backward = false, RegexOptions options = RegexOptions.None)
        {
            var sel = Selection.Clone();
            sel.Normalize();
            var range1 = backward ? new Range(this, Range.Start, sel.Start) : new Range(this, sel.End, Range.End);

            Range res = null;
            foreach (var r in range1.GetRanges(regexPattern, options))
            {
                res = r;
                if (!backward) break;
            }

            if (res == null) return false;
            Selection = res;
            Invalidate();
            return true;
        }

        public virtual void OnSyntaxHighlight(TextChangedEventArgs args)
        {
#if debug
            Stopwatch sw = Stopwatch.StartNew();
#endif

            Range range;

            switch (HighlightingRangeType)
            {
                case HighlightingRangeType.VisibleRange:
                    range = VisibleRange.GetUnionWith(args.ChangedRange);
                    break;
                case HighlightingRangeType.AllTextRange:
                    range = Range;
                    break;
                default:
                    range = args.ChangedRange;
                    break;
            }

            if (SyntaxHighlighter != null)
            {
                if (!string.IsNullOrEmpty(DescriptionFile))
                    SyntaxHighlighter.HighlightSyntax(DescriptionFile, range);
                else
                    SyntaxHighlighter.HighlightSyntax(Language, range);
            }

#if debug
            Console.WriteLine("OnSyntaxHighlight: "+ sw.ElapsedMilliseconds);
#endif
        }

        private void InitializeComponent()
        {
            SuspendLayout();
            // 
            // FastColoredTextBox
            // 
            Name = "FastColoredTextBox";
            ResumeLayout(false);
        }

        /// <summary>
        /// Prints range of text
        /// </summary>
        public virtual void Print(Range range, PrintDialogSettings settings)
        {
            //prepare export with wordwrapping
            var exporter = new ExportToHTML();
            exporter.UseBr = true;
            exporter.UseForwardNbsp = true;
            exporter.UseNbsp = true;
            exporter.UseStyleTag = false;
            exporter.IncludeLineNumbers = settings.IncludeLineNumbers;

            if (range == null)
                range = Range;

            if (range.Text == string.Empty)
                return;

            //change visible range
            visibleRange = range;
            try
            {
                //call handlers for VisibleRange
                if (VisibleRangeChanged != null)
                    VisibleRangeChanged(this, new EventArgs());
                if (VisibleRangeChangedDelayed != null)
                    VisibleRangeChangedDelayed(this, new EventArgs());
            }
            finally
            {
                //restore visible range
                visibleRange = null;
            }

            //generate HTML
            string HTML = exporter.GetHtml(range);
            HTML = "<META HTTP-EQUIV=\"Content-Type\" CONTENT=\"text/html; charset=UTF-8\"><head><title>" +
                   PrepareHtmlText(settings.Title) + "</title></head>" + HTML + "<br>" + SelectHTMLRangeScript();
            string tempFile = Path.GetTempPath() + "fctb.html";
            File.WriteAllText(tempFile, HTML);

            //clear wb page setup settings
            SetPageSetupSettings(settings);

            //create wb
            var wb = new WebBrowser();
            wb.Tag = settings;
            wb.Visible = false;
            wb.Location = new Point(-1000, -1000);
            wb.Parent = this;
            wb.StatusTextChanged += wb_StatusTextChanged;
            wb.Navigate(tempFile);
        }

        protected virtual string PrepareHtmlText(string s)
        {
            return s.Replace("<", "&lt;").Replace(">", "&gt;").Replace("&", "&amp;");
        }

        private void wb_StatusTextChanged(object sender, EventArgs e)
        {
            var wb = sender as WebBrowser;
            if (wb.StatusText.Contains("#print"))
            {
                var settings = wb.Tag as PrintDialogSettings;
                try
                {
                    //show print dialog
                    if (settings.ShowPrintPreviewDialog)
                        wb.ShowPrintPreviewDialog();
                    else
                    {
                        if (settings.ShowPageSetupDialog)
                            wb.ShowPageSetupDialog();

                        if (settings.ShowPrintDialog)
                            wb.ShowPrintDialog();
                        else
                            wb.Print();
                    }
                }
                finally
                {
                    //destroy webbrowser
                    wb.Parent = null;
                    wb.Dispose();
                }
            }
        }

        /// <summary>
        /// Prints all text
        /// </summary>
        public void Print(PrintDialogSettings settings)
        {
            Print(Range, settings);
        }

        /// <summary>
        /// Prints all text, without any dialog windows
        /// </summary>
        public void Print()
        {
            Print(Range,
                new PrintDialogSettings
                    {ShowPageSetupDialog = false, ShowPrintDialog = false, ShowPrintPreviewDialog = false});
        }

        private string SelectHTMLRangeScript()
        {
            Range sel = Selection.Clone();
            sel.Normalize();
            int start = PlaceToPosition(sel.Start) - sel.Start.iLine;
            int len = sel.Text.Length - (sel.End.iLine - sel.Start.iLine);
            return string.Format(
                @"<script type=""text/javascript"">
try{{
    var sel = document.selection;
    var rng = sel.createRange();
    rng.moveStart(""character"", {0});
    rng.moveEnd(""character"", {1});
    rng.select();
}}catch(ex){{}}
window.status = ""#print"";
</script>",
                start, len);
        }

        private static void SetPageSetupSettings(PrintDialogSettings settings)
        {
            RegistryKey key = Registry.CurrentUser.OpenSubKey(@"Software\Microsoft\Internet Explorer\PageSetup", true);
            if (key != null)
            {
                key.SetValue("footer", settings.Footer);
                key.SetValue("header", settings.Header);
            }
        }

        protected override void Dispose(bool disposing)
        {
            base.Dispose(disposing);
            if (disposing)
            {
                if (SyntaxHighlighter != null)
                    SyntaxHighlighter.Dispose();
                timer.Dispose();
                timer2.Dispose();
                middleClickScrollingTimer.Dispose();

                if (findForm != null)
                    findForm.Dispose();

                if (replaceForm != null)
                    replaceForm.Dispose();
                /*
                if (Font != null)
                    Font.Dispose();

                if (originalFont != null)
                    originalFont.Dispose();*/

                if (TextSource != null)
                    TextSource.Dispose();

                if (ToolTip != null)
                    ToolTip.Dispose();
            }
        }

        protected virtual void OnPaintLine(PaintLineEventArgs e)
        {
            if (PaintLine != null)
                PaintLine(this, e);
        }

        internal void OnLineInserted(int index)
        {
            OnLineInserted(index, 1);
        }

        internal void OnLineInserted(int index, int count)
        {
            if (LineInserted != null)
                LineInserted(this, new LineInsertedEventArgs(index, count));
        }

        internal void OnLineRemoved(int index, int count, List<int> removedLineIds)
        {
            if (count > 0)
                if (LineRemoved != null)
                    LineRemoved(this, new LineRemovedEventArgs(index, count, removedLineIds));
        }

        /// <summary>
        /// Open text file
        /// </summary>
        public void OpenFile(string fileName, Encoding enc)
        {
            var ts = CreateTextSource();
            try
            {
                InitTextSource(ts);
                Text = File.ReadAllText(fileName, enc);
                ClearUndo();
                IsChanged = false;
                OnVisibleRangeChanged();
            }
            catch
            {
                InitTextSource(CreateTextSource());
                lines.InsertLine(0, TextSource.CreateLine());
                IsChanged = false;
                throw;
            }

            Selection.Start = Place.Empty;
            DoSelectionVisible();
        }

        /// <summary>
        /// Open text file (with automatic encoding detector)
        /// </summary>
        public void OpenFile(string fileName)
        {
            try
            {
                var enc = EncodingDetector.DetectTextFileEncoding(fileName);
                if (enc != null)
                    OpenFile(fileName, enc);
                else
                    OpenFile(fileName, Encoding.Default);
            }
            catch
            {
                InitTextSource(CreateTextSource());
                lines.InsertLine(0, TextSource.CreateLine());
                IsChanged = false;
                throw;
            }
        }

        /// <summary>
        /// Open file binding mode
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="enc"></param>
        public void OpenBindingFile(string fileName, Encoding enc)
        {
            var fts = new FileTextSource(this);
            try
            {
                InitTextSource(fts);
                fts.OpenFile(fileName, enc);
                IsChanged = false;
                OnVisibleRangeChanged();
            }
            catch
            {
                fts.CloseFile();
                InitTextSource(CreateTextSource());
                lines.InsertLine(0, TextSource.CreateLine());
                IsChanged = false;
                throw;
            }

            Invalidate();
        }

        /// <summary>
        /// Close file binding mode
        /// </summary>
        public void CloseBindingFile()
        {
            if (lines is FileTextSource)
            {
                var fts = lines as FileTextSource;
                fts.CloseFile();

                InitTextSource(CreateTextSource());
                lines.InsertLine(0, TextSource.CreateLine());
                IsChanged = false;
                Invalidate();
            }
        }

        /// <summary>
        /// Save text to the file
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="enc"></param>
        public void SaveToFile(string fileName, Encoding enc)
        {
            lines.SaveToFile(fileName, enc);
            IsChanged = false;
            OnVisibleRangeChanged();
            UpdateScrollbars();
        }

        /// <summary>
        /// Set VisibleState of line
        /// </summary>
        public void SetVisibleState(int iLine, VisibleState state)
        {
            LineInfo li = LineInfos[iLine];
            li.VisibleState = state;
            LineInfos[iLine] = li;
            needRecalc = true;
        }

        /// <summary>
        /// Returns VisibleState of the line
        /// </summary>
        public VisibleState GetVisibleState(int iLine)
        {
            return LineInfos[iLine].VisibleState;
        }

        /// <summary>
        /// Shows Goto dialog form
        /// </summary>
        public void ShowGoToDialog()
        {
            var form = new GoToForm();
            form.TotalLineCount = LinesCount;
            form.SelectedLineNumber = Selection.Start.iLine + 1;

            if (form.ShowDialog() == DialogResult.OK)
            {
                int line = Math.Min(LinesCount - 1, Math.Max(0, form.SelectedLineNumber - 1));
                Selection = new Range(this, 0, line, 0, line);
                DoSelectionVisible();
            }
        }

        /// <summary>
        /// Occurs when undo/redo stack is changed
        /// </summary>
        public void OnUndoRedoStateChanged()
        {
            if (UndoRedoStateChanged != null)
                UndoRedoStateChanged(this, EventArgs.Empty);
        }

        /// <summary>
        /// Search lines by regex pattern
        /// </summary>
        public List<int> FindLines(string searchPattern, RegexOptions options)
        {
            var iLines = new List<int>();
            foreach (Range r in Range.GetRangesByLines(searchPattern, options))
                iLines.Add(r.Start.iLine);

            return iLines;
        }

        /// <summary>
        /// Removes given lines
        /// </summary>
        public void RemoveLines(List<int> iLines)
        {
            TextSource.Manager.ExecuteCommand(new RemoveLinesCommand(TextSource, iLines));
            if (iLines.Count > 0)
                IsChanged = true;
            if (LinesCount == 0)
                Text = "";
            NeedRecalc();
            Invalidate();
        }

        void ISupportInitialize.BeginInit()
        {
            //
        }

        void ISupportInitialize.EndInit()
        {
            OnTextChanged();
            Selection.Start = Place.Empty;
            DoCaretVisible();
            IsChanged = false;
            ClearUndo();
        }

        #region Drag and drop

        private bool IsDragDrop { get; set; }


        protected override void OnDragEnter(DragEventArgs e)
        {
            if (e.Data.GetDataPresent(DataFormats.Text) && AllowDrop)
            {
                e.Effect = DragDropEffects.Copy;
                IsDragDrop = true;
            }

            base.OnDragEnter(e);
        }

        protected override void OnDragDrop(DragEventArgs e)
        {
            if (ReadOnly || !AllowDrop)
            {
                IsDragDrop = false;
                return;
            }

            if (e.Data.GetDataPresent(DataFormats.Text))
            {
                if (ParentForm != null)
                    ParentForm.Activate();
                Focus();
                Point p = PointToClient(new Point(e.X, e.Y));
                var text = e.Data.GetData(DataFormats.Text).ToString();
                var place = PointToPlace(p);
                DoDragDrop(place, text);
                IsDragDrop = false;
            }

            base.OnDragDrop(e);
        }

        private void DoDragDrop_old(Place place, string text)
        {
            Range insertRange = new Range(this, place, place);

            // Abort, if insertRange is read only
            if (insertRange.ReadOnly)
                return;

            // Abort, if dragged range contains target place
            if ((draggedRange != null) && (draggedRange.Contains(place) == true))
                return;

            // Determine, if the dragged string should be copied or moved
            bool copyMode =
                (draggedRange == null) || // drag from outside
                (draggedRange.ReadOnly) || // dragged range is read only
                ((ModifierKeys & Keys.Control) != Keys.None);

            //drag from outside?
            if (draggedRange == null)
            {
                Selection.BeginUpdate();
                // Insert text
                Selection.Start = place;
                InsertText(text);
                // Select inserted text
                Selection = new Range(this, place, Selection.Start);
                Selection.EndUpdate();
                return;
            }

            //drag from me
            Place caretPositionAfterInserting;
            BeginAutoUndo();
            Selection.BeginUpdate();

            //remember dragged selection for undo/redo
            Selection = draggedRange;
            lines.Manager.ExecuteCommand(new SelectCommand(lines));
            //
            if (draggedRange.ColumnSelectionMode)
            {
                draggedRange.Normalize();
                insertRange =
                    new Range(this, place,
                            new Place(place.iChar, place.iLine + draggedRange.End.iLine - draggedRange.Start.iLine))
                        {ColumnSelectionMode = true};
                for (int i = LinesCount; i <= insertRange.End.iLine; i++)
                {
                    Selection.GoLast(false);
                    InsertChar('\n');
                }
            }

            if (!insertRange.ReadOnly)
            {
                if (place < draggedRange.Start)
                {
                    // Delete dragged range if not in copy mode
                    if (copyMode == false)
                    {
                        Selection = draggedRange;
                        ClearSelected();
                    }

                    // Insert text
                    Selection = insertRange;
                    Selection.ColumnSelectionMode = insertRange.ColumnSelectionMode;
                    InsertText(text);
                    caretPositionAfterInserting = Selection.Start;
                }
                else
                {
                    // Insert text
                    Selection = insertRange;
                    Selection.ColumnSelectionMode = insertRange.ColumnSelectionMode;
                    InsertText(text);
                    caretPositionAfterInserting = Selection.Start;
                    var lineLength = this[caretPositionAfterInserting.iLine].Count;

                    // Delete dragged range if not in copy mode
                    if (copyMode == false)
                    {
                        Selection = draggedRange;
                        ClearSelected();
                    }

                    var shift = lineLength - this[caretPositionAfterInserting.iLine].Count;
                    caretPositionAfterInserting.iChar = caretPositionAfterInserting.iChar - shift;
                    place.iChar = place.iChar - shift;
                }

                // Select inserted text
                if (!draggedRange.ColumnSelectionMode)
                {
                    Selection = new Range(this, place, caretPositionAfterInserting);
                }
                else
                {
                    draggedRange.Normalize();
                    Selection = new Range(this, place,
                            new Place(place.iChar + draggedRange.End.iChar - draggedRange.Start.iChar,
                                place.iLine + draggedRange.End.iLine - draggedRange.Start.iLine))
                        {ColumnSelectionMode = true};
                }
            }

            Selection.EndUpdate();
            EndAutoUndo();
            draggedRange = null;
        }

        protected virtual void DoDragDrop(Place place, string text)
        {
            Range insertRange = new Range(this, place, place);

            // Abort, if insertRange is read only
            if (insertRange.ReadOnly)
                return;

            // Abort, if dragged range contains target place
            if ((draggedRange != null) && (draggedRange.Contains(place) == true))
                return;

            // Determine, if the dragged string should be copied or moved
            bool copyMode =
                (draggedRange == null) || // drag from outside
                (draggedRange.ReadOnly) || // dragged range is read only
                ((ModifierKeys & Keys.Control) != Keys.None);

            if (draggedRange == null) //drag from outside
            {
                Selection.BeginUpdate();
                // Insert text
                Selection.Start = place;
                InsertText(text);
                // Select inserted text
                Selection = new Range(this, place, Selection.Start);
                Selection.EndUpdate();
            }
            else //drag from me
            {
                if (!draggedRange.Contains(place))
                {
                    BeginAutoUndo();

                    //remember dragged selection for undo/redo
                    Selection = draggedRange;
                    lines.Manager.ExecuteCommand(new SelectCommand(lines));
                    //
                    if (draggedRange.ColumnSelectionMode)
                    {
                        draggedRange.Normalize();
                        insertRange =
                            new Range(this, place,
                                    new Place(place.iChar,
                                        place.iLine + draggedRange.End.iLine - draggedRange.Start.iLine))
                                {ColumnSelectionMode = true};
                        for (int i = LinesCount; i <= insertRange.End.iLine; i++)
                        {
                            Selection.GoLast(false);
                            InsertChar('\n');
                        }
                    }

                    if (!insertRange.ReadOnly)
                    {
                        if (place < draggedRange.Start)
                        {
                            // Delete dragged range if not in copy mode
                            if (copyMode == false)
                            {
                                Selection = draggedRange;
                                ClearSelected();
                            }

                            // Insert text
                            Selection = insertRange;
                            Selection.ColumnSelectionMode = insertRange.ColumnSelectionMode;
                            InsertText(text);
                        }
                        else
                        {
                            // Insert text
                            Selection = insertRange;
                            Selection.ColumnSelectionMode = insertRange.ColumnSelectionMode;
                            InsertText(text);

                            // Delete dragged range if not in copy mode
                            if (copyMode == false)
                            {
                                Selection = draggedRange;
                                ClearSelected();
                            }
                        }
                    }

                    // Selection start and end position
                    Place startPosition = place;
                    Place endPosition = Selection.Start;

                    // Correct selection
                    Range dR = (draggedRange.End > draggedRange.Start) // dragged selection
                        ? this.GetRange(draggedRange.Start, draggedRange.End)
                        : this.GetRange(draggedRange.End, draggedRange.Start);
                    Place tP = place; // targetPlace
                    int tS_S_Line; // targetSelection.Start.iLine
                    int tS_S_Char; // targetSelection.Start.iChar
                    int tS_E_Line; // targetSelection.End.iLine
                    int tS_E_Char; // targetSelection.End.iChar
                    if ((place > draggedRange.Start) && (copyMode == false))
                    {
                        if (draggedRange.ColumnSelectionMode == false)
                        {
                            // Normal selection mode:

                            // Determine character/column position of target selection
                            if (dR.Start.iLine != dR.End.iLine) // If more then one line was selected/dragged ...
                            {
                                tS_S_Char = (dR.End.iLine != tP.iLine)
                                    ? tP.iChar
                                    : dR.Start.iChar + (tP.iChar - dR.End.iChar);
                                tS_E_Char = dR.End.iChar;
                            }
                            else // only one line was selected/dragged
                            {
                                if (dR.End.iLine == tP.iLine)
                                {
                                    tS_S_Char = tP.iChar - dR.Text.Length;
                                    tS_E_Char = tP.iChar;
                                }
                                else
                                {
                                    tS_S_Char = tP.iChar;
                                    tS_E_Char = tP.iChar + dR.Text.Length;
                                }
                            }

                            // Determine line/row of target selection
                            if (dR.End.iLine != tP.iLine)
                            {
                                tS_S_Line = tP.iLine - (dR.End.iLine - dR.Start.iLine);
                                tS_E_Line = tP.iLine;
                            }
                            else
                            {
                                tS_S_Line = dR.Start.iLine;
                                tS_E_Line = dR.End.iLine;
                            }

                            startPosition = new Place(tS_S_Char, tS_S_Line);
                            endPosition = new Place(tS_E_Char, tS_E_Line);
                        }
                    }


                    // Select inserted text
                    if (!draggedRange.ColumnSelectionMode)
                        Selection = new Range(this, startPosition, endPosition);
                    else
                    {
                        if ((copyMode == false) &&
                            (place.iLine >= dR.Start.iLine) && (place.iLine <= dR.End.iLine) &&
                            (place.iChar >= dR.End.iChar))
                        {
                            tS_S_Char = tP.iChar - (dR.End.iChar - dR.Start.iChar);
                            tS_E_Char = tP.iChar;
                        }
                        else
                        {
                            tS_S_Char = tP.iChar;
                            tS_E_Char = tP.iChar + (dR.End.iChar - dR.Start.iChar);
                        }

                        tS_S_Line = tP.iLine;
                        tS_E_Line = tP.iLine + (dR.End.iLine - dR.Start.iLine);

                        startPosition = new Place(tS_S_Char, tS_S_Line);
                        endPosition = new Place(tS_E_Char, tS_E_Line);
                        Selection = new Range(this, startPosition, endPosition)
                        {
                            ColumnSelectionMode = true
                        };
                    }

                    EndAutoUndo();
                }

                this.selection.Inverse();
                OnSelectionChanged();
            }

            draggedRange = null;
        }

        protected override void OnDragOver(DragEventArgs e)
        {
            if (e.Data.GetDataPresent(DataFormats.Text))
            {
                Point p = PointToClient(new Point(e.X, e.Y));
                Selection.Start = PointToPlace(p);
                if (p.Y < 6 && VerticalScroll.Visible && VerticalScroll.Value > 0)
                    VerticalScroll.Value = Math.Max(0, VerticalScroll.Value - charHeight);

                DoCaretVisible();
                Invalidate();
            }

            base.OnDragOver(e);
        }

        protected override void OnDragLeave(EventArgs e)
        {
            IsDragDrop = false;
            base.OnDragLeave(e);
        }

        #endregion

        #region MiddleClickScrolling

        private bool middleClickScrollingActivated;
        private Point middleClickScrollingOriginPoint;
        private Point middleClickScrollingOriginScroll;
        private readonly Timer middleClickScrollingTimer = new Timer();
        private ScrollDirection middleClickScollDirection = ScrollDirection.None;

        /// <summary>
        /// Activates the scrolling mode (middle click button).
        /// </summary>
        /// <param name="e">MouseEventArgs</param>
        private void ActivateMiddleClickScrollingMode(MouseEventArgs e)
        {
            if (!middleClickScrollingActivated)
            {
                if ((!HorizontalScroll.Visible) && (!VerticalScroll.Visible))
                    if (ShowScrollBars)
                        return;
                middleClickScrollingActivated = true;
                middleClickScrollingOriginPoint = e.Location;
                middleClickScrollingOriginScroll = new Point(HorizontalScroll.Value, VerticalScroll.Value);
                middleClickScrollingTimer.Interval = 50;
                middleClickScrollingTimer.Enabled = true;
                Capture = true;
                // Refresh the control 
                Refresh();
                // Disable drawing
                NativeMethodWrapper.SendMessage(Handle, WM_SETREDRAW, 0, 0);
            }
        }

        /// <summary>
        /// Deactivates the scrolling mode (middle click button).
        /// </summary>
        private void DeactivateMiddleClickScrollingMode()
        {
            if (middleClickScrollingActivated)
            {
                middleClickScrollingActivated = false;
                middleClickScrollingTimer.Enabled = false;
                Capture = false;
                base.Cursor = defaultCursor;
                // Enable drawing
                NativeMethodWrapper.SendMessage(Handle, WM_SETREDRAW, 1, 0);
                Invalidate();
            }
        }

        /// <summary>
        /// Restore scrolls
        /// </summary>
        private void RestoreScrollsAfterMiddleClickScrollingMode()
        {
            var xea = new ScrollEventArgs(ScrollEventType.ThumbPosition,
                HorizontalScroll.Value,
                middleClickScrollingOriginScroll.X,
                ScrollOrientation.HorizontalScroll);
            OnScroll(xea);

            var yea = new ScrollEventArgs(ScrollEventType.ThumbPosition,
                VerticalScroll.Value,
                middleClickScrollingOriginScroll.Y,
                ScrollOrientation.VerticalScroll);
            OnScroll(yea);
        }

       

        private const int WM_SETREDRAW = 0xB;

        void middleClickScrollingTimer_Tick(object sender, EventArgs e)
        {
            if (IsDisposed)
                return;

            if (!middleClickScrollingActivated)
                return;

            Point currentMouseLocation = PointToClient(Cursor.Position);

            Capture = true;

            // Calculate angle and distance between current position point and origin point
            int distanceX = this.middleClickScrollingOriginPoint.X - currentMouseLocation.X;
            int distanceY = this.middleClickScrollingOriginPoint.Y - currentMouseLocation.Y;

            if (!VerticalScroll.Visible && ShowScrollBars) distanceY = 0;
            if (!HorizontalScroll.Visible && ShowScrollBars) distanceX = 0;

            double angleInDegree = 180 - Math.Atan2(distanceY, distanceX) * 180 / Math.PI;
            double distance = Math.Sqrt(Math.Pow(distanceX, 2) + Math.Pow(distanceY, 2));

            // determine scrolling direction depending on the angle
            if (distance > 10)
            {
                if (angleInDegree >= 325 || angleInDegree <= 35)
                    this.middleClickScollDirection = ScrollDirection.Right;
                else if (angleInDegree <= 55)
                    this.middleClickScollDirection = ScrollDirection.Right | ScrollDirection.Up;
                else if (angleInDegree <= 125)
                    this.middleClickScollDirection = ScrollDirection.Up;
                else if (angleInDegree <= 145)
                    this.middleClickScollDirection = ScrollDirection.Up | ScrollDirection.Left;
                else if (angleInDegree <= 215)
                    this.middleClickScollDirection = ScrollDirection.Left;
                else if (angleInDegree <= 235)
                    this.middleClickScollDirection = ScrollDirection.Left | ScrollDirection.Down;
                else if (angleInDegree <= 305)
                    this.middleClickScollDirection = ScrollDirection.Down;
                else
                    this.middleClickScollDirection = ScrollDirection.Down | ScrollDirection.Right;
            }
            else
            {
                this.middleClickScollDirection = ScrollDirection.None;
            }

            // Set mouse cursor
            switch (this.middleClickScollDirection)
            {
                case ScrollDirection.Right:
                    base.Cursor = Cursors.PanEast;
                    break;
                case ScrollDirection.Right | ScrollDirection.Up:
                    base.Cursor = Cursors.PanNE;
                    break;
                case ScrollDirection.Up:
                    base.Cursor = Cursors.PanNorth;
                    break;
                case ScrollDirection.Up | ScrollDirection.Left:
                    base.Cursor = Cursors.PanNW;
                    break;
                case ScrollDirection.Left:
                    base.Cursor = Cursors.PanWest;
                    break;
                case ScrollDirection.Left | ScrollDirection.Down:
                    base.Cursor = Cursors.PanSW;
                    break;
                case ScrollDirection.Down:
                    base.Cursor = Cursors.PanSouth;
                    break;
                case ScrollDirection.Down | ScrollDirection.Right:
                    base.Cursor = Cursors.PanSE;
                    break;
                default:
                    base.Cursor = defaultCursor;
                    return;
            }

            var xScrollOffset = (int) (-distanceX / 5.0);
            var yScrollOffset = (int) (-distanceY / 5.0);

            var xea = new ScrollEventArgs(
                xScrollOffset < 0 ? ScrollEventType.SmallIncrement : ScrollEventType.SmallDecrement,
                HorizontalScroll.Value,
                HorizontalScroll.Value + xScrollOffset,
                ScrollOrientation.HorizontalScroll);

            var yea = new ScrollEventArgs(
                yScrollOffset < 0 ? ScrollEventType.SmallDecrement : ScrollEventType.SmallIncrement,
                VerticalScroll.Value,
                VerticalScroll.Value + yScrollOffset,
                ScrollOrientation.VerticalScroll);

            if ((middleClickScollDirection & (ScrollDirection.Down | ScrollDirection.Up)) > 0)
                //DoScrollVertical(1 + Math.Abs(yScrollOffset), Math.Sign(distanceY));
                OnScroll(yea, false);

            if ((middleClickScollDirection & (ScrollDirection.Right | ScrollDirection.Left)) > 0)
                OnScroll(xea);

            // Enable drawing
            NativeMethodWrapper.SendMessage(Handle, WM_SETREDRAW, 1, 0);
            // Refresh the control 
            Refresh();
            // Disable drawing
            NativeMethodWrapper.SendMessage(Handle, WM_SETREDRAW, 0, 0);
        }

        private void DrawMiddleClickScrolling(Graphics gr)
        {
            // If mouse scrolling mode activated draw the scrolling cursor image
            bool ableToScrollVertically = this.VerticalScroll.Visible || !ShowScrollBars;
            bool ableToScrollHorizontally = this.HorizontalScroll.Visible || !ShowScrollBars;

            // Calculate inverse color
            Color inverseColor = Color.FromArgb(100, (byte) ~this.BackColor.R, (byte) ~this.BackColor.G,
                (byte) ~this.BackColor.B);
            using (SolidBrush inverseColorBrush = new SolidBrush(inverseColor))
            {
                var p = middleClickScrollingOriginPoint;

                var state = gr.Save();

                gr.SmoothingMode = SmoothingMode.HighQuality;
                gr.TranslateTransform(p.X, p.Y);
                gr.FillEllipse(inverseColorBrush, -2, -2, 4, 4);

                if (ableToScrollVertically) DrawTriangle(gr, inverseColorBrush);
                gr.RotateTransform(90);
                if (ableToScrollHorizontally) DrawTriangle(gr, inverseColorBrush);
                gr.RotateTransform(90);
                if (ableToScrollVertically) DrawTriangle(gr, inverseColorBrush);
                gr.RotateTransform(90);
                if (ableToScrollHorizontally) DrawTriangle(gr, inverseColorBrush);

                gr.Restore(state);
            }
        }

        private void DrawTriangle(Graphics g, Brush brush)
        {
            const int size = 5;
            var points = new Point[] {new Point(size, 2 * size), new Point(0, 3 * size), new Point(-size, 2 * size)};
            g.FillPolygon(brush, points);
        }

        #endregion


        #region Nested type: LineYComparer

        private class LineYComparer : IComparer<LineInfo>
        {
            private readonly int Y;

            public LineYComparer(int Y)
            {
                this.Y = Y;
            }

            #region IComparer<LineInfo> Members

            public int Compare(LineInfo x, LineInfo y)
            {
                if (x.startY == -10)
                    return -y.startY.CompareTo(Y);
                else
                    return x.startY.CompareTo(Y);
            }

            #endregion
        }

        #endregion
    }

    public class PaintLineEventArgs : PaintEventArgs
    {
        public PaintLineEventArgs(int iLine, Rectangle rect, Graphics gr, Rectangle clipRect) : base(gr, clipRect)
        {
            LineIndex = iLine;
            LineRect = rect;
        }

        public int LineIndex { get; private set; }
        public Rectangle LineRect { get; private set; }
    }

    public class LineInsertedEventArgs : EventArgs
    {
        public LineInsertedEventArgs(int index, int count)
        {
            Index = index;
            Count = count;
        }

        /// <summary>
        /// Inserted line index
        /// </summary>
        public int Index { get; private set; }

        /// <summary>
        /// Count of inserted lines
        /// </summary>
        public int Count { get; private set; }
    }

    public class LineRemovedEventArgs : EventArgs
    {
        public LineRemovedEventArgs(int index, int count, List<int> removedLineIds)
        {
            Index = index;
            Count = count;
            RemovedLineUniqueIds = removedLineIds;
        }

        /// <summary>
        /// Removed line index
        /// </summary>
        public int Index { get; private set; }

        /// <summary>
        /// Count of removed lines
        /// </summary>
        public int Count { get; private set; }

        /// <summary>
        /// UniqueIds of removed lines
        /// </summary>
        public List<int> RemovedLineUniqueIds { get; private set; }
    }

    /// <summary>
    /// TextChanged event argument
    /// </summary>
    public class TextChangedEventArgs : EventArgs
    {
        /// <summary>
        /// Constructor
        /// </summary>
        public TextChangedEventArgs(Range changedRange)
        {
            ChangedRange = changedRange;
        }

        /// <summary>
        /// This range contains changed area of text
        /// </summary>
        public Range ChangedRange { get; set; }
    }

    public class TextChangingEventArgs : EventArgs
    {
        public string InsertingText { get; set; }

        /// <summary>
        /// Set to true if you want to cancel text inserting
        /// </summary>
        public bool Cancel { get; set; }
    }

    public class WordWrapNeededEventArgs : EventArgs
    {
        public List<int> CutOffPositions { get; private set; }
        public bool ImeAllowed { get; private set; }
        public Line Line { get; private set; }

        public WordWrapNeededEventArgs(List<int> cutOffPositions, bool imeAllowed, Line line)
        {
            this.CutOffPositions = cutOffPositions;
            this.ImeAllowed = imeAllowed;
            this.Line = line;
        }
    }

    public enum WordWrapMode
    {
        /// <summary>
        /// Word wrapping by control width
        /// </summary>
        WordWrapControlWidth,

        /// <summary>
        /// Word wrapping by preferred line width (PreferredLineWidth)
        /// </summary>
        WordWrapPreferredWidth,

        /// <summary>
        /// Char wrapping by control width
        /// </summary>
        CharWrapControlWidth,

        /// <summary>
        /// Char wrapping by preferred line width (PreferredLineWidth)
        /// </summary>
        CharWrapPreferredWidth,

        /// <summary>
        /// Custom wrap (by event WordWrapNeeded)
        /// </summary>
        Custom
    }

    public class PrintDialogSettings
    {
        public PrintDialogSettings()
        {
            ShowPrintPreviewDialog = true;
            Title = "";
            Footer = "";
            Header = "";
        }

        public bool ShowPageSetupDialog { get; set; }
        public bool ShowPrintDialog { get; set; }
        public bool ShowPrintPreviewDialog { get; set; }

        /// <summary>
        /// Title of page. If you want to print Title on the page, insert code &amp;w in Footer or Header.
        /// </summary>
        public string Title { get; set; }

        /// <summary>
        /// Footer of page.
        /// Here you can use special codes: &amp;w (Window title), &amp;D, &amp;d (Date), &amp;t(), &amp;4 (Time), &amp;p (Current page number), &amp;P (Total number of pages),  &amp;&amp; (A single ampersand), &amp;b (Right justify text, Center text. If &amp;b occurs once, then anything after the &amp;b is right justified. If &amp;b occurs twice, then anything between the two &amp;b is centered, and anything after the second &amp;b is right justified).
        /// More detailed see <see cref="http://msdn.microsoft.com/en-us/library/aa969429(v=vs.85).aspx">here</see>
        /// </summary>
        public string Footer { get; set; }

        /// <summary>
        /// Header of page
        /// Here you can use special codes: &amp;w (Window title), &amp;D, &amp;d (Date), &amp;t(), &amp;4 (Time), &amp;p (Current page number), &amp;P (Total number of pages),  &amp;&amp; (A single ampersand), &amp;b (Right justify text, Center text. If &amp;b occurs once, then anything after the &amp;b is right justified. If &amp;b occurs twice, then anything between the two &amp;b is centered, and anything after the second &amp;b is right justified).
        /// More detailed see <see cref="http://msdn.microsoft.com/en-us/library/aa969429(v=vs.85).aspx">here</see>
        /// </summary>
        public string Header { get; set; }

        /// <summary>
        /// Prints line numbers
        /// </summary>
        public bool IncludeLineNumbers { get; set; }
    }

    public class AutoIndentEventArgs : EventArgs
    {
        public AutoIndentEventArgs(int iLine, string lineText, string prevLineText, int tabLength,
            int currentIndentation)
        {
            this.iLine = iLine;
            LineText = lineText;
            PrevLineText = prevLineText;
            TabLength = tabLength;
            AbsoluteIndentation = currentIndentation;
        }

        public int iLine { get; internal set; }
        public int TabLength { get; internal set; }
        public string LineText { get; internal set; }
        public string PrevLineText { get; internal set; }

        /// <summary>
        /// Additional spaces count for this line, relative to previous line
        /// </summary>
        public int Shift { get; set; }

        /// <summary>
        /// Additional spaces count for next line, relative to previous line
        /// </summary>
        public int ShiftNextLines { get; set; }

        /// <summary>
        /// Absolute indentation of current line. You can change this property if you want to set absolute indentation.
        /// </summary>
        public int AbsoluteIndentation { get; set; }
    }

    /// <summary>
    /// Type of highlighting
    /// </summary>
    public enum HighlightingRangeType
    {
        /// <summary>
        /// Highlight only changed range of text. Highest performance.
        /// </summary>
        ChangedRange,

        /// <summary>
        /// Highlight visible range of text. Middle performance.
        /// </summary>
        VisibleRange,

        /// <summary>
        /// Highlight all (visible and invisible) text. Lowest performance.
        /// </summary>
        AllTextRange
    }

    /// <summary>
    /// Strategy of search of end of folding block
    /// </summary>
    public enum FindEndOfFoldingBlockStrategy
    {
        Strategy1,
        Strategy2
    }

    /// <summary>
    /// Strategy of search of brackets to highlighting
    /// </summary>
    public enum BracketsHighlightStrategy
    {
        Strategy1,
        Strategy2
    }

    /// <summary>
    /// ToolTipNeeded event args
    /// </summary>
    public class ToolTipNeededEventArgs : EventArgs
    {
        public ToolTipNeededEventArgs(Place place, string hoveredWord)
        {
            HoveredWord = hoveredWord;
            Place = place;
        }

        public Place Place { get; private set; }
        public string HoveredWord { get; private set; }
        public string ToolTipTitle { get; set; }
        public string ToolTipText { get; set; }
        public ToolTipIcon ToolTipIcon { get; set; }
    }

    /// <summary>
    /// HintClick event args
    /// </summary>
    public class HintClickEventArgs : EventArgs
    {
        public HintClickEventArgs(Hint hint)
        {
            Hint = hint;
        }

        public Hint Hint { get; private set; }
    }

    /// <summary>
    /// CustomAction event args
    /// </summary>
    public class CustomActionEventArgs : EventArgs
    {
        public FCTBAction Action { get; private set; }

        public CustomActionEventArgs(FCTBAction action)
        {
            Action = action;
        }
    }

    public enum TextAreaBorderType
    {
        None,
        Single,
        Shadow
    }

    [Flags]
    public enum ScrollDirection : ushort
    {
        None = 0,
        Left = 1,
        Right = 2,
        Up = 4,
        Down = 8
    }

    [Serializable]
    public class ServiceColors
    {
        public Color CollapseMarkerForeColor { get; set; }
        public Color CollapseMarkerBackColor { get; set; }
        public Color CollapseMarkerBorderColor { get; set; }
        public Color ExpandMarkerForeColor { get; set; }
        public Color ExpandMarkerBackColor { get; set; }
        public Color ExpandMarkerBorderColor { get; set; }

        public ServiceColors()
        {
            CollapseMarkerForeColor = Color.Silver;
            CollapseMarkerBackColor = Color.White;
            CollapseMarkerBorderColor = Color.Silver;
            ExpandMarkerForeColor = Color.Red;
            ExpandMarkerBackColor = Color.White;
            ExpandMarkerBorderColor = Color.Silver;
        }
    }

#if Styles32
    /// <summary>
    /// Style index mask (32 styles)
    /// </summary>
    [Flags]
    public enum StyleIndex : uint
    {
        None = 0,
        Style0 = 0x1,
        Style1 = 0x2,
        Style2 = 0x4,
        Style3 = 0x8,
        Style4 = 0x10,
        Style5 = 0x20,
        Style6 = 0x40,
        Style7 = 0x80,
        Style8 = 0x100,
        Style9 = 0x200,
        Style10 = 0x400,
        Style11 = 0x800,
        Style12 = 0x1000,
        Style13 = 0x2000,
        Style14 = 0x4000,
        Style15 = 0x8000,

        Style16 = 0x10000,
        Style17 = 0x20000,
        Style18 = 0x40000,
        Style19 = 0x80000,
        Style20 = 0x100000,
        Style21 = 0x200000,
        Style22 = 0x400000,
        Style23 = 0x800000,
        Style24 = 0x1000000,
        Style25 = 0x2000000,
        Style26 = 0x4000000,
        Style27 = 0x8000000,
        Style28 = 0x10000000,
        Style29 = 0x20000000,
        Style30 = 0x40000000,
        Style31 = 0x80000000,

        All = 0xffffffff
    }
#else
    /// <summary>
    /// Style index mask (16 styles)
    /// </summary>
    [Flags]
    public enum StyleIndex : ushort
    {
        None = 0,
        Style0 = 0x1,
        Style1 = 0x2,
        Style2 = 0x4,
        Style3 = 0x8,
        Style4 = 0x10,
        Style5 = 0x20,
        Style6 = 0x40,
        Style7 = 0x80,
        Style8 = 0x100,
        Style9 = 0x200,
        Style10 = 0x400,
        Style11 = 0x800,
        Style12 = 0x1000,
        Style13 = 0x2000,
        Style14 = 0x4000,
        Style15 = 0x8000,
        All = 0xffff
    }
#endif
}

================================================
FILE: FastColoredTextBox/FastColoredTextBox.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
    <ProductVersion>9.0.21022</ProductVersion>
    <SchemaVersion>2.0</SchemaVersion>
    <ProjectGuid>{6DD14A85-CCFC-4774-BD26-0F5772512319}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>FastColoredTextBoxNS</RootNamespace>
    <AssemblyName>FastColoredTextBox</AssemblyName>
    <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
    <FileAlignment>512</FileAlignment>
    <TargetFrameworkProfile />
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
    <DebugSymbols>true</DebugSymbols>
    <DebugType>full</DebugType>
    <Optimize>false</Optimize>
    <OutputPath>..\bin\Win32\Debug\</OutputPath>
    <DefineConstants>TRACE;DEBUG</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
    <DocumentationFile>
    </DocumentationFile>
    <Prefer32Bit>false</Prefer32Bit>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
    <DebugType>pdbonly</DebugType>
    <Optimize>true</Optimize>
    <OutputPath>..\bin\Win32\Release\</OutputPath>
    <DefineConstants>TRACE</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
    <Prefer32Bit>false</Prefer32Bit>
  </PropertyGroup>
  <PropertyGroup>
    <SignAssembly>true</SignAssembly>
  </PropertyGroup>
  <PropertyGroup>
    <AssemblyOriginatorKeyFile>FCTB_key.snk</AssemblyOriginatorKeyFile>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
    <DebugSymbols>true</DebugSymbols>
    <OutputPath>..\bin\x64\Debug\</OutputPath>
    <DefineConstants>TRACE;DEBUG</DefineConstants>
    <DebugType>full</DebugType>
    <PlatformTarget>x64</PlatformTarget>
    <LangVersion>7.3</LangVersion>
    <ErrorReport>prompt</ErrorReport>
    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
    <Prefer32Bit>false</Prefer32Bit>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
    <OutputPath>..\bin\x64\Release\</OutputPath>
    <DefineConstants>TRACE</DefineConstants>
    <Optimize>true</Optimize>
    <DebugType>pdbonly</DebugType>
    <PlatformTarget>x64</PlatformTarget>
    <LangVersion>7.3</LangVersion>
    <ErrorReport>prompt</ErrorReport>
    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
    <Prefer32Bit>false</Prefer32Bit>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="System" />
    <Reference Include="System.Data" />
    <Reference Include="System.Design" />
    <Reference Include="System.Drawing" />
    <Reference Include="System.Windows.Forms" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="AutocompleteItem.cs" />
    <Compile Include="AutocompleteMenu.cs">
      <SubType>UserControl</SubType>
    </Compile>
    <Compile Include="Bookmarks.cs" />
    <Compile Include="Char.cs" />
    <Compile Include="DocumentMap.cs">
      <SubType>Component</SubType>
    </Compile>
    <Compile Include="EncodingDetector.cs" />
    <Compile Include="ExportToHTML.cs" />
    <Compile Include="ExportToRTF.cs" />
    <Compile Include="GoToForm.cs">
      <SubType>Form</SubType>
    </Compile>
    <Compile Include="GoToForm.Designer.cs">
      <DependentUpon>GoToForm.cs</DependentUpon>
    </Compile>
    <Compile Include="Hints.cs" />
    <Compile Include="HotkeysEditorForm.cs">
      <SubType>Form</SubType>
    </Compile>
    <Compile Include="HotkeysEditorForm.Designer.cs">
      <DependentUpon>HotkeysEditorForm.cs</DependentUpon>
    </Compile>
    <Compile Include="LinesAccessor.cs" />
    <Compile Include="MacrosManager.cs" />
    <Compile Include="NativeMethods.cs" />
    <Compile Include="PlatformType.cs" />
    <Compile Include="Hotkeys.cs" />
    <Compile Include="Ruler.cs">
      <SubType>UserControl</SubType>
    </Compile>
    <Compile Include="Ruler.Designer.cs">
      <DependentUpon>Ruler.cs</DependentUpon>
    </Compile>
    <Compile Include="SyntaxDescriptor.cs" />
    <Compile Include="SyntaxHighlighter.cs" />
    <Compile Include="ReplaceForm.cs">
      <SubType>Form</SubType>
    </Compile>
    <Compile Include="ReplaceForm.Designer.cs">
      <DependentUpon>ReplaceForm.cs</DependentUpon>
    </Compile>
    <Compile Include="FastColoredTextBox.cs">
      <SubType>UserControl</SubType>
    </Compile>
    <Compile Include="CommandManager.cs" />
    <Compile Include="Commands.cs" />
    <Compile Include="FindForm.cs">
      <SubType>Form</SubType>
    </Compile>
    <Compile Include="FindForm.Designer.cs">
      <DependentUpon>FindForm.cs</DependentUpon>
    </Compile>
    <Compile Include="LimitedStack.cs" />
    <Compile Include="Line.cs" />
    <Compile Include="Place.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="Range.cs" />
    <Compile Include="Style.cs" />
    <Compile Include="TextSource.cs" />
    <Compile Include="TypeDescriptor.cs" />
    <Compile Include="FileTextSource.cs" />
    <Compile Include="UnfocusablePanel.cs">
      <SubType>UserControl</SubType>
    </Compile>
    <Compile Include="VisualMarker.cs" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="FastColoredTextBox.resx">
      <DependentUpon>FastColoredTextBox.cs</DependentUpon>
    </EmbeddedResource>
    <EmbeddedResource Include="FindForm.resx">
      <DependentUpon>FindForm.cs</DependentUpon>
    </EmbeddedResource>
    <EmbeddedResource Include="GoToForm.resx">
      <DependentUpon>GoToForm.cs</DependentUpon>
    </EmbeddedResource>
    <EmbeddedResource Include="HotkeysEditorForm.resx">
      <DependentUpon>HotkeysEditorForm.cs</DependentUpon>
    </EmbeddedResource>
    <EmbeddedResource Include="ReplaceForm.resx">
      <DependentUpon>ReplaceForm.cs</DependentUpon>
      <SubType>Designer</SubType>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <None Include="FCTB_key.snk" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>

================================================
FILE: FastColoredTextBox/FastColoredTextBox.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
</root>

================================================
FILE: FastColoredTextBox/FastColoredTextBox.xml
================================================
<?xml version="1.0"?>
<doc>
    <assembly>
        <name>FastColoredTextBox</name>
    </assembly>
    <members>
        <member name="T:FastColoredTextBoxNS.AutocompleteItem">
            <summary>
            Item of autocomplete menu
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.AutocompleteItem.GetTextForReplace">
            <summary>
            Returns text for inserting into Textbox
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.AutocompleteItem.Compare(System.String)">
            <summary>
            Compares fragment text with this item
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.AutocompleteItem.ToString">
            <summary>
            Returns text for display into popup menu
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.AutocompleteItem.OnSelected(FastColoredTextBoxNS.AutocompleteMenu,FastColoredTextBoxNS.SelectedEventArgs)">
            <summary>
            This method is called after item inserted into text
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.AutocompleteItem.ToolTipTitle">
            <summary>
            Title for tooltip.
            </summary>
            <remarks>Return null for disable tooltip for this item</remarks>
        </member>
        <member name="P:FastColoredTextBoxNS.AutocompleteItem.ToolTipText">
            <summary>
            Tooltip text.
            </summary>
            <remarks>For display tooltip text, ToolTipTitle must be not null</remarks>
        </member>
        <member name="P:FastColoredTextBoxNS.AutocompleteItem.MenuText">
            <summary>
            Menu text. This text is displayed in the drop-down menu.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.AutocompleteItem.ForeColor">
            <summary>
            Fore color of text of item
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.AutocompleteItem.BackColor">
            <summary>
            Back color of item
            </summary>
        </member>
        <member name="F:FastColoredTextBoxNS.CompareResult.Hidden">
            <summary>
            Item do not appears
            </summary>
        </member>
        <member name="F:FastColoredTextBoxNS.CompareResult.Visible">
            <summary>
            Item appears
            </summary>
        </member>
        <member name="F:FastColoredTextBoxNS.CompareResult.VisibleAndSelected">
            <summary>
            Item appears and will selected
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.SnippetAutocompleteItem">
            <summary>
            Autocomplete item for code snippets
            </summary>
            <remarks>Snippet can contain special char ^ for caret position.</remarks>
        </member>
        <member name="M:FastColoredTextBoxNS.SnippetAutocompleteItem.Compare(System.String)">
            <summary>
            Compares fragment text with this item
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.MethodAutocompleteItem">
            <summary>
            This autocomplete item appears after dot
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.SuggestItem">
            <summary>
            This Item does not check correspondence to current text fragment.
            SuggestItem is intended for dynamic menus.
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.AutocompleteMenu">
            <summary>
            Popup menu for autocomplete
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.AutocompleteMenu.SearchPattern">
            <summary>
            Regex pattern for serach fragment around caret
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.AutocompleteMenu.MinFragmentLength">
            <summary>
            Minimum fragment length for popup
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.AutocompleteMenu.Selecting">
            <summary>
            User selects item
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.AutocompleteMenu.Selected">
            <summary>
            It fires after item inserting
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.AutocompleteMenu.Opening">
            <summary>
            Occurs when popup menu is opening
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.AutocompleteMenu.AllowTabKey">
            <summary>
            Allow TAB for select menu item
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.AutocompleteMenu.AppearInterval">
            <summary>
            Interval of menu appear (ms)
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.AutocompleteMenu.SelectedColor">
            <summary>
            Back color of selected item
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.AutocompleteMenu.HoveredColor">
            <summary>
            Border color of hovered item
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.AutocompleteMenu.Show(System.Boolean)">
            <summary>
            Shows popup menu immediately
            </summary>
            <param name="forced">If True - MinFragmentLength will be ignored</param>
        </member>
        <member name="P:FastColoredTextBoxNS.AutocompleteMenu.MinimumSize">
            <summary>
            Minimal size of menu
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.AutocompleteMenu.ImageList">
            <summary>
            Image list of menu
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.AutocompleteMenu.ToolTipDuration">
            <summary>
            Tooltip duration (ms)
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.AutocompleteMenu.ToolTip">
            <summary>
            Tooltip
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.BaseBookmarks">
            <summary>
            Base class for bookmark collection
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.Bookmarks">
            <summary>
            Collection of bookmarks
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Bookmarks.Remove(System.Int32)">
            <summary>
            Removes bookmark by line index
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Bookmarks.GetBookmark(System.Int32)">
            <summary>
            Returns Bookmark by index.
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.Bookmark">
            <summary>
            Bookmark of FastColoredTextbox
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Bookmark.Name">
            <summary>
            Name of bookmark
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Bookmark.LineIndex">
            <summary>
            Line index
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Bookmark.Color">
            <summary>
            Color of bookmark sign
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Bookmark.DoVisible">
            <summary>
            Scroll textbox to the bookmark
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.Char">
            <summary>
            Char and style
            </summary>
        </member>
        <member name="F:FastColoredTextBoxNS.Char.c">
            <summary>
            Unicode character
            </summary>
        </member>
        <member name="F:FastColoredTextBoxNS.Char.style">
            <summary>
            Style bit mask
            </summary>
            <remarks>Bit 1 in position n means that this char will rendering by FastColoredTextBox.Styles[n]</remarks>
        </member>
        <member name="T:FastColoredTextBoxNS.DocumentMap">
            <summary>
            Shows document map of FCTB
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.DocumentMap.Scale">
            <summary>
            Scale
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.DocumentMap.ScrollbarVisible">
            <summary>
            Scrollbar visibility
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.ExportToHTML">
            <summary>
            Exports colored text as HTML
            </summary>
            <remarks>At this time only TextStyle renderer is supported. Other styles is not exported.</remarks>
        </member>
        <member name="P:FastColoredTextBoxNS.ExportToHTML.UseNbsp">
            <summary>
            Use nbsp; instead space
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.ExportToHTML.UseForwardNbsp">
            <summary>
            Use nbsp; instead space in beginning of line
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.ExportToHTML.UseOriginalFont">
            <summary>
            Use original font
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.ExportToHTML.UseStyleTag">
            <summary>
            Use style tag instead style attribute
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.ExportToHTML.UseBr">
            <summary>
            Use 'br' tag instead of '\n'
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.ExportToHTML.IncludeLineNumbers">
            <summary>
            Includes line numbers
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.ExportToRTF">
            <summary>
            Exports colored text as RTF
            </summary>
            <remarks>At this time only TextStyle renderer is supported. Other styles is not exported.</remarks>
        </member>
        <member name="P:FastColoredTextBoxNS.ExportToRTF.IncludeLineNumbers">
            <summary>
            Includes line numbers
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.ExportToRTF.UseOriginalFont">
            <summary>
            Use original font
            </summary>
        </member>
        <member name="F:FastColoredTextBoxNS.GoToForm.components">
            <summary>
            Required designer variable.
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.GoToForm.Dispose(System.Boolean)">
            <summary>
            Clean up any resources being used.
            </summary>
            <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        </member>
        <member name="M:FastColoredTextBoxNS.GoToForm.InitializeComponent">
            <summary>
            Required method for Designer support - do not modify
            the contents of this method with the code editor.
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.Hints">
            <summary>
            Collection of Hints.
            This is temporary buffer for currently displayed hints.
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Hints.Clear">
            <summary>
            Clears all displayed hints
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Hints.Add(FastColoredTextBoxNS.Hint)">
            <summary>
            Add and shows the hint
            </summary>
            <param name="hint"></param>
        </member>
        <member name="M:FastColoredTextBoxNS.Hints.Contains(FastColoredTextBoxNS.Hint)">
            <summary>
            Is collection contains the hint?
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Hints.Count">
            <summary>
            Count of hints
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.Hint">
            <summary>
            Hint of FastColoredTextbox
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Hint.Text">
            <summary>
            Text of simple hint
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Hint.Range">
            <summary>
            Linked range
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Hint.BackColor">
            <summary>
            Backcolor
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Hint.BackColor2">
            <summary>
            Second backcolor
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Hint.BorderColor">
            <summary>
            Border color
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Hint.ForeColor">
            <summary>
            Fore color
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Hint.TextAlignment">
            <summary>
            Text alignment
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Hint.Font">
            <summary>
            Font
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.Hint.Click">
            <summary>
            Occurs when user click on simple hint
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Hint.InnerControl">
            <summary>
            Inner control
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Hint.Dock">
            <summary>
            Docking (allows None and Fill only)
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Hint.Width">
            <summary>
            Width of hint (if Dock is None)
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Hint.Height">
            <summary>
            Height of hint
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Hint.HostPanel">
            <summary>
            Host panel
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Hint.Tag">
            <summary>
            Tag
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Hint.Cursor">
            <summary>
            Cursor
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Hint.Inline">
            <summary>
            Inlining. If True then hint will moves apart text.
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Hint.DoVisible">
            <summary>
            Scroll textbox to the hint
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Hint.#ctor(FastColoredTextBoxNS.Range,System.String,System.Boolean,System.Boolean)">
            <summary>
            Creates Hint
            </summary>
            <param name="range">Linked range</param>
            <param name="text">Text for simple hint</param>
            <param name="inline">Inlining. If True then hint will moves apart text</param>
            <param name="dock">Docking. If True then hint will fill whole line</param>
        </member>
        <member name="M:FastColoredTextBoxNS.Hint.#ctor(FastColoredTextBoxNS.Range,System.String)">
            <summary>
            Creates Hint
            </summary>
            <param name="range">Linked range</param>
            <param name="text">Text for simple hint</param>
        </member>
        <member name="M:FastColoredTextBoxNS.Hint.#ctor(FastColoredTextBoxNS.Range,System.Windows.Forms.Control,System.Boolean,System.Boolean)">
            <summary>
            Creates Hint
            </summary>
            <param name="range">Linked range</param>
            <param name="innerControl">Inner control</param>
            <param name="inline">Inlining. If True then hint will moves apart text</param>
            <param name="dock">Docking. If True then hint will fill whole line</param>
        </member>
        <member name="M:FastColoredTextBoxNS.Hint.#ctor(FastColoredTextBoxNS.Range,System.Windows.Forms.Control)">
            <summary>
            Creates Hint
            </summary>
            <param name="range">Linked range</param>
            <param name="innerControl">Inner control</param>
        </member>
        <member name="M:FastColoredTextBoxNS.HotkeysEditorForm.GetHotkeys">
            <summary>
            Returns edited hotkey map
            </summary>
            <returns></returns>
        </member>
        <member name="F:FastColoredTextBoxNS.HotkeysEditorForm.components">
            <summary>
            Required designer variable.
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.HotkeysEditorForm.Dispose(System.Boolean)">
            <summary>
            Clean up any resources being used.
            </summary>
            <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        </member>
        <member name="M:FastColoredTextBoxNS.HotkeysEditorForm.InitializeComponent">
            <summary>
            Required method for Designer support - do not modify
            the contents of this method with the code editor.
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.MacrosManager">
            <summary>
            This class records, stores and executes the macros.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.MacrosManager.AllowMacroRecordingByUser">
            <summary>
            Allows to user to record macros
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.MacrosManager.IsRecording">
            <summary>
            Returns current recording state. Set to True/False to start/stop recording programmatically.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.MacrosManager.UnderlayingControl">
            <summary>
            FCTB
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.MacrosManager.ExecuteMacros">
            <summary>
            Executes recorded macro
            </summary>
            <returns></returns>
        </member>
        <member name="M:FastColoredTextBoxNS.MacrosManager.AddCharToMacros(System.Char,System.Windows.Forms.Keys)">
            <summary>
            Adds the char to current macro
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.MacrosManager.AddKeyToMacros(System.Windows.Forms.Keys)">
            <summary>
            Adds keyboard key to current macro
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.MacrosManager.ClearMacros">
            <summary>
            Clears last recorded macro
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.MacrosManager.MacroIsEmpty">
            <summary>
            Returns True if last macro is empty
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.MacrosManager.Macros">
            <summary>
            Macros as string.
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.HotkeysMapping">
            <summary>
            Dictionary of shortcuts for FCTB
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.FCTBAction">
            <summary>
            Actions for shortcuts
            </summary>
        </member>
        <member name="F:FastColoredTextBoxNS.Ruler.components">
            <summary> 
            Required designer variable.
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Ruler.Dispose(System.Boolean)">
            <summary> 
            Clean up any resources being used.
            </summary>
            <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        </member>
        <member name="M:FastColoredTextBoxNS.Ruler.InitializeComponent">
            <summary> 
            Required method for Designer support - do not modify 
            the contents of this method with the code editor.
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.SyntaxHighlighter.HighlightSyntax(FastColoredTextBoxNS.Language,FastColoredTextBoxNS.Range)">
            <summary>
            Highlights syntax for given language
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.SyntaxHighlighter.HighlightSyntax(System.String,FastColoredTextBoxNS.Range)">
            <summary>
            Highlights syntax for given XML description file
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.SyntaxHighlighter.CSharpSyntaxHighlight(FastColoredTextBoxNS.Range)">
            <summary>
            Highlights C# code
            </summary>
            <param name="range"></param>
        </member>
        <member name="M:FastColoredTextBoxNS.SyntaxHighlighter.VBSyntaxHighlight(FastColoredTextBoxNS.Range)">
            <summary>
            Highlights VB code
            </summary>
            <param name="range"></param>
        </member>
        <member name="M:FastColoredTextBoxNS.SyntaxHighlighter.HTMLSyntaxHighlight(FastColoredTextBoxNS.Range)">
            <summary>
            Highlights HTML code
            </summary>
            <param name="range"></param>
        </member>
        <member name="M:FastColoredTextBoxNS.SyntaxHighlighter.XMLSyntaxHighlight(FastColoredTextBoxNS.Range)">
            <summary>
            Highlights XML code
            </summary>
            <param name="range"></param>
        </member>
        <member name="M:FastColoredTextBoxNS.SyntaxHighlighter.SQLSyntaxHighlight(FastColoredTextBoxNS.Range)">
            <summary>
            Highlights SQL code
            </summary>
            <param name="range"></param>
        </member>
        <member name="M:FastColoredTextBoxNS.SyntaxHighlighter.PHPSyntaxHighlight(FastColoredTextBoxNS.Range)">
            <summary>
            Highlights PHP code
            </summary>
            <param name="range"></param>
        </member>
        <member name="M:FastColoredTextBoxNS.SyntaxHighlighter.JScriptSyntaxHighlight(FastColoredTextBoxNS.Range)">
            <summary>
            Highlights JavaScript code
            </summary>
            <param name="range"></param>
        </member>
        <member name="M:FastColoredTextBoxNS.SyntaxHighlighter.LuaSyntaxHighlight(FastColoredTextBoxNS.Range)">
            <summary>
            Highlights Lua code
            </summary>
            <param name="range"></param>
        </member>
        <member name="P:FastColoredTextBoxNS.SyntaxHighlighter.StringStyle">
            <summary>
            String style
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.SyntaxHighlighter.CommentStyle">
            <summary>
            Comment style
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.SyntaxHighlighter.NumberStyle">
            <summary>
            Number style
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.SyntaxHighlighter.AttributeStyle">
            <summary>
            C# attribute style
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.SyntaxHighlighter.ClassNameStyle">
            <summary>
            Class name style
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.SyntaxHighlighter.KeywordStyle">
            <summary>
            Keyword style
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.SyntaxHighlighter.CommentTagStyle">
            <summary>
            Style of tags in comments of C#
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.SyntaxHighlighter.AttributeValueStyle">
            <summary>
            HTML attribute value style
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.SyntaxHighlighter.TagBracketStyle">
            <summary>
            HTML tag brackets style
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.SyntaxHighlighter.TagNameStyle">
            <summary>
            HTML tag name style
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.SyntaxHighlighter.HtmlEntityStyle">
            <summary>
            HTML Entity style
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.SyntaxHighlighter.XmlAttributeStyle">
            <summary>
            XML attribute style
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.SyntaxHighlighter.XmlAttributeValueStyle">
            <summary>
            XML attribute value style
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.SyntaxHighlighter.XmlTagBracketStyle">
            <summary>
            XML tag brackets style
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.SyntaxHighlighter.XmlTagNameStyle">
            <summary>
            XML tag name style
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.SyntaxHighlighter.XmlEntityStyle">
            <summary>
            XML Entity style
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.SyntaxHighlighter.XmlCDataStyle">
            <summary>
            XML CData style
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.SyntaxHighlighter.VariableStyle">
            <summary>
            Variable style
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.SyntaxHighlighter.KeywordStyle2">
            <summary>
            Specific PHP keyword style
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.SyntaxHighlighter.KeywordStyle3">
            <summary>
            Specific PHP keyword style
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.SyntaxHighlighter.StatementsStyle">
            <summary>
            SQL Statements style
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.SyntaxHighlighter.FunctionsStyle">
            <summary>
            SQL Functions style
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.SyntaxHighlighter.TypesStyle">
            <summary>
            SQL Types style
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.Language">
            <summary>
            Language
            </summary>
        </member>
        <member name="F:FastColoredTextBoxNS.ReplaceForm.components">
            <summary>
            Required designer variable.
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.ReplaceForm.Dispose(System.Boolean)">
            <summary>
            Clean up any resources being used.
            </summary>
            <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        </member>
        <member name="M:FastColoredTextBoxNS.ReplaceForm.InitializeComponent">
            <summary>
            Required method for Designer support - do not modify
            the contents of this method with the code editor.
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.FastColoredTextBox">
            <summary>
            Fast colored textbox
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.#ctor">
            <summary>
            Constructor
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.AutoCompleteBrackets">
            <summary>
            AutoComplete brackets
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.ServiceColors">
            <summary>
            Colors of some service visual markers
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.FoldedBlocks">
            <summary>
            Contains UniqueId of start lines of folded blocks
            </summary>
            <remarks>This dictionary remembers folding state of blocks.
            It is needed to restore child folding after user collapsed/expanded top-level folding block.</remarks>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.BracketsHighlightStrategy">
            <summary>
            Strategy of search of brackets to highlighting
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.WordWrapAutoIndent">
            <summary>
            Automatically shifts secondary wordwrap lines on the shift amount of the first line
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.WordWrapIndent">
            <summary>
            Indent of secondary wordwrap lines (in chars)
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.MacrosManager">
            <summary>
            MacrosManager records, stores and executes the macroses
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.AllowDrop">
            <summary>
            Allows drag and drop
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.Hints">
            <summary>
            Collection of Hints.
            This is temporary buffer for currently displayed hints.
            </summary>
            <remarks>You can asynchronously add, remove and clear hints. Appropriate hints will be shown or hidden from the screen.</remarks>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.ToolTipDelay">
            <summary>
            Delay (ms) of ToolTip
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.ToolTip">
            <summary>
            ToolTip component
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.BookmarkColor">
            <summary>
            Color of bookmarks
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.Bookmarks">
            <summary>
            Bookmarks
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.VirtualSpace">
            <summary>
            Enables virtual spaces
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.FindEndOfFoldingBlockStrategy">
            <summary>
            Strategy of search of end of folding block
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.AcceptsTab">
            <summary>
            Indicates if tab characters are accepted as input
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.AcceptsReturn">
            <summary>
            Indicates if return characters are accepted as input
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.CaretVisible">
            <summary>
            Shows or hides the caret
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.CaretBlinking">
            <summary>
            Enables caret blinking
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.TextAreaBorderColor">
            <summary>
            Color of border of text area
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.TextAreaBorder">
            <summary>
            Type of border of text area
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.CurrentLineColor">
            <summary>
            Background color for current line
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.ChangedLineColor">
            <summary>
            Background color for highlighting of changed lines
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.ForeColor">
            <summary>
            Fore color (default style color)
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.CharHeight">
            <summary>
            Height of char in pixels (includes LineInterval)
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.LineInterval">
            <summary>
            Interval between lines (in pixels)
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.CharWidth">
            <summary>
            Width of char in pixels
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.TabLength">
            <summary>
            Spaces count for tab
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.IsChanged">
            <summary>
            Text was changed
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.TextVersion">
            <summary>
            Text version
            </summary>
            <remarks>This counter is incremented each time changes the text</remarks>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.ReadOnly">
            <summary>
            Read only
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.ShowLineNumbers">
            <summary>
            Shows line numbers.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.ShowFoldingLines">
            <summary>
            Shows vertical lines between folding start line and folding end line.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.TextAreaRect">
            <summary>
            Rectangle where located text
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.LineNumberColor">
            <summary>
            Color of line numbers.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.LineNumberStartValue">
            <summary>
            Start value of first line number.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.IndentBackColor">
            <summary>
            Background color of indent area
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.PaddingBackColor">
            <summary>
            Background color of padding area
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.DisabledColor">
            <summary>
            Color of disabled component
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.CaretColor">
            <summary>
            Color of caret
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.WideCaret">
            <summary>
            Wide caret
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.ServiceLinesColor">
            <summary>
            Color of service lines (folding lines, borders of blocks etc.)
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.Paddings">
            <summary>
            Padings of text area
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.Padding">
            <summary>
            --Do not use this property--
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.FoldingIndicatorColor">
            <summary>
            Color of folding area indicator
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.HighlightFoldingIndicator">
            <summary>
            Enables folding indicator (left vertical line between folding bounds)
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.LeftIndent">
            <summary>
            Left distance to text beginning
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.LeftPadding">
            <summary>
            Left padding in pixels
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.PreferredLineWidth">
            <summary>
            This property draws vertical line after defined char position.
            Set to 0 for disable drawing of vertical line.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.Styles">
            <summary>
            Styles
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.Hotkeys">
            <summary>
            Hotkeys. Do not use this property in your code, use HotkeysMapping property.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.HotkeysMapping">
            <summary>
            Hotkeys mapping
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.DefaultStyle">
            <summary>
            Default text style
            This style is using when no one other TextStyle is not defined in Char.style
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.SelectionStyle">
            <summary>
            Style for rendering Selection area
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.FoldedBlockStyle">
            <summary>
            Style for folded block rendering
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.BracketsStyle">
            <summary>
            Style for brackets highlighting
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.BracketsStyle2">
            <summary>
            Style for alternative brackets highlighting
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.LeftBracket">
            <summary>
            Opening bracket for brackets highlighting.
            Set to '\x0' for disable brackets highlighting.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.RightBracket">
            <summary>
            Closing bracket for brackets highlighting.
            Set to '\x0' for disable brackets highlighting.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.LeftBracket2">
            <summary>
            Alternative opening bracket for brackets highlighting.
            Set to '\x0' for disable brackets highlighting.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.RightBracket2">
            <summary>
            Alternative closing bracket for brackets highlighting.
            Set to '\x0' for disable brackets highlighting.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.CommentPrefix">
            <summary>
            Comment line prefix.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.HighlightingRangeType">
            <summary>
            This property specifies which part of the text will be highlighted as you type (by built-in highlighter).
            </summary>
            <remarks>When a user enters text, a component refreshes highlighting (because the text was changed).
            This property specifies exactly which section of the text will be re-highlighted.
            This can be useful to highlight multi-line comments, for example.</remarks>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.IsReplaceMode">
            <summary>
            Is keyboard in replace mode (wide caret) ?
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.AllowSeveralTextStyleDrawing">
            <summary>
            Allows text rendering several styles same time.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.AllowMacroRecording">
            <summary>
            Allows to record macros.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.AutoIndent">
            <summary>
            Allows AutoIndent. Inserts spaces before new line.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.AutoIndentExistingLines">
            <summary>
            Does autoindenting in existing lines. It works only if AutoIndent is True.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.DelayedEventsInterval">
            <summary>
            Minimal delay(ms) for delayed events (except TextChangedDelayed).
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.DelayedTextChangedInterval">
            <summary>
            Minimal delay(ms) for TextChangedDelayed event.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.Language">
            <summary>
            Language for highlighting by built-in highlighter.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.SyntaxHighlighter">
            <summary>
            Syntax Highlighter
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.DescriptionFile">
            <summary>
            XML file with description of syntax highlighting.
            This property works only with Language == Language.Custom.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.LeftBracketPosition">
            <summary>
            Position of left highlighted bracket.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.RightBracketPosition">
            <summary>
            Position of right highlighted bracket.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.LeftBracketPosition2">
            <summary>
            Position of left highlighted alternative bracket.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.RightBracketPosition2">
            <summary>
            Position of right highlighted alternative bracket.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.StartFoldingLine">
            <summary>
            Start line index of current highlighted folding area. Return -1 if start of area is not found.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.EndFoldingLine">
            <summary>
            End line index of current highlighted folding area. Return -1 if end of area is not found.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.TextSource">
            <summary>
            TextSource
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.SourceTextBox">
            <summary>
            The source of the text.
            Allows to get text from other FastColoredTextBox.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.VisibleRange">
            <summary>
            Returns current visible range of text
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.Selection">
            <summary>
            Current selection range
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.BackColor">
            <summary>
            Background color.
            It is used if BackBrush is null.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.BackBrush">
            <summary>
            Background brush.
            If Null then BackColor is used.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.Multiline">
            <summary>
            Multiline
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.WordWrap">
            <summary>
            WordWrap.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.WordWrapMode">
            <summary>
            WordWrap mode.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.SelectionHighlightingForLineBreaksEnabled">
            <summary>
            If <c>true</c> then line breaks included into the selection will be selected too.
            Then line breaks will be shown as selected blank character.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.AutoScroll">
            <summary>
            Do not change this property
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.LinesCount">
            <summary>
            Count of lines
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.Item(FastColoredTextBoxNS.Place)">
            <summary>
            Gets or sets char and styleId for given place
            This property does not fire OnTextChanged event
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.Item(System.Int32)">
            <summary>
            Gets Line
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.Text">
            <summary>
            Text of control
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.Lines">
            <summary>
            Text lines
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.Html">
            <summary>
            Gets colored text as HTML
            </summary>
            <remarks>For more flexibility you can use ExportToHTML class also</remarks>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.Rtf">
            <summary>
            Gets colored text as RTF
            </summary>
            <remarks>For more flexibility you can use ExportToRTF class also</remarks>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.SelectedText">
            <summary>
            Text of current selection
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.SelectionStart">
            <summary>
            Start position of selection
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.SelectionLength">
            <summary>
            Length of selected text
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.Font">
            <summary>
            Font
            </summary>
            <remarks>Use only monospaced font</remarks>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.BaseFont">
            <summary>
            Font
            </summary>
            <remarks>Use only monospaced font</remarks>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.ImeAllowed">
            <summary>
            Indicates that IME is allowed (for CJK language entering)
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.UndoEnabled">
            <summary>
            Is undo enabled?
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.RedoEnabled">
            <summary>
            Is redo enabled?
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.Range">
            <summary>
            Range of all text
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.SelectionColor">
            <summary>
            Color of selected area
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.ReservedCountOfLineNumberChars">
            <summary>
            Reserved space for line number characters.
            If smaller than needed (e. g. line count >= 10 and this value set to 1) this value will have no impact.
            If you want to reserve space, e. g. for line numbers >= 10 or >= 100 than you can set this value to 2 or 3 or higher.
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.FastColoredTextBox.ToolTipNeeded">
            <summary>
            Occurs when mouse is moving over text and tooltip is needed
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.ClearHints">
            <summary>
            Removes all hints
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.AddHint(FastColoredTextBoxNS.Range,System.Windows.Forms.Control,System.Boolean,System.Boolean,System.Boolean)">
            <summary>
            Add and shows the hint
            </summary>
            <param name="range">Linked range</param>
            <param name="innerControl">Inner control</param>
            <param name="scrollToHint">Scrolls textbox to the hint</param>
            <param name="inline">Inlining. If True then hint will moves apart text</param>
            <param name="dock">Docking. If True then hint will fill whole line</param>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.AddHint(FastColoredTextBoxNS.Range,System.Windows.Forms.Control)">
            <summary>
            Add and shows the hint
            </summary>
            <param name="range">Linked range</param>
            <param name="innerControl">Inner control</param>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.AddHint(FastColoredTextBoxNS.Range,System.String,System.Boolean,System.Boolean,System.Boolean)">
            <summary>
            Add and shows simple text hint
            </summary>
            <param name="range">Linked range</param>
            <param name="text">Text of simple hint</param>
            <param name="scrollToHint">Scrolls textbox to the hint</param>
            <param name="inline">Inlining. If True then hint will moves apart text</param>
            <param name="dock">Docking. If True then hint will fill whole line</param>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.AddHint(FastColoredTextBoxNS.Range,System.String)">
            <summary>
            Add and shows simple text hint
            </summary>
            <param name="range">Linked range</param>
            <param name="text">Text of simple hint</param>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.OnHintClick(FastColoredTextBoxNS.Hint)">
            <summary>
            Occurs when user click on the hint
            </summary>
            <param name="hint"></param>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.OnVisibleRangeChanged">
            <summary>
            Occurs when VisibleRange is changed
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.Invalidate">
            <summary>
            Invalidates the entire surface of the control and causes the control to be redrawn.
            This method is thread safe and does not require Invoke.
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.FastColoredTextBox.HintClick">
            <summary>
            HintClick event.
            It occurs if user click on the hint.
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.FastColoredTextBox.TextChanged">
            <summary>
            TextChanged event.
            It occurs after insert, delete, clear, undo and redo operations.
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.FastColoredTextBox.BindingTextChanged">
            <summary>
            Fake event for correct data binding
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.FastColoredTextBox.Pasting">
            <summary>
            Occurs when user paste text from clipboard
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.FastColoredTextBox.TextChanging">
            <summary>
            TextChanging event.
            It occurs before insert, delete, clear, undo and redo operations.
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.FastColoredTextBox.SelectionChanged">
            <summary>
            SelectionChanged event.
            It occurs after changing of selection.
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.FastColoredTextBox.VisibleRangeChanged">
            <summary>
            VisibleRangeChanged event.
            It occurs after changing of visible range.
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.FastColoredTextBox.TextChangedDelayed">
            <summary>
            TextChangedDelayed event. 
            It occurs after insert, delete, clear, undo and redo operations. 
            This event occurs with a delay relative to TextChanged, and fires only once.
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.FastColoredTextBox.SelectionChangedDelayed">
            <summary>
            SelectionChangedDelayed event.
            It occurs after changing of selection.
            This event occurs with a delay relative to SelectionChanged, and fires only once.
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.FastColoredTextBox.VisibleRangeChangedDelayed">
            <summary>
            VisibleRangeChangedDelayed event.
            It occurs after changing of visible range.
            This event occurs with a delay relative to VisibleRangeChanged, and fires only once.
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.FastColoredTextBox.VisualMarkerClick">
            <summary>
            It occurs when user click on VisualMarker.
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.FastColoredTextBox.KeyPressing">
            <summary>
            It occurs when visible char is enetering (alphabetic, digit, punctuation, DEL, BACKSPACE)
            </summary>
            <remarks>Set Handle to True for cancel key</remarks>
        </member>
        <member name="E:FastColoredTextBoxNS.FastColoredTextBox.KeyPressed">
            <summary>
            It occurs when visible char is enetered (alphabetic, digit, punctuation, DEL, BACKSPACE)
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.FastColoredTextBox.AutoIndentNeeded">
            <summary>
            It occurs when calculates AutoIndent for new line
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.FastColoredTextBox.PaintLine">
            <summary>
            It occurs when line background is painting
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.FastColoredTextBox.LineInserted">
            <summary>
            Occurs when line was inserted/added
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.FastColoredTextBox.LineRemoved">
            <summary>
            Occurs when line was removed
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.FastColoredTextBox.FoldingHighlightChanged">
            <summary>
            Occurs when current highlighted folding area is changed.
            Current folding area see in StartFoldingLine and EndFoldingLine.
            </summary>
            <remarks></remarks>
        </member>
        <member name="E:FastColoredTextBoxNS.FastColoredTextBox.UndoRedoStateChanged">
            <summary>
            Occurs when undo/redo stack is changed
            </summary>
            <remarks></remarks>
        </member>
        <member name="E:FastColoredTextBoxNS.FastColoredTextBox.ZoomChanged">
            <summary>
            Occurs when component was zoomed
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.FastColoredTextBox.CustomAction">
            <summary>
            Occurs when user pressed key, that specified as CustomAction
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.FastColoredTextBox.ScrollbarsUpdated">
            <summary>
            Occurs when scroolbars are updated
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.FastColoredTextBox.WordWrapNeeded">
            <summary>
            Occurs when custom wordwrap is needed
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.GetStylesOfChar(FastColoredTextBoxNS.Place)">
            <summary>
            Returns list of styles of given place
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.NeedRecalc">
            <summary>
            Call this method if the recalc of the position of lines is needed.
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.NeedRecalc(System.Boolean)">
            <summary>
            Call this method if the recalc of the position of lines is needed.
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.NeedRecalc(System.Boolean,System.Boolean)">
            <summary>
            Call this method if the recalc of the position of lines is needed.
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.NavigateForward">
            <summary>
            Navigates forward (by Line.LastVisit property)
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.NavigateBackward">
            <summary>
            Navigates backward (by Line.LastVisit property)
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.Navigate(System.Int32)">
            <summary>
            Navigates to defined line, without Line.LastVisit reseting
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.AddStyle(FastColoredTextBoxNS.Style)">
            <summary>
            Add new style
            </summary>
            <returns>Layer index of this style</returns>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.ShowFindDialog">
            <summary>
            Shows find dialog
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.ShowFindDialog(System.String)">
            <summary>
            Shows find dialog
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.ShowReplaceDialog">
            <summary>
            Shows replace dialog
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.ShowReplaceDialog(System.String)">
            <summary>
            Shows replace dialog
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.GetLineLength(System.Int32)">
            <summary>
            Gets length of given line
            </summary>
            <param name="iLine">Line index</param>
            <returns>Length of line</returns>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.GetLine(System.Int32)">
            <summary>
            Get range of line
            </summary>
            <param name="iLine">Line index</param>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.Copy">
            <summary>
            Copy selected text into Clipboard
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.Cut">
            <summary>
            Cut selected text into Clipboard
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.Paste">
            <summary>
            Paste text from clipboard into selected position
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.SelectAll">
            <summary>
            Select all chars of text
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.GoEnd">
            <summary>
            Move caret to end of text
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.GoHome">
            <summary>
            Move caret to first position
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.Clear">
            <summary>
            Clear text, styles, history, caches
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.ClearStylesBuffer">
            <summary>
            Clear buffer of styles
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.ClearStyle(FastColoredTextBoxNS.StyleIndex)">
            <summary>
            Clear style of all text
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.ClearUndo">
            <summary>
            Clears undo and redo stacks
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.InsertText(System.String)">
            <summary>
            Insert text into current selected position
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.InsertText(System.String,System.Boolean)">
            <summary>
            Insert text into current selected position
            </summary>
            <param name="text"></param>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.InsertText(System.String,FastColoredTextBoxNS.Style)">
            <summary>
            Insert text into current selection position (with predefined style)
            </summary>
            <param name="text"></param>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.InsertText(System.String,FastColoredTextBoxNS.Style,System.Boolean)">
            <summary>
            Insert text into current selection position (with predefined style)
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.AppendText(System.String)">
            <summary>
            Append string to end of the Text
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.AppendText(System.String,FastColoredTextBoxNS.Style)">
            <summary>
            Append string to end of the Text
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.GetStyleIndex(FastColoredTextBoxNS.Style)">
            <summary>
            Returns index of the style in Styles
            -1 otherwise
            </summary>
            <param name="style"></param>
            <returns>Index of the style in Styles</returns>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.GetStyleIndexMask(FastColoredTextBoxNS.Style[])">
            <summary>
            Returns StyleIndex mask of given styles
            </summary>
            <param name="styles"></param>
            <returns>StyleIndex mask of given styles</returns>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.ClearSelected">
            <summary>
            Deletes selected chars
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.ClearCurrentLine">
            <summary>
            Deletes current line(s)
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.CalcCutOffs(System.Collections.Generic.List{System.Int32},System.Int32,System.Int32,System.Boolean,System.Boolean,FastColoredTextBoxNS.Line)">
            <summary>
            Calculates wordwrap cutoffs
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.DoVisibleRectangle(System.Drawing.Rectangle)">
            <summary>
            Scroll control for display defined rectangle
            </summary>
            <param name="rect"></param>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.UpdateScrollbars">
            <summary>
            Updates scrollbar position after Value changed
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.DoCaretVisible">
            <summary>
            Scroll control for display caret
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.ScrollLeft">
            <summary>
            Scroll control left
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.DoSelectionVisible">
            <summary>
            Scroll control for display selection area
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.DoRangeVisible(FastColoredTextBoxNS.Range)">
            <summary>
            Scroll control for display given range
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.DoRangeVisible(FastColoredTextBoxNS.Range,System.Boolean)">
            <summary>
            Scroll control for display given range
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.ProcessKey(System.Windows.Forms.Keys)">
            <summary>
            Process control keys
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.GotoNextBookmark(System.Int32)">
            <summary>
            Scrolls to nearest bookmark or to first bookmark
            </summary>
            <param name="iLine">Current bookmark line index</param>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.GotoPrevBookmark(System.Int32)">
            <summary>
            Scrolls to nearest previous bookmark or to last bookmark
            </summary>
            <param name="iLine">Current bookmark line index</param>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.BookmarkLine(System.Int32)">
            <summary>
            Bookmarks line
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.UnbookmarkLine(System.Int32)">
            <summary>
            Unbookmarks current line
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.MoveSelectedLinesDown">
            <summary>
            Moves selected lines down
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.MoveSelectedLinesUp">
            <summary>
            Moves selected lines up
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.UpperCase">
            <summary>
            Convert selected text to upper case
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.LowerCase">
            <summary>
            Convert selected text to lower case
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.TitleCase">
            <summary>
            Convert selected text to title case
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.CommentSelected">
            <summary>
            Insert/remove comment prefix into selected lines
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.CommentSelected(System.String)">
            <summary>
            Insert/remove comment prefix into selected lines
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.ProcessKey(System.Char,System.Windows.Forms.Keys)">
            <summary>
            Process "real" keys (no control)
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.AutoIndentChars">
            <summary>
            Enables AutoIndentChars mode
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.AutoIndentCharsPatterns">
            <summary>
            Regex patterns for AutoIndentChars (one regex per line)
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.DoAutoIndentChars(System.Int32)">
            <summary>
            Do AutoIndentChars
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.FindChar(System.Char)">
            <summary>
            Finds given char after current caret position, moves the caret to found pos.
            </summary>
            <param name="c"></param>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.DoAutoIndent(System.Int32)">
            <summary>
            Inserts autoindent's spaces in the line
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.CalcAutoIndent(System.Int32)">
            <summary>
            Returns needed start space count for the line
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.Undo">
            <summary>
            Undo last operation
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.Redo">
            <summary>
            Redo
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.DrawText(System.Drawing.Graphics,FastColoredTextBoxNS.Place,System.Drawing.Size)">
            <summary>
            Draws text to given Graphics
            </summary>
            <param name="gr"></param>
            <param name="start">Start place of drawing text</param>
            <param name="size">Size of drawing</param>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.OnPaint(System.Windows.Forms.PaintEventArgs)">
            <summary>
            Draw control
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.GetControlPanelWheelScrollLinesValue">
            <summary>
            Gets the value for the system control panel mouse wheel scroll settings.
            The value returns the number of lines that shall be scolled if the user turns the mouse wheet one step.
            </summary>
            <remarks>
            This methods gets the "WheelScrollLines" value our from the registry key "HKEY_CURRENT_USER\Control Panel\Desktop".
            If the value of this option is 0, the screen will not scroll when the mouse wheel is turned.
            If the value of this option is -1 or is greater than the number of lines visible in the window,
            the screen will scroll up or down by one page.
            </remarks>
            <returns>
            Number of lines to scrol l when the mouse wheel is turned
            </returns>
        </member>
        <member name="P:FastColoredTextBoxNS.FastColoredTextBox.Zoom">
            <summary>
            Zooming (in percentages)
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.PointToPlace(System.Drawing.Point)">
            <summary>
            Gets nearest line and char position from coordinates
            </summary>
            <param name="point">Point</param>
            <returns>Line and char position</returns>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.PointToPosition(System.Drawing.Point)">
            <summary>
            Gets nearest absolute text position for given point
            </summary>
            <param name="point">Point</param>
            <returns>Position</returns>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.OnTextChanging(System.String@)">
            <summary>
            Fires TextChanging event
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.OnTextChanged">
            <summary>
            Fires TextChanged event
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.OnTextChanged(System.Int32,System.Int32)">
            <summary>
            Fires TextChanged event
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.OnTextChanged(FastColoredTextBoxNS.Range)">
            <summary>
            Fires TextChanged event
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.BeginUpdate">
            <summary>
            Call this method before multiple text changing
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.EndUpdate">
            <summary>
            Call this method after multiple text changing
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.OnTextChanged(FastColoredTextBoxNS.TextChangedEventArgs)">
            <summary>
            Fires TextChanged event
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.ClearFoldingState(FastColoredTextBoxNS.Range)">
            <summary>
            Clears folding state for range of text
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.OnSelectionChanged">
            <summary>
            Fires SelectionChanged event
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.PlaceToPosition(FastColoredTextBoxNS.Place)">
            <summary>
            Gets absolute text position from line and char position
            </summary>
            <param name="point">Line and char position</param>
            <returns>Point of char</returns>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.PositionToPlace(System.Int32)">
            <summary>
            Gets line and char position from absolute text position
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.PositionToPoint(System.Int32)">
            <summary>
            Gets absolute char position from char position
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.PlaceToPoint(FastColoredTextBoxNS.Place)">
            <summary>
            Gets point for given line and char position
            </summary>
            <param name="place">Line and char position</param>
            <returns>Coordiantes</returns>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.GetRange(System.Int32,System.Int32)">
            <summary>
            Get range of text
            </summary>
            <param name="fromPos">Absolute start position</param>
            <param name="toPos">Absolute finish position</param>
            <returns>Range</returns>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.GetRange(FastColoredTextBoxNS.Place,FastColoredTextBoxNS.Place)">
            <summary>
            Get range of text
            </summary>
            <param name="fromPlace">Line and char position</param>
            <param name="toPlace">Line and char position</param>
            <returns>Range</returns>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.GetRanges(System.String)">
            <summary>
            Finds ranges for given regex pattern
            </summary>
            <param name="regexPattern">Regex pattern</param>
            <returns>Enumeration of ranges</returns>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.GetRanges(System.String,System.Text.RegularExpressions.RegexOptions)">
            <summary>
            Finds ranges for given regex pattern
            </summary>
            <param name="regexPattern">Regex pattern</param>
            <returns>Enumeration of ranges</returns>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.GetLineText(System.Int32)">
            <summary>
            Get text of given line
            </summary>
            <param name="iLine">Line index</param>
            <returns>Text</returns>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.ExpandFoldedBlock(System.Int32)">
            <summary>
            Exapnds folded block
            </summary>
            <param name="iLine">Start line</param>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.AdjustFolding">
            <summary>
            Collapse folding blocks using FoldedBlocks dictionary.
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.ExpandBlock(System.Int32,System.Int32)">
            <summary>
            Expand collapsed block
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.ExpandBlock(System.Int32)">
            <summary>
            Expand collapsed block
            </summary>
            <param name="iLine">Any line inside collapsed block</param>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.CollapseAllFoldingBlocks">
            <summary>
            Collapses all folding blocks
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.ExpandAllFoldingBlocks">
            <summary>
            Exapnds all folded blocks
            </summary>
            <param name="iLine"></param>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.CollapseFoldingBlock(System.Int32)">
            <summary>
            Collapses folding block
            </summary>
            <param name="iLine">Start folding line</param>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.GetLineFoldingStartMarker(System.Int32)">
            <summary>
            Start foilding marker for the line
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.GetLineFoldingEndMarker(System.Int32)">
            <summary>
            End foilding marker for the line
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.CollapseBlock(System.Int32,System.Int32)">
            <summary>
            Collapse text block
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.IncreaseIndent">
            <summary>
            Insert TAB into front of seletcted lines.
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.DecreaseIndent">
            <summary>
            Remove TAB from front of seletcted lines.
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.DecreaseIndentOfSingleLine">
            <summary>
            Remove TAB in front of the caret ot the selected line.
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.DoAutoIndent">
            <summary>
            Insert autoindents into selected lines
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.InsertLinePrefix(System.String)">
            <summary>
            Insert prefix into front of seletcted lines
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.RemoveLinePrefix(System.String)">
            <summary>
            Remove prefix from front of selected lines
            This method ignores forward spaces of the line
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.BeginAutoUndo">
            <summary>
            Begins AutoUndo block.
            All changes of text between BeginAutoUndo() and EndAutoUndo() will be canceled in one operation Undo.
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.EndAutoUndo">
            <summary>
            Ends AutoUndo block.
            All changes of text between BeginAutoUndo() and EndAutoUndo() will be canceled in one operation Undo.
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.HighlightBrackets(System.Char,System.Char,FastColoredTextBoxNS.Range@,FastColoredTextBoxNS.Range@)">
            <summary>
            Highlights brackets around caret
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.GetBracketsRange(FastColoredTextBoxNS.Place,System.Char,System.Char)">
            <summary>
            Returns range between brackets (or null if not found)
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.SelectNext(System.String,System.Boolean,System.Text.RegularExpressions.RegexOptions)">
            <summary>
            Selectes next fragment for given regex.
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.Print(FastColoredTextBoxNS.Range,FastColoredTextBoxNS.PrintDialogSettings)">
            <summary>
            Prints range of text
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.Print(FastColoredTextBoxNS.PrintDialogSettings)">
            <summary>
            Prints all text
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.Print">
            <summary>
            Prints all text, without any dialog windows
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.OpenFile(System.String,System.Text.Encoding)">
            <summary>
            Open text file
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.OpenFile(System.String)">
            <summary>
            Open text file (with automatic encoding detector)
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.OpenBindingFile(System.String,System.Text.Encoding)">
            <summary>
            Open file binding mode
            </summary>
            <param name="fileName"></param>
            <param name="enc"></param>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.CloseBindingFile">
            <summary>
            Close file binding mode
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.SaveToFile(System.String,System.Text.Encoding)">
            <summary>
            Save text to the file
            </summary>
            <param name="fileName"></param>
            <param name="enc"></param>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.SetVisibleState(System.Int32,FastColoredTextBoxNS.VisibleState)">
            <summary>
            Set VisibleState of line
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.GetVisibleState(System.Int32)">
            <summary>
            Returns VisibleState of the line
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.ShowGoToDialog">
            <summary>
            Shows Goto dialog form
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.OnUndoRedoStateChanged">
            <summary>
            Occurs when undo/redo stack is changed
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.FindLines(System.String,System.Text.RegularExpressions.RegexOptions)">
            <summary>
            Search lines by regex pattern
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.RemoveLines(System.Collections.Generic.List{System.Int32})">
            <summary>
            Removes given lines
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.ActivateMiddleClickScrollingMode(System.Windows.Forms.MouseEventArgs)">
            <summary>
            Activates the scrolling mode (middle click button).
            </summary>
            <param name="e">MouseEventArgs</param>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.DeactivateMiddleClickScrollingMode">
            <summary>
            Deactivates the scrolling mode (middle click button).
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FastColoredTextBox.RestoreScrollsAfterMiddleClickScrollingMode">
            <summary>
            Restore scrolls
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.LineInsertedEventArgs.Index">
            <summary>
            Inserted line index
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.LineInsertedEventArgs.Count">
            <summary>
            Count of inserted lines
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.LineRemovedEventArgs.Index">
            <summary>
            Removed line index
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.LineRemovedEventArgs.Count">
            <summary>
            Count of removed lines
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.LineRemovedEventArgs.RemovedLineUniqueIds">
            <summary>
            UniqueIds of removed lines
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.TextChangedEventArgs">
            <summary>
            TextChanged event argument
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.TextChangedEventArgs.#ctor(FastColoredTextBoxNS.Range)">
            <summary>
            Constructor
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.TextChangedEventArgs.ChangedRange">
            <summary>
            This range contains changed area of text
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.TextChangingEventArgs.Cancel">
            <summary>
            Set to true if you want to cancel text inserting
            </summary>
        </member>
        <member name="F:FastColoredTextBoxNS.WordWrapMode.WordWrapControlWidth">
            <summary>
            Word wrapping by control width
            </summary>
        </member>
        <member name="F:FastColoredTextBoxNS.WordWrapMode.WordWrapPreferredWidth">
            <summary>
            Word wrapping by preferred line width (PreferredLineWidth)
            </summary>
        </member>
        <member name="F:FastColoredTextBoxNS.WordWrapMode.CharWrapControlWidth">
            <summary>
            Char wrapping by control width
            </summary>
        </member>
        <member name="F:FastColoredTextBoxNS.WordWrapMode.CharWrapPreferredWidth">
            <summary>
            Char wrapping by preferred line width (PreferredLineWidth)
            </summary>
        </member>
        <member name="F:FastColoredTextBoxNS.WordWrapMode.Custom">
            <summary>
            Custom wrap (by event WordWrapNeeded)
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.PrintDialogSettings.Title">
            <summary>
            Title of page. If you want to print Title on the page, insert code &amp;w in Footer or Header.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.PrintDialogSettings.Footer">
            <summary>
            Footer of page.
            Here you can use special codes: &amp;w (Window title), &amp;D, &amp;d (Date), &amp;t(), &amp;4 (Time), &amp;p (Current page number), &amp;P (Total number of pages),  &amp;&amp; (A single ampersand), &amp;b (Right justify text, Center text. If &amp;b occurs once, then anything after the &amp;b is right justified. If &amp;b occurs twice, then anything between the two &amp;b is centered, and anything after the second &amp;b is right justified).
            More detailed see <see cref="!:http://msdn.microsoft.com/en-us/library/aa969429(v=vs.85).aspx">here</see>
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.PrintDialogSettings.Header">
            <summary>
            Header of page
            Here you can use special codes: &amp;w (Window title), &amp;D, &amp;d (Date), &amp;t(), &amp;4 (Time), &amp;p (Current page number), &amp;P (Total number of pages),  &amp;&amp; (A single ampersand), &amp;b (Right justify text, Center text. If &amp;b occurs once, then anything after the &amp;b is right justified. If &amp;b occurs twice, then anything between the two &amp;b is centered, and anything after the second &amp;b is right justified).
            More detailed see <see cref="!:http://msdn.microsoft.com/en-us/library/aa969429(v=vs.85).aspx">here</see>
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.PrintDialogSettings.IncludeLineNumbers">
            <summary>
            Prints line numbers
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.AutoIndentEventArgs.Shift">
            <summary>
            Additional spaces count for this line, relative to previous line
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.AutoIndentEventArgs.ShiftNextLines">
            <summary>
            Additional spaces count for next line, relative to previous line
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.AutoIndentEventArgs.AbsoluteIndentation">
            <summary>
            Absolute indentation of current line. You can change this property if you want to set absolute indentation.
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.HighlightingRangeType">
            <summary>
            Type of highlighting
            </summary>
        </member>
        <member name="F:FastColoredTextBoxNS.HighlightingRangeType.ChangedRange">
            <summary>
            Highlight only changed range of text. Highest performance.
            </summary>
        </member>
        <member name="F:FastColoredTextBoxNS.HighlightingRangeType.VisibleRange">
            <summary>
            Highlight visible range of text. Middle performance.
            </summary>
        </member>
        <member name="F:FastColoredTextBoxNS.HighlightingRangeType.AllTextRange">
            <summary>
            Highlight all (visible and invisible) text. Lowest performance.
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.FindEndOfFoldingBlockStrategy">
            <summary>
            Strategy of search of end of folding block
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.BracketsHighlightStrategy">
            <summary>
            Strategy of search of brackets to highlighting
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.ToolTipNeededEventArgs">
            <summary>
            ToolTipNeeded event args
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.HintClickEventArgs">
            <summary>
            HintClick event args
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.CustomActionEventArgs">
            <summary>
            CustomAction event args
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.StyleIndex">
            <summary>
            Style index mask (16 styles)
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.InsertCharCommand">
            <summary>
            Insert single char
            </summary>
            <remarks>This operation includes also insertion of new line and removing char by backspace</remarks>
        </member>
        <member name="M:FastColoredTextBoxNS.InsertCharCommand.#ctor(FastColoredTextBoxNS.TextSource,System.Char)">
            <summary>
            Constructor
            </summary>
            <param name="tb">Underlaying textbox</param>
            <param name="c">Inserting char</param>
        </member>
        <member name="M:FastColoredTextBoxNS.InsertCharCommand.Undo">
            <summary>
            Undo operation
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.InsertCharCommand.Execute">
            <summary>
            Execute operation
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.InsertCharCommand.MergeLines(System.Int32,FastColoredTextBoxNS.TextSource)">
            <summary>
            Merge lines i and i+1
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.InsertTextCommand">
            <summary>
            Insert text
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.InsertTextCommand.#ctor(FastColoredTextBoxNS.TextSource,System.String)">
            <summary>
            Constructor
            </summary>
            <param name="tb">Underlaying textbox</param>
            <param name="insertedText">Text for inserting</param>
        </member>
        <member name="M:FastColoredTextBoxNS.InsertTextCommand.Undo">
            <summary>
            Undo operation
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.InsertTextCommand.Execute">
            <summary>
            Execute operation
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.ReplaceTextCommand">
            <summary>
            Insert text into given ranges
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.ReplaceTextCommand.#ctor(FastColoredTextBoxNS.TextSource,System.Collections.Generic.List{FastColoredTextBoxNS.Range},System.String)">
            <summary>
            Constructor
            </summary>
            <param name="tb">Underlaying textbox</param>
            <param name="ranges">List of ranges for replace</param>
            <param name="insertedText">Text for inserting</param>
        </member>
        <member name="M:FastColoredTextBoxNS.ReplaceTextCommand.Undo">
            <summary>
            Undo operation
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.ReplaceTextCommand.Execute">
            <summary>
            Execute operation
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.ClearSelectedCommand">
            <summary>
            Clear selected text
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.ClearSelectedCommand.#ctor(FastColoredTextBoxNS.TextSource)">
            <summary>
            Construstor
            </summary>
            <param name="tb">Underlaying textbox</param>
        </member>
        <member name="M:FastColoredTextBoxNS.ClearSelectedCommand.Undo">
            <summary>
            Undo operation
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.ClearSelectedCommand.Execute">
            <summary>
            Execute operation
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.ReplaceMultipleTextCommand">
            <summary>
            Replaces text
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.ReplaceMultipleTextCommand.#ctor(FastColoredTextBoxNS.TextSource,System.Collections.Generic.List{FastColoredTextBoxNS.ReplaceMultipleTextCommand.ReplaceRange})">
            <summary>
            Constructor
            </summary>
            <param name="ts">Underlaying textsource</param>
            <param name="ranges">List of ranges for replace</param>
        </member>
        <member name="M:FastColoredTextBoxNS.ReplaceMultipleTextCommand.Undo">
            <summary>
            Undo operation
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.ReplaceMultipleTextCommand.Execute">
            <summary>
            Execute operation
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.RemoveLinesCommand">
            <summary>
            Removes lines
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.RemoveLinesCommand.#ctor(FastColoredTextBoxNS.TextSource,System.Collections.Generic.List{System.Int32})">
            <summary>
            Constructor
            </summary>
            <param name="tb">Underlaying textbox</param>
            <param name="ranges">List of ranges for replace</param>
            <param name="insertedText">Text for inserting</param>
        </member>
        <member name="M:FastColoredTextBoxNS.RemoveLinesCommand.Undo">
            <summary>
            Undo operation
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.RemoveLinesCommand.Execute">
            <summary>
            Execute operation
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.MultiRangeCommand">
            <summary>
            Wrapper for multirange commands
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.SelectCommand">
            <summary>
            Remembers current selection and restore it after Undo
            </summary>
        </member>
        <member name="F:FastColoredTextBoxNS.FindForm.components">
            <summary>
            Required designer variable.
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.FindForm.Dispose(System.Boolean)">
            <summary>
            Clean up any resources being used.
            </summary>
            <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        </member>
        <member name="M:FastColoredTextBoxNS.FindForm.InitializeComponent">
            <summary>
            Required method for Designer support - do not modify
            the contents of this method with the code editor.
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.LimitedStack`1">
            <summary>
            Limited stack
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.LimitedStack`1.MaxItemCount">
            <summary>
            Max stack length
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.LimitedStack`1.Count">
            <summary>
            Current length of stack
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.LimitedStack`1.#ctor(System.Int32)">
            <summary>
            Constructor
            </summary>
            <param name="maxItemCount">Maximum length of stack</param>
        </member>
        <member name="M:FastColoredTextBoxNS.LimitedStack`1.Pop">
            <summary>
            Pop item
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.LimitedStack`1.Peek">
            <summary>
            Peek item
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.LimitedStack`1.Push(`0)">
            <summary>
            Push item
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.LimitedStack`1.Clear">
            <summary>
            Clear stack
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.Line">
            <summary>
            Line of text
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Line.IsChanged">
            <summary>
            Text of line was changed
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Line.LastVisit">
            <summary>
            Time of last visit of caret in this line
            </summary>
            <remarks>This property can be used for forward/backward navigating</remarks>
        </member>
        <member name="P:FastColoredTextBoxNS.Line.BackgroundBrush">
            <summary>
            Background brush.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Line.UniqueId">
            <summary>
            Unique ID
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Line.AutoIndentSpacesNeededCount">
            <summary>
            Count of needed start spaces for AutoIndent
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Line.ClearStyle(FastColoredTextBoxNS.StyleIndex)">
            <summary>
            Clears style of chars, delete folding markers
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Line.Text">
            <summary>
            Text of the line
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Line.ClearFoldingMarkers">
            <summary>
            Clears folding markers
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Line.StartSpacesCount">
            <summary>
            Count of start spaces
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Line.Count">
            <summary>
            Chars count
            </summary>
        </member>
        <member name="F:FastColoredTextBoxNS.LineInfo.VisibleState">
            <summary>
            Visible state
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.LineInfo.CutOffPositions">
            <summary>
            Positions for wordwrap cutoffs
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.LineInfo.WordWrapStringsCount">
            <summary>
            Count of wordwrap string count for this line
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.LineInfo.GetWordWrapStringIndex(System.Int32)">
            <summary>
            Gets index of wordwrap string for given char position
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.Place">
            <summary>
            Line index and char index
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.Range">
            <summary>
            Diapason of text chars
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.#ctor(FastColoredTextBoxNS.FastColoredTextBox)">
            <summary>
            Constructor
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Range.IsEmpty">
            <summary>
            Return true if no selected text
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Range.ColumnSelectionMode">
            <summary>
            Column selection mode
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.#ctor(FastColoredTextBoxNS.FastColoredTextBox,System.Int32,System.Int32,System.Int32,System.Int32)">
            <summary>
            Constructor
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.#ctor(FastColoredTextBoxNS.FastColoredTextBox,FastColoredTextBoxNS.Place,FastColoredTextBoxNS.Place)">
            <summary>
            Constructor
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.#ctor(FastColoredTextBoxNS.FastColoredTextBox,System.Int32)">
            <summary>
            Constructor. Creates range of the line
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.GetIntersectionWith(FastColoredTextBoxNS.Range)">
            <summary>
            Returns intersection with other range,
            empty range returned otherwise
            </summary>
            <param name="range"></param>
            <returns></returns>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.GetUnionWith(FastColoredTextBoxNS.Range)">
            <summary>
            Returns union with other range.
            </summary>
            <param name="range"></param>
            <returns></returns>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.SelectAll">
            <summary>
            Select all chars of control
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Range.Start">
            <summary>
            Start line and char position
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Range.End">
            <summary>
            Finish line and char position
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Range.Text">
            <summary>
            Text of range
            </summary>
            <remarks>This property has not 'set' accessor because undo/redo stack works only with 
            FastColoredTextBox.Selection range. So, if you want to set text, you need to use FastColoredTextBox.Selection
            and FastColoredTextBox.InsertText() mehtod.
            </remarks>
        </member>
        <member name="P:FastColoredTextBoxNS.Range.CharAfterStart">
            <summary>
            Returns first char after Start place
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Range.CharBeforeStart">
            <summary>
            Returns first char before Start place
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.GetCharsBeforeStart(System.Int32)">
            <summary>
            Returns required char's number before start of the Range
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.GetCharsAfterStart(System.Int32)">
            <summary>
            Returns required char's number after start of the Range
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.Clone">
            <summary>
            Clone range
            </summary>
            <returns></returns>
        </member>
        <member name="P:FastColoredTextBoxNS.Range.FromX">
            <summary>
            Return minimum of end.X and start.X
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Range.ToX">
            <summary>
            Return maximum of end.X and start.X
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.GoRight">
            <summary>
            Move range right
            </summary>
            <remarks>This method jump over folded blocks</remarks>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.GoRightThroughFolded">
            <summary>
            Move range left
            </summary>
            <remarks>This method can to go inside folded blocks</remarks>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.GoLeft">
            <summary>
            Move range left
            </summary>
            <remarks>This method jump over folded blocks</remarks>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.GoLeftThroughFolded">
            <summary>
            Move range left
            </summary>
            <remarks>This method can to go inside folded blocks</remarks>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.SetStyle(FastColoredTextBoxNS.Style)">
            <summary>
            Set style for range
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.SetStyle(FastColoredTextBoxNS.Style,System.String)">
            <summary>
            Set style for given regex pattern
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.SetStyle(FastColoredTextBoxNS.Style,System.Text.RegularExpressions.Regex)">
            <summary>
            Set style for given regex
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.SetStyle(FastColoredTextBoxNS.Style,System.String,System.Text.RegularExpressions.RegexOptions)">
            <summary>
            Set style for given regex pattern
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.SetStyle(FastColoredTextBoxNS.StyleIndex,System.String,System.Text.RegularExpressions.RegexOptions)">
            <summary>
            Set style for given regex pattern
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.SetStyle(FastColoredTextBoxNS.StyleIndex,System.Text.RegularExpressions.Regex)">
            <summary>
            Set style for given regex pattern
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.SetStyle(FastColoredTextBoxNS.StyleIndex)">
            <summary>
            Appends style to chars of range
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.SetFoldingMarkers(System.String,System.String)">
            <summary>
            Sets folding markers
            </summary>
            <param name="startFoldingPattern">Pattern for start folding line</param>
            <param name="finishFoldingPattern">Pattern for finish folding line</param>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.SetFoldingMarkers(System.String,System.String,System.Text.RegularExpressions.RegexOptions)">
            <summary>
            Sets folding markers
            </summary>
            <param name="startFoldingPattern">Pattern for start folding line</param>
            <param name="finishFoldingPattern">Pattern for finish folding line</param>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.SetFoldingMarkers(System.String,System.Text.RegularExpressions.RegexOptions)">
            <summary>
            Sets folding markers
            </summary>
            <param name="startEndFoldingPattern">Pattern for start and end folding line</param>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.GetRanges(System.String)">
            <summary>
            Finds ranges for given regex pattern
            </summary>
            <param name="regexPattern">Regex pattern</param>
            <returns>Enumeration of ranges</returns>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.GetRanges(System.String,System.Text.RegularExpressions.RegexOptions)">
            <summary>
            Finds ranges for given regex pattern
            </summary>
            <param name="regexPattern">Regex pattern</param>
            <returns>Enumeration of ranges</returns>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.GetRangesByLines(System.String,System.Text.RegularExpressions.RegexOptions)">
            <summary>
            Finds ranges for given regex pattern.
            Search is separately in each line.
            This method requires less memory than GetRanges().
            </summary>
            <param name="regexPattern">Regex pattern</param>
            <returns>Enumeration of ranges</returns>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.GetRangesByLines(System.Text.RegularExpressions.Regex)">
            <summary>
            Finds ranges for given regex.
            Search is separately in each line.
            This method requires less memory than GetRanges().
            </summary>
            <param name="regex">Regex</param>
            <returns>Enumeration of ranges</returns>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.GetRangesByLinesReversed(System.String,System.Text.RegularExpressions.RegexOptions)">
            <summary>
            Finds ranges for given regex pattern.
            Search is separately in each line (order of lines is reversed).
            This method requires less memory than GetRanges().
            </summary>
            <param name="regexPattern">Regex pattern</param>
            <returns>Enumeration of ranges</returns>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.GetRanges(System.Text.RegularExpressions.Regex)">
            <summary>
            Finds ranges for given regex
            </summary>
            <returns>Enumeration of ranges</returns>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.ClearStyle(FastColoredTextBoxNS.Style[])">
            <summary>
            Clear styles of range
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.ClearStyle(FastColoredTextBoxNS.StyleIndex)">
            <summary>
            Clear styles of range
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.ClearFoldingMarkers">
            <summary>
            Clear folding markers of all lines of range
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.BeginUpdate">
            <summary>
            Starts selection position updating
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.EndUpdate">
            <summary>
            Ends selection position updating
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.Normalize">
            <summary>
            Exchanges Start and End if End appears before Start
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.Inverse">
            <summary>
            Exchanges Start and End
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.Expand">
            <summary>
            Expands range from first char of Start line to last char of End line
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.Range.Chars">
            <summary>
            Chars of range (exclude \n)
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.GetFragment(System.String)">
            <summary>
            Get fragment of text around Start place. Returns maximal matched to pattern fragment.
            </summary>
            <param name="allowedSymbolsPattern">Allowed chars pattern for fragment</param>
            <returns>Range of found fragment</returns>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.GetFragment(FastColoredTextBoxNS.Style,System.Boolean)">
            <summary>
            Get fragment of text around Start place. Returns maximal matched to given Style.
            </summary>
            <param name="style">Allowed style for fragment</param>
            <returns>Range of found fragment</returns>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.GetFragment(System.String,System.Text.RegularExpressions.RegexOptions)">
            <summary>
            Get fragment of text around Start place. Returns maximal mathed to pattern fragment.
            </summary>
            <param name="allowedSymbolsPattern">Allowed chars pattern for fragment</param>
            <returns>Range of found fragment</returns>
        </member>
        <member name="P:FastColoredTextBoxNS.Range.ReadOnly">
            <summary>
            Range is readonly?
            This property return True if any char of the range contains ReadOnlyStyle.
            Set this property to True/False to mark chars of the range as Readonly/Writable.
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.IsReadOnlyLeftChar">
            <summary>
            Is char before range readonly
            </summary>
            <returns></returns>
        </member>
        <member name="M:FastColoredTextBoxNS.Range.IsReadOnlyRightChar">
            <summary>
            Is char after range readonly
            </summary>
            <returns></returns>
        </member>
        <member name="T:FastColoredTextBoxNS.Style">
            <summary>
            Style of chars
            </summary>
            <remarks>This is base class for all text and design renderers</remarks>
        </member>
        <member name="P:FastColoredTextBoxNS.Style.IsExportable">
            <summary>
            This style is exported to outer formats (HTML for example)
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.Style.VisualMarkerClick">
            <summary>
            Occurs when user click on StyleVisualMarker joined to this style 
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Style.#ctor">
            <summary>
            Constructor
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Style.Draw(System.Drawing.Graphics,System.Drawing.Point,FastColoredTextBoxNS.Range)">
            <summary>
            Renders given range of text
            </summary>
            <param name="gr">Graphics object</param>
            <param name="position">Position of the range in absolute control coordinates</param>
            <param name="range">Rendering range of text</param>
        </member>
        <member name="M:FastColoredTextBoxNS.Style.OnVisualMarkerClick(FastColoredTextBoxNS.FastColoredTextBox,FastColoredTextBoxNS.VisualMarkerEventArgs)">
            <summary>
            Occurs when user click on StyleVisualMarker joined to this style 
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Style.AddVisualMarker(FastColoredTextBoxNS.FastColoredTextBox,FastColoredTextBoxNS.StyleVisualMarker)">
            <summary>
            Shows VisualMarker
            Call this method in Draw method, when you need to show VisualMarker for your style
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.Style.GetCSS">
            <summary>
            Returns CSS for export to HTML
            </summary>
            <returns></returns>
        </member>
        <member name="M:FastColoredTextBoxNS.Style.GetRTF">
            <summary>
            Returns RTF descriptor for export to RTF
            </summary>
            <returns></returns>
        </member>
        <member name="T:FastColoredTextBoxNS.TextStyle">
            <summary>
            Style for chars rendering
            This renderer can draws chars, with defined fore and back colors
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.FoldedBlockStyle">
            <summary>
            Renderer for folded block
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.SelectionStyle">
            <summary>
            Renderer for selected area
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.MarkerStyle">
            <summary>
            Marker style
            Draws background color for text
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.ShortcutStyle">
            <summary>
            Draws small rectangle for popup menu
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.WavyLineStyle">
            <summary>
            This style draws a wavy line below a given text range.
            </summary>
            <remarks>Thanks for Yallie</remarks>
        </member>
        <member name="T:FastColoredTextBoxNS.ReadOnlyStyle">
            <summary>
            This style is used to mark range of text as ReadOnly block
            </summary>
            <remarks>You can inherite this style to add visual effects of readonly text</remarks>
        </member>
        <member name="T:FastColoredTextBoxNS.TextSource">
            <summary>
            This class contains the source text (chars and styles).
            It stores a text lines, the manager of commands, undo/redo stack, styles.
            </summary>
        </member>
        <member name="F:FastColoredTextBoxNS.TextSource.Styles">
            <summary>
            Styles
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.TextSource.LineInserted">
            <summary>
            Occurs when line was inserted/added
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.TextSource.LineRemoved">
            <summary>
            Occurs when line was removed
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.TextSource.TextChanged">
            <summary>
            Occurs when text was changed
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.TextSource.RecalcNeeded">
            <summary>
            Occurs when recalc is needed
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.TextSource.RecalcWordWrap">
            <summary>
            Occurs when recalc wordwrap is needed
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.TextSource.TextChanging">
            <summary>
            Occurs before text changing
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.TextSource.CurrentTBChanged">
            <summary>
            Occurs after CurrentTB was changed
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.TextSource.CurrentTB">
            <summary>
            Current focused FastColoredTextBox
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.TextSource.DefaultStyle">
            <summary>
            Default text style
            This style is using when no one other TextStyle is not defined in Char.style
            </summary>
        </member>
        <member name="M:FastColoredTextBoxNS.TextSource.GetLines">
            <summary>
            Text lines
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.TextSource.Count">
            <summary>
            Lines count
            </summary>
        </member>
        <member name="T:FastColoredTextBoxNS.FCTBDescriptionProvider">
            
             These classes are required for correct data binding to Text property of FastColoredTextbox
             
        </member>
        <member name="T:FastColoredTextBoxNS.FileTextSource">
            <summary>
            This class contains the source text (chars and styles).
            It stores a text lines, the manager of commands, undo/redo stack, styles.
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.FileTextSource.LineNeeded">
            <summary>
            Occurs when need to display line in the textbox
            </summary>
        </member>
        <member name="E:FastColoredTextBoxNS.FileTextSource.LinePushed">
            <summary>
            Occurs when need to save line in the file
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.FileTextSource.SaveEOL">
            <summary>
            End Of Line characters used for saving
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.LineNeededEventArgs.DisplayedLineText">
            <summary>
            This text will be displayed in textbox
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.LinePushedEventArgs.DisplayedLineText">
            <summary>
            This property contains only changed text.
            If text of line is not changed, this property contains null.
            </summary>
        </member>
        <member name="P:FastColoredTextBoxNS.LinePushedEventArgs.SavedText">
            <summary>
            This text will be saved in the file
            </summary>
        </member>
    </members>
</doc>


================================================
FILE: FastColoredTextBox/FileTextSource.cs
================================================
//#define debug

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

namespace FastColoredTextBoxNS
{
    /// <summary>
    /// This class contains the source text (chars and styles).
    /// It stores a text lines, the manager of commands, undo/redo stack, styles.
    /// </summary>
    public class FileTextSource : TextSource, IDisposable
    {
        List<int> sourceFileLinePositions = new List<int>();
        FileStream fs;
        Encoding fileEncoding;
        System.Windows.Forms.Timer timer = new System.Windows.Forms.Timer();

        /// <summary>
        /// Occurs when need to display line in the textbox
        /// </summary>
        public event EventHandler<LineNeededEventArgs> LineNeeded;

        /// <summary>
        /// Occurs when need to save line in the file
        /// </summary>
        public event EventHandler<LinePushedEventArgs> LinePushed;

        public FileTextSource(FastColoredTextBox currentTB)
            : base(currentTB)
        {
            timer.Interval = 10000;
            timer.Tick += new EventHandler(timer_Tick);
            timer.Enabled = true;

            SaveEOL = Environment.NewLine;
        }

        void timer_Tick(object sender, EventArgs e)
        {
            timer.Enabled = false;
            try
            {
                UnloadUnusedLines();
            }
            finally
            {
                timer.Enabled = true;
            }
        }

        private void UnloadUnusedLines()
        {
            const int margin = 2000;
            var iStartVisibleLine = CurrentTB.VisibleRange.Start.iLine;
            var iFinishVisibleLine = CurrentTB.VisibleRange.End.iLine;

            int count = 0;
            for (int i = 0; i < Count; i++)
                if (base.lines[i] != null && !base.lines[i].IsChanged && Math.Abs(i - iFinishVisibleLine) > margin)
                {
                    base.lines[i] = null;
                    count++;
                }
#if debug
            Console.WriteLine("UnloadUnusedLines: " + count);
#endif
        }

        public void OpenFile(string fileName, Encoding enc)
        {
            Clear();

            if (fs != null)
                fs.Dispose();

            SaveEOL = Environment.NewLine;

            //read lines of file
            fs = new FileStream(fileName, FileMode.Open);
            var length = fs.Length;
            //read signature
            enc = DefineEncoding(enc, fs);
            int shift = DefineShift(enc);
            //first line
            sourceFileLinePositions.Add((int) fs.Position);
            base.lines.Add(null);
            //other lines
            sourceFileLinePositions.Capacity = (int) (length / 7 + 1000);

            //int prev = 0;
            //while(fs.Position < length)
            //{
            //    var b = fs.ReadByte();

            //    if (b == 10)// \n
            //    {
            //        sourceFileLinePositions.Add((int)(fs.Position) + shift);
            //        base.lines.Add(null);
            //    }else
            //    if (prev == 13)// \r (Mac format)
            //    {
            //        sourceFileLinePositions.Add((int)(fs.Position - 1) + shift);
            //        base.lines.Add(null);
            //        SaveEOL = "\r";
            //    }

            //    prev = b;
            //}

            //if (prev == 13)
            //{
            //    sourceFileLinePositions.Add((int)(fs.Position) + shift);
            //    base.lines.Add(null);
            //}

            int prev = 0;
            int prevPos = 0;
            BinaryReader br = new BinaryReader(fs, enc);
            while (fs.Position < length)
            {
                prevPos = (int) fs.Position;
                var b = br.ReadChar();

                if (b == 10) // \n
                {
                    sourceFileLinePositions.Add((int) fs.Position);
                    base.lines.Add(null);
                }
                else if (prev == 13) // \r (Mac format)
                {
                    sourceFileLinePositions.Add((int) prevPos);
                    base.lines.Add(null);
                    SaveEOL = "\r";
                }

                prev = b;
            }

            if (prev == 13)
            {
                sourceFileLinePositions.Add((int) prevPos);
                base.lines.Add(null);
            }

            if (length > 2000000)
                GC.Collect();

            Line[] temp = new Line[100];

            var c = base.lines.Count;
            base.lines.AddRange(temp);
            base.lines.TrimExcess();
            base.lines.RemoveRange(c, temp.Length);


            int[] temp2 = new int[100];
            c = base.lines.Count;
            sourceFileLinePositions.AddRange(temp2);
            sourceFileLinePositions.TrimExcess();
            sourceFileLinePositions.RemoveRange(c, temp.Length);


            fileEncoding = enc;

            OnLineInserted(0, Count);
            //load first lines for calc width of the text
            var linesCount = Math.Min(lines.Count, CurrentTB.ClientRectangle.Height / CurrentTB.CharHeight);
            for (int i = 0; i < linesCount; i++)
                LoadLineFromSourceFile(i);
            //
            NeedRecalc(new TextChangedEventArgs(0, linesCount - 1));
            if (CurrentTB.WordWrap)
                OnRecalcWordWrap(new TextChangedEventArgs(0, linesCount - 1));
        }

        private int DefineShift(Encoding enc)
        {
            if (enc.IsSingleByte)
                return 0;

            if (enc.HeaderName == "unicodeFFFE")
                return 0; //UTF16 BE

            if (enc.HeaderName == "utf-16")
                return 1; //UTF16 LE

            if (enc.HeaderName == "utf-32BE")
                return 0; //UTF32 BE

            if (enc.HeaderName == "utf-32")
                return 3; //UTF32 LE

            return 0;
        }

        private static Encoding DefineEncoding(Encoding enc, FileStream fs)
        {
            int bytesPerSignature = 0;
            byte[] signature = new byte[4];
            int c = fs.Read(signature, 0, 4);
            if (signature[0] == 0xFF && signature[1] == 0xFE && signature[2] == 0x00 && signature[3] == 0x00 && c >= 4)
            {
                enc = Encoding.UTF32; //UTF32 LE
                bytesPerSignature = 4;
            }
            else if (signature[0] == 0x00 && signature[1] == 0x00 && signature[2] == 0xFE && signature[3] == 0xFF)
            {
                enc = new UTF32Encoding(true, true); //UTF32 BE
                bytesPerSignature = 4;
            }
            else if (signature[0] == 0xEF && signature[1] == 0xBB && signature[2] == 0xBF)
            {
                enc = Encoding.UTF8; //UTF8
                bytesPerSignature = 3;
            }
            else if (signature[0] == 0xFE && signature[1] == 0xFF)
            {
                enc = Encoding.BigEndianUnicode; //UTF16 BE
                bytesPerSignature = 2;
            }
            else if (signature[0] == 0xFF && signature[1] == 0xFE)
            {
                enc = Encoding.Unicode; //UTF16 LE
                bytesPerSignature = 2;
            }

            fs.Seek(bytesPerSignature, SeekOrigin.Begin);

            return enc;
        }

        public void CloseFile()
        {
            if (fs != null)
                try
                {
                    fs.Dispose();
                }
                catch
                {
                    ;
                }

            fs = null;
        }

        /// <summary>
        /// End Of Line characters used for saving
        /// </summary>
        public string SaveEOL { get; set; }

        public override void SaveToFile(string fileName, Encoding enc)
        {
            //
            var newLinePos = new List<int>(Count);
            //create temp file
            var dir = Path.GetDirectoryName(fileName);
            var tempFileName = Path.Combine(dir, Path.GetFileNameWithoutExtension(fileName) + ".tmp");

            StreamReader sr = new StreamReader(fs, fileEncoding);
            using (FileStream tempFs = new FileStream(tempFileName, FileMode.Create))
            using (StreamWriter sw = new StreamWriter(tempFs, enc))
            {
                sw.Flush();

                for (int i = 0; i < Count; i++)
                {
                    newLinePos.Add((int) tempFs.Length);

                    var sourceLine = ReadLine(sr, i); //read line from source file
                    string line;

                    bool lineIsChanged = lines[i] != null && lines[i].IsChanged;

                    if (lineIsChanged)
                        line = lines[i].Text;
                    else
                        line = sourceLine;

                    //call event handler
                    if (LinePushed != null)
                    {
                        var args = new LinePushedEventArgs(sourceLine, i, lineIsChanged ? line : null);
                        LinePushed(this, args);

                        if (args.SavedText != null)
                            line = args.SavedText;
                    }

                    //save line to file
                    sw.Write(line);

                    if (i < Count - 1)
                        sw.Write(SaveEOL);

                    sw.Flush();
                }
            }

            //clear lines buffer
            for (int i = 0; i < Count; i++)
                lines[i] = null;
            //deattach from source file
            sr.Dispose();
            fs.Dispose();
            //delete target file
            if (File.Exists(fileName))
                File.Delete(fileName);
            //rename temp file
            File.Move(tempFileName, fileName);

            //binding to new file
            sourceFileLinePositions = newLinePos;
            fs = new FileStream(fileName, FileMode.Open);
            this.fileEncoding = enc;
        }

        private string ReadLine(StreamReader sr, int i)
        {
            string line;
            var filePos = sourceFileLinePositions[i];
            if (filePos < 0)
                return "";
            fs.Seek(filePos, SeekOrigin.Begin);
            sr.DiscardBufferedData();
            line = sr.ReadLine();
            return line;
        }

        public override void ClearIsChanged()
        {
            foreach (var line in lines)
                if (line != null)
                    line.IsChanged = false;
        }

        public override Line this[int i]
        {
            get
            {
                if (base.lines[i] != null)
                    return lines[i];
                else
                    LoadLineFromSourceFile(i);

                return lines[i];
            }
            set { throw new NotImplementedException(); }
        }

        private void LoadLineFromSourceFile(int i)
        {
            var line = CreateLine();
            fs.Seek(sourceFileLinePositions[i], SeekOrigin.Begin);
            StreamReader sr = new StreamReader(fs, fileEncoding);

            var s = sr.ReadLine();
            if (s == null)
                s = "";

            //call event handler
            if (LineNeeded != null)
            {
                var args = new LineNeededEventArgs(s, i);
                LineNeeded(this, args);
                s = args.DisplayedLineText;
                if (s == null)
                    return;
            }

            foreach (var c in s)
                line.Add(new Char(c));
            base.lines[i] = line;

            if (CurrentTB.WordWrap)
                OnRecalcWordWrap(new TextChangedEventArgs(i, i));
        }

        public override void InsertLine(int index, Line line)
        {
            sourceFileLinePositions.Insert(index, -1);
            base.InsertLine(index, line);
        }

        public override void RemoveLine(int index, int count)
        {
            sourceFileLinePositions.RemoveRange(index, count);
            base.RemoveLine(index, count);
        }

        public override void Clear()
        {
            base.Clear();
        }

        public override int GetLineLength(int i)
        {
            if (base.lines[i] == null)
                return 0;
            else
                return base.lines[i].Count;
        }

        public override bool LineHasFoldingStartMarker(int iLine)
        {
            if (lines[iLine] == null)
                return false;
            else
                return !string.IsNullOrEmpty(lines[iLine].FoldingStartMarker);
        }

        public override bool LineHasFoldingEndMarker(int iLine)
        {
            if (lines[iLine] == null)
                return false;
            else
                return !string.IsNullOrEmpty(lines[iLine].FoldingEndMarker);
        }

        public override void Dispose()
        {
            if (fs != null)
                fs.Dispose();

            timer.Dispose();
        }

        internal void UnloadLine(int iLine)
        {
            if (lines[iLine] != null && !lines[iLine].IsChanged)
                lines[iLine] = null;
        }
    }

    public class LineNeededEventArgs : EventArgs
    {
        public string SourceLineText { get; private set; }
        public int DisplayedLineIndex { get; private set; }

        /// <summary>
        /// This text will be displayed in textbox
        /// </summary>
        public string DisplayedLineText { get; set; }

        public LineNeededEventArgs(string sourceLineText, int displayedLineIndex)
        {
            this.SourceLineText = sourceLineText;
            this.DisplayedLineIndex = displayedLineIndex;
            this.DisplayedLineText = sourceLineText;
        }
    }

    public class LinePushedEventArgs : EventArgs
    {
        public string SourceLineText { get; private set; }
        public int DisplayedLineIndex { get; private set; }

        /// <summary>
        /// This property contains only changed text.
        /// If text of line is not changed, this property contains null.
        /// </summary>
        public string DisplayedLineText { get; private set; }

        /// <summary>
        /// This text will be saved in the file
        /// </summary>
        public string SavedText { get; set; }

        public LinePushedEventArgs(string sourceLineText, int displayedLineIndex, string displayedLineText)
        {
            this.SourceLineText = sourceLineText;
            this.DisplayedLineIndex = displayedLineIndex;
            this.DisplayedLineText = displayedLineText;
            this.SavedText = displayedLineText;
        }
    }

    class CharReader : TextReader
    {
        public override int Read()
        {
            return base.Read();
        }
    }
}

================================================
FILE: FastColoredTextBox/FindForm.Designer.cs
================================================
namespace FastColoredTextBoxNS
{
    partial class FindForm
    {
        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.btClose = new System.Windows.Forms.Button();
            this.btFindNext = new System.Windows.Forms.Button();
            this.tbFind = new System.Windows.Forms.TextBox();
            this.cbRegex = new System.Windows.Forms.CheckBox();
            this.cbMatchCase = new System.Windows.Forms.CheckBox();
            this.label1 = new System.Windows.Forms.Label();
            this.cbWholeWord = new System.Windows.Forms.CheckBox();
            this.SuspendLayout();
            // 
            // btClose
            // 
            this.btClose.Location = new System.Drawing.Point(318, 69);
            this.btClose.Name = "btClose";
            this.btClose.Size = new System.Drawing.Size(87, 27);
            this.btClose.TabIndex = 5;
            this.btClose.Text = "Close";
            this.btClose.UseVisualStyleBackColor = true;
            this.btClose.Click += new System.EventHandler(this.btClose_Click);
            // 
            // btFindNext
            // 
            this.btFindNext.Location = new System.Drawing.Point(225, 69);
            this.btFindNext.Name = "btFindNext";
            this.btFindNext.Size = new System.Drawing.Size(87, 27);
            this.btFindNext.TabIndex = 4;
            this.btFindNext.Text = "Find next";
            this.btFindNext.UseVisualStyleBackColor = true;
            this.btFindNext.Click += new System.EventHandler(this.btFindNext_Click);
            // 
            // tbFind
            // 
            this.tbFind.Location = new System.Drawing.Point(49, 14);
            this.tbFind.Name = "tbFind";
            this.tbFind.Size = new System.Drawing.Size(356, 23);
            this.tbFind.TabIndex = 0;
            this.tbFind.TextChanged += new System.EventHandler(this.cbMatchCase_CheckedChanged);
            this.tbFind.KeyPress += new System.Windows.Forms.KeyPressEventHandler(this.tbFind_KeyPress);
            // 
            // cbRegex
            // 
            this.cbRegex.AutoSize = true;
            this.cbRegex.Location = new System.Drawing.Point(290, 44);
            this.cbRegex.Name = "cbRegex";
            this.cbRegex.Size = new System.Drawing.Size(57, 19);
            this.cbRegex.TabIndex = 3;
            this.cbRegex.Text = "Regex";
            this.cbRegex.UseVisualStyleBackColor = true;
            this.cbRegex.CheckedChanged += new System.EventHandler(this.cbMatchCase_CheckedChanged);
            // 
            // cbMatchCase
            // 
            this.cbMatchCase.AutoSize = true;
            this.cbMatchCase.Location = new System.Drawing.Point(49, 44);
            this.cbMatchCase.Name = "cbMatchCase";
            this.cbMatchCase.Size = new System.Drawing.Size(86, 19);
            this.cbMatchCase.TabIndex = 1;
            this.cbMatchCase.Text = "Match case";
            this.cbMatchCase.UseVisualStyleBackColor = true;
            this.cbMatchCase.CheckedChanged += new System.EventHandler(this.cbMatchCase_CheckedChanged);
            // 
            // label1
            // 
            this.label1.AutoSize = true;
            this.label1.Location = new System.Drawing.Point(7, 17);
            this.label1.Name = "label1";
            this.label1.Size = new System.Drawing.Size(36, 15);
            this.label1.TabIndex = 5;
            this.label1.Text = "Find: ";
            // 
            // cbWholeWord
            // 
            this.cbWholeWord.AutoSize = true;
            this.cbWholeWord.Location = new System.Drawing.Point(152, 44);
            this.cbWholeWord.Name = "cbWholeWord";
            this.cbWholeWord.Size = new System.Drawing.Size(125, 19);
            this.cbWholeWord.TabIndex = 2;
            this.cbWholeWord.Text = "Match whole word";
            this.cbWholeWord.UseVisualStyleBackColor = true;
            this.cbWholeWord.CheckedChanged += new System.EventHandler(this.cbMatchCase_CheckedChanged);
            // 
            // FindForm
            // 
            this.AutoScaleDimensions = new System.Drawing.SizeF(7F, 15F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.ClientSize = new System.Drawing.Size(420, 107);
            this.Controls.Add(this.cbWholeWord);
            this.Controls.Add(this.label1);
            this.Controls.Add(this.cbMatchCase);
            this.Controls.Add(this.cbRegex);
            this.Controls.Add(this.tbFind);
            this.Controls.Add(this.btFindNext);
            this.Controls.Add(this.btClose);
            this.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedToolWindow;
            this.Name = "FindForm";
            this.ShowIcon = false;
            this.ShowInTaskbar = false;
            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
            this.Text = "Find";
            this.TopMost = true;
            this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.FindForm_FormClosing);
            this.ResumeLayout(false);
            this.PerformLayout();

        }

        #endregion

        private System.Windows.Forms.Button btClose;
        private System.Windows.Forms.Button btFindNext;
        private System.Windows.Forms.CheckBox cbRegex;
        private System.Windows.Forms.CheckBox cbMatchCase;
        private System.Windows.Forms.Label label1;
        private System.Windows.Forms.CheckBox cbWholeWord;
        public System.Windows.Forms.TextBox tbFind;
    }
}

================================================
FILE: FastColoredTextBox/FindForm.cs
================================================
using System;
using System.Windows.Forms;
using System.Text.RegularExpressions;
using System.Collections.Generic;

namespace FastColoredTextBoxNS
{
    public partial class FindForm : Form
    {
        bool firstSearch = true;
        Place startPlace;
        FastColoredTextBox tb;

        public FindForm(FastColoredTextBox tb)
        {
            InitializeComponent();
            this.tb = tb;
        }

        private void btClose_Click(object sender, EventArgs e)
        {
            Close();
        }

        private void btFindNext_Click(object sender, EventArgs e)
        {
            FindNext(tbFind.Text);
        }

        public virtual void FindNext(string pattern)
        {
            try
            {
                RegexOptions opt = cbMatchCase.Checked ? RegexOptions.None : RegexOptions.IgnoreCase;
                if (!cbRegex.Checked)
                    pattern = Regex.Escape(pattern);
                if (cbWholeWord.Checked)
                    pattern = "\\b" + pattern + "\\b";
                //
                Range range = tb.Selection.Clone();
                range.Normalize();
                //
                if (firstSearch)
                {
                    startPlace = range.Start;
                    firstSearch = false;
                }

                //
                range.Start = range.End;
                if (range.Start >= startPlace)
                    range.End = new Place(tb.GetLineLength(tb.LinesCount - 1), tb.LinesCount - 1);
                else
                    range.End = startPlace;
                //
                foreach (var r in range.GetRangesByLines(pattern, opt))
                {
                    tb.Selection = r;
                    tb.DoSelectionVisible();
                    tb.Invalidate();
                    return;
                }

                //
                if (range.Start >= startPlace && startPlace > Place.Empty)
                {
                    tb.Selection.Start = new Place(0, 0);
                    FindNext(pattern);
                    return;
                }

                MessageBox.Show("Not found");
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

        private void tbFind_KeyPress(object sender, KeyPressEventArgs e)
        {
            if (e.KeyChar == '\r')
            {
                btFindNext.PerformClick();
                e.Handled = true;
                return;
            }

            if (e.KeyChar == '\x1b')
            {
                Hide();
                e.Handled = true;
                return;
            }
        }

        private void FindForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (e.CloseReason == CloseReason.UserClosing)
            {
                e.Cancel = true;
                Hide();
            }

            this.tb.Focus();
        }

        protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
        {
            if (keyData == Keys.Escape)
            {
                this.Close();
                return true;
            }

            return base.ProcessCmdKey(ref msg, keyData);
        }

        protected override void OnActivated(EventArgs e)
        {
            tbFind.Focus();
            ResetSerach();
        }

        void ResetSerach()
        {
            firstSearch = true;
        }

        private void cbMatchCase_CheckedChanged(object sender, EventArgs e)
        {
            ResetSerach();
        }
    }
}

================================================
FILE: FastColoredTextBox/FindForm.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
</root>

================================================
FILE: FastColoredTextBox/GoToForm.Designer.cs
================================================
namespace FastColoredTextBoxNS
{
    partial class GoToForm
    {
        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.label = new System.Windows.Forms.Label();
            this.tbLineNumber = new System.Windows.Forms.TextBox();
            this.btnOk = new System.Windows.Forms.Button();
            this.btnCancel = new System.Windows.Forms.Button();
            this.SuspendLayout();
            // 
            // label
            // 
            this.label.AutoSize = true;
            this.label.Location = new System.Drawing.Point(14, 10);
            this.label.Name = "label";
            this.label.Size = new System.Drawing.Size(107, 15);
            this.label.TabIndex = 0;
            this.label.Text = "Line Number (1/1):";
            // 
            // tbLineNumber
            // 
            this.tbLineNumber.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.tbLineNumber.Location = new System.Drawing.Point(14, 33);
            this.tbLineNumber.Name = "tbLineNumber";
            this.tbLineNumber.Size = new System.Drawing.Size(199, 23);
            this.tbLineNumber.TabIndex = 1;
            // 
            // btnOk
            // 
            this.btnOk.DialogResult = System.Windows.Forms.DialogResult.OK;
            this.btnOk.Location = new System.Drawing.Point(14, 62);
            this.btnOk.Name = "btnOk";
            this.btnOk.Size = new System.Drawing.Size(87, 27);
            this.btnOk.TabIndex = 2;
            this.btnOk.Text = "OK";
            this.btnOk.UseVisualStyleBackColor = true;
            this.btnOk.Click += new System.EventHandler(this.btnOk_Click);
            // 
            // btnCancel
            // 
            this.btnCancel.DialogResult = System.Windows.Forms.DialogResult.Cancel;
            this.btnCancel.Location = new System.Drawing.Point(125, 62);
            this.btnCancel.Name = "btnCancel";
            this.btnCancel.Size = new System.Drawing.Size(87, 27);
            this.btnCancel.TabIndex = 3;
            this.btnCancel.Text = "Cancel";
            this.btnCancel.UseVisualStyleBackColor = true;
            this.btnCancel.Click += new System.EventHandler(this.btnCancel_Click);
            // 
            // GoToForm
            // 
            this.AcceptButton = this.btnOk;
            this.AutoScaleDimensions = new System.Drawing.SizeF(7F, 15F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.CancelButton = this.btnCancel;
            this.ClientSize = new System.Drawing.Size(225, 105);
            this.Controls.Add(this.btnCancel);
            this.Controls.Add(this.btnOk);
            this.Controls.Add(this.tbLineNumber);
            this.Controls.Add(this.label);
            this.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedToolWindow;
            this.MaximizeBox = false;
            this.MinimizeBox = false;
            this.Name = "GoToForm";
            this.ShowIcon = false;
            this.ShowInTaskbar = false;
            this.SizeGripStyle = System.Windows.Forms.SizeGripStyle.Hide;
            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
            this.Text = "Go To Line";
            this.TopMost = true;
            this.ResumeLayout(false);
            this.PerformLayout();

        }

        #endregion

        private System.Windows.Forms.Label label;
        private System.Windows.Forms.TextBox tbLineNumber;
        private System.Windows.Forms.Button btnOk;
        private System.Windows.Forms.Button btnCancel;
    }
}

================================================
FILE: FastColoredTextBox/GoToForm.cs
================================================
using System;
using System.Windows.Forms;

namespace FastColoredTextBoxNS
{
    public partial class GoToForm : Form
    {
        public int SelectedLineNumber { get; set; }
        public int TotalLineCount { get; set; }

        public GoToForm()
        {
            InitializeComponent();
        }

        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);

            this.tbLineNumber.Text = this.SelectedLineNumber.ToString();

            this.label.Text = String.Format("Line number (1 - {0}):", this.TotalLineCount);
        }

        protected override void OnShown(EventArgs e)
        {
            base.OnShown(e);

            this.tbLineNumber.Focus();
        }

        private void btnOk_Click(object sender, EventArgs e)
        {
            int enteredLine;
            if (int.TryParse(this.tbLineNumber.Text, out enteredLine))
            {
                enteredLine = Math.Min(enteredLine, this.TotalLineCount);
                enteredLine = Math.Max(1, enteredLine);

                this.SelectedLineNumber = enteredLine;
            }

            this.DialogResult = DialogResult.OK;
            this.Close();
        }

        private void btnCancel_Click(object sender, EventArgs e)
        {
            this.DialogResult = DialogResult.Cancel;
            this.Close();
        }
    }
}

================================================
FILE: FastColoredTextBox/GoToForm.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
</root>

================================================
FILE: FastColoredTextBox/Hints.cs
================================================
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Text;
using System.Windows.Forms;

namespace FastColoredTextBoxNS
{
    /// <summary>
    /// Collection of Hints.
    /// This is temporary buffer for currently displayed hints.
    /// </summary>
    public class Hints : ICollection<Hint>, IDisposable
    {
        FastColoredTextBox tb;
        List<Hint> items = new List<Hint>();

        public Hints(FastColoredTextBox tb)
        {
            this.tb = tb;
            tb.TextChanged += OnTextBoxTextChanged;
            tb.KeyDown += OnTextBoxKeyDown;
            tb.VisibleRangeChanged += OnTextBoxVisibleRangeChanged;
        }

        protected virtual void OnTextBoxKeyDown(object sender, System.Windows.Forms.KeyEventArgs e)
        {
            if (e.KeyCode == System.Windows.Forms.Keys.Escape && e.Modifiers == System.Windows.Forms.Keys.None)
                Clear();
        }

        protected virtual void OnTextBoxTextChanged(object sender, TextChangedEventArgs e)
        {
            Clear();
        }

        public void Dispose()
        {
            tb.TextChanged -= OnTextBoxTextChanged;
            tb.KeyDown -= OnTextBoxKeyDown;
            tb.VisibleRangeChanged -= OnTextBoxVisibleRangeChanged;
        }

        void OnTextBoxVisibleRangeChanged(object sender, EventArgs e)
        {
            if (items.Count == 0)
                return;

            tb.NeedRecalc(true);
            foreach (var item in items)
            {
                LayoutHint(item);
                item.HostPanel.Invalidate();
            }
        }

        private void LayoutHint(Hint hint)
        {
            if (hint.Inline)
            {
                if (hint.Range.Start.iLine < tb.LineInfos.Count - 1)
                    hint.HostPanel.Top = tb.LineInfos[hint.Range.Start.iLine + 1].startY - hint.TopPadding -
                                         hint.HostPanel.Height - tb.VerticalScroll.Value;
                else
                    hint.HostPanel.Top = tb.TextHeight + tb.Paddings.Top - hint.HostPanel.Height -
                                         tb.VerticalScroll.Value;
            }
            else
            {
                if (hint.Range.Start.iLine > tb.LinesCount - 1) return;
                if (hint.Range.Start.iLine == tb.LinesCount - 1)
                {
                    var y = tb.LineInfos[hint.Range.Start.iLine].startY - tb.VerticalScroll.Value + tb.CharHeight;

                    if (y + hint.HostPanel.Height + 1 > tb.ClientRectangle.Bottom)
                    {
                        hint.HostPanel.Top = Math.Max(0,
                            tb.LineInfos[hint.Range.Start.iLine].startY - tb.VerticalScroll.Value -
                            hint.HostPanel.Height);
                    }
                    else
                        hint.HostPanel.Top = y;
                }
                else
                {
                    hint.HostPanel.Top = tb.LineInfos[hint.Range.Start.iLine + 1].startY - tb.VerticalScroll.Value;
                    if (hint.HostPanel.Bottom > tb.ClientRectangle.Bottom)
                        hint.HostPanel.Top = tb.LineInfos[hint.Range.Start.iLine + 1].startY - tb.CharHeight -
                                             hint.TopPadding - hint.HostPanel.Height - tb.VerticalScroll.Value;
                }
            }

            if (hint.Dock == DockStyle.Fill)
            {
                hint.Width = tb.ClientSize.Width - tb.LeftIndent - 2;
                hint.HostPanel.Left = tb.LeftIndent;
            }
            else
            {
                var p1 = tb.PlaceToPoint(hint.Range.Start);
                var p2 = tb.PlaceToPoint(hint.Range.End);
                var cx = (p1.X + p2.X) / 2;
                var x = cx - hint.HostPanel.Width / 2;
                hint.HostPanel.Left = Math.Max(tb.LeftIndent, x);
                if (hint.HostPanel.Right > tb.ClientSize.Width)
                    hint.HostPanel.Left = Math.Max(tb.LeftIndent, x - (hint.HostPanel.Right - tb.ClientSize.Width));
            }
        }

        public IEnumerator<Hint> GetEnumerator()
        {
            foreach (var item in items)
                yield return item;
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        /// <summary>
        /// Clears all displayed hints
        /// </summary>
        public void Clear()
        {
            items.Clear();
            if (tb.Controls.Count != 0)
            {
                var toDelete = new List<Control>();
                foreach (Control item in tb.Controls)
                    if (item is UnfocusablePanel)
                        toDelete.Add(item);

                foreach (var item in toDelete)
                    tb.Controls.Remove(item);

                for (int i = 0; i < tb.LineInfos.Count; i++)
                {
                    var li = tb.LineInfos[i];
                    li.bottomPadding = 0;
                    tb.LineInfos[i] = li;
                }

                tb.NeedRecalc();
                tb.Invalidate();
                tb.Select();
                tb.ActiveControl = null;
            }
        }

        /// <summary>
        /// Add and shows the hint
        /// </summary>
        /// <param name="hint"></param>
        public void Add(Hint hint)
        {
            items.Add(hint);

            if (hint.Inline /* || hint.Range.Start.iLine >= tb.LinesCount - 1*/)
            {
                var li = tb.LineInfos[hint.Range.Start.iLine];
                hint.TopPadding = li.bottomPadding;
                li.bottomPadding += hint.HostPanel.Height;
                tb.LineInfos[hint.Range.Start.iLine] = li;
                tb.NeedRecalc(true);
            }

            LayoutHint(hint);

            tb.OnVisibleRangeChanged();

            hint.HostPanel.Parent = tb;

            tb.Select();
            tb.ActiveControl = null;
            tb.Invalidate();
        }

        /// <summary>
        /// Is collection contains the hint?
        /// </summary>
        public bool Contains(Hint item)
        {
            return items.Contains(item);
        }

        public void CopyTo(Hint[] array, int arrayIndex)
        {
            items.CopyTo(array, arrayIndex);
        }

        /// <summary>
        /// Count of hints
        /// </summary>
        public int Count
        {
            get { return items.Count; }
        }

        public bool IsReadOnly
        {
            get { return false; }
        }

        public bool Remove(Hint item)
        {
            throw new NotImplementedException();
        }
    }

    /// <summary>
    /// Hint of FastColoredTextbox
    /// </summary>
    public class Hint
    {
        /// <summary>
        /// Text of simple hint
        /// </summary>
        public string Text
        {
            get { return HostPanel.Text; }
            set { HostPanel.Text = value; }
        }

        /// <summary>
        /// Linked range
        /// </summary>
        public Range Range { get; set; }

        /// <summary>
        /// Backcolor
        /// </summary>
        public Color BackColor
        {
            get { return HostPanel.BackColor; }
            set { HostPanel.BackColor = value; }
        }

        /// <summary>
        /// Second backcolor
        /// </summary>
        public Color BackColor2
        {
            get { return HostPanel.BackColor2; }
            set { HostPanel.BackColor2 = value; }
        }

        /// <summary>
        /// Border color
        /// </summary>
        public Color BorderColor
        {
            get { return HostPanel.BorderColor; }
            set { HostPanel.BorderColor = value; }
        }

        /// <summary>
        /// Fore color
        /// </summary>
        public Color ForeColor
        {
            get { return HostPanel.ForeColor; }
            set { HostPanel.ForeColor = value; }
        }

        /// <summary>
        /// Text alignment
        /// </summary>
        public StringAlignment TextAlignment
        {
            get { return HostPanel.TextAlignment; }
            set { HostPanel.TextAlignment = value; }
        }

        /// <summary>
        /// Font
        /// </summary>
        public Font Font
        {
            get { return HostPanel.Font; }
            set { HostPanel.Font = value; }
        }

        /// <summary>
        /// Occurs when user click on simple hint
        /// </summary>
        public event EventHandler Click
        {
            add { HostPanel.Click += value; }
            remove { HostPanel.Click -= value; }
        }

        /// <summary>
        /// Inner control
        /// </summary>
        public Control InnerControl { get; set; }

        /// <summary>
        /// Docking (allows None and Fill only)
        /// </summary>
        public DockStyle Dock { get; set; }

        /// <summary>
        /// Width of hint (if Dock is None)
        /// </summary>
        public int Width
        {
            get { return HostPanel.Width; }
            set { HostPanel.Width = value; }
        }

        /// <summary>
        /// Height of hint
        /// </summary>
        public int Height
        {
            get { return HostPanel.Height; }
            set { HostPanel.Height = value; }
        }

        /// <summary>
        /// Host panel
        /// </summary>
        public UnfocusablePanel HostPanel { get; private set; }

        internal int TopPadding { get; set; }

        /// <summary>
        /// Tag
        /// </summary>
        public object Tag { get; set; }

        /// <summary>
        /// Cursor
        /// </summary>
        public Cursor Cursor
        {
            get { return HostPanel.Cursor; }
            set { HostPanel.Cursor = value; }
        }

        /// <summary>
        /// Inlining. If True then hint will moves apart text.
        /// </summary>
        public bool Inline { get; set; }

        /// <summary>
        /// Scroll textbox to the hint
        /// </summary>
        public virtual void DoVisible()
        {
            Range.tb.DoRangeVisible(Range, true);
            Range.tb.DoVisibleRectangle(HostPanel.Bounds);

            Range.tb.Invalidate();
        }

        private Hint(Range range, Control innerControl, string text, bool inline, bool dock)
        {
            this.Range = range;
            this.Inline = inline;
            this.InnerControl = innerControl;

            Init();

            Dock = dock ? DockStyle.Fill : DockStyle.None;
            Text = text;
        }

        /// <summary>
        /// Creates Hint
        /// </summary>
        /// <param name="range">Linked range</param>
        /// <param name="text">Text for simple hint</param>
        /// <param name="inline">Inlining. If True then hint will moves apart text</param>
        /// <param name="dock">Docking. If True then hint will fill whole line</param>
        public Hint(Range range, string text, bool inline, bool dock)
            : this(range, null, text, inline, dock)
        {
        }

        /// <summary>
        /// Creates Hint
        /// </summary>
        /// <param name="range">Linked range</param>
        /// <param name="text">Text for simple hint</param>
        public Hint(Range range, string text)
            : this(range, null, text, true, true)
        {
        }

        /// <summary>
        /// Creates Hint
        /// </summary>
        /// <param name="range">Linked range</param>
        /// <param name="innerControl">Inner control</param>
        /// <param name="inline">Inlining. If True then hint will moves apart text</param>
        /// <param name="dock">Docking. If True then hint will fill whole line</param>
        public Hint(Range range, Control innerControl, bool inline, bool dock)
            : this(range, innerControl, null, inline, dock)
        {
        }

        /// <summary>
        /// Creates Hint
        /// </summary>
        /// <param name="range">Linked range</param>
        /// <param name="innerControl">Inner control</param>
        public Hint(Range range, Control innerControl)
            : this(range, innerControl, null, true, true)
        {
        }

        protected virtual void Init()
        {
            HostPanel = new UnfocusablePanel();
            HostPanel.Click += OnClick;

            Cursor = Cursors.Default;
            BorderColor = Color.Silver;
            BackColor2 = Color.White;
            BackColor = InnerControl == null ? Color.Silver : SystemColors.Control;
            ForeColor = Color.Black;
            TextAlignment = StringAlignment.Near;
            Font = Range.tb.Parent == null ? Range.tb.Font : Range.tb.Parent.Font;

            if (InnerControl != null)
            {
                HostPanel.Controls.Add(InnerControl);
                var size = InnerControl.GetPreferredSize(InnerControl.Size);
                HostPanel.Width = size.Width + 2;
                HostPanel.Height = size.Height + 2;
                InnerControl.Dock = DockStyle.Fill;
                InnerControl.Visible = true;
                BackColor = SystemColors.Control;
            }
            else
            {
                HostPanel.Height = Range.tb.CharHeight + 5;
            }
        }

        protected virtual void OnClick(object sender, EventArgs e)
        {
            Range.tb.OnHintClick(this);
        }
    }
}

================================================
FILE: FastColoredTextBox/Hotkeys.cs
================================================
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Drawing;
using System.Drawing.Design;
using System.Globalization;
using System.Reflection;
using System.Text;
using System.Threading;
using System.Windows.Forms;
using System.Windows.Forms.Design;
using KEYS = System.Windows.Forms.Keys;

namespace FastColoredTextBoxNS
{
    /// <summary>
    /// Dictionary of shortcuts for FCTB
    /// </summary>
    public class HotkeysMapping : SortedDictionary<Keys, FCTBAction>
    {
        public virtual void InitDefault()
        {
            this[KEYS.Control | KEYS.G] = FCTBAction.GoToDialog;
            this[KEYS.Control | KEYS.F] = FCTBAction.FindDialog;
            this[KEYS.Alt | KEYS.F] = FCTBAction.FindChar;
            this[KEYS.F3] = FCTBAction.FindNext;
            this[KEYS.Control | KEYS.H] = FCTBAction.ReplaceDialog;
            this[KEYS.Control | KEYS.C] = FCTBAction.Copy;
            this[KEYS.Control | KEYS.Shift | KEYS.C] = FCTBAction.CommentSelected;
            this[KEYS.Control | KEYS.X] = FCTBAction.Cut;
            this[KEYS.Control | KEYS.V] = FCTBAction.Paste;
            this[KEYS.Control | KEYS.A] = FCTBAction.SelectAll;
            this[KEYS.Control | KEYS.Z] = FCTBAction.Undo;
            this[KEYS.Control | KEYS.R] = FCTBAction.Redo;
            this[KEYS.Control | KEYS.U] = FCTBAction.UpperCase;
            this[KEYS.Shift | KEYS.Control | KEYS.U] = FCTBAction.LowerCase;
            this[KEYS.Control | KEYS.OemMinus] = FCTBAction.NavigateBackward;
            this[KEYS.Control | KEYS.Shift | KEYS.OemMinus] = FCTBAction.NavigateForward;
            this[KEYS.Control | KEYS.B] = FCTBAction.BookmarkLine;
            this[KEYS.Control | KEYS.Shift | KEYS.B] = FCTBAction.UnbookmarkLine;
            this[KEYS.Control | KEYS.N] = FCTBAction.GoNextBookmark;
            this[KEYS.Control | KEYS.Shift | KEYS.N] = FCTBAction.GoPrevBookmark;
            this[KEYS.Alt | KEYS.Back] = FCTBAction.Undo;
            this[KEYS.Control | KEYS.Back] = FCTBAction.ClearWordLeft;
            this[KEYS.Insert] = FCTBAction.ReplaceMode;
            this[KEYS.Control | KEYS.Insert] = FCTBAction.Copy;
            this[KEYS.Shift | KEYS.Insert] = FCTBAction.Paste;
            this[KEYS.Delete] = FCTBAction.DeleteCharRight;
            this[KEYS.Control | KEYS.Delete] = FCTBAction.ClearWordRight;
            this[KEYS.Shift | KEYS.Delete] = FCTBAction.Cut;
            this[KEYS.Left] = FCTBAction.GoLeft;
            this[KEYS.Shift | KEYS.Left] = FCTBAction.GoLeftWithSelection;
            this[KEYS.Control | KEYS.Left] = FCTBAction.GoWordLeft;
            this[KEYS.Control | KEYS.Shift | KEYS.Left] = FCTBAction.GoWordLeftWithSelection;
            this[KEYS.Alt | KEYS.Shift | KEYS.Left] = FCTBAction.GoLeft_ColumnSelectionMode;
            this[KEYS.Right] = FCTBAction.GoRight;
            this[KEYS.Shift | KEYS.Right] = FCTBAction.GoRightWithSelection;
            this[KEYS.Control | KEYS.Right] = FCTBAction.GoWordRight;
            this[KEYS.Control | KEYS.Shift | KEYS.Right] = FCTBAction.GoWordRightWithSelection;
            this[KEYS.Alt | KEYS.Shift | KEYS.Right] = FCTBAction.GoRight_ColumnSelectionMode;
            this[KEYS.Up] = FCTBAction.GoUp;
            this[KEYS.Shift | KEYS.Up] = FCTBAction.GoUpWithSelection;
            this[KEYS.Alt | KEYS.Shift | KEYS.Up] = FCTBAction.GoUp_ColumnSelectionMode;
            this[KEYS.Alt | KEYS.Up] = FCTBAction.MoveSelectedLinesUp;
            this[KEYS.Control | KEYS.Up] = FCTBAction.ScrollUp;
            this[KEYS.Down] = FCTBAction.GoDown;
            this[KEYS.Shift | KEYS.Down] = FCTBAction.GoDownWithSelection;
            this[KEYS.Alt | KEYS.Shift | KEYS.Down] = FCTBAction.GoDown_ColumnSelectionMode;
            this[KEYS.Alt | KEYS.Down] = FCTBAction.MoveSelectedLinesDown;
            this[KEYS.Control | KEYS.Down] = FCTBAction.ScrollDown;
            this[KEYS.PageUp] = FCTBAction.GoPageUp;
            this[KEYS.Shift | KEYS.PageUp] = FCTBAction.GoPageUpWithSelection;
            this[KEYS.PageDown] = FCTBAction.GoPageDown;
            this[KEYS.Shift | KEYS.PageDown] = FCTBAction.GoPageDownWithSelection;
            this[KEYS.Home] = FCTBAction.GoHome;
            this[KEYS.Shift | KEYS.Home] = FCTBAction.GoHomeWithSelection;
            this[KEYS.Control | KEYS.Home] = FCTBAction.GoFirstLine;
            this[KEYS.Control | KEYS.Shift | KEYS.Home] = FCTBAction.GoFirstLineWithSelection;
            this[KEYS.End] = FCTBAction.GoEnd;
            this[KEYS.Shift | KEYS.End] = FCTBAction.GoEndWithSelection;
            this[KEYS.Control | KEYS.End] = FCTBAction.GoLastLine;
            this[KEYS.Control | KEYS.Shift | KEYS.End] = FCTBAction.GoLastLineWithSelection;
            this[KEYS.Escape] = FCTBAction.ClearHints;
            this[KEYS.Control | KEYS.M] = FCTBAction.MacroRecord;
            this[KEYS.Control | KEYS.E] = FCTBAction.MacroExecute;
            this[KEYS.Control | KEYS.Space] = FCTBAction.AutocompleteMenu;
            this[KEYS.Tab] = FCTBAction.IndentIncrease;
            this[KEYS.Shift | KEYS.Tab] = FCTBAction.IndentDecrease;
            this[KEYS.Control | KEYS.Subtract] = FCTBAction.ZoomOut;
            this[KEYS.Control | KEYS.Add] = FCTBAction.ZoomIn;
            this[KEYS.Control | KEYS.D0] = FCTBAction.ZoomNormal;
            this[KEYS.Control | KEYS.I] = FCTBAction.AutoIndentChars;
        }

        public override string ToString()
        {
            var cult = Thread.CurrentThread.CurrentUICulture;
            Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
            StringBuilder sb = new StringBuilder();
            var kc = new KeysConverter();
            foreach (var pair in this)
            {
                sb.AppendFormat("{0}={1}, ", kc.ConvertToString(pair.Key), pair.Value);
            }

            if (sb.Length > 1)
                sb.Remove(sb.Length - 2, 2);
            Thread.CurrentThread.CurrentUICulture = cult;

            return sb.ToString();
        }

        public static HotkeysMapping Parse(string s)
        {
            var result = new HotkeysMapping();
            result.Clear();
            var cult = Thread.CurrentThread.CurrentUICulture;
            Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;

            var kc = new KeysConverter();

            foreach (var p in s.Split(','))
            {
                var pp = p.Split('=');
                var k = (Keys) kc.ConvertFromString(pp[0].Trim());
                var a = (FCTBAction) Enum.Parse(typeof(FCTBAction), pp[1].Trim());
                result[k] = a;
            }

            Thread.CurrentThread.CurrentUICulture = cult;

            return result;
        }
    }

    /// <summary>
    /// Actions for shortcuts
    /// </summary>
    public enum FCTBAction
    {
        None,
        AutocompleteMenu,
        AutoIndentChars,
        BookmarkLine,
        ClearHints,
        ClearWordLeft,
        ClearWordRight,
        CommentSelected,
        Copy,
        Cut,
        DeleteCharRight,
        FindChar,
        FindDialog,
        FindNext,
        GoDown,
        GoDownWithSelection,
        GoDown_ColumnSelectionMode,
        GoEnd,
        GoEndWithSelection,
        GoFirstLine,
        GoFirstLineWithSelection,
        GoHome,
        GoHomeWithSelection,
        GoLastLine,
        GoLastLineWithSelection,
        GoLeft,
        GoLeftWithSelection,
        GoLeft_ColumnSelectionMode,
        GoPageDown,
        GoPageDownWithSelection,
        GoPageUp,
        GoPageUpWithSelection,
        GoRight,
        GoRightWithSelection,
        GoRight_ColumnSelectionMode,
        GoToDialog,
        GoNextBookmark,
        GoPrevBookmark,
        GoUp,
        GoUpWithSelection,
        GoUp_ColumnSelectionMode,
        GoWordLeft,
        GoWordLeftWithSelection,
        GoWordRight,
        GoWordRightWithSelection,
        IndentIncrease,
        IndentDecrease,
        LowerCase,
        MacroExecute,
        MacroRecord,
        MoveSelectedLinesDown,
        MoveSelectedLinesUp,
        NavigateBackward,
        NavigateForward,
        Paste,
        Redo,
        ReplaceDialog,
        ReplaceMode,
        ScrollDown,
        ScrollUp,
        SelectAll,
        UnbookmarkLine,
        Undo,
        UpperCase,
        ZoomIn,
        ZoomNormal,
        ZoomOut,
        CustomAction1,
        CustomAction2,
        CustomAction3,
        CustomAction4,
        CustomAction5,
        CustomAction6,
        CustomAction7,
        CustomAction8,
        CustomAction9,
        CustomAction10,
        CustomAction11,
        CustomAction12,
        CustomAction13,
        CustomAction14,
        CustomAction15,
        CustomAction16,
        CustomAction17,
        CustomAction18,
        CustomAction19,
        CustomAction20
    }

    internal class HotkeysEditor : UITypeEditor
    {
        public override UITypeEditorEditStyle GetEditStyle(System.ComponentModel.ITypeDescriptorContext context)
        {
            return UITypeEditorEditStyle.Modal;
        }

        public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
        {
            if ((provider != null) &&
                (((IWindowsFormsEditorService) provider.GetService(typeof(IWindowsFormsEditorService))) != null))
            {
                var form = new HotkeysEditorForm(HotkeysMapping.Parse(value as string));

                if (form.ShowDialog() == DialogResult.OK)
                    value = form.GetHotkeys().ToString();
            }

            return value;
        }
    }
}

================================================
FILE: FastColoredTextBox/HotkeysEditorForm.Designer.cs
================================================
namespace FastColoredTextBoxNS
{
    partial class HotkeysEditorForm
    {
        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            System.Windows.Forms.DataGridViewCellStyle dataGridViewCellStyle1 = new System.Windows.Forms.DataGridViewCellStyle();
            this.dgv = new System.Windows.Forms.DataGridView();
            this.cbModifiers = new System.Windows.Forms.DataGridViewComboBoxColumn();
            this.cbKey = new System.Windows.Forms.DataGridViewComboBoxColumn();
            this.cbAction = new System.Windows.Forms.DataGridViewComboBoxColumn();
            this.btAdd = new System.Windows.Forms.Button();
            this.btRemove = new System.Windows.Forms.Button();
            this.btCancel = new System.Windows.Forms.Button();
            this.btOk = new System.Windows.Forms.Button();
            this.label1 = new System.Windows.Forms.Label();
            this.btResore = new System.Windows.Forms.Button();
            ((System.ComponentModel.ISupportInitialize)(this.dgv)).BeginInit();
            this.SuspendLayout();
            // 
            // dgv
            // 
            this.dgv.AllowUserToAddRows = false;
            this.dgv.AllowUserToDeleteRows = false;
            this.dgv.AllowUserToResizeColumns = false;
            this.dgv.AllowUserToResizeRows = false;
            this.dgv.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.dgv.BackgroundColor = System.Drawing.SystemColors.Control;
            this.dgv.ColumnHeadersHeightSizeMode = System.Windows.Forms.DataGridViewColumnHeadersHeightSizeMode.AutoSize;
            this.dgv.Columns.AddRange(new System.Windows.Forms.DataGridViewColumn[] {
            this.cbModifiers,
            this.cbKey,
            this.cbAction});
            dataGridViewCellStyle1.Alignment = System.Windows.Forms.DataGridViewContentAlignment.MiddleLeft;
            dataGridViewCellStyle1.BackColor = System.Drawing.SystemColors.Window;
            dataGridViewCellStyle1.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(204)));
            dataGridViewCellStyle1.ForeColor = System.Drawing.SystemColors.ControlText;
            dataGridViewCellStyle1.SelectionBackColor = System.Drawing.Color.LightSteelBlue;
            dataGridViewCellStyle1.SelectionForeColor = System.Drawing.SystemColors.HighlightText;
            dataGridViewCellStyle1.WrapMode = System.Windows.Forms.DataGridViewTriState.False;
            this.dgv.DefaultCellStyle = dataGridViewCellStyle1;
            this.dgv.GridColor = System.Drawing.SystemColors.Control;
            this.dgv.Location = new System.Drawing.Point(12, 28);
            this.dgv.Name = "dgv";
            this.dgv.RowHeadersBorderStyle = System.Windows.Forms.DataGridViewHeaderBorderStyle.None;
            this.dgv.RowHeadersVisible = false;
            this.dgv.RowHeadersWidthSizeMode = System.Windows.Forms.DataGridViewRowHeadersWidthSizeMode.DisableResizing;
            this.dgv.SelectionMode = System.Windows.Forms.DataGridViewSelectionMode.FullRowSelect;
            this.dgv.Size = new System.Drawing.Size(525, 278);
            this.dgv.TabIndex = 0;
            this.dgv.RowsAdded += new System.Windows.Forms.DataGridViewRowsAddedEventHandler(this.dgv_RowsAdded);
            // 
            // cbModifiers
            // 
            this.cbModifiers.DataPropertyName = "Modifiers";
            this.cbModifiers.DisplayStyle = System.Windows.Forms.DataGridViewComboBoxDisplayStyle.ComboBox;
            this.cbModifiers.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
            this.cbModifiers.HeaderText = "Modifiers";
            this.cbModifiers.Name = "cbModifiers";
            // 
            // cbKey
            // 
            this.cbKey.DataPropertyName = "Key";
            this.cbKey.DisplayStyle = System.Windows.Forms.DataGridViewComboBoxDisplayStyle.ComboBox;
            this.cbKey.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
            this.cbKey.HeaderText = "Key";
            this.cbKey.Name = "cbKey";
            this.cbKey.Resizable = System.Windows.Forms.DataGridViewTriState.True;
            this.cbKey.Width = 120;
            // 
            // cbAction
            // 
            this.cbAction.AutoSizeMode = System.Windows.Forms.DataGridViewAutoSizeColumnMode.Fill;
            this.cbAction.DataPropertyName = "Action";
            this.cbAction.DisplayStyle = System.Windows.Forms.DataGridViewComboBoxDisplayStyle.ComboBox;
            this.cbAction.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
            this.cbAction.HeaderText = "Action";
            this.cbAction.Name = "cbAction";
            // 
            // btAdd
            // 
            this.btAdd.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.btAdd.Location = new System.Drawing.Point(13, 322);
            this.btAdd.Name = "btAdd";
            this.btAdd.Size = new System.Drawing.Size(75, 23);
            this.btAdd.TabIndex = 1;
            this.btAdd.Text = "Add";
            this.btAdd.UseVisualStyleBackColor = true;
            this.btAdd.Click += new System.EventHandler(this.btAdd_Click);
            // 
            // btRemove
            // 
            this.btRemove.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.btRemove.Location = new System.Drawing.Point(103, 322);
            this.btRemove.Name = "btRemove";
            this.btRemove.Size = new System.Drawing.Size(75, 23);
            this.btRemove.TabIndex = 2;
            this.btRemove.Text = "Remove";
            this.btRemove.UseVisualStyleBackColor = true;
            this.btRemove.Click += new System.EventHandler(this.btRemove_Click);
            // 
            // btCancel
            // 
            this.btCancel.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
            this.btCancel.DialogResult = System.Windows.Forms.DialogResult.Cancel;
            this.btCancel.Location = new System.Drawing.Point(460, 322);
            this.btCancel.Name = "btCancel";
            this.btCancel.Size = new System.Drawing.Size(75, 23);
            this.btCancel.TabIndex = 4;
            this.btCancel.Text = "Cancel";
            this.btCancel.UseVisualStyleBackColor = true;
            // 
            // btOk
            // 
            this.btOk.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
            this.btOk.DialogResult = System.Windows.Forms.DialogResult.OK;
            this.btOk.Location = new System.Drawing.Point(379, 322);
            this.btOk.Name = "btOk";
            this.btOk.Size = new System.Drawing.Size(75, 23);
            this.btOk.TabIndex = 3;
            this.btOk.Text = "OK";
            this.btOk.UseVisualStyleBackColor = true;
            // 
            // label1
            // 
            this.label1.AutoSize = true;
            this.label1.Font = new System.Drawing.Font("Microsoft Sans Serif", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(204)));
            this.label1.Location = new System.Drawing.Point(12, 9);
            this.label1.Name = "label1";
            this.label1.Size = new System.Drawing.Size(114, 16);
            this.label1.TabIndex = 5;
            this.label1.Text = "Hotkeys mapping";
            // 
            // btResore
            // 
            this.btResore.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.btResore.Location = new System.Drawing.Point(194, 322);
            this.btResore.Name = "btResore";
            this.btResore.Size = new System.Drawing.Size(105, 23);
            this.btResore.TabIndex = 6;
            this.btResore.Text = "Restore default";
            this.btResore.UseVisualStyleBackColor = true;
            this.btResore.Click += new System.EventHandler(this.btResore_Click);
            // 
            // HotkeysEditorForm
            // 
            this.AcceptButton = this.btOk;
            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.CancelButton = this.btCancel;
            this.ClientSize = new System.Drawing.Size(549, 357);
            this.Controls.Add(this.btResore);
            this.Controls.Add(this.label1);
            this.Controls.Add(this.btCancel);
            this.Controls.Add(this.btOk);
            this.Controls.Add(this.btRemove);
            this.Controls.Add(this.btAdd);
            this.Controls.Add(this.dgv);
            this.MaximumSize = new System.Drawing.Size(565, 700);
            this.MinimumSize = new System.Drawing.Size(565, 395);
            this.Name = "HotkeysEditorForm";
            this.ShowIcon = false;
            this.Text = "Hotkeys Editor";
            this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.HotkeysEditorForm_FormClosing);
            ((System.ComponentModel.ISupportInitialize)(this.dgv)).EndInit();
            this.ResumeLayout(false);
            this.PerformLayout();

        }

        #endregion

        private System.Windows.Forms.DataGridView dgv;
        private System.Windows.Forms.Button btAdd;
        private System.Windows.Forms.Button btRemove;
        private System.Windows.Forms.Button btCancel;
        private System.Windows.Forms.Button btOk;
        private System.Windows.Forms.Label label1;
        private System.Windows.Forms.Button btResore;
        private System.Windows.Forms.DataGridViewComboBoxColumn cbModifiers;
        private System.Windows.Forms.DataGridViewComboBoxColumn cbKey;
        private System.Windows.Forms.DataGridViewComboBoxColumn cbAction;
    }
}

================================================
FILE: FastColoredTextBox/HotkeysEditorForm.cs
================================================
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

namespace FastColoredTextBoxNS
{
    public partial class HotkeysEditorForm : Form
    {
        BindingList<HotkeyWrapper> wrappers = new BindingList<HotkeyWrapper>();

        public HotkeysEditorForm(HotkeysMapping hotkeys)
        {
            InitializeComponent();
            BuildWrappers(hotkeys);
            dgv.DataSource = wrappers;
        }

        int CompereKeys(Keys key1, Keys key2)
        {
            var res = ((int) key1 & 0xff).CompareTo((int) key2 & 0xff);
            if (res == 0)
                res = key1.CompareTo(key2);

            return res;
        }

        private void BuildWrappers(HotkeysMapping hotkeys)
        {
            var keys = new List<Keys>(hotkeys.Keys);
            keys.Sort(CompereKeys);

            wrappers.Clear();
            foreach (var k in keys)
                wrappers.Add(new HotkeyWrapper(k, hotkeys[k]));
        }

        /// <summary>
        /// Returns edited hotkey map
        /// </summary>
        /// <returns></returns>
        public HotkeysMapping GetHotkeys()
        {
            var result = new HotkeysMapping();
            foreach (var w in wrappers)
                result[w.ToKeyData()] = w.Action;

            return result;
        }

        private void btAdd_Click(object sender, EventArgs e)
        {
            wrappers.Add(new HotkeyWrapper(Keys.None, FCTBAction.None));
        }

        private void dgv_RowsAdded(object sender, DataGridViewRowsAddedEventArgs e)
        {
            var cell = (dgv[0, e.RowIndex] as DataGridViewComboBoxCell);
            if (cell.Items.Count == 0)
                foreach (var item in new string[]
                    {"", "Ctrl", "Ctrl + Shift", "Ctrl + Alt", "Shift", "Shift + Alt", "Alt", "Ctrl + Shift + Alt"})
                    cell.Items.Add(item);

            cell = (dgv[1, e.RowIndex] as DataGridViewComboBoxCell);
            if (cell.Items.Count == 0)
                foreach (var item in Enum.GetValues(typeof(Keys)))
                    cell.Items.Add(item);

            cell = (dgv[2, e.RowIndex] as DataGridViewComboBoxCell);
            if (cell.Items.Count == 0)
                foreach (var item in Enum.GetValues(typeof(FCTBAction)))
                    cell.Items.Add(item);
        }

        private void btResore_Click(object sender, EventArgs e)
        {
            HotkeysMapping h = new HotkeysMapping();
            h.InitDefault();
            BuildWrappers(h);
        }

        private void btRemove_Click(object sender, EventArgs e)
        {
            for (int i = dgv.RowCount - 1; i >= 0; i--)
                if (dgv.Rows[i].Selected)
                    dgv.Rows.RemoveAt(i);
        }

        private void HotkeysEditorForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (DialogResult == System.Windows.Forms.DialogResult.OK)
            {
                var actions = GetUnAssignedActions();
                if (!string.IsNullOrEmpty(actions))
                {
                    if (MessageBox.Show(
                            "Some actions are not assigned!\r\nActions: " + actions +
                            "\r\nPress Yes to save and exit, press No to continue editing",
                            "Some actions is not assigned", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) ==
                        System.Windows.Forms.DialogResult.No)
                        e.Cancel = true;
                }
            }
        }

        private string GetUnAssignedActions()
        {
            StringBuilder sb = new StringBuilder();
            var dic = new Dictionary<FCTBAction, FCTBAction>();

            foreach (var w in wrappers)
                dic[w.Action] = w.Action;

            foreach (var item in Enum.GetValues(typeof(FCTBAction)))
                if ((FCTBAction) item != FCTBAction.None)
                    if (!((FCTBAction) item).ToString().StartsWith("CustomAction"))
                    {
                        if (!dic.ContainsKey((FCTBAction) item))
                            sb.Append(item + ", ");
                    }

            return sb.ToString().TrimEnd(' ', ',');
        }
    }

    internal class HotkeyWrapper
    {
        public HotkeyWrapper(Keys keyData, FCTBAction action)
        {
            KeyEventArgs a = new KeyEventArgs(keyData);
            Ctrl = a.Control;
            Shift = a.Shift;
            Alt = a.Alt;

            Key = a.KeyCode;
            Action = action;
        }

        public Keys ToKeyData()
        {
            var res = Key;
            if (Ctrl) res |= Keys.Control;
            if (Alt) res |= Keys.Alt;
            if (Shift) res |= Keys.Shift;

            return res;
        }

        bool Ctrl;
        bool Shift;
        bool Alt;

        public string Modifiers
        {
            get
            {
                var res = "";
                if (Ctrl) res += "Ctrl + ";
                if (Shift) res += "Shift + ";
                if (Alt) res += "Alt + ";

                return res.Trim(' ', '+');
            }
            set
            {
                if (value == null)
                {
                    Ctrl = Alt = Shift = false;
                }
                else
                {
                    Ctrl = value.Contains("Ctrl");
                    Shift = value.Contains("Shift");
                    Alt = value.Contains("Alt");
                }
            }
        }

        public Keys Key { get; set; }
        public FCTBAction Action { get; set; }
    }
}

================================================
FILE: FastColoredTextBox/HotkeysEditorForm.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <metadata name="cbModifiers.UserAddedColumn" type="System.Boolean, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
    <value>True</value>
  </metadata>
  <metadata name="cbKey.UserAddedColumn" type="System.Boolean, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
    <value>True</value>
  </metadata>
  <metadata name="cbAction.UserAddedColumn" type="System.Boolean, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
    <value>True</value>
  </metadata>
</root>

================================================
FILE: FastColoredTextBox/LimitedStack.cs
================================================
using System;

namespace FastColoredTextBoxNS
{
    /// <summary>
    /// Limited stack
    /// </summary>
    public class LimitedStack<T>
    {
        T[] items;
        int count;
        int start;

        /// <summary>
        /// Max stack length
        /// </summary>
        public int MaxItemCount
        {
            get { return items.Length; }
        }

        /// <summary>
        /// Current length of stack
        /// </summary>
        public int Count
        {
            get { return count; }
        }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="maxItemCount">Maximum length of stack</param>
        public LimitedStack(int maxItemCount)
        {
            items = new T[maxItemCount];
            count = 0;
            start = 0;
        }

        /// <summary>
        /// Pop item
        /// </summary>
        public T Pop()
        {
            if (count == 0)
                throw new Exception("Stack is empty");

            int i = LastIndex;
            T item = items[i];
            items[i] = default(T);

            count--;

            return item;
        }

        int LastIndex
        {
            get { return (start + count - 1) % items.Length; }
        }

        /// <summary>
        /// Peek item
        /// </summary>
        public T Peek()
        {
            if (count == 0)
                return default(T);

            return items[LastIndex];
        }

        /// <summary>
        /// Push item
        /// </summary>
        public void Push(T item)
        {
            if (count == items.Length)
                start = (start + 1) % items.Length;
            else
                count++;

            items[LastIndex] = item;
        }

        /// <summary>
        /// Clear stack
        /// </summary>
        public void Clear()
        {
            items = new T[items.Length];
            count = 0;
            start = 0;
        }

        public T[] ToArray()
        {
            T[] result = new T[count];
            for (int i = 0; i < count; i++)
                result[i] = items[(start + i) % items.Length];
            return result;
        }
    }
}

================================================
FILE: FastColoredTextBox/Line.cs
================================================
using System.Collections.Generic;
using System;
using System.Text;
using System.Drawing;

namespace FastColoredTextBoxNS
{
    /// <summary>
    /// Line of text
    /// </summary>
    public class Line : IList<Char>
    {
        protected List<Char> chars;

        public string FoldingStartMarker { get; set; }
        public string FoldingEndMarker { get; set; }

        /// <summary>
        /// Text of line was changed
        /// </summary>
        public bool IsChanged { get; set; }

        /// <summary>
        /// Time of last visit of caret in this line
        /// </summary>
        /// <remarks>This property can be used for forward/backward navigating</remarks>
        public DateTime LastVisit { get; set; }

        /// <summary>
        /// Background brush.
        /// </summary>
        public Brush BackgroundBrush { get; set; }

        /// <summary>
        /// Unique ID
        /// </summary>
        public int UniqueId { get; private set; }

        /// <summary>
        /// Count of needed start spaces for AutoIndent
        /// </summary>
        public int AutoIndentSpacesNeededCount { get; set; }

        internal Line(int uid)
        {
            this.UniqueId = uid;
            chars = new List<Char>();
        }


        /// <summary>
        /// Clears style of chars, delete folding markers
        /// </summary>
        public void ClearStyle(StyleIndex styleIndex)
        {
            FoldingStartMarker = null;
            FoldingEndMarker = null;
            for (int i = 0; i < Count; i++)
            {
                Char c = this[i];
                c.style &= ~styleIndex;
                this[i] = c;
            }
        }

        /// <summary>
        /// Text of the line
        /// </summary>
        public virtual string Text
        {
            get
            {
                StringBuilder sb = new StringBuilder(Count);
                foreach (Char c in this)
                    sb.Append(c.c);
                return sb.ToString();
            }
        }

        /// <summary>
        /// Clears folding markers
        /// </summary>
        public void ClearFoldingMarkers()
        {
            FoldingStartMarker = null;
            FoldingEndMarker = null;
        }

        /// <summary>
        /// Count of start spaces
        /// </summary>
        public int StartSpacesCount
        {
            get
            {
                int spacesCount = 0;
                for (int i = 0; i < Count; i++)
                    if (this[i].c == ' ')
                        spacesCount++;
                    else
                        break;
                return spacesCount;
            }
        }

        public int IndexOf(Char item)
        {
            return chars.IndexOf(item);
        }

        public void Insert(int index, Char item)
        {
            chars.Insert(index, item);
        }

        public void RemoveAt(int index)
        {
            chars.RemoveAt(index);
        }

        public Char this[int index]
        {
            get { return chars[index]; }
            set { chars[index] = value; }
        }

        public void Add(Char item)
        {
            chars.Add(item);
        }

        public void Clear()
        {
            chars.Clear();
        }

        public bool Contains(Char item)
        {
            return chars.Contains(item);
        }

        public void CopyTo(Char[] array, int arrayIndex)
        {
            chars.CopyTo(array, arrayIndex);
        }

        /// <summary>
        /// Chars count
        /// </summary>
        public int Count
        {
            get { return chars.Count; }
        }

        public bool IsReadOnly
        {
            get { return false; }
        }

        public bool Remove(Char item)
        {
            return chars.Remove(item);
        }

        public IEnumerator<Char> GetEnumerator()
        {
            return chars.GetEnumerator();
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return chars.GetEnumerator() as System.Collections.IEnumerator;
        }

        public virtual void RemoveRange(int index, int count)
        {
            if (index >= Count)
                return;
            chars.RemoveRange(index, Math.Min(Count - index, count));
        }

        public virtual void TrimExcess()
        {
            chars.TrimExcess();
        }

        public virtual void AddRange(IEnumerable<Char> collection)
        {
            chars.AddRange(collection);
        }
    }

    public struct LineInfo
    {
        List<int> cutOffPositions;

        //Y coordinate of line on screen
        internal int startY;

        internal int bottomPadding;

        //indent of secondary wordwrap strings (in chars)
        internal int wordWrapIndent;

        /// <summary>
        /// Visible state
        /// </summary>
        public VisibleState VisibleState;

        public LineInfo(int startY)
        {
            cutOffPositions = null;
            VisibleState = VisibleState.Visible;
            this.startY = startY;
            bottomPadding = 0;
            wordWrapIndent = 0;
        }

        /// <summary>
        /// Positions for wordwrap cutoffs
        /// </summary>
        public List<int> CutOffPositions
        {
            get
            {
                if (cutOffPositions == null)
                    cutOffPositions = new List<int>();
                return cutOffPositions;
            }
        }

        /// <summary>
        /// Count of wordwrap string count for this line
        /// </summary>
        public int WordWrapStringsCount
        {
            get
            {
                switch (VisibleState)
                {
                    case VisibleState.Visible:
                        if (cutOffPositions == null)
                            return 1;
                        else
                            return cutOffPositions.Count + 1;
                    case VisibleState.Hidden: return 0;
                    case VisibleState.StartOfHiddenBlock: return 1;
                }

                return 0;
            }
        }

        internal int GetWordWrapStringStartPosition(int iWordWrapLine)
        {
            return iWordWrapLine == 0 ? 0 : CutOffPositions[iWordWrapLine - 1];
        }

        internal int GetWordWrapStringFinishPosition(int iWordWrapLine, Line line)
        {
            if (WordWrapStringsCount <= 0)
                return 0;
            return iWordWrapLine == WordWrapStringsCount - 1 ? line.Count - 1 : CutOffPositions[iWordWrapLine] - 1;
        }

        /// <summary>
        /// Gets index of wordwrap string for given char position
        /// </summary>
        public int GetWordWrapStringIndex(int iChar)
        {
            if (cutOffPositions == null || cutOffPositions.Count == 0) return 0;
            for (int i = 0; i < cutOffPositions.Count; i++)
                if (cutOffPositions[i] > /*>=*/ iChar)
                    return i;
            return cutOffPositions.Count;
        }
    }

    public enum VisibleState : byte
    {
        Visible,
        StartOfHiddenBlock,
        Hidden
    }

    public enum IndentMarker
    {
        None,
        Increased,
        Decreased
    }
}

================================================
FILE: FastColoredTextBox/LinesAccessor.cs
================================================
using System;
using System.Collections.Generic;
using System.Text;

namespace FastColoredTextBoxNS
{
    public class LinesAccessor : IList<string>
    {
        IList<Line> ts;

        public LinesAccessor(IList<Line> ts)
        {
            this.ts = ts;
        }

        public int IndexOf(string item)
        {
            for (int i = 0; i < ts.Count; i++)
                if (ts[i].Text == item)
                    return i;

            return -1;
        }

        public void Insert(int index, string item)
        {
            throw new NotImplementedException();
        }

        public void RemoveAt(int index)
        {
            throw new NotImplementedException();
        }

        public string this[int index]
        {
            get { return ts[index].Text; }
            set { throw new NotImplementedException(); }
        }

        public void Add(string item)
        {
            throw new NotImplementedException();
        }

        public void Clear()
        {
            throw new NotImplementedException();
        }

        public bool Contains(string item)
        {
            for (int i = 0; i < ts.Count; i++)
                if (ts[i].Text == item)
                    return true;

            return false;
        }

        public void CopyTo(string[] array, int arrayIndex)
        {
            for (int i = 0; i < ts.Count; i++)
                array[i + arrayIndex] = ts[i].Text;
        }

        public int Count
        {
            get { return ts.Count; }
        }

        public bool IsReadOnly
        {
            get { return true; }
        }

        public bool Remove(string item)
        {
            throw new NotImplementedException();
        }

        public IEnumerator<string> GetEnumerator()
        {
            for (int i = 0; i < ts.Count; i++)
                yield return ts[i].Text;
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
    }
}

================================================
FILE: FastColoredTextBox/MacrosManager.cs
================================================
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Text;
using System.Threading;
using System.Windows.Forms;
using System.Xml;

namespace FastColoredTextBoxNS
{
    /// <summary>
    /// This class records, stores and executes the macros.
    /// </summary>
    public class MacrosManager
    {
        private readonly List<object> macro = new List<object>();

        internal MacrosManager(FastColoredTextBox ctrl)
        {
            UnderlayingControl = ctrl;
            AllowMacroRecordingByUser = true;
        }

        /// <summary>
        /// Allows to user to record macros
        /// </summary>
        public bool AllowMacroRecordingByUser { get; set; }

        private bool isRecording;

        /// <summary>
        /// Returns current recording state. Set to True/False to start/stop recording programmatically.
        /// </summary>
        public bool IsRecording
        {
            get { return isRecording; }
            set
            {
                isRecording = value;
                UnderlayingControl.Invalidate();
            }
        }

        /// <summary>
        /// FCTB
        /// </summary>
        public FastColoredTextBox UnderlayingControl { get; private set; }

        /// <summary>
        /// Executes recorded macro
        /// </summary>
        /// <returns></returns>
        public void ExecuteMacros()
        {
            IsRecording = false;
            UnderlayingControl.BeginUpdate();
            UnderlayingControl.Selection.BeginUpdate();
            UnderlayingControl.BeginAutoUndo();
            foreach (var item in macro)
            {
                if (item is Keys)
                {
                    UnderlayingControl.ProcessKey((Keys) item);
                }

                if (item is KeyValuePair<char, Keys>)
                {
                    var p = (KeyValuePair<char, Keys>) item;
                    UnderlayingControl.ProcessKey(p.Key, p.Value);
                }
            }

            UnderlayingControl.EndAutoUndo();
            UnderlayingControl.Selection.EndUpdate();
            UnderlayingControl.EndUpdate();
        }

        /// <summary>
        /// Adds the char to current macro
        /// </summary>
        public void AddCharToMacros(char c, Keys modifiers)
        {
            macro.Add(new KeyValuePair<char, Keys>(c, modifiers));
        }

        /// <summary>
        /// Adds keyboard key to current macro
        /// </summary>
        public void AddKeyToMacros(Keys keyData)
        {
            macro.Add(keyData);
        }

        /// <summary>
        /// Clears last recorded macro
        /// </summary>
        public void ClearMacros()
        {
            macro.Clear();
        }


        internal void ProcessKey(Keys keyData)
        {
            if (IsRecording)
                AddKeyToMacros(keyData);
        }

        internal void ProcessKey(char c, Keys modifiers)
        {
            if (IsRecording)
                AddCharToMacros(c, modifiers);
        }

        /// <summary>
        /// Returns True if last macro is empty
        /// </summary>
        public bool MacroIsEmpty
        {
            get { return macro.Count == 0; }
        }

        /// <summary>
        /// Macros as string.
        /// </summary>
        public string Macros
        {
            get
            {
                var cult = Thread.CurrentThread.CurrentUICulture;
                Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
                var kc = new KeysConverter();

                StringBuilder sb = new StringBuilder();
                sb.AppendLine("<macros>");
                foreach (var item in macro)
                {
                    if (item is Keys)
                    {
                        sb.AppendFormat("<item key='{0}' />\r\n", kc.ConvertToString((Keys) item));
                    }
                    else if (item is KeyValuePair<char, Keys>)
                    {
                        var p = (KeyValuePair<char, Keys>) item;
                        sb.AppendFormat("<item char='{0}' key='{1}' />\r\n", (int) p.Key, kc.ConvertToString(p.Value));
                    }
                }

                sb.AppendLine("</macros>");

                Thread.CurrentThread.CurrentUICulture = cult;

                return sb.ToString();
            }

            set
            {
                isRecording = false;
                ClearMacros();

                if (string.IsNullOrEmpty(value))
                    return;

                var doc = new XmlDocument();
                doc.LoadXml(value);
                var list = doc.SelectNodes("./macros/item");

                var cult = Thread.CurrentThread.CurrentUICulture;
                Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
                var kc = new KeysConverter();

                if (list != null)
                    foreach (XmlElement node in list)
                    {
                        var ca = node.GetAttributeNode("char");
                        var ka = node.GetAttributeNode("key");
                        if (ca != null)
                        {
                            if (ka != null)
                                AddCharToMacros((char) int.Parse(ca.Value), (Keys) kc.ConvertFromString(ka.Value));
                            else
                                AddCharToMacros((char) int.Parse(ca.Value), Keys.None);
                        }
                        else if (ka != null)
                            AddKeyToMacros((Keys) kc.ConvertFromString(ka.Value));
                    }

                Thread.CurrentThread.CurrentUICulture = cult;
            }
        }
    }
}

================================================
FILE: FastColoredTextBox/NativeMethods.cs
================================================
using System;
using System.Runtime.InteropServices;

namespace FastColoredTextBoxNS
{
    public static class NativeMethodWrapper {
        public static void GetNativeSystemInfo(ref Win32NativeMethods.SYSTEM_INFO sysInfo)
        {
             Win32NativeMethods.GetNativeSystemInfo(ref sysInfo);
             return;
        }

        public static void GetSystemInfo(ref Win32NativeMethods.SYSTEM_INFO sysInfo)
        {
            Win32NativeMethods.GetSystemInfo(ref sysInfo);
            return;        
        }

        public static void ShowCaret(IntPtr handle)
        {
            if (Environment.OSVersion.Platform != PlatformID.Unix)
                Win32NativeMethods.ShowCaret(handle);
        }

        public static void SetCaretPos(int carX, int carY)
        {
            if (Environment.OSVersion.Platform != PlatformID.Unix)
                Win32NativeMethods.SetCaretPos(carX,carY);        }

        public static void CreateCaret(IntPtr handle, int i, int carWidth, int caretHeight)
        {
            if (Environment.OSVersion.Platform != PlatformID.Unix)
                Win32NativeMethods.CreateCaret(handle,i,carWidth,caretHeight);
        }

        public static void HideCaret(IntPtr handle)
        {
            if (Environment.OSVersion.Platform != PlatformID.Unix)
                Win32NativeMethods.HideCaret(handle);
        }

        public static void SendMessage(IntPtr handle, int wmSetredraw, int i, int i1)
        {
            if (Environment.OSVersion.Platform != PlatformID.Unix)
                Win32NativeMethods.SendMessage(handle,wmSetredraw,i,i1);
        }

        public static IntPtr ImmGetContext(IntPtr handle)
        {
            if (Environment.OSVersion.Platform != PlatformID.Unix)
                return Win32NativeMethods.ImmGetContext(handle);
            return IntPtr.Zero;
        }

        public static void CloseClipboard()
        {
            if (Environment.OSVersion.Platform != PlatformID.Unix)
                Win32NativeMethods.CloseClipboard();        
        }

        public static void ImmAssociateContext(IntPtr handle, IntPtr mHImc)
        {
            if (Environment.OSVersion.Platform != PlatformID.Unix)
                Win32NativeMethods.ImmAssociateContext(handle,mHImc); 
        }
    }
    
    public static class Win32NativeMethods
    {
        [DllImport("User32.dll")]
        public static extern bool CreateCaret(IntPtr hWnd, int hBitmap, int nWidth, int nHeight);

        [DllImport("User32.dll")]
        public static extern bool SetCaretPos(int x, int y);

        [DllImport("User32.dll")]
        public static extern bool DestroyCaret();

        [DllImport("User32.dll")]
        public static extern bool ShowCaret(IntPtr hWnd);

        [DllImport("User32.dll")]
        public static extern bool HideCaret(IntPtr hWnd);
        
        [DllImport("Imm32.dll")]
        public static extern IntPtr ImmGetContext(IntPtr hWnd);

        [DllImport("Imm32.dll")]
        public static extern IntPtr ImmAssociateContext(IntPtr hWnd, IntPtr hIMC);
        
        [DllImport("user32.dll")]
        public static extern IntPtr GetOpenClipboardWindow();

        [DllImport("user32.dll")]
        public static extern IntPtr CloseClipboard();
        
        [DllImport("user32.dll")]
        public static extern int SendMessage(IntPtr hwnd, int wMsg, int wParam, int lParam);
        
        [DllImport("kernel32.dll")]
        public static extern void GetNativeSystemInfo(ref SYSTEM_INFO lpSystemInfo);

        [DllImport("kernel32.dll")]
        public static extern void GetSystemInfo(ref SYSTEM_INFO lpSystemInfo);
        
        [StructLayout(LayoutKind.Sequential)]
        public struct SYSTEM_INFO
        {
            public ushort wProcessorArchitecture;
            public ushort wReserved;
            public uint dwPageSize;
            public IntPtr lpMinimumApplicationAddress;
            public IntPtr lpMaximumApplicationAddress;
            public UIntPtr dwActiveProcessorMask;
            public uint dwNumberOfProcessors;
            public uint dwProcessorType;
            public uint dwAllocationGranularity;
            public ushort wProcessorLevel;
            public ushort wProcessorRevision;
        };
    }
}

================================================
FILE: FastColoredTextBox/Place.cs
================================================
using System;

namespace FastColoredTextBoxNS
{
    /// <summary>
    /// Line index and char index
    /// </summary>
    public struct Place : IEquatable<Place>
    {
        public int iChar;
        public int iLine;

        public Place(int iChar, int iLine)
        {
            this.iChar = iChar;
            this.iLine = iLine;
        }

        public void Offset(int dx, int dy)
        {
            iChar += dx;
            iLine += dy;
        }

        public bool Equals(Place other)
        {
            return iChar == other.iChar && iLine == other.iLine;
        }

        public override bool Equals(object obj)
        {
            return (obj is Place) && Equals((Place) obj);
        }

        public override int GetHashCode()
        {
            return iChar.GetHashCode() ^ iLine.GetHashCode();
        }

        public static bool operator !=(Place p1, Place p2)
        {
            return !p1.Equals(p2);
        }

        public static bool operator ==(Place p1, Place p2)
        {
            return p1.Equals(p2);
        }

        public static bool operator <(Place p1, Place p2)
        {
            if (p1.iLine < p2.iLine) return true;
            if (p1.iLine > p2.iLine) return false;
            if (p1.iChar < p2.iChar) return true;
            return false;
        }

        public static bool operator <=(Place p1, Place p2)
        {
            if (p1.Equals(p2)) return true;
            if (p1.iLine < p2.iLine) return true;
            if (p1.iLine > p2.iLine) return false;
            if (p1.iChar < p2.iChar) return true;
            return false;
        }

        public static bool operator >(Place p1, Place p2)
        {
            if (p1.iLine > p2.iLine) return true;
            if (p1.iLine < p2.iLine) return false;
            if (p1.iChar > p2.iChar) return true;
            return false;
        }

        public static bool operator >=(Place p1, Place p2)
        {
            if (p1.Equals(p2)) return true;
            if (p1.iLine > p2.iLine) return true;
            if (p1.iLine < p2.iLine) return false;
            if (p1.iChar > p2.iChar) return true;
            return false;
        }

        public static Place operator +(Place p1, Place p2)
        {
            return new Place(p1.iChar + p2.iChar, p1.iLine + p2.iLine);
        }

        public static Place Empty
        {
            get { return new Place(); }
        }

        public override string ToString()
        {
            return "(" + iChar + "," + iLine + ")";
        }
    }
}

================================================
FILE: FastColoredTextBox/PlatformType.cs
================================================
using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;

namespace FastColoredTextBoxNS
{
    public static class PlatformType
    {
        const ushort PROCESSOR_ARCHITECTURE_INTEL = 0;
        const ushort PROCESSOR_ARCHITECTURE_IA64 = 6;
        const ushort PROCESSOR_ARCHITECTURE_AMD64 = 9;
        const ushort PROCESSOR_ARCHITECTURE_UNKNOWN = 0xFFFF;
        

        public static Platform GetOperationSystemPlatform()
        {
            if (Environment.OSVersion.Platform == PlatformID.Unix)
                return Environment.Is64BitOperatingSystem  ? Platform.X64 : Platform.X86;
            var sysInfo = new Win32NativeMethods.SYSTEM_INFO();

            // WinXP and older - use GetNativeSystemInfo
            if (Environment.OSVersion.Version.Major > 5 ||
                (Environment.OSVersion.Version.Major == 5 && Environment.OSVersion.Version.Minor >= 1))
            {
                NativeMethodWrapper.GetNativeSystemInfo(ref sysInfo);
            }
            // else use GetSystemInfo
            else
            {
                NativeMethodWrapper.GetSystemInfo(ref sysInfo);
            }

            switch (sysInfo.wProcessorArchitecture)
            {
                case PROCESSOR_ARCHITECTURE_IA64:
                case PROCESSOR_ARCHITECTURE_AMD64:
                    return Platform.X64;

                case PROCESSOR_ARCHITECTURE_INTEL:
                    return Platform.X86;

                default:
                    return Platform.Unknown;
            }
        }
    }

    public enum Platform
    {
        X86,
        X64,
        Unknown
    }
}

================================================
FILE: FastColoredTextBox/Properties/AssemblyInfo.cs
================================================
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

// General Information about an assembly is controlled through the following 
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("FastColoredTextBox")]
[assembly: AssemblyDescription("Fast сolored textbox control")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Pavel Torgashov")]
[assembly: AssemblyProduct("FastColoredTextBox")]
[assembly: AssemblyCopyright("© Pavel Torgashov, 2011-2016, pavel_torgashov@ukr.net.")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]

// Setting ComVisible to false makes the types in this assembly not visible 
// to COM components.  If you need to access a type in this assembly from 
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]

// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("95be11b3-45bc-4512-be26-a860a78bd1f1")]

// Version information for an assembly consists of the following four values:
//
//      Major Version
//      Minor Version 
//      Build Number
//      Revision
//
// You can specify all the values or you can default the Build and Revision Numbers 
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("2.16.23.0")]
[assembly: AssemblyFileVersion("2.16.23.0")]

================================================
FILE: FastColoredTextBox/Range.cs
================================================
using System;
using System.Text;
using System.Drawing;
using System.Text.RegularExpressions;
using System.Collections.Generic;

namespace FastColoredTextBoxNS
{
    /// <summary>
    /// Diapason of text chars
    /// </summary>
    public class Range : IEnumerable<Place>
    {
        Place start;
        Place end;
        public readonly FastColoredTextBox tb;
        int preferedPos = -1;
        int updating = 0;

        string cachedText;
        List<Place> cachedCharIndexToPlace;
        int cachedTextVersion = -1;

        /// <summary>
        /// Constructor
        /// </summary>
        public Range(FastColoredTextBox tb)
        {
            this.tb = tb;
        }

        /// <summary>
        /// Return true if no selected text
        /// </summary>
        public virtual bool IsEmpty
        {
            get
            {
                if (ColumnSelectionMode)
                    return Start.iChar == End.iChar;
                return Start == End;
            }
        }

        private bool columnSelectionMode;

        /// <summary>
        /// Column selection mode
        /// </summary>
        public bool ColumnSelectionMode
        {
            get { return columnSelectionMode; }
            set { columnSelectionMode = value; }
        }

        /// <summary>
        /// Constructor
        /// </summary>
        public Range(FastColoredTextBox tb, int iStartChar, int iStartLine, int iEndChar, int iEndLine)
            : this(tb)
        {
            start = new Place(iStartChar, iStartLine);
            end = new Place(iEndChar, iEndLine);
        }

        /// <summary>
        /// Constructor
        /// </summary>
        public Range(FastColoredTextBox tb, Place start, Place end)
            : this(tb)
        {
            this.start = start;
            this.end = end;
        }

        /// <summary>
        /// Constructor. Creates range of the line
        /// </summary>
        public Range(FastColoredTextBox tb, int iLine)
            : this(tb)
        {
            start = new Place(0, iLine);
            end = new Place(tb[iLine].Count, iLine);
        }

        public bool Contains(Place place)
        {
            if (place.iLine < Math.Min(start.iLine, end.iLine)) return false;
            if (place.iLine > Math.Max(start.iLine, end.iLine)) return false;

            Place s = start;
            Place e = end;
            //normalize start and end
            if (s.iLine > e.iLine || (s.iLine == e.iLine && s.iChar > e.iChar))
            {
                var temp = s;
                s = e;
                e = temp;
            }

            if (columnSelectionMode)
            {
                if (place.iChar < s.iChar || place.iChar > e.iChar) return false;
            }
            else
            {
                if (place.iLine == s.iLine && place.iChar < s.iChar) return false;
                if (place.iLine == e.iLine && place.iChar > e.iChar) return false;
            }

            return true;
        }

        /// <summary>
        /// Returns intersection with other range,
        /// empty range returned otherwise
        /// </summary>
        /// <param name="range"></param>
        /// <returns></returns>
        public virtual Range GetIntersectionWith(Range range)
        {
            if (ColumnSelectionMode)
                return GetIntersectionWith_ColumnSelectionMode(range);

            Range r1 = this.Clone();
            Range r2 = range.Clone();
            r1.Normalize();
            r2.Normalize();
            Place newStart = r1.Start > r2.Start ? r1.Start : r2.Start;
            Place newEnd = r1.End < r2.End ? r1.End : r2.End;
            if (newEnd < newStart)
                return new Range(tb, start, start);
            return tb.GetRange(newStart, newEnd);
        }

        /// <summary>
        /// Returns union with other range.
        /// </summary>
        /// <param name="range"></param>
        /// <returns></returns>
        public Range GetUnionWith(Range range)
        {
            Range r1 = this.Clone();
            Range r2 = range.Clone();
            r1.Normalize();
            r2.Normalize();
            Place newStart = r1.Start < r2.Start ? r1.Start : r2.Start;
            Place newEnd = r1.End > r2.End ? r1.End : r2.End;

            return tb.GetRange(newStart, newEnd);
        }

        /// <summary>
        /// Select all chars of control
        /// </summary>
        public void SelectAll()
        {
            ColumnSelectionMode = false;

            Start = new Place(0, 0);
            if (tb.LinesCount == 0)
                Start = new Place(0, 0);
            else
            {
                end = new Place(0, 0);
                start = new Place(tb[tb.LinesCount - 1].Count, tb.LinesCount - 1);
            }

            if (this == tb.Selection)
                tb.Invalidate();
        }

        /// <summary>
        /// Start line and char position
        /// </summary>
        public Place Start
        {
            get { return start; }
            set
            {
                end = start = value;
                preferedPos = -1;
                OnSelectionChanged();
            }
        }

        /// <summary>
        /// Finish line and char position
        /// </summary>
        public Place End
        {
            get { return end; }
            set
            {
                end = value;
                OnSelectionChanged();
            }
        }

        /// <summary>
        /// Text of range
        /// </summary>
        /// <remarks>This property has not 'set' accessor because undo/redo stack works only with 
        /// FastColoredTextBox.Selection range. So, if you want to set text, you need to use FastColoredTextBox.Selection
        /// and FastColoredTextBox.InsertText() mehtod.
        /// </remarks>
        public virtual string Text
        {
            get
            {
                if (ColumnSelectionMode)
                    return Text_ColumnSelectionMode;

                int fromLine = Math.Min(end.iLine, start.iLine);
                int toLine = Math.Max(end.iLine, start.iLine);
                int fromChar = FromX;
                int toChar = ToX;
                if (fromLine < 0) return null;
                //
                StringBuilder sb = new StringBuilder();
                for (int y = fromLine; y <= toLine; y++)
                {
                    int fromX = y == fromLine ? fromChar : 0;
                    int toX = y == toLine ? Math.Min(tb[y].Count - 1, toChar - 1) : tb[y].Count - 1;
                    for (int x = fromX; x <= toX; x++)
                        sb.Append(tb[y][x].c);
                    if (y != toLine && fromLine != toLine)
                        sb.AppendLine();
                }

                return sb.ToString();
            }
        }

        public int Length
        {
            get
            {
                if (ColumnSelectionMode)
                    return Length_ColumnSelectionMode(false);

                int fromLine = Math.Min(end.iLine, start.iLine);
                int toLine = Math.Max(end.iLine, start.iLine);
                int cnt = 0;
                if (fromLine < 0) return 0;

                for (int y = fromLine; y <= toLine; y++)
                {
                    int fromX = y == fromLine ? FromX : 0;
                    int toX = y == toLine ? Math.Min(tb[y].Count - 1, ToX - 1) : tb[y].Count - 1;

                    cnt += toX - fromX + 1;

                    if (y != toLine && fromLine != toLine)
                        cnt += Environment.NewLine.Length;
                }

                return cnt;
            }
        }

        public int TextLength
        {
            get
            {
                if (ColumnSelectionMode)
                    return Length_ColumnSelectionMode(true);
                else
                    return Length;
            }
        }

        internal void GetText(out string text, out List<Place> charIndexToPlace)
        {
            //try get cached text
            if (tb.TextVersion == cachedTextVersion)
            {
                text = cachedText;
                charIndexToPlace = cachedCharIndexToPlace;
                return;
            }

            //
            int fromLine = Math.Min(end.iLine, start.iLine);
            int toLine = Math.Max(end.iLine, start.iLine);
            int fromChar = FromX;
            int toChar = ToX;

            StringBuilder sb = new StringBuilder((toLine - fromLine) * 50);
            charIndexToPlace = new List<Place>(sb.Capacity);
            if (fromLine >= 0)
            {
                for (int y = fromLine; y <= toLine; y++)
                {
                    int fromX = y == fromLine ? fromChar : 0;
                    int toX = y == toLine ? Math.Min(toChar - 1, tb[y].Count - 1) : tb[y].Count - 1;
                    for (int x = fromX; x <= toX; x++)
                    {
                        sb.Append(tb[y][x].c);
                        charIndexToPlace.Add(new Place(x, y));
                    }

                    if (y != toLine && fromLine != toLine)
                        foreach (char c in Environment.NewLine)
                        {
                            sb.Append(c);
                            charIndexToPlace.Add(new Place(tb[y].Count /*???*/, y));
                        }
                }
            }

            text = sb.ToString();
            charIndexToPlace.Add(End > Start ? End : Start);
            //caching
            cachedText = text;
            cachedCharIndexToPlace = charIndexToPlace;
            cachedTextVersion = tb.TextVersion;
        }

        /// <summary>
        /// Returns first char after Start place
        /// </summary>
        public char CharAfterStart
        {
            get
            {
                if (Start.iChar >= tb[Start.iLine].Count)
                    return '\n';
                return tb[Start.iLine][Start.iChar].c;
            }
        }

        /// <summary>
        /// Returns first char before Start place
        /// </summary>
        public char CharBeforeStart
        {
            get
            {
                if (Start.iChar > tb[Start.iLine].Count)
                    return '\n';
                if (Start.iChar <= 0)
                    return '\n';
                return tb[Start.iLine][Start.iChar - 1].c;
            }
        }

        /// <summary>
        /// Returns required char's number before start of the Range
        /// </summary>
        public string GetCharsBeforeStart(int charsCount)
        {
            var pos = tb.PlaceToPosition(Start) - charsCount;
            if (pos < 0) pos = 0;

            return new Range(tb, tb.PositionToPlace(pos), Start).Text;
        }

        /// <summary>
        /// Returns required char's number after start of the Range
        /// </summary>
        public string GetCharsAfterStart(int charsCount)
        {
            return GetCharsBeforeStart(-charsCount);
        }

        /// <summary>
        /// Clone range
        /// </summary>
        /// <returns></returns>
        public Range Clone()
        {
            return (Range) MemberwiseClone();
        }

        /// <summary>
        /// Return minimum of end.X and start.X
        /// </summary>
        internal int FromX
        {
            get
            {
                if (end.iLine < start.iLine) return end.iChar;
                if (end.iLine > start.iLine) return start.iChar;
                return Math.Min(end.iChar, start.iChar);
            }
        }

        /// <summary>
        /// Return maximum of end.X and start.X
        /// </summary>
        internal int ToX
        {
            get
            {
                if (end.iLine < start.iLine) return start.iChar;
                if (end.iLine > start.iLine) return end.iChar;
                return Math.Max(end.iChar, start.iChar);
            }
        }

        public int FromLine
        {
            get { return Math.Min(Start.iLine, End.iLine); }
        }

        public int ToLine
        {
            get { return Math.Max(Start.iLine, End.iLine); }
        }

        /// <summary>
        /// Move range right
        /// </summary>
        /// <remarks>This method jump over folded blocks</remarks>
        public bool GoRight()
        {
            Place prevStart = start;
            GoRight(false);
            return prevStart != start;
        }

        /// <summary>
        /// Move range left
        /// </summary>
        /// <remarks>This method can to go inside folded blocks</remarks>
        public virtual bool GoRightThroughFolded()
        {
            if (ColumnSelectionMode)
                return GoRightThroughFolded_ColumnSelectionMode();

            if (start.iLine >= tb.LinesCount - 1 && start.iChar >= tb[tb.LinesCount - 1].Count)
                return false;

            if (start.iChar < tb[start.iLine].Count)
                start.Offset(1, 0);
            else
                start = new Place(0, start.iLine + 1);

            preferedPos = -1;
            end = start;
            OnSelectionChanged();
            return true;
        }

        /// <summary>
        /// Move range left
        /// </summary>
        /// <remarks>This method jump over folded blocks</remarks>
        public bool GoLeft()
        {
            ColumnSelectionMode = false;

            Place prevStart = start;
            GoLeft(false);
            return prevStart != start;
        }

        /// <summary>
        /// Move range left
        /// </summary>
        /// <remarks>This method can to go inside folded blocks</remarks>
        public bool GoLeftThroughFolded()
        {
            ColumnSelectionMode = false;

            if (start.iChar == 0 && start.iLine == 0)
                return false;

            if (start.iChar > 0)
                start.Offset(-1, 0);
            else
                start = new Place(tb[start.iLine - 1].Count, start.iLine - 1);

            preferedPos = -1;
            end = start;
            OnSelectionChanged();
            return true;
        }

        public void GoLeft(bool shift)
        {
            ColumnSelectionMode = false;

            if (!shift)
                if (start > end)
                {
                    Start = End;
                    return;
                }

            if (start.iChar != 0 || start.iLine != 0)
            {
                if (start.iChar > 0 && tb.LineInfos[start.iLine].VisibleState == VisibleState.Visible)
                    start.Offset(-1, 0);
                else
                {
                    int i = tb.FindPrevVisibleLine(start.iLine);
                    if (i == start.iLine) return;
                    start = new Place(tb[i].Count, i);
                }
            }

            if (!shift)
                end = start;

            OnSelectionChanged();

            preferedPos = -1;
        }

        public void GoRight(bool shift)
        {
            ColumnSelectionMode = false;

            if (!shift)
                if (start < end)
                {
                    Start = End;
                    return;
                }

            if (start.iLine < tb.LinesCount - 1 || start.iChar < tb[tb.LinesCount - 1].Count)
            {
                if (start.iChar < tb[start.iLine].Count &&
                    tb.LineInfos[start.iLine].VisibleState == VisibleState.Visible)
                    start.Offset(1, 0);
                else
                {
                    int i = tb.FindNextVisibleLine(start.iLine);
                    if (i == start.iLine) return;
                    start = new Place(0, i);
                }
            }

            if (!shift)
                end = start;

            OnSelectionChanged();

            preferedPos = -1;
        }

        internal void GoUp(bool shift)
        {
            ColumnSelectionMode = false;

            if (!shift)
                if (start.iLine > end.iLine)
                {
                    Start = End;
                    return;
                }

            if (preferedPos < 0)
                preferedPos = start.iChar - tb.LineInfos[start.iLine]
                                  .GetWordWrapStringStartPosition(tb.LineInfos[start.iLine]
                                      .GetWordWrapStringIndex(start.iChar));

            int iWW = tb.LineInfos[start.iLine].GetWordWrapStringIndex(start.iChar);
            if (iWW == 0)
            {
                if (start.iLine <= 0) return;
                int i = tb.FindPrevVisibleLine(start.iLine);
                if (i == start.iLine) return;
                start.iLine = i;
                iWW = tb.LineInfos[start.iLine].WordWrapStringsCount;
            }

            if (iWW > 0)
            {
                int finish = tb.LineInfos[start.iLine].GetWordWrapStringFinishPosition(iWW - 1, tb[start.iLine]);
                start.iChar = tb.LineInfos[start.iLine].GetWordWrapStringStartPosition(iWW - 1) + preferedPos;
                if (start.iChar > finish + 1)
                    start.iChar = finish + 1;
            }

            if (!shift)
                end = start;

            OnSelectionChanged();
        }

        internal void GoPageUp(bool shift)
        {
            ColumnSelectionMode = false;

            if (preferedPos < 0)
                preferedPos = start.iChar - tb.LineInfos[start.iLine]
                                  .GetWordWrapStringStartPosition(tb.LineInfos[start.iLine]
                                      .GetWordWrapStringIndex(start.iChar));

            int pageHeight = tb.ClientRectangle.Height / tb.CharHeight - 1;

            for (int i = 0; i < pageHeight; i++)
            {
                int iWW = tb.LineInfos[start.iLine].GetWordWrapStringIndex(start.iChar);
                if (iWW == 0)
                {
                    if (start.iLine <= 0) break;
                    //pass hidden
                    int newLine = tb.FindPrevVisibleLine(start.iLine);
                    if (newLine == start.iLine) break;
                    start.iLine = newLine;
                    iWW = tb.LineInfos[start.iLine].WordWrapStringsCount;
                }

                if (iWW > 0)
                {
                    int finish = tb.LineInfos[start.iLine].GetWordWrapStringFinishPosition(iWW - 1, tb[start.iLine]);
                    start.iChar = tb.LineInfos[start.iLine].GetWordWrapStringStartPosition(iWW - 1) + preferedPos;
                    if (start.iChar > finish + 1)
                        start.iChar = finish + 1;
                }
            }

            if (!shift)
                end = start;

            OnSelectionChanged();
        }

        internal void GoDown(bool shift)
        {
            ColumnSelectionMode = false;

            if (!shift)
                if (start.iLine < end.iLine)
                {
                    Start = End;
                    return;
                }

            if (preferedPos < 0)
                preferedPos = start.iChar - tb.LineInfos[start.iLine]
                                  .GetWordWrapStringStartPosition(tb.LineInfos[start.iLine]
                                      .GetWordWrapStringIndex(start.iChar));

            int iWW = tb.LineInfos[start.iLine].GetWordWrapStringIndex(start.iChar);
            if (iWW >= tb.LineInfos[start.iLine].WordWrapStringsCount - 1)
            {
                if (start.iLine >= tb.LinesCount - 1) return;
                //pass hidden
                int i = tb.FindNextVisibleLine(start.iLine);
                if (i == start.iLine) return;
                start.iLine = i;
                iWW = -1;
            }

            if (iWW < tb.LineInfos[start.iLine].WordWrapStringsCount - 1)
            {
                int finish = tb.LineInfos[start.iLine].GetWordWrapStringFinishPosition(iWW + 1, tb[start.iLine]);
                start.iChar = tb.LineInfos[start.iLine].GetWordWrapStringStartPosition(iWW + 1) + preferedPos;
                if (start.iChar > finish + 1)
                    start.iChar = finish + 1;
            }

            if (!shift)
                end = start;

            OnSelectionChanged();
        }

        internal void GoPageDown(bool shift)
        {
            ColumnSelectionMode = false;

            if (preferedPos < 0)
                preferedPos = start.iChar - tb.LineInfos[start.iLine]
                                  .GetWordWrapStringStartPosition(tb.LineInfos[start.iLine]
                                      .GetWordWrapStringIndex(start.iChar));

            int pageHeight = tb.ClientRectangle.Height / tb.CharHeight - 1;

            for (int i = 0; i < pageHeight; i++)
            {
                int iWW = tb.LineInfos[start.iLine].GetWordWrapStringIndex(start.iChar);
                if (iWW >= tb.LineInfos[start.iLine].WordWrapStringsCount - 1)
                {
                    if (start.iLine >= tb.LinesCount - 1) break;
                    //pass hidden
                    int newLine = tb.FindNextVisibleLine(start.iLine);
                    if (newLine == start.iLine) break;
                    start.iLine = newLine;
                    iWW = -1;
                }

                if (iWW < tb.LineInfos[start.iLine].WordWrapStringsCount - 1)
                {
                    int finish = tb.LineInfos[start.iLine].GetWordWrapStringFinishPosition(iWW + 1, tb[start.iLine]);
                    start.iChar = tb.LineInfos[start.iLine].GetWordWrapStringStartPosition(iWW + 1) + preferedPos;
                    if (start.iChar > finish + 1)
                        start.iChar = finish + 1;
                }
            }

            if (!shift)
                end = start;

            OnSelectionChanged();
        }

        internal void GoHome(bool shift)
        {
            ColumnSelectionMode = false;

            if (start.iLine < 0)
                return;

            if (tb.LineInfos[start.iLine].VisibleState != VisibleState.Visible)
                return;

            start = new Place(0, start.iLine);

            if (!shift)
                end = start;

            OnSelectionChanged();

            preferedPos = -1;
        }

        internal void GoEnd(bool shift)
        {
            ColumnSelectionMode = false;

            if (start.iLine < 0)
                return;
            if (tb.LineInfos[start.iLine].VisibleState != VisibleState.Visible)
                return;

            start = new Place(tb[start.iLine].Count, start.iLine);

            if (!shift)
                end = start;

            OnSelectionChanged();

            preferedPos = -1;
        }

        /// <summary>
        /// Set style for range
        /// </summary>
        public void SetStyle(Style style)
        {
            //search code for style
            int code = tb.GetOrSetStyleLayerIndex(style);
            //set code to chars
            SetStyle(ToStyleIndex(code));
            //
            tb.Invalidate();
        }

        /// <summary>
        /// Set style for given regex pattern
        /// </summary>
        public void SetStyle(Style style, string regexPattern)
        {
            //search code for style
            StyleIndex layer = ToStyleIndex(tb.GetOrSetStyleLayerIndex(style));
            SetStyle(layer, regexPattern, RegexOptions.None);
        }

        /// <summary>
        /// Set style for given regex
        /// </summary>
        public void SetStyle(Style style, Regex regex)
        {
            //search code for style
            StyleIndex layer = ToStyleIndex(tb.GetOrSetStyleLayerIndex(style));
            SetStyle(layer, regex);
        }


        /// <summary>
        /// Set style for given regex pattern
        /// </summary>
        public void SetStyle(Style style, string regexPattern, RegexOptions options)
        {
            //search code for style
            StyleIndex layer = ToStyleIndex(tb.GetOrSetStyleLayerIndex(style));
            SetStyle(layer, regexPattern, options);
        }

        /// <summary>
        /// Set style for given regex pattern
        /// </summary>
        public void SetStyle(StyleIndex styleLayer, string regexPattern, RegexOptions options)
        {
            if (Math.Abs(Start.iLine - End.iLine) > 1000)
                options |= SyntaxHighlighter.RegexCompiledOption;
            //
            foreach (var range in GetRanges(regexPattern, options))
                range.SetStyle(styleLayer);
            //
            tb.Invalidate();
        }

        /// <summary>
        /// Set style for given regex pattern
        /// </summary>
        public void SetStyle(StyleIndex styleLayer, Regex regex)
        {
            foreach (var range in GetRanges(regex))
                range.SetStyle(styleLayer);
            //
            tb.Invalidate();
        }

        /// <summary>
        /// Appends style to chars of range
        /// </summary>
        public void SetStyle(StyleIndex styleIndex)
        {
            //set code to chars
            int fromLine = Math.Min(End.iLine, Start.iLine);
            int toLine = Math.Max(End.iLine, Start.iLine);
            int fromChar = FromX;
            int toChar = ToX;
            if (fromLine < 0) return;
            //
            for (int y = fromLine; y <= toLine; y++)
            {
                int fromX = y == fromLine ? fromChar : 0;
                int toX = y == toLine ? Math.Min(toChar - 1, tb[y].Count - 1) : tb[y].Count - 1;
                for (int x = fromX; x <= toX; x++)
                {
                    Char c = tb[y][x];
                    c.style |= styleIndex;
                    tb[y][x] = c;
                }
            }
        }

        /// <summary>
        /// Sets folding markers
        /// </summary>
        /// <param name="startFoldingPattern">Pattern for start folding line</param>
        /// <param name="finishFoldingPattern">Pattern for finish folding line</param>
        public void SetFoldingMarkers(string startFoldingPattern, string finishFoldingPattern)
        {
            SetFoldingMarkers(startFoldingPattern, finishFoldingPattern, SyntaxHighlighter.RegexCompiledOption);
        }

        /// <summary>
        /// Sets folding markers
        /// </summary>
        /// <param name="startFoldingPattern">Pattern for start folding line</param>
        /// <param name="finishFoldingPattern">Pattern for finish folding line</param>
        public void SetFoldingMarkers(string startFoldingPattern, string finishFoldingPattern, RegexOptions options)
        {
            if (startFoldingPattern == finishFoldingPattern)
            {
                SetFoldingMarkers(startFoldingPattern, options);
                return;
            }

            foreach (var range in GetRanges(startFoldingPattern, options))
                tb[range.Start.iLine].FoldingStartMarker = startFoldingPattern;

            foreach (var range in GetRanges(finishFoldingPattern, options))
                tb[range.Start.iLine].FoldingEndMarker = startFoldingPattern;
            //
            tb.Invalidate();
        }

        /// <summary>
        /// Sets folding markers
        /// </summary>
        /// <param name="startEndFoldingPattern">Pattern for start and end folding line</param>
        public void SetFoldingMarkers(string foldingPattern, RegexOptions options)
        {
            foreach (var range in GetRanges(foldingPattern, options))
            {
                if (range.Start.iLine > 0)
                    tb[range.Start.iLine - 1].FoldingEndMarker = foldingPattern;
                tb[range.Start.iLine].FoldingStartMarker = foldingPattern;
            }

            tb.Invalidate();
        }

        /// <summary>
        /// Finds ranges for given regex pattern
        /// </summary>
        /// <param name="regexPattern">Regex pattern</param>
        /// <returns>Enumeration of ranges</returns>
        public IEnumerable<Range> GetRanges(string regexPattern)
        {
            return GetRanges(regexPattern, RegexOptions.None);
        }

        /// <summary>
        /// Finds ranges for given regex pattern
        /// </summary>
        /// <param name="regexPattern">Regex pattern</param>
        /// <returns>Enumeration of ranges</returns>
        public IEnumerable<Range> GetRanges(string regexPattern, RegexOptions options)
        {
            //get text
            string text;
            List<Place> charIndexToPlace;
            GetText(out text, out charIndexToPlace);
            //create regex
            Regex regex = new Regex(regexPattern, options);
            //
            foreach (Match m in regex.Matches(text))
            {
                Range r = new Range(this.tb);
                //try get 'range' group, otherwise use group 0
                Group group = m.Groups["range"];
                if (!group.Success)
                    group = m.Groups[0];
                //
                r.Start = charIndexToPlace[group.Index];
                r.End = charIndexToPlace[group.Index + group.Length];
                yield return r;
            }
        }

        /// <summary>
        /// Finds ranges for given regex pattern.
        /// Search is separately in each line.
        /// This method requires less memory than GetRanges().
        /// </summary>
        /// <param name="regexPattern">Regex pattern</param>
        /// <returns>Enumeration of ranges</returns>
        public IEnumerable<Range> GetRangesByLines(string regexPattern, RegexOptions options)
        {
            var regex = new Regex(regexPattern, options);
            foreach (var r in GetRangesByLines(regex))
                yield return r;
        }

        /// <summary>
        /// Finds ranges for given regex.
        /// Search is separately in each line.
        /// This method requires less memory than GetRanges().
        /// </summary>
        /// <param name="regex">Regex</param>
        /// <returns>Enumeration of ranges</returns>
        public IEnumerable<Range> GetRangesByLines(Regex regex)
        {
            Normalize();

            var fts = tb.TextSource as FileTextSource; //<----!!!! ugly

            //enumaerate lines
            for (int iLine = Start.iLine; iLine <= End.iLine; iLine++)
            {
                //
                bool isLineLoaded = fts != null ? fts.IsLineLoaded(iLine) : true;
                //
                var r = new Range(tb, new Place(0, iLine), new Place(tb[iLine].Count, iLine));
                if (iLine == Start.iLine || iLine == End.iLine)
                    r = r.GetIntersectionWith(this);

                foreach (var foundRange in r.GetRanges(regex))
                    yield return foundRange;

                if (!isLineLoaded)
                    fts.UnloadLine(iLine);
            }
        }

        /// <summary>
        /// Finds ranges for given regex pattern.
        /// Search is separately in each line (order of lines is reversed).
        /// This method requires less memory than GetRanges().
        /// </summary>
        /// <param name="regexPattern">Regex pattern</param>
        /// <returns>Enumeration of ranges</returns>
        public IEnumerable<Range> GetRangesByLinesReversed(string regexPattern, RegexOptions options)
        {
            Normalize();
            //create regex
            Regex regex = new Regex(regexPattern, options);
            //
            var fts = tb.TextSource as FileTextSource; //<----!!!! ugly

            //enumaerate lines
            for (int iLine = End.iLine; iLine >= Start.iLine; iLine--)
            {
                //
                bool isLineLoaded = fts != null ? fts.IsLineLoaded(iLine) : true;
                //
                var r = new Range(tb, new Place(0, iLine), new Place(tb[iLine].Count, iLine));
                if (iLine == Start.iLine || iLine == End.iLine)
                    r = r.GetIntersectionWith(this);

                var list = new List<Range>();

                foreach (var foundRange in r.GetRanges(regex))
                    list.Add(foundRange);

                for (int i = list.Count - 1; i >= 0; i--)
                    yield return list[i];

                if (!isLineLoaded)
                    fts.UnloadLine(iLine);
            }
        }

        /// <summary>
        /// Finds ranges for given regex
        /// </summary>
        /// <returns>Enumeration of ranges</returns>
        public IEnumerable<Range> GetRanges(Regex regex)
        {
            //get text
            string text;
            List<Place> charIndexToPlace;
            GetText(out text, out charIndexToPlace);
            //
            foreach (Match m in regex.Matches(text))
            {
                Range r = new Range(this.tb);
                //try get 'range' group, otherwise use group 0
                Group group = m.Groups["range"];
                if (!group.Success)
                    group = m.Groups[0];
                //
                r.Start = charIndexToPlace[group.Index];
                r.End = charIndexToPlace[group.Index + group.Length];
                yield return r;
            }
        }

        /// <summary>
        /// Clear styles of range
        /// </summary>
        public void ClearStyle(params Style[] styles)
        {
            try
            {
                ClearStyle(tb.GetStyleIndexMask(styles));
            }
            catch
            {
                ;
            }
        }

        /// <summary>
        /// Clear styles of range
        /// </summary>
        public void ClearStyle(StyleIndex styleIndex)
        {
            //set code to chars
            int fromLine = Math.Min(End.iLine, Start.iLine);
            int toLine = Math.Max(End.iLine, Start.iLine);
            int fromChar = FromX;
            int toChar = ToX;
            if (fromLine < 0) return;
            //
            for (int y = fromLine; y <= toLine; y++)
            {
                int fromX = y == fromLine ? fromChar : 0;
                int toX = y == toLine ? Math.Min(toChar - 1, tb[y].Count - 1) : tb[y].Count - 1;
                for (int x = fromX; x <= toX; x++)
                {
                    Char c = tb[y][x];
                    c.style &= ~styleIndex;
                    tb[y][x] = c;
                }
            }

            //
            tb.Invalidate();
        }

        /// <summary>
        /// Clear folding markers of all lines of range
        /// </summary>
        public void ClearFoldingMarkers()
        {
            //set code to chars
            int fromLine = Math.Min(End.iLine, Start.iLine);
            int toLine = Math.Max(End.iLine, Start.iLine);
            if (fromLine < 0) return;
            //
            for (int y = fromLine; y <= toLine; y++)
                tb[y].ClearFoldingMarkers();
            //
            tb.Invalidate();
        }

        void OnSelectionChanged()
        {
            //clear cache
            cachedTextVersion = -1;
            cachedText = null;
            cachedCharIndexToPlace = null;
            //
            if (tb.Selection == this)
                if (updating == 0)
                    tb.OnSelectionChanged();
        }

        /// <summary>
        /// Starts selection position updating
        /// </summary>
        public void BeginUpdate()
        {
            updating++;
        }

        /// <summary>
        /// Ends selection position updating
        /// </summary>
        public void EndUpdate()
        {
            updating--;
            if (updating == 0)
                OnSelectionChanged();
        }

        public override string ToString()
        {
            return "Start: " + Start + " End: " + End;
        }

        /// <summary>
        /// Exchanges Start and End if End appears before Start
        /// </summary>
        public void Normalize()
        {
            if (Start > End)
                Inverse();
        }

        /// <summary>
        /// Exchanges Start and End
        /// </summary>
        public void Inverse()
        {
            var temp = start;
            start = end;
            end = temp;
        }

        /// <summary>
        /// Expands range from first char of Start line to last char of End line
        /// </summary>
        public void Expand()
        {
            Normalize();
            start = new Place(0, start.iLine);
            end = new Place(tb.GetLineLength(end.iLine), end.iLine);
        }

        IEnumerator<Place> IEnumerable<Place>.GetEnumerator()
        {
            if (ColumnSelectionMode)
            {
                foreach (var p in GetEnumerator_ColumnSelectionMode())
                    yield return p;
                yield break;
            }

            int fromLine = Math.Min(end.iLine, start.iLine);
            int toLine = Math.Max(end.iLine, start.iLine);
            int fromChar = FromX;
            int toChar = ToX;
            if (fromLine < 0) yield break;
            //
            for (int y = fromLine; y <= toLine; y++)
            {
                int fromX = y == fromLine ? fromChar : 0;
                int toX = y == toLine ? Math.Min(toChar - 1, tb[y].Count - 1) : tb[y].Count - 1;
                for (int x = fromX; x <= toX; x++)
                    yield return new Place(x, y);
            }
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return (this as IEnumerable<Place>).GetEnumerator();
        }

        /// <summary>
        /// Chars of range (exclude \n)
        /// </summary>
        public IEnumerable<Char> Chars
        {
            get
            {
                if (ColumnSelectionMode)
                {
                    foreach (var p in GetEnumerator_ColumnSelectionMode())
                        yield return tb[p];
                    yield break;
                }

                int fromLine = Math.Min(end.iLine, start.iLine);
                int toLine = Math.Max(end.iLine, start.iLine);
                int fromChar = FromX;
                int toChar = ToX;
                if (fromLine < 0) yield break;
                //
                for (int y = fromLine; y <= toLine; y++)
                {
                    int fromX = y == fromLine ? fromChar : 0;
                    int toX = y == toLine ? Math.Min(toChar - 1, tb[y].Count - 1) : tb[y].Count - 1;
                    var line = tb[y];
                    for (int x = fromX; x <= toX; x++)
                        yield return line[x];
                }
            }
        }

        /// <summary>
        /// Get fragment of text around Start place. Returns maximal matched to pattern fragment.
        /// </summary>
        /// <param name="allowedSymbolsPattern">Allowed chars pattern for fragment</param>
        /// <returns>Range of found fragment</returns>
        public Range GetFragment(string allowedSymbolsPattern)
        {
            return GetFragment(allowedSymbolsPattern, RegexOptions.None);
        }

        /// <summary>
        /// Get fragment of text around Start place. Returns maximal matched to given Style.
        /// </summary>
        /// <param name="style">Allowed style for fragment</param>
        /// <returns>Range of found fragment</returns>
        public Range GetFragment(Style style, bool allowLineBreaks)
        {
            var mask = tb.GetStyleIndexMask(new Style[] {style});
            //
            Range r = new Range(tb);
            r.Start = Start;
            //go left, check style
            while (r.GoLeftThroughFolded())
            {
                if (!allowLineBreaks && r.CharAfterStart == '\n')
                    break;
                if (r.Start.iChar < tb.GetLineLength(r.Start.iLine))
                    if ((tb[r.Start].style & mask) == 0)
                    {
                        r.GoRightThroughFolded();
                        break;
                    }
            }

            Place startFragment = r.Start;

            r.Start = Start;
            //go right, check style
            do
            {
                if (!allowLineBreaks && r.CharAfterStart == '\n')
                    break;
                if (r.Start.iChar < tb.GetLineLength(r.Start.iLine))
                    if ((tb[r.Start].style & mask) == 0)
                        break;
            } while (r.GoRightThroughFolded());

            Place endFragment = r.Start;

            return new Range(tb, startFragment, endFragment);
        }

        /// <summary>
        /// Get fragment of text around Start place. Returns maximal mathed to pattern fragment.
        /// </summary>
        /// <param name="allowedSymbolsPattern">Allowed chars pattern for fragment</param>
        /// <returns>Range of found fragment</returns>
        public Range GetFragment(string allowedSymbolsPattern, RegexOptions options)
        {
            Range r = new Range(tb);
            r.Start = Start;
            Regex regex = new Regex(allowedSymbolsPattern, options);
            //go left, check symbols
            while (r.GoLeftThroughFolded())
            {
                if (!regex.IsMatch(r.CharAfterStart.ToString()))
                {
                    r.GoRightThroughFolded();
                    break;
                }
            }

            Place startFragment = r.Start;

            r.Start = Start;
            //go right, check symbols
            do
            {
                if (!regex.IsMatch(r.CharAfterStart.ToString()))
                    break;
            } while (r.GoRightThroughFolded());

            Place endFragment = r.Start;

            return new Range(tb, startFragment, endFragment);
        }

        bool IsIdentifierChar(char c)
        {
            return char.IsLetterOrDigit(c) || c == '_';
        }

        bool IsSpaceChar(char c)
        {
            return c == ' ' || c == '\t';
        }

        public void GoWordLeft(bool shift)
        {
            ColumnSelectionMode = false;

            if (!shift && start > end)
            {
                Start = End;
                return;
            }

            Range range = this.Clone(); //to OnSelectionChanged disable
            bool wasSpace = false;
            while (IsSpaceChar(range.CharBeforeStart))
            {
                wasSpace = true;
                range.GoLeft(shift);
            }

            bool wasIdentifier = false;
            while (IsIdentifierChar(range.CharBeforeStart))
            {
                wasIdentifier = true;
                range.GoLeft(shift);
            }

            if (!wasIdentifier && (!wasSpace || range.CharBeforeStart != '\n'))
                range.GoLeft(shift);
            this.Start = range.Start;
            this.End = range.End;

            if (tb.LineInfos[Start.iLine].VisibleState != VisibleState.Visible)
                GoRight(shift);
        }

        public void GoWordRight(bool shift, bool goToStartOfNextWord = false)
        {
            ColumnSelectionMode = false;

            if (!shift && start < end)
            {
                Start = End;
                return;
            }

            Range range = this.Clone(); //to OnSelectionChanged disable

            bool wasNewLine = false;


            if (range.CharAfterStart == '\n')
            {
                range.GoRight(shift);
                wasNewLine = true;
            }

            bool wasSpace = false;
            while (IsSpaceChar(range.CharAfterStart))
            {
                wasSpace = true;
                range.GoRight(shift);
            }

            if (!((wasSpace || wasNewLine) && goToStartOfNextWord))
            {
                bool wasIdentifier = false;
                while (IsIdentifierChar(range.CharAfterStart))
                {
                    wasIdentifier = true;
                    range.GoRight(shift);
                }

                if (!wasIdentifier)
                    range.GoRight(shift);

                if (goToStartOfNextWord && !wasSpace)
                    while (IsSpaceChar(range.CharAfterStart))
                        range.GoRight(shift);
            }

            this.Start = range.Start;
            this.End = range.End;

            if (tb.LineInfos[Start.iLine].VisibleState != VisibleState.Visible)
                GoLeft(shift);
        }

        internal void GoFirst(bool shift)
        {
            ColumnSelectionMode = false;

            start = new Place(0, 0);
            if (tb.LineInfos[Start.iLine].VisibleState != VisibleState.Visible)
                tb.ExpandBlock(Start.iLine);

            if (!shift)
                end = start;

            OnSelectionChanged();
        }

        internal void GoLast(bool shift)
        {
            ColumnSelectionMode = false;

            start = new Place(tb[tb.LinesCount - 1].Count, tb.LinesCount - 1);
            if (tb.LineInfos[Start.iLine].VisibleState != VisibleState.Visible)
                tb.ExpandBlock(Start.iLine);

            if (!shift)
                end = start;

            OnSelectionChanged();
        }

        public static StyleIndex ToStyleIndex(int i)
        {
            return (StyleIndex) (1 << i);
        }

        public RangeRect Bounds
        {
            get
            {
                int minX = Math.Min(Start.iChar, End.iChar);
                int minY = Math.Min(Start.iLine, End.iLine);
                int maxX = Math.Max(Start.iChar, End.iChar);
                int maxY = Math.Max(Start.iLine, End.iLine);
                return new RangeRect(minY, minX, maxY, maxX);
            }
        }

        public IEnumerable<Range> GetSubRanges(bool includeEmpty)
        {
            if (!ColumnSelectionMode)
            {
                yield return this;
                yield break;
            }

            var rect = Bounds;
            for (int y = rect.iStartLine; y <= rect.iEndLine; y++)
            {
                if (rect.iStartChar > tb[y].Count && !includeEmpty)
                    continue;

                var r = new Range(tb, rect.iStartChar, y, Math.Min(rect.iEndChar, tb[y].Count), y);
                yield return r;
            }
        }

        /// <summary>
        /// Range is readonly?
        /// This property return True if any char of the range contains ReadOnlyStyle.
        /// Set this property to True/False to mark chars of the range as Readonly/Writable.
        /// </summary>
        public bool ReadOnly
        {
            get
            {
                if (tb.ReadOnly) return true;

                ReadOnlyStyle readonlyStyle = null;
                foreach (var style in tb.Styles)
                    if (style is ReadOnlyStyle)
                    {
                        readonlyStyle = (ReadOnlyStyle) style;
                        break;
                    }

                if (readonlyStyle != null)
                {
                    var si = ToStyleIndex(tb.GetStyleIndex(readonlyStyle));

                    if (IsEmpty)
                    {
                        //check previous and next chars
                        var line = tb[start.iLine];
                        if (columnSelectionMode)
                        {
                            foreach (var sr in GetSubRanges(false))
                            {
                                line = tb[sr.start.iLine];
                                if (sr.start.iChar < line.Count && sr.start.iChar > 0)
                                {
                                    var left = line[sr.start.iChar - 1];
                                    var right = line[sr.start.iChar];
                                    if ((left.style & si) != 0 &&
                                        (right.style & si) != 0) return true; //we are between readonly chars
                                }
                            }
                        }
                        else if (start.iChar < line.Count && start.iChar > 0)
                        {
                            var left = line[start.iChar - 1];
                            var right = line[start.iChar];
                            if ((left.style & si) != 0 &&
                                (right.style & si) != 0) return true; //we are between readonly chars
                        }
                    }
                    else
                        foreach (Char c in Chars)
                            if ((c.style & si) != 0) //found char with ReadonlyStyle
                                return true;
                }

                return false;
            }

            set
            {
                //find exists ReadOnlyStyle of style buffer
                ReadOnlyStyle readonlyStyle = null;
                foreach (var style in tb.Styles)
                    if (style is ReadOnlyStyle)
                    {
                        readonlyStyle = (ReadOnlyStyle) style;
                        break;
                    }

                //create ReadOnlyStyle
                if (readonlyStyle == null)
                    readonlyStyle = new ReadOnlyStyle();

                //set/clear style
                if (value)
                    SetStyle(readonlyStyle);
                else
                    ClearStyle(readonlyStyle);
            }
        }

        /// <summary>
        /// Is char before range readonly
        /// </summary>
        /// <returns></returns>
        public bool IsReadOnlyLeftChar()
        {
            if (tb.ReadOnly) return true;

            var r = Clone();

            r.Normalize();
            if (r.start.iChar == 0) return false;
            if (ColumnSelectionMode)
                r.GoLeft_ColumnSelectionMode();
            else
                r.GoLeft(true);

            return r.ReadOnly;
        }

        /// <summary>
        /// Is char after range readonly
        /// </summary>
        /// <returns></returns>
        public bool IsReadOnlyRightChar()
        {
            if (tb.ReadOnly) return true;

            var r = Clone();

            r.Normalize();
            if (r.end.iChar >= tb[end.iLine].Count) return false;
            if (ColumnSelectionMode)
                r.GoRight_ColumnSelectionMode();
            else
                r.GoRight(true);

            return r.ReadOnly;
        }

        public IEnumerable<Place> GetPlacesCyclic(Place startPlace, bool backward = false)
        {
            if (backward)
            {
                var r = new Range(this.tb, startPlace, startPlace);
                while (r.GoLeft() && r.start >= Start)
                {
                    if (r.Start.iChar < tb[r.Start.iLine].Count)
                        yield return r.Start;
                }

                r = new Range(this.tb, End, End);
                while (r.GoLeft() && r.start >= startPlace)
                {
                    if (r.Start.iChar < tb[r.Start.iLine].Count)
                        yield return r.Start;
                }
            }
            else
            {
                var r = new Range(this.tb, startPlace, startPlace);
                if (startPlace < End)
                    do
                    {
                        if (r.Start.iChar < tb[r.Start.iLine].Count)
                            yield return r.Start;
                    } while (r.GoRight());

                r = new Range(this.tb, Start, Start);
                if (r.Start < startPlace)
                    do
                    {
                        if (r.Start.iChar < tb[r.Start.iLine].Count)
                            yield return r.Start;
                    } while (r.GoRight() && r.Start < startPlace);
            }
        }

        #region ColumnSelectionMode

        private Range GetIntersectionWith_ColumnSelectionMode(Range range)
        {
            if (range.Start.iLine != range.End.iLine)
                return new Range(tb, Start, Start);
            var rect = Bounds;
            if (range.Start.iLine < rect.iStartLine || range.Start.iLine > rect.iEndLine)
                return new Range(tb, Start, Start);

            return new Range(tb, rect.iStartChar, range.Start.iLine, rect.iEndChar, range.Start.iLine)
                .GetIntersectionWith(range);
        }

        private bool GoRightThroughFolded_ColumnSelectionMode()
        {
            var boundes = Bounds;
            var endOfLines = true;
            for (int iLine = boundes.iStartLine; iLine <= boundes.iEndLine; iLine++)
                if (boundes.iEndChar < tb[iLine].Count)
                {
                    endOfLines = false;
                    break;
                }

            if (endOfLines)
                return false;

            var start = Start;
            var end = End;
            start.Offset(1, 0);
            end.Offset(1, 0);
            BeginUpdate();
            Start = start;
            End = end;
            EndUpdate();

            return true;
        }

        private IEnumerable<Place> GetEnumerator_ColumnSelectionMode()
        {
            var bounds = Bounds;
            if (bounds.iStartLine < 0) yield break;
            //
            for (int y = bounds.iStartLine; y <= bounds.iEndLine; y++)
            {
                for (int x = bounds.iStartChar; x < bounds.iEndChar; x++)
                {
                    if (x < tb[y].Count)
                        yield return new Place(x, y);
                }
            }
        }

        private string Text_ColumnSelectionMode
        {
            get
            {
                StringBuilder sb = new StringBuilder();
                var bounds = Bounds;
                if (bounds.iStartLine < 0) return "";
                //
                for (int y = bounds.iStartLine; y <= bounds.iEndLine; y++)
                {
                    for (int x = bounds.iStartChar; x < bounds.iEndChar; x++)
                    {
                        if (x < tb[y].Count)
                            sb.Append(tb[y][x].c);
                    }

                    if (bounds.iEndLine != bounds.iStartLine && y != bounds.iEndLine)
                        sb.AppendLine();
                }

                return sb.ToString();
            }
        }

        private int Length_ColumnSelectionMode(bool withNewLines)
        {
            var bounds = Bounds;
            if (bounds.iStartLine < 0) return 0;
            int cnt = 0;
            //
            for (int y = bounds.iStartLine; y <= bounds.iEndLine; y++)
            {
                for (int x = bounds.iStartChar; x < bounds.iEndChar; x++)
                {
                    if (x < tb[y].Count)
                        cnt++;
                }

                if (withNewLines && bounds.iEndLine != bounds.iStartLine && y != bounds.iEndLine)
                    cnt += Environment.NewLine.Length;
            }

            return cnt;
        }

        internal void GoDown_ColumnSelectionMode()
        {
            var iLine = tb.FindNextVisibleLine(End.iLine);
            End = new Place(End.iChar, iLine);
        }

        internal void GoUp_ColumnSelectionMode()
        {
            var iLine = tb.FindPrevVisibleLine(End.iLine);
            End = new Place(End.iChar, iLine);
        }

        internal void GoRight_ColumnSelectionMode()
        {
            End = new Place(End.iChar + 1, End.iLine);
        }

        internal void GoLeft_ColumnSelectionMode()
        {
            if (End.iChar > 0)
                End = new Place(End.iChar - 1, End.iLine);
        }

        #endregion
    }

    public struct RangeRect
    {
        public RangeRect(int iStartLine, int iStartChar, int iEndLine, int iEndChar)
        {
            this.iStartLine = iStartLine;
            this.iStartChar = iStartChar;
            this.iEndLine = iEndLine;
            this.iEndChar = iEndChar;
        }

        public int iStartLine;
        public int iStartChar;
        public int iEndLine;
        public int iEndChar;
    }
}

================================================
FILE: FastColoredTextBox/ReplaceForm.Designer.cs
================================================
namespace FastColoredTextBoxNS
{
    partial class ReplaceForm
    {
        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.btClose = new System.Windows.Forms.Button();
            this.btFindNext = new System.Windows.Forms.Button();
            this.tbFind = new System.Windows.Forms.TextBox();
            this.cbRegex = new System.Windows.Forms.CheckBox();
            this.cbMatchCase = new System.Windows.Forms.CheckBox();
            this.label1 = new System.Windows.Forms.Label();
            this.cbWholeWord = new System.Windows.Forms.CheckBox();
            this.btReplace = new System.Windows.Forms.Button();
            this.btReplaceAll = new System.Windows.Forms.Button();
            this.label2 = new System.Windows.Forms.Label();
            this.tbReplace = new System.Windows.Forms.TextBox();
            this.SuspendLayout();
            // 
            // btClose
            // 
            this.btClose.Location = new System.Drawing.Point(273, 153);
            this.btClose.Name = "btClose";
            this.btClose.Size = new System.Drawing.Size(75, 23);
            this.btClose.TabIndex = 8;
            this.btClose.Text = "Close";
            this.btClose.UseVisualStyleBackColor = true;
            this.btClose.Click += new System.EventHandler(this.btClose_Click);
            // 
            // btFindNext
            // 
            this.btFindNext.Location = new System.Drawing.Point(111, 124);
            this.btFindNext.Name = "btFindNext";
            this.btFindNext.Size = new System.Drawing.Size(75, 23);
            this.btFindNext.TabIndex = 5;
            this.btFindNext.Text = "Find next";
            this.btFindNext.UseVisualStyleBackColor = true;
            this.btFindNext.Click += new System.EventHandler(this.btFindNext_Click);
            // 
            // tbFind
            // 
            this.tbFind.Location = new System.Drawing.Point(62, 12);
            this.tbFind.Name = "tbFind";
            this.tbFind.Size = new System.Drawing.Size(286, 20);
            this.tbFind.TabIndex = 0;
            this.tbFind.TextChanged += new System.EventHandler(this.cbMatchCase_CheckedChanged);
            this.tbFind.KeyPress += new System.Windows.Forms.KeyPressEventHandler(this.tbFind_KeyPress);
            // 
            // cbRegex
            // 
            this.cbRegex.AutoSize = true;
            this.cbRegex.Location = new System.Drawing.Point(273, 38);
            this.cbRegex.Name = "cbRegex";
            this.cbRegex.Size = new System.Drawing.Size(57, 17);
            this.cbRegex.TabIndex = 3;
            this.cbRegex.Text = "Regex";
            this.cbRegex.UseVisualStyleBackColor = true;
            this.cbRegex.CheckedChanged += new System.EventHandler(this.cbMatchCase_CheckedChanged);
            // 
            // cbMatchCase
            // 
            this.cbMatchCase.AutoSize = true;
            this.cbMatchCase.Location = new System.Drawing.Point(66, 38);
            this.cbMatchCase.Name = "cbMatchCase";
            this.cbMatchCase.Size = new System.Drawing.Size(82, 17);
            this.cbMatchCase.TabIndex = 1;
            this.cbMatchCase.Text = "Match case";
            this.cbMatchCase.UseVisualStyleBackColor = true;
            this.cbMatchCase.CheckedChanged += new System.EventHandler(this.cbMatchCase_CheckedChanged);
            // 
            // label1
            // 
            this.label1.AutoSize = true;
            this.label1.Location = new System.Drawing.Point(23, 14);
            this.label1.Name = "label1";
            this.label1.Size = new System.Drawing.Size(33, 13);
            this.label1.TabIndex = 5;
            this.label1.Text = "Find: ";
            // 
            // cbWholeWord
            // 
            this.cbWholeWord.AutoSize = true;
            this.cbWholeWord.Location = new System.Drawing.Point(154, 38);
            this.cbWholeWord.Name = "cbWholeWord";
            this.cbWholeWord.Size = new System.Drawing.Size(113, 17);
            this.cbWholeWord.TabIndex = 2;
            this.cbWholeWord.Text = "Match whole word";
            this.cbWholeWord.UseVisualStyleBackColor = true;
            this.cbWholeWord.CheckedChanged += new System.EventHandler(this.cbMatchCase_CheckedChanged);
            // 
            // btReplace
            // 
            this.btReplace.Location = new System.Drawing.Point(192, 124);
            this.btReplace.Name = "btReplace";
            this.btReplace.Size = new System.Drawing.Size(75, 23);
            this.btReplace.TabIndex = 6;
            this.btReplace.Text = "Replace";
            this.btReplace.UseVisualStyleBackColor = true;
            this.btReplace.Click += new System.EventHandler(this.btReplace_Click);
            // 
            // btReplaceAll
            // 
            this.btReplaceAll.Location = new System.Drawing.Point(273, 124);
            this.btReplaceAll.Name = "btReplaceAll";
            this.btReplaceAll.Size = new System.Drawing.Size(75, 23);
            this.btReplaceAll.TabIndex = 7;
            this.btReplaceAll.Text = "Replace all";
            this.btReplaceAll.UseVisualStyleBackColor = true;
            this.btReplaceAll.Click += new System.EventHandler(this.btReplaceAll_Click);
            // 
            // label2
            // 
            this.label2.AutoSize = true;
            this.label2.Location = new System.Drawing.Point(6, 81);
            this.label2.Name = "label2";
            this.label2.Size = new System.Drawing.Size(50, 13);
            this.label2.TabIndex = 9;
            this.label2.Text = "Replace:";
            // 
            // tbReplace
            // 
            this.tbReplace.Location = new System.Drawing.Point(62, 78);
            this.tbReplace.Name = "tbReplace";
            this.tbReplace.Size = new System.Drawing.Size(286, 20);
            this.tbReplace.TabIndex = 0;
            this.tbReplace.TextChanged += new System.EventHandler(this.cbMatchCase_CheckedChanged);
            this.tbReplace.KeyPress += new System.Windows.Forms.KeyPressEventHandler(this.tbFind_KeyPress);
            // 
            // ReplaceForm
            // 
            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.ClientSize = new System.Drawing.Size(360, 191);
            this.Controls.Add(this.tbFind);
            this.Controls.Add(this.label2);
            this.Controls.Add(this.tbReplace);
            this.Controls.Add(this.btReplaceAll);
            this.Controls.Add(this.btReplace);
            this.Controls.Add(this.cbWholeWord);
            this.Controls.Add(this.label1);
            this.Controls.Add(this.cbMatchCase);
            this.Controls.Add(this.cbRegex);
            this.Controls.Add(this.btFindNext);
            this.Controls.Add(this.btClose);
            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedToolWindow;
            this.Name = "ReplaceForm";
            this.ShowIcon = false;
            this.ShowInTaskbar = false;
            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
            this.Text = "Find and replace";
            this.TopMost = true;
            this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.ReplaceForm_FormClosing);
            this.ResumeLayout(false);
            this.PerformLayout();

        }

        #endregion

        private System.Windows.Forms.Button btClose;
        private System.Windows.Forms.Button btFindNext;
        private System.Windows.Forms.CheckBox cbRegex;
        private System.Windows.Forms.CheckBox cbMatchCase;
        private System.Windows.Forms.Label label1;
        private System.Windows.Forms.CheckBox cbWholeWord;
        private System.Windows.Forms.Button btReplace;
        private System.Windows.Forms.Button btReplaceAll;
        private System.Windows.Forms.Label label2;
        public System.Windows.Forms.TextBox tbFind;
        public System.Windows.Forms.TextBox tbReplace;
    }
}

================================================
FILE: FastColoredTextBox/ReplaceForm.cs
================================================
using System;
using System.Windows.Forms;
using System.Text.RegularExpressions;
using System.Collections.Generic;

namespace FastColoredTextBoxNS
{
    public partial class ReplaceForm : Form
    {
        FastColoredTextBox tb;
        bool firstSearch = true;
        Place startPlace;

        public ReplaceForm(FastColoredTextBox tb)
        {
            InitializeComponent();
            this.tb = tb;
        }

        private void btClose_Click(object sender, EventArgs e)
        {
            Close();
        }

        private void btFindNext_Click(object sender, EventArgs e)
        {
            try
            {
                if (!Find(tbFind.Text))
                    MessageBox.Show("Not found");
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

        public List<Range> FindAll(string pattern)
        {
            var opt = cbMatchCase.Checked ? RegexOptions.None : RegexOptions.IgnoreCase;
            if (!cbRegex.Checked)
                pattern = Regex.Escape(pattern);
            if (cbWholeWord.Checked)
                pattern = "\\b" + pattern + "\\b";
            //
            var range = tb.Selection.IsEmpty ? tb.Range.Clone() : tb.Selection.Clone();
            //
            var list = new List<Range>();
            foreach (var r in range.GetRangesByLines(pattern, opt))
                list.Add(r);

            return list;
        }

        public bool Find(string pattern)
        {
            RegexOptions opt = cbMatchCase.Checked ? RegexOptions.None : RegexOptions.IgnoreCase;
            if (!cbRegex.Checked)
                pattern = Regex.Escape(pattern);
            if (cbWholeWord.Checked)
                pattern = "\\b" + pattern + "\\b";
            //
            Range range = tb.Selection.Clone();
            range.Normalize();
            //
            if (firstSearch)
            {
                startPlace = range.Start;
                firstSearch = false;
            }

            //
            range.Start = range.End;
            if (range.Start >= startPlace)
                range.End = new Place(tb.GetLineLength(tb.LinesCount - 1), tb.LinesCount - 1);
            else
                range.End = startPlace;
            //
            foreach (var r in range.GetRangesByLines(pattern, opt))
            {
                tb.Selection.Start = r.Start;
                tb.Selection.End = r.End;
                tb.DoSelectionVisible();
                tb.Invalidate();
                return true;
            }

            if (range.Start >= startPlace && startPlace > Place.Empty)
            {
                tb.Selection.Start = new Place(0, 0);
                return Find(pattern);
            }

            return false;
        }

        private void tbFind_KeyPress(object sender, KeyPressEventArgs e)
        {
            if (e.KeyChar == '\r')
                btFindNext_Click(sender, null);
            if (e.KeyChar == '\x1b')
                Hide();
        }

        protected override bool ProcessCmdKey(ref Message msg, Keys keyData) // David
        {
            if (keyData == Keys.Escape)
            {
                this.Close();
                return true;
            }

            return base.ProcessCmdKey(ref msg, keyData);
        }

        private void ReplaceForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (e.CloseReason == CloseReason.UserClosing)
            {
                e.Cancel = true;
                Hide();
            }

            this.tb.Focus();
        }

        private void btReplace_Click(object sender, EventArgs e)
        {
            try
            {
                if (tb.SelectionLength != 0)
                    if (!tb.Selection.ReadOnly)
                        tb.InsertText(tbReplace.Text);
                btFindNext_Click(sender, null);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

        private void btReplaceAll_Click(object sender, EventArgs e)
        {
            try
            {
                tb.Selection.BeginUpdate();

                //search
                var ranges = FindAll(tbFind.Text);
                //check readonly
                var ro = false;
                foreach (var r in ranges)
                    if (r.ReadOnly)
                    {
                        ro = true;
                        break;
                    }

                //replace
                if (!ro)
                    if (ranges.Count > 0)
                    {
                        tb.TextSource.Manager.ExecuteCommand(new ReplaceTextCommand(tb.TextSource, ranges,
                            tbReplace.Text));
                        tb.Selection.Start = new Place(0, 0);
                    }

                //
                tb.Invalidate();
                MessageBox.Show(ranges.Count + " occurrence(s) replaced");
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }

            tb.Selection.EndUpdate();
        }

        protected override void OnActivated(EventArgs e)
        {
            tbFind.Focus();
            ResetSerach();
        }

        void ResetSerach()
        {
            firstSearch = true;
        }

        private void cbMatchCase_CheckedChanged(object sender, EventArgs e)
        {
            ResetSerach();
        }
    }
}

================================================
FILE: FastColoredTextBox/ReplaceForm.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
</root>

================================================
FILE: FastColoredTextBox/Ruler.Designer.cs
================================================
namespace FastColoredTextBoxNS
{
    partial class Ruler
    {
        /// <summary> 
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary> 
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Component Designer generated code

        /// <summary> 
        /// Required method for Designer support - do not modify 
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            components = new System.ComponentModel.Container();
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
        }

        #endregion
    }
}


================================================
FILE: FastColoredTextBox/Ruler.cs
================================================
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Drawing.Drawing2D;
using System.Text;
using System.Windows.Forms;

namespace FastColoredTextBoxNS
{
    public partial class Ruler : UserControl
    {
        public EventHandler TargetChanged;

        [DefaultValue(typeof(Color), "ControlLight")]
        public Color BackColor2 { get; set; }

        [DefaultValue(typeof(Color), "DarkGray")]
        public Color TickColor { get; set; }

        [DefaultValue(typeof(Color), "Black")] public Color CaretTickColor { get; set; }

        FastColoredTextBox target;

        [Description("Target FastColoredTextBox")]
        public FastColoredTextBox Target
        {
            get { return target; }
            set
            {
                if (target != null)
                    UnSubscribe(target);
                target = value;
                Subscribe(target);
                OnTargetChanged();
            }
        }

        public Ruler()
        {
            InitializeComponent();

            SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.OptimizedDoubleBuffer | ControlStyles.UserPaint,
                true);
            MinimumSize = new Size(0, 24);
            MaximumSize = new Size(int.MaxValue / 2, 24);

            BackColor2 = SystemColors.ControlLight;
            TickColor = Color.DarkGray;
            CaretTickColor = Color.Black;
        }


        protected virtual void OnTargetChanged()
        {
            if (TargetChanged != null)
                TargetChanged(this, EventArgs.Empty);
        }

        protected virtual void UnSubscribe(FastColoredTextBox target)
        {
            target.Scroll -= new ScrollEventHandler(target_Scroll);
            target.SelectionChanged -= new EventHandler(target_SelectionChanged);
            target.VisibleRangeChanged -= new EventHandler(target_VisibleRangeChanged);
        }

        protected virtual void Subscribe(FastColoredTextBox target)
        {
            target.Scroll += new ScrollEventHandler(target_Scroll);
            target.SelectionChanged += new EventHandler(target_SelectionChanged);
            target.VisibleRangeChanged += new EventHandler(target_VisibleRangeChanged);
        }

        void target_VisibleRangeChanged(object sender, EventArgs e)
        {
            Invalidate();
        }

        void target_SelectionChanged(object sender, EventArgs e)
        {
            Invalidate();
        }

        protected virtual void target_Scroll(object sender, ScrollEventArgs e)
        {
            Invalidate();
        }

        protected override void OnResize(EventArgs e)
        {
            base.OnResize(e);
            Invalidate();
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            if (target == null)
                return;

            Point car = PointToClient(target.PointToScreen(target.PlaceToPoint(target.Selection.Start)));

            Size fontSize = TextRenderer.MeasureText("W", Font);

            int column = 0;
            e.Graphics.FillRectangle(
                new LinearGradientBrush(new Rectangle(0, 0, Width, Height), BackColor, BackColor2, 270),
                new Rectangle(0, 0, Width, Height));

            float columnWidth = target.CharWidth;
            var sf = new StringFormat();
            sf.Alignment = StringAlignment.Center;
            sf.LineAlignment = StringAlignment.Near;

            var zeroPoint = target.PositionToPoint(0);
            zeroPoint = PointToClient(target.PointToScreen(zeroPoint));

            using (var pen = new Pen(TickColor))
            using (var textBrush = new SolidBrush(ForeColor))
                for (float x = zeroPoint.X; x < Right; x += columnWidth, ++column)
                {
                    if (column % 10 == 0)
                        e.Graphics.DrawString(column.ToString(), Font, textBrush, x, 0f, sf);

                    e.Graphics.DrawLine(pen, (int) x, fontSize.Height + (column % 5 == 0 ? 1 : 3), (int) x, Height - 4);
                }

            using (var pen = new Pen(TickColor))
                e.Graphics.DrawLine(pen, new Point(car.X - 3, Height - 3), new Point(car.X + 3, Height - 3));

            using (var pen = new Pen(CaretTickColor))
            {
                e.Graphics.DrawLine(pen, new Point(car.X - 2, fontSize.Height + 3), new Point(car.X - 2, Height - 4));
                e.Graphics.DrawLine(pen, new Point(car.X, fontSize.Height + 1), new Point(car.X, Height - 4));
                e.Graphics.DrawLine(pen, new Point(car.X + 2, fontSize.Height + 3), new Point(car.X + 2, Height - 4));
            }
        }
    }
}

================================================
FILE: FastColoredTextBox/Style.cs
================================================
using System.Drawing;
using System;
using System.Drawing.Drawing2D;
using System.Collections.Generic;

namespace FastColoredTextBoxNS
{
    /// <summary>
    /// Style of chars
    /// </summary>
    /// <remarks>This is base class for all text and design renderers</remarks>
    public abstract class Style : IDisposable
    {
        /// <summary>
        /// This style is exported to outer formats (HTML for example)
        /// </summary>
        public virtual bool IsExportable { get; set; }

        /// <summary>
        /// Occurs when user click on StyleVisualMarker joined to this style 
        /// </summary>
        public event EventHandler<VisualMarkerEventArgs> VisualMarkerClick;

        /// <summary>
        /// Constructor
        /// </summary>
        public Style()
        {
            IsExportable = true;
        }

        /// <summary>
        /// Renders given range of text
        /// </summary>
        /// <param name="gr">Graphics object</param>
        /// <param name="position">Position of the range in absolute control coordinates</param>
        /// <param name="range">Rendering range of text</param>
        public abstract void Draw(Graphics gr, Point position, Range range);

        /// <summary>
        /// Occurs when user click on StyleVisualMarker joined to this style 
        /// </summary>
        public virtual void OnVisualMarkerClick(FastColoredTextBox tb, VisualMarkerEventArgs args)
        {
            if (VisualMarkerClick != null)
                VisualMarkerClick(tb, args);
        }

        /// <summary>
        /// Shows VisualMarker
        /// Call this method in Draw method, when you need to show VisualMarker for your style
        /// </summary>
        protected virtual void AddVisualMarker(FastColoredTextBox tb, StyleVisualMarker marker)
        {
            tb.AddVisualMarker(marker);
        }

        public static Size GetSizeOfRange(Range range)
        {
            return new Size((range.End.iChar - range.Start.iChar) * range.tb.CharWidth, range.tb.CharHeight);
        }

        public static GraphicsPath GetRoundedRectangle(Rectangle rect, int d)
        {
            GraphicsPath gp = new GraphicsPath();

            gp.AddArc(rect.X, rect.Y, d, d, 180, 90);
            gp.AddArc(rect.X + rect.Width - d, rect.Y, d, d, 270, 90);
            gp.AddArc(rect.X + rect.Width - d, rect.Y + rect.Height - d, d, d, 0, 90);
            gp.AddArc(rect.X, rect.Y + rect.Height - d, d, d, 90, 90);
            gp.AddLine(rect.X, rect.Y + rect.Height - d, rect.X, rect.Y + d / 2);

            return gp;
        }

        public virtual void Dispose()
        {
            ;
        }

        /// <summary>
        /// Returns CSS for export to HTML
        /// </summary>
        /// <returns></returns>
        public virtual string GetCSS()
        {
            return "";
        }

        /// <summary>
        /// Returns RTF descriptor for export to RTF
        /// </summary>
        /// <returns></returns>
        public virtual RTFStyleDescriptor GetRTF()
        {
            return new RTFStyleDescriptor();
        }
    }

    /// <summary>
    /// Style for chars rendering
    /// This renderer can draws chars, with defined fore and back colors
    /// </summary>
    public class TextStyle : Style
    {
        public Brush ForeBrush { get; set; }
        public Brush BackgroundBrush { get; set; }

        public FontStyle FontStyle { get; set; }

        //public readonly Font Font;
        public StringFormat stringFormat;

        public TextStyle(Brush foreBrush, Brush backgroundBrush, FontStyle fontStyle)
        {
            this.ForeBrush = foreBrush;
            this.BackgroundBrush = backgroundBrush;
            this.FontStyle = fontStyle;
            stringFormat = new StringFormat(StringFormatFlags.MeasureTrailingSpaces);
        }

        public override void Draw(Graphics gr, Point position, Range range)
        {
            //draw background
            if (BackgroundBrush != null)
                gr.FillRectangle(BackgroundBrush, position.X, position.Y,
                    (range.End.iChar - range.Start.iChar) * range.tb.CharWidth, range.tb.CharHeight);
            //draw chars
            using (var f = new Font(range.tb.Font, FontStyle))
            {
                Line line = range.tb[range.Start.iLine];
                float dx = range.tb.CharWidth;
                float y = position.Y + range.tb.LineInterval / 2;
                float x = position.X - range.tb.CharWidth / 3;

                if (ForeBrush == null)
                    ForeBrush = new SolidBrush(range.tb.ForeColor);

                if (range.tb.ImeAllowed)
                {
                    //IME mode
                    for (int i = range.Start.iChar; i < range.End.iChar; i++)
                    {
                        SizeF size = FastColoredTextBox.GetCharSize(f, line[i].c);

                        var gs = gr.Save();
                        float k = size.Width > range.tb.CharWidth + 1 ? range.tb.CharWidth / size.Width : 1;
                        gr.TranslateTransform(x, y + (1 - k) * range.tb.CharHeight / 2);
                        gr.ScaleTransform(k, (float) Math.Sqrt(k));
                        gr.DrawString(line[i].c.ToString(), f, ForeBrush, 0, 0, stringFormat);
                        gr.Restore(gs);
                        x += dx;
                    }
                }
                else
                {
                    //classic mode 
                    for (int i = range.Start.iChar; i < range.End.iChar; i++)
                    {
                        //draw char
                        gr.DrawString(line[i].c.ToString(), f, ForeBrush, x, y, stringFormat);
                        x += dx;
                    }
                }
            }
        }

        public override string GetCSS()
        {
            string result = "";

            if (BackgroundBrush is SolidBrush)
            {
                var s = ExportToHTML.GetColorAsString((BackgroundBrush as SolidBrush).Color);
                if (s != "")
                    result += "background-color:" + s + ";";
            }

            if (ForeBrush is SolidBrush)
            {
                var s = ExportToHTML.GetColorAsString((ForeBrush as SolidBrush).Color);
                if (s != "")
                    result += "color:" + s + ";";
            }

            if ((FontStyle & FontStyle.Bold) != 0)
                result += "font-weight:bold;";
            if ((FontStyle & FontStyle.Italic) != 0)
                result += "font-style:oblique;";
            if ((FontStyle & FontStyle.Strikeout) != 0)
                result += "text-decoration:line-through;";
            if ((FontStyle & FontStyle.Underline) != 0)
                result += "text-decoration:underline;";

            return result;
        }

        public override RTFStyleDescriptor GetRTF()
        {
            var result = new RTFStyleDescriptor();

            if (BackgroundBrush is SolidBrush)
                result.BackColor = (BackgroundBrush as SolidBrush).Color;

            if (ForeBrush is SolidBrush)
                result.ForeColor = (ForeBrush as SolidBrush).Color;

            if ((FontStyle & FontStyle.Bold) != 0)
                result.AdditionalTags += @"\b";
            if ((FontStyle & FontStyle.Italic) != 0)
                result.AdditionalTags += @"\i";
            if ((FontStyle & FontStyle.Strikeout) != 0)
                result.AdditionalTags += @"\strike";
            if ((FontStyle & FontStyle.Underline) != 0)
                result.AdditionalTags += @"\ul";

            return result;
        }
    }

    /// <summary>
    /// Renderer for folded block
    /// </summary>
    public class FoldedBlockStyle : TextStyle
    {
        public FoldedBlockStyle(Brush foreBrush, Brush backgroundBrush, FontStyle fontStyle) :
            base(foreBrush, backgroundBrush, fontStyle)
        {
        }

        public override void Draw(Graphics gr, Point position, Range range)
        {
            if (range.End.iChar > range.Start.iChar)
            {
                base.Draw(gr, position, range);

                int firstNonSpaceSymbolX = position.X;

                //find first non space symbol
                for (int i = range.Start.iChar; i < range.End.iChar; i++)
                    if (range.tb[range.Start.iLine][i].c != ' ')
                        break;
                    else
                        firstNonSpaceSymbolX += range.tb.CharWidth;

                //create marker
                range.tb.AddVisualMarker(new FoldedAreaMarker(range.Start.iLine,
                    new Rectangle(firstNonSpaceSymbolX, position.Y,
                        position.X + (range.End.iChar - range.Start.iChar) * range.tb.CharWidth - firstNonSpaceSymbolX,
                        range.tb.CharHeight)));
            }
            else
            {
                //draw '...'
                using (Font f = new Font(range.tb.Font, FontStyle))
                    gr.DrawString("...", f, ForeBrush, range.tb.LeftIndent, position.Y - 2);
                //create marker
                range.tb.AddVisualMarker(new FoldedAreaMarker(range.Start.iLine,
                    new Rectangle(range.tb.LeftIndent + 2, position.Y, 2 * range.tb.CharHeight, range.tb.CharHeight)));
            }
        }
    }

    /// <summary>
    /// Renderer for selected area
    /// </summary>
    public class SelectionStyle : Style
    {
        public Brush BackgroundBrush { get; set; }
        public Brush ForegroundBrush { get; private set; }

        public override bool IsExportable
        {
            get { return false; }
            set { }
        }

        public SelectionStyle(Brush backgroundBrush, Brush foregroundBrush = null)
        {
            this.BackgroundBrush = backgroundBrush;
            this.ForegroundBrush = foregroundBrush;
        }

        public override void Draw(Graphics gr, Point position, Range range)
        {
            //draw background
            if (BackgroundBrush != null)
            {
                gr.SmoothingMode = SmoothingMode.None;
                var rect = new Rectangle(position.X, position.Y,
                    (range.End.iChar - range.Start.iChar) * range.tb.CharWidth, range.tb.CharHeight);
                if (rect.Width == 0)
                    return;
                gr.FillRectangle(BackgroundBrush, rect);
                //
                if (ForegroundBrush != null)
                {
                    //draw text
                    gr.SmoothingMode = SmoothingMode.AntiAlias;

                    var r = new Range(range.tb, range.Start.iChar, range.Start.iLine,
                        Math.Min(range.tb[range.End.iLine].Count, range.End.iChar), range.End.iLine);
                    using (var style = new TextStyle(ForegroundBrush, null, FontStyle.Regular))
                        style.Draw(gr, new Point(position.X, position.Y - 1), r);
                }
            }
        }
    }

    /// <summary>
    /// Marker style
    /// Draws background color for text
    /// </summary>
    public class MarkerStyle : Style
    {
        public Brush BackgroundBrush { get; set; }

        public MarkerStyle(Brush backgroundBrush)
        {
            this.BackgroundBrush = backgroundBrush;
            IsExportable = true;
        }

        public override void Draw(Graphics gr, Point position, Range range)
        {
            //draw background
            if (BackgroundBrush != null)
            {
                Rectangle rect = new Rectangle(position.X, position.Y,
                    (range.End.iChar - range.Start.iChar) * range.tb.CharWidth, range.tb.CharHeight);
                if (rect.Width == 0)
                    return;
                gr.FillRectangle(BackgroundBrush, rect);
            }
        }

        public override string GetCSS()
        {
            string result = "";

            if (BackgroundBrush is SolidBrush)
            {
                var s = ExportToHTML.GetColorAsString((BackgroundBrush as SolidBrush).Color);
                if (s != "")
                    result += "background-color:" + s + ";";
            }

            return result;
        }
    }

    /// <summary>
    /// Draws small rectangle for popup menu
    /// </summary>
    public class ShortcutStyle : Style
    {
        public Pen borderPen;

        public ShortcutStyle(Pen borderPen)
        {
            this.borderPen = borderPen;
        }

        public override void Draw(Graphics gr, Point position, Range range)
        {
            //get last char coordinates
            Point p = range.tb.PlaceToPoint(range.End);
            //draw small square under char
            Rectangle rect = new Rectangle(p.X - 5, p.Y + range.tb.CharHeight - 2, 4, 3);
            gr.FillPath(Brushes.White, GetRoundedRectangle(rect, 1));
            gr.DrawPath(borderPen, GetRoundedRectangle(rect, 1));
            //add visual marker for handle mouse events
            AddVisualMarker(range.tb,
                new StyleVisualMarker(
                    new Rectangle(p.X - range.tb.CharWidth, p.Y, range.tb.CharWidth, range.tb.CharHeight), this));
        }
    }

    /// <summary>
    /// This style draws a wavy line below a given text range.
    /// </summary>
    /// <remarks>Thanks for Yallie</remarks>
    public class WavyLineStyle : Style
    {
        private Pen Pen { get; set; }

        public WavyLineStyle(int alpha, Color color)
        {
            Pen = new Pen(Color.FromArgb(alpha, color));
        }

        public override void Draw(Graphics gr, Point pos, Range range)
        {
            var size = GetSizeOfRange(range);
            var start = new Point(pos.X, pos.Y + size.Height - 1);
            var end = new Point(pos.X + size.Width, pos.Y + size.Height - 1);
            DrawWavyLine(gr, start, end);
        }

        private void DrawWavyLine(Graphics graphics, Point start, Point end)
        {
            if (end.X - start.X < 2)
            {
                graphics.DrawLine(Pen, start, end);
                return;
            }

            var offset = -1;
            var points = new List<Point>();

            for (int i = start.X; i <= end.X; i += 2)
            {
                points.Add(new Point(i, start.Y + offset));
                offset = -offset;
            }

            graphics.DrawLines(Pen, points.ToArray());
        }

        public override void Dispose()
        {
            base.Dispose();

            if (Pen != null)
                Pen.Dispose();
        }
    }

    /// <summary>
    /// This style is used to mark range of text as ReadOnly block
    /// </summary>
    /// <remarks>You can inherite this style to add visual effects of readonly text</remarks>
    public class ReadOnlyStyle : Style
    {
        public ReadOnlyStyle()
        {
            IsExportable = false;
        }

        public override void Draw(Graphics gr, Point position, Range range)
        {
            //
        }
    }
}

================================================
FILE: FastColoredTextBox/SyntaxDescriptor.cs
================================================
using System.Collections.Generic;
using System.Text.RegularExpressions;
using System;

namespace FastColoredTextBoxNS
{
    public class SyntaxDescriptor : IDisposable
    {
        public char leftBracket = '(';
        public char rightBracket = ')';
        public char leftBracket2 = '{';
        public char rightBracket2 = '}';
        public BracketsHighlightStrategy bracketsHighlightStrategy = BracketsHighlightStrategy.Strategy2;
        public readonly List<Style> styles = new List<Style>();
        public readonly List<RuleDesc> rules = new List<RuleDesc>();
        public readonly List<FoldingDesc> foldings = new List<FoldingDesc>();

        public void Dispose()
        {
            foreach (var style in styles)
                style.Dispose();
        }
    }

    public class RuleDesc
    {
        Regex regex;
        public string pattern;
        public RegexOptions options = RegexOptions.None;
        public Style style;

        public Regex Regex
        {
            get
            {
                if (regex == null)
                {
                    regex = new Regex(pattern, SyntaxHighlighter.RegexCompiledOption | options);
                }

                return regex;
            }
        }
    }

    public class FoldingDesc
    {
        public string startMarkerRegex;
        public string finishMarkerRegex;
        public RegexOptions options = RegexOptions.None;
    }
}

================================================
FILE: FastColoredTextBox/SyntaxHighlighter.cs
================================================
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Globalization;
using System.IO;
using System.Text.RegularExpressions;
using System.Xml;

namespace FastColoredTextBoxNS
{
    public class SyntaxHighlighter : IDisposable
    {
        //styles
        protected static readonly Platform platformType = PlatformType.GetOperationSystemPlatform();
        public readonly Style BlueBoldStyle = new TextStyle(Brushes.Blue, null, FontStyle.Bold);
        public readonly Style BlueStyle = new TextStyle(Brushes.Blue, null, FontStyle.Regular);
        public readonly Style BoldStyle = new TextStyle(null, null, FontStyle.Bold | FontStyle.Underline);
        public readonly Style BrownStyle = new TextStyle(Brushes.Brown, null, FontStyle.Italic);
        public readonly Style GrayStyle = new TextStyle(Brushes.Gray, null, FontStyle.Regular);
        public readonly Style GreenStyle = new TextStyle(Brushes.Green, null, FontStyle.Italic);
        public readonly Style MagentaStyle = new TextStyle(Brushes.Magenta, null, FontStyle.Regular);
        public readonly Style MaroonStyle = new TextStyle(Brushes.Maroon, null, FontStyle.Regular);
        public readonly Style RedStyle = new TextStyle(Brushes.Red, null, FontStyle.Regular);
        public readonly Style BlackStyle = new TextStyle(Brushes.Black, null, FontStyle.Regular);
        public readonly Style CrimsonStyle = new TextStyle(Brushes.Crimson, null, FontStyle.Regular);
        public readonly Style DarkOrangeStyle = new TextStyle(Brushes.DarkOrange, null, FontStyle.Regular);
        public readonly Style DodgerBlueStyle = new TextStyle(Brushes.DodgerBlue, null, FontStyle.Regular);

        public readonly Style DarkOrangeBoldStyle =
            new TextStyle(Brushes.DarkOrange, null, FontStyle.Bold | FontStyle.Regular);

        public readonly Style RazorDarkKeywords =
            new TextStyle(new SolidBrush(Color.FromArgb(255, 253, 134, 30)), null, FontStyle.Regular);

        public readonly Style RazorDarkCommands =
            new TextStyle(new SolidBrush(Color.FromArgb(255, 43, 144, 175)), null, FontStyle.Regular);

        public readonly Style RazorDarkStrings =
            new TextStyle(new SolidBrush(Color.FromArgb(255, 181, 241, 9)), null, FontStyle.Regular);

        public readonly Style RazorDarkOperators =
            new TextStyle(new SolidBrush(Color.FromArgb(255, 253, 134, 30)), null, FontStyle.Regular);

        public readonly Style RazorDarkNumbers =
            new TextStyle(new SolidBrush(Color.FromArgb(255, 174, 129, 255)), null, FontStyle.Regular);

        public readonly Style RazorDarkComments =
            new TextStyle(new SolidBrush(Color.FromArgb(255, 150, 150, 150)), null, FontStyle.Regular);

        public readonly Style RazorDarkSerial =
            new TextStyle(new SolidBrush(Color.FromArgb(255, 249, 37, 77)), null, FontStyle.Regular);


        //
        protected readonly Dictionary<string, SyntaxDescriptor> descByXMLfileNames =
            new Dictionary<string, SyntaxDescriptor>();

        protected readonly List<Style> resilientStyles = new List<Style>(5);

        protected Regex RazorCommentRegex;
        protected Regex RazorSerialRegex;
        protected Regex RazorOperatorRegex;
        protected Regex RazorLayerRegex;
        protected Regex RazorExpressionRegex;
        protected Regex RazorCommandRegex;
        protected Regex RazorKeywordRegex;
        protected Regex RazorNumberRegex;
        protected Regex RazorStringRegex1;
        protected Regex RazorStringRegex2;

        protected FastColoredTextBox currentTb;

        public static RegexOptions RegexCompiledOption
        {
            get
            {
                if (platformType == Platform.X86)
                    return RegexOptions.Compiled;
                else
                    return RegexOptions.None;
            }
        }

        public SyntaxHighlighter(FastColoredTextBox currentTb)
        {
            this.currentTb = currentTb;
        }

        #region IDisposable Members

        public void Dispose()
        {
            foreach (SyntaxDescriptor desc in descByXMLfileNames.Values)
                desc.Dispose();
        }

        #endregion

        /// <summary>
        /// Highlights syntax for given language
        /// </summary>
        public virtual void HighlightSyntax(Language language, Range range)
        {
            RazorSyntaxHighlight(range);
        }

        /// <summary>
        /// Highlights syntax for given XML description file
        /// </summary>
        public virtual void HighlightSyntax(string XMLdescriptionFile, Range range)
        {
            SyntaxDescriptor desc = null;
            if (!descByXMLfileNames.TryGetValue(XMLdescriptionFile, out desc))
            {
                var doc = new XmlDocument();
                string file = XMLdescriptionFile;
                if (!File.Exists(file))
                    file = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, Path.GetFileName(file));

                doc.LoadXml(File.ReadAllText(file));
                desc = ParseXmlDescription(doc);
                descByXMLfileNames[XMLdescriptionFile] = desc;
            }

            HighlightSyntax(desc, range);
        }

        public virtual void AutoIndentNeeded(object sender, AutoIndentEventArgs args)
        {
            RazorAutoIndentNeeded(sender, args);
        }

        /// <summary>
        /// Uses the given <paramref name="doc"/> to parse a XML description and adds it as syntax descriptor. 
        /// The syntax descriptor is used for highlighting when 
        /// <list type="bullet">
        ///     <item>Language property of FCTB is set to <see cref="Language.Custom"/></item>
        ///     <item>DescriptionFile property of FCTB has the same value as the method parameter <paramref name="descriptionFileName"/></item>
        /// </list>
        /// </summary>
        /// <param name="descriptionFileName">Name of the description file</param>
        /// <param name="doc">XmlDocument to parse</param>
        public virtual void AddXmlDescription(string descriptionFileName, XmlDocument doc)
        {
            SyntaxDescriptor desc = ParseXmlDescription(doc);
            descByXMLfileNames[descriptionFileName] = desc;
        }

        /// <summary>
        /// Adds the given <paramref name="style"/> as resilient style. A resilient style is additionally available when highlighting is 
        /// based on a syntax descriptor that has been derived from a XML description file. In the run of the highlighting routine 
        /// the styles used by the FCTB are always dropped and replaced with the (initial) ones from the syntax descriptor. Resilient styles are 
        /// added afterwards and can be used anyway. 
        /// </summary>
        /// <param name="style">Style to add</param>
        public virtual void AddResilientStyle(Style style)
        {
            if (resilientStyles.Contains(style)) return;
            currentTb.CheckStylesBufferSize(); // Prevent buffer overflow
            resilientStyles.Add(style);
        }

        public static SyntaxDescriptor ParseXmlDescription(XmlDocument doc)
        {
            var desc = new SyntaxDescriptor();
            XmlNode brackets = doc.SelectSingleNode("doc/brackets");
            if (brackets != null)
            {
                if (brackets.Attributes["left"] == null || brackets.Attributes["right"] == null ||
                    brackets.Attributes["left"].Value == "" || brackets.Attributes["right"].Value == "")
                {
                    desc.leftBracket = '\x0';
                    desc.rightBracket = '\x0';
                }
                else
                {
                    desc.leftBracket = brackets.Attributes["left"].Value[0];
                    desc.rightBracket = brackets.Attributes["right"].Value[0];
                }

                if (brackets.Attributes["left2"] == null || brackets.Attributes["right2"] == null ||
                    brackets.Attributes["left2"].Value == "" || brackets.Attributes["right2"].Value == "")
                {
                    desc.leftBracket2 = '\x0';
                    desc.rightBracket2 = '\x0';
                }
                else
                {
                    desc.leftBracket2 = brackets.Attributes["left2"].Value[0];
                    desc.rightBracket2 = brackets.Attributes["right2"].Value[0];
                }

                if (brackets.Attributes["strategy"] == null || brackets.Attributes["strategy"].Value == "")
                    desc.bracketsHighlightStrategy = BracketsHighlightStrategy.Strategy2;
                else
                    desc.bracketsHighlightStrategy =
                        (BracketsHighlightStrategy) Enum.Parse(typeof(BracketsHighlightStrategy),
                            brackets.Attributes["strategy"].Value);
            }

            var styleByName = new Dictionary<string, Style>();

            foreach (XmlNode style in doc.SelectNodes("doc/style"))
            {
                Style s = ParseStyle(style);
                styleByName[style.Attributes["name"].Value] = s;
                desc.styles.Add(s);
            }

            foreach (XmlNode rule in doc.SelectNodes("doc/rule"))
                desc.rules.Add(ParseRule(rule, styleByName));
            foreach (XmlNode folding in doc.SelectNodes("doc/folding"))
                desc.foldings.Add(ParseFolding(folding));

            return desc;
        }

        protected static FoldingDesc ParseFolding(XmlNode foldingNode)
        {
            var folding = new FoldingDesc();
            //regex
            folding.startMarkerRegex = foldingNode.Attributes["start"].Value;
            folding.finishMarkerRegex = foldingNode.Attributes["finish"].Value;
            //options
            XmlAttribute optionsA = foldingNode.Attributes["options"];
            if (optionsA != null)
                folding.options = (RegexOptions) Enum.Parse(typeof(RegexOptions), optionsA.Value);

            return folding;
        }

        protected static RuleDesc ParseRule(XmlNode ruleNode, Dictionary<string, Style> styles)
        {
            var rule = new RuleDesc();
            rule.pattern = ruleNode.InnerText;
            //
            XmlAttribute styleA = ruleNode.Attributes["style"];
            XmlAttribute optionsA = ruleNode.Attributes["options"];
            //Style
            if (styleA == null)
                throw new Exception("Rule must contain style name.");
            if (!styles.ContainsKey(styleA.Value))
                throw new Exception("Style '" + styleA.Value + "' is not found.");
            rule.style = styles[styleA.Value];
            //options
            if (optionsA != null)
                rule.options = (RegexOptions) Enum.Parse(typeof(RegexOptions), optionsA.Value);

            return rule;
        }

        protected static Style ParseStyle(XmlNode styleNode)
        {
            XmlAttribute typeA = styleNode.Attributes["type"];
            XmlAttribute colorA = styleNode.Attributes["color"];
            XmlAttribute backColorA = styleNode.Attributes["backColor"];
            XmlAttribute fontStyleA = styleNode.Attributes["fontStyle"];
            XmlAttribute nameA = styleNode.Attributes["name"];
            //colors
            SolidBrush foreBrush = null;
            if (colorA != null)
                foreBrush = new SolidBrush(ParseColor(colorA.Value));
            SolidBrush backBrush = null;
            if (backColorA != null)
                backBrush = new SolidBrush(ParseColor(backColorA.Value));
            //fontStyle
            FontStyle fontStyle = FontStyle.Regular;
            if (fontStyleA != null)
                fontStyle = (FontStyle) Enum.Parse(typeof(FontStyle), fontStyleA.Value);

            return new TextStyle(foreBrush, backBrush, fontStyle);
        }

        protected static Color ParseColor(string s)
        {
            if (s.StartsWith("#"))
            {
                if (s.Length <= 7)
                    return Color.FromArgb(255,
                        Color.FromArgb(Int32.Parse(s.Substring(1), NumberStyles.AllowHexSpecifier)));
                else
                    return Color.FromArgb(Int32.Parse(s.Substring(1), NumberStyles.AllowHexSpecifier));
            }
            else
                return Color.FromName(s);
        }

        public void HighlightSyntax(SyntaxDescriptor desc, Range range)
        {
            //set style order
            range.tb.ClearStylesBuffer();
            for (int i = 0; i < desc.styles.Count; i++)
                range.tb.Styles[i] = desc.styles[i];
            // add resilient styles
            int l = desc.styles.Count;
            for (int i = 0; i < resilientStyles.Count; i++)
                range.tb.Styles[l + i] = resilientStyles[i];
            //brackets
            char[] oldBrackets = RememberBrackets(range.tb);
            range.tb.LeftBracket = desc.leftBracket;
            range.tb.RightBracket = desc.rightBracket;
            range.tb.LeftBracket2 = desc.leftBracket2;
            range.tb.RightBracket2 = desc.rightBracket2;
            //clear styles of range
            range.ClearStyle(desc.styles.ToArray());
            //highlight syntax
            foreach (RuleDesc rule in desc.rules)
                range.SetStyle(rule.style, rule.Regex);
            //clear folding
            range.ClearFoldingMarkers();
            //folding markers
            foreach (FoldingDesc folding in desc.foldings)
                range.SetFoldingMarkers(folding.startMarkerRegex, folding.finishMarkerRegex, folding.options);

            //
            RestoreBrackets(range.tb, oldBrackets);
        }

        protected void RestoreBrackets(FastColoredTextBox tb, char[] oldBrackets)
        {
            tb.LeftBracket = oldBrackets[0];
            tb.RightBracket = oldBrackets[1];
            tb.LeftBracket2 = oldBrackets[2];
            tb.RightBracket2 = oldBrackets[3];
        }

        protected char[] RememberBrackets(FastColoredTextBox tb)
        {
            return new[] {tb.LeftBracket, tb.RightBracket, tb.LeftBracket2, tb.RightBracket2};
        }

        public void InitStyleSchema(Language lang)
        {
            CommentStyle = RazorDarkComments;
            StringStyle = RazorDarkStrings;
            NumberStyle = RazorDarkNumbers;
            KeywordStyle = RazorDarkKeywords;
            FunctionsStyle = RedStyle;
            RazorCommandStyle = RazorDarkCommands;
            RazorSerialStyle = RazorDarkSerial;
            RazorLayerStyle = RazorDarkNumbers;
            RazorExpressionStyle = RazorDarkSerial;
        }

        protected void InitRazorRegex()
        {
            RazorStringRegex1 = new Regex("([\"'])(?:(?=(\\\\?))\\2.)*?\\1", RegexCompiledOption);

            RazorStringRegex2 = new Regex("'[^'\\\\]*(\\\\.[^'\\\\]*)*'", RegexCompiledOption);

            RazorCommentRegex = new Regex("(//.*$|#.*$)", RegexOptions.Multiline | RegexCompiledOption);

            RazorSerialRegex = new Regex(@"0x[\da-fA-F]*");

            RazorNumberRegex = new Regex(@"\b[+-]?[0-9]+(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?\b", RegexCompiledOption);
            RazorKeywordRegex =
                new Regex(
                    @"\b(if|elseif|else|endif|while|endwhile|for|foreach|endfor|break|continue|not|and|or|stop|replay|loop|as|in)\b",
                    RegexCompiledOption);

            RazorCommandRegex =
                new Regex(
                    @"\b(attack|cast|dress|undress|dressconfig|target|targettype|targetloc|targetrelloc|dress|drop|waitfortarget|wft|dclick|dclicktype|dclickvar|usetype|useobject|droprelloc|lift|lifttype|waitforgump|gumpresponse|gumpclose|menu|menuresponse|waitformenu|promptresponse|waitforprompt|hotkey|say|msg|overhead|sysmsg|wait|pause|waitforstat|setability|setlasttarget|lasttarget|setvar|unsetvar|skill|useskill|walk|script|useonce|organizer|organize|org|restock|scav|scavenger|potion|clearsysmsg|clearjournal|whisper|yell|guild|alliance|emote|waitforsysmsg|wfsysmsg|clearall|virtue|interrupt|sound|music|classicuo|cuo|rename|getlabel|ignore|unignore|clearignore|cooldown|settimer|removetimer|createtimer|poplist|pushlist|removelist|createlist|clearlist|cleardragdrop|clearhands|sell)\b",
                    RegexCompiledOption);

            RazorLayerRegex =
                new Regex(
                    @"\b(RightHand|LeftHand|Shoes|Pants|Shirt|Head|Gloves|Ring|Talisman|Neck|Hair|Waist|InnerTorso|Bracelet|FacialHair|MiddleTorso|Earrings|Arms|Cloak|Backpack|OuterTorso|OuterLegs|InnerLegs|backpack|true|false|criminal|enemy|friend|friendly|grey|gray|innocent|murderer|red|blue|nonfriendly|cancel|clear|minutes|minute|min|seconds|second|sec)\b",
                    RegexCompiledOption);

            RazorExpressionRegex =
                new Regex(
                    @"\b(queued|position|insysmsg|insysmessage|findtype|findbuff|finddebuff|stam|maxstam|hp|maxhp|maxhits|hits|mana|maxmana|str|dex|int|poisoned|hidden|mounted|rhandempty|lhandempty|skill|count|counter|weight|dead|closest|close|rand|random|next|prev|previous|human|humanoid|monster|varexist|varexist|followers|maxfollowers|maxweight|targetexists|diffmana|diffstam|diffhits|diffhp|diffweight|blessed|invul|invuln|warmode|name|paralyzed|itemcount|poplist|atlist|listexists|list|inlist|timer|timerexists)\b",
                    RegexCompiledOption);
        }

        public virtual void RazorSyntaxHighlight(Range range)
        {
            range.tb.CommentPrefix = "//";

            range.tb.LeftBracket = '(';
            range.tb.RightBracket = ')';
            range.tb.LeftBracket2 = '[';
            range.tb.RightBracket2 = ']';
            range.tb.BracketsHighlightStrategy = BracketsHighlightStrategy.Strategy1;

            //range.tb.AutoIndentCharsPatterns = @"^\s*[\w\.]+(\s\w+)?\s*(?<range>=)\s*(?<range>.+)";

            //clear style of changed range
            range.ClearStyle(StringStyle, CommentStyle, NumberStyle, KeywordStyle, FunctionsStyle);

            InitRazorRegex();

            //string highlighting
            range.SetStyle(StringStyle, RazorStringRegex1);
            range.SetStyle(StringStyle, RazorStringRegex2);

            //comment highlighting
            range.SetStyle(CommentStyle, RazorCommentRegex);

            //number highlighting
            range.SetStyle(NumberStyle, RazorNumberRegex);

            //keyword highlighting
            range.SetStyle(KeywordStyle, RazorKeywordRegex);

            // Razor highlight
            range.SetStyle(RazorCommandStyle, RazorCommandRegex);
            range.SetStyle(RazorSerialStyle, RazorSerialRegex);
            range.SetStyle(RazorLayerStyle, RazorLayerRegex);
            range.SetStyle(RazorExpressionStyle, RazorExpressionRegex);
            //range.SetStyle(RazorOperatorStyle, RazorOperatorsRegEx);

            //clear folding markers
            range.ClearFoldingMarkers();
        }

        protected void RazorAutoIndentNeeded(object sender, AutoIndentEventArgs args)
        {
            if (Regex.IsMatch(args.LineText, @"^[^""']*\:"))
            {
                args.ShiftNextLines = args.TabLength;
            }

            if (Regex.IsMatch(args.PrevLineText, @"^\s*(if|for|while|elseif|[\}\s]*else)\b[^{]*$"))
                if (!Regex.IsMatch(args.PrevLineText, @"(;\s*$)|(;\s*//)")) //operator is unclosed
                {
                    args.Shift = args.TabLength;
                }
        }

        #region Styles

        /// <summary>
        /// String style
        /// </summary>
        public Style StringStyle { get; set; }

        /// <summary>
        /// Comment style
        /// </summary>
        public Style CommentStyle { get; set; }

        /// <summary>
        /// Number style
        /// </summary>
        public Style NumberStyle { get; set; }

        /// <summary>
        /// Keyword style
        /// </summary>
        public Style KeywordStyle { get; set; }

      
        /// <summary>
        /// SQL Functions style
        /// </summary>
        public Style FunctionsStyle { get; set; }

        public Style RazorCommandStyle { get; set; }
        public Style RazorSerialStyle { get; set; }
        public Style RazorLayerStyle { get; set; }
        public Style RazorExpressionStyle { get; set; }
        public Style RazorOperatorStyle { get; set; }

        #endregion
    }

    /// <summary>
    /// Language
    /// </summary>
    public enum Language
    {
        Razor
    }
}

================================================
FILE: FastColoredTextBox/TextSource.cs
================================================
using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;
using System.Drawing;
using System.IO;

namespace FastColoredTextBoxNS
{
    /// <summary>
    /// This class contains the source text (chars and styles).
    /// It stores a text lines, the manager of commands, undo/redo stack, styles.
    /// </summary>
    public class TextSource : IList<Line>, IDisposable
    {
        readonly protected List<Line> lines = new List<Line>();
        protected LinesAccessor linesAccessor;
        int lastLineUniqueId;
        public CommandManager Manager { get; set; }
        FastColoredTextBox currentTB;

        /// <summary>
        /// Styles
        /// </summary>
        public readonly Style[] Styles;

        /// <summary>
        /// Occurs when line was inserted/added
        /// </summary>
        public event EventHandler<LineInsertedEventArgs> LineInserted;

        /// <summary>
        /// Occurs when line was removed
        /// </summary>
        public event EventHandler<LineRemovedEventArgs> LineRemoved;

        /// <summary>
        /// Occurs when text was changed
        /// </summary>
        public event EventHandler<TextChangedEventArgs> TextChanged;

        /// <summary>
        /// Occurs when recalc is needed
        /// </summary>
        public event EventHandler<TextChangedEventArgs> RecalcNeeded;

        /// <summary>
        /// Occurs when recalc wordwrap is needed
        /// </summary>
        public event EventHandler<TextChangedEventArgs> RecalcWordWrap;

        /// <summary>
        /// Occurs before text changing
        /// </summary>
        public event EventHandler<TextChangingEventArgs> TextChanging;

        /// <summary>
        /// Occurs after CurrentTB was changed
        /// </summary>
        public event EventHandler CurrentTBChanged;

        /// <summary>
        /// Current focused FastColoredTextBox
        /// </summary>
        public FastColoredTextBox CurrentTB
        {
            get { return currentTB; }
            set
            {
                if (currentTB == value)
                    return;
                currentTB = value;
                OnCurrentTBChanged();
            }
        }

        public virtual void ClearIsChanged()
        {
            foreach (var line in lines)
                line.IsChanged = false;
        }

        public virtual Line CreateLine()
        {
            return new Line(GenerateUniqueLineId());
        }

        private void OnCurrentTBChanged()
        {
            if (CurrentTBChanged != null)
                CurrentTBChanged(this, EventArgs.Empty);
        }

        /// <summary>
        /// Default text style
        /// This style is using when no one other TextStyle is not defined in Char.style
        /// </summary>
        public TextStyle DefaultStyle { get; set; }

        public TextSource(FastColoredTextBox currentTB)
        {
            this.CurrentTB = currentTB;
            linesAccessor = new LinesAccessor(this);
            Manager = new CommandManager(this);

            if (Enum.GetUnderlyingType(typeof(StyleIndex)) == typeof(UInt32))
                Styles = new Style[32];
            else
                Styles = new Style[16];

            InitDefaultStyle();
        }

        public virtual void InitDefaultStyle()
        {
            DefaultStyle = new TextStyle(null, null, FontStyle.Regular);
        }

        public virtual Line this[int i]
        {
            get { return lines[i]; }
            set { throw new NotImplementedException(); }
        }

        public virtual bool IsLineLoaded(int iLine)
        {
            return lines[iLine] != null;
        }

        /// <summary>
        /// Text lines
        /// </summary>
        public virtual IList<string> GetLines()
        {
            return linesAccessor;
        }

        public IEnumerator<Line> GetEnumerator()
        {
            return lines.GetEnumerator();
        }

        IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return (lines as IEnumerator);
        }

        public virtual int BinarySearch(Line item, IComparer<Line> comparer)
        {
            return lines.BinarySearch(item, comparer);
        }

        public virtual int GenerateUniqueLineId()
        {
            return lastLineUniqueId++;
        }

        public virtual void InsertLine(int index, Line line)
        {
            lines.Insert(index, line);
            OnLineInserted(index);
        }

        public virtual void OnLineInserted(int index)
        {
            OnLineInserted(index, 1);
        }

        public virtual void OnLineInserted(int index, int count)
        {
            if (LineInserted != null)
                LineInserted(this, new LineInsertedEventArgs(index, count));
        }

        public virtual void RemoveLine(int index)
        {
            RemoveLine(index, 1);
        }

        public virtual bool IsNeedBuildRemovedLineIds
        {
            get { return LineRemoved != null; }
        }

        public virtual void RemoveLine(int index, int count)
        {
            List<int> removedLineIds = new List<int>();
            //
            if (count > 0)
                if (IsNeedBuildRemovedLineIds)
                    for (int i = 0; i < count; i++)
                        removedLineIds.Add(this[index + i].UniqueId);
            //
            lines.RemoveRange(index, count);

            OnLineRemoved(index, count, removedLineIds);
        }

        public virtual void OnLineRemoved(int index, int count, List<int> removedLineIds)
        {
            if (count > 0)
                if (LineRemoved != null)
                    LineRemoved(this, new LineRemovedEventArgs(index, count, removedLineIds));
        }

        public virtual void OnTextChanged(int fromLine, int toLine)
        {
            if (TextChanged != null)
                TextChanged(this, new TextChangedEventArgs(Math.Min(fromLine, toLine), Math.Max(fromLine, toLine)));
        }

        public class TextChangedEventArgs : EventArgs
        {
            public int iFromLine;
            public int iToLine;

            public TextChangedEventArgs(int iFromLine, int iToLine)
            {
                this.iFromLine = iFromLine;
                this.iToLine = iToLine;
            }
        }

        public virtual int IndexOf(Line item)
        {
            return lines.IndexOf(item);
        }

        public virtual void Insert(int index, Line item)
        {
            InsertLine(index, item);
        }

        public virtual void RemoveAt(int index)
        {
            RemoveLine(index);
        }

        public virtual void Add(Line item)
        {
            InsertLine(Count, item);
        }

        public virtual void Clear()
        {
            RemoveLine(0, Count);
        }

        public virtual bool Contains(Line item)
        {
            return lines.Contains(item);
        }

        public virtual void CopyTo(Line[] array, int arrayIndex)
        {
            lines.CopyTo(array, arrayIndex);
        }

        /// <summary>
        /// Lines count
        /// </summary>
        public virtual int Count
        {
            get { return lines.Count; }
        }

        public virtual bool IsReadOnly
        {
            get { return false; }
        }

        public virtual bool Remove(Line item)
        {
            int i = IndexOf(item);
            if (i >= 0)
            {
                RemoveLine(i);
                return true;
            }
            else
                return false;
        }

        public virtual void NeedRecalc(TextChangedEventArgs args)
        {
            if (RecalcNeeded != null)
                RecalcNeeded(this, args);
        }

        public virtual void OnRecalcWordWrap(TextChangedEventArgs args)
        {
            if (RecalcWordWrap != null)
                RecalcWordWrap(this, args);
        }

        public virtual void OnTextChanging()
        {
            string temp = null;
            OnTextChanging(ref temp);
        }

        public virtual void OnTextChanging(ref string text)
        {
            if (TextChanging != null)
            {
                var args = new TextChangingEventArgs() {InsertingText = text};
                TextChanging(this, args);
                text = args.InsertingText;
                if (args.Cancel)
                    text = string.Empty;
            }

            ;
        }

        public virtual int GetLineLength(int i)
        {
            return lines[i].Count;
        }

        public virtual bool LineHasFoldingStartMarker(int iLine)
        {
            return !string.IsNullOrEmpty(lines[iLine].FoldingStartMarker);
        }

        public virtual bool LineHasFoldingEndMarker(int iLine)
        {
            return !string.IsNullOrEmpty(lines[iLine].FoldingEndMarker);
        }

        public virtual void Dispose()
        {
            ;
        }

        public virtual void SaveToFile(string fileName, Encoding enc)
        {
            using (StreamWriter sw = new StreamWriter(fileName, false, enc))
            {
                for (int i = 0; i < Count - 1; i++)
                    sw.WriteLine(lines[i].Text);

                sw.Write(lines[Count - 1].Text);
            }
        }
    }
}

================================================
FILE: FastColoredTextBox/TypeDescriptor.cs
================================================
using System;
using System.ComponentModel;
using System.Windows.Forms;

namespace FastColoredTextBoxNS
{
    ///
    /// These classes are required for correct data binding to Text property of FastColoredTextbox
    /// 
    class FCTBDescriptionProvider : TypeDescriptionProvider
    {
        public FCTBDescriptionProvider(Type type)
            : base(GetDefaultTypeProvider(type))
        {
        }

        private static TypeDescriptionProvider GetDefaultTypeProvider(Type type)
        {
            return TypeDescriptor.GetProvider(type);
        }


        public override ICustomTypeDescriptor GetTypeDescriptor(Type objectType, object instance)
        {
            ICustomTypeDescriptor defaultDescriptor = base.GetTypeDescriptor(objectType, instance);
            return new FCTBTypeDescriptor(defaultDescriptor, instance);
        }
    }

    class FCTBTypeDescriptor : CustomTypeDescriptor
    {
        ICustomTypeDescriptor parent;
        object instance;

        public FCTBTypeDescriptor(ICustomTypeDescriptor parent, object instance)
            : base(parent)
        {
            this.parent = parent;
            this.instance = instance;
        }

        public override string GetComponentName()
        {
            var ctrl = (instance as Control);
            return ctrl == null ? null : ctrl.Name;
        }

        public override EventDescriptorCollection GetEvents()
        {
            var coll = base.GetEvents();
            var list = new EventDescriptor[coll.Count];

            for (int i = 0; i < coll.Count; i++)
                if (coll[i].Name == "TextChanged") //instead of TextChanged slip BindingTextChanged for binding
                    list[i] = new FooTextChangedDescriptor(coll[i]);
                else
                    list[i] = coll[i];

            return new EventDescriptorCollection(list);
        }
    }

    class FooTextChangedDescriptor : EventDescriptor
    {
        public FooTextChangedDescriptor(MemberDescriptor desc)
            : base(desc)
        {
        }

        public override void AddEventHandler(object component, Delegate value)
        {
            (component as FastColoredTextBox).BindingTextChanged += value as EventHandler;
        }

        public override Type ComponentType
        {
            get { return typeof(FastColoredTextBox); }
        }

        public override Type EventType
        {
            get { return typeof(EventHandler); }
        }

        public override bool IsMulticast
        {
            get { return true; }
        }

        public override void RemoveEventHandler(object component, Delegate value)
        {
            (component as FastColoredTextBox).BindingTextChanged -= value as EventHandler;
        }
    }
}

================================================
FILE: FastColoredTextBox/UnfocusablePanel.cs
================================================
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Text;
using System.Windows.Forms;

namespace FastColoredTextBoxNS
{
    [System.ComponentModel.ToolboxItem(false)]
    public class UnfocusablePanel : UserControl
    {
        public Color BackColor2 { get; set; }
        public Color BorderColor { get; set; }
        public new string Text { get; set; }
        public StringAlignment TextAlignment { get; set; }

        public UnfocusablePanel()
        {
            SetStyle(ControlStyles.Selectable, false);
            SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.OptimizedDoubleBuffer | ControlStyles.UserPaint,
                true);
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            using (var brush = new LinearGradientBrush(ClientRectangle, BackColor2, BackColor, 90))
                e.Graphics.FillRectangle(brush, 0, 0, ClientSize.Width - 1, ClientSize.Height - 1);
            using (var pen = new Pen(BorderColor))
                e.Graphics.DrawRectangle(pen, 0, 0, ClientSize.Width - 1, ClientSize.Height - 1);

            if (!string.IsNullOrEmpty(Text))
            {
                StringFormat sf = new StringFormat();
                sf.Alignment = TextAlignment;
                sf.LineAlignment = StringAlignment.Center;
                using (var brush = new SolidBrush(ForeColor))
                    e.Graphics.DrawString(Text, Font, brush,
                        new RectangleF(1, 1, ClientSize.Width - 2, ClientSize.Height - 2), sf);
            }
        }
    }
}

================================================
FILE: FastColoredTextBox/VisualMarker.cs
================================================
using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.Windows.Forms;

namespace FastColoredTextBoxNS
{
    public class VisualMarker
    {
        public readonly Rectangle rectangle;

        public VisualMarker(Rectangle rectangle)
        {
            this.rectangle = rectangle;
        }

        public virtual void Draw(Graphics gr, Pen pen)
        {
        }

        public virtual Cursor Cursor
        {
            get { return Cursors.Hand; }
        }
    }

    public class CollapseFoldingMarker : VisualMarker
    {
        public readonly int iLine;

        public CollapseFoldingMarker(int iLine, Rectangle rectangle)
            : base(rectangle)
        {
            this.iLine = iLine;
        }

        public void Draw(Graphics gr, Pen pen, Brush backgroundBrush, Pen forePen)
        {
            //draw minus
            gr.FillRectangle(backgroundBrush, rectangle);
            gr.DrawRectangle(pen, rectangle);
            gr.DrawLine(forePen, rectangle.Left + 2, rectangle.Top + rectangle.Height / 2, rectangle.Right - 2,
                rectangle.Top + rectangle.Height / 2);
        }
    }

    public class ExpandFoldingMarker : VisualMarker
    {
        public readonly int iLine;

        public ExpandFoldingMarker(int iLine, Rectangle rectangle)
            : base(rectangle)
        {
            this.iLine = iLine;
        }

        public void Draw(Graphics gr, Pen pen, Brush backgroundBrush, Pen forePen)
        {
            //draw plus
            gr.FillRectangle(backgroundBrush, rectangle);
            gr.DrawRectangle(pen, rectangle);
            gr.DrawLine(forePen, rectangle.Left + 2, rectangle.Top + rectangle.Height / 2, rectangle.Right - 2,
                rectangle.Top + rectangle.Height / 2);
            gr.DrawLine(forePen, rectangle.Left + rectangle.Width / 2, rectangle.Top + 2,
                rectangle.Left + rectangle.Width / 2, rectangle.Bottom - 2);
        }
    }

    public class FoldedAreaMarker : VisualMarker
    {
        public readonly int iLine;

        public FoldedAreaMarker(int iLine, Rectangle rectangle)
            : base(rectangle)
        {
            this.iLine = iLine;
        }

        public override void Draw(Graphics gr, Pen pen)
        {
            gr.DrawRectangle(pen, rectangle);
        }
    }

    public class StyleVisualMarker : VisualMarker
    {
        public Style Style { get; private set; }

        public StyleVisualMarker(Rectangle rectangle, Style style)
            : base(rectangle)
        {
            this.Style = style;
        }
    }

    public class VisualMarkerEventArgs : MouseEventArgs
    {
        public Style Style { get; private set; }
        public StyleVisualMarker Marker { get; private set; }

        public VisualMarkerEventArgs(Style style, StyleVisualMarker marker, MouseEventArgs args)
            : base(args.Button, args.Clicks, args.X, args.Y, args.Delta)
        {
            this.Style = style;
            this.Marker = marker;
        }
    }
}

================================================
FILE: INSTALL.md
================================================
# Installation

These steps assume that you already have obtained and installed the Ultima Online game asset files in the local system and want to install ClassicUO and Razor for the first time.

For information on installing Razor on Windows, [please read this guide](https://www.razorce.com/install/windows/).

For information on installing Razor on Linux, [please read this guide](https://www.razorce.com/install/linux/).

================================================
FILE: LICENSE.md
================================================
                    GNU GENERAL PUBLIC LICENSE
                       Version 3, 29 June 2007

 Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

                            Preamble

  The GNU General Public License is a free, copyleft license for
software and other kinds of works.

  The licenses for most software and other practical works are designed
to take away your freedom to share and change the works.  By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users.  We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors.  You can apply it to
your programs, too.

  When we speak of free software, we are referring to freedom, not
price.  Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.

  To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights.  Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.

  For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received.  You must make sure that they, too, receive
or can get the source code.  And you must show them these terms so they
know their rights.

  Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.

  For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software.  For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.

  Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so.  This is fundamentally incompatible with the aim of
protecting users' freedom to change the software.  The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable.  Therefore, we
have designed this version of the GPL to prohibit the practice for those
products.  If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.

  Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary.  To prevent this, the GPL assures that
patents cannot be used to render the program non-free.

  The precise terms and conditions for copying, distribution and
modification follow.

                       TERMS AND CONDITIONS

  0. Definitions.

  "This License" refers to version 3 of the GNU General Public License.

  "Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.

  "The Program" refers to any copyrightable work licensed under this
License.  Each licensee is addressed as "you".  "Licensees" and
"recipients" may be individuals or organizations.

  To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy.  The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.

  A "covered work" means either the unmodified Program or a work based
on the Program.

  To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy.  Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.

  To "convey" a work means any kind of propagation that enables other
parties to make or receive copies.  Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.

  An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License.  If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.

  1. Source Code.

  The "source code" for a work means the preferred form of the work
for making modifications to it.  "Object code" means any non-source
form of a work.

  A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.

  The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form.  A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.

  The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities.  However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work.  For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.

  The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.

  The Corresponding Source for a work in source code form is that
same work.

  2. Basic Permissions.

  All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met.  This License explicitly affirms your unlimited
permission to run the unmodified Program.  The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work.  This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.

  You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force.  You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright.  Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.

  Conveying under any other circumstances is permitted solely under
the conditions stated below.  Sublicensing is not allowed; section 10
makes it unnecessary.

  3. Protecting Users' Legal Rights From Anti-Circumvention Law.

  No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.

  When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.

  4. Conveying Verbatim Copies.

  You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.

  You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.

  5. Conveying Modified Source Versions.

  You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:

    a) The work must carry prominent notices stating that you modified
    it, and giving a relevant date.

    b) The work must carry prominent notices stating that it is
    released under this License and any conditions added under section
    7.  This requirement modifies the requirement in section 4 to
    "keep intact all notices".

    c) You must license the entire work, as a whole, under this
    License to anyone who comes into possession of a copy.  This
    License will therefore apply, along with any applicable section 7
    additional terms, to the whole of the work, and all its parts,
    regardless of how they are packaged.  This License gives no
    permission to license the work in any other way, but it does not
    invalidate such permission if you have separately received it.

    d) If the work has interactive user interfaces, each must display
    Appropriate Legal Notices; however, if the Program has interactive
    interfaces that do not display Appropriate Legal Notices, your
    work need not make them do so.

  A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit.  Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.

  6. Conveying Non-Source Forms.

  You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:

    a) Convey the object code in, or embodied in, a physical product
    (including a physical distribution medium), accompanied by the
    Corresponding Source fixed on a durable physical medium
    customarily used for software interchange.

    b) Convey the object code in, or embodied in, a physical product
    (including a physical distribution medium), accompanied by a
    written offer, valid for at least three years and valid for as
    long as you offer spare parts or customer support for that product
    model, to give anyone who possesses the object code either (1) a
    copy of the Corresponding Source for all the software in the
    product that is covered by this License, on a durable physical
    medium customarily used for software interchange, for a price no
    more than your reasonable cost of physically performing this
    conveying of source, or (2) access to copy the
    Corresponding Source from a network server at no charge.

    c) Convey individual copies of the object code with a copy of the
    written offer to provide the Corresponding Source.  This
    alternative is allowed only occasionally and noncommercially, and
    only if you received the object code with such an offer, in accord
    with subsection 6b.

    d) Convey the object code by offering access from a designated
    place (gratis or for a charge), and offer equivalent access to the
    Corresponding Source in the same way through the same place at no
    further charge.  You need not require recipients to copy the
    Corresponding Source along with the object code.  If the place to
    copy the object code is a network server, the Corresponding Source
    may be on a different server (operated by you or a third party)
    that supports equivalent copying facilities, provided you maintain
    clear directions next to the object code saying where to find the
    Corresponding Source.  Regardless of what server hosts the
    Corresponding Source, you remain obligated to ensure that it is
    available for as long as needed to satisfy these requirements.

    e) Convey the object code using peer-to-peer transmission, provided
    you inform other peers where the object code and Corresponding
    Source of the work are being offered to the general public at no
    charge under subsection 6d.

  A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.

  A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling.  In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage.  For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product.  A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.

  "Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source.  The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.

  If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information.  But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).

  The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed.  Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.

  Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.

  7. Additional Terms.

  "Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law.  If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.

  When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it.  (Additional permissions may be written to require their own
removal in certain cases when you modify the work.)  You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.

  Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:

    a) Disclaiming warranty or limiting liability differently from the
    terms of sections 15 and 16 of this License; or

    b) Requiring preservation of specified reasonable legal notices or
    author attributions in that material or in the Appropriate Legal
    Notices displayed by works containing it; or

    c) Prohibiting misrepresentation of the origin of that material, or
    requiring that modified versions of such material be marked in
    reasonable ways as different from the original version; or

    d) Limiting the use for publicity purposes of names of licensors or
    authors of the material; or

    e) Declining to grant rights under trademark law for use of some
    trade names, trademarks, or service marks; or

    f) Requiring indemnification of licensors and authors of that
    material by anyone who conveys the material (or modified versions of
    it) with contractual assumptions of liability to the recipient, for
    any liability that these contractual assumptions directly impose on
    those licensors and authors.

  All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10.  If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term.  If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.

  If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.

  Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.

  8. Termination.

  You may not propagate or modify a covered work except as expressly
provided under this License.  Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).

  However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.

  Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.

  Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License.  If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.

  9. Acceptance Not Required for Having Copies.

  You are not required to accept this License in order to receive or
run a copy of the Program.  Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance.  However,
nothing other than this License grants you permission to propagate or
modify any covered work.  These actions infringe copyright if you do
not accept this License.  Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.

  10. Automatic Licensing of Downstream Recipients.

  Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License.  You are not responsible
for enforcing compliance by third parties with this License.

  An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations.  If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.

  You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License.  For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.

  11. Patents.

  A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based.  The
work thus licensed is called the contributor's "contributor version".

  A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version.  For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.

  Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.

  In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement).  To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.

  If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients.  "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.

  If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.

  A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License.  You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.

  Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.

  12. No Surrender of Others' Freedom.

  If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all.  For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.

  13. Use with the GNU Affero General Public License.

  Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work.  The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.

  14. Revised Versions of this License.

  The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time.  Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.

  Each version is given a distinguishing version number.  If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation.  If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.

  If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.

  Later license versions may give you additional or different
permissions.  However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.

  15. Disclaimer of Warranty.

  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

  16. Limitation of Liability.

  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.

  17. Interpretation of Sections 15 and 16.

  If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.

                     END OF TERMS AND CONDITIONS

            How to Apply These Terms to Your New Programs

  If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.

  To do so, attach the following notices to the program.  It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.

    <one line to give the program's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.

Also add information on how to contact you by electronic and paper mail.

  If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:

    <program>  Copyright (C) <year>  <name of author>
    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.

The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License.  Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".

  You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
<https://www.gnu.org/licenses/>.

  The GNU General Public License does not permit incorporating your program
into proprietary programs.  If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library.  If this is what you want to do, use the GNU Lesser General
Public License instead of this License.  But first, please read
<https://www.gnu.org/licenses/why-not-lgpl.html>.


================================================
FILE: Loader/Loader.cpp
================================================

#include "stdafx.h"

BOOL APIENTRY DllMain( HANDLE hModule, DWORD dwReason, LPVOID lpReserved )
{
	switch ( dwReason )
	{
	case DLL_PROCESS_ATTACH:
		DisableThreadLibraryCalls( (HMODULE)hModule );
		break;
	}

    return TRUE;
}

enum ERROR_TYPE
{
	SUCCESS = 0,
	NO_OPEN_EXE,
	NO_MAP_EXE,
	NO_READ_EXE_DATA,

	NO_RUN_EXE,
	NO_ALLOC_MEM,

	NO_WRITE,
	NO_VPROTECT,
	NO_READ,

	UNKNOWN_ERROR = 99
};

extern "C" __declspec(dllexport) DWORD __stdcall Load( const char *exe, const char *dll, const char *func, const void *dllData, int dataLen, DWORD *pid )
{
	SIZE_T Num;
	char buff[MAX_PATH];
	LPVOID Entry;
	STARTUPINFO StartInfo;
	PROCESS_INFORMATION ProcInfo;
	IMAGE_DOS_HEADER idh;
	IMAGE_OPTIONAL_HEADER32 ioh;

	FILE* pExe;
	if (fopen_s(&pExe, exe, "rb") != 0)
	{
	    buff[0] = 0;
	    if (GetShortPathName(exe, buff, MAX_PATH) >= MAX_PATH)
		   buff[0] = 0;
	    if (fopen_s(&pExe, buff, "rb") != 0)
		   return NO_OPEN_EXE;
	}

	if ( fread( &idh, 1, sizeof(IMAGE_DOS_HEADER), pExe ) != sizeof(IMAGE_DOS_HEADER) )
	{
		fclose( pExe );
		return NO_READ_EXE_DATA;
	}

	fseek( pExe, idh.e_lfanew + 4 + sizeof(IMAGE_FILE_HEADER), SEEK_SET );
	if ( fread( &ioh, 1, sizeof(IMAGE_OPTIONAL_HEADER32), pExe ) != sizeof(IMAGE_OPTIONAL_HEADER32) )
	{
		fclose( pExe );
		return NO_READ_EXE_DATA;
	}

	Entry = (LPVOID)(ioh.ImageBase + ioh.AddressOfEntryPoint);
	
	//sprintf( buff, "magic: %X\nlfanew: %X\nimg_base: %X\naoep: %X\nmagic2: %X", idh.e_magic, idh.e_lfanew, ioh.ImageBase, ioh.AddressOfEntryPoint, ioh.Magic );
	//MessageBox( NULL, buff, "Error", MB_OK );

	fclose( pExe );

	// find the exe's working directory
	strcpy_s(buff, exe);

	int i=(int)strlen(buff);
	while ( buff[i] != '\\' && buff[i] != '/' && i > 0 )
		i--;
	buff[i] = 0;

	//GetStartupInfo( &StartInfo );
	memset( &StartInfo, 0, sizeof(STARTUPINFO) );
	StartInfo.cb = sizeof(STARTUPINFO);

	// launch the exe
	if ( !CreateProcess( exe, NULL, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, buff, &StartInfo, &ProcInfo ) )
		return NO_RUN_EXE;

	*pid = ProcInfo.dwProcessId;

	int dllNameLen = (int)strlen(dll)+1;
	int funcNameLen = (int)strlen(func)+1;
	const int LoadAsmSize = 60;
	SIZE_T allocSize = dllNameLen + funcNameLen + dataLen + LoadAsmSize;

	// allocate some space in the exe for our memory
	DWORD ProcMem = 0;
	
	ProcMem = (DWORD)VirtualAllocEx( ProcInfo.hProcess, NULL, allocSize, MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE );
	if ( !ProcMem )
	{
		ProcMem = 0x00700000;
		if ( !VirtualProtectEx( ProcInfo.hProcess, (LPVOID)ProcMem, allocSize, PAGE_EXECUTE_READWRITE, (PDWORD)&Num ) )
		{
			TerminateProcess( ProcInfo.hProcess, 0 );
			return NO_ALLOC_MEM;
		}
	}

	char *toWrite = new char[allocSize];
	if ( !toWrite )
	{
		TerminateProcess( ProcInfo.hProcess, 0 );
		return NO_ALLOC_MEM;
	}

	// change protection to allow us to read/write the entry point (note: the old protection is not restored (so that we can change this space again later...)
	if ( !VirtualProtectEx( ProcInfo.hProcess, Entry, 8, PAGE_EXECUTE_READWRITE, (PDWORD)&Num ) )
	{
		TerminateProcess( ProcInfo.hProcess, 0 );
		return NO_VPROTECT;
	}
	
	// read the old code at the entry point
	if ( !ReadProcessMemory( ProcInfo.hProcess, Entry, buff, 8, &Num ) || Num != 8 )
	{
		TerminateProcess( ProcInfo.hProcess, 0 );
		return NO_READ;
	}

	// note if you change this size you must rewrite the LoadAsm to copy back the original code properly
	unsigned char EntryAsm[] = {
		0xE9, 0,0,0,0,			// jmp (offset)
		0x90,0x90,0x90,			// nop (for 4 byte alignment)
	};

	*((DWORD*)&EntryAsm[1]) = ProcMem - ((DWORD)Entry + 5);

	// write the new code at the entry point
	if ( !WriteProcessMemory( ProcInfo.hProcess, Entry, EntryAsm, 8, &Num ) || Num != 8 )
	{
		TerminateProcess( ProcInfo.hProcess, 0 );
		return NO_WRITE;
	}

	// this asm section does everything
	unsigned char LoadAsm[LoadAsmSize] = {
		// restore the original entry point bytes
		0xB8, 0,0,0,0,			// mov     eax, (number)
		0xC7, 0x00, 0,0,0,0,	// mov     dword ptr [eax], (num)
		0xC7, 0x40, 4, 0,0,0,0, // mov     dword ptr [eax+4], (num)

		// LoadLibrary( name )
		0x68, 0,0,0,0,			// push (num)
		0xE8, 0,0,0,0,			// call (offset)

		// GetProcAddress( lib, name )
		0x68, 0,0,0,0,			// push (num)
		0x50,					// push eax
		0xE8, 0,0,0,0,			// call (offset)

		// name( data, dataLen )
		0x68, 0,0,0,0,			// push (num)
		0x68, 0,0,0,0,			// push (num)
		0xFF, 0xD0,				// call eax

		// go back to the original entry point
		0xE9, 0,0,0,0,			// jmp  (offset)
		
		0x90, 0x90, 0x90, 0x90,	// nop (padding)
	};

	*((DWORD*)(LoadAsm+ 1)) = (DWORD)Entry; // data dest
	*((DWORD*)(LoadAsm+ 7)) = *((DWORD*)&buff[0]); // 1st data 
	*((DWORD*)(LoadAsm+14)) = *((DWORD*)&buff[4]); // 2nd data

	HMODULE hKernel = LoadLibrary( "Kernel32" );

	*((DWORD*)(LoadAsm+19)) = (ProcMem + LoadAsmSize); // begining of dll name
	*((DWORD*)(LoadAsm+24)) = ((DWORD)GetProcAddress( hKernel, "LoadLibraryA" )) - (ProcMem + 28); // offset to LoadLibraryA
	
	*((DWORD*)(LoadAsm+29)) = (ProcMem + LoadAsmSize + dllNameLen); // begining of function name
	*((DWORD*)(LoadAsm+35)) = ((DWORD)GetProcAddress( hKernel, "GetProcAddress" )) - (ProcMem + 39); // offset to GetProcAddress

	FreeLibrary( hKernel );

	*((DWORD*)(LoadAsm+40)) = dataLen; // user data Length
	*((DWORD*)(LoadAsm+45)) = ProcMem + LoadAsmSize + dllNameLen + funcNameLen; // begining of user data
	*((DWORD*)(LoadAsm+52)) = (DWORD)Entry - (ProcMem + 56); // entry points

	memcpy( toWrite, LoadAsm, LoadAsmSize );
	memcpy( &toWrite[LoadAsmSize], dll, dllNameLen );
	memcpy( &toWrite[LoadAsmSize+dllNameLen], func, funcNameLen );

	if ( dataLen > 0 )
		memcpy( &toWrite[LoadAsmSize+dllNameLen+funcNameLen], dllData, dataLen );

	if ( !WriteProcessMemory( ProcInfo.hProcess, (void*)ProcMem, toWrite, allocSize, &Num ) || Num != allocSize )
	{
		TerminateProcess( ProcInfo.hProcess, 0 );
		return NO_WRITE;
	}

	delete[] toWrite;

	*pid = ProcInfo.dwProcessId;

	ResumeThread( ProcInfo.hThread );

	CloseHandle( ProcInfo.hProcess );
	CloseHandle( ProcInfo.hThread );

	return SUCCESS;
}


================================================
FILE: Loader/Loader.def
================================================
LIBRARY	Loader

EXPORTS
	Load


================================================
FILE: Loader/Loader.h
================================================
// The following ifdef block is the standard way of creating macros which make exporting 
// from a DLL simpler. All files within this DLL are compiled with the LOADER_EXPORTS
// symbol defined on the command line. this symbol should not be defined on any project
// that uses this DLL. This way any other project whose source files include this file see 
// LOADER_API functions as being imported from a DLL, whereas this DLL sees symbols
// defined with this macro as being exported.
#ifdef LOADER_EXPORTS
#define LOADER_API __declspec(dllexport)
#else
#define LOADER_API __declspec(dllimport)
#endif

// This class is exported from the Loader.dll
class LOADER_API CLoader {
public:
	CLoader(void);
	// TODO: add your methods here.
};

extern LOADER_API int nLoader;

LOADER_API int fnLoader(void);


================================================
FILE: Loader/Loader.vcxproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup Label="ProjectConfigurations">
    <ProjectConfiguration Include="Debug|Win32">
      <Configuration>Debug</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|Win32">
      <Configuration>Release</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
  </ItemGroup>
  <PropertyGroup Label="Globals">
    <ProjectGuid>{F308E8D5-2B4F-40AD-9BF7-9A8F5DDA420D}</ProjectGuid>
    <RootNamespace>Loader</RootNamespace>
    <Keyword>Win32Proj</Keyword>
    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
    <ConfigurationType>DynamicLibrary</ConfigurationType>
    <CharacterSet>MultiByte</CharacterSet>
    <PlatformToolset>v142</PlatformToolset>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
    <ConfigurationType>DynamicLibrary</ConfigurationType>
    <CharacterSet>MultiByte</CharacterSet>
    <PlatformToolset>v143</PlatformToolset>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
  <ImportGroup Label="ExtensionSettings">
  </ImportGroup>
  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
    <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />
  </ImportGroup>
  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
    <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />
  </ImportGroup>
  <PropertyGroup Label="UserMacros" />
  <PropertyGroup>
    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <OutDir>$(SolutionDir)bin\$(Platform)\$(Configuration)\</OutDir>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <OutDir>$(SolutionDir)bin\$(Platform)\$(Configuration)\</OutDir>
  </PropertyGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <ClCompile>
      <Optimization>Disabled</Optimization>
      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;LOADER_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <MinimalRebuild>
      </MinimalRebuild>
      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
      <PrecompiledHeader>Use</PrecompiledHeader>
      <WarningLevel>Level3</WarningLevel>
      <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
    </ClCompile>
    <Link>
      <GenerateDebugInformation>true</GenerateDebugInformation>
      <SubSystem>Windows</SubSystem>
      <TargetMachine>MachineX86</TargetMachine>
      <ModuleDefinitionFile>Loader.def</ModuleDefinitionFile>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <ClCompile>
      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
      <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;WIN32;NDEBUG;_WINDOWS;_USRDLL;LOADER_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
      <BufferSecurityCheck>false</BufferSecurityCheck>
      <PrecompiledHeader>Use</PrecompiledHeader>
      <WarningLevel>Level3</WarningLevel>
      <DebugInformationFormat>
      </DebugInformationFormat>
    </ClCompile>
    <Link>
      <ModuleDefinitionFile>Loader.def</ModuleDefinitionFile>
      <GenerateDebugInformation>true</GenerateDebugInformation>
      <SubSystem>Windows</SubSystem>
      <OptimizeReferences>true</OptimizeReferences>
      <TargetMachine>MachineX86</TargetMachine>
    </Link>
    <PreBuildEvent>
      <Command>
      </Command>
    </PreBuildEvent>
    <PostBuildEvent />
  </ItemDefinitionGroup>
  <ItemGroup>
    <ClCompile Include="Loader.cpp" />
    <ClCompile Include="stdafx.cpp">
      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
    </ClCompile>
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="resource.h" />
    <ClInclude Include="stdafx.h" />
  </ItemGroup>
  <ItemGroup>
    <ResourceCompile Include="Loader.rc" />
  </ItemGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
  <ImportGroup Label="ExtensionTargets">
  </ImportGroup>
</Project>

================================================
FILE: Loader/Loader.vcxproj.filters
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup>
    <Filter Include="Source Files">
      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
      <Extensions>cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
    </Filter>
    <Filter Include="Header Files">
      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
    </Filter>
    <Filter Include="Resource Files">
      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx</Extensions>
    </Filter>
  </ItemGroup>
  <ItemGroup>
    <ClCompile Include="Loader.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
    <ClCompile Include="stdafx.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="stdafx.h">
      <Filter>Header Files</Filter>
    </ClInclude>
    <ClInclude Include="resource.h">
      <Filter>Header Files</Filter>
    </ClInclude>
  </ItemGroup>
  <ItemGroup>
    <ResourceCompile Include="Loader.rc">
      <Filter>Resource Files</Filter>
    </ResourceCompile>
  </ItemGroup>
</Project>

================================================
FILE: Loader/stdafx.cpp
================================================
// stdafx.cpp : source file that includes just the standard includes
// Loader.pch will be the pre-compiled header
// stdafx.obj will contain the pre-compiled type information

#include "stdafx.h"

// TODO: reference any additional headers you need in STDAFX.H
// and not in this file


================================================
FILE: Loader/stdafx.h
================================================
// stdafx.h : include file for standard system include files,
// or project specific include files that are used frequently, but
// are changed infrequently
//

#pragma once
#pragma warning(disable: 4309)
#pragma warning(disable: 4311)
#pragma warning(disable: 4312)
#pragma warning(disable: 4800)
#pragma warning(disable: 4530)

#define WIN32_LEAN_AND_MEAN		// Exclude rarely-used stuff from Windows headers
// Windows Header Files:
#include <windows.h>

#pragma pack(1)

#include <stdio.h>


================================================
FILE: Notepad++UDL.xml
================================================
<NotepadPlus>
    <UserLang name="Razor" ext="" udlVersion="2.1">
        <Settings>
            <Global caseIgnored="no" allowFoldOfComments="no" foldCompact="no" forcePureLC="0" decimalSeparator="0" />
            <Prefix Keywords1="no" Keywords2="no" Keywords3="no" Keywords4="no" Keywords5="no" Keywords6="no" Keywords7="no" Keywords8="no" />
        </Settings>
        <KeywordLists>
            <Keywords name="Comments">00// 00# 01 02 03/* 04*/</Keywords>
            <Keywords name="Numbers, prefix1">0x</Keywords>
            <Keywords name="Numbers, prefix2"></Keywords>
            <Keywords name="Numbers, extras1"></Keywords>
            <Keywords name="Numbers, extras2"></Keywords>
            <Keywords name="Numbers, suffix1"></Keywords>
            <Keywords name="Numbers, suffix2"></Keywords>
            <Keywords name="Numbers, range"></Keywords>
            <Keywords name="Operators1">= == != &lt; &lt;= &gt; &gt;= + - / * ( ) @ , !</Keywords>
            <Keywords name="Operators2"></Keywords>
            <Keywords name="Folders in code1, open"></Keywords>
            <Keywords name="Folders in code1, middle"></Keywords>
            <Keywords name="Folders in code1, close"></Keywords>
            <Keywords name="Folders in code2, open"></Keywords>
            <Keywords name="Folders in code2, middle"></Keywords>
            <Keywords name="Folders in code2, close"></Keywords>
            <Keywords name="Folders in comment, open"></Keywords>
            <Keywords name="Folders in comment, middle"></Keywords>
            <Keywords name="Folders in comment, close"></Keywords>
            <Keywords name="Keywords1">if else elseif endif for endfor while endwhile and break continue loop replay not or stop</Keywords>
            <Keywords name="Keywords2">alliance attack cast clearall clearhands clearsysmsg dclick dclicktype dress drop droprelloc emote guild gumpresponse gumpclose hotkey lasttarget lift lifttype menu menuresponse organizer overhead potion promptresponse random restock say script scavenger sell setability setlasttarget setvar skill sysmsg target targetrelloc targetloc targettype undress useonce virtue walk wait &amp; pause waitforgump waitformenu waitforprompt waitforsysmsg waitfortarget whisper yell</Keywords>
            <Keywords name="Keywords3">count counter findbuff findtype hidden hp maxhp hits maxhits insysmsg insysmessage lhandempty&#x000D;&#x000A;mana maxmana mounted poisoned position&#x000D;&#x000A;queued rhandempty skill stam maxstam str dex int weight</Keywords>
            <Keywords name="Keywords4">true false</Keywords>
            <Keywords name="Keywords5">backpack self anatomy animallore itemidentification itemid armslore begging peacemaking peace cartography detectinghidden discord discordance evaluatingintelligence evalint forensicevaluation forensiceval hiding provocation provo inscription poisoning spiritspeak stealing taming tasteidentification tasteid tracking meditation stealth removetrap imbuing nonfriendly friendly enemy red murderer gray grey criminal blue innocent friend RightHand LeftHand Shoes Pants Shirt Head Gloves Ring Talisman Neck Hair Waist InnerTorso Face Bracelet FacialHair MiddleTorso Earrings Arms Cloak Backpack OuterTorso OuterLegs InnerLegs</Keywords>
            <Keywords name="Keywords6"></Keywords>
            <Keywords name="Keywords7"></Keywords>
            <Keywords name="Keywords8"></Keywords>
            <Keywords name="Delimiters">00&apos; 01\ 02&apos; 03 04 05 06&quot; 07\ 08&quot; 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23</Keywords>
        </KeywordLists>
        <Styles>
            <WordsStyle name="DEFAULT" fgColor="000000" bgColor="FFFFFF" fontName="" fontStyle="0" nesting="0" />
            <WordsStyle name="COMMENTS" fgColor="808080" bgColor="FFFFFF" fontName="" fontStyle="0" nesting="0" />
            <WordsStyle name="LINE COMMENTS" fgColor="808080" bgColor="FFFFFF" fontName="" fontStyle="0" nesting="0" />
            <WordsStyle name="NUMBERS" fgColor="0080C0" bgColor="FFFFFF" fontName="" fontStyle="0" nesting="0" />
            <WordsStyle name="KEYWORDS1" fgColor="DD4800" bgColor="FFFFFF" fontName="" fontStyle="0" nesting="0" />
            <WordsStyle name="KEYWORDS2" fgColor="000080" bgColor="FFFFFF" fontName="" fontStyle="0" nesting="0" />
            <WordsStyle name="KEYWORDS3" fgColor="830E11" bgColor="FFFFFF" fontName="" fontStyle="0" nesting="0" />
            <WordsStyle name="KEYWORDS4" fgColor="0080C0" bgColor="FFFFFF" fontName="" fontStyle="0" nesting="0" />
            <WordsStyle name="KEYWORDS5" fgColor="AE00AE" bgColor="FFFFFF" fontName="" fontStyle="0" nesting="0" />
            <WordsStyle name="KEYWORDS6" fgColor="000000" bgColor="FFFFFF" fontName="" fontStyle="0" nesting="0" />
            <WordsStyle name="KEYWORDS7" fgColor="000000" bgColor="FFFFFF" fontName="" fontStyle="0" nesting="0" />
            <WordsStyle name="KEYWORDS8" fgColor="000000" bgColor="FFFFFF" fontName="" fontStyle="0" nesting="0" />
            <WordsStyle name="OPERATORS" fgColor="FF0000" bgColor="FFFFFF" fontName="" fontStyle="0" nesting="0" />
            <WordsStyle name="FOLDER IN CODE1" fgColor="000000" bgColor="FFFFFF" fontName="" fontStyle="0" nesting="0" />
            <WordsStyle name="FOLDER IN CODE2" fgColor="000000" bgColor="FFFFFF" fontName="" fontStyle="0" nesting="0" />
            <WordsStyle name="FOLDER IN COMMENT" fgColor="8080FF" bgColor="FFFFFF" fontName="" fontStyle="0" nesting="0" />
            <WordsStyle name="DELIMITERS1" fgColor="008000" bgColor="FFFFFF" fontName="" fontStyle="0" nesting="0" />
            <WordsStyle name="DELIMITERS2" fgColor="000000" bgColor="FFFFFF" fontName="" fontStyle="0" nesting="0" />
            <WordsStyle name="DELIMITERS3" fgColor="008000" bgColor="FFFFFF" fontName="" fontStyle="0" nesting="0" />
            <WordsStyle name="DELIMITERS4" fgColor="000000" bgColor="FFFFFF" fontName="" fontStyle="0" nesting="0" />
            <WordsStyle name="DELIMITERS5" fgColor="000000" bgColor="FFFFFF" fontName="" fontStyle="0" nesting="0" />
            <WordsStyle name="DELIMITERS6" fgColor="000000" bgColor="FFFFFF" fontName="" fontStyle="0" nesting="0" />
            <WordsStyle name="DELIMITERS7" fgColor="000000" bgColor="FFFFFF" fontName="" fontStyle="0" nesting="0" />
            <WordsStyle name="DELIMITERS8" fgColor="000000" bgColor="FFFFFF" fontName="" fontStyle="0" nesting="0" />
        </Styles>
    </UserLang>
</NotepadPlus>


================================================
FILE: Platform/Platform.cpp
================================================
#include "Platform.h"

HINSTANCE hInstance = NULL;
HICON hRazorIcon = NULL;
HFONT hRazorFont = NULL;

BOOL APIENTRY DllMain(HANDLE hModule, DWORD dwReason, LPVOID)
{
	hInstance = (HMODULE)hModule;

	switch (dwReason) {
	case DLL_PROCESS_ATTACH:
		DisableThreadLibraryCalls(hInstance);
		break;

	case DLL_PROCESS_DETACH:
		break;

	case DLL_THREAD_ATTACH:
	case DLL_THREAD_DETACH:
		break;
	}

	return TRUE;
}

DLLFUNCTION HBITMAP CaptureScreen(HWND hUOWindow, BOOL full, const char *msg)
{
	HDC hScreen = NULL;
	int destWidth, destHeight;
	RECT rect;

	if (!hRazorFont)
		hRazorFont = CreateFont(-10, 0, 0, 0, FW_SEMIBOLD, FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DRAFT_QUALITY, FIXED_PITCH, "Comic Sans MS");

	UpdateWindow(hUOWindow);

	if (full)
	{
		hScreen = GetDC(NULL);
		rect.left = 0;
		rect.top = 0;
		destWidth = GetDeviceCaps(hScreen, HORZRES);
		destHeight = GetDeviceCaps(hScreen, VERTRES);
	}
	else
	{
		hScreen = GetWindowDC(hUOWindow);
		GetWindowRect(hUOWindow, &rect);
		destWidth = rect.right - rect.left;
		destHeight = rect.bottom - rect.top;
	}

	HDC hCap = CreateCompatibleDC(hScreen);
	HBITMAP hBMP = CreateCompatibleBitmap(hScreen, destWidth, destHeight);
	SelectObject(hCap, hBMP);

	BitBlt(hCap, 0, 0, destWidth, destHeight, hScreen, 0, 0, SRCCOPY);

	if (msg != NULL && msg[0] != 0)
	{
		SIZE text;
		int len = (int)strlen(msg);
		SelectObject(hCap, hRazorFont);
		SetTextColor(hCap, RGB(255, 255, 255));
		SetBkMode(hCap, TRANSPARENT);

		GetTextExtentPoint32(hCap, msg, len, &text);

		rect.top = 0;
		rect.bottom = text.cy + 4;
		rect.right = destWidth - 32;
		rect.left = destWidth - 32 - text.cx - 4;
		FillRect(hCap, &rect, (HBRUSH)GetStockObject(BLACK_BRUSH));

		TextOut(hCap, rect.left + 2, 2, msg, len);
	}

	ReleaseDC(full ? NULL : hUOWindow, hScreen);
	DeleteDC(hCap);

	return hBMP;
}

DLLFUNCTION void BringToFront(HWND hWnd)
{
	SetWindowPos(hWnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
	ShowWindow(hWnd, SW_SHOW);
	SetForegroundWindow(hWnd);
	SetFocus(hWnd);
}

================================================
FILE: Platform/Platform.def
================================================
LIBRARY	Platform

EXPORTS
	CaptureScreen
	BringToFront

================================================
FILE: Platform/Platform.h
================================================
#pragma once

#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <winsock2.h>
#include <time.h>
#include <zmouse.h>

#define DLLFUNCTION __declspec(dllexport)

DLLFUNCTION HBITMAP CaptureScreen(HWND hUOWindow, BOOL full, const char *msg);
DLLFUNCTION void BringToFront(HWND hWnd);

================================================
FILE: Platform/Platform.vcxproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup Label="ProjectConfigurations">
    <ProjectConfiguration Include="Debug|Win32">
      <Configuration>Debug</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Debug|x64">
      <Configuration>Debug</Configuration>
      <Platform>x64</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|Win32">
      <Configuration>Release</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|x64">
      <Configuration>Release</Configuration>
      <Platform>x64</Platform>
    </ProjectConfiguration>
  </ItemGroup>
  <PropertyGroup Label="Globals">
    <VCProjectVersion>15.0</VCProjectVersion>
    <ProjectGuid>{DB18390C-8AD4-4E69-8A5A-171260F7D74A}</ProjectGuid>
    <RootNamespace>Platform</RootNamespace>
    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
    <ProjectName>Platform</ProjectName>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
    <ConfigurationType>DynamicLibrary</ConfigurationType>
    <UseDebugLibraries>true</UseDebugLibraries>
    <PlatformToolset>v142</PlatformToolset>
    <CharacterSet>MultiByte</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
    <ConfigurationType>DynamicLibrary</ConfigurationType>
    <UseDebugLibraries>true</UseDebugLibraries>
    <PlatformToolset>v143</PlatformToolset>
    <CharacterSet>MultiByte</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
    <ConfigurationType>DynamicLibrary</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <PlatformToolset>v142</PlatformToolset>
    <CharacterSet>MultiByte</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
    <ConfigurationType>DynamicLibrary</ConfigurationType>
    <UseDebugLibraries>false</UseDebugLibraries>
    <PlatformToolset>v142</PlatformToolset>
    <CharacterSet>MultiByte</CharacterSet>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
  <ImportGroup Label="ExtensionSettings">
  </ImportGroup>
  <ImportGroup Label="Shared">
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <PropertyGroup Label="UserMacros" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <OutDir>$(SolutionDir)bin\$(Platform)\$(Configuration)\</OutDir>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <OutDir>$(SolutionDir)bin\Win32\$(Configuration)\</OutDir>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <OutDir>$(SolutionDir)bin\$(Platform)\$(Configuration)\</OutDir>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <OutDir>$(SolutionDir)bin\Win32\$(Configuration)\</OutDir>
  </PropertyGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <CallingConvention>StdCall</CallingConvention>
      <BasicRuntimeChecks>Default</BasicRuntimeChecks>
      <ExceptionHandling>Async</ExceptionHandling>
      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
      <BufferSecurityCheck>false</BufferSecurityCheck>
    </ClCompile>
    <Link>
      <ModuleDefinitionFile>Platform.def</ModuleDefinitionFile>
      <SubSystem>Windows</SubSystem>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <CallingConvention>StdCall</CallingConvention>
      <BasicRuntimeChecks>Default</BasicRuntimeChecks>
      <ExceptionHandling>Async</ExceptionHandling>
      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
      <BufferSecurityCheck>false</BufferSecurityCheck>
    </ClCompile>
    <Link>
      <ModuleDefinitionFile>Platform.def</ModuleDefinitionFile>
      <SubSystem>Windows</SubSystem>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <CallingConvention>StdCall</CallingConvention>
      <ExceptionHandling>Async</ExceptionHandling>
      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
      <BufferSecurityCheck>false</BufferSecurityCheck>
    </ClCompile>
    <Link>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <ModuleDefinitionFile>Platform.def</ModuleDefinitionFile>
      <SubSystem>Windows</SubSystem>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <ClCompile>
      <WarningLevel>Level3</WarningLevel>
      <CallingConvention>StdCall</CallingConvention>
      <ExceptionHandling>Async</ExceptionHandling>
      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
      <BufferSecurityCheck>false</BufferSecurityCheck>
    </ClCompile>
    <Link>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <OptimizeReferences>true</OptimizeReferences>
      <ModuleDefinitionFile>Platform.def</ModuleDefinitionFile>
      <SubSystem>Windows</SubSystem>
    </Link>
  </ItemDefinitionGroup>
  <ItemGroup>
    <ClCompile Include="Platform.cpp" />
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="Platform.h" />
  </ItemGroup>
  <ItemGroup>
    <None Include="Platform.def" />
  </ItemGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
  <ImportGroup Label="ExtensionTargets">
  </ImportGroup>
</Project>

================================================
FILE: Platform/Platform.vcxproj.filters
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup>
    <Filter Include="Source Files">
      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
    </Filter>
    <Filter Include="Header Files">
      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
      <Extensions>h;hh;hpp;hxx;hm;inl;inc;ipp;xsd</Extensions>
    </Filter>
    <Filter Include="Resource Files">
      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
    </Filter>
  </ItemGroup>
  <ItemGroup>
    <ClCompile Include="Platform.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
  </ItemGroup>
  <ItemGroup>
    <None Include="Platform.def">
      <Filter>Source Files</Filter>
    </None>
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="Platform.h">
      <Filter>Header Files</Filter>
    </ClInclude>
  </ItemGroup>
</Project>

================================================
FILE: README.md
================================================
# Razor: An Ultima Online Assistant

![Razor Logo](https://imgur.com/jTtHLVF.png)

Razor is a free tool designed to help with simple tasks while playing Ultima Online.

[![Build](https://github.com/markdwags/Razor/actions/workflows/build.yml/badge.svg)](https://github.com/markdwags/Razor/actions/workflows/build.yml) [![Chat on Discord status](https://img.shields.io/discord/458277173208547350.svg?logo=discord)](https://discord.gg/VdyCpjQ)

## Community Edition (CE)

The goal of this project is to revive and continue development and maintenance of the abandoned Razor project, focusing on "quality of life" improvements while attempting to keep the spirit and vision the original developers had for Razor and not driving down the path of advanced automation and scripting that's found in other UO assistants.

It's recommended that you use the [ClassicUO](https://github.com/ClassicUO/ClassicUO) client with this version of Razor, however it should will work with the original 5.x and 7.x clients though support for any bugs may be limited.

Learn more about this version of Razor by exploring the links below.

- [Home](https://www.razorce.com)
- [Download](https://www.razorce.com/download/)
- [Release Notes](https://www.razorce.com/releasenotes/)
- [Project History](https://www.razorce.com/history/)
- [Help Overview](https://www.razorce.com/help/)
- [Scripting Guide](https://www.razorce.com/guide/)

## Installation & Help

- [Installing Razor on Windows](https://www.razorce.com/install/windows/)
- [Installing Razor on Linux](https://www.razorce.com/install/linux/)

If you need more help, [please go here](https://www.razorce.com/help) and review the documentation and/or join Discord and ask there.

[![Chat on Discord status](https://img.shields.io/discord/458277173208547350.svg?logo=discord)](https://discord.gg/VdyCpjQ)

## Razor Scripting Engine

Introduced in 1.6.4.2, Razor supports a command-based script language. For a comprehensive guide on the language and syntax, visit the [Razor Scripting Guide](https://www.razorce.com/guide/).

## Contributing & Code of Conduct

Please read [CONTRIBUTING](CONTRIBUTING.md) for more information on how to contribute to this project.

Please note we have a [Code of Conduct](CODE_OF_CONDUCT.md), please follow it in all your interactions with this project.

## License

This work is released under the GPLv3 license. This project does not distribute any copyrighted game assets. In order to run this application you'll need to legally obtain a copy of the Ultima Online Classic Client.

See the [LICENSE](LICENSE.md) file for details.


================================================
FILE: Razor/Agents/Agents.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System.Collections.Generic;
using System.Windows.Forms;
using System.Xml;
using Assistant.UI;

namespace Assistant.Agents
{
    public abstract class Agent
    {
        public static List<Agent> List { get; } = new List<Agent>();

        public delegate void ItemCreatedEventHandler(Item item);

        public delegate void MobileCreatedEventHandler(Mobile m);

        public static event ItemCreatedEventHandler OnItemCreated;
        public static event MobileCreatedEventHandler OnMobileCreated;

        public static void InvokeMobileCreated(Mobile m)
        {
            if (OnMobileCreated != null)
            {
                OnMobileCreated(m);
            }
        }

        public static void InvokeItemCreated(Item i)
        {
            if (OnItemCreated != null)
            {
                OnItemCreated(i);
            }
        }

        public static void Add(Agent a)
        {
            List.Add(a);
        }

        public static void ClearAll()
        {
            for (int i = 0; i < List.Count; i++)
            {
                ((Agent) List[i]).Clear();
            }
        }

        public static void SaveProfile(XmlTextWriter xml)
        {
            foreach (Agent a in List)
            {
                xml.WriteStartElement(a.Name);
                a.Save(xml);
                xml.WriteEndElement();
            }
        }

        public static void LoadProfile(XmlElement xml)
        {
            ClearAll();

            if (xml == null)
            {
                return;
            }

            for (int i = 0; i < List.Count; i++)
            {
                try
                {
                    Agent a = (Agent) List[i];
                    XmlElement el = xml[a.Name];
                    if (el != null)
                    {
                        a.Load(el);
                    }
                }
                catch
                {
                }
            }
        }

        public static void Redraw(ComboBox list, GroupBox gb, params Button[] buttons)
        {
            list.Visible = true;
            list.BeginUpdate();
            list.Items.Clear();
            list.SelectedIndex = -1;

            for (int i = 0; i < buttons.Length; i++)
            {
                buttons[i].Visible = false;
            }

            for (int i = 0; i < List.Count; i++)
            {
                list.Items.Add(List[i]);
            }

            list.EndUpdate();

            gb.Visible = false;
        }

        public static void Select(int idx, ComboBox agents, ListBox subList, GroupBox grp, params Button[] buttons)
        {
            for (int i = 0; i < buttons.Length; i++)
            {
                buttons[i].Visible = false;
                buttons[i].Text = "";
                Engine.MainWindow.SafeAction(s => s.UnlockControl(buttons[i]));
            }

            grp.Visible = false;
            subList.Visible = false;
            Engine.MainWindow.SafeAction(s => s.UnlockControl(subList));

            Agent a = null;
            if (idx >= 0 && idx < List.Count)
            {
                a = List[idx] as Agent;
            }

            if (a != null)
            {
                grp.Visible = true;
                subList.Visible = true;
                grp.Text = a.ToString();
                a.OnSelected(subList, buttons);
            }
        }

        public override string ToString()
        {
            return !string.IsNullOrEmpty(Alias) ? $"{Name} ({Alias})" : Name;
        }

        public abstract string Name { get; }
        public abstract string Alias { get; set; }
        public abstract int Number { get; }
        public abstract void Save(XmlTextWriter xml);
        public abstract void Load(XmlElement node);
        public abstract void Clear();
        public abstract void OnSelected(ListBox subList, params Button[] buttons);
        public abstract void OnButtonPress(int num);
    }
}

================================================
FILE: Razor/Agents/BuyAgent.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
using System.Xml;
using Assistant.Gumps.Internal;
using Assistant.UI;

namespace Assistant.Agents
{
    public class BuyAgent : Agent
    {
        public class BuyEntry
        {
            public BuyEntry(ItemID id, ushort amount)
            {
                Id = id;
                Amount = amount;
            }

            public readonly ItemID Id;
            public ushort Amount;

            public override string ToString()
            {
                return $"{Id}\t{Amount}";
            }
        }

        private class ItemXYComparer : IComparer<Item>
        {
            public static readonly ItemXYComparer Instance = new ItemXYComparer();

            private ItemXYComparer()
            {
            }

            public int Compare(Item x, Item y)
            {
                if (!(x is Item))
                {
                    return 1;
                }
                else if (!(y is Item))
                {
                    return -1;
                }

                int xsum = x.Position.X + x.Position.Y * 200;
                int ysum = y.Position.X + y.Position.Y * 200;

                return xsum.CompareTo(ysum);
            }
        }

        private static readonly ArrayList m_Instances = new ArrayList();

        public static List<BuyAgent> Agents { get; set; }

        public static void Initialize()
        {
            PacketHandler.RegisterServerToClientViewer(0x74, new PacketViewerCallback(ExtBuyInfo));
            PacketHandler.RegisterServerToClientViewer(0x24, new PacketViewerCallback(DisplayBuy));
            PacketHandler.RegisterServerToClientViewer(0x3B, new PacketViewerCallback(EndVendorBuy));

            int maxAgents = Config.GetAppSetting<int>("MaxBuyAgents") == 0
                ? 20
                : Config.GetAppSetting<int>("MaxBuyAgents");

            Agents = new List<BuyAgent>();

            for (int i = 1; i <= maxAgents; i++)
            {
                BuyAgent b = new BuyAgent(i);
                m_Instances.Add(b);
                Agent.Add(b);

                Agents.Add(b);
            }
        }

        private ListBox m_SubList;
        private Button m_EnableBTN;
        public readonly List<BuyEntry> Items;
        private bool m_Enabled;
        private bool _fromGump;

        public BuyAgent(int num)
        {
            Number = num;
            Items = new List<BuyEntry>();
        }

        private static void DisplayBuy(PacketReader p, PacketHandlerEventArgs args)
        {
            Serial serial = p.ReadUInt32();
            ushort gump = p.ReadUInt16();

            if (gump != 0x30 || !serial.IsMobile || !Client.Instance.AllowBit(FeatureBit.BuyAgent) ||
                World.Player == null)
            {
                return;
            }

            Mobile vendor = World.FindMobile(serial);
            if (vendor == null)
            {
                return;
            }

            Item pack = vendor.GetItemOnLayer(Layer.ShopBuy);
            if (pack == null || pack.Contains == null || pack.Contains.Count <= 0)
            {
                return;
            }

            pack.Contains.Sort(ItemXYComparer.Instance);

            int total = 0;
            int cost = 0;
            List<VendorBuyItem> buyList = new List<VendorBuyItem>();
            Dictionary<ushort, int> found = new Dictionary<ushort, int>();
            bool lowGoldWarn = false;
            for (int i = 0; i < pack.Contains.Count; i++)
            {
                Item item = (Item) pack.Contains[i];
                if (item == null)
                {
                    continue;
                }

                foreach (BuyAgent ba in m_Instances)
                {
                    if (ba == null || ba.Items == null || !ba.m_Enabled)
                    {
                        continue;
                    }

                    for (int a = 0; a < ba.Items.Count; a++)
                    {
                        BuyEntry b = (BuyEntry) ba.Items[a];
                        if (b == null)
                        {
                            continue;
                        }

                        bool dupe = false;
                        foreach (VendorBuyItem vbi in buyList)
                        {
                            if (vbi.Serial == item.Serial)
                            {
                                dupe = true;
                            }
                        }

                        if (dupe)
                        {
                            continue;
                        }

                        // fucking osi and their blank scrolls
                        if (b.Id == item.ItemID.Value || (b.Id == 0x0E34 && item.ItemID.Value == 0x0EF3) ||
                            (b.Id == 0x0EF3 && item.ItemID.Value == 0x0E34))
                        {
                            int count = World.Player.Backpack.GetCount(b.Id);
                            if (found.ContainsKey(b.Id))
                            {
                                count += (int) found[b.Id];
                            }

                            if (count < b.Amount && b.Amount > 0)
                            {
                                count = b.Amount - count;
                                if (count >= item.Amount)
                                {
                                    count = item.Amount;
                                }
                                else if (count <= 0)
                                {
                                    continue;
                                }

                                if (!found.ContainsKey(b.Id))
                                {
                                    found.Add(b.Id, (int) count);
                                }
                                else
                                {
                                    found[b.Id] = (int) found[b.Id] + (int) count;
                                }

                                buyList.Add(new VendorBuyItem(item.Serial, count, item.Price));
                                total += count;
                                cost += item.Price * count;
                            }
                        }
                    }
                }
            }

            if (!Config.GetBool("BuyAgentsIgnoreGold"))
            {
                if (cost > World.Player.Gold && cost < 2000 && buyList.Count > 0)
                {
                    lowGoldWarn = true;
                    do
                    {
                        VendorBuyItem vbi = (VendorBuyItem)buyList[0];
                        if (cost - vbi.TotalCost <= World.Player.Gold)
                        {
                            while (cost > World.Player.Gold && vbi.Amount > 0)
                            {
                                cost -= vbi.Price;
                                --vbi.Amount;
                                --total;
                            }

                            if (vbi.Amount <= 0)
                            {
                                buyList.RemoveAt(0);
                            }
                        }
                        else
                        {
                            cost -= vbi.TotalCost;
                            total -= vbi.Amount;
                            buyList.RemoveAt(0);
                        }
                    } while (cost > World.Player.Gold && buyList.Count > 0);
                }
            }            

            if (buyList.Count > 0)
            {
                args.Block = true;
                BuyLists[serial] = buyList;
                Client.Instance.SendToServer(new VendorBuyResponse(serial, buyList));

                if (Config.GetBool("BuyAgentsIgnoreGold"))
                {
                    World.Player.SendMessage(MsgLevel.Force, LocString.BuyAgentAttempt, total, cost);
                }
                else
                {
                    World.Player.SendMessage(MsgLevel.Force, LocString.BuyTotals, total, cost);
                }
            }

            if (lowGoldWarn)
            {
                World.Player.SendMessage(MsgLevel.Force, LocString.BuyLowGold);
            }
        }

        private static readonly Dictionary<uint, List<VendorBuyItem>> BuyLists = new Dictionary<uint, List<VendorBuyItem>>();
        private static void ExtBuyInfo(PacketReader p, PacketHandlerEventArgs args)
        {
            Serial ser = p.ReadUInt32();
            Item pack = World.FindItem(ser);
            if (pack == null)
            {
                return;
            }

            byte count = p.ReadByte();
            if (count < pack.Contains.Count)
            {
                World.Player.SendMessage(MsgLevel.Debug,
                    "Buy Agent Warning: Contains Count {0} does not match ExtInfo {1}.", pack.Contains.Count, count);
            }

            pack.Contains.Sort(ItemXYComparer.Instance);

            for (int i = count - 1; i >= 0; i--)
            {
                if (i < pack.Contains.Count)
                {
                    Item item = (Item) pack.Contains[i];
                    item.Price = p.ReadInt32();
                    byte len = p.ReadByte();
                    item.BuyDesc = p.ReadStringSafe(len);
                }
                else
                {
                    p.ReadInt32();
                    p.Position += p.ReadByte() + 1;
                }
            }
        }

        private static void EndVendorBuy(PacketReader p, PacketHandlerEventArgs args)
        {
            if (!Client.Instance.AllowBit(FeatureBit.BuyAgent) || World.Player == null)
                return;
            uint serial = p.ReadUInt32();
            if (BuyLists.TryGetValue(serial, out var list))
            {
                BuyLists.Remove(serial);
                Mobile vendor = World.FindMobile(serial);
                if (vendor == null)
                    return;

                Item pack = vendor.GetItemOnLayer(Layer.ShopBuy);
                if (pack == null || pack.Contains == null || pack.Contains.Count <= 0)
                    return;

                for (int i = list.Count - 1; i >= 0; --i)
                {
                    VendorBuyItem vbi = list[i];
                    Item item = World.FindItem(vbi.Serial);
                    if (item == null || !pack.Contains.Contains(item))
                        continue;
                    item.Amount -= (ushort)vbi.Amount;
                    if (item.Amount <= 0)
                        item.Remove();
                }
            }
        }

        public override void Clear()
        {
            Items.Clear();
        }

        internal static void OnDisconnected()
        {
            BuyLists.Clear();
        }

        public override string Name => $"{Language.GetString(LocString.Buy)}-{Number}";

        public override string Alias { get; set; }

        public override int Number { get; }

        public override void OnSelected(ListBox subList, params Button[] buttons)
        {
            m_SubList = subList;
            m_EnableBTN = buttons[4];

            buttons[0].Text = Language.GetString(LocString.AddTarg);
            buttons[0].Visible = true;
            buttons[1].Text = Language.GetString(LocString.Edit);
            buttons[1].Visible = true;
            buttons[2].Text = Language.GetString(LocString.Remove);
            buttons[2].Visible = true;
            buttons[3].Text = Language.GetString(LocString.ClearList);
            buttons[3].Visible = true;
            buttons[4].Text = Language.GetString(m_Enabled ? LocString.PushDisable : LocString.PushEnable);
            buttons[4].Visible = true;

            m_SubList.BeginUpdate();
            m_SubList.Items.Clear();
            for (int i = 0; i < Items.Count; i++)
            {
                m_SubList.Items.Add(Items[i]);
            }

            m_SubList.EndUpdate();

            if (!Client.Instance.AllowBit(FeatureBit.BuyAgent) && Engine.MainWindow != null)
            {
                for (int i = 0; i < buttons.Length; i++)
                {
                    Engine.MainWindow.SafeAction(s => s.LockControl(buttons[i]));
                }

                Engine.MainWindow.SafeAction(s => s.LockControl(subList));
            }
        }

        public override void OnButtonPress(int num)
        {
            switch (num)
            {
                case 1:
                    World.Player.SendMessage(MsgLevel.Force, LocString.TargItemAdd);
                    Targeting.OneTimeTarget(new Targeting.TargetResponseCallback(OnTarget));
                    break;
                case 2:
                    if (m_SubList == null)
                    {
                        break;
                    }

                    if (m_SubList.SelectedIndex >= 0)
                    {
                        BuyEntry e = (BuyEntry)Items[m_SubList.SelectedIndex];

                        InputDialogGump inputGump = new InputDialogGump(OnItemChangeAmountResponse, m_SubList.SelectedIndex, Language.GetString(LocString.EnterAmount), e.Amount.ToString());
                        inputGump.SendGump();
                    }

                    break;
                case 3:

                    if (MessageBox.Show(Language.GetString(LocString.Confirm), Language.GetString(LocString.ClearList),
                            MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
                    {
                        if (m_SubList.SelectedIndex >= 0)
                        {
                            Items.RemoveAt(m_SubList.SelectedIndex);
                            m_SubList.Items.RemoveAt(m_SubList.SelectedIndex);
                            m_SubList.SelectedIndex = -1;
                        }
                    }

                    break;
                case 4:

                    if (MessageBox.Show(Language.GetString(LocString.Confirm), Language.GetString(LocString.ClearList),
                            MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
                    {
                        m_SubList.Items.Clear();
                        Items.Clear();
                    }

                    break;
                case 5:
                    m_Enabled = !m_Enabled;
                    m_EnableBTN.Text = Language.GetString(m_Enabled ? LocString.PushDisable : LocString.PushEnable);
                    break;
            }
        }

        private void OnTarget(bool location, Serial serial, Point3D loc, ushort gfx)
        {
            if (!location && !serial.IsMobile)
            {
                InputDialogGump inputGump = new InputDialogGump(OnItemTargetAmountResponse, gfx, Language.GetString(LocString.EnterAmount), "0");
                inputGump.SendGump();
            }

            if (!_fromGump)
            {
                Engine.MainWindow.SafeAction(s => s.ShowMe());
            }
        }

        private bool OnItemTargetAmountResponse(int gfx, string input)
        {
            if (ushort.TryParse(input, out ushort count))
            {
                if (count <= 0)
                {
                    return false;
                }

                AddItem(new BuyEntry((ushort) gfx, count));
                
                if (_fromGump)
                {
                    _fromGump = false;

                    AgentsGump agent = new AgentsGump(this);
                    agent.SendGump();
                }
                else
                {
                    Engine.MainWindow.SafeAction(s => s.ShowMe());
                }

                return true;
            }

            if (_fromGump)
            {
                _fromGump = false;

                AgentsGump agent = new AgentsGump(this);
                agent.SendGump();
            }
            else
            {
                Engine.MainWindow.SafeAction(s => s.ShowMe());
            }

            return false;
        }

        private bool OnItemChangeAmountResponse(int entryId, string input)
        {
            if (ushort.TryParse(input, out ushort amount))
            {
                if (amount <= 0)
                {
                    return false;
                }

                BuyEntry e = (BuyEntry)Items[entryId];

                e.Amount = amount;

                if (m_SubList != null)
                {
                    m_SubList.BeginUpdate();
                    m_SubList.Items.Clear();

                    for (int i = 0; i < Items.Count; i++)
                    {
                        m_SubList.Items.Add(Items[i]);
                    }

                    m_SubList.EndUpdate();
                }

                if (_fromGump)
                {
                    _fromGump = false;

                    AgentsGump agent = new AgentsGump(this);
                    agent.SendGump();
                }
                else
                {
                    Engine.MainWindow.SafeAction(s => s.ShowMe());
                }

                return true;
            }

            if (_fromGump)
            {
                _fromGump = false;

                AgentsGump agent = new AgentsGump(this);
                agent.SendGump();
            }
            else
            {
                Engine.MainWindow.SafeAction(s => s.ShowMe());
            }

            return false;
        }

        public void AddItemTarget(bool fromGump = false)
        {
            _fromGump = fromGump;

            World.Player.SendMessage(MsgLevel.Force, LocString.TargItemAdd);
            Targeting.OneTimeTarget(OnTarget);
        }

        public void AddItem(BuyEntry entry)
        {
            Items?.Add(entry);

            m_SubList?.Items.Add(entry);

            World.Player?.SendMessage(MsgLevel.Force, LocString.ItemAdded);
        }

        public void RemoveItem(int itemId)
        {
            BuyEntry item = Items.FirstOrDefault(a => a.Id == itemId);

            if (item != null)
            {
                Items.Remove(item);
                m_SubList?.Items?.Remove(item);

                World.Player?.SendMessage(MsgLevel.Force, LocString.ItemRemoved);
            }
        }

        public void SetItemAmount(int itemId, bool fromGump = false)
        {
            int itemIndex = Items.FindIndex(a => a.Id == itemId);
            BuyEntry item = Items[itemIndex];

            if (item != null)
            {
                _fromGump = fromGump;

                InputDialogGump inputGump = new InputDialogGump(OnItemChangeAmountResponse, itemIndex, Language.GetString(LocString.EnterAmount), item.Amount.ToString());
                inputGump.SendGump();
            }
        }

        public override void Save(XmlTextWriter xml)
        {
            if (Items == null)
            {
                return;
            }

            xml.WriteAttributeString("enabled", m_Enabled.ToString());
            xml.WriteAttributeString("alias", Alias);

            foreach (BuyEntry b in Items)
            {
                xml.WriteStartElement("item");
                xml.WriteAttributeString("id", b.Id.Value.ToString());
                xml.WriteAttributeString("amount", b.Amount.ToString());
                xml.WriteEndElement();
            }
        }

        public override void Load(XmlElement node)
        {
            try
            {
                m_Enabled = bool.Parse(node.GetAttribute("enabled"));
            }
            catch
            {
                m_Enabled = false;
            }

            try
            {
                Alias = node.GetAttribute("alias");
            }
            catch
            {
                Alias = string.Empty;
            }

            foreach (XmlElement el in node.GetElementsByTagName("item"))
            {
                try
                {
                    ushort id = Convert.ToUInt16(el.GetAttribute("id"));
                    ushort amount = Convert.ToUInt16(el.GetAttribute("amount"));

                    Items.Add(new BuyEntry(id, amount));
                }
                catch
                {
                    // ignored
                }
            }
        }
    }
}


================================================
FILE: Razor/Agents/IgnoreAgent.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Xml;
using Assistant.Core;
using Assistant.UI;

namespace Assistant.Agents
{
    public class IgnoreAgent : Agent
    {
        public static IgnoreAgent Instance { get; private set; }

        public static void Initialize()
        {
            Agent.Add(Instance = new IgnoreAgent());
            
            MessageManager.OnMobileMessage += HandleMobileMessage;
        }
        
        public static void HandleMobileMessage(Packet p, PacketHandlerEventArgs args, Serial source, ushort graphic,
            MessageType type, ushort hue, ushort font, string lang, string sourceName,
            string text)
        {
            if (Instance == null)
                return;

            if (Instance.IsSerialIgnored(source))
            {
                args.Block = true;
            }
        }

        public static bool IsIgnored(Serial ser)
        {
            return Instance?.IsSerialIgnored(ser) ?? false;
        }

        private ListBox m_SubList;
        private readonly List<Serial> m_Chars;
        private readonly Dictionary<Serial, string> m_Names;
        private static bool m_Enabled;
        private Button m_EnableBTN;

        public IgnoreAgent()
        {
            m_Chars = new List<Serial>();
            m_Names = new Dictionary<Serial, string>();

            Number = 0;

            HotKey.Add(HKCategory.Targets, LocString.AddToIgnore, new HotKeyCallback(AddToIgnoreList));
            HotKey.Add(HKCategory.Targets, LocString.RemoveFromIgnore, new HotKeyCallback(RemoveFromIgnoreList));

            Agent.OnMobileCreated += new MobileCreatedEventHandler(OPLCheckIgnore);
        }

        public override void Clear()
        {
            m_Chars.Clear();
            m_Names.Clear();
        }

        public static bool IsEnabled()
        {
            return m_Enabled;
        }

        public bool IsSerialIgnored(Serial ser)
        {
            if (m_Enabled)
            {
                return m_Chars.Contains(ser);
            }
            else
            {
                return false;
            }
        }

        public override string Name
        {
            get { return Language.GetString(LocString.IgnoreAgent); }
        }

        public override string Alias { get; set; }

        public override int Number { get; }

        public override void OnSelected(ListBox subList, params Button[] buttons)
        {
            m_EnableBTN = buttons[4];

            buttons[0].Text = Language.GetString(LocString.AddTarg);
            buttons[0].Visible = true;
            buttons[1].Text = Language.GetString(LocString.Remove);
            buttons[1].Visible = true;
            buttons[2].Text = Language.GetString(LocString.RemoveTarg);
            buttons[2].Visible = true;
            buttons[3].Text = Language.GetString(LocString.ClearList);
            buttons[3].Visible = true;
            buttons[4].Text = Language.GetString(m_Enabled ? LocString.PushDisable : LocString.PushEnable);
            buttons[4].Visible = true;

            m_SubList = subList;
            subList.BeginUpdate();
            subList.Items.Clear();
            for (int i = 0; i < m_Chars.Count; i++)
            {
                Add2List((Serial) m_Chars[i]);
            }

            subList.EndUpdate();
        }

        public void AddToIgnoreList()
        {
            World.Player.SendMessage(MsgLevel.Force, LocString.AddToIgnore);
            Targeting.OneTimeTarget(new Targeting.TargetResponseCallback(OnAddTarget));
        }

        public void RemoveFromIgnoreList()
        {
            World.Player.SendMessage(MsgLevel.Force, LocString.RemoveFromIgnore);
            Targeting.OneTimeTarget(new Targeting.TargetResponseCallback(OnRemoveTarget));
        }

        public override void OnButtonPress(int num)
        {
            switch (num)
            {
                case 1:
                {
                    AddToIgnoreList();
                    break;
                }

                case 2:
                {
                    if (m_SubList.SelectedIndex >= 0 && m_SubList.SelectedIndex < m_Chars.Count)
                    {
                        try
                        {
                            m_Names.Remove(m_Chars[m_SubList.SelectedIndex]);
                        }
                        catch
                        {
                        }

                        m_Chars.RemoveAt(m_SubList.SelectedIndex);
                        m_SubList.Items.RemoveAt(m_SubList.SelectedIndex);
                    }

                    break;
                }

                case 3:
                {
                    RemoveFromIgnoreList();
                    break;
                }

                case 4:
                {
                    if (MessageBox.Show(Language.GetString(LocString.Confirm), Language.GetString(LocString.ClearList),
                            MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
                    {
                        foreach (Serial s in m_Chars)
                        {
                            Mobile m = World.FindMobile(s);
                            if (m != null)
                            {
                                if (m.ObjPropList.Remove(Language.GetString(LocString.RazorIgnored)))
                                {
                                    m.OPLChanged();
                                }
                            }
                        }

                        m_Chars.Clear();
                        m_SubList.Items.Clear();
                    }

                    break;
                }

                case 5:
                {
                    m_Enabled = !m_Enabled;
                    m_EnableBTN.Text = Language.GetString(m_Enabled ? LocString.PushDisable : LocString.PushEnable);
                    break;
                }
            }
        }

        private void OPLCheckIgnore(Mobile m)
        {
            if (IsIgnored(m.Serial))
            {
                m.ObjPropList.Add(Language.GetString(LocString.RazorIgnored));
            }
        }

        private void OnAddTarget(bool location, Serial serial, Point3D loc, ushort gfx)
        {
            Engine.MainWindow.SafeAction(s => s.ShowMe());

            if (!location && serial.IsMobile && serial != World.Player.Serial)
            {
                World.Player.SendMessage(MsgLevel.Force, LocString.AddToIgnore);
                if (!m_Chars.Contains(serial))
                {
                    m_Chars.Add(serial);

                    Add2List(serial);

                    Mobile m = World.FindMobile(serial);
                    if (m != null)
                    {
                        m.ObjPropList.Add(Language.GetString(LocString.RazorIgnored));
                        m.OPLChanged();
                    }
                }
            }
        }

        private void Add2List(Serial s)
        {
            Mobile m = World.FindMobile(s);
            string name = null;

            if (m_Names.ContainsKey(s))
            {
                name = m_Names[s] as string;
            }

            if (m != null && m.Name != null && m.Name != "")
            {
                name = m.Name;
            }

            if (name == null)
            {
                name = "(Name Unknown)";
            }

            m_Names[s] = name;

            if (m_SubList != null)
            {
                m_SubList.Items.Add($"\"{name}\" {s}");
            }
        }

        private void OnRemoveTarget(bool location, Serial serial, Point3D loc, ushort gfx)
        {
            Engine.MainWindow.SafeAction(s => s.ShowMe());

            if (!location && serial.IsMobile && serial != World.Player.Serial)
            {
                m_Chars.Remove(serial);
                m_Names.Remove(serial);

                World.Player.SendMessage(MsgLevel.Force, LocString.RemoveFromIgnore);

                m_SubList.BeginUpdate();
                m_SubList.Items.Clear();
                for (int i = 0; i < m_Chars.Count; i++)
                {
                    Add2List((Serial) m_Chars[i]);
                }

                m_SubList.EndUpdate();

                Mobile m = World.FindMobile(serial);
                if (m != null)
                {
                    if (m.ObjPropList.Remove(Language.GetString(LocString.RazorIgnored)))
                    {
                        m.OPLChanged();
                    }
                }
            }
        }

        public override void Save(XmlTextWriter xml)
        {
            xml.WriteAttributeString("enabled", m_Enabled.ToString());
            for (int i = 0; i < m_Chars.Count; i++)
            {
                xml.WriteStartElement("ignore");
                xml.WriteAttributeString("serial", m_Chars[i].ToString());
                try
                {
                    if (m_Names.ContainsKey((Serial) m_Chars[i]))
                    {
                        xml.WriteAttributeString("name", m_Names[(Serial) m_Chars[i]].ToString());
                    }
                }
                catch
                {
                }

                xml.WriteEndElement();
            }
        }

        public override void Load(XmlElement node)
        {
            try
            {
                m_Enabled = Convert.ToBoolean(node.GetAttribute("enabled"));
            }
            catch
            {
                // ignored
            }

            foreach (XmlElement el in node.GetElementsByTagName("ignore"))
            {
                try
                {
                    Serial toAdd = Serial.Parse(el.GetAttribute("serial"));

                    if (!m_Chars.Contains(toAdd))
                    {
                        m_Chars.Add(toAdd);
                    }

                    string name = el.GetAttribute("name");
                    if (!string.IsNullOrEmpty(name))
                    {
                        m_Names.Add(toAdd, name.Trim());
                    }
                }
                catch
                {
                    // ignored
                }
            }
        }
    }
}

================================================
FILE: Razor/Agents/OrganizerAgent.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
using System.Xml;
using Assistant.Gumps.Internal;
using Assistant.Scripts;
using Assistant.UI;

namespace Assistant.Agents
{
    public class OrganizerAgent : Agent
    {
        public static List<OrganizerAgent> Agents { get; set; }

        public static void Initialize()
        {
            int maxAgents = Config.GetAppSetting<int>("MaxOrganizerAgents") == 0
                ? 20
                : Config.GetAppSetting<int>("MaxOrganizerAgents");

            Agents = new List<OrganizerAgent>();

            for (int i = 1; i <= maxAgents; i++)
            {
                OrganizerAgent organizerAgent = new OrganizerAgent(i);

                Agent.Add(organizerAgent);

                Agents.Add(organizerAgent);
            }
        }

        private ListBox m_SubList;
        private Button m_BagBTN;
        private Button m_ArrBTN;
        public readonly List<ItemID> Items;
        private uint m_Cont;
        private bool _fromGump;

        public OrganizerAgent(int num)
        {
            Items = new List<ItemID>();
            Number = num;
            HotKey.Add(HKCategory.Agents, HKSubCat.None,
                $"{Language.GetString(LocString.OrganizerAgent)}-{Number:D2}",
                new HotKeyCallback(Organize));
            HotKey.Add(HKCategory.Agents, HKSubCat.None,
                $"{Language.GetString(LocString.SetOrganizerHB)}-{Number:D2}",
                new HotKeyCallback(SetHotBag));
            PacketHandler.RegisterClientToServerViewer(0x09, new PacketViewerCallback(OnSingleClick));

            Agent.OnItemCreated += new ItemCreatedEventHandler(CheckContOPL);
        }

        public void CheckContOPL(Item item)
        {
            if (item.Serial == m_Cont)
            {
                item.ObjPropList.Add(Language.Format(LocString.OrganizerHBA1, Number));
            }
        }

        private void OnSingleClick(PacketReader pvSrc, PacketHandlerEventArgs args)
        {
            uint serial = pvSrc.ReadUInt32();
            if (m_Cont == serial)
            {
                ushort gfx = 0;
                Item c = World.FindItem(m_Cont);
                if (c != null)
                {
                    gfx = c.ItemID.Value;
                }

                Client.Instance.SendToClient(new UnicodeMessage(m_Cont, gfx, Assistant.MessageType.Label, 0x3B2, 3,
                    Language.CliLocName, "", Language.Format(LocString.OrganizerHBA1, Number)));
            }
        }

        public override string Name
        {
            get { return $"{Language.GetString(LocString.Organizer)}-{Number}"; }
        }

        public override string Alias { get; set; }

        public override int Number { get; }

        public override void OnSelected(ListBox subList, params Button[] buttons)
        {
            m_SubList = subList;
            buttons[0].Text = Language.GetString(LocString.AddTarg);
            buttons[0].Visible = true;
            m_BagBTN = buttons[1];
            m_ArrBTN = buttons[2];
            if (m_Cont != 0)
            {
                buttons[1].Text = Language.GetString(LocString.ClearHB);
            }
            else
            {
                buttons[1].Text = Language.GetString(LocString.SetHB);
            }

            buttons[1].Visible = true;
            buttons[2].Text = Language.GetString(LocString.OrganizeNow);
            buttons[2].Visible = true;
            buttons[3].Text = Language.GetString(LocString.Remove);
            buttons[3].Visible = true;
            buttons[4].Text = Language.GetString(LocString.Clear);
            buttons[4].Visible = true;
            buttons[5].Text = Language.GetString(LocString.StopNow);
            buttons[5].Visible = true;

            m_SubList.BeginUpdate();
            m_SubList.Items.Clear();
            for (int i = 0; i < Items.Count; i++)
            {
                m_SubList.Items.Add((ItemID) (Items[i]));
            }

            m_SubList.EndUpdate();
        }

        public void SetHotBag()
        {
            World.Player.SendMessage(MsgLevel.Force, LocString.TargCont);
            Targeting.OneTimeTarget(new Targeting.TargetResponseCallback(OnTargetBag));
        }

        public override void OnButtonPress(int num)
        {
            switch (num)
            {
                case 1:
                    AddItemTarget();
                    break;
                case 2:
                    SetHotBag();
                    break;
                case 3:
                    Organize();
                    break;
                case 4:
                    if (m_SubList.SelectedIndex >= 0 && m_SubList.SelectedIndex < Items.Count)
                    {
                        Items.RemoveAt(m_SubList.SelectedIndex);
                        m_SubList.Items.RemoveAt(m_SubList.SelectedIndex);
                    }

                    break;
                case 5:
                {
                    if (MessageBox.Show(Language.GetString(LocString.Confirm), Language.GetString(LocString.ClearList),
                            MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
                    {
                        Item bag = World.FindItem(m_Cont);
                        if (bag != null)
                        {
                            bag.ObjPropList.Remove(Language.Format(LocString.OrganizerHBA1, Number));
                            bag.OPLChanged();
                        }

                        m_SubList.Items.Clear();
                        Items.Clear();
                        m_Cont = 0;
                        m_BagBTN.Text = Language.GetString(LocString.SetHB);
                    }

                    break;
                }

                case 6:
                    DragDropManager.GracefulStop();
                    break;
            }
        }

        public void Organize()
        {
            if (m_Cont == 0 || m_Cont > 0x7FFFFF00)
            {
                World.Player.SendMessage(MsgLevel.Force, LocString.ContNotSet);
                return;
            }

            Item pack = World.Player.Backpack;
            if (pack == null)
            {
                World.Player.SendMessage(MsgLevel.Warning, LocString.NoBackpack);
                return;
            }

            int count = OrganizeChildren(pack);

            if (count > 0)
            {
                World.Player.SendMessage(LocString.OrgQueued, count);
            }
            else
            {
                World.Player.SendMessage(LocString.OrgNoItems);
            }
        }

        private int OrganizeChildren(Item container)
        {
            object dest = World.FindItem(m_Cont);
            if (dest == null)
            {
                dest = World.FindMobile(m_Cont);
                if (dest == null)
                {
                    return 0;
                }
            }

            /*else if ( World.Player.Backpack != null && ((Item)dest).IsChildOf( World.Player ) && !((Item)dest).IsChildOf( World.Player.Backpack ) )
            {
                 return 0;
            }*/

            return OrganizeChildren(container, dest);
        }

        private int OrganizeChildren(Item container, object dest)
        {
            int count = 0;
            for (int i = 0; i < container.Contains.Count; i++)
            {
                Item item = (Item) container.Contains[i];
                if (item.Serial != m_Cont && !item.IsChildOf(dest))
                {
                    count += OrganizeChildren(item, dest);
                    if (Items.Contains(item.ItemID.Value))
                    {
                        if (dest is Item)
                        {
                            DragDropManager.DragDrop(item, (Item) dest);
                        }
                        else if (dest is Mobile)
                        {
                            DragDropManager.DragDrop(item, ((Mobile) dest).Serial);
                        }

                        count++;
                    }
                }
            }

            return count;
        }

        private void OnTarget(bool location, Serial serial, Point3D loc, ushort gfx)
        {
            if (!location && serial.IsItem && World.Player != null)
            {
                AddItem(gfx);
            }

            if (_fromGump)
            {
                _fromGump = false;

                AgentsGump agent = new AgentsGump(this);
                agent.SendGump();
            } 
            else if (Engine.MainWindow != null)
            {
                Engine.MainWindow.SafeAction(s => s.ShowMe());
            }
        }
        public void AddItemTarget(bool fromGump = false)
        {
            _fromGump = fromGump;

            World.Player.SendMessage(MsgLevel.Force, LocString.TargItemAdd);
            Targeting.OneTimeTarget(OnTarget);
        }

        public void AddItem(ushort gfx)
        {
            if (Items != null && Items.Contains(gfx))
            {
                World.Player?.SendMessage(MsgLevel.Force, LocString.ItemExists);
            }
            else
            {
                Items?.Add(gfx);

                m_SubList?.Items.Add((ItemID)gfx);

                World.Player?.SendMessage(MsgLevel.Force, LocString.ItemAdded);
            }
        }

        public void RemoveItem(int itemId)
        {
            ItemID item = Items.FirstOrDefault(a => a == itemId);

            if (item != null)
            {
                Items.Remove(item);
                m_SubList?.Items?.Remove(item);

                World.Player?.SendMessage(MsgLevel.Force, LocString.ItemRemoved);
            }
        }

        private void OnTargetBag(bool location, Serial serial, Point3D loc, ushort gfx)
        {
            if (Engine.MainWindow != null && !ScriptManager.Running)
            {
                Engine.MainWindow.SafeAction(s => s.ShowMe());
            }

            if (!location && serial > 0 && serial <= 0x7FFFFF00)
            {
                Item bag = World.FindItem(m_Cont);
                if (bag != null && bag.ObjPropList != null)
                {
                    bag.ObjPropList.Remove(Language.Format(LocString.OrganizerHBA1, Number));
                    bag.OPLChanged();
                }

                m_Cont = serial;
                if (m_BagBTN != null)
                {
                    m_BagBTN.Text = Language.GetString(LocString.ClearHB);
                }

                if (World.Player != null)
                {
                    World.Player.SendMessage(MsgLevel.Force, LocString.ContSet);
                }

                bag = World.FindItem(m_Cont);
                if (bag != null && bag.ObjPropList != null)
                {
                    bag.ObjPropList.Add(Language.Format(LocString.OrganizerHBA1, Number));
                    bag.OPLChanged();
                }
            }
        }

        public override void Clear()
        {
            Items.Clear();
            m_Cont = 0;
            if (m_BagBTN != null)
            {
                m_BagBTN.Text = Language.GetString(LocString.SetHB);
            }
        }

        public override void Save(XmlTextWriter xml)
        {
            xml.WriteAttributeString("hotbag", m_Cont.ToString());
            xml.WriteAttributeString("alias", Alias);

            for (int i = 0; i < Items.Count; i++)
            {
                xml.WriteStartElement("item");
                xml.WriteAttributeString("id", Items[i].Value.ToString());
                xml.WriteEndElement();
            }
        }

        public override void Load(XmlElement node)
        {
            try
            {
                m_Cont = Convert.ToUInt32(node.GetAttribute("hotbag"));
            }
            catch
            {
                // ignored
            }

            try
            {
                Alias = node.GetAttribute("alias");
            }
            catch
            {
                Alias = string.Empty;
            }

            if (m_BagBTN != null)
            {
                m_BagBTN.Text = Language.GetString(m_Cont != 0 ? LocString.ClearHB : LocString.SetHB);
            }

            foreach (XmlElement el in node.GetElementsByTagName("item"))
            {
                try
                {
                    string gfx = el.GetAttribute("id");
                    Items.Add(Convert.ToUInt16(gfx));
                }
                catch
                {
                    // ignored
                }
            }
        }
    }
}

================================================
FILE: Razor/Agents/RestockAgent.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
using System.Xml;
using Assistant.Gumps;
using Assistant.Gumps.Internal;
using Assistant.Scripts;
using Assistant.UI;

namespace Assistant.Agents
{
    public class RestockAgent : Agent
    {
        public static List<RestockAgent> Agents { get; set; }
        
        public static void Initialize()
        {
            int maxAgents = Config.GetAppSetting<int>("MaxRestockAgents") == 0
                ? 20
                : Config.GetAppSetting<int>("MaxRestockAgents");

            Agents = new List<RestockAgent>();

            for (int i = 1; i <= maxAgents; i++)
            {
                RestockAgent restockAgent = new RestockAgent(i);

                Agent.Add(restockAgent);
                Agents.Add(restockAgent);
            }
        }

        private ListBox m_SubList;
        public readonly List<RestockItem> Items;
        private Button m_HotBTN;
        private Serial m_HotBag;

        private bool _fromGump { get; set; }

        public RestockAgent(int num)
        {
            Number = num;

            Items = new List<RestockItem>();

            HotKey.Add(HKCategory.Agents, HKSubCat.None,
                $"{Language.GetString(LocString.RestockAgent)}-{Number:D2}",
                new HotKeyCallback(OnHotKey));
            HotKey.Add(HKCategory.Agents, HKSubCat.None,
                $"{Language.GetString(LocString.SetRestockHB)}-{Number:D2}",
                new HotKeyCallback(SetHB));
            PacketHandler.RegisterClientToServerViewer(0x09, new PacketViewerCallback(OnSingleClick));

            Agent.OnItemCreated += new ItemCreatedEventHandler(CheckHBOPL);
        }

        public void CheckHBOPL(Item item)
        {
            if (item.Serial == m_HotBag)
            {
                item.ObjPropList.Add(Language.Format(LocString.RestockHBA1, Number));
            }
        }

        private void OnSingleClick(PacketReader pvSrc, PacketHandlerEventArgs args)
        {
            Serial serial = pvSrc.ReadUInt32();
            if (m_HotBag == serial)
            {
                ushort gfx = 0;
                Item c = World.FindItem(m_HotBag);
                if (c != null)
                {
                    gfx = c.ItemID.Value;
                }

                Client.Instance.SendToClient(new UnicodeMessage(m_HotBag, gfx, Assistant.MessageType.Label, 0x3B2, 3,
                    Language.CliLocName, "", Language.Format(LocString.RestockHBA1, Number)));
            }
        }

        public override void Clear()
        {
            Items.Clear();
        }
        public override string Name
        {

            get { return $"{Language.GetString(LocString.Restock)}-{Number}"; }
        }

        public override string Alias { get; set; }

        public override int Number { get; }

        public override void OnSelected(ListBox subList, params Button[] buttons)
        {
            buttons[0].Text = Language.GetString(LocString.AddTarg);
            buttons[0].Visible = true;
            buttons[1].Text = Language.GetString(LocString.Remove);
            buttons[1].Visible = true;
            buttons[2].Text = Language.GetString(LocString.SetAmt);
            buttons[2].Visible = true;
            buttons[3].Text = Language.GetString(LocString.ClearList);
            buttons[3].Visible = true;
            m_HotBTN = buttons[4];
            SetHBText();
            buttons[4].Visible = true;
            buttons[5].Text = Language.GetString(LocString.RestockNow);
            buttons[5].Visible = true;

            m_SubList = subList;
            subList.BeginUpdate();
            subList.Items.Clear();
            for (int i = 0; i < Items.Count; i++)
            {
                subList.Items.Add(Items[i]);
            }

            subList.EndUpdate();

            if (!Client.Instance.AllowBit(FeatureBit.RestockAgent) && Engine.MainWindow != null)
            {
                for (int i = 0; i < buttons.Length; i++)
                {
                    Engine.MainWindow.SafeAction(s => s.LockControl(buttons[i]));
                }

                Engine.MainWindow.SafeAction(s => s.LockControl(subList));
            }
        }

        public override void OnButtonPress(int num)
        {
            switch (num)
            {
                case 1:
                {
                    AddItemTarget();
                    break;
                }

                case 2:
                {
                    if (m_SubList.SelectedIndex >= 0 && m_SubList.SelectedIndex < Items.Count)
                    {
                        Items.RemoveAt(m_SubList.SelectedIndex);
                        m_SubList.Items.RemoveAt(m_SubList.SelectedIndex);
                    }

                    break;
                }

                case 3:
                {
                    int i = m_SubList.SelectedIndex;
                    if (i < 0 || i > Items.Count)
                    {
                        return;
                    }

                    RestockItem ri = (RestockItem) Items[i];
                    
                    InputDialogGump inputGump = new InputDialogGump(OnItemTargetChangeResponse, m_SubList.SelectedIndex, Language.GetString(LocString.EnterAmount), ri.Amount.ToString());
                    inputGump.SendGump();

                    break;
                }

                case 4:
                {
                    if (MessageBox.Show(Language.GetString(LocString.Confirm), Language.GetString(LocString.ClearList),
                            MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
                    {
                        m_SubList.Items.Clear();
                        Items.Clear();
                    }

                    break;
                }

                case 5:
                {
                    if (m_HotBag == Serial.Zero)
                    {
                        SetHB();
                    }
                    else
                    {
                        m_HotBag = Serial.Zero;
                        SetHBText();
                    }

                    break;
                }

                case 6:
                {
                    OnHotKey();
                    break;
                }
            }
        }

        private void SetHBText()
        {
            if (m_HotBTN != null)
            {
                m_HotBTN.Text = Language.GetString(m_HotBag == Serial.Zero ? LocString.SetHB : LocString.ClearHB);
            }
        }

        public void SetHB()
        {
            World.Player.SendMessage(MsgLevel.Force, LocString.TargCont);
            Targeting.OneTimeTarget(new Targeting.TargetResponseCallback(OnHBTarget));
        }

        private void OnHBTarget(bool location, Serial serial, Point3D loc, ushort gfx)
        {
            if (Engine.MainWindow != null && !ScriptManager.Running)
            {
                Engine.MainWindow.SafeAction(s => s.ShowMe());
            }

            Item hb = World.FindItem(m_HotBag);
            if (hb != null)
            {
                if (hb.ObjPropList.Remove(Language.Format(LocString.RestockHBA1, Number)))
                {
                    hb.OPLChanged();
                }
            }

            if (!location && serial.IsItem)
            {
                m_HotBag = serial;
            }
            else
            {
                m_HotBag = Serial.Zero;
            }

            hb = World.FindItem(m_HotBag);
            if (hb != null)
            {
                hb.ObjPropList.Add(Language.Format(LocString.RestockHBA1, Number));
                hb.OPLChanged();
            }

            SetHBText();
        }

        public void OnHotKey()
        {
            if (Client.Instance.AllowBit(FeatureBit.RestockAgent))
            {
                World.Player.SendMessage(MsgLevel.Force, LocString.RestockTarget);
                Targeting.OneTimeTarget(new Targeting.TargetResponseCallback(OnRestockTarget));
            }
        }

        Item m_Cont = null;

        private void OnRestockTarget(bool location, Serial serial, Point3D loc, ushort gfx)
        {
            if (serial == World.Player.Serial)
            {
                m_Cont = World.Player.GetItemOnLayer(Layer.Bank);
            }
            else if (serial.IsItem)
            {
                m_Cont = World.FindItem(serial);
                if (m_Cont != null)
                {
                    object root = m_Cont.RootContainer;
                    if (root is Mobile && root != World.Player)
                    {
                        m_Cont = null;
                    }
                }
            }

            if (m_Cont == null || m_Cont.IsCorpse)
            {
                World.Player.SendMessage(MsgLevel.Force, LocString.InvalidCont);
                return;
            }

            if (Utility.Distance(World.Player.Position, m_Cont.GetWorldPosition()) > 3)
            {
                World.Player.SendMessage(MsgLevel.Error, LocString.TooFar);
            }
            else
            {
                if (m_Cont.IsContainer && m_Cont.Layer != Layer.Bank)
                {
                    PlayerData.DoubleClick(m_Cont);

                    if (Config.GetBool("ObjectDelayEnabled"))
                    {
                        Timer.DelayedCallback(TimeSpan.FromMilliseconds(Config.GetInt("ObjectDelay") + 200),
                            new TimerCallback(DoRestock)).Start();
                    }
                    else
                    {
                        Timer.DelayedCallback(TimeSpan.FromMilliseconds(200), new TimerCallback(DoRestock)).Start();
                    }


                    World.Player.SendMessage(LocString.RestockQueued);
                }
                else
                {
                    DoRestock();
                }
            }
        }

        private void DoRestock()
        {
            Item bag = null;
            if (m_HotBag != Serial.Zero)
            {
                bag = World.FindItem(m_HotBag);
                if (bag != null && bag.RootContainer != World.Player)
                {
                    bag = null;
                }
            }

            if (bag == null)
            {
                bag = World.Player.Backpack;
                if (bag == null)
                {
                    World.Player.SendMessage(MsgLevel.Force, LocString.NoBackpack);
                    return;
                }
            }

            int num = 0;
            for (int i = 0; i < Items.Count; i++)
            {
                RestockItem ri = Items[i];
                int count = World.Player.Backpack.GetCount(ri.ItemID);

                num += Recurse(bag, m_Cont.Contains, ri, ref count);
            }

            World.Player.SendMessage(MsgLevel.Force, LocString.RestockDone, num, num != 1 ? "s" : "");
        }

        private int Recurse(Item pack, List<Item> items, RestockItem ri, ref int count)
        {
            int num = 0;
            for (int i = 0; count < ri.Amount && i < items.Count; i++)
            {
                Item item = (Item) items[i];

                if (item.ItemID == ri.ItemID)
                {
                    int amt = ri.Amount - count;
                    if (amt > item.Amount)
                    {
                        amt = item.Amount;
                    }

                    DragDropManager.DragDrop(item, amt, pack);
                    count += amt;
                    num++;
                }
                else if (item.Contains.Count > 0)
                {
                    num += Recurse(pack, item.Contains, ri, ref count);
                }
            }

            return num;
        }

        private void OnItemTarget(bool location, Serial serial, Point3D loc, ushort gfx)
        {
            if (location || serial.IsMobile)
            {
                return;
            }

            Item item = World.FindItem(serial);
            if (item != null)
            {
                gfx = item.ItemID;
            }

            if (gfx == 0 || gfx >= 0x4000)
            {
                return;
            }
            
            InputDialogGump inputGump = new InputDialogGump(OnItemTargetAmountResponse, gfx, Language.GetString(LocString.EnterAmount),"1");
            inputGump.SendGump();
        }

        private bool OnItemTargetAmountResponse(int gfx, string input)
        {
            if (int.TryParse(input, out int amount))
            {
                RestockItem ri = new RestockItem((ushort) gfx, amount);
                AddItem(ri);

                if (_fromGump)
                {
                    _fromGump = false;

                    AgentsGump agent = new AgentsGump(this);
                    agent.SendGump();
                }
                else
                {
                    Engine.MainWindow.SafeAction(s => s.ShowMe());
                }

                return true;
            }

            if (_fromGump)
            {
                _fromGump = false;

                AgentsGump agent = new AgentsGump(this);
                agent.SendGump();
            }
            else
            {
                Engine.MainWindow.SafeAction(s => s.ShowMe());
            }

            return false;
        }

        private bool OnItemTargetChangeResponse(int restockId, string input)
        {
            if (int.TryParse(input, out int amount))
            {
                RestockItem ri = (RestockItem)Items[restockId];
                
                ri.Amount = amount;

                if (m_SubList != null)
                {
                    m_SubList.BeginUpdate();
                    m_SubList.Items.Clear();

                    for (int j = 0; j < Items.Count; j++)
                    {
                        m_SubList.Items.Add(Items[j]);
                    }

                    m_SubList.SelectedIndex = restockId;
                    m_SubList.EndUpdate();
                }

                if (_fromGump)
                {
                    _fromGump = false;

                    AgentsGump agent = new AgentsGump(this);
                    agent.SendGump();
                }
                else
                {
                    Engine.MainWindow.SafeAction(s => s.ShowMe());
                }

                return true;
            }

            if (_fromGump)
            {
                _fromGump = false;

                AgentsGump agent = new AgentsGump(this);
                agent.SendGump();
            }
            else
            {
                Engine.MainWindow.SafeAction(s => s.ShowMe());
            }

            return false;
        }

        public void AddItemTarget(bool fromGump = false)
        {
            _fromGump = fromGump;

            Targeting.OneTimeTarget(OnItemTarget);
            World.Player.SendMessage(MsgLevel.Force, LocString.TargItemAdd);
        }

        public void AddItem(RestockItem item)
        {
            foreach (RestockItem restockItem in Items)
            {
                if (restockItem.ItemID.Value == item.ItemID.Value)
                {
                    World.Player?.SendMessage(MsgLevel.Force, LocString.ItemExists);
                    return;
                }
            }

            Items.Add(item);
            m_SubList?.Items?.Add(item);

            World.Player?.SendMessage(MsgLevel.Force, LocString.ItemAdded);
        }

        public void RemoveItem(int itemId)
        {
            RestockItem item = Items.FirstOrDefault(a => a.ItemID == itemId);

            if (item != null)
            {
                Items.Remove(item);
                m_SubList?.Items?.Remove(item);

                World.Player?.SendMessage(MsgLevel.Force, LocString.ItemRemoved);
            }
        }

        public void SetItemAmount(int itemId, bool fromGump = false)
        {
            int itemIndex = Items.FindIndex(a => a.ItemID == itemId);
            RestockItem item = Items[itemIndex];

            if (item != null)
            {
                _fromGump = fromGump;

                InputDialogGump inputGump = new InputDialogGump(OnItemTargetChangeResponse, itemIndex, Language.GetString(LocString.EnterAmount), item.Amount.ToString());
                inputGump.SendGump();
            }
        }

        public override void Save(XmlTextWriter xml)
        {
            xml.WriteAttributeString("hotbag", m_HotBag.Value.ToString());
            xml.WriteAttributeString("alias", Alias);

            for (int i = 0; i < Items.Count; i++)
            {
                xml.WriteStartElement("item");
                RestockItem ri = (RestockItem) Items[i];
                xml.WriteAttributeString("id", ri.ItemID.Value.ToString());
                xml.WriteAttributeString("amount", ri.Amount.ToString());
                xml.WriteEndElement();
            }
        }

        public override void Load(XmlElement node)
        {
            try
            {
                m_HotBag = Convert.ToUInt32(node.GetAttribute("hotbag"));
            }
            catch
            {
                m_HotBag = Serial.Zero;
            }

            try
            {
                Alias = node.GetAttribute("alias");
            }
            catch
            {
                Alias = string.Empty;
            }

            foreach (XmlElement el in node.GetElementsByTagName("item"))
            {
                try
                {
                    string iid = el.GetAttribute("id");
                    string amt = el.GetAttribute("amount");
                    Items.Add(new RestockItem((ItemID) Convert.ToInt32(iid), Convert.ToInt32(amt)));
                }
                catch
                {
                    // ignored
                }
            }
        }

        public class RestockItem
        {
            public ItemID ItemID;
            public int Amount;

            public RestockItem(ItemID id, int amount)
            {
                ItemID = id;
                Amount = amount;
            }

            public override string ToString()
            {
                return $"{ItemID}\t\t{Amount}";
            }
        }
    }
}

================================================
FILE: Razor/Agents/ScavengerAgent.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Xml;
using Assistant.UI;

namespace Assistant.Agents
{
    public class ScavengerAgent : Agent
    {
        private static readonly ScavengerAgent m_Instance = new ScavengerAgent();

        public static ScavengerAgent Instance
        {
            get { return m_Instance; }
        }

        public static bool Debug = false;

        public static void Initialize()
        {
            Agent.Add(m_Instance);
        }

        private bool m_Enabled;
        private Serial m_Bag;
        private ListBox m_SubList;
        private Button m_EnButton;
        private readonly List<ItemID> m_Items;

        private List<Serial> m_Cache;
        private Item m_BagRef;

        public ScavengerAgent()
        {
            m_Items = new List<ItemID>();

            Number = 0;

            HotKey.Add(HKCategory.Agents, LocString.ClearScavCache, new HotKeyCallback(ClearCache));
            HotKey.Add(HKCategory.Agents, LocString.ScavengerEnableDisable, new HotKeyCallback(OnEnableDisable));
            HotKey.Add(HKCategory.Agents, LocString.ScavengerSetHotBag, new HotKeyCallback(OnSetHotBag));
            HotKey.Add(HKCategory.Agents, LocString.ScavengerAddTarget, new HotKeyCallback(OnAddToHotBag));

            PacketHandler.RegisterClientToServerViewer(0x09, new PacketViewerCallback(OnSingleClick));

            Agent.OnItemCreated += new ItemCreatedEventHandler(CheckBagOPL);
        }

        public void ToggleEnabled()
        {
            OnEnableDisable();
        }

        public void Disable()
        {
            m_Enabled = false;
            UpdateEnableButton();
            World.Player.SendMessage(MsgLevel.Force, "Scavenger Agent Disabled");
        }

        public void Enable()
        {
            m_Enabled = true;
            UpdateEnableButton();
            World.Player.SendMessage(MsgLevel.Force, "Scavenger Agent Enabled");
        }

        private void OnEnableDisable()
        {
            m_Enabled = !m_Enabled;
            UpdateEnableButton();

            if (m_Enabled)
            {
                World.Player.SendMessage(MsgLevel.Force, "Scavenger Agent Enabled");
            }
            else
            {
                World.Player.SendMessage(MsgLevel.Force, "Scavenger Agent Disabled");
            }
        }

        public void OnAddToHotBag()
        {
            World.Player.SendMessage(MsgLevel.Force, LocString.TargItemAdd);
            Targeting.OneTimeTarget(new Targeting.TargetResponseCallback(OnTarget));
        }

        public void OnSetHotBag()
        {
            World.Player.SendMessage(LocString.TargCont);
            Targeting.OneTimeTarget(new Targeting.TargetResponseCallback(OnTargetBag));
        }

        private void CheckBagOPL(Item item)
        {
            if (item.Serial == m_Bag)
            {
                item.ObjPropList.Add(Language.GetString(LocString.ScavengerHB));
            }
        }

        private void OnSingleClick(PacketReader pvSrc, PacketHandlerEventArgs args)
        {
            Serial serial = pvSrc.ReadUInt32();
            if (m_Bag == serial)
            {
                ushort gfx = 0;
                Item c = World.FindItem(m_Bag);
                if (c != null)
                {
                    gfx = c.ItemID.Value;
                }

                Client.Instance.SendToClient(new UnicodeMessage(m_Bag, gfx, Assistant.MessageType.Label, 0x3B2, 3,
                    Language.CliLocName, "", Language.GetString(LocString.ScavengerHB)));
            }
        }

        public override void Clear()
        {
            m_Items.Clear();
            m_BagRef = null;
        }

        public bool Enabled
        {
            get { return m_Enabled; }
        }

        public override string Name
        {
            get { return Language.GetString(LocString.Scavenger); }
        }

        public override string Alias { get; set; }

        public override int Number { get; }

        public override void OnSelected(ListBox subList, params Button[] buttons)
        {
            buttons[0].Text = Language.GetString(LocString.AddTarg);
            buttons[0].Visible = true;
            buttons[1].Text = Language.GetString(LocString.Remove);
            buttons[1].Visible = true;
            buttons[2].Text = Language.GetString(LocString.SetHB);
            buttons[2].Visible = true;
            buttons[3].Text = Language.GetString(LocString.ClearList);
            buttons[3].Visible = true;
            buttons[4].Text = Language.GetString(LocString.ClearScavCache);
            buttons[4].Visible = true;
            m_EnButton = buttons[5];
            m_EnButton.Visible = true;
            UpdateEnableButton();

            m_SubList = subList;
            subList.BeginUpdate();
            subList.Items.Clear();

            for (int i = 0; i < m_Items.Count; i++)
            {
                subList.Items.Add(m_Items[i]);
            }

            subList.EndUpdate();
        }

        private void UpdateEnableButton()
        {
            if (m_EnButton != null)
            {
                m_EnButton.Text = Language.GetString(m_Enabled ? LocString.PushDisable : LocString.PushEnable);
            }
        }

        public override void OnButtonPress(int num)
        {
            DebugLog("User pressed button {0}", num);
            switch (num)
            {
                case 1:
                    World.Player.SendMessage(MsgLevel.Force, LocString.TargItemAdd);
                    Targeting.OneTimeTarget(new Targeting.TargetResponseCallback(OnTarget));
                    break;
                case 2:
                    if (m_SubList.SelectedIndex >= 0 && m_SubList.SelectedIndex < m_Items.Count)
                    {
                        m_Items.RemoveAt(m_SubList.SelectedIndex);
                        m_SubList.Items.RemoveAt(m_SubList.SelectedIndex);
                    }

                    break;
                case 3:
                    World.Player.SendMessage(LocString.TargCont);
                    Targeting.OneTimeTarget(new Targeting.TargetResponseCallback(OnTargetBag));
                    break;
                case 4:
                    if (MessageBox.Show(Language.GetString(LocString.Confirm), Language.GetString(LocString.ClearList),
                            MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
                    {
                        m_SubList.Items.Clear();
                        m_Items.Clear();
                    }

                    break;
                case 5:
                    ClearCache();
                    break;
                case 6:
                    m_Enabled = !m_Enabled;
                    UpdateEnableButton();
                    break;
            }
        }

        public void ClearCache()
        {
            DebugLog("Clearing Cache of {0} items", m_Cache == null ? -1 : m_Cache.Count);
            if (m_Cache != null)
            {
                m_Cache.Clear();
            }

            if (World.Player != null)
            {
                World.Player.SendMessage(MsgLevel.Force, "Scavenger agent item cache cleared.");
            }
        }

        private void OnTarget(bool location, Serial serial, Point3D loc, ushort gfx)
        {
            Engine.MainWindow.SafeAction(s => s.ShowMe());

            if (location || !serial.IsItem)
            {
                return;
            }

            Item item = World.FindItem(serial);
            if (item == null)
            {
                return;
            }

            Add(item.ItemID);
        }

        public void Add(ItemID itemId)
        {
            m_Items?.Add(itemId);
            m_SubList?.Items.Add(itemId);

            DebugLog("Added item {0}", itemId);

            World.Player?.SendMessage(MsgLevel.Force, LocString.ItemAdded);
        }

        private void OnTargetBag(bool location, Serial serial, Point3D loc, ushort gfx)
        {
            Engine.MainWindow.SafeAction(s => s.ShowMe());

            if (location || !serial.IsItem)
            {
                return;
            }

            if (m_BagRef == null)
            {
                m_BagRef = World.FindItem(m_Bag);
            }

            if (m_BagRef != null)
            {
                m_BagRef.ObjPropList.Remove(Language.GetString(LocString.ScavengerHB));
                m_BagRef.OPLChanged();
            }

            DebugLog("Set bag to {0}", serial);
            m_Bag = serial;
            m_BagRef = World.FindItem(m_Bag);
            if (m_BagRef != null)
            {
                m_BagRef.ObjPropList.Add(Language.GetString(LocString.ScavengerHB));
                m_BagRef.OPLChanged();
            }

            World.Player.SendMessage(MsgLevel.Force, LocString.ContSet, m_Bag);
        }

        public void Uncache(Serial s)
        {
            if (m_Cache != null)
            {
                m_Cache.Remove(s);
            }
        }

        public void Scavenge(Item item)
        {
            DebugLog("Checking WorldItem {0} ...", item);
            if (!m_Enabled || !m_Items.Contains(item.ItemID) || World.Player.Backpack == null || World.Player.IsGhost ||
                World.Player.Weight >= World.Player.MaxWeight)
            {
                DebugLog("... skipped.");
                return;
            }

            if (m_Cache == null)
            {
                m_Cache = new List<Serial>();
            }
            else if (m_Cache.Count >= 190)
            {
                m_Cache.RemoveRange(0, 50);
            }

            if (m_Cache.Contains(item.Serial))
            {
                DebugLog("Item was cached.");
                return;
            }

            Item bag = m_BagRef;
            if (bag == null || bag.Deleted)
            {
                bag = m_BagRef = World.FindItem(m_Bag);
            }

            if (bag == null || bag.Deleted || !bag.IsChildOf(World.Player.Backpack))
            {
                bag = World.Player.Backpack;
            }

            m_Cache.Add(item.Serial);
            DragDropManager.DragDrop(item, bag);
            DebugLog("Dragging to {0}!", bag);
        }

        private static void DebugLog(string str, params object[] args)
        {
            if (Debug)
            {
                using (System.IO.StreamWriter w = new System.IO.StreamWriter("Scavenger.log", true))
                {
                    w.Write(Engine.MistedDateTime.ToString("HH:mm:ss.fff"));
                    w.Write(":: ");
                    w.WriteLine(str, args);
                    w.Flush();
                }
            }
        }

        public override void Save(XmlTextWriter xml)
        {
            xml.WriteAttributeString("enabled", m_Enabled.ToString());

            if (m_Bag != Serial.Zero)
            {
                xml.WriteStartElement("bag");
                xml.WriteAttributeString("serial", m_Bag.ToString());
                xml.WriteEndElement();
            }

            for (int i = 0; i < m_Items.Count; i++)
            {
                xml.WriteStartElement("item");
                xml.WriteAttributeString("id", ((ItemID) m_Items[i]).Value.ToString());
                xml.WriteEndElement();
            }
        }

        public override void Load(XmlElement node)
        {
            try
            {
                m_Enabled = bool.Parse(node.GetAttribute("enabled"));
            }
            catch
            {
                m_Enabled = false;
            }

            try
            {
                m_Bag = node["bag"] != null ? Serial.Parse(node["bag"].GetAttribute("serial")) : Serial.Zero;
            }
            catch
            {
                m_Bag = Serial.Zero;
            }

            foreach (XmlElement el in node.GetElementsByTagName("item"))
            {
                try
                {
                    string iid = el.GetAttribute("id");
                    m_Items.Add((ItemID) Convert.ToUInt16(iid));
                }
                catch
                {
                    // ignored
                }
            }
        }
    }
}

================================================
FILE: Razor/Agents/SearchExemptionAgent.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections;
using System.Windows.Forms;
using System.Xml;
using Assistant.UI;

namespace Assistant.Agents
{
    public class SearchExemptionAgent : Agent
    {
        public static int Count
        {
            get { return Instance.m_Items.Count; }
        }

        public static SearchExemptionAgent Instance { get; private set; }

        public static void Initialize()
        {
            Agent.Add(Instance = new SearchExemptionAgent());
        }

        public static bool IsExempt(Item item)
        {
            if (item == null || item.IsBagOfSending)
            {
                return true;
            }

            return Instance == null ? false : Instance.CheckExempt(item);
        }

        public static bool Contains(Item item)
        {
            return Instance == null
                ? false
                : Instance.m_Items.Contains(item.Serial) || Instance.m_Items.Contains(item.ItemID);
        }

        private ListBox m_SubList;
        private readonly ArrayList m_Items;

        public SearchExemptionAgent()
        {
            m_Items = new ArrayList();
        }

        public override void Clear()
        {
            m_Items.Clear();
        }

        private bool CheckExempt(Item item)
        {
            if (m_Items.Count > 0)
            {
                if (m_Items.Contains(item.Serial))
                {
                    return true;
                }
                else if (m_Items.Contains(item.ItemID))
                {
                    return true;
                }
                else if (item.Container != null && item.Container is Item)
                {
                    return CheckExempt((Item) item.Container);
                }
            }

            return false;
        }

        public override string Name
        {
            get { return Language.GetString(LocString.AutoSearchEx); }
        }

        public override string Alias { get; set; }

        public override int Number { get; }

        public override void OnSelected(ListBox subList, params Button[] buttons)
        {
            m_SubList = subList;

            buttons[0].Text = Language.GetString(LocString.AddTarg);
            buttons[0].Visible = true;
            buttons[1].Text = Language.GetString(LocString.AddTargType);
            buttons[1].Visible = true;
            buttons[2].Text = Language.GetString(LocString.Remove);
            buttons[2].Visible = true;
            buttons[3].Text = Language.GetString(LocString.RemoveTarg);
            buttons[3].Visible = true;
            buttons[4].Text = Language.GetString(LocString.ClearList);
            buttons[4].Visible = true;

            m_SubList.BeginUpdate();
            m_SubList.Items.Clear();

            for (int i = 0; i < m_Items.Count; i++)
            {
                Item item = null;
                if (m_Items[i] is Serial)
                {
                    item = World.FindItem((Serial) m_Items[i]);
                }

                if (item != null)
                {
                    m_SubList.Items.Add(item.ToString());
                }
                else
                {
                    m_SubList.Items.Add(m_Items[i].ToString());
                }
            }

            m_SubList.EndUpdate();
        }

        public override void OnButtonPress(int num)
        {
            switch (num)
            {
                case 1:
                    World.Player.SendMessage(MsgLevel.Force, LocString.TargItemAdd);
                    Targeting.OneTimeTarget(new Targeting.TargetResponseCallback(OnTarget));
                    break;
                case 2:
                    World.Player.SendMessage(MsgLevel.Force, LocString.TargItemAdd);
                    Targeting.OneTimeTarget(new Targeting.TargetResponseCallback(OnTargetType));
                    break;
                case 3:
                    if (m_SubList.SelectedIndex >= 0 && m_SubList.SelectedIndex < m_Items.Count)
                    {
                        m_Items.RemoveAt(m_SubList.SelectedIndex);
                        m_SubList.Items.RemoveAt(m_SubList.SelectedIndex);
                    }

                    break;
                case 4:
                    World.Player.SendMessage(MsgLevel.Force, LocString.TargItemRem);
                    Targeting.OneTimeTarget(new Targeting.TargetResponseCallback(OnTargetRemove));
                    break;
                case 5:
                    if (MessageBox.Show(Language.GetString(LocString.Confirm), Language.GetString(LocString.ClearList),
                            MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
                    {
                        m_SubList.Items.Clear();
                        m_Items.Clear();
                    }

                    break;
            }
        }

        private void OnTarget(bool location, Serial serial, Point3D loc, ushort gfx)
        {
            Engine.MainWindow.SafeAction(s => s.ShowMe());
            if (!location && serial.IsItem)
            {
                m_Items.Add(serial);

                Item item = World.FindItem(serial);
                if (item != null)
                {
                    Client.Instance.SendToClient(new ContainerItem(item));
                    m_SubList.Items.Add(item.ToString());
                }
                else
                {
                    m_SubList.Items.Add(serial.ToString());
                }

                World.Player.SendMessage(MsgLevel.Force, LocString.ItemAdded);
            }
        }

        private void OnTargetType(bool location, Serial serial, Point3D loc, ushort gfx)
        {
            Engine.MainWindow.SafeAction(s => s.ShowMe());

            if (!serial.IsItem)
            {
                return;
            }

            m_Items.Add((ItemID) gfx);
            m_SubList.Items.Add(((ItemID) gfx).ToString());
            World.Player.SendMessage(MsgLevel.Force, LocString.ItemAdded);
        }

        private void OnTargetRemove(bool location, Serial serial, Point3D loc, ushort gfx)
        {
            Engine.MainWindow.SafeAction(s => s.ShowMe());
            if (!location && serial.IsItem)
            {
                for (int i = 0; i < m_Items.Count; i++)
                {
                    if (m_Items[i] is Serial && (Serial) m_Items[i] == serial)
                    {
                        m_Items.RemoveAt(i);
                        m_SubList.Items.RemoveAt(i);
                        World.Player.SendMessage(MsgLevel.Force, LocString.ItemRemoved);

                        Item item = World.FindItem(serial);
                        if (item != null)
                        {
                            Client.Instance.SendToClient(new ContainerItem(item));
                        }

                        return;
                    }
                }

                World.Player.SendMessage(MsgLevel.Force, LocString.ItemNotFound);
            }
        }

        public override void Save(XmlTextWriter xml)
        {
            for (int i = 0; i < m_Items.Count; i++)
            {
                xml.WriteStartElement("item");
                if (m_Items[i] is Serial)
                {
                    xml.WriteAttributeString("serial", ((Serial) m_Items[i]).Value.ToString());
                }
                else
                {
                    xml.WriteAttributeString("id", ((ItemID) m_Items[i]).Value.ToString());
                }

                xml.WriteEndElement();
            }
        }

        public override void Load(XmlElement node)
        {
            foreach (XmlElement el in node.GetElementsByTagName("item"))
            {
                try
                {
                    string ser = el.GetAttribute("serial");
                    string iid = el.GetAttribute("id");

                    if (!string.IsNullOrEmpty(ser))
                    {
                        m_Items.Add((Serial) Convert.ToUInt32(ser));
                    }
                    else if (!string.IsNullOrEmpty(iid))
                    {
                        m_Items.Add((ItemID) Convert.ToUInt16(iid));
                    }
                }
                catch
                {
                    // ignored
                }
            }
        }
    }
}

================================================
FILE: Razor/Agents/SellAgent.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Xml;
using Assistant.Gumps.Internal;
using Assistant.UI;

namespace Assistant.Agents
{
    public class SellAgent : Agent
    {
        public static SellAgent Instance { get; private set; }

        public static void Initialize()
        {
            Agent.Add(Instance = new SellAgent());
        }

        private ListBox m_SubList;
        private Button m_EnableBTN;
        private Button m_HotBTN;
        private Button m_AmountButton;
        private readonly List<ushort> m_Items;
        private Serial m_HotBag;
        private bool m_Enabled;
        
        public SellAgent()
        {
            m_Items = new List<ushort>();
            PacketHandler.RegisterServerToClientViewer(0x9E, new PacketViewerCallback(OnVendorSell));
            PacketHandler.RegisterClientToServerViewer(0x09, new PacketViewerCallback(OnSingleClick));

            Number = 0;

            HotKey.Add(HKCategory.Agents, HKSubCat.None, Language.GetString(LocString.SetSellAgentHotBag),
                new HotKeyCallback(SetHotBag));

            Agent.OnItemCreated += new ItemCreatedEventHandler(CheckHBOPL);
        }

        private void CheckHBOPL(Item item)
        {
            if (item.Serial == m_HotBag)
            {
                item.ObjPropList.Add(Language.GetString(LocString.SellHB));
            }
        }

        private void OnSingleClick(PacketReader pvSrc, PacketHandlerEventArgs args)
        {
            Serial serial = pvSrc.ReadUInt32();
            if (m_HotBag == serial)
            {
                ushort gfx = 0;
                Item c = World.FindItem(m_HotBag);
                if (c != null)
                {
                    gfx = c.ItemID.Value;
                }

                Client.Instance.SendToClient(new UnicodeMessage(m_HotBag, gfx, Assistant.MessageType.Label, 0x3B2, 3,
                    Language.CliLocName, "", Language.GetString(LocString.SellHB)));
            }
        }

        public override void Clear()
        {
            m_Items.Clear();
        }

        private void OnVendorSell(PacketReader pvSrc, PacketHandlerEventArgs args)
        {
            if (!m_Enabled || !Client.Instance.AllowBit(FeatureBit.SellAgent) ||
                (m_Items.Count == 0 && m_HotBag == Serial.Zero))
            {
                return;
            }

            Item hb = null;
            if (m_HotBag != Serial.Zero)
            {
                hb = World.FindItem(m_HotBag);
                if (hb == null)
                {
                    //m_HotBag = Serial.Zero;
                    //SetHBText();
                    World.Player.SendMessage(MsgLevel.Warning, "Sell Agent HotBag could not be found.");

                    if (m_Items.Count == 0)
                    {
                        return;
                    }
                }
            }

            int total = 0;

            uint serial = pvSrc.ReadUInt32();
            Mobile vendor = World.FindMobile(serial);
            if (vendor == null)
            {
                World.AddMobile(vendor = new Mobile(serial));
            }

            int count = pvSrc.ReadUInt16();

            int maxSell = Config.GetInt("SellAgentMax");
            int sold = 0;
            List<SellListItem> list = new List<SellListItem>(count);
            for (int i = 0; i < count && (sold < maxSell || maxSell <= 0); i++)
            {
                uint ser = pvSrc.ReadUInt32();
                ushort gfx = pvSrc.ReadUInt16();
                ushort hue = pvSrc.ReadUInt16();
                ushort amount = pvSrc.ReadUInt16();
                ushort price = pvSrc.ReadUInt16();

                pvSrc.ReadString(pvSrc.ReadUInt16()); //name

                Item item = World.FindItem(ser);

                if (m_Items.Contains(gfx) || (item != null && item != hb && item.IsChildOf(hb)))
                {
                    if (sold + amount > maxSell && maxSell > 0)
                    {
                        amount = (ushort) (maxSell - sold);
                    }

                    list.Add(new SellListItem(ser, amount));
                    total += amount * price;
                    sold += amount;
                }

                //if ( sold >= maxSell && maxSell > 0 ) break;
            }

            if (list.Count > 0)
            {
                Client.Instance.SendToServer(new VendorSellResponse(vendor, list));
                World.Player.SendMessage(MsgLevel.Force, LocString.SellTotals, sold, total);
                args.Block = true;
            }
        }

        public override string Name
        {
            get { return Language.GetString(LocString.Sell); }
        }

        public override string Alias { get; set; }

        public override int Number { get; }

        public override void OnSelected(ListBox subList, params Button[] buttons)
        {
            m_SubList = subList;
            m_EnableBTN = buttons[5];
            m_HotBTN = buttons[2];
            m_AmountButton = buttons[4];

            buttons[0].Text = Language.GetString(LocString.AddTarg);
            buttons[0].Visible = true;
            buttons[1].Text = Language.GetString(LocString.Remove);
            buttons[1].Visible = true;
            //button[2] = hotbutton
            buttons[2].Visible = true;
            buttons[3].Text = Language.GetString(LocString.Clear);
            buttons[3].Visible = true;
            m_AmountButton.Text = Language.Format(LocString.SellAmount, Config.GetInt("SellAgentMax"));
            buttons[4].Visible = true;
            buttons[5].Text = Language.GetString(m_Enabled ? LocString.PushDisable : LocString.PushEnable);
            buttons[5].Visible = true;

            SetHBText();
            m_SubList.BeginUpdate();
            m_SubList.Items.Clear();
            for (int i = 0; i < m_Items.Count; i++)
            {
                m_SubList.Items.Add((ItemID) ((ushort) m_Items[i]));
            }

            m_SubList.EndUpdate();

            if (!Client.Instance.AllowBit(FeatureBit.SellAgent) && Engine.MainWindow != null)
            {
                for (int i = 0; i < buttons.Length; i++)
                {
                    Engine.MainWindow.SafeAction(s => s.LockControl(buttons[i]));
                }

                Engine.MainWindow.SafeAction(s => s.LockControl(subList));
            }
        }

        public override void OnButtonPress(int num)
        {
            switch (num)
            {
                case 1:
                    World.Player.SendMessage(MsgLevel.Force, LocString.TargItemAdd);
                    Targeting.OneTimeTarget(new Targeting.TargetResponseCallback(OnTarget));
                    break;
                case 2:
                    if (m_SubList.SelectedIndex >= 0)
                    {
                        m_Items.RemoveAt(m_SubList.SelectedIndex);
                        m_SubList.Items.RemoveAt(m_SubList.SelectedIndex);
                        m_SubList.SelectedIndex = -1;
                    }

                    break;
                case 3:
                    if (m_HotBag == Serial.Zero)
                    {
                        World.Player.SendMessage(MsgLevel.Force, LocString.TargCont);
                        Targeting.OneTimeTarget(new Targeting.TargetResponseCallback(OnHBTarget));
                    }
                    else
                    {
                        Item hb = World.FindItem(m_HotBag);
                        if (hb != null)
                        {
                            if (hb.ObjPropList.Remove(Language.GetString(LocString.SellHB)))
                            {
                                hb.OPLChanged();
                            }
                        }

                        m_HotBag = Serial.Zero;
                        SetHBText();
                    }

                    break;
                case 4:
                    if (MessageBox.Show(Language.GetString(LocString.Confirm), Language.GetString(LocString.ClearList),
                            MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
                    {
                        m_SubList.Items.Clear();
                        m_Items.Clear();
                    }

                    break;
                case 5:

                    InputDialogGump gump = new InputDialogGump(OnChangeSellMaxAmount, 0, Language.GetString(LocString.EnterAmount), Config.GetInt("SellAgentMax").ToString());
                    gump.SendGump();

                    break;
                case 6:
                    m_Enabled = !m_Enabled;
                    m_EnableBTN.Text = Language.GetString(m_Enabled ? LocString.PushDisable : LocString.PushEnable);
                    break;
            }
        }
        
        private bool OnChangeSellMaxAmount(int gfx, string amount)
        {
            if (int.TryParse(amount, out int parsedAmount))
            {
                Config.SetProperty("SellAgentMax", parsedAmount);
                m_AmountButton.Text = Language.Format(LocString.SellAmount, Config.GetInt("SellAgentMax"));

                return true;
            }

            return false;
        }

        private void SetHBText()
        {
            m_HotBTN?.SafeAction(s =>
            {
                s.Text = Language.GetString(m_HotBag == Serial.Zero ? LocString.SetHB : LocString.ClearHB);
            });
        }

        private void OnTarget(bool location, Serial serial, Point3D loc, ushort gfx)
        {
            Engine.MainWindow.SafeAction(s => s.ShowMe());
            if (!location && serial.IsItem)
            {
                Add(gfx);
            }
        }

        public void Add(ItemID itemId)
        {
            m_Items?.Add(itemId);
            m_SubList?.Items.Add((ItemID)itemId);

            World.Player?.SendMessage(MsgLevel.Force, LocString.ItemAdded);
        }

        private void OnHBTarget(bool location, Serial serial, Point3D loc, ushort gfx)
        {
            Engine.MainWindow.SafeAction(s => s.ShowMe());
            if (!location && serial.IsItem)
            {
                m_HotBag = serial;
                SetHBText();

                Item hb = World.FindItem(m_HotBag);
                if (hb != null)
                {
                    hb.ObjPropList.Add(Language.GetString(LocString.SellHB));
                    hb.OPLChanged();
                }
            }
        }

        public void SetHotBag()
        {
            World.Player.SendMessage(MsgLevel.Force, LocString.TargCont);
            Targeting.OneTimeTarget(new Targeting.TargetResponseCallback(OnHBTarget));
        }

        /*private void OnHBTarget(bool location, Serial serial, Point3D loc, ushort gfx)
        {
            Engine.MainWindow.SafeAction(s => s.ShowMe(););

            Item hb = World.FindItem(m_HotBag);
            if (hb != null)
            {
                if (hb.ObjPropList.Remove(Language.Format(LocString.RestockHBA1, m_Num)))
                {
                    hb.OPLChanged();
                }
            }

            if (!location && serial.IsItem)
            {
                m_HotBag = serial;
            }
            else
            {
                m_HotBag = Serial.Zero;
            }

            hb = World.FindItem(m_HotBag);
            if (hb != null)
            {
                hb.ObjPropList.Add(Language.Format(LocString.RestockHBA1, m_Num));
                hb.OPLChanged();
            }

            SetHBText();
        }*/

        public override void Save(XmlTextWriter xml)
        {
            if (m_Items == null)
            {
                return;
            }

            xml.WriteAttributeString("enabled", m_Enabled.ToString());

            if (m_HotBag != Serial.Zero)
            {
                xml.WriteStartElement("hotbag");
                xml.WriteString(m_HotBag.ToString());
                xml.WriteEndElement();
            }

            foreach (ushort iid in m_Items)
            {
                xml.WriteStartElement("item");
                xml.WriteAttributeString("id", iid.ToString());
                xml.WriteEndElement();
            }
        }


        public override void Load(XmlElement node)
        {
            try
            {
                m_Enabled = bool.Parse(node.GetAttribute("enabled"));
            }
            catch
            {
                m_Enabled = false;
            }

            try
            {
                m_HotBag = node["hotbag"] != null ? Serial.Parse(node["hotbag"].InnerText) : Serial.Zero;
            }
            catch
            {
                m_HotBag = Serial.Zero;
            }

            foreach (XmlElement el in node.GetElementsByTagName("item"))
            {
                try
                {
                    string str = el.GetAttribute("id");
                    m_Items.Add(Convert.ToUInt16(str));
                }
                catch
                {
                    // ignored
                }
            }
        }
    }
}

================================================
FILE: Razor/Agents/UseOnceAgent.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections;
using System.Windows.Forms;
using System.Xml;
using Assistant.UI;

namespace Assistant.Agents
{
    public class UseOnceAgent : Agent
    {
        public static UseOnceAgent Instance { get; private set; }

        public static void Initialize()
        {
            Agent.Add(Instance = new UseOnceAgent());
        }

        private ListBox m_SubList;
        private readonly ArrayList m_Items;

        public UseOnceAgent()
        {
            m_Items = new ArrayList();
            PacketHandler.RegisterClientToServerViewer(0x09, new PacketViewerCallback(OnSingleClick));
            HotKey.Add(HKCategory.Agents, LocString.UseOnceAgent, new HotKeyCallback(OnHotKey));
            HotKey.Add(HKCategory.Agents, LocString.AddUseOnce, new HotKeyCallback(OnAdd));
            HotKey.Add(HKCategory.Agents, LocString.AddUseOnceContainer, new HotKeyCallback(OnAddContainer));

            Number = 0;

            Agent.OnItemCreated += new ItemCreatedEventHandler(CheckItemOPL);
        }

        public override void Clear()
        {
            m_Items.Clear();
        }

        private void CheckItemOPL(Item newItem)
        {
            for (int i = 0; i < m_Items.Count; i++)
            {
                if (m_Items[i] is Serial)
                {
                    if (newItem.Serial == (Serial) m_Items[i])
                    {
                        m_Items[i] = newItem;
                        newItem.ObjPropList.Add(Language.GetString(LocString.UseOnce));
                        break;
                    }
                }
            }
        }

        private void OnSingleClick(PacketReader pvSrc, PacketHandlerEventArgs args)
        {
            Serial serial = pvSrc.ReadUInt32();
            for (int i = 0; i < m_Items.Count; i++)
            {
                Item item;
                if (m_Items[i] is Serial)
                {
                    item = World.FindItem((Serial) m_Items[i]);
                    if (item != null)
                    {
                        m_Items[i] = item;
                    }
                }

                item = m_Items[i] as Item;
                if (item == null)
                {
                    continue;
                }

                if (item.Serial == serial)
                {
                    Client.Instance.SendToClient(new UnicodeMessage(item.Serial, item.ItemID,
                        Assistant.MessageType.Label, 0x3B2, 3, Language.CliLocName, "",
                        Language.Format(LocString.UseOnceHBA1, i + 1)));
                    break;
                }
            }
        }

        public override string Name
        {
            get { return Language.GetString(LocString.UseOnce); }
        }

        public override string Alias { get; set; }

        public override int Number { get; }

        public override void OnSelected(ListBox subList, params Button[] buttons)
        {
            m_SubList = subList;
            buttons[0].Text = Language.GetString(LocString.AddTarg);
            buttons[0].Visible = true;
            buttons[1].Text = Language.GetString(LocString.AddContTarg);
            buttons[1].Visible = true;
            buttons[2].Text = Language.GetString(LocString.RemoveTarg);
            buttons[2].Visible = true;
            buttons[3].Text = Language.GetString(LocString.ClearList);
            buttons[3].Visible = true;

            m_SubList.BeginUpdate();
            m_SubList.Items.Clear();

            for (int i = 0; i < m_Items.Count; i++)
            {
                if (m_Items[i] is Serial)
                {
                    Item item = World.FindItem((Serial) m_Items[i]);
                    if (item != null)
                    {
                        m_Items[i] = item;
                    }
                }

                m_SubList.Items.Add(m_Items[i]);
            }

            m_SubList.EndUpdate();

            if (!Client.Instance.AllowBit(FeatureBit.UseOnceAgent) && Engine.MainWindow != null)
            {
                for (int i = 0; i < buttons.Length; i++)
                {
                    Engine.MainWindow.SafeAction(s => s.LockControl(buttons[i]));
                }

                Engine.MainWindow.SafeAction(s => s.LockControl(subList));
            }
        }

        public override void OnButtonPress(int num)
        {
            switch (num)
            {
                case 1:
                    OnAdd();
                    break;
                case 2:
                    World.Player.SendMessage(MsgLevel.Force, LocString.TargCont);
                    Targeting.OneTimeTarget(new Targeting.TargetResponseCallback(OnTargetBag));
                    break;
                case 3:
                    World.Player.SendMessage(MsgLevel.Force, LocString.TargItemRem);
                    Targeting.OneTimeTarget(new Targeting.TargetResponseCallback(OnTargetRemove));
                    break;
                case 4:

                    if (MessageBox.Show(Language.GetString(LocString.Confirm), Language.GetString(LocString.ClearList),
                            MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
                    {
                        for (int i = 0; i < m_Items.Count; i++)
                        {
                            if (m_Items[i] is Item)
                            {
                                Item item = (Item) m_Items[i];

                                item.ObjPropList.Remove(Language.GetString(LocString.UseOnce));
                                item.OPLChanged();
                            }
                        }

                        m_SubList.Items.Clear();
                        m_Items.Clear();
                    }

                    break;
            }
        }

        public void OnAdd()
        {
            World.Player.SendMessage(MsgLevel.Force, LocString.TargItemAdd);
            Targeting.OneTimeTarget(new Targeting.TargetResponseCallback(OnTarget));
        }

        public void OnAddContainer()
        {
            World.Player.SendMessage(MsgLevel.Force, LocString.TargItemAdd);
            Targeting.OneTimeTarget(new Targeting.TargetResponseCallback(OnTargetBag));
        }

        private void OnTarget(bool location, Serial serial, Point3D loc, ushort gfx)
        {
            if (Config.GetBool("AlwaysOnTop"))
            {
                Engine.MainWindow.SafeAction(s => s.ShowMe());
            }

            if (!location && serial.IsItem)
            {
                Item item = World.FindItem(serial);
                if (item == null)
                {
                    World.Player.SendMessage(MsgLevel.Force, LocString.ItemNotFound);
                    return;
                }

                item.ObjPropList.Add(Language.GetString(LocString.UseOnce));
                item.OPLChanged();

                m_Items.Add(item);
                if (m_SubList != null)
                {
                    m_SubList.Items.Add(item);
                }

                World.Player.SendMessage(MsgLevel.Force, LocString.ItemAdded);
            }
        }

        private void OnTargetRemove(bool location, Serial serial, Point3D loc, ushort gfx)
        {
            Engine.MainWindow.SafeAction(s => s.ShowMe());
            if (!location && serial.IsItem)
            {
                for (int i = 0; i < m_Items.Count; i++)
                {
                    bool rem = false;
                    if (m_Items[i] is Item)
                    {
                        if (((Item) m_Items[i]).Serial == serial)
                        {
                            ((Item) m_Items[i]).ObjPropList.Remove(Language.GetString(LocString.UseOnce));
                            ((Item) m_Items[i]).OPLChanged();

                            rem = true;
                        }
                    }
                    else if (m_Items[i] is Serial)
                    {
                        if (((Serial) m_Items[i]) == serial)
                        {
                            rem = true;
                        }
                    }

                    if (rem)
                    {
                        m_Items.RemoveAt(i);
                        m_SubList.Items.RemoveAt(i);
                        World.Player.SendMessage(MsgLevel.Force, LocString.ItemRemoved);
                        return;
                    }
                }

                World.Player.SendMessage(MsgLevel.Force, LocString.ItemNotFound);
            }
        }

        private void OnTargetBag(bool location, Serial serial, Point3D loc, ushort gfx)
        {
            if (Config.GetBool("AlwaysOnTop"))
            {
                Engine.MainWindow.SafeAction(s => s.ShowMe());
            }

            Engine.MainWindow.SafeAction(s => s.ShowMe());
            if (!location && serial.IsItem)
            {
                Item i = World.FindItem(serial);
                if (i != null && i.Contains.Count > 0)
                {
                    for (int ci = 0; ci < i.Contains.Count; ci++)
                    {
                        Item toAdd = i.Contains[ci] as Item;

                        if (toAdd != null)
                        {
                            toAdd.ObjPropList.Add(Language.GetString(LocString.UseOnce));
                            toAdd.OPLChanged();
                            m_Items.Add(toAdd);

                            if (m_SubList != null)
                            {
                                m_SubList.Items.Add(toAdd);
                            }
                        }
                    }

                    World.Player.SendMessage(MsgLevel.Force, LocString.ItemsAdded, i.Contains.Count);
                }
            }
        }

        public override void Save(XmlTextWriter xml)
        {
            for (int i = 0; i < m_Items.Count; i++)
            {
                xml.WriteStartElement("item");
                if (m_Items[i] is Item)
                {
                    xml.WriteAttributeString("serial", ((Item) m_Items[i]).Serial.Value.ToString());
                }
                else
                {
                    xml.WriteAttributeString("serial", ((Serial) m_Items[i]).Value.ToString());
                }

                xml.WriteEndElement();
            }
        }

        public override void Load(XmlElement node)
        {
            foreach (XmlElement el in node.GetElementsByTagName("item"))
            {
                try
                {
                    string ser = el.GetAttribute("serial");
                    m_Items.Add((Serial) Convert.ToUInt32(ser));
                }
                catch
                {
                    // ignored
                }
            }
        }

        public void OnHotKey()
        {
            if (World.Player == null || !Client.Instance.AllowBit(FeatureBit.UseOnceAgent))
            {
                return;
            }

            if (m_Items.Count <= 0)
            {
                World.Player.SendMessage(MsgLevel.Error, LocString.UseOnceEmpty);
            }
            else
            {
                Item item = null;
                if (m_Items[0] is Item)
                {
                    item = (Item) m_Items[0];
                }
                else if (m_Items[0] is Serial)
                {
                    item = World.FindItem((Serial) m_Items[0]);
                }

                try
                {
                    m_Items.RemoveAt(0);
                    if (m_SubList != null && m_SubList.Items.Count > 0)
                    {
                        m_SubList.Items.RemoveAt(0);
                    }
                }
                catch
                {
                }

                if (item != null)
                {
                    item.ObjPropList.Remove(Language.GetString(LocString.UseOnce));
                    item.OPLChanged();

                    World.Player.SendMessage(LocString.UseOnceStatus, item, m_Items.Count);
                    PlayerData.DoubleClick(item);
                }
                else
                {
                    World.Player.SendMessage(LocString.UseOnceError);
                    OnHotKey();
                }
            }
        }
    }
}

================================================
FILE: Razor/Boat/BoatWindow.Designer.cs
================================================
using System.Windows.Forms;

namespace Assistant.Boat
{
    partial class BoatWindow
    {
        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(BoatWindow));
            this.boatNorth = new System.Windows.Forms.PictureBox();
            this.boatNortheast = new System.Windows.Forms.PictureBox();
            this.boatEast = new System.Windows.Forms.PictureBox();
            this.boatSoutheast = new System.Windows.Forms.PictureBox();
            this.boatSouth = new System.Windows.Forms.PictureBox();
            this.boatSouthwest = new System.Windows.Forms.PictureBox();
            this.boatWest = new System.Windows.Forms.PictureBox();
            this.boatNorthwest = new System.Windows.Forms.PictureBox();
            this.boatAnchor = new System.Windows.Forms.PictureBox();
            this.boatT2a = new System.Windows.Forms.PictureBox();
            this.boatSpeedNormal = new System.Windows.Forms.RadioButton();
            this.boatSpeedSlow = new System.Windows.Forms.RadioButton();
            this.boatSpeedOne = new System.Windows.Forms.RadioButton();
            this.boatStop = new System.Windows.Forms.PictureBox();
            this.boatTurnRight = new System.Windows.Forms.PictureBox();
            this.boatTurnLeft = new System.Windows.Forms.PictureBox();
            this.boatTurnAround = new System.Windows.Forms.PictureBox();
            this.boatGoto1 = new System.Windows.Forms.Button();
            this.boatGoto2 = new System.Windows.Forms.Button();
            this.boatGoto3 = new System.Windows.Forms.Button();
            this.boatGoto4 = new System.Windows.Forms.Button();
            this.boatGoto5 = new System.Windows.Forms.Button();
            this.boatGoto6 = new System.Windows.Forms.Button();
            this.boatGoto7 = new System.Windows.Forms.Button();
            this.boatGoto8 = new System.Windows.Forms.Button();
            this.boatGoto9 = new System.Windows.Forms.Button();
            this.boatStart = new System.Windows.Forms.Button();
            this.boatContinue = new System.Windows.Forms.Button();
            this.boatNav = new System.Windows.Forms.Button();
            this.alwaysOnTop = new System.Windows.Forms.CheckBox();
            this.boatBorder = new System.Windows.Forms.PictureBox();
            this.boatWindowsBorder = new System.Windows.Forms.CheckBox();
            this.boatClose = new System.Windows.Forms.Label();
            ((System.ComponentModel.ISupportInitialize)(this.boatNorth)).BeginInit();
            ((System.ComponentModel.ISupportInitialize)(this.boatNortheast)).BeginInit();
            ((System.ComponentModel.ISupportInitialize)(this.boatEast)).BeginInit();
            ((System.ComponentModel.ISupportInitialize)(this.boatSoutheast)).BeginInit();
            ((System.ComponentModel.ISupportInitialize)(this.boatSouth)).BeginInit();
            ((System.ComponentModel.ISupportInitialize)(this.boatSouthwest)).BeginInit();
            ((System.ComponentModel.ISupportInitialize)(this.boatWest)).BeginInit();
            ((System.ComponentModel.ISupportInitialize)(this.boatNorthwest)).BeginInit();
            ((System.ComponentModel.ISupportInitialize)(this.boatAnchor)).BeginInit();
            ((System.ComponentModel.ISupportInitialize)(this.boatT2a)).BeginInit();
            ((System.ComponentModel.ISupportInitialize)(this.boatStop)).BeginInit();
            ((System.ComponentModel.ISupportInitialize)(this.boatTurnRight)).BeginInit();
            ((System.ComponentModel.ISupportInitialize)(this.boatTurnLeft)).BeginInit();
            ((System.ComponentModel.ISupportInitialize)(this.boatTurnAround)).BeginInit();
            ((System.ComponentModel.ISupportInitialize)(this.boatBorder)).BeginInit();
            this.SuspendLayout();
            // 
            // boatNorth
            // 
            this.boatNorth.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
            this.boatNorth.Image = ((System.Drawing.Image)(resources.GetObject("boatNorth.Image")));
            this.boatNorth.Location = new System.Drawing.Point(80, 40);
            this.boatNorth.Name = "boatNorth";
            this.boatNorth.Size = new System.Drawing.Size(27, 28);
            this.boatNorth.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage;
            this.boatNorth.TabIndex = 0;
            this.boatNorth.TabStop = false;
            this.boatNorth.MouseClick += new System.Windows.Forms.MouseEventHandler(this.boatNorth_MouseClick);
            // 
            // boatNortheast
            // 
            this.boatNortheast.Image = ((System.Drawing.Image)(resources.GetObject("boatNortheast.Image")));
            this.boatNortheast.Location = new System.Drawing.Point(113, 40);
            this.boatNortheast.Name = "boatNortheast";
            this.boatNortheast.Size = new System.Drawing.Size(27, 28);
            this.boatNortheast.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage;
            this.boatNortheast.TabIndex = 1;
            this.boatNortheast.TabStop = false;
            this.boatNortheast.MouseClick += new MouseEventHandler(this.boatNortheast_Click);
            // 
            // boatEast
            // 
            this.boatEast.Image = ((System.Drawing.Image)(resources.GetObject("boatEast.Image")));
            this.boatEast.Location = new System.Drawing.Point(113, 74);
            this.boatEast.Name = "boatEast";
            this.boatEast.Size = new System.Drawing.Size(27, 28);
            this.boatEast.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage;
            this.boatEast.TabIndex = 2;
            this.boatEast.TabStop = false;
            this.boatEast.Click += new System.EventHandler(this.boatEast_Click);
            // 
            // boatSoutheast
            // 
            this.boatSoutheast.Image = ((System.Drawing.Image)(resources.GetObject("boatSoutheast.Image")));
            this.boatSoutheast.Location = new System.Drawing.Point(113, 108);
            this.boatSoutheast.Name = "boatSoutheast";
            this.boatSoutheast.Size = new System.Drawing.Size(27, 28);
            this.boatSoutheast.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage;
            this.boatSoutheast.TabIndex = 3;
            this.boatSoutheast.TabStop = false;
            this.boatSoutheast.MouseClick += new MouseEventHandler(this.boatSoutheast_Click);
            // 
            // boatSouth
            // 
            this.boatSouth.Image = ((System.Drawing.Image)(resources.GetObject("boatSouth.Image")));
            this.boatSouth.Location = new System.Drawing.Point(80, 108);
            this.boatSouth.Name = "boatSouth";
            this.boatSouth.Size = new System.Drawing.Size(27, 28);
            this.boatSouth.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage;
            this.boatSouth.TabIndex = 4;
            this.boatSouth.TabStop = false;
            this.boatSouth.Click += new System.EventHandler(this.boatSouth_Click);
            // 
            // boatSouthwest
            // 
            this.boatSouthwest.Image = ((System.Drawing.Image)(resources.GetObject("boatSouthwest.Image")));
            this.boatSouthwest.Location = new System.Drawing.Point(47, 108);
            this.boatSouthwest.Name = "boatSouthwest";
            this.boatSouthwest.Size = new System.Drawing.Size(27, 28);
            this.boatSouthwest.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage;
            this.boatSouthwest.TabIndex = 5;
            this.boatSouthwest.TabStop = false;
            this.boatSouthwest.MouseClick += new MouseEventHandler(this.boatSouthwest_Click);
            // 
            // boatWest
            // 
            this.boatWest.Image = ((System.Drawing.Image)(resources.GetObject("boatWest.Image")));
            this.boatWest.Location = new System.Drawing.Point(47, 74);
            this.boatWest.Name = "boatWest";
            this.boatWest.Size = new System.Drawing.Size(27, 28);
            this.boatWest.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage;
            this.boatWest.TabIndex = 6;
            this.boatWest.TabStop = false;
            this.boatWest.Click += new System.EventHandler(this.boatWest_Click);
            // 
            // boatNorthwest
            // 
            this.boatNorthwest.Image = ((System.Drawing.Image)(resources.GetObject("boatNorthwest.Image")));
            this.boatNorthwest.Location = new System.Drawing.Point(47, 40);
            this.boatNorthwest.Name = "boatNorthwest";
            this.boatNorthwest.Size = new System.Drawing.Size(27, 28);
            this.boatNorthwest.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage;
            this.boatNorthwest.TabIndex = 7;
            this.boatNorthwest.TabStop = false;
            this.boatNorthwest.MouseClick += new MouseEventHandler(this.boatNorthwest_Click);
            // 
            // boatAnchor
            // 
            this.boatAnchor.Image = ((System.Drawing.Image)(resources.GetObject("boatAnchor.Image")));
            this.boatAnchor.Location = new System.Drawing.Point(15, 142);
            this.boatAnchor.Name = "boatAnchor";
            this.boatAnchor.Size = new System.Drawing.Size(27, 28);
            this.boatAnchor.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage;
            this.boatAnchor.TabIndex = 8;
            this.boatAnchor.TabStop = false;
            this.boatAnchor.Click += new System.EventHandler(this.boatAnchor_Click);
            // 
            // boatT2a
            // 
            this.boatT2a.Image = ((System.Drawing.Image)(resources.GetObject("boatT2a.Image")));
            this.boatT2a.Location = new System.Drawing.Point(145, 142);
            this.boatT2a.Name = "boatT2a";
            this.boatT2a.Size = new System.Drawing.Size(27, 28);
            this.boatT2a.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage;
            this.boatT2a.TabIndex = 9;
            this.boatT2a.TabStop = false;
            this.boatT2a.Click += new System.EventHandler(this.boatT2a_Click);
            // 
            // boatSpeedNormal
            // 
            this.boatSpeedNormal.AutoSize = true;
            this.boatSpeedNormal.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.boatSpeedNormal.ForeColor = System.Drawing.Color.DarkGray;
            this.boatSpeedNormal.Location = new System.Drawing.Point(12, 12);
            this.boatSpeedNormal.Name = "boatSpeedNormal";
            this.boatSpeedNormal.Size = new System.Drawing.Size(62, 17);
            this.boatSpeedNormal.TabIndex = 11;
            this.boatSpeedNormal.TabStop = true;
            this.boatSpeedNormal.Text = "Normal";
            this.boatSpeedNormal.UseVisualStyleBackColor = true;
            // 
            // boatSpeedSlow
            // 
            this.boatSpeedSlow.AutoSize = true;
            this.boatSpeedSlow.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.boatSpeedSlow.ForeColor = System.Drawing.Color.DarkGray;
            this.boatSpeedSlow.Location = new System.Drawing.Point(74, 12);
            this.boatSpeedSlow.Name = "boatSpeedSlow";
            this.boatSpeedSlow.Size = new System.Drawing.Size(50, 17);
            this.boatSpeedSlow.TabIndex = 12;
            this.boatSpeedSlow.TabStop = true;
            this.boatSpeedSlow.Text = "Slow";
            this.boatSpeedSlow.UseVisualStyleBackColor = true;
            // 
            // boatSpeedOne
            // 
            this.boatSpeedOne.AutoSize = true;
            this.boatSpeedOne.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.boatSpeedOne.ForeColor = System.Drawing.Color.DarkGray;
            this.boatSpeedOne.Location = new System.Drawing.Point(128, 12);
            this.boatSpeedOne.Name = "boatSpeedOne";
            this.boatSpeedOne.Size = new System.Drawing.Size(47, 17);
            this.boatSpeedOne.TabIndex = 13;
            this.boatSpeedOne.TabStop = true;
            this.boatSpeedOne.Text = "One";
            this.boatSpeedOne.UseVisualStyleBackColor = true;
            // 
            // boatStop
            // 
            this.boatStop.Image = ((System.Drawing.Image)(resources.GetObject("boatStop.Image")));
            this.boatStop.Location = new System.Drawing.Point(80, 74);
            this.boatStop.Name = "boatStop";
            this.boatStop.Size = new System.Drawing.Size(27, 28);
            this.boatStop.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage;
            this.boatStop.TabIndex = 14;
            this.boatStop.TabStop = false;
            this.boatStop.Click += new System.EventHandler(this.boatStop_Click);
            // 
            // boatTurnRight
            // 
            this.boatTurnRight.Image = ((System.Drawing.Image)(resources.GetObject("boatTurnRight.Image")));
            this.boatTurnRight.Location = new System.Drawing.Point(146, 74);
            this.boatTurnRight.Name = "boatTurnRight";
            this.boatTurnRight.Size = new System.Drawing.Size(26, 19);
            this.boatTurnRight.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage;
            this.boatTurnRight.TabIndex = 16;
            this.boatTurnRight.TabStop = false;
            this.boatTurnRight.Click += new System.EventHandler(this.boatTurnRight_Click);
            // 
            // boatTurnLeft
            // 
            this.boatTurnLeft.Image = ((System.Drawing.Image)(resources.GetObject("boatTurnLeft.Image")));
            this.boatTurnLeft.Location = new System.Drawing.Point(15, 74);
            this.boatTurnLeft.Name = "boatTurnLeft";
            this.boatTurnLeft.Size = new System.Drawing.Size(26, 19);
            this.boatTurnLeft.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage;
            this.boatTurnLeft.TabIndex = 17;
            this.boatTurnLeft.TabStop = false;
            this.boatTurnLeft.Click += new System.EventHandler(this.boatTurnLeft_Click);
            // 
            // boatTurnAround
            // 
            this.boatTurnAround.Image = ((System.Drawing.Image)(resources.GetObject("boatTurnAround.Image")));
            this.boatTurnAround.Location = new System.Drawing.Point(80, 142);
            this.boatTurnAround.Name = "boatTurnAround";
            this.boatTurnAround.Size = new System.Drawing.Size(27, 28);
            this.boatTurnAround.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage;
            this.boatTurnAround.TabIndex = 18;
            this.boatTurnAround.TabStop = false;
            this.boatTurnAround.Click += new System.EventHandler(this.boatTurnAround_Click);
            // 
            // boatGoto1
            // 
            this.boatGoto1.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
            this.boatGoto1.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.boatGoto1.ForeColor = System.Drawing.Color.DarkGray;
            this.boatGoto1.Location = new System.Drawing.Point(26, 185);
            this.boatGoto1.Name = "boatGoto1";
            this.boatGoto1.Size = new System.Drawing.Size(22, 21);
            this.boatGoto1.TabIndex = 19;
            this.boatGoto1.Text = "1";
            this.boatGoto1.UseVisualStyleBackColor = true;
            this.boatGoto1.Click += new System.EventHandler(this.boatGoto1_Click);
            // 
            // boatGoto2
            // 
            this.boatGoto2.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
            this.boatGoto2.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.boatGoto2.ForeColor = System.Drawing.Color.DarkGray;
            this.boatGoto2.Location = new System.Drawing.Point(54, 185);
            this.boatGoto2.Name = "boatGoto2";
            this.boatGoto2.Size = new System.Drawing.Size(22, 21);
            this.boatGoto2.TabIndex = 20;
            this.boatGoto2.Text = "2";
            this.boatGoto2.UseVisualStyleBackColor = true;
            this.boatGoto2.Click += new System.EventHandler(this.boatGoto2_Click);
            // 
            // boatGoto3
            // 
            this.boatGoto3.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
            this.boatGoto3.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.boatGoto3.ForeColor = System.Drawing.Color.DarkGray;
            this.boatGoto3.Location = new System.Drawing.Point(82, 185);
            this.boatGoto3.Name = "boatGoto3";
            this.boatGoto3.Size = new System.Drawing.Size(22, 21);
            this.boatGoto3.TabIndex = 21;
            this.boatGoto3.Text = "3";
            this.boatGoto3.UseVisualStyleBackColor = true;
            this.boatGoto3.Click += new System.EventHandler(this.boatGoto3_Click);
            // 
            // boatGoto4
            // 
            this.boatGoto4.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
            this.boatGoto4.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.boatGoto4.ForeColor = System.Drawing.Color.DarkGray;
            this.boatGoto4.Location = new System.Drawing.Point(26, 212);
            this.boatGoto4.Name = "boatGoto4";
            this.boatGoto4.Size = new System.Drawing.Size(22, 21);
            this.boatGoto4.TabIndex = 22;
            this.boatGoto4.Text = "4";
            this.boatGoto4.UseVisualStyleBackColor = true;
            this.boatGoto4.Click += new System.EventHandler(this.boatGoto4_Click);
            // 
            // boatGoto5
            // 
            this.boatGoto5.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
            this.boatGoto5.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.boatGoto5.ForeColor = System.Drawing.Color.DarkGray;
            this.boatGoto5.Location = new System.Drawing.Point(54, 212);
            this.boatGoto5.Name = "boatGoto5";
            this.boatGoto5.Size = new System.Drawing.Size(22, 21);
            this.boatGoto5.TabIndex = 23;
            this.boatGoto5.Text = "5";
            this.boatGoto5.UseVisualStyleBackColor = true;
            this.boatGoto5.Click += new System.EventHandler(this.boatGoto5_Click);
            // 
            // boatGoto6
            // 
            this.boatGoto6.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
            this.boatGoto6.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.boatGoto6.ForeColor = System.Drawing.Color.DarkGray;
            this.boatGoto6.Location = new System.Drawing.Point(82, 212);
            this.boatGoto6.Name = "boatGoto6";
            this.boatGoto6.Size = new System.Drawing.Size(22, 21);
            this.boatGoto6.TabIndex = 24;
            this.boatGoto6.Text = "6";
            this.boatGoto6.UseVisualStyleBackColor = true;
            this.boatGoto6.Click += new System.EventHandler(this.boatGoto6_Click);
            // 
            // boatGoto7
            // 
            this.boatGoto7.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
            this.boatGoto7.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.boatGoto7.ForeColor = System.Drawing.Color.DarkGray;
            this.boatGoto7.Location = new System.Drawing.Point(26, 239);
            this.boatGoto7.Name = "boatGoto7";
            this.boatGoto7.Size = new System.Drawing.Size(22, 21);
            this.boatGoto7.TabIndex = 25;
            this.boatGoto7.Text = "7";
            this.boatGoto7.UseVisualStyleBackColor = true;
            this.boatGoto7.Click += new System.EventHandler(this.boatGoto7_Click);
            // 
            // boatGoto8
            // 
            this.boatGoto8.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
            this.boatGoto8.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.boatGoto8.ForeColor = System.Drawing.Color.DarkGray;
            this.boatGoto8.Location = new System.Drawing.Point(54, 239);
            this.boatGoto8.Name = "boatGoto8";
            this.boatGoto8.Size = new System.Drawing.Size(22, 21);
            this.boatGoto8.TabIndex = 26;
            this.boatGoto8.Text = "8";
            this.boatGoto8.UseVisualStyleBackColor = true;
            this.boatGoto8.Click += new System.EventHandler(this.boatGoto8_Click);
            // 
            // boatGoto9
            // 
            this.boatGoto9.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
            this.boatGoto9.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.boatGoto9.ForeColor = System.Drawing.Color.DarkGray;
            this.boatGoto9.Location = new System.Drawing.Point(82, 239);
            this.boatGoto9.Name = "boatGoto9";
            this.boatGoto9.Size = new System.Drawing.Size(22, 21);
            this.boatGoto9.TabIndex = 27;
            this.boatGoto9.Text = "9";
            this.boatGoto9.UseVisualStyleBackColor = true;
            this.boatGoto9.Click += new System.EventHandler(this.boatGoto9_Click);
            // 
            // boatStart
            // 
            this.boatStart.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
            this.boatStart.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.boatStart.ForeColor = System.Drawing.Color.DarkGray;
            this.boatStart.Location = new System.Drawing.Point(110, 185);
            this.boatStart.Name = "boatStart";
            this.boatStart.Size = new System.Drawing.Size(52, 21);
            this.boatStart.TabIndex = 28;
            this.boatStart.Text = "Start";
            this.boatStart.UseVisualStyleBackColor = true;
            this.boatStart.Click += new System.EventHandler(this.boatStart_Click);
            // 
            // boatContinue
            // 
            this.boatContinue.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
            this.boatContinue.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.boatContinue.ForeColor = System.Drawing.Color.DarkGray;
            this.boatContinue.Location = new System.Drawing.Point(110, 212);
            this.boatContinue.Name = "boatContinue";
            this.boatContinue.Size = new System.Drawing.Size(52, 21);
            this.boatContinue.TabIndex = 29;
            this.boatContinue.Text = "Cont.";
            this.boatContinue.UseVisualStyleBackColor = true;
            this.boatContinue.Click += new System.EventHandler(this.boatContinue_Click);
            // 
            // boatNav
            // 
            this.boatNav.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
            this.boatNav.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.boatNav.ForeColor = System.Drawing.Color.DarkGray;
            this.boatNav.Location = new System.Drawing.Point(110, 239);
            this.boatNav.Name = "boatNav";
            this.boatNav.Size = new System.Drawing.Size(52, 21);
            this.boatNav.TabIndex = 30;
            this.boatNav.Text = "Nav";
            this.boatNav.UseVisualStyleBackColor = true;
            this.boatNav.Click += new System.EventHandler(this.boatNav_Click);
            // 
            // alwaysOnTop
            // 
            this.alwaysOnTop.AutoSize = true;
            this.alwaysOnTop.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.alwaysOnTop.ForeColor = System.Drawing.Color.DarkGray;
            this.alwaysOnTop.Location = new System.Drawing.Point(11, 270);
            this.alwaysOnTop.Name = "alwaysOnTop";
            this.alwaysOnTop.Size = new System.Drawing.Size(101, 17);
            this.alwaysOnTop.TabIndex = 31;
            this.alwaysOnTop.Text = "Always On Top";
            this.alwaysOnTop.UseVisualStyleBackColor = true;
            this.alwaysOnTop.CheckedChanged += new System.EventHandler(this.alwaysOnTop_CheckedChanged);
            // 
            // boatBorder
            // 
            this.boatBorder.Image = ((System.Drawing.Image)(resources.GetObject("boatBorder.Image")));
            this.boatBorder.Location = new System.Drawing.Point(0, 0);
            this.boatBorder.Name = "boatBorder";
            this.boatBorder.Size = new System.Drawing.Size(190, 296);
            this.boatBorder.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage;
            this.boatBorder.TabIndex = 32;
            this.boatBorder.TabStop = false;
            this.boatBorder.Visible = false;
            // 
            // boatWindowsBorder
            // 
            this.boatWindowsBorder.AutoSize = true;
            this.boatWindowsBorder.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.boatWindowsBorder.ForeColor = System.Drawing.Color.DarkGray;
            this.boatWindowsBorder.Location = new System.Drawing.Point(114, 270);
            this.boatWindowsBorder.Name = "boatWindowsBorder";
            this.boatWindowsBorder.Size = new System.Drawing.Size(61, 17);
            this.boatWindowsBorder.TabIndex = 33;
            this.boatWindowsBorder.Text = "Border";
            this.boatWindowsBorder.UseVisualStyleBackColor = true;
            this.boatWindowsBorder.CheckedChanged += new System.EventHandler(this.boatWindowsBorder_CheckedChanged);
            // 
            // boatClose
            // 
            this.boatClose.AutoSize = true;
            this.boatClose.ForeColor = System.Drawing.Color.DimGray;
            this.boatClose.Location = new System.Drawing.Point(172, 4);
            this.boatClose.Name = "boatClose";
            this.boatClose.Size = new System.Drawing.Size(14, 15);
            this.boatClose.TabIndex = 34;
            this.boatClose.Text = "X";
            this.boatClose.Click += new System.EventHandler(this.boatClose_Click);
            // 
            // BoatWindow
            // 
            this.AutoScaleDimensions = new System.Drawing.SizeF(7F, 15F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.BackColor = System.Drawing.Color.Black;
            this.ClientSize = new System.Drawing.Size(190, 296);
            this.Controls.Add(this.boatClose);
            this.Controls.Add(this.boatWindowsBorder);
            this.Controls.Add(this.alwaysOnTop);
            this.Controls.Add(this.boatNav);
            this.Controls.Add(this.boatContinue);
            this.Controls.Add(this.boatStart);
            this.Controls.Add(this.boatGoto9);
            this.Controls.Add(this.boatGoto8);
            this.Controls.Add(this.boatGoto7);
            this.Controls.Add(this.boatGoto6);
            this.Controls.Add(this.boatGoto5);
            this.Controls.Add(this.boatGoto4);
            this.Controls.Add(this.boatGoto3);
            this.Controls.Add(this.boatGoto2);
            this.Controls.Add(this.boatGoto1);
            this.Controls.Add(this.boatTurnAround);
            this.Controls.Add(this.boatTurnLeft);
            this.Controls.Add(this.boatTurnRight);
            this.Controls.Add(this.boatStop);
            this.Controls.Add(this.boatSpeedOne);
            this.Controls.Add(this.boatSpeedSlow);
            this.Controls.Add(this.boatSpeedNormal);
            this.Controls.Add(this.boatT2a);
            this.Controls.Add(this.boatAnchor);
            this.Controls.Add(this.boatNorthwest);
            this.Controls.Add(this.boatWest);
            this.Controls.Add(this.boatSouthwest);
            this.Controls.Add(this.boatSouth);
            this.Controls.Add(this.boatSoutheast);
            this.Controls.Add(this.boatEast);
            this.Controls.Add(this.boatNortheast);
            this.Controls.Add(this.boatNorth);
            this.Controls.Add(this.boatBorder);
            this.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.None;
            this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon")));
            this.MaximizeBox = false;
            this.MinimizeBox = false;
            this.Name = "BoatWindow";
            this.SizeGripStyle = System.Windows.Forms.SizeGripStyle.Hide;
            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
            this.Text = "Razor Boat Control";
            this.Load += new System.EventHandler(this.BoatWindow_Load);
            ((System.ComponentModel.ISupportInitialize)(this.boatNorth)).EndInit();
            ((System.ComponentModel.ISupportInitialize)(this.boatNortheast)).EndInit();
            ((System.ComponentModel.ISupportInitialize)(this.boatEast)).EndInit();
            ((System.ComponentModel.ISupportInitialize)(this.boatSoutheast)).EndInit();
            ((System.ComponentModel.ISupportInitialize)(this.boatSouth)).EndInit();
            ((System.ComponentModel.ISupportInitialize)(this.boatSouthwest)).EndInit();
            ((System.ComponentModel.ISupportInitialize)(this.boatWest)).EndInit();
            ((System.ComponentModel.ISupportInitialize)(this.boatNorthwest)).EndInit();
            ((System.ComponentModel.ISupportInitialize)(this.boatAnchor)).EndInit();
            ((System.ComponentModel.ISupportInitialize)(this.boatT2a)).EndInit();
            ((System.ComponentModel.ISupportInitialize)(this.boatStop)).EndInit();
            ((System.ComponentModel.ISupportInitialize)(this.boatTurnRight)).EndInit();
            ((System.ComponentModel.ISupportInitialize)(this.boatTurnLeft)).EndInit();
            ((System.ComponentModel.ISupportInitialize)(this.boatTurnAround)).EndInit();
            ((System.ComponentModel.ISupportInitialize)(this.boatBorder)).EndInit();
            this.ResumeLayout(false);
            this.PerformLayout();

        }

        #endregion

        private System.Windows.Forms.PictureBox boatNorth;
        private System.Windows.Forms.PictureBox boatNortheast;
        private System.Windows.Forms.PictureBox boatEast;
        private System.Windows.Forms.PictureBox boatSoutheast;
        private System.Windows.Forms.PictureBox boatSouth;
        private System.Windows.Forms.PictureBox boatSouthwest;
        private System.Windows.Forms.PictureBox boatWest;
        private System.Windows.Forms.PictureBox boatNorthwest;
        private System.Windows.Forms.PictureBox boatAnchor;
        private System.Windows.Forms.PictureBox boatT2a;
        private System.Windows.Forms.RadioButton boatSpeedNormal;
        private System.Windows.Forms.RadioButton boatSpeedSlow;
        private System.Windows.Forms.RadioButton boatSpeedOne;
        private System.Windows.Forms.PictureBox boatStop;
        private System.Windows.Forms.PictureBox boatTurnRight;
        private System.Windows.Forms.PictureBox boatTurnLeft;
        private System.Windows.Forms.PictureBox boatTurnAround;
        private System.Windows.Forms.Button boatGoto1;
        private System.Windows.Forms.Button boatGoto2;
        private System.Windows.Forms.Button boatGoto3;
        private System.Windows.Forms.Button boatGoto4;
        private System.Windows.Forms.Button boatGoto5;
        private System.Windows.Forms.Button boatGoto6;
        private System.Windows.Forms.Button boatGoto7;
        private System.Windows.Forms.Button boatGoto8;
        private System.Windows.Forms.Button boatGoto9;
        private System.Windows.Forms.Button boatStart;
        private System.Windows.Forms.Button boatContinue;
        private System.Windows.Forms.Button boatNav;
        private System.Windows.Forms.CheckBox alwaysOnTop;
        private System.Windows.Forms.PictureBox boatBorder;
        private System.Windows.Forms.CheckBox boatWindowsBorder;
        private System.Windows.Forms.Label boatClose;
    }
}

================================================
FILE: Razor/Boat/BoatWindow.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Windows.Forms;

namespace Assistant.Boat
{
    public partial class BoatWindow : Form
    {
        private enum Orientation
        {
            Normal,
            Northwest,
            Southwest,
            Southeast,
            Northeast
        }

        private int _orientation = 0;

        public const int WM_NCLBUTTONDOWN = 0xA1;
        public const int HT_CAPTION = 0x2;

        [System.Runtime.InteropServices.DllImport("user32.dll")]
        public static extern int SendMessage(IntPtr hWnd, int Msg, int wParam, int lParam);

        [System.Runtime.InteropServices.DllImport("user32.dll")]
        public static extern bool ReleaseCapture();

        private bool _inT2A = false;
        private bool _ancherUp = false;

        public BoatWindow()
        {
            InitializeComponent();
            this.MouseDown += BoatWindow_MouseDown;
            this.boatBorder.MouseDown += BoatWindow_MouseDown;
        }

        private void BoatWindow_Load(object sender, EventArgs e)
        {
            alwaysOnTop.Checked = true;
        }

        private void BoatWindow_MouseDown(object sender, System.Windows.Forms.MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left)
            {
                ReleaseCapture();
                SendMessage(Handle, WM_NCLBUTTONDOWN, HT_CAPTION, 0);
            }
        }

        private void SendBoatCommand(string command, bool directionCommand = true)
        {
            string boatCommand = command;

            if (boatSpeedOne.Checked && directionCommand)
            {
                boatCommand = $"{command} One";
            }
            else if (boatSpeedSlow.Checked && directionCommand)
            {
                boatCommand = $"Slow {command}";
            }

            if (World.Player != null)
            {
                World.Player.Say(boatCommand);
            }
        }

        private string[] _boatDirCommands =
            {"Forward", "Forward Right", "Right", "Back Right", "Back", "Back Left", "Left", "Forward Left"};
        //        0             1            2           3          4        5          6           7

        private void boatNorth_MouseClick(object sender, MouseEventArgs e)
        {
            switch (e.Button)
            {
                case MouseButtons.Left:

                    switch (_orientation)
                    {
                        case (int) Orientation.Northwest:
                            SendBoatCommand(_boatDirCommands[1]);
                            break;
                        case (int) Orientation.Southwest:
                            SendBoatCommand(_boatDirCommands[3]);
                            break;
                        case (int) Orientation.Southeast:
                            SendBoatCommand(_boatDirCommands[5]);
                            break;
                        case (int) Orientation.Northeast:
                            SendBoatCommand(_boatDirCommands[7]);
                            break;
                        default:
                            SendBoatCommand(_boatDirCommands[0]);
                            break;
                    }

                    //SendBoatCommand(_boatDirCommands[1]); //NW orientation
                    //SendBoatCommand(_boatDirCommands[3]); //SW orientation
                    //SendBoatCommand(_boatDirCommands[5]); //SE orientation
                    //SendBoatCommand(_boatDirCommands[7]); //NE orientation
                    break;
                case MouseButtons.Right:
                    _orientation = (int) Orientation.Normal;

                    boatNorth.BorderStyle = BorderStyle.FixedSingle;
                    boatNortheast.BorderStyle = BorderStyle.None;
                    boatNorthwest.BorderStyle = BorderStyle.None;
                    boatSouthwest.BorderStyle = BorderStyle.None;
                    boatSoutheast.BorderStyle = BorderStyle.None;

                    if (World.Player != null)
                        World.Player.SendMessage(MsgLevel.Force, "Set Boat Orientation: Normal");

                    break;
            }
        }

        private void boatNorthwest_Click(object sender, MouseEventArgs e)
        {
            switch (e.Button)
            {
                case MouseButtons.Left:
                    switch (_orientation)
                    {
                        case (int) Orientation.Northwest:
                            SendBoatCommand(_boatDirCommands[0]);
                            break;
                        case (int) Orientation.Southwest:
                            SendBoatCommand(_boatDirCommands[2]);
                            break;
                        case (int) Orientation.Southeast:
                            SendBoatCommand(_boatDirCommands[4]);
                            break;
                        case (int) Orientation.Northeast:
                            SendBoatCommand(_boatDirCommands[6]);
                            break;
                        default:
                            SendBoatCommand(_boatDirCommands[7]);
                            break;
                    }

                    break;
                case MouseButtons.Right:
                    _orientation = (int) Orientation.Northwest;

                    boatNorth.BorderStyle = BorderStyle.None;
                    boatNortheast.BorderStyle = BorderStyle.None;
                    boatNorthwest.BorderStyle = BorderStyle.FixedSingle;
                    boatSouthwest.BorderStyle = BorderStyle.None;
                    boatSoutheast.BorderStyle = BorderStyle.None;

                    if (World.Player != null)
                        World.Player.SendMessage(MsgLevel.Force, "Set Boat Orientation: Northwest");


                    break;
            }
        }

        private void boatSouth_Click(object sender, EventArgs e)
        {
            switch (_orientation)
            {
                case (int) Orientation.Northwest:
                    SendBoatCommand(_boatDirCommands[5]);
                    break;
                case (int) Orientation.Southwest:
                    SendBoatCommand(_boatDirCommands[7]);
                    break;
                case (int) Orientation.Southeast:
                    SendBoatCommand(_boatDirCommands[1]);
                    break;
                case (int) Orientation.Northeast:
                    SendBoatCommand(_boatDirCommands[3]);
                    break;
                default:
                    SendBoatCommand(_boatDirCommands[4]);
                    break;
            }
        }

        private void boatSoutheast_Click(object sender, MouseEventArgs e)
        {
            switch (e.Button)
            {
                case MouseButtons.Left:
                    switch (_orientation)
                    {
                        case (int) Orientation.Northwest:
                            SendBoatCommand(_boatDirCommands[4]);
                            break;
                        case (int) Orientation.Southwest:
                            SendBoatCommand(_boatDirCommands[6]);
                            break;
                        case (int) Orientation.Southeast:
                            SendBoatCommand(_boatDirCommands[0]);
                            break;
                        case (int) Orientation.Northeast:
                            SendBoatCommand(_boatDirCommands[2]);
                            break;
                        default:
                            SendBoatCommand(_boatDirCommands[3]);
                            break;
                    }

                    break;
                case MouseButtons.Right:
                    _orientation = (int) Orientation.Southeast;

                    boatNorth.BorderStyle = BorderStyle.None;
                    boatNortheast.BorderStyle = BorderStyle.None;
                    boatNorthwest.BorderStyle = BorderStyle.None;
                    boatSouthwest.BorderStyle = BorderStyle.None;
                    boatSoutheast.BorderStyle = BorderStyle.FixedSingle;

                    if (World.Player != null)
                        World.Player.SendMessage(MsgLevel.Force, "Set Boat Orientation: Southeast");

                    break;
            }
        }

        private void boatSouthwest_Click(object sender, MouseEventArgs e)
        {
            switch (e.Button)
            {
                case MouseButtons.Left:
                    switch (_orientation)
                    {
                        case (int) Orientation.Northwest:
                            SendBoatCommand(_boatDirCommands[6]);
                            break;
                        case (int) Orientation.Southwest:
                            SendBoatCommand(_boatDirCommands[0]);
                            break;
                        case (int) Orientation.Southeast:
                            SendBoatCommand(_boatDirCommands[2]);
                            break;
                        case (int) Orientation.Northeast:
                            SendBoatCommand(_boatDirCommands[4]);
                            break;
                        default:
                            SendBoatCommand(_boatDirCommands[5]);
                            break;
                    }

                    break;
                case MouseButtons.Right:
                    _orientation = (int) Orientation.Southwest;

                    boatNorth.BorderStyle = BorderStyle.None;
                    boatNortheast.BorderStyle = BorderStyle.None;
                    boatNorthwest.BorderStyle = BorderStyle.None;
                    boatSouthwest.BorderStyle = BorderStyle.FixedSingle;
                    boatSoutheast.BorderStyle = BorderStyle.None;

                    if (World.Player != null)
                        World.Player.SendMessage(MsgLevel.Force, "Set Boat Orientation: Southwest");

                    break;
            }
        }

        private void boatWest_Click(object sender, EventArgs e)
        {
            switch (_orientation)
            {
                case (int) Orientation.Northwest:
                    SendBoatCommand(_boatDirCommands[7]);
                    break;
                case (int) Orientation.Southwest:
                    SendBoatCommand(_boatDirCommands[1]);
                    break;
                case (int) Orientation.Southeast:
                    SendBoatCommand(_boatDirCommands[3]);
                    break;
                case (int) Orientation.Northeast:
                    SendBoatCommand(_boatDirCommands[5]);
                    break;
                default:
                    SendBoatCommand(_boatDirCommands[6]);
                    break;
            }
        }

        private void boatNortheast_Click(object sender, MouseEventArgs e)
        {
            switch (e.Button)
            {
                case MouseButtons.Left:
                    switch (_orientation)
                    {
                        case (int) Orientation.Northwest:
                            SendBoatCommand(_boatDirCommands[2]);
                            break;
                        case (int) Orientation.Southwest:
                            SendBoatCommand(_boatDirCommands[4]);
                            break;
                        case (int) Orientation.Southeast:
                            SendBoatCommand(_boatDirCommands[6]);
                            break;
                        case (int) Orientation.Northeast:
                            SendBoatCommand(_boatDirCommands[0]);
                            break;
                        default:
                            SendBoatCommand(_boatDirCommands[1]);
                            break;
                    }

                    break;
                case MouseButtons.Right:
                    _orientation = (int) Orientation.Northeast;

                    boatNorth.BorderStyle = BorderStyle.None;
                    boatNortheast.BorderStyle = BorderStyle.FixedSingle;
                    boatNorthwest.BorderStyle = BorderStyle.None;
                    boatSouthwest.BorderStyle = BorderStyle.None;
                    boatSoutheast.BorderStyle = BorderStyle.None;

                    if (World.Player != null)
                        World.Player.SendMessage(MsgLevel.Force, "Set Boat Orientation: Northeast");

                    break;
            }
        }

        private void boatEast_Click(object sender, EventArgs e)
        {
            switch (_orientation)
            {
                case (int) Orientation.Northwest:
                    SendBoatCommand(_boatDirCommands[3]);
                    break;
                case (int) Orientation.Southwest:
                    SendBoatCommand(_boatDirCommands[5]);
                    break;
                case (int) Orientation.Southeast:
                    SendBoatCommand(_boatDirCommands[7]);
                    break;
                case (int) Orientation.Northeast:
                    SendBoatCommand(_boatDirCommands[1]);
                    break;
                default:
                    SendBoatCommand(_boatDirCommands[2]);
                    break;
            }
        }

        private void boatTurnRight_Click(object sender, EventArgs e)
        {
            SendBoatCommand("Turn Right", false);

            switch (_orientation)
            {
                case (int) Orientation.Northwest:
                    boatNortheast_Click(null, new MouseEventArgs(MouseButtons.Right, 1, 1, 1, 1));
                    break;
                case (int) Orientation.Southwest:
                    boatNorthwest_Click(null, new MouseEventArgs(MouseButtons.Right, 1, 1, 1, 1));
                    break;
                case (int) Orientation.Southeast:
                    boatSouthwest_Click(null, new MouseEventArgs(MouseButtons.Right, 1, 1, 1, 1));
                    break;
                case (int) Orientation.Northeast:
                    boatSoutheast_Click(null, new MouseEventArgs(MouseButtons.Right, 1, 1, 1, 1));
                    break;
            }
        }

        private void boatTurnLeft_Click(object sender, EventArgs e)
        {
            SendBoatCommand("Turn Left", false);

            switch (_orientation)
            {
                case (int) Orientation.Northwest:
                    boatSouthwest_Click(null, new MouseEventArgs(MouseButtons.Right, 1, 1, 1, 1));
                    break;
                case (int) Orientation.Southwest:
                    boatSoutheast_Click(null, new MouseEventArgs(MouseButtons.Right, 1, 1, 1, 1));
                    break;
                case (int) Orientation.Southeast:
                    boatNortheast_Click(null, new MouseEventArgs(MouseButtons.Right, 1, 1, 1, 1));
                    break;
                case (int) Orientation.Northeast:
                    boatNorthwest_Click(null, new MouseEventArgs(MouseButtons.Right, 1, 1, 1, 1));
                    break;
            }
        }

        private void boatTurnAround_Click(object sender, EventArgs e)
        {
            SendBoatCommand("Turn Around", false);

            switch (_orientation)
            {
                case (int) Orientation.Northwest:
                    boatSoutheast_Click(null, new MouseEventArgs(MouseButtons.Right, 1, 1, 1, 1));
                    break;
                case (int) Orientation.Southwest:
                    boatNortheast_Click(null, new MouseEventArgs(MouseButtons.Right, 1, 1, 1, 1));
                    break;
                case (int) Orientation.Southeast:
                    boatNorthwest_Click(null, new MouseEventArgs(MouseButtons.Right, 1, 1, 1, 1));
                    break;
                case (int) Orientation.Northeast:
                    boatSouthwest_Click(null, new MouseEventArgs(MouseButtons.Right, 1, 1, 1, 1));
                    break;
            }
        }

        private void boatAnchor_Click(object sender, EventArgs e)
        {
            if (_ancherUp)
            {
                SendBoatCommand("Drop Anchor", false);
                _ancherUp = false;
            }
            else
            {
                SendBoatCommand("Raise Anchor", false);
                _ancherUp = true;
            }
        }

        private void boatT2a_Click(object sender, EventArgs e)
        {
            if (_inT2A)
            {
                SendBoatCommand("Sueacron", false);
                _inT2A = false;
            }
            else
            {
                SendBoatCommand("Doracron", false);
                _inT2A = true;
            }
        }

        private void alwaysOnTop_CheckedChanged(object sender, EventArgs e)
        {
            TopMost = alwaysOnTop.Checked;
        }

        private void boatGoto1_Click(object sender, EventArgs e)
        {
            SendBoatCommand("Goto 1", false);
        }

        private void boatGoto2_Click(object sender, EventArgs e)
        {
            SendBoatCommand("Goto 2", false);
        }

        private void boatGoto3_Click(object sender, EventArgs e)
        {
            SendBoatCommand("Goto 3", false);
        }

        private void boatGoto4_Click(object sender, EventArgs e)
        {
            SendBoatCommand("Goto 4", false);
        }

        private void boatGoto5_Click(object sender, EventArgs e)
        {
            SendBoatCommand("Goto 5", false);
        }

        private void boatGoto6_Click(object sender, EventArgs e)
        {
            SendBoatCommand("Goto 6", false);
        }

        private void boatGoto7_Click(object sender, EventArgs e)
        {
            SendBoatCommand("Goto 7", false);
        }

        private void boatGoto8_Click(object sender, EventArgs e)
        {
            SendBoatCommand("Goto 8", false);
        }

        private void boatGoto9_Click(object sender, EventArgs e)
        {
            SendBoatCommand("Goto 9", false);
        }

        private void boatStart_Click(object sender, EventArgs e)
        {
            SendBoatCommand("Start", false);
        }

        private void boatContinue_Click(object sender, EventArgs e)
        {
            SendBoatCommand("Continue", false);
        }

        private void boatNav_Click(object sender, EventArgs e)
        {
            SendBoatCommand("Nav", false);
        }

        private void boatWindowsBorder_CheckedChanged(object sender, EventArgs e)
        {
            boatBorder.Visible = boatWindowsBorder.Checked;
        }

        private void boatStop_Click(object sender, EventArgs e)
        {
            SendBoatCommand("Stop", false);
        }

        private void boatClose_Click(object sender, EventArgs e)
        {
            Hide();
        }
    }
}

================================================
FILE: Razor/Boat/BoatWindow.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <assembly alias="System.Drawing" name="System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
  <data name="boatNorth.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
    <value>
        iVBORw0KGgoAAAANSUhEUgAAADIAAAAyCAYAAAAeP4ixAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO
        wwAADsMBx2+oZAAAABl0RVh0U29mdHdhcmUAcGFpbnQubmV0IDQuMC4xNzNun2MAAAUFSURBVGhD7Vor
        sKNKEI2MjMQikUgsEokci0QixyJHIrEjkUgsEhkZG3nlyn7nzAz7srt3782+ejeZVG1XdVF8Evr06e7p
        6eTwV+6U0/Eox+NBwunrSlUkkqWn1wZCJggkTY4AQn1RUWUq1Cw9SnJ6WSBH0U0mbZ1KkZ9ekRVvcFtn
        YtpCeqiqMpcniQPzMsIqdRTTlTL2NVRJ31VSl3lI+pcA49lowMCgK7GmETt0Mo2d6LZGiKWvwooHYtoc
        QEppVAnjM1nn0QFSdQFWkthZ8SBqVKkeQAgmOZ1cmNnRyDIZhJjyrMRdwQIbHRM8R4KnDgS1qsqfWIk2
        VzwIVqcdSJp4Nqi8N1sjc2Alj5cVbyzzgkAalN4dxA5E1ZWsS/S5gkpVM8ErV3Zp5C2QXReE1w+5ElcF
        8x7nmkEgrSreBcFn2kbJdsNKnkXFCnMjl9F4IPQ0DT+FinWrvLYtFqwMN6xE0Rl7T9sBC5/xK/it0bcg
        qHy2161sq0VJ1oGVNAZWsG5UhUxDC0aUlIVP8vdA7JomiZy32ZXjXjduwXwyK97Ds2UL0sqAnmoH8BEQ
        fmYYNMBMMtkerJSuHD+RFZbUEkB6GKQdMzT0IxC75lkml/Pi8sX0rRRg8kmseM+ylFInxDsNoZH3AOFn
        52l0YGYkfqNYJLLnAGlU7Ra4ZR5QVmtn4D0gdi3LQt6uG0JsEWM0WEFvhvwJL3iUHAHCyorqw0UuDQvg
        nwDhd2zrItfrGd9hpYEzCCa84DHCdmNbJwdGo5zSk2ma3qW3YBRY/fZ2kfN5BSs9ql7x2FzxIFB1EN+q
        rmGQgkcbd/xMazyfIdl3MJfzJtfL5nKGwB7GSg02LvAgw8H0Wvq+RzkdnBpj7lKtNVp7v3i2rfqeK8PQ
        u5afIRpe93Xyhpi+wIPLPAEEgMAorbGV7TrpuvZfbRsYCUV/xcLAI43mdaedV67018sKMKs7TnZw18Pr
        vkbIxre3q0tQJqq1o2NFw3AayerFUsotLtuPGvsTDujKPHFHnit0ybzfYQ8/YA1h+eVK78EwzFZ3Xn5l
        iDEUmNh7ctPzM5iZJwtPGvRcWgbTiNE12vlKdFugG/azLR51g00XrvP+iOc4lFhm4xZGMpPhO/fv57vC
        ax8nE5ihF7dlkIUti2si2Q1jo4XdYt9wxsX9SoF2v8J95Z7xrc0Xh9GfSJHnKACznNdR1knLPCoAqWQE
        kKHzgwiD4wggvE6QbPvJTBrXgPsIRuwNI7VYeJ4MEMAOxDPCwV2FECvdJoyfDV8Sh3DntyHeCYQetzSY
        jPykBMJjh3xh8oePxyNsHlcAmW3rQyd4nhsunzMNzv11DihalUtVsn2PTCwqkAOCBN7zg0CYzKxmy4R2
        nxswXNuBlEWEQAwMXufeAyEAGMsQYkOZYTvL0CMYMsQpPUdGhRs+RCa6Q1sPQwmE4cMhHX8fCbcPXPhW
        tPwsufvsK8+iqlheGuwW6XECYXXqsADeThPJCvfpC3aUvM+pJKeR4XY8UpX5dyDe47/GP8emZMUi6fnT
        Q5Q/MXCC4hJ6RCOIsHpvtutYQa4w6fmLVpTzXwJhjrD9YFiFy78Ih3MML91waxshEE4NWX65hnzkaZ8r
        2L8g/KJkJEMpJRCOTcOl3woXz88AP03oaebIPZWIz7IoRBlaNI7zrXD6qXAvEmX5PSFM/ED6PuGz/MNN
        OI1J/otRUQL5K/+DHA7/AFGuD+HZCC/CAAAAAElFTkSuQmCC
</value>
  </data>
  <data name="boatNortheast.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
    <value>
        iVBORw0KGgoAAAANSUhEUgAAADIAAAAyCAYAAAAeP4ixAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO
        wwAADsMBx2+oZAAAABl0RVh0U29mdHdhcmUAcGFpbnQubmV0IDQuMC4xNzNun2MAAAnQSURBVGhD7Zh7
        UFNXHsetWr2BAAGCBEEwPA3yMEQkUUGeylMQRJCnhIc8lAQIBKKovCEBiQLlIUiESpE34qO0StWqfdiH
        u+O023a72+0fu+Mu3Z3dznS2O9v57rl4dTu6dv+BtnT4zHznJvfe3N/53nPO7/xOli2xxBJLLLHELxPK
        lsiEa7yqVY9aPsScXAxQK5ljHpui9umvpn6/hsN66OFkDIe1huBQlMej6z9bKCdjY4pNjjfMTFl9JsYU
        rLjUv+2tKAgdDRAq4WHHJu5+5uafI1Qi14CKe3EFBUue4W/51sbY5LQGIgEP24XmCJJwkRzEx1YXU1DU
        shLmRz8HKAMWixKTY5+5EXXO1IgNO0tDuDlaIGCbM2JCNyN7fwDkqb4oTBVDleaOokRH7N1hM8w84KeE
        MidyY7PZlfos/U/WWrD+yrfiQui8DptFdoiL2IJ8aQjqS5PR2yzDQFsx+rQ56K5OQHORH3L2CEB+/x4R
        i3ngj8sLL1AZq1frZxsZGbxvYcb9xsHWHB7Olgjy3oDY0C04nBaMurIkdDbJMXr2GK6NNGOiX4N2tRKK
        g9Ho00jRVh6Gg3tcwGEbjDGP/fHg8XjWTnaWGWZmHDg5WcHDzZ4Mm03YG+4JWXoYasib1zXLMamrwNUh
        DS4NN+HyQCPkOUmIjgqGoQEb4YEiNCp3o6EgAHwrE5CXQveKkgmxcPB4nCCikI0bHcccHGxnvb3cEOTn
        gaT4QORnRaOxKge61jJMvFKHGxfbcfdKJ853VqBdW47QIG8IXV2wgkx4iqLA1tPD7u22OFXiDVWKELZr
        TWkTbxIZMOHmD3+JkEsfrazWNjs62ra4uzt9u9nNBZG7g5CwPxzKkoNo0SgxdK6BNLwDb73Ri7euncN7
        ty+gU3sUeenx8HAnQ8bIFKtXU1i58pEJWnbrOChMEKA2T4hdXutoE7RuEK2YCz5f6OmxHEUujp+qq4ve
        K5RLEbs3DFJpPBRy0vgWNabGe3H7xgQ+/vAafvfRdXxwZwxDfSdRX1eAHRJPONmux/Lljxq9atV/DdDS
        12PB1ZYLldQVqnR3eDrzHhuJZ8LPHyRgqPkaMwy9fAr3bo3hzswQLk/24u7MKD66fxN//PLX+PzTe/js
        wW001JYgNysFFmY8rDEzezJ86F74voHH4hjqIzncAfUyT8iT3PHiShZt4k9EFkz4+YVM6Dg+fz1en9Lh
        L1++jT9/eRsP//Au7t2+jNemhpCZmQRfHx9wuWZzjX76zT8tFos1d1xP5kN+wiYyySVICBWAWqVPG+lj
        wi4MdtbWcXvDAvHh3XF88fEMLg69NDc/uKam4HCMnmns86Svrw8jo0f3B4jtoSkKQIsqEC4OFrSJ74j8
        mJALh6ZCHndj8gzukIncoT2CdGksJBIvCIVCrF+//klDv9/wp0Vfp3vEysIEaXtEOF0WAmX6NvC4JrSR
        r4hIJfAjMHK2fPTVsVp0N8pQVpSC/ENpUJWVkgQghb+/P/h8/pM3/r9kaGgIPZJyN9hbQFO8C51VkUiK
        ENEm/kYkYcIsLNbWRpXFuaEYOXMYOm02lIejkJsWhRJZDslStcjPz0dISMhzzdA9QfeIMceArPYexMRe
        aFRh2GhnSRv5hGj+145noQKs15qhoiAML2tTcL45FQ1lUchK2oq0xEDIZVLU1dX8oBlSf8HAwGDufHH2
        TvSfTEVr9X6Yc+cWwSom0MISFewkTtzt/s0JmT961HtwQbsP7RURKM/1Q0KEM/ZHeOFQZgrqap9vhjZB
        HwO83dClScVgSzZ2B3nSJr4hcmNCLRxB2/niUH/+bGa8EDWFvuipIb2iCcOZCn80yL2Qt9+ZlBmWiNkp
        IjUU3TPPDjN6WNHzw9iYjbSEQIz2KTHVX4htWzbSRj4g4jHhFgaxwFy8Q2Q9mxy5ESXpm0mW8cWZygB0
        nfBBR5kXmmQeKD8gQE60LaL9rJAUuwNF8mfnDJfLnZvkm1wc0N9ajCsD1ThWlEgWTT3aSA4TbmFw5nPE
        IoHJbIy/LRSpHmgskqDjhC86T9C5fzuaFORcvhAN2a44kekGRYYIB2JFyEqJIPWXDPX1dU+ZMUFwoBdG
        +mtwffwkDmdEk8WTTRvJZELOPxY8ltiGZzgb5m1Dygc3NB3aiq6KEOjqY8gmKAbtx4LRrJCg8bAQLYVC
        tCq9cfpIEBoKQ5F3IBC5mXFQKuVzZhQKBcLDw2FjYw11bRFuvt6N8QE1bG34tIkRJuT8wzOhxDxTapau
        RmWJ7jhVuo1kmERMkLR7qVeJyR4FXiEZp+P4LjSXSNBSKkZvRSAGmvZAp07AycoEFGTHID83GUdLi6HV
        NqOgoADJ8bHo7arD3Vvnca6j5rGRcSbs/DJnwpyajfS2RjlZcV+u3oNL3Qpcu1CDWxe1uPdaB7oaC0gK
        PoR+dRy6ygPRc8wXA3VhmOzYh1d1eZjSKXDulBKqYimKC7Jx/HgpamtqUH1CiVcvdeP9OyNITYheQBMc
        YoJDzaaRilRbGo6LXUWYGVNjZlSLkbN131YcyUZLY0mLo6P1t7IMkrWqo9BdRdaD6gAMnozE1bOZeOdi
        Je6/0YY7r/Vg5PxpqCtVqCkvJSaOoLWpCjNXBnB1/AwSokMXxoQVjy3mraFm6X8zBk8mY2ZYg+vDWtRV
        5H2RlRr1ID9rn59AwE+k7+XzeUGFBzy/66R7g0z8fnUkJjuluHlBhQ+ut+LTD4cxPdmD8cHery9ODKK9
        VYPenlZcnRjA/Xem8cb0+V/NBZ1vjFmUeB3XcFaVF4qmI7EY11V8nRK/63J8TFADafwqInPm1jkifdZe
        qs4Vok2xFf21wRh9KRnTg0W4d0mN+ze70FRfgM2url9VqhSStramuKysA+jrbsPHD+7is9+8jcyMxH9F
        R4euYx43X1AOLy6nZjfaWeF0VdogaXTpzoAtO5iLz0CGnqXvpjUPjx90J2uJH0a1iZjuK8SdKTVuTjTh
        3ekOsp+gyth6nCcFoECwIc7e3g5XLw/j7w8//+7B+zM7mUvzDeUjFPB9mC8/iMTVNDc3zh6Nii14pXkf
        pnUFxEQlhkk2G+s7+txNEb05syVriTQtEaQ3djOnfxpIb6zYsM7wTVW6G/oaYnCFmLg5Uol2dRY0VdL/
        u7MjRWMcqX61zNefDk8nE5vCBMGDdrIwTukO4xoxcVwWB3lG2MJuT+cb0iOVhSmeJC1nYIaYyE8PRUSg
        aHGZoGkoCKwf1Cbj9kQtZAeC4S8RLD4TfB4nID7ME7cm6pCZFIBtIrvFZ4LmdNVBn0nd0X8m7fOHQMBb
        nCZIajbfKtzwj5BAT2KCvzhNPIatz37b2Ji1uE08gjrEfFhiiV82y5b9B9NZKrUTvUWDAAAAAElFTkSu
        QmCC
</value>
  </data>
  <data name="boatEast.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
    <value>
        iVBORw0KGgoAAAANSUhEUgAAADIAAAAyCAYAAAAeP4ixAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO
        wwAADsMBx2+oZAAAABl0RVh0U29mdHdhcmUAcGFpbnQubmV0IDQuMC4xNzNun2MAAAR7SURBVGhD7Zgt
        kJxAEIVPIldikUgkFolEjh2JRI5FIkdikUgkFolErl15MrLzXgN7l8sludxtVXYrdFUXy+4F5pvXf5On
        ww477LDDDjvssP/AgiCQLE1ku31cC8NQlnmQqrJyOp0eF4ggl/MkfeclzzNJoU4YPiBQHEXyfJkVxvta
        jCkQaukGFD4OUO1KhXi+TAixUYa+laapxdpCYdIk3hQK7htqHjvNkRWGysyyLJOMQwcgJ9bkAIolSaJ7
        BAokik7ia4sFN1DBC5UpSyPnZZZvz2e5XJZNIS9NXYopkD9QJ4lvDhTICaUzwkPDMJDwtPn+GVf+lsQn
        SeMQcR9JnkVS5LGUJpXGFdK3JbwCUKlVi6WYzjyZp1EVOi+jULW+qwFrAYT8gToJnsl33ASIu8OFDFhQ
        1xTiq1ScTaQsYrFYsIFbfoaXBt/DK5tKXWXS4u97b3G1UpWFguR5foXhArMs1ZwhzDL3Mg2tdK3DvzdX
        oDgCEDbuJkAxgMa+wYu8jNi53gOsBpjDzgOuKbcr3DtA1LmC996oMtZkgLHinJM4jq8wO1CC77x3mkvz
        1OFdXjpfXYGYPzFC9cZAXqaxfYFStYwuvq0JsXrX8D7HYnIsBkoBpGkaKYriB5DXQBHKMXOJoTbjHdy8
        10BXhW4VcgQaOiq0AfWrSq2qlKlSLZxXh1DTvEGiE8QYg0IQvQtD5wI5AZTWoFDg+QAa3gVac/d2QFBo
        3b0aKlgFaapk9ZJ5E0uehrqwj4DszgXyaor8umm7Qg45V2SJwkRb8bkZUIcYZ3IrCADotYUSRSRZEiJP
        ir8C2X1dYKDjTdeuQCxAGrJQOk1OAGJYBgoWBE+fB4oQt+wZzJVdEf9FRX7l7DVUpa2N1Cgy3CiDss93
        0NkytmV93Cipw67vlUr9miO8ZgiDPUfWZP8KSIjcYQVkCDMfWS35foJ8SgkCWOxEhd2usevsL1y4Vit1
        lt+1BDdatdJr1foTCBOd/vo7Nl6TR6owN8e7HM/NtJ99KjcIsC9+7RkAeLPwtX8UaKJGc+baR6rytyDv
        AbDUstnyfbsThs2Yv/81BHeEu7A3ub612u1/8q5Eb6nUp97p1SMMOBj+CuQ9AJbXkmMOdn1vtPQCIbQn
        /4t/wNYRBQtCaZ0w/KnjM+935/00vPw+00cvy9TqldWsxMj+FuQtAD9nmIJZjbhpL55pdfoUwGp8OOQF
        zOqh7hRfRs9Rxy0mVlchD1ixUBJZ59lTlrnD/DToyNGjB7AZugrqeI9ziP1BEU66RY4wRRVqUfV0SoDy
        TGaLieALALcwhkcCCHblDhAl5qwVhIrwZMiSTaWoeN/BEZo6wyGvTP7PAX62YeihGCZaDIx1jaMuZi2H
        eYrjx6jjDc4rmNkG5BOVuavFvzbmRgdlasAQqNehs5MJUy7nKILwUHW3ALsxH3iIGqEMj7fT2OMeZw/A
        cGy5e4Dd9L+DcKw946x+xlmdEBwEHwZgN4J8e77gWLvgLEKABzWW2IcGOOywww477LDDDruVPT19B3xJ
        D+GMWMoJAAAAAElFTkSuQmCC
</value>
  </data>
  <data name="boatSoutheast.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
    <value>
        iVBORw0KGgoAAAANSUhEUgAAADIAAAAyCAYAAAAeP4ixAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO
        wwAADsMBx2+oZAAAABl0RVh0U29mdHdhcmUAcGFpbnQubmV0IDQuMC4xNzNun2MAAAnWSURBVGhD7Zh5
        UJTnHceNMfguLLDAIosguJwucrisiCuCnAosCIIIcspyyKGwCwsLKCr3sRyrQDgEwUUJciPeUaJGzGEO
        23GSNmnaNH+0Y0vaaTOTaTrNfPu829e26cQxf7hWZvjM/PY99t3n93z39/x+7/M8K5ZZ5qWCcmROljKU
        32srqUUTFrWVubE0EQr4fhvtrbGOa7RozWMvbTGnatJHK/LDwVtDLfI4SzgyAgG/rPVIHIrStoIIWeSZ
        LlExO4O27JgeqvpmtC0F6RGO4FksYTGpCbsuz4+roC6LQJSvDXhm1KIlj7X0xCTEhjTdGlfjYl8xKjN8
        sMt7HWx5RosufM7SEkPyRK+hKv/L+almnKvdg8IkD0h8bSESmC5uFVg8UwxFUeH6+iwn5lI3kBJrwZw+
        FSLEIjst+tH8pBqX+hU4WeYDWbI7YgPtsENksxiynf9UMTweL95ijTlErk6fBYqFXOb284Q6xDZgv7tN
        uOGvp2oO+vF5nCDmix+lIHtfwMSZhu9uXqjDcFsSWg9tgyLNEylRGxEeyF+MDnUmYqgftGFvYxPP56/H
        2LmTaK4t/oC5/fwxMWFpwoK9MDt09G8JEi80yYMbSYmt9nI2tSXHV5nHtJCoJFUdycHdi2rMnD6Mvqow
        tBSLUZqxGVkJQiTt9vjWZq05bGyMq+nnVVWy+L2SYLw5N4QHd6dQJJPC2nptu7YxXUA6qEneF4i7Mw0Y
        VaegKNULRYmCRxvWGb0tdjPLI4KsmEdXdLSUdjy40YNLg0oMNcai54Q/TpX7o67IHycKA1Ell6AkLxwT
        Zyonb8+exsf3p/HHr97FwvwY4vZK4ORk18E0pRsEAp4mKzkI92bqSWXKRDf5tysy3JEX7wD/TWseR/mt
        vcTn80KcnGy+62uRY3ZAgf7aWPSeCMLp6iAM1Ekw0LwH59SpmCDRujZVj4WbZ/Hlp/P4w1f3cHl2EFJp
        Ajw8nL/j8TghjFvd4COy1xQeCMX8RDXmhg5D0xSLFsUWHD/ogdo8IYoOeH1fmCkhnT2EN9rS0H0sFB0V
        29F3wg/nVBJcUO/D+fY0DKlz0N9SiB71EVwcex2Pf/s+7s9PQiE7iM3uriBCwhiXuiNQLNAUZITjJhFz
        ZUiON9r3kY4GoEuxDb2VwThdG43h5nj0HN+FdoUYrQpP9JR743RVIIliJJrKo6E8HI3y4lRkSOOQuD8C
        D+5dxicP76CjoxlRu0OwcaPTFONOt0QGizTHC+Nxh4i5TsRMqpMwXB+KATKM+mt2oo8Iai8Vo+WwEC0F
        QrQWeqJJ5o3KvABkJ29DXno0Cg6lQyz2BtfMDDfmxvC7r36OuelBrTBHR7tFUpJtGHe6RZYp0XQ3Z2Nh
        jojRFGHy9RQSiSgM15J8OOaPjrKt6CgSoinHDZUHBMjf74LESBekJwWjtDAXFeVlEAqF4HCMkZWVjC8+
        e4B7t2egLD0IX293ONtbZTKudI+qRqoZJ9VpYa4Z10eLMdsrxWhbFEYaJBisCkan0hcnstyRG2OH3dut
        sD/SG7JCKRob6kliS7F+/XqQNzr8/fzw+aN7+PTjm+hQKRES4Alzcw5eeYV6cWKmNEc1d2Za8eBSM+5c
        qMDVM1mY7dmHkdY9OHUkBIpMEWICrBG7U4RDWaloaKhDQUEBAgMDtSJo43LN0VRfil9/cgtjZ5uQnBAM
        Z2drrF5tkMO4eTG8f71H8/BOHz661Yn3Llbj2lA+hpoT0VQUjgNxIiTH7YAsV4qG+n+JCAsLA5/Ph4GB
        gVbI6tUU8rJT8dHCFG5f7EFBdgw83R1gbGz4IZkJPHN69Byhylsb5fjs43E8fKuLlGYF2qoTkX8gGNmp
        kSiW5ZJI1P9AhLGx8b8joqdHwdKchzFNG955axAtNbkI8tlE7nG/JW27M050D1ufI97s5vb19dkBLNwY
        wNmTSshzYpGXFU+St1CbE08T8cTWmJuT5+R4h7wkhzrLsTfCC452FmCz2drpzAujukIhnh4d/Gbi/ClU
        lEhRkJcCpVKGxsaGZ4qg7dVXKewQe+GDexcw80YDCjMk8HSxggHL4JckKoaMG93T1dUaf3FmFM3VFSiR
        5+BoWclPFvHEnO3Wo1d9lORJN+rKUhDiuwFrLVl/Yr2orSaBYEN8dvYBdHeqUFdZhuPHy6BWt0OhUPxk
        EXTCr1xJIT8jAfev9GKoXYa48C3gW3NBIqJhXOkOelHk4GAPTX8XBgc6UXviCOrr6iCXyxEREaEVweVy
        wWKxflTA/5qnhyvO91aRZUMVDqeHQuiyDhbG1FnGnW4giRhvRzp69fI4Pn10H1dnRtDZWkPEKJGSEAdb
        WxsiwhT6+vowMjKCoaEhnbxPFUVXL46xGbrVlbg6pkJDeTI2i+xhZsymo5LEuH3+kPeAWpqehL88/uL7
        z3/xLh6+dx3zV0Zw7VI/Bvsa0FxfjNBgb2xydYSJCVvbWVoM/f6ghdHHJ++SJ0YPsfAQX1wab0Vvqwzx
        kVtgb2UEriEVz7jVDTEx4bsffTi/Mysz6e9vXT//s6vTp/HhwgTu3z2PO2/2Y2KYLHs7S5CeGIwgX3dt
        rphwDLVRoiNDX/93hFatoiB0c8XlkRZMnjmGAmkY3J0s8RqpaiQqzoxb3UEEraOPiTHh02mJMTjbU4fp
        kWbcmm7DlZFaTGqU6FOloSRnJ0liT2xwsIS1pekPovHE6FIsy00mS4V2NJLqFeTjAiue0a9MTCi21tmL
        g5q2s+WDtsOZMThWnIS54SKMduRgmCy4emv2QlWyC+l7RAja6oD1a83AMSLDTP8/kYmJDsXMsAqD7YWI
        Dd8Mvo0JHZHbxFYxTl4U1DSxCT09NvmH9eGzZSN2h3ihs3Y/VBUSIiaKrOXDoCoOQkHiJqREOMLNjgv7
        dRyw6eJgyEZ3sxIjXSXI2R+ETc5rYG7G0n0ZfjpUFrFcYh8R+9aCa4aN9lZIjhRBmeFDlsLBaJKL0Vjo
        hQqpG72pQab8dogIFkFxMAYadS5kaf4QCXgwNdHmST7T8P8LikeMTACpGmL0tOPPPFKaXR0tkRgugCzZ
        AxUZHqjPF+JkqS9alLuhUUnRX5uo3eXfLrSANZf6B5ui9jENvgzQcydKTOxrYt9TegZ4bRULXi487Z5x
        RSpZWcqD0FUpQXtxACrSPRAi5sLBmoLBauo35Dd2TEMvC/QcigogRsY+9Xti9NCBHUl+vrUpDu5xRe4e
        AYqTnJASwofQyRBrOKzH5BlTpoGXEcqSWAIxujK9TZa54LANp8j5B3t32I5vczVDuJgHT2cTcE30Opkf
        vczQ27DaoadkrlnaT2pF6Y5N3P2Oa42gT60c0361lOFQlCdzuswyyyyzzMvGihX/BKVCKrWoB0HcAAAA
        AElFTkSuQmCC
</value>
  </data>
  <data name="boatSouth.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
    <value>
        iVBORw0KGgoAAAANSUhEUgAAADIAAAAyCAYAAAAeP4ixAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO
        wwAADsMBx2+oZAAAABl0RVh0U29mdHdhcmUAcGFpbnQubmV0IDQuMC4xNzNun2MAAAUESURBVGhD7Vor
        lKtIEB2JjMQikUgsEonEIpHItsiWSGxLJBIbiYyMHTnyydp7qyGTnZ1P3p6dTGfPq3PqMOGXun3r25mn
        P/L/lUi2P35D/s0z3yyHQyRZmtxsGO89RAECSWHYNJqbDZvGTpL4ECaQZepvMo73zmMrcRwkI7EcZyuD
        Kb80bpmsOFtJDHfcToUjeZYokK8MJBvHeZChy8MEUuSpHOFa01BLV6cfGrhMgyyuF9NkYboWgTBGprGR
        voWR76y2srGMANtKW6VhMlIWmQJhEFu4TVP9MxXPzqpbub6SpgSQEBlpquICZDC5utf1ivvYGNWteL0G
        kCDTr+kqjRECGftC3cs0r7EyIzbIxnRhLEUBDRCI7RsY6oG4vtSsNJhCkiQWsrEiNsiYs7XY1gPJkbK3
        x8MRh0rN9KtAbCkjQIwEBIBuMD4RIMh5joy0dSZFfntLczdhkVMgjkAqdS8aTQamAWBsg8/+/A6kLAIE
        QtdZAWRxnQJxBAJW6F7XSiA8dk0uFQJ+ezwUieS0OsQBi10HBggEboXsZLsMMQHFkZ93pvquACs5gASU
        gvMsk/NpltNxROYyiJP6EifDFZARQHheXQ9qTYVkEFDmmtwIRuYrRhgTlboQQfRIwzx6Rkpc93HDVMxk
        sL3mfhJhEIrjWDVJEum6VuZ5knlyMqFqMzsNCGqutO1KMUizLQpjiyrPo0Fc9DjP6yPu40yyIK7WxUlv
        Wknxzv39/K7ta/97qapSfr08y/PzSdbjIg5M2N6IAaC2raVt0HrUJbSQuvLBXOaxFFmsR36uq0yvdy0Y
        67EQKJRk8/l8lJfnVY/8XOTZ9zL1AhDn84qVnKQHiN4AiOkAplOGLto2AAdtahhe6ZFgeV6180omPIij
        Hic36Pnt675PyMr5dAQQp2z0PXqnAfMF1Fp7kxqAL8tS3YfgyMRpXfCOHucLORzulADW44R2fJIJblFX
        ldQ1Vr1p9PiVVrg/TVMFQT2f6E4rXGzE9Ury73apa6nBigfjsLqcvX3w36I7ACoN//VylhMYtrZHXGBq
        vG9HHCmI49HBxUYY6LMMXeLa0M+U72DCYOKgmzZIFHdlw0ukAcxpb0FrzmxF434HSFHkl9iw1igIMrt9
        wb3ErygbRSr3s+gSNPAWMHyWMXE+LZp+mbLz7Mf6Lvg4psIZE9/kDGpErkbeAiRDsBMEC6FFLckx7985
        Nq5lW1m2JNpq1BcQn4HhMwM6gNOKrIdF4GJkGdt5XvsxiZQJHZgwd3AnhcZ+BiRBHLByc37vTaMu9YNs
        7OJX2GmTWGsftRv8Hhjey0q+Its5xBXbGL/x/aNs7IJYKdGia7fLoPW14j0gPMe44CZd39V6bwBs7OJX
        mmMsgbQYlt4CoPIe9lucJN3QbWww3QbBxi6oK+hqCcRi8ku3AvlWWTyZrl/ZCAoExa+4DlLbntU1AF5j
        W8MCurNBsIGxQdmMxbxBINyc4y7iNRBul84bG0y3Qe77evEG70Dq8rVBZGvOdPvKBgM8cCBVkSgQzujx
        lrnc6FuZS2yEy8YuGyu60VDoSMuC93c2goyNt+KB8CcDZjDuLhIANxkMZvRAM9VH4uOCadhvkfqKXxVZ
        6LHxVjwr/EWKu+49lNmMIB6IjWuJ9PcR7mnl2QHp2APcLj6W1Mhg1DSJHiFTfSxR9KQbcw/Nxi4E4oP8
        wYX/OENmto9/5HN5evoL29wP4R4iUDsAAAAASUVORK5CYII=
</value>
  </data>
  <data name="boatSouthwest.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
    <value>
        iVBORw0KGgoAAAANSUhEUgAAADIAAAAyCAYAAAAeP4ixAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO
        wwAADsMBx2+oZAAAABl0RVh0U29mdHdhcmUAcGFpbnQubmV0IDQuMC4xNzNun2MAAAnISURBVGhD7Zl5
        UJPpHcddD3wDAQIECYJgOA1yGBAxKsoRFAIIgghySjjkUBIgnIrKDQlIFFgOQTAoIiCHt67iseq669mO
        s3bdbrv1j3Zs2XbanXFqp863zxujo113948VlZbPzG9e8l7P7/s+7+94XqZNMcX/DdQWzR+TFwMDhoqp
        w7yh+Tk54fG4qgChO5bxF/yDz+OaaHZPLng8jip2gw9Gu7f/c2/55pWa3ZOL5W7WqpRYX1wZqUZUoDu4
        HJav5tDkwUfAU0k2+ePqSBX6lHGozRbWaA5NHoKFbqqsJBHGBstwrD0ZOfHu4LCoMs3hyYE0OVC1UxKJ
        80TE8e6taCkNQE407767vaGl5pT3h46OjpLJZEZqfv4oinKxqkWeistExKnubKhqw1Gc5IwF8/Q+JTMy
        Q3Pa+yEsTLRWnBgDKy4XHA7nR8UMqbarBroKcO14Gc4SEYcbNqBOtgQZkTYQOBllaE77SUhqJlmNmpjM
        dv/22Oq/P/7m2emTA7CxsQaPt+ClGKY2S0AGLvribKvq8kg9ESHHWVUOjipj0L7LGzs3u8Br0ZzHZDbM
        NJf8gNW+S1aROlO4tzyxb6G1OWZNp8bJPW01h98OZDbmpSTH/Ovr39zAg/vXoepoRmrqJjQ310eWFcsE
        i52cvquvyca9y+24eYKI6MvF0Y/j0FPlj2bZMlRk8BGycu4Jze3UEKdNiGlFhfvVxketOTncXfp9/bYI
        FGeKMI+tN27AoJZqTn27XDx76Ff3Pj+L0yO96OpsQkuTAsdG+jDc1/X92dFOPLw7gDsXmnD5SDFG28To
        kYegc5cv2kqEyNnk/ozL5fjR9yHOx2SlbvBOTQi9X12a+e2FASXGBhTo2x2HnISl4Myhxs05zIkRER0m
        Gj49vA9jp3rRVF+Oil3bUFlSCHlZMQYP7cW1c524d7EZnx8rw+n9KcSpEPRU+KKjfDX2VYRCkhwIOzuL
        p411+Y2l29IwuL/66dhRImBITtJyLpSFQUgMsqVT8zixiRFB3tPhhOgw3L42iDMnOoiIAlRVVmLnzkLk
        ZaehOE+MA3sKSIqV4Ux3JkZbN6C3OhCdO7zQTmajRx6Jg8otaK/Lxs1zrbhyTInzRypxokOGgxXrUJK0
        HCGeFuCYEBGGEyjCypKLA62VuH7lELraqxEXFYHs7GwolQ3YXpiHrIw4ZKeFY3dZNLrl0eitX4euUiEa
        C5eiIV+A1p1rcHh3AkY7ZThBstnIvq3o2R2DPYXLIYlxwRqPeeAYTagIGmqQFjLcK8flTzogr8qFpaUF
        goKCIJPJUFNTjYICKTJSIpG5SYjaHBH2bvNDU4EnGnP4qNvKR4NMgJYd/uioCEd3TTjaSWGs37IM0lhn
        BHpawpKjN27KYUyoiBQtLSa2JofhwvBuDPZUwl/oATbbEFxSSwICApCVlfVcTL4EqfHB2BThBlmyG3al
        OKM2zQl1WXzUy1zRWLwCbSTwW3d5oS5XAFmCK8J9rODGMxx34LImUgQNlT5jhjZ25MbgVG8FeprysMjR
        Ftra2kQM+3Ux1VXIlaYjNmIVwrzNkR5mhZJNPNRLXNFa5EFqyUrsK/PF3iIv5CctRlzIQqxysxhfyjOZ
        cBEcYneWL1mI4z2ksKkKkBgthIEBE3p6emAwGNDX139NTDURI00XI3y1G9auMEPmRgfUSj2wr9QHBxUk
        +CsDUZnjhZQoPkQ+3HG/FdyJFkFDORN7stbPHX2NaWhXJMDX0xkURUFXV1e9pe0HYqoqsSUlHhuDPRAd
        7ICSDG/SLAbjiHIDOuXrsEvig5i1Lk9C/e3fhQgaqtyEbYSmio0kwyQgL2212mlaBGkaXwp5o5jqSkgl
        YiTGCJEauwy1RaE41JBAUnA8SrMDYTHXGOT+72JhRekS+2qhtRkUxYFoK1+PCJErDFi6IN2v+rV6Vcib
        xNAxky9JR0ZiKAq2hqJbSYogSbt5GSJYWOi/q/UIRTeAf4sNdiMiQqDIW4MFNqbqIKfj479FvLAXYnx8
        fCAWi1FcVIisLYkoyo1HR50EZ4aqSEUvOaoZZKKhixL1HYek2AJScfcWBSBxnRvMTQ3VM0HPyJtEvLAX
        x+fPnw8+nw+BwANJ4gi0Krfh2vkDuDS6D4pS6c+uZ94ClDexZ462piT3C6HI9YXvUhu1c/QT/zkhrxqL
        pQ+2kRGiNwbhWP/H+PbBGO5eH8b6QCGsLSwmWgylorR0EC3ioTZbgKzoRZg/10jt2Jti41XT0qIwezZF
        aowxvFauREpKLM4d78fNqyfx+A9f4M+PruIvj27gk+Pd5BWc/5OLs18IZUrsT7NmMkj74IIaiTviSEfK
        0nvzLNBO09sZMyjMMTaGqTEHGanxqK3Kx9f3r+Kbhzfxx0e/xpf3LuP62FGcHO3CtTEi7MoQ+g/ugckc
        Y/p6kWbwtwkVRQzuDhyyvnZBsdgJTlZs6Gi/PhP0k6e306dTsLeaj1UCd5KlstGv2o0714bwuy8v4MHd
        87h6aQTHh7vQ2CiHTLqZJIAoRKwPRI5UDHlF7i03R7uH2toMO83gbwv6gwB1iRZCd6NVmXz6iwes57Fe
        Cpg58/kssPSN4OriiMykKLQpt+PW1SP4jATyZxe7cOlYK/oP1KJRUUD6r83q+AhZ64fFzo5wcbF/amdn
        1WhuPreBHtFHwGerh367qGvHp1YkHorj+diT70naDCswScqlRdCvD9/JESI/T7QoS3CorRTXT7URx1sw
        crga3U1FqCtPR1ZqGGKjhPDzdoWnhzNsba3GFy60G+JwWAHE1CvECYYq+OgjClxzQxLkvqgrWIsgoRv0
        dJkIC/UnPVQsTvbW4cRAPU73KzDaXYruBikqC+MgSQrE+iB3+C5fBFdnG9jbm8PYmAV7a7NkEtAWmgHe
        HSym7tDmdY5oLgmESiGGbHMYWuRkIdSjwPnBBhzdvwNt9VJUF8Via6I/qfZL4Oe5AK4OZrC1MiHBzn6i
        r697e/ZsnTTyUJI1t33XUAxit9LX8dCQ600WQdFQKdPR25yHrgYJasiTzxIHIDJ4CRa7WYPvMI/MHhtz
        TRl/1WHofEX6L9J2qBvN9/+vgvWrLAdyY+xQnOii/pohTfBC2kZfhIsWk9fGAc52prA204ORPhMm+tQB
        4rSKof5kQ8fXBwJFTctf5miEOD8u/ARsrOCbkNUbB4vs54BrYQAzjt5vZ5GAZ+tSpIhRMZrLPjxWLWJv
        FAk44Nvpwsacgjmb+rehAQVjI4aKOH7JwIBikq295vQPExZFudrO1YOrvQHmsBiPdWZTv2dS1AbieObz
        M6iZz7eTAG1qej/bQKuJOG1IzEqze4oppphiiin+h5g27T/8sSq1mpXgwAAAAABJRU5ErkJggg==
</value>
  </data>
  <data name="boatWest.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
    <value>
        iVBORw0KGgoAAAANSUhEUgAAADIAAAAyCAYAAAAeP4ixAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO
        wwAADsMBx2+oZAAAABl0RVh0U29mdHdhcmUAcGFpbnQubmV0IDQuMC4xNzNun2MAAASbSURBVGhD7Vgr
        kKtYEI2MRGKRSCQWiUReeyUSiUUir8QikUgsEhkZGxn5ZO85DeQzmc3OvDe1m2zRVV13mEngnD79Y3ab
        bbbZZpttttlmm+2yLJX9fi/L5fsZCZxPB/l1Ponv++9ChBGf3YDANHZyPIxyPE5yApk3IHIlYE0m49Aq
        iXHoZOhbeIfrQYIgeFUitwokMnQ1wDcyjq2S6TondVVKBW/bRooifzUiVwJZGkvfFvBKiQy9gzdSljnI
        ZSBRSVWWSqiHMssN/ku7gqebNJLWWelcLl0Db0ucpeQ2Qwr5Wg/GGHHOgVQhJdToO6gEZeIoWu7zr9o9
        AZtF0lSZNHUmbW1wAmxlVBnf97TF0lkP1tqZSFFInhuQqOUw9WgAPU7UEdKQKrZNAcUsPpfh/omkSSRJ
        HKrHUSBh6MN5BuJ5K5Yv2z0Bk4biygSeXrwqUn2Y510J8Gc6iVCRuq61NqhU60qAd3IYGz2nHjV18UrG
        jul5dV6vf+c1FY9AZgH4T3ZPIEsCqYv4xhPJTayRWsHfElivPxKxBuRrKwPqaexKPel9i5RDan70rmHa
        GqieadACqL0A/KrNQCwUqPNIqhu3WSgh8n8FS/9IYPVHIonUZQZwFkCRZo6puXoqbZUiZan4HDA+rzCh
        +JpK37a95ADLqM/pg4fjhiYNNCK3QP+OwOp3RHKLDkaAAHwDvAVwgm+YsjfgbRb8HoH9ficGKVRaqhBr
        MbdIA0bRfwL2md8SyUEkg8Il7s3gKHBEnmejSsxB4/N/i4CHB6axr04iOSJRKRHkpitQB+GnIL/id0Ss
        0WfkiDYVdkUEdXACPDufQ8diy15gfd+oRBigw/h7nHsA97Q7sRt1aIkjBlvb1JKmCR4yF/9noD/zWyJc
        W5IIRBgoVR1ESAhEWDPsZmytC6w/sb1KOhPy0KkipAHSC6ro2gFCPWYAF0GC/AqhZ4pQjasi6GRorZwp
        PVaanyO0kGF7ZYFWxZxm/bJHcf0gMBb6M0L3NcKBiRqxrBHWxnxqvaAeuR3o3MB6swbthwn5D4SoEKM3
        YSmssE8Fupp/TibDrkUic9dCC0fKsrDZtbRbXZy/Q0vG/Biwsykhnfo/qRBSjgpFD4QwmbHlcuVwyPEo
        DB8IhfhdiYWRRK5zBN9HC1471WXQosnwpFLtqtJCisH7YUIfFMLKwFQ4THyBGpB+jSRJfEcoTVMMRAsy
        3M84ra3uaRVmVYFUy02kzmFLZ7PhMOY8Ky07HIjh8/O0L76zojyzOeUiLHEXQiXAIXJMNZI5nyZ9iTLo
        VCsZEnHVDITpQ2VyrDmsmxRtP4kDiXHPKGQH9fQZDNzlXH7m3zgyiGMB9KfGGyPdEB3OGr5U1QDKrnOY
        Bn2t/XU+gtikhc5a4t8GLH/zzJgbxXKzV7CFENSJsQVzMaxrLIR4vT3gXf2Ed3UqdDqOWktUbfniq9pM
        iOrEMfIdK3tdV1ozVOh8IqlRlVm+8PrGN0OSSeJY68S5SklQmRCzZfnY+5gqBEJcb7rWKZk3+r/Wo3ED
        YNdijbw1kdUSqMNWvFxuttlmm2222Wab/X9tt/sLv/AP4ZlSTOUAAAAASUVORK5CYII=
</value>
  </data>
  <data name="boatNorthwest.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
    <value>
        iVBORw0KGgoAAAANSUhEUgAAADIAAAAyCAYAAAAeP4ixAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO
        wwAADsMBx2+oZAAAABl0RVh0U29mdHdhcmUAcGFpbnQubmV0IDQuMC4xNzNun2MAAAm+SURBVGhD7Zh7
        UFTXHceJGr0LCyywyCIILk9BHi4ruogosIvCLgiCCPKU5SEPZRdYWEBReT8WZBWIgCAIisgb3xjFR9SY
        mKjtOEmTNG2aP9qxJe20mck0nWa+PbveNNVo25mWjczwnfnOfZ177vnsOed3zm/15jWvec1rXq+tWBTl
        RZ/OXelTC4Yclxlh02r2TorSK3p2l2LQRyWxIfHCZ9evsdgmi1u9nE0g9uFgvZsZtm+yHSYN/4DFNBx7
        4w0K5Pwd4pvEscSW9GuvoyjTpSzGU56TIRKDuCiId0LWNhfs3uYGrrUp7JaZaWC+9++I+4gDiAV0Ba+L
        KDuDJdSvHawpBPmwUZriieaCALSVSVCfJ0RpEg9b1i2HtysHby5igFpsoAH6jvgrYh9iMvReEzEpaoc1
        m/r7Bp4F8pMF6KqKQ59KikblVhwp8kNNDg+lqZ6QJ3giTuwCN0dLcNimGqA/EX9CXEnsQcyhq/ypROWY
        mlDgu3AgT/ZHnzoLit2RCBXxsXWDHfLjXFAqdUedzJv0kg9aSkVQpvoiIYyPVfZWsGBrh983xA+Js4jT
        6Yp1L3MzRt9q56XI3CnEQFshjjUoYWTIBFNfH/bLWXC3YyMx1BG5cauhKhDiaEkIOirDoSqVoLVqJ7YG
        ecN37SosXKiPxYuZGrAR4nG6el2JWkR8k2tjgijxGvQ0yzDRr0JkRDAoitLaQJ8BlpEBVpDJLxQ4IGUb
        H6rCLQRmO/oPJ2OwJRPn+/NxoCAee9MiYWfL1VrnMCYmFNOKY/RLoa8r6ooTcW2kGfKsBPILPwN50daW
        pljpYIlosRcKMzejU5WM0T4lLg1U4fr4YYwPNOBkezWS4yIRFynWwkRGipdrPza7opzfJI32cLJErjQE
        oycO4OJAI3jubli06AcABoMBY2Nj7VGfDDsTlqH2WujngZQ4EfpbCzHSX41bb3fh3u3T+PDuCC6PH8eN
        qdM/S0+L/9uTD6c3E6Ct9EdnR2xDKsbeyggxYWvR0STHheEmiIP8sGTJ871hYGCgtZGRkfZoaGiovW9i
        wsRqN0cEi9ahoaYAPZ21uHKhC9OXBvD4vSl89ov7+PPTz7+TpsRr3lPTn50NUfFmxkys4dujtiQBl4dU
        OKYuA8vYjEzg52G+t6ZnmEymFkYDpuklNgnNtrY2SIyNRtUhJVqbKnF5YgAfP7mHyxeHYcflat6JoT86
        O7Iwpk7yXJdjb0owJnvLcbqjHF6ebi+FeNEaKDabDS5paGhoKPLy8lBTXU1g9qGnuxV9XW1wcLAHh8OZ
        XYhnovq41mwyideit1mOe5c6kJMaiwULqB8NsRetmSsaiJCQECgUCqjVzTh4sBjVZcU41qpCRsYuuLis
        1AWEnh6DQQmWWTL+GOS3EtUket08dwwd6v1wtlvx0sZ/73+FyM3NRV1dLfYXF6IwLxMNFaU4NzGItrYm
        3UA8E2VowDD4xMvVCrJUCSbO1OKDO2exycf7laH4ZRBKpRy52YkoLZRi5PRRjA/2fF1RqiB7Mx2KTMQK
        RzsLbA/1Rm9rCd69dhJ1tXlYam7+nyFqa6AskiE7PQZ5mVE4eUSJu1e7MTXZjTXu7l8x9Vm6hKE8LM3Z
        3wh9V6OxMgvv3ujBUN9hWJpznoteL0LUEogCeRYyksKQs0uEwxVxON+rwOMbbfj00TCa6vI0K30J/RFd
        iLIwNjb80MvDAbkZkWSetOPh3TFkZyT9c8Jr1o/nIGqqyU5AioToTdgVzUd9vhi9DXG40puD985V4OH1
        Vjy+1Yn3p9pJPqNDLVlikOnsbI2EWBGGTtbjVx9dR31NEQmvPwyvwMBAuieqsSc9CVGb+YgMsIYijY+j
        +4Iw0LQNk+07cPlEOm6dLcWDCw24NdGEsb79uoMhaW6auTkLQQFeaFEp8fGja/jsyR34b9yohVixYgWk
        Uql2TshlUuwMW0e2/FbIirTDoXQPtCr90FMuwkCtBIOHwzHZIcXUYAHunm/AcI8Sqkqp7mCc7a3S/NZ5
        kMm7G3duTuDzTx8gPT0BLJYxeDySbJUUo0iWhZR4EeLCXJGz0xVlu1xQn+mOlnweWooF6D7gj/4qIfob
        wjH6ViKm+vIJTAVJEzIgT5PoBoaswDaOjnYzcTtDcX68B7/98ue4en4IbDMz+PisQ+6eFGSnRCAjYT3K
        sgNQL1+HJpkXGnN5aNzLQ3ORDzrLROiq3IzuQwSmJhij6nhM9ebh1kgFDspiECbi6wZm1SqnsfCtQWhp
        acBHj2/hwZ2L0IClSqNRUpAE5d4I1JdE4Fh5GI6XB6K9hMAovNCs8EH7wS2kJ2JwvCoCHQSoTbEenYcC
        cKZ5By4RmGsEJjdVjEAfl9mH4XBYIWs83KCQ78a96VE8/c37ODf0FtrV+9DVKEOvOhOnm5NxVr0Dp1QS
        0tCNJBXegGMHgnGGJFyn1HsgS5Mgf5f3d1XZPBzc7YlGxVr01UeR0LwX0wRGtisYvnz72YUhIEGens7f
        SqWxuDjZg99/eQdffDyNu2SRvDJWg5Hje0ljk9DdsA3d1RIcrxCigwyjrqooTHYr0NmYBycnm2+5XE5Q
        +MZlF/xXL32aHeOA0lQP0oshONeZhjsTNUhPEJJ9GGd2YZyc7Fqit0twd3oIf/jyPh7dG8fNyeMYOVE2
        WpgtRnmeBIdkgajO9ye5vD/aD/mjty4KF0h0enC1HS2NRS10VXocFmXl426WvXK50Tv5cS5P8pO8MahO
        xO2JWiTsCCQw3NmDsbZe1pwvl+LB7TG8fb4X2yUiqMrl2g2gjY1xhc0yc8Rv9fwmPZaHotQ1aCwgk5z8
        2hOkt26fU6N8X6amgfHaymgRoIXezqa25FhRnyeqi5V4k7Rh/19DRN4kQWPMHkxDVcEHQ6eOkNV8Bext
        bF7YxVLCiGBngTiQO5MYvgqKZC807VmP/sPxuHa2mvRc7be5GTsC6MIvFZfDEh6t3L1xPW/lX5gGzPuk
        zj30o/+fAn14bL6b06cWS83/bVIUtIEr2MS3mYkKtIM8wQNHin1xoUuB6VE1MpIjnpBesaCLvlK8/6LM
        /yR9fYYTWdHF9OUrJXCxEPBdTGckfraQxXviVNU2TI81oLY85wsCspguNjfkymUJbDlGM5r/jMtSfUlk
        KsD1YTVio4Lq6SJzR5YchoBjRs2E+9lAXRyK6WEVkmK3XKQfzy1xTCkBx4KaSQl1JBvHRIz3ln+9Wbh2
        E/14bkkLw6JmNP/yN+2L1oThYvrR3BMBEXCWUjOlOWIcrUwZpG/PTVlzmILlbKOZVfbWICF2I317bsqE
        QQneXEDNkMVuboM8E+VIn8xrXj+99PT+ASrXKrXzqbQeAAAAAElFTkSuQmCC
</value>
  </data>
  <data name="boatAnchor.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
    <value>
        iVBORw0KGgoAAAANSUhEUgAAACwAAAA6CAYAAADLC7uHAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO
        wwAADsMBx2+oZAAAABl0RVh0U29mdHdhcmUAcGFpbnQubmV0IDQuMC4xNzNun2MAAATuSURBVGhDzZkh
        l6tIEIVHRkZikUgktiUSiUUikdiRkZGxI0eOfPb9lZX7E3rv1z2VIaTm7Z6zIYO4J6SA5Etxq7ogLzHG
        f1Woy4i6UOmtf8yz5AaXapsy9k0V38Y2/n3pYlv/LLQbRMXxEPtQx/fXPmX3bcqwprosdJh/7pZygwig
        35chNlUZawloQP+amwzd1DrMP3dLuUEEcBDo8XgUdJ2yPQ9tvMgaJ70CHH4A2g1WxTG+zW2CRZXgS71+
        DHX8PTXxVcCHw2FfwKcxJNhQN3Hse2W00a4o8CIOXZ9eQ70T4FIFhyUMeOi62C2A67KKo2IGbFeC7a11
        FzjqUnPpl8DTMKgHZ4vgZ+CbDJtiVZm9/gzou0ChL/2Qfy9DI9gqQbRNiK/TGKd+iEMbkqfJrsGWRZH2
        8ePWn/do3QVK+Xeoi3jpBawuQXERayps0MYhNOoYTayKDIr6EBIsx64/79G6C1BwB4WBJJNYxC43QHgX
        QMvs2LaC10KiH7T+rC10FwB01HI8t+q7UiUog24EOQ1jKkKAyXQnPQsWuUF67qRB52MK8X1qU7a/gAdl
        VUUnu/TK7jNhkRtEdAnUVHSLnGF+SCc7kFmW62fDIjeIKLhBWT6H3LKSNQBWS5t6LLGz4ccEJJlMXUIr
        XhAw3YIfsD72GXKDJsss3YBCS8BqX51miN0B38CqyIClMwAclO1dAa9hKTJWtlrAo/xLd/CAOQ+t44/U
        XYAvZHkGlpm3FShjJDGENVg4vA7BuZy3JfTNG76oZrgJnfqtRkqyqve2z7yMhylCO8+Uj2EFzEv6ev8j
        dPOGL6w0OjKRzSPDzNe8m2G0oDC5CZjtl5dbKAOe5XeO2aJP3wX4UtM6Dox1ioJLv8qiHcM9H773rsL/
        lRv0tARmFqbouDHF1+tjOo2j+J8itX2Pkhv0dAWWh5mJAR21CvYakKzQvjKsYt0L8Kxi5A66kIfnrlIR
        MhtnYPbbHQm3UevPeITcoCcDYo6gN5NhhqKu0V3J5/jJfuyAdgVMQdElelniNOZb/iXwVrDIDXpaAtPu
        mNZaFR3AdAUynu2wQ2ArOuZlYNmHLb7s8PhiM7lBT2vgPNyT4expbAFs2BAWuUFPS+BeXaBX28IWAF9e
        80PDVkv6ltlFN2/s0i5jphtgFV1aerGEWhzP2ujFW8Oi6wZADD0UDNsWX+6/WkKQ46ctOm2nJ5kqwPU5
        W+i6kYG0emklA2wJzfYaeO5CssFlliUkzrXjt9R1AyCmq0HDOR3AoA2UlkXcbvPnvk1Phlj1zmPOtn3W
        lrpu4F2AyTCQ1lcNFNEF0iwhD+fhvkrZxQ48MbLP2lLXDcswtz+tXjvBIFrYjT4fU1F4gwafX6dBNskr
        n33WlrpuLDPMMLOE5UfwSIpbI7JKNxh5lNVroZAlLunp0JMtgQDh0rOdbWFPf6rkYzLL+14WmFR05+nz
        ziId8wPA/0V4tRPwu7x7nnsVYftt795CbvBPojMw9FB0AHe1rsKT7IDc4HfCv2dNZ7/OU/IuLe1Z7czk
        BtdigZh0Z5H+GVWBvasz9KFSO9tujPxObnApqp8/FD804KQ/F1VsaTn+AVjkBpdKbUuwb/LraaLlHX8M
        FrnBtVgk6LtdoyX6yZ5dyw3uWW5wz3KDe5Yb3LPc4J7lBvcsN7hnucE9yw3uWW5wv4ov/wADTuEmApvE
        QgAAAABJRU5ErkJggg==
</value>
  </data>
  <data name="boatT2a.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
    <value>
        iVBORw0KGgoAAAANSUhEUgAAAB4AAAAeCAIAAAC0Ujn1AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO
        wwAADsMBx2+oZAAAABl0RVh0U29mdHdhcmUAcGFpbnQubmV0IDQuMC4xNzNun2MAAAgwSURBVEhLTVZp
        c9pYFpVtkJAAiU2AWCS0IHYHvGH2Vey7DcZ27NhOnGScbifdPb1lUtUfZqmafz0HM9M1qlO3rlTo6HDf
        fe9col83oprE0CRtIW1Wxs3aHQzjtFo9LOt1OHiO8zmdAY/H6eRY1sZxdo61OR2s4PfyHhdyj5vlPRyi
        4Hf7fbzb5QgIvmDALwg+otuqimH/hpoyc3a7w2q1WyiOoT0c6+E4r9MR4D0hv2/L6HY7wehycuFQwOf1
        ODi7l3cAYA8GeEkMetzOUNCPJBwOEo12NRiULBbaYqGsVoqhqRf5NF4DBQAKAAleg1hEQBJDkIbnkBUO
        +bZQlTBu9WgkqkU0TSWa7aYkqiRJWSwkTZvBa7cx4AXwJpSCFH8T8PJuAE8QI1JYjoiKLMV0+U8kE9F4
        TMm+SmbSsWQySUwmi+OjAsc5zGaT1UaB18pYXoroBAVrt26x/QaeI0c1Q0FBDAfliASNIAVjIq4m4npU
        VdIp0Mbj8RjRbA46xuDVqyzL2i20CW9uhYMXwpFsqaEavCgUEiwXKo6ID8iRgCKHNFXcFEFRdS2aSaUR
        FUUhOp1Ru91rtQ1d1zkHuGgLZWZt4HIxDG1lGEh1YD29PL5ts9mQBAOC4IdwvyKLEVFQIkFAlcOqoqZT
        6Vw2p6maLMtEq93pdPuD4bg/GB2f5ENhwWqjUR+3y+d087xP4L0C53B5vH4762A5F279voDP5xfFoKKK
        ybgqSwE1EtQ1SdOUbHZ/fz+NNdyons3PprMFMJnO20anVCmkM5l0JpvNHh/kCyfFSm80Lddb8fQrNZbU
        4ik9kZEiUSEQkhVFlELRaEQUhYgcCoX8uq4eHubS6WQ0qm5Ug3G5Wq8vrwHklWaj0em2e+NGe9gbLybn
        l8vru3Z/Uu8MS43OSbl+VKwdnFQyuRM9lfYGA6IUFgKCrEQAqE6lEoiyHMFFDEeTi/UVVKMsjZZRbjQ7
        w8nk7Gq+vJ2ubq8e/rK4ehgvXzf781JrcFIxgIYxMQbzQrV5VCzuH+TUmL5pQ1XRde2FVwK1LCtEbzZt
        GP3eaDaYLA7zxU5/NJ6vJmevlzcf2uPl+vb97PyqO5jOzy6mi9V4sS7Ueov1w9MPX8+v355d3p+UDTzJ
        l41irXtarMjypszg17Qo0RtPxotVtdU9KlROy/XxZHH5+uH86u3N+8+rNx/704v+aHF5eTPojRaLVcMY
        VpqD8+vHTz9+u7x7mizfdMeXwNnl4/2HH1eXt4nEvqZGk7FYNBolmpVWdzQr1duxdBax1e7Nz69Hi6vJ
        xd3y9sP5+n66uLhYvz7IHeVyx+V652x9d/v4+edv//rr3/752x///vj89fbdl5u3n2/ePq+v72KxtBSW
        4mgRVSUKR+XjUq3RGewf5l8dnfYGk+5gvnr9aEwuqp3p9ZuPy/VNrdZyOT3xRCaiJUfzq9nF/fvvf/3w
        /Nvzz388ffn27umXH379+/2Hn4zuWNdTiqzEUHJFJfb3T6rtXjyTU2KpUq01W6yg2hhC7lNvfjlfvbm5
        e290BixOU9YlhNXx4vrm3fPHz7//9PUfj9/9AtX/w+/lmgHV2C/Yi1hHwpM5iMb0eDKRTCcPjg5P0SWT
        eWs0NdDmk1ljMFo/vFve3uMPHeRLp5XGcLa8e/zu7cfn1fU94vrN083j9w+fvkwvrw9LlWgyo8fTiqyL
        UoRwSRmzmWFZTzAoZ/aPsqelYtOodvoVo1fvDbvTRanV6YxnlSZOmkmrNxrNl4Mp2D+B9+r23fj81hid
        NQeTUsvI5fOpbE7XExFJkUBtt8q7uyxB2CwWTzSaLVSaaOyTYrXe7p+WG6DLl+ooVLM7RN4bz+tGvzta
        VFv93vjMGMxa3Wl/fFZvd08rlePCKQoQ1TRd1SIRmaDM7p0dcm+P2d2lWY6Pp7InherxaaXVGTba/Xyx
        Viw3esONajTo5OwCwmvtQbM7Xl7djRbrwXgxP1/XWq1Mdl8I+HDexrB3sBdR6z2zxWTeM1NmYmdnb3Nk
        OxQ1fnhUKBRrmf3DWt3IHeSP8+XDfBmNjx14UqoeF+v5chPshWq7UKxmc0dCULDZGZeb1RRRk0Lx7W6k
        zBRt3t2cpCRF7Jh3dyiTiWbtMJSgEJa9gsj7ww63n4Yb2zgn7w9F1LCsiUo0IMq8P2i3WynKTNMUfBnm
        AC+I4thGg0gyAS+0UiaahnaS2DHtECTq8yd2d6k9E72zY6YstJnEb6gtLLSVZmyUhbFaLbB5n48XRRiC
        DKPZOA1Ug5o0kTaaZF6od/ZQdMCMaDJRBLFrMpGk2UKSFuv/XfaXCwmDscLJYS6IRET1hTeVjEM1jE0B
        td2Kv2SC58J49yiGerksFgteYyiLjWbsjNXtcPKwXY9L8HoCfl7w8XB2v9eN6PV6JCmM3YdjL5mIAZtq
        bKlhTzS5h3qBj2KsCDYbA1CkycnaAZfdHuB5AWaIMQF2jiEGpB5ngHeHfB5IBjXOfiAeg6OjHBEcsQr6
        GuYEtyWpXWCjmzRhFIHDwnCdLg7zkOBxS4KAASoEhSzrd7mQI+JWDYfhvBgcUAQUGtiQvgB2TKiaDqUU
        RcKuSdK0pd6yc052M8T4/crGnnwyphqeD/t8QS+/Gal8XikQwNADmQB4/6tXlvCxiBQgGs02+hvLQqOD
        UGWMZyBlbZtJgbVhNNhQh0NQh2EMt9v5BIwA5gUApBh3wIveQEFiOtwA3wgRMPL57Pwgd+xx+0wmzGfk
        dqBxgN3FORz2kM+nhMOoKeqBNXA4WHQFcjScGwvr94IXMredl04lsJKb7tak/wCwwKk7K8PkFAAAAABJ
        RU5ErkJggg==
</value>
  </data>
  <data name="boatStop.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
    <value>
        iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAABGdBTUEAALGPC/xhBQAAACBjSFJNAAB6
        JgAAgIQAAPoAAACA6AAAdTAAAOpgAAA6mAAAF3CculE8AAAACXBIWXMAAA3XAAAN1wFCKJt4AAAAB3RJ
        TUUH4gcMAzMSajrZoAAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAGvSURBVFhH
        zZc9bsJAFIRdRPgIVPRpUsMVaDlHDkBDTU2D3HGVIOUKERJlThCFA5j5knESZwmxwc7LSCN5Z9+bXe+v
        nTVFWZa5OBULcSvuxYPJMxp1xOROux4yG4pr8VXciUtxJk7EkTm2Rh0xxJIztE17KHkgLsQXcSPeuupX
        EOsccvEYuKoZlMBbP4oP4p3l1iDXHng1Gw0nPYsr8cbyxcDDXniefxkF8OYE3lvqDHja+/RIqII5Z6hW
        ljoH3m4jXRMSWSzM19XD/hPwdhsLS++QwNCzYpM5ksZ2m1/IiW0+II01RlufU6ECe3bjYg3SMXoSOWTa
        kJy5bWqQzhZdVwVOOA6Ok/tcOh0oXGwMcsh1sQbaEmkzp8DRuXNdAtV13gFAm+K0ClxaT4AJMS42hn3P
        dYBju+CBS2RmPQEmb4EtQQ65LiagTXHLAzfZ2HoCTMQ+OsDu2vPAdTqyngATsY8OcIse/kUHwqcgfBES
        GLoNww+i2KPYQtxlBFSIvY6BhLgPEiAx9pMMqCLuo7SCAuI+yysoMO7HpIIS4n7NvkLJjMbf/5x+h8x6
        +D3PsiMj33ZRDLqMiwAAAABJRU5ErkJggg==
</value>
  </data>
  <data name="boatTurnRight.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
    <value>
        /9j/4AAQSkZJRgABAQEAYABgAAD/4QBoRXhpZgAATU0AKgAAAAgABAEaAAUAAAABAAAAPgEbAAUAAAAB
        AAAARgEoAAMAAAABAAIAAAExAAIAAAARAAAATgAAAAAAAABgAAAAAQAAAGAAAAABcGFpbnQubmV0IDQu
        MC4xNwAA/9sAQwABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB
        AQEBAQEBAQEBAQEBAQEB/9sAQwEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB
        AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB/8AAEQgAFgAeAwEiAAIRAQMRAf/EAB8AAAEFAQEBAQEBAAAA
        AAAAAAABAgMEBQYHCAkKC//EALUQAAIBAwMCBAMFBQQEAAABfQECAwAEEQUSITFBBhNRYQcicRQygZGh
        CCNCscEVUtHwJDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0
        dXZ3eHl6g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh
        4uPk5ebn6Onq8fLz9PX29/j5+v/EAB8BAAMBAQEBAQEBAQEAAAAAAAABAgMEBQYHCAkKC//EALURAAIB
        AgQEAwQHBQQEAAECdwABAgMRBAUhMQYSQVEHYXETIjKBCBRCkaGxwQkjM1LwFWJy0QoWJDThJfEXGBka
        JicoKSo1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoKDhIWGh4iJipKTlJWWl5iZ
        mqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uLj5OXm5+jp6vLz9PX29/j5+v/aAAwD
        AQACEQMRAD8A83/bl/aS+HfwC8IafaeCG/Zpi1XwR+zJ4J+LmtSfEnw98dfEniXx34y+KvxK8caN4s8B
        aLB8Ofixong3R73w5FouiqZ9W0Wxs5Q4+yXMwjlMf4uW/wDwWe+KEHkyRfCr9jy1kCRS+ZbeEv2vY/s8
        U2MSZf8AaNHyJ/y3YfLbHi4MJr3X/goV+zba6p+0J8JvhG/xI0LQrz4+/Av4DfEjWdZ1jxCJk+Htp4s+
        J3xX8Q+NDe26QSS/YvB+j6Bql5cWsUckv7iO3toprq8sYLj6X+D3/BWT/gnJ+wT/AGT8KP2V/wBnnX9e
        0fRJ3t9d+O8ui6HB8S/HuuMoTVPGOs+INR1Cy8Vac2sxqFtNA0+7NhZKoWVYQAB+eZVkWSzyyvicVHAz
        xNdxlUi43XT4VJyavfRNyTunZnv4vF4unX+qUZc2G0993c7bfEmlv/d1Pnb9oz9uX9rz9nDRPhT4u8f/
        ALNv7IL+G/2gvg78PPjD8LPGmn+Gf2tG0Dxxoninwboviyy0/S9Wuv2lUsY/Gfhe3ubXwtc6Xfy2mrST
        6FFLHaTQ6hp8959AaP8AHPVtb1n4W3+g6vodnJ8TP2XfhN8bfGUNpBr17YaF448cxSSat4X0ePXfE2uT
        22maeEJWNWQB8YYjiuK/4LBf8FU/Afxw+Emh/A3wN4N8PeM9O+I3gnwd8QNT13xFpGnX974Lh8SaNpfi
        HQ9T0KGG3s9S0XxvDoniKwtW0bRfEWnaPpxv7q1vkguIvEtvr/hPwy+HEfgW9+BSWXiKz1SLxx+xL8Cf
        iDcyR3aXQ0e712KQnw+TG8nlNZKDmHjyzwwUkA9Ussy/BV8LWwccBGdZS524NRV4X5Uqbi/NXcre9ZJM
        wVapWwydeclqtE7dV62/XTserftcfB/WvGvxHj8SXE/grW9SmivfDQj8b+FdN8WfZLCE622r6LY6nrmm
        6rf2+g3BvdRNjbJte2N5IQqFia+NF/Z1vIbGCY+HfgQsc9t9pdYvhL4R3l+n3m8Mf16UUVvRwtCNBRjT
        5Y3WkZSS3h0UvN/0kd1OMZUlKUU33av1Xc3F/ZW1aXVYdLfRPgIbuWXRYpLxvhZ4bk2v4ltrC9sUhD+G
        CUtdJs7i1sYYQAqx2iBF2gV9D/Cz4M+Ko/FOqSeI/Ftm8mkeFdE8NaJbaHZvb2OmeHtPdTp2mwRzIjLD
        aKCsaKAqg8Ciiu6ng8NOtgFOlGXuTtdydvcvprp8vTY83G+7hY201v8A+TRP/9k=
</value>
  </data>
  <data name="boatTurnLeft.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
    <value>
        /9j/4AAQSkZJRgABAQEAYABgAAD/4QBoRXhpZgAATU0AKgAAAAgABAEaAAUAAAABAAAAPgEbAAUAAAAB
        AAAARgEoAAMAAAABAAIAAAExAAIAAAARAAAATgAAAAAAAABgAAAAAQAAAGAAAAABcGFpbnQubmV0IDQu
        MC4xNwAA/9sAQwABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB
        AQEBAQEBAQEBAQEBAQEB/9sAQwEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB
        AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB/8AAEQgAFgAeAwEiAAIRAQMRAf/EAB8AAAEFAQEBAQEBAAAA
        AAAAAAABAgMEBQYHCAkKC//EALUQAAIBAwMCBAMFBQQEAAABfQECAwAEEQUSITFBBhNRYQcicRQygZGh
        CCNCscEVUtHwJDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0
        dXZ3eHl6g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh
        4uPk5ebn6Onq8fLz9PX29/j5+v/EAB8BAAMBAQEBAQEBAQEAAAAAAAABAgMEBQYHCAkKC//EALURAAIB
        AgQEAwQHBQQEAAECdwABAgMRBAUhMQYSQVEHYXETIjKBCBRCkaGxwQkjM1LwFWJy0QoWJDThJfEXGBka
        JicoKSo1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoKDhIWGh4iJipKTlJWWl5iZ
        mqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uLj5OXm5+jp6vLz9PX29/j5+v/aAAwD
        AQACEQMRAD8A/Lv4u/theJfgt8EPE3xb03S/hx43+IH/AA1PD8C7jwn8QIviGPB7+AZPh5qniweK7mz8
        G/E7wZNBMl9ZRQajcx3lisdsZHuPMtRNDJk3H7dv7W/h39l6H9srWv2ff2Q/CPwc8WfFvQfhJ4T8Qah4
        S/a/sr34heIr/wAJePPEslx4Us5f2j1ur3w54XtfC2pWbXotk066vPFwtrGe8vbK6htPjP8Aal8G22j/
        ALPmu/Gm6vtJ1e80v9uyy8HjwVqBe8s9TttN+FWteI4NT1DS7XUdNvZtLvXsV03UZra4jmis55yolkUW
        8n7lfAX/AILtfC7wd+yRY+PPFXgcaD4l8Ga9oPwtk+G/gO20awtraa70LxA+jWmiafpdp4bsLLwpbad4
        O1+I6xaAahJHbw6RqjrpmqaJolj8HDKcrxUMTisXDASq+1nTfuXjKLai7c/O1ZaLVxT5ny3PZnWrQpUY
        UpycZSjF6vRNpXW2vnbsfj5pn/BYrx9qmsaNp+p/DT9jjSbK81vTbG71aTwT+1pdnSHuLqIrqMsV3+0J
        e209tZPsnv0S3nnSGOWGAJqBt1H9BPgT4h/DPx58Ddb1TT3+Cup+Ovhh+0L4o+Fq6x8J9N+I2naB478H
        ar8N/AHj+58WRaL8aPiD4t1jTY7DxXq99ouzy9LkkkYyQQSWkiyt+O/7Svx9/YA/4KoeCfEtv4d+GMX7
        MH7Y2i+H9W1b4X+L7XR9D8PaT8Ul0mCbWp/hn4/Phd59Ge81mCyv38OeKNTeWc67PptrqF3aRzzTJ7T+
        wd4DNx+zN4/+PXhfWbXxBfj9pS7+FK+FNP8AECS+Vpt38Evhb4zuNfmt3iUpLFeW9vpkryKskcs72zhZ
        Y5kTjz7Jsqw1LC4vALALEKEYSjyvkUW47qMotvXfm6pW6HVl+JxOKnKhi5OFKn8EoXUnqrayc09F2V72
        PlLxf8APF2s6n480SDXvCOs+FBr1x4yfQvGnh6HXbT+3bTR7nzL0WV3ZXthJNJpqz2SPNA7RecJEKOiO
        vlDfsy6jDaX91/YPwHSLTrjSra9hj+FvhkrdnXPt13p9ysTeGPK+06f9ivLcyuA3kalcKhO4glFe+8Jh
        4U8Uo0lFfWnpFyS0mlfSW/nv13ObDLmw1G6v70N/PlvpsNg/Z01WO80y7ttA+AqXwvG+x3P/AAqfwnG9
        tPZRPdWtyCnhZtz208Mc0alSrvGEf5GJr9P/ANij4f8AiD4f+FLzTtBvtAtU1rzNdOj6RpzeFPDUUrxa
        TZXuoyaZ4bhsoZ9buTb2MP2t7fC2Vv5W4fKtFFcmIwmHqU6cZ0lOKtpJya2g+r83/VjrrJQhFxXK3bVa
        dj//2Q==
</value>
  </data>
  <data name="boatTurnAround.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
    <value>
        iVBORw0KGgoAAAANSUhEUgAAAB4AAAA6CAYAAACnDemCAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO
        wwAADsMBx2+oZAAAABl0RVh0U29mdHdhcmUAcGFpbnQubmV0IDQuMC4xNzNun2MAAANPSURBVFhH7Zkh
        cKNAFIYjkZFYJBKJRSKRa5FI5FrkSmQsEonEIpGRsZGVJ1//fxcuaS/XS9uEnc7cP/Mm0yTst/++tw+y
        3f3Xj9A+CCQIdrL8uZ3yNJQ42m8LplOCozAAmLGRVBYJI44CCfebgQPRZSxVEUma7Ldw7QBVEYupUmkQ
        Ko9tnkMLf5pYxYGYOpNDUyCUNHUuRZYsRfYUuHNbwmGrc+lMKV1bS3+oRVcFljx6lmsHNlUCcCalygCL
        ZRoOdgKqSOE6fLRrBy1QxQ3AhIf7vV327mBk7A2WXDnXj63wxW3NgkpQUJGFMvI8e+f6Ybl2UFbvCo5C
        55bBz4bOyLC4Th7n2g3OvBJcYiut0BWsilym8eG5RiUXLKjcbiMOeg1eY8Ryv8n19yrcOeKeJbhS6U0o
        v1OVSuYr10n8LdfMbSIH48B0QtB+qejr4Hvz2MF1e+X6S3cu56Rr0SiM61DXkGsog99tdCXz1GGL6cV1
        9BXX2Ld5Kn1bwbGSLHVFdQu6RhSGcpwHu70aXdoG80nXzsHQsSVW0qInr8CPwLymbTXgvfRdA9eZ3V6f
        cM0tkgHcYABtnXPgj6BrJHEsp+No822aSlKs1J2u3cy5NRg98sULOeg9YF479AcLH1BopWJRxveBS1XY
        hjAOLbZJYQe8B7pGlqXycp6x5KMYo+EavR35XwB/UwBoJxOqk00hWhrGZ8AcY55GOZ+PGKOTEpMnfAHc
        FtvfPPUWrrE9ONMoiu6Ka7jCqv16OcnxOMF1g12R3s41v0yIg6IqkR9VFBhAYcalff1XFPh+jOJa4afj
        LOfTbHPOiaxLzs8W7G5XwCnjhBlyeUyjpWkabI/WhjHmrtBa41bpmk1Vqd+5btvG3kKZsuz9sr8gJyfM
        cBx6QAHGIFrj0aaupa6rS1QlBkWgP7MQ+UoI37dRu2AnO58mwCf72netfX/BXbSV4wX3Vs/O8YL5U5tX
        9UWe9jEv8ta5GB56NeXl7kQtM9/+fkx5eQKhnAMPz1yUl6dMyjnx8FxNefklQTlHXn472cG3/7VIOcDG
        v48pB/ZwIkAtrgHd8AyEcmAPpz6Uy+vG51yUc+3hZG/V5meZF3k6vYU/X+fVlJcTesrb/yR+oHa7V4q5
        kiuq8MxFAAAAAElFTkSuQmCC
</value>
  </data>
  <data name="boatBorder.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
    <value>
        iVBORw0KGgoAAAANSUhEUgAAA6YAAALECAYAAAAbyS0OAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO
        wwAADsMBx2+oZAAAABl0RVh0U29mdHdhcmUAcGFpbnQubmV0IDQuMC4xNzNun2MAAEjmSURBVHhe7d0v
        l6vI2jfg81VGtmwZG4lEYpGRSGxkZGRsZGTLti23PHLs8zF46y4SOn1PZs6fhHme9a5rr3WtdFdTBChC
        +O2C4h/jrp32QzsdxnY67rtq3DXT0G2rvp915eeu3SyvbdNMTdi+TefzoThOv34dp6+v4/T5sZ8ul6GU
        7abTqS9l+1I2zmWnUnbsp315n6G87668V98383y7Mt+Yd319n/r4W1WmK9Peft8NZfnK72NZ5qEYx6bM
        r6zDoSz/savv+/FxKO/7MX1+norL1HelXjH0pU7xX693XffNtNm81fX95z8v1/X+P7CO5T2a5n0R7xPv
        F+8b6xLLMZT53uYTbXO5lPmUZf783Jd5neq6XM6n2qbN9jqPu/nc1PnVeW6nsczzUOZZl+tunh+XsbzH
        vrzfUOcT8/tevnn9h917+fu2rMu8DB9lG57PQ6m3m46Hsg3H+21Y3jfe+7Ycddm287zL/MZhU5dnbpfY
        Hw91npeyHDHP43FX1rsv2/KP7dKG63q23dwu0QbRJnO7zG0TdWrb1DZ50Dansg1i/f/tttn8ddtct8u/
        0za3bVO3013bxDx/tE2ZZ93OS9tsfyzb0jbDrW3GpW0utW3Ktjzs/rptrr7bZl6euW3mdblv7/u22cW2
        LtsrPj/juL1b57d/e52X/bF8TuIzuazzeV/eZ6x179c3XmOdd2V/rO95/Uzclu+2P/7cd77f/1XrvOyP
        ZR63+cSydWWfHIa+Tv8//3Op84t53eYzb6tQ9snYP8sy1uWs+26Z73W/vd+fu3I8DE1Z77pdY5su2/GP
        ++P3toz9cT7ex3H/D21T5xXbouzb5bXO71HbXPfHeZ7z/ng4DPUz/Ye2KZa2qce+ONZGndI21+1Y98c4
        jtbt+LhtYtlinsOtbcp61GPF192xIvbvv2yba/vUZYt1ndsm2uD3389123xc9vVzUpfr2jZxrPjRNjHf
        a9vM7ZPaJda7bsvZv2qX+N591C7xPR3f10u7XF/rNipu33nx/Xf7Lozvxfh+jO9J5wj/4XrXdXeOUOdX
        5+kcwTnCg7a5+m6beXnmtnGO8GfrvOyPZR63+cSy/f90jvCPeYP8+YHz9sGKBY4FqhukaNq2ih02TiYO
        x9iQ85dMLGQsbHwYY8WP1wNw3iBjKduXjXgofw9DbPz4EB/KF0LZYY7lYBFO96LBysa+hLLy55imfAj2
        5UMQ9esGvjZe2EXDF7EhakOWRvx3vjD+bL3nnWF+nXfMeb3/L6zjGDtwMZT3jOlm8zLEzhr2++8Pzv0B
        81jaLA5K87qMtU3rul7XOda/fsjKjnO/fvPP8wHiUNYpPujzgW0+UF0uh7Ls+7INY+e+tkE175TDuKn1
        og2+yslh7NA/P0ixjLG88/vEe94+SEubXJcxTjZjftEu8UUTB4rbh/rWLvP8yra/bpNom7Fskz9tl7Ie
        /7ptxnXbph48n2+bU/lCvLVNbO//qG3KF/hHWefzuaxvPViu3zanss7Hsk++dJ3LyUCcCEXbLOu7zDOW
        c1O3+f/WOuf9MV7HeN/y92GM8n5e76rsY+V955Og8kVb9pNT2UfOZV0vIZa97KOn4tH+fIj9trjti/f7
        4205lv2xuD+5un0JPXusmE/Q4lgRx995f/zrtmmu0x+u2zTC33ysqMs4lNfYJnW7lLa5fpn/bJtYrlkc
        a27t++Pzd13u2j5lnWP+89/7eb4xzbV9aluVE4Jdee/6XXFrm+L7yztOSMt3S5zAXLd/OJb3PpSyED+H
        fRzry3Z91C61bf6Ndonv47ld7r6ry7rHdojluz9xju+7+N6r32dl28a+f//9+N9+VzpHcI4wi59/fu6d
        I7y4beJY6hxhXrZn19k5wrIv/2+dI/zjXx0448s0NnysQCxoHPyO5aCwPx6r+CLdlYXpdyVR1zeNg/Ss
        fugiddcF+P4gxsrNO1XZQNEg140UH+D44t4f4wA71MasJxjXDTtv4PmL4LaB9mUDxDIvH9jrRqonJPG/
        n/GhX5Zt/kDF63+83nEgLHVuDXYu5bGOm9v/Sv0fWMflxOdeee94z5soO5QPUOxQtw9LLG+sS9025YMX
        bTmUE8DYWeu6R72qzCvWo6z7/ZfhuN/VZbl9Ocf/sNy2c8xrN27r9pu343VbVmWnLzvtMN5OoKKd5p12
        3n/mA/Y+Dh4/tuP1w1Tn990uMa/xcD2I1v9B+m6X7xPEOIjftUupV7dLKPN62C7hb2ub2J7/um2W9Y96
        1X/XNsN929yU3+O1ts3tf0tz25QDyn3bXD6ubVPe/75t6rKV8kdtMx+YUtuUg9mtbfaHckAr9V69zj/2
        x3D383+yzuf/Yp0f7o91nWNfmOdX94VQyur8rq9jWa5Yty7+17bM53asql9cdR+M/fF6LCtiX7ztR4/2
        5/gSidAV8z6W9anLUN/v+t71s1COFRHGYn8u6xHrEn7sj2U+p0v5Yquf7es2iHnV9ZnbJuZZ9+3x2ja1
        XVLb9GW9yvY9xJdzaccqvuzj9/q5iM/lbpn+D8eK0j6xLeLk/vvzVpanfLF+z2ue71g+48M+/ld8PuGK
        +dyO3bf2qScD5fNd51fqxjxjm8R8YrvUbV23dznhLMsV/1sd4SbmMW/n8n0Soo1KaJ1PNuL4UNoltud1
        m9627a1tYnvG8WVeh2u7lP3h5hbGH7dLEetS9/Omtsf3d3Vp01I39q3YZ+P7Ld4jli/2pbq+Zb+J42N8
        L87/WRDHSOcIzhEefO6dI8xtcvO3tU1sT+cI0TbOEebPye31/5dzhH/EDLbpwHmbcSxoXMpyc39Zz7Ar
        X2jFGD+XaYdSNy6D2ZUG+n4tGyY2zu21GK9uvy+WaTeLXWzcKn4uSsOF/vpaxd/vf78rH0qdm+VEp4gN
        83O95wPKn633TVzS8/CynvvlL/631vF+vj9d3/O2DPfLfGdXprkZ+k1dv3v7+JBc3cru121u8+951PW5
        m1etd3Wbx7zvlG0e016nr3VurvMf46SzuF+GmzrPZXlu+978vsvyxTySh2V1W1yX5X6b3pavmrf9j3a7
        +/2v2+LO7T3Tcv4Qy1Nf7+s9aJs7t7L7edy2a3Vb5q4sb1Gnv9uGt59vbdOXaW/merNl2Yq5fa7LcGuX
        B/O6vf/9Nqj1r26/V7Utvtuyzu/qvv2X96rv81132R/vlz9+L+r0d/W+6xfl+NXf2vM6/c1tmevyxv5Y
        6uTt/mNedX53da/1/8y8D8Z08Xr7+c8tbVl974M/f5/L7vfL+vd4rb9/v/8f3dbjtj2zUr/8La97lbbv
        X87nfnliumX6b3GJbny39OULr3o0n/Bjuf/oNp86rzJ9zOvhfP6FZTn+G028lu+eJvbL7/Lvtvtuqy6C
        3N8sThziZKueLJXt5RzBOUK4fUbnz6lzhLAsx235qnnb/2i3u9//ui3u3N4zLecPsTz19b6ec4T79l/e
        q77Pd91lf7xf/vi9qNPf1fuuX9TvoWt7Xqe/uS1zXV7nCEWpX/6W171K2/c2n3/crvuN/5mI/yUr//4B
        AAAAa8gZNP5jtBbOXcjzJVS5EgAAALxKzqB/CKZxjXuuBAAAAK+SM2gKppt6X0muBAAAAK+SM+gcTDdv
        tSBGYdq7xxQAAIAV5Qy6BNN4LlcMiR43oOZKAAAA8Co5gy7B9Pbg6BgaPVcCAACAV8kZdAmmH/EQWj2m
        AAAArCxn0O9LeUvB8djXUZFyJQAAAHiVnEGXYHo67abDoasPOM2VAAAA4FVyBl2CaSTVcWj1mAIAALCq
        nEHbxqW8AAAA/I1yBnUpLwAAAH+rnEFdygsAAMDfKmfQ+VLe7dt02HfTsGv0mAIAALCqnEHnHtNSGEl1
        HNtpKK+5EgAAALxKzqA1mLalcFeS6jA00/7QlekeVwYAAIBn5Qy6BNPoPo0/xHW+uRIAAAC8Ss6gy+BH
        URhdqDEyUq4EAAAAr5Iz6I9gGtf3ns5Dme5xZQAAAHhWzqDfl/J217QqmAIAALCinEHnHtNS2HWbklib
        6ehSXgAAAFaUM2gNpl3zXh9q2vXb6XAUTAEAAFhPzqA1mPZtKWw3c6EeUwAAAFaUM+h8j2lJq20UlsQq
        mAIAALCmnEGXwY9qYUmrx5PBjwAAAFhPzqBLMN1u3+dCo/ICAACwopxBl0t5v7720/HY11GRciUAAAB4
        lZxBl2D669exFjbl51wJAAAAXiVn0OulvHNa3e+7evNprgQAAACvkjPo0mP6+TlO49hOfS+YAgAAsJ6c
        QWswbUpavVyGaRiaabdzjykAAADryRl0Cabn864WGPwIAACANeUMutxjejrNoyHpMQUAAGBNOYMuPaYx
        GlIUDGNbpntcGQAAAJ6VM+jSY7rft/X63hgVKVcCAACAV8kZdAmmUTCWPxwOfZnucWUAAAB4Vs6gSzCN
        LtQoOB53ZbrHlQEAAOBZOYMuwTRuOo1rfI8nwRQAAID15Ay6DH7UddvpIJgCAACwspxB52DaROFmGved
        YAoAAMCqcgadL+UthW27qcP0RmLNlQAAAOBVcgb9EUwjrRqVFwAAgDXlDLpcyhvGUiCYAgAAsKacQX8E
        030UupQXAACAFeUM+iOYHo47wRQAAIBV5Qxag2nfberDTSOthlwJAAAAXiVn0BpMx7Gdfv/9c2raTSnY
        lOkeVwYAAIBn5Qw6B9OhmX79OtVRkXb9tkz3uDIAAAA8K2fQGkyHXTN9fu6nrhTEz7kSAAAAvErOoDWY
        RkK9nIep75t6nW+uBAAAAK+SM+gSTI/HfupLgR5TAAAA1pQzaA2mMSLSft9N/VAKh7ZM97gyAAAAPCtn
        0Ltg2k5j+cNQ/pArAQAAwKvkDFqDaQzPG8P1ns6DHlMAAABWlTNoDaZt815/OV8EUwAAANaVM2gNpk0p
        jLR6/hhLoUt5AQAAWE/OoHMw3b7XG0/PH3uPiwEAAGBVOYNeg+lbTauXz/3U99sy3ePKAAAA8KycQedg
        unmrKTW6UbtOMAUAAGA9OYMuwTQebHq8jHpMAQAAWFXOoDWYbt5/m4axm47noaRWwRQAAID15Axag2m7
        fZu+vvb15tO+N/gRAAAA68kZtAbT7eZt+vXrOB0O3dS6xxQAAIAV5Qw6B9P3t+n3f16m02k3bbfvZbrH
        lQEAAOBZOYNe7zGd02oUdjuX8gIAALCenEFrMH1/+23abkpK7Zvp9LEv0z2uDAAAAM/KGXTuMS2Fbbsp
        hdvpdBnLdI8rAwAAwLNyBl3uMa2FnWAKAADAunIGXYJp181pNR5wmisBAADAq+QMeh386LeaVGvheSjT
        Pa4MAAAAz8oZdBn8KArjwaZnPaYAAACsKGfQZfCjvhQOYztdjMoLAADAinIG/Q6m/XYa910p1GMKAADA
        enIGXQY/qoUlrbqUFwAAgDXlDPojmA5DM50MfgQAAMCKcgZdgulu15TCdjoc+zLd48oAAADwrJxB52C6
        eatdqCFuPs2VAAAA4FVyBq3BtCmFh0NXu1G7vinTPa4MAAAAz8oZtAbTdvs2nU67mlbjWTK5EgAAALxK
        zqBLML2ch+l47Kd4wGmuBAAAAK+SM+hyKe/lMtTEqscUAACANeUMugTTz8+x/qFpNmW6x5UBAADgWTmD
        1mAaQ/V+fe2nj49x2m7fy3SPKwMAAMCzcgZdgmkUhKbVYwoAAMB6cgZdLuXt++20G5rpcBrKdI8rAwAA
        wLNyBl2CadO8T223nU6XsUz3uDIAAAA8K2fQH8E0RkM6nvWYAgAAsJ6cQed7TEthG9f19oIpAAAA68oZ
        dAmmekwBAAD4O+QM6lJeAAAA/lYPL+WthVuDHwEAALC+nEGXYBpJdbeLoXp3ZbrHlQEAAOBZOYMuwfRy
        3k2Xy1AfbporAQAAwKvkDDoPfvT+2/T5OU4fH+O03b6X6R5XBgAAgGflDHoNpm+lYJjOJbE2jR5TAAAA
        1pMz6BxMr92op1Nfr/PNlQAAAOBVcgZd7jGNpHo4dFPfC6YAAACsJ2fQJZiejv00jq0eUwAAAFaVM+gc
        TLdv02HfTcPQTJ0eUwAAAFaUM+gSTMehrWl1KK+5EgAAALxKzqA1mLalMB5sGml1f+jLdI8rAwAAwLNy
        Bl2CadxwGoXH065M97gyAAAAPCtn0GXwo7mwnU7noUz3uDIAAAA8K2fQH8E0ru89XwRTAAAA1pMz6HIp
        bwzRq8cUAACAteUMOveY1sJNSazuMQUAAGBdOYPWYNo177Uwnh9zOAqmAAAArCdn0BpM+7YUttdCPaYA
        AACsKGfQ+R7TklbbKOwEUwAAANaVM+gy+FEt1GMKAADAynIGXYLpdvteh+s9GpUXAACAFeUMulzK+/W5
        n46Hvo6KlCsBAADAq+QM+h1Mvw7T8dhPTfk5VwIAAIBXyRn0einvnFb3+7YO2ZsrAQAAwKvkDLr0mH58
        jNM4tvUa31wJAAAAXiVn0KXH9HLZTcPQTLude0wBAABYT86gSzA9nfpaoMcUAACANeUMugTTuOk0CvSY
        AgAAsKacQbvmGkwPh64WDENbpntcGQAAAJ6VM+jSYxo3nQ6lcL/vynSPKwMAAMCzcgZdgmkUxB/2JbXm
        SgAAAPAqOYMuwTS6UCOpHg59me5xZQAAAHhWzqBLMI2bTqPgcBRMAQAAWE/OoDWYNqWw66JQjykAAADr
        yhl0GZW36zb1+l7BFAAAgDXlDDoH06YUtptpNxj8CAAAgHXlDDrfY1oK21I4xIhIHhcDAADAinIG/Q6m
        xVgKBFMAAADWlDNoe7uUtxFMAQAA+BvkDFrvMY2CptlM+0PvHlMAAABWlTNo7THtu019uGmk1XEUTAEA
        AFhPzqD1HtNxaKZ//jrVm09jZKRcCQAAAF4lZ9AaTIeSVL++9rVw12/LdI8rAwAAwLNyBr0G0+30cRmm
        rtsKpgAAAKwqZ9AaTOOH02k39eVVMAUAAGBNOYPOwbTbTIdDVwqbegNqrgQAAACvkjNoDaYxItJ+3059
        KRBMAQAAWFPOoEswHce2iptQcyUAAAB4lZxBazCN4XmHoZ2Ox768CqYAAACsJ2fQGkzb5r3+cjrvBFMA
        AABWlTNo12xvhW0pHFzKCwAAwKpyBm1vwTSu7T1dBoMfAQAAsKqcQWswbbZvNa2eL+PUd55jCgAAwHpy
        Bl2CaQzTeyxptes2ZbrHlQEAAOBZOYO2TXMt7JvpcBrKqx5TAAAA1pMzaO0x3b6/TcPYlsLdtBNMAQAA
        WFHOoHMw3bxNu6EUnvWYAgAAsK6cQed7TEthXN8badXgRwAAAKwpZ9DvwY/i+l49pgAAAKwsZ9AlmDbx
        HJlDPx2KXAkAAABeJWfQGkzj4aZtu6k3n+73XZnucWUAAAB4Vs6gSzDtSmG9+fQgmAIAALCenEG/g2m3
        mcYYrtelvAAAAKwoZ9DrPaZRuK1JVTAFAABgTTmDLj2mMRJSFByPgikAAADryRl0DqYlre52Tb3pVI8p
        AAAAa8oZtN1ee0yHUjhf32vwIwAAANaTM+hyKW8UxB88LgYAAIA15Qy6XMobKTW6UoehLdM9rgwAAADP
        yhl0CaZxw2ncfBp/yJUAAADgVXIGXYLp6dTXgr4XTAEAAFhPzqBLML1cdtMwNHpMAQAAWFXOoG3TlMLm
        ffr4GOvNp9GVmisBAADAq+QMugTTr8/9tN+3U9dtynSPKwMAAMCzcgb9DqZfh3rzaVN+zpUAAADgVXIG
        XZ5jGmn1eIhRkdxjCgAAwHpyBr0OfvQ2bbfv9dre43ko0z2uDAAAAM/KGXQJpm27mbooPO3KdI8rAwAA
        wLNyBl0u5a2F3XY6CKYAAACsKGfQGkz79n3qrmlVMAUAAGBNOYPWYNqVtBpD9AqmAAAArC1n0Pq4mGb7
        VgtjNKTjWTAFAABgPTmDzs8xrYXbaRja6XwxKi8AAADryRm0a6PHdPNWh+kdR8EUAACAdeUM+iOYRlo9
        eY4pAAAAK8oZtAbT6EadCxvPMQUAAGBVOYN2t3tMd7umFh4OfZnucWUAAAB4Vs6g9XExMSLSOLT1+t7o
        Ss2VAAAA4FVyBl2C6WHf1bQaz5HJlQAAAOBVcgadg+nmbTod+5pWY8jeXAkAAABeJWfQ7hZMz+fddDh0
        9QbUXAkAAABeJWfQGky3pfBSCk+nXo8pAAAAq8oZdA6m72/Tx8dQE2vTbMp0jysDAADAs3IGrfeYbt9/
        mz4/x/KHcdpu38t0jysDAADAs3IGXQY/im7Uy2WY2laPKQAAAOvJGXQJpnFdbzzg9HDalekeVwYAAIBn
        5Qy6BNMmuk/LH06XsUz3uDIAAAA8K2fQ72DavNfEerwMZbrHlQEAAOBZOYPOgx/dF54FUwAAANaTM+gS
        TOOG064XTAEAAFhXzqB/uJTXPaYAAACsKWfQH8HU4EcAAACsLWfQJZj2/XbaDTFUr0t5AQAAWE/OoPM9
        pu9v08fHWMV1vrkSAAAAvErOoEsw/fra18Lt9r1M97gyAAAAPCtn0OVS3s/PcbpchqnRYwoAAMCKcgZd
        gmkUnE67OipSrgQAAACvkjNoDabtthSeh+l47Ke+b8p0jysDAADAs3IG7dpmLoykOo6tHlMAAABWlTNo
        DabRjXo4dNMwlKSqxxQAAIAV5Qxag+m2FEZSDUORKwEAAMCr5Aw6B9P3t2m3a0pabafDsS/TPa4MAAAA
        z8oZtG2uwbTvt7Ub9XQeynSPKwMAAMCzcgato/LeCqMb9fIxlukeVwYAAIBn5Qxag+nm7be5cN9Nl899
        me5xZQAAAHhWzqDfwbTb1ptOBVMAAADWlDNoDabvpTCeHRMPNj27lBcAAIAV5Qw695i+z4Vdv52OBj8C
        AABgRTmDLoMfdd2mFp4uekwBAABYT86gSzBt21JYEqtgCgAAwJpyBl0GP6qFkVbdYwoAAMCKcgZdBj/a
        bt5LYVMKjcoLAADAenIGvQ5+9Db9+nWcTqdd/UOuBAAAAK+SM2h3u8f0939eauF2+16me1wZAAAAnpUz
        aNc2pXAzp9XDoZvablume1wZAAAAnpUzaA2m7fZt+vraT/t9Vx9wmisBAADAq+QMWi/ljYebDmNXH2y6
        2+kxBQAAYD05g3ZtCabN5m3qd810vIwlrQqmAAAArCdn0DoqbxTuSuH5Y6wPOM2VAAAA4FVyBp2D6fZt
        Gsd2unzu9ZgCAACwqpxBr8H0vd50ev7YT0NJrbkSAAAAvErOoHMwbd5rWo1u1HFoy3SPKwMAAMCzcgat
        wbQthUP55XwZ6h9zJQAAAHiVnEFrMO3aTf3ldB6mQTAFAABgRTmD1mDad5tpv2+ncd/V1JorAQAAwKvk
        DNp9B9Nu6odGMAUAAGBVOYPWHtNdv52Ox74+4NSovAAAAKwpZ9AlmF7Ow9T3gikAAADryhm0BtP44fNz
        P3Xlj4IpAAAAa8oZdA6mQzP9+nWa2nYz7UpizZUAAADgVXIGrYMfxTC9v//+OTWlMIbtzZUAAADgVXIG
        XR4Xs9s10/7QF12Z7nFlAAAAeFbOoDWYNs37FA7HXdGX6R5XBgAAgGflDFov5b0VRloVTAEAAFhTzqBd
        03wXjlFY5EoAAADwKjmD1mDaloIYDWncd4IpAAAAq8oZtGvvgukwti7lBQAAYFU5g9ZgGl2oXTen1eNp
        V6Z7XBkAAACelTNoW+8x3bzV63u7bjsdz0OZ7nFlAAAAeFbOoHOPaRRu36e2FJ4uY5nucWUAAAB4Vs6g
        SzCNpBoPOD24lBcAAIAV5Qy6BNPLeTddLsPUtJsy3ePKAAAA8KycQWsw3b7/Nn1+jtPHxzhtt+9luseV
        AQAA4Fk5g16D6VspGKZzSaxNo8cUAACA9eQMOgfTazfq6dTX63xzJQAAAHiVnEGXe0wjqR4O3dT3gikA
        AADryRl0CaanYz+NY6vHFAAAgFXlDDoH0+3bdNh30zA0U6fHFAAAgBXlDLoE03Foa1odymuuBAAAAK+S
        M2gNpm0pjAebRlrdH/oy3ePKAAAA8KycQZdgGjecRuHxtCvTPa4MAAAAz8oZdBn8aC5sp9N5KNM9rgwA
        AADPyhn0RzCN63vPF8EUAACA9eQMulzKG0P06jEFAABgbTmDzj2mtXBTEqt7TAEAAFhXzqA1mHbNey2M
        58ccjoIpAAAA68kZtAbTvi2F7bVQjykAAAAryhl0vse0pNU2CjvBFAAAgHXlDLoMflQL9ZgCAACwspxB
        l2C63b7X4XqPRuUFAABgRTmDLpfyfn3up+Ohr6Mi5UoAAADwKjmDfgfTr8N0PPZTU37OlQAAAOBVcga9
        Xso7p9X9vq1D9uZKAAAA8Co5gy49ph8f4zSObb3GN1cCAACAV8kZdOkxvVx20zA0027nHlMAAADWkzPo
        EkxPp74W6DEFAABgTTmDLsE0bjqNAj2mAAAArCln0K65BtPDoasFw9CW6R5XBgAAgGflDLr0mMZNp0Mp
        3O+7Mt3jygAAAPCsnEGXYBoF8Yd9Sa25EgAAALxKzqBLMI0u1Eiqh0NfpntcGQAAAJ6VM+gSTOOm0yg4
        HAVTAAAA1pMzaA2mTSnsuijUYwoAAMC6cgZdRuXtuk29vlcwBQAAYE05g87BtCmF7WbaDQY/AgAAYF05
        g873mJbCthQOMSKSx8UAAACwopxBv4NpMZYCwRQAAIA15Qza3i7lbQRTAAAA/gY5g9Z7TKOgaTbT/tC7
        xxQAAIBV5Qxae0z7blMfbhppdRwFUwAAANaTM2i9x3Qcmumfv0715tMYGSlXAgAAgFfJGbQG06Ek1a+v
        fS3c9dsy3ePKAAAA8KycQa/BdDt9XIap67aCKQAAAKvKGbQG0/jhdNpNfXkVTAEAAFhTzqBzMO020+HQ
        lcKm3oCaKwEAAMCr5Axag2mMiLTft1NfCgRTAAAA1pQz6BJMx7Gt4ibUXAkAAABeJWfQGkxjeN5haKfj
        sS+vgikAAADryRm0BtO2ea+/nM47wRQAAIBV5QzaNdtbYVsKB5fyAgAAsKqcQdtbMI1re0+XweBHAAAA
        rCpn0BpMm+1bTavnyzj1neeYAgAAsJ6cQZdgGsP0Hkta7bpNme5xZQAAAHhWzqBt01wL+2Y6nIbyqscU
        AACA9eQMWntMt+9v0zC2pXA37QRTAAAAVpQz6BxMN2/TbiiFZz2mAAAArCtn0Pke01IY1/dGWjX4EQAA
        AGvKGfR78KO4vlePKQAAACvLGXQJpk08R+bQT4ciVwIAAIBXyRm0BtN4uGnbburNp/t9V6Z7XBkAAACe
        lTPoEky7UlhvPj0IpgAAAKwnZ9DvYNptpjGG63UpLwAAACvKGfR6j2kUbmtSFUwBAABYU86gS49pjIQU
        BcejYAoAAMB6cgadg2lJq7tdU2861WMKAADAmnIGbbfXHtOhFM7X9xr8CAAAgPXkDLpcyhsF8QePiwEA
        AGBNOYMul/JGSo2u1GFoy3SPKwMAAMCzcgZdgmnccBo3n8YfciUAAAB4lZxBl2B6OvW1oO8FUwAAANaT
        M+gSTC+X3TQMjR5TAAAAVpUzaNs0pbB5nz4+xnrzaXSl5koAAADwKjmDLsH063M/7fft1HWbMt3jygAA
        APCsnEG/g+nXod582pSfcyUAAAB4lZxBl+eYRlo9HmJUJPeYAgAAsJ6cQa+DH71N2+17vbb3eB7KdI8r
        AwAAwLNyBl2Cadtupi4KT7sy3ePKAAAA8KycQZdLeWtht50OgikAAAAryhm0BtO+fZ+6a1oVTAEAAFhT
        zqA1mHYlrcYQvYIpAAAAa8sZtD4uptm+1cIYDel4FkwBAABYT86g83NMa+F2GoZ2Ol+MygsAAMB6cgbt
        2ugx3bzVYXrHUTAFAABgXTmD/gimkVZPnmMKAADAinIGrcE0ulHnwsZzTAEAAFhVzqDd7R7T3a6phYdD
        X6Z7XBkAAACelTNofVxMjIg0Dm29vje6UnMlAAAAeJWcQZdgeth3Na3Gc2RyJQAAAHiVnEHnYLp5m07H
        vqbVGLI3VwIAAIBXyRm0uwXT83k3HQ5dvQE1VwIAAIBXyRm0BtNtKbyUwtOp12MKAADAqnIGnYPp+9v0
        8THUxNo0mzLd48oAAADwrJxB6z2m2/ffps/PsfxhnLbb9zLd48oAAADwrJxBl8GPohv1chmmttVjCgAA
        wHpyBl2CaVzXGw84PZx2ZbrHlQEAAOBZOYMuwbSJ7tPyh9NlLNM9rgwAAADPyhn0O5g27zWxHi9Dme5x
        ZQAAAHhWzqDz4Ef3hWfBFAAAgPXkDLoE07jhtOsFUwAAANaVM+gfLuV1jykAAABryhn0RzA1+BEAAABr
        yxl0CaZ9v512QwzV61JeAAAA1pMz6HyP6fvb9PExVnGdb64EAAAAr5Iz6BJMv772tXC7fS/TPa4MAAAA
        z8oZdLmU9/NznC6XYWr0mAIAALCinEGXYBoFp9OujoqUKwEAAMCr5Axag2m7LYXnYToe+6nvmzLd48oA
        AADwrJxBu7aZCyOpjmOrxxQAAIBV5Qxag2l0ox4O3TQMJanqMQUAAGBFOYPWYLothZFUw1DkSgAAAPAq
        OYPOwfT9bdrtmpJW2+lw7Mt0jysDAADAs3IGbZtrMO37be1GPZ2HMt3jygAAAPCsnEHrqLy3wuhGvXyM
        ZbrHlQEAAOBZOYPWYLp5+20u3HfT5XNfpntcGQAAAJ6VM+h3MO229aZTwRQAAIA15Qxag+l7KYxnx8SD
        Tc8u5QUAAGBFOYPOPabvc2HXb6ejwY8AAABYUc6gy+BHXbephaeLHlMAAADWkzPoEkzbthSWxCqYAgAA
        sKacQZfBj2phpFX3mAIAALCinEGXwY+2m/dS2JRCo/ICAACwnpxBr4MfvU2/fh2n02lX/5ArAQAAwKvk
        DNrd7jH9/Z+XWrjdvpfpHlcGAACAZ+UM2rVNKdzMafVw6Ka225bpHlcGAACAZ+UMWoNpu32bvr72037f
        1Qec5koAAADwKjmD1kt54+Gmw9jVB5vudnpMAQAAWE/OoF1bgmmzeZv6XTMdL2NJq4IpAAAA68kZtI7K
        G4W7Unj+GOsDTnMlAAAAeJWcQedgun2bxrGdLp97PaYAAACsKmfQazB9rzednj/201BSa64EAAAAr5Iz
        6BxMm/eaVqMbdRzaMt3jygAAAPCsnEFrMG1L4VB+OV+G+sdcCQAAAF4lZ9AaTLt2U385nYdpEEwBAABY
        Uc6gNZj23Wba79tp3Hc1teZKAAAA8Co5g3bfwbSb+qERTAEAAFhVzqC1x3TXb6fjsa8PODUqLwAAAGvK
        GXQJppfzMPW9YAoAAMC6cgatwTR++PzcT135o2AKAADAmnIGnYPp0Ey/fp2mtt1Mu5JYcyUAAAB4lZxB
        6+BHMUzv779/Tk0pjGF7cyUAAAB4lZxBl8fF7HbNtD/0RVeme1wZAAAAnpUzaA2mTfM+hcNxV/RluseV
        AQAA4Fk5g9ZLeW+FkVYFUwAAANaUM2jXNN+FYxQWuRIAAAC8Ss6gNZi2pSBGQxr3nWAKAADAqnIG7dq7
        YDqMrUt5AQAAWFXOoDWYRhdq181p9XjalekeVwYAAIBn5Qza1ntMt281rfb9tqRVwRQAAID15Aw695iW
        wjmxlkI9pgAAAKwoZ9A/BFOX8gIAALCmnEFTMN1Mx/NQpntcGQAAAJ6VM+gcTDdvtWC3a6a9e0wBAABY
        Uc6gSzA9n3bT+byrN6DmSgAAAPAqOYMuwfTzY5wul2Habt/LdI8rAwAAwLNyBl2C6Ucp0GMKAADA2nIG
        /b6UtxQcj30dFSlXAgAAgFfJGXQJpqfTbjocuvqA01wJAAAAXiVn0CWYRlIdh1aPKQAAAKvKGbRtXMoL
        AADA3yhnUJfyAgAA8LfKGdSlvAAAAPytcgadL+Xdvk2HfTcNu0aPKQAAAKvKGXTuMS2FkVTHsZ2G8por
        AQAAwKvkDFqDaVsKdyWpDkMz7Q9dme5xZQAAAHhWzqBLMI3u0/hDXOebKwEAAMCr5Ay6DH4UhdGFGiMj
        5UoAAADwKjmD/gimcX3v6TyU6R5XBgAAgGflDPp9KW93TauCKQAAACvKGXTuMS2FXbcpibWZji7lBQAA
        YEU5g9Zg2jXv9aGmXb+dDkfBFAAAgPXkDFqDad+WwnYzF+oxBQAAYEU5g873mJa02kZhSayCKQAAAGvK
        GXQZ/KgWlrR6PBn8CAAAgPXkDLoE0+32fS40Ki8AAAAryhl0uZT362s/HY99HRUpVwIAAIBXyRl0Caa/
        fh1rYVN+zpUAAADgVXIGvV7KO6fV/b6rN5/mSgAAAPAqOYMuPaafn+M0ju3U94IpAAAA68kZtAbTpqTV
        y2WYhqGZdjv3mAIAALCenEGXYHo+72qBwY8AAABYU86gyz2mp9M8GpIeUwAAANaUM+jSYxqjIUXBMLZl
        useVAQAA4Fk5gy49pvt9W6/vjVGRciUAAAB4lZxBl2AaBWP5w+HQl+keVwYAAIBn5Qy6BNPoQo2C43FX
        pntcGQAAAJ6VM+gSTOOm07jG93gSTAEAAFhPzqDL4Eddt50OgikAAAAryxl0DqZNFG6mcd8JpgAAAKwq
        Z9D5Ut5S2LabOkxvJNZcCQAAAF4lZ9AfwTTSqlF5AQAAWFPOoMulvGEsBYIpAAAAa8oZ9Ecw3UehS3kB
        AABYUc6gP4Lp4bgTTAEAAFhVzqA1mPbdpj7cNNJqyJUAAADgVXIGrcF0HNvp998/p6bdlIJNme5xZQAA
        AHhWzqBzMB2a6devUx0Vaddvy3SPKwMAAMCzcgatwXTYNdPn537qSkH8nCsBAADAq+QMWoNpJNTLeZj6
        vqnX+eZKAAAA8Co5gy7B9Hjsp74U6DEFAABgTTmD1mAaIyLt993UD6VwaMt0jysDAADAs3IGvQum7TSW
        PwzlD7kSAAAAvErOoDWYxvC8MVzv6TzoMQUAAGBVOYPWYNo27/WX80UwBQAAYF05g9Zg2pTCSKvnj7EU
        upQXAACA9eQMOgfT7Xu98fT8sfe4GAAAAFaVM+g1mL7VtHr53E99vy3TPa4MAAAAz8oZdA6mm7eaUqMb
        tesEUwAAANaTM+gSTOPBpsfLqMcUAACAVeUMWoPp5v23aRi76XgeSmoVTAEAAFhPzqA1mLbbt+nra19v
        Pu17gx8BAACwnpxBazDdbt6mX7+O0+HQTa17TAEAAFhRzqBzMH1/m37/52U6nXbTdvtepntcGQAAAJ6V
        M+j1HtM5rUZht3MpLwAAAOvJGbQG0/e336btpqTUvplOH/sy3ePKAAAA8KycQece01LYtptSuJ1Ol7FM
        97gyAAAAPCtn0OUe01rYCaYAAACsK2fQJZh23ZxW4wGnuRIAAAC8Ss6g18GPfqtJtRaehzLd48oAAADw
        rJxBl8GPojAebHrWYwoAAMCKcgZdBj/qS+EwttPFqLwAAACsKGfQ72Dab6dx35VCPaYAAACsJ2fQZfCj
        WljSqkt5AQAAWFPOoD+C6TA008ngRwAAAKwoZ9AlmO52TSlsp8OxL9M9rgwAAADPyhl0Dqabt9qFGuLm
        01wJAAAAXiVn0BpMm1J4OHS1G7XrmzLd48oAAADwrJxBazBtt2/T6bSraTWeJZMrAQAAwKvkDLoE08t5
        mI7HfooHnOZKAAAA8Co5gy6X8l4uQ02sekwBAABYU86gSzD9/BzrH5pmU6Z7XBkAAACelTNoDaYxVO/X
        1376+Bin7fa9TPe4MgAAADwrZ9AlmEZBaFo9pgAAAKwnZ9DlUt6+3067oZkOp6FM97gyAAAAPCtn0CWY
        Ns371Hbb6XQZy3SPKwMAAMCzcgb9EUxjNKTjWY8pAAAA68kZdL7HtBS2cV1vL5gCAACwrpxBl2CqxxQA
        AIC/Q86gLuUFAADgb/XwUt5auDX4EQAAAOvLGXQJppFUd7sYqndXpntcGQAAAJ6VM+gSTC/n3XS5DPXh
        prkSAAAAvErOoPPgR++/TZ+f4/TxMU7b7XuZ7nFlAAAAeFbOoNdg+lYKhulcEmvT6DEFAABgPTmDzsH0
        2o16OvX1Ot9cCQAAAF4lZ9DlHtNIqodDN/W9YAoAAMB6cgZdgunp2E/j2OoxBQAAYFU5g87BdPs2Hfbd
        NAzN1OkxBQAAYEU5gy7BdBzamlaH8porAQAAwKvkDFqDaVsK48GmkVb3h75M97gyAAAAPCtn0CWYxg2n
        UXg87cp0jysDAADAs3IGXQY/mgvb6XQeynSPKwMAAMCzcgb9EUzj+t7zRTAFAABgPTmDLpfyxhC9ekwB
        AABYW86gc49pLdyUxOoeUwAAANaVM2gNpl3zXgvj+TGHo2AKAADAenIGrcG0b0they3UYwoAAMCKcgad
        7zEtabWNwk4wBQAAYF05gy6DH9VCPaYAAACsLGfQJZhut+91uN6jUXkBAABYUc6gy6W8X5/76Xjo66hI
        uRIAAAC8Ss6g38H06zAdj/3UlJ9zJQAAAHiVnEGvl/LOaXW/b+uQvbkSAAAAvErOoEuP6cfHOI1jW6/x
        zZUAAADgVXIGXXpML5fdNAzNtNu5xxQAAID15Ay6BNPTqa8FekwBAABYU86gSzCNm06jQI8pAAAAa8oZ
        tGuuwfRw6GrBMLRluseVAQAA4Fk5gy49pnHT6VAK9/uuTPe4MgAAADwrZ9AlmEZB/GFfUmuuBAAAAK+S
        M+gSTKMLNZLq4dCX6R5XBgAAgGflDLoE07jpNAoOR8EUAACA9eQMWoNpUwq7Lgr1mAIAALCunEGXUXm7
        blOv7xVMAQAAWFPOoHMwbUphu5l2g8GPAAAAWFfOoPM9pqWwLYVDjIjkcTEAAACsKGfQ72BajKVAMAUA
        AGBNOYO2t0t5G8EUAACAv0HOoPUe0yhoms20P/TuMQUAAGBVOYPWHtO+29SHm0ZaHUfBFAAAgPXkDFrv
        MR2HZvrnr1O9+TRGRsqVAAAA4FVyBq3BdChJ9etrXwt3/bZM97gyAAAAPCtn0Gsw3U4fl2Hquq1gCgAA
        wKpyBq3BNH44nXZTX14FUwAAANaUM+gcTLvNdDh0pbCpN6DmSgAAAPAqOYPWYBojIu337dSXAsEUAACA
        NeUMugTTcWyruAk1VwIAAIBXyRm0BtMYnncY2ul47MurYAoAAMB6cgatwbRt3usvp/NOMAUAAGBVOYN2
        zfZW2JbCwaW8AAAArCpn0PYWTOPa3tNlMPgRAAAAq8oZtAbTZvtW0+r5Mk595zmmAAAArCdn0CWYxjC9
        x5JWu25TpntcGQAAAJ6VM2jbNNfCvpkOp6G86jEFAABgPTmD1h7T7fvbNIxtKdxNO8EUAACAFeUMOgfT
        zdu0G0rhWY8pAAAA68oZdL7HtBTG9b2RVg1+BAAAwJpyBv0e/Ciu79VjCgAAwMpyBl2CaRPPkTn006HI
        lQAAAOBVcgatwTQebtq2m3rz6X7flekeVwYAAIBn5Qy6BNOuFNabTw+CKQAAAOvJGfQ7mHabaYzhel3K
        CwAAwIpyBr3eYxqF25pUBVMAAADWlDPo0mMaIyFFwfEomAIAALCenEHnYFrS6m7X1JtO9ZgCAACwppxB
        2+21x3QohfP1vQY/AgAAYD05gy6X8kZB/MHjYgAAAFhTzqDLpbyRUqMrdRjaMt3jygAAAPCsnEGXYBo3
        nMbNp/GHXAkAAABeJWfQJZieTn0t6HvBFAAAgPXkDLoE08tlNw1Do8cUAACAVeUM2jZNKWzep4+Psd58
        Gl2puRIAAAC8Ss6gSzD9+txP+307dd2mTPe4MgAAADwrZ9DvYPp1qDefNuXnXAkAAABeJWfQ5TmmkVaP
        hxgVyT2mAAAArCdn0OvgR2/Tdvter+09nocy3ePKAAAA8KycQZdg2rabqYvC065M97gyAAAAPCtn0OVS
        3lrYbaeDYAoAAMCKcgatwbRv36fumlYFUwAAANaUM2gNpl1JqzFEr2AKAADA2nIGrY+LabZvtTBGQzqe
        BVMAAADWkzPo/BzTWridhqGdzhej8gIAALCenEG7NnpMN291mN5xFEwBAABYV86gP4JppNWT55gCAACw
        opxBazCNbtS5sPEcUwAAAFaVM2h3u8d0t2tq4eHQl+keVwYAAIBn5QxaHxcTIyKNQ1uv742u1FwJAAAA
        XiVn0CWYHvZdTavxHJlcCQAAAF4lZ9A5mG7eptOxr2k1huzNlQAAAOBVcgbtbsH0fN5Nh0NXb0DNlQAA
        AOBVcgatwXRbCi+l8HTq9ZgCAACwqpxB52D6/jZ9fAw1sTbNpkz3uDIAAAA8K2fQeo/p9v236fNzLH8Y
        p+32vUz3uDIAAAA8K2fQZfCj6Ea9XIapbfWYAgAAsJ6cQZdgGtf1xgNOD6ddme5xZQAAAHhWzqBLMG2i
        +7T84XQZy3SPKwMAAMCzcgb9DqbNe02sx8tQpntcGQAAAJ6VM+g8+NF94VkwBQAAYD05gy7BNG447XrB
        FAAAgHXlDPqHS3ndYwoAAMCacgb9EUwNfgQAAMDacgZdgmnfb6fdEEP1upQXAACA9eQMOt9j+v42fXyM
        VVznmysBAADAq+QMugTTr699Ldxu38t0jysDAADAs3IGXS7l/fwcp8tlmBo9pgAAAKwoZ9AlmEbB6bSr
        oyLlSgAAAPAqOYPWYNpuS+F5mI7Hfur7pkz3uDIAAAA8K2fQrm3mwkiq49jqMQUAAGBVOYPWYBrdqIdD
        Nw1DSap6TAEAAFhRzqA1mG5LYSTVMBS5EgAAALxKzqBzMH1/m3a7pqTVdjoc+zLd48oAAADwrJxB2+Ya
        TPt+W7tRT+ehTPe4MgAAADwrZ9A6Ku+tMLpRLx9jme5xZQAAAHhWzqA1mG7efpsL9910+dyX6R5XBgAA
        gGflDPodTLttvelUMAUAAGBNOYPWYPpeCuPZMfFg07NLeQEAAFhRzqBzj+n7XNj12+lo8CMAAABWlDPo
        MvhR121q4emixxQAAID15Ay6BNO2LYUlsQqmAAAArCln0GXwo1oYadU9pgAAAKwoZ9Bl8KPt5r0UNqXQ
        qLwAAACsJ2fQ6+BHb9OvX8fpdNrVP+RKAAAA8Co5g3a3e0x//+elFm6372W6x5UBAADgWTmDdm1TCjdz
        Wj0cuqnttmW6x5UBAADgWTmD1mDabt+mr6/9tN939QGnuRIAAAC8Ss6g9VLeeLjpMHb1waa7nR5TAAAA
        1pMzaNeWYNps3qZ+10zHy1jSqmAKAADAenIGraPyRuGuFJ4/xvqA01wJAAAAXiVn0DmYbt+mcWyny+de
        jykAAACryhn0Gkzf602n54/9NJTUmisBAADAq+QMOgfT5r2m1ehGHYe2TPe4MgAAADwrZ9AaTNtSOJRf
        zpeh/jFXAgAAgFfJGbQG067d1F9O52EaBFMAAABWlDNoDaZ9t5n2+3Ya911NrbkSAAAAvErOoN13MO2m
        fmgEUwAAAFaVM2jtMd312+l47OsDTo3KCwAAwJpyBl2C6eU8TH0vmAIAALCunEFrMI0fPj/3U1f+KJgC
        AACwppxB52A6NNOvX6epbTfTriTWXAkAAABeJWfQOvhRDNP7+++fU1MKY9jeXAkAAABeJWfQ5XExu10z
        7Q990ZXpHlcGAACAZ+UMWoNp07xP4XDcFX2Z7nFlAAAAeFbOoPVS3lthpFXBFAAAgDXlDNo1zXfhGIVF
        rgQAAACvkjNoDaZtKYjRkMZ9J5gCAACwqpxBu/YumA5j61JeAAAAVpUzaA2m0YXadXNaPZ52ZbrHlQEA
        AOBZOYO29R7TzVu9vrfrttPxPJTpHlcGAACAZ+UMOveYRuH2fWpL4ekylukeVwYAAIBn5Qy6BNNIqvGA
        04NLeQEAAFhRzqBLML2cd9PlMkxNuynTPa4MAAAAz8oZtAbT7ftv0+fnOH18jNN2+16me1wZAAAAnpUz
        6DWYvpWCYTqXxNo0ekwBAABYT86gczC9dqOeTn29zjdXAgAAgFfJGXS5xzSS6uHQTX0vmAIAALCenEGX
        YHo69tM4tnpMAQAAWFXOoHMw3b5Nh303DUMzdXpMAQAAWFHOoEswHYe2ptWhvOZKAAAA8Co5g9Zg2pbC
        eLBppNX9oS/TPa4MAAAAz8oZdAmmccNpFB5PuzLd48oAAADwrJxBl8GP5sJ2Op2HMt3jygAAAPCsnEF/
        BNO4vvd8EUwBAABYT86gy6W8MUSvHlMAAADWljPo3GNaCzclsbrHFAAAgHXlDFqDade818J4fszhKJgC
        AACwnpxBazDt21LYXgv1mAIAALCinEHne0xLWm2jsBNMAQAAWFfOoMvgR7VQjykAAAAryxl0Cabb7Xsd
        rvdoVF4AAABWlDPocinv1+d+Oh76OipSrgQAAACvkjPodzD9OkzHYz815edcCQAAAF4lZ9DrpbxzWt3v
        2zpkb64EAAAAr5Iz6NJj+vExTuPY1mt8cyUAAAB4lZxBlx7Ty2U3DUMz7XbuMQUAAGA9OYMuwfR06muB
        HlMAAADWlDPoEkzjptMo0GMKAADAmnIG7ZprMD0culowDG2Z7nFlAAAAeFbOoEuPadx0OpTC/b4r0z2u
        DAAAAM/KGXQJplEQf9iX1JorAQAAwKvkDLoE0+hCjaR6OPRluseVAQAA4Fk5gy7BNG46jYLDUTAFAABg
        PTmD1mDalMKui0I9pgAAAKwrZ9BlVN6u29TrewVTAAAA1pQz6BxMm1LYbqbdYPAjAAAA1pUz6HyPaSls
        S+EQIyJ5XAwAAAAryhn0O5gWYykQTAEAAFhTzqDt7VLeRjAFAADgb5AzaL3HNAqaZjPtD717TAEAAFhV
        zqC1x7TvNvXhppFWx1EwBQAAYD05g9Z7TMehmf7561RvPo2RkXIlAAAAeJWcQWswHUpS/fra18Jdvy3T
        Pa4MAAAAz8oZ9BpMt9PHZZi6biuYAgAAsKqcQWswjR9Op93Ul1fBFAAAgDXlDDoH024zHQ5dKWzqDai5
        EgAAALxKzqA1mMaISPt9O/WlQDAFAABgTTmDLsF0HNsqbkLNlQAAAOBVcgatwTSG5x2Gdjoe+/IqmAIA
        ALCenEFrMG2b9/rL6bwTTAEAAFhVzqBds70VtqVwcCkvAAAAq8oZtL0F07i293QZDH4EAADAqnIGrcG0
        2b7VtHq+jFPfeY4pAAAA68kZdAmmMUzvsaTVrtuU6R5XBgAAgGflDNo2zbWwb6bDaSivekwBAABYT86g
        tcd0+/42DWNbCnfTTjAFAABgRTmDzsF08zbthlJ41mMKAADAunIGne8xLYVxfW+kVYMfAQAAsKacQb8H
        P4rre/WYAgAAsLKcQZdg2sRzZA79dChyJQAAAHiVnEFrMI2Hm7btpt58ut93ZbrHlQEAAOBZOYMuwbQr
        hfXm04NgCgAAwHpyBv0Opt1mGmO4XpfyAgAAsKKcQa/3mEbhtiZVwRQAAIA15Qy69JjGSEhRcDwKpgAA
        AKwnZ9A5mJa0uts19aZTPaYAAACsKWfQdnvtMR1K4Xx9r8GPAAAAWE/OoMulvFEQf/C4GAAAANaUM+hy
        KW+k1OhKHYa2TPe4MgAAADwrZ9AlmMYNp3HzafwhVwIAAIBXyRl0CaanU18L+l4wBQAAYD05gy7B9HLZ
        TcPQ6DEFAABgVTmDtk0z/WPctdN+aKfD2E7HfVeN5Y9Dt62iezXEA1C7drO8RuUmbN+m8/lQHKdfv47T
        19dx+vzYlzcaStmuJuGvr30pG+eyUyk79vUm17ie+JaS63y7Mt+Yd319n/r4W1WmK9Peft+VFYi69YbZ
        Yhzjptl5RKfjsavv+/FxKO/7MX1+norL1HelXjH0pU7xX693XffNtNm81fX95z8v1/X+P7CO5T2a5n0R
        7xPvF+976yaPxr/NJ9omdoiPssyfn/syr1Ndl8v5VNs0Hnxb53E3n5s6vzrP7TSWeR7KPOty3c3z4zKW
        99iX9xvqfGJ+38s3r/+wey9/35Z1mZfho2zD83ko9XbT8VC24Xi/Dcv7xnvflqMu23aed5nfOGzq8szt
        Evvjoc7zUpYj5nk87sp692Vb/rFd2nBdz7ab2yXaINpkbpe5baJObZvaJg/a5lS2Qaz/v902m79um+t2
        +Xfa5rZt6na6a5uY54+2KfOs23lpm+2PZVvaZri1zbi0zaW2TdmWh91ft83Vd9vMyzO3zbwu9+193za7
        2NZle8XnZxy3d+v89m+v87I/ls9JfCaXdT7vy/uMte79+sZrrPOu7I/1Pa+fidvy3fbHn/vO9/u/ap2X
        /bHM4zafWLau7JPD0Nfp/+d/LnV+Ma/bfOZtFco+GftnWca6nHXfLfO97rf3+3NXjoehKetdt2ts02U7
        /nF//N6WsT/Ox/s47v+hbeq8YluUfbu81vk9apvr/jjPc94fD4ehfqb/0DbF0jb12BfH2qhT2ua6Hev+
        GMfRuh0ft00sW8xzuLVNWY96rPi6O1bE/v2XbXNtn7pssa5z20Qb/P77uW6bj8u+fk7qcl3bJo4VP9om
        5nttm7l9UrvEetdtOftX7RLfu4/aJb6n4/t6aZfra91Gxe07L77/bt+F8b0Y34/xPekc4T9c77ruzhHq
        /Oo8nSM4R3jQNlffbTMvz9w2zhH+bJ2X/bHM4zafWLb/n84R/jFvkD8/cN4+WLHAsUB1gxRN21axw8bJ
        xOEYG3L+komFjIWND2OseFw/PG+UnxtkLGX7shEP5e9hiI0fH+JD+UIoO8yxHCzC6V40WNnYl1BW/hzT
        lA/BvnwIon7dwNfGC7to+CI2RG3I0oj/zhfGn633vDPMr/OOOa/3/4V1HGMHLobynjHdbF6G2FnDfv/9
        wbk/YB5Lm8VBaV6XsbZpXdfrOsf61w9Z2XHu12/+eT5AHMo6xQd9PrDNB6rL5VCWfV+2Yezc1zao5p1y
        GDe1XrTBVzk5jB365wcpljGWd36feM/bB2lpk+syxslmzC/aJb5o4kBx+1Df2mWeX9n2120SbTOWbfKn
        7VLW41+3zbhu29SD5/NtcypfiLe2ie39H7VN+QL/KOt8Ppf1rQfL9dvmVNb5WPbJl65zORmIE6Fom2V9
        l3nGcm7qNv/fWue8P8brGO9b/j6MUT7fizEr+1h53/kkqHzRlv3kVPaRc1nXS4hlL/voqXi0Px9ivy1u
        ++L9/nhbjmV/LO5Prm5fQs8eK+YTtDhWxPF33h//um2a6/SH6zaN8DcfK+oyDuU1tkndLqVtrl/mP9sm
        lmsWx5pb+/74/F2Xu7ZPWeeY//z3fp5vTHNtn9pW5YRgV967flfc2qb4/vKOE9Ly3RInMNftH47lvQ+l
        LMTPYR/H+rJdH7VLbZt/o13i+3hul7vv6rLusR1i+e5PnOP7Lr736vdZ2bax799/P/6335XOEZwjzOLn
        n5975wgvbps4ljpHmJft2XV2jrDsy/9b5wj/+FcHzvgyjQ0fKxALGge/Yzko7I/HKr5Id2Vh+l1J1PVN
        4yA9qx+6SN11Ab4/iLFy805VNlA0yHUjxQc4vrj3xzjADrUx6wnGdcPOG3j+IrhtoH3ZALHMywf2upHq
        CUn872d86Jdlmz9Q8fofr3ccCEudW4OdS3ms4+b2v1L/B9ZxOfG5V9473vMmyg7lAxQ71O3DEssb61K3
        TfngRVsO5QQwdta67lGvKvOK9Sjrfv9lOO53dVluX87xPyy37Rzz2o3buv3m7XjdllXZ6ctOO4y3E6ho
        p3mnnfef+YC9j4PHj+14/TDV+X23S8xrPFwPovV/kL7b5fsEMQ7id+1S6tXtEsq8HrZL+NvaJrbnv26b
        Zf2jXvXftc1w3zY35fd4rW1z+9/S3DblgHLfNpePa9uU979vm7pspfxR28wHptQ25WB2a5v9oRzQSr1X
        r/OP/THc/fyfrPP5v1jnh/tjXefYF+b51X0hlLI6v+vrWJYr1q2L/7Ut87kdq+oXV90HY3+8HsuK2Bdv
        +9Gj/Tm+RCJ0xbyPZX3qMtT3u753/SyUY0WEsdify3rEuoQf+2OZz+lSvtjqZ/u6DWJedX3mtol51n17
        vLZNbZfUNn1Zr7J9D/HlXNqxii/7+L1+LuJzuVum/8OxorRPbIs4uf/+vJXlKV+s3/Oa5zuWz/iwj/8V
        n0+4Yj63Y/etferJQPl81/mVujHP2CYxn9gudVvX7V1OOMtyxf9WR7iJeczbuXyfhGijElrnk404PpR2
        ie153aa3bXtrm9iecXyZ1+HaLmV/uLmF8cftUsS61P28qe3x/V1d2rTUjX0r9tn4fov3iOWLfamub9lv
        4vgY34vzfxbEMdI5gnOEB5975whzm9z8bW0T29M5QrSNc4T5c3J7/f/lHOEfMYNtOnDeZhwLGpey3Nxf
        1jPsyhdaMcbPZdqh1I3LYHalgb5fy4aJjXN7Lcar2++LZdrNYhcbt4qfi9Jwob++VvH3+9/vyodS52Y5
        0Sliw/xc7/mA8mfrfROX9Dy8rOd++Yv/rXW8n+9P1/e8LcP9Mt/ZlWluhn5T1+/ePj4kV7ey+3Wb2/x7
        HnV97uZV613d5jHvO2Wbx7TX6Wudm+v8xzjpLO6X4abOc1me2743v++yfDGP5GFZ3RbXZbnfprflq+Zt
        /6Pd7n7/67a4c3vPtJw/xPLU1/t6D9rmzq3sfh637Vrdlrkry1vU6e+24e3nW9v0Zdqbud5sWbZibp/r
        Mtza5cG8bu9/vw1q/avb71Vti++2rPO7um//5b3q+3zXXfbH++WP34s6/V297/pFOX71t/a8Tn9zW+a6
        vLE/ljp5u/+YV53fXd1r/T8z74MxXbzefv5zS1tW3/vgz9/nsvv9sv49Xuvv3+//R7f1uG3PrNQvf8vr
        XqXt+5fzuV+emG6Z/ltcohvfLX35wqsezSf8WO4/us2nzqtMH/N6OJ9/YVmO/0YTr+W7p4n98rv8u+2+
        26qLIPc3ixOHONmqJ0tlezlHcI4Qbp/R+XPqHCEsy3Fbvmre9j/a7e73v26LO7f3TMv5QyxPfb2v5xzh
        vv2X96rv81132R/vlz9+L+r0d/W+6xf1e+jantfpb27LXJfXOUJR6pe/5XWv0vad57Od/h9j8UqsDmle
        QAAAAABJRU5ErkJggg==
</value>
  </data>
  <data name="$this.Icon" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
    <value>
        AAABAAEAICAAAAAAAACoCAAAFgAAACgAAAAgAAAAQAAAAAEACAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAB
        AAAAAAAAAACAAACAAAAAgIAAgAAAAIAAgACAgAAAwMDAAMDcwADwyqYABAQEAAgICAAMDAwAERERABYW
        FgAcHBwAIiIiACkpKQBVVVUATU1NAEJCQgA5OTkAgHz/AFBQ/wCTANYA/+zMAMbW7wDW5+cAkKmtAAAA
        MwAAAGYAAACZAAAAzAAAMwAAADMzAAAzZgAAM5kAADPMAAAz/wAAZgAAAGYzAABmZgAAZpkAAGbMAABm
        /wAAmQAAAJkzAACZZgAAmZkAAJnMAACZ/wAAzAAAAMwzAADMZgAAzJkAAMzMAADM/wAA/2YAAP+ZAAD/
        zAAzAAAAMwAzADMAZgAzAJkAMwDMADMA/wAzMwAAMzMzADMzZgAzM5kAMzPMADMz/wAzZgAAM2YzADNm
        ZgAzZpkAM2bMADNm/wAzmQAAM5kzADOZZgAzmZkAM5nMADOZ/wAzzAAAM8wzADPMZgAzzJkAM8zMADPM
        /wAz/zMAM/9mADP/mQAz/8wAM///AGYAAABmADMAZgBmAGYAmQBmAMwAZgD/AGYzAABmMzMAZjNmAGYz
        mQBmM8wAZjP/AGZmAABmZjMAZmZmAGZmmQBmZswAZpkAAGaZMwBmmWYAZpmZAGaZzABmmf8AZswAAGbM
        MwBmzJkAZszMAGbM/wBm/wAAZv8zAGb/mQBm/8wAzAD/AP8AzACZmQAAmTOZAJkAmQCZAMwAmQAAAJkz
        MwCZAGYAmTPMAJkA/wCZZgAAmWYzAJkzZgCZZpkAmWbMAJkz/wCZmTMAmZlmAJmZmQCZmcwAmZn/AJnM
        AACZzDMAZsxmAJnMmQCZzMwAmcz/AJn/AACZ/zMAmcxmAJn/mQCZ/8wAmf//AMwAAACZADMAzABmAMwA
        mQDMAMwAmTMAAMwzMwDMM2YAzDOZAMwzzADMM/8AzGYAAMxmMwCZZmYAzGaZAMxmzACZZv8AzJkAAMyZ
        MwDMmWYAzJmZAMyZzADMmf8AzMwAAMzMMwDMzGYAzMyZAMzMzADMzP8AzP8AAMz/MwCZ/2YAzP+ZAMz/
        zADM//8AzAAzAP8AZgD/AJkAzDMAAP8zMwD/M2YA/zOZAP8zzAD/M/8A/2YAAP9mMwDMZmYA/2aZAP9m
        zADMZv8A/5kAAP+ZMwD/mWYA/5mZAP+ZzAD/mf8A/8wAAP/MMwD/zGYA/8yZAP/MzAD/zP8A//8zAMz/
        ZgD//5kA///MAGZm/wBm/2YAZv//AP9mZgD/Zv8A//9mACEApQBfX18Ad3d3AIaGhgCWlpYAy8vLALKy
        sgDX19cA3d3dAOPj4wDq6uoA8fHxAPj4+ADw+/8ApKCgAICAgAAAAP8AAP8AAAD//wD/AAAA/wD/AP//
        AAD///8ACgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoK
        CgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCrcKCgoKCgoKCgoKCgoK
        CgoKCgoKCgoKCgoKCgoKCgoK+QoKCgoKCgoKCgrSCgoKCgoKCgoKCgoKCgoKCgoKCgr5+QoKCgoKCgr5
        sQoKCgoKCgoKCgoKCgoKCgoKCgoKCvn5CgoKCgoKsbEKCgoKCgoKCgoKCgoKCgoKCgoKCgoK+ZQKCgoK
        CuPjCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgr5sQoKCgpHsQoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgpq
        Cgr5QbEKCgqxtwoKCgoKCgr5CgoK+QoKCgoKCgoKCuP5lPmUCgoKCrGxt7f5+fkKCvkK+fkKCgoKCgoK
        CgoKFkH5lAoK+QoK+bcKCgr5t7cK+fn5CgoKCgoKCgoKCrdB+fkKCgoK0rext7EKCvn5Crf5+QoKCgoK
        CgoKCgqx+UdBCgoKCgq3+fkKt5QK+fkK0vn5CgoKCgoKCgoKCgq3+UGUCgoKCvmxtwoKsbcK+QqUCvn5
        +QoKCgoKCgoKCgr5F0f5CgoKCmqxCgoKavn5+eP5arexagoKCgoKCgoKCgqU+Wrj+QoKt7cKRmlq+Qq3
        lJQXF+MWCgoKCgoKCgoKCvn5+flq4/kKCuvs7O0KCgoKCgoKCgoKCgoKCgoKCgoKCkfjCgoWRxaSku3s
        7OwKCgoKCgoKCgoKCgoKCgoKCgoK+fkKCgr5bpKS7e3t7eztCgoKCgoKCgoKCgoKCgoKCgr5+ZQKCgqS
        kpLt7e3t7e3tCgoKCgoKCgoKCgoKCgoKCgr54woK7++SkpLt7e3t7Ozs7fcKCgoKCgoKCgoKCrHjFkEX
        FhZpku/3kpLt7e3s7Ozs7JIKCgoKCgoKCgoKR/n5+fn5+fkg7e+SkpLt7Ozs7Ozs7ZIKCgoKCgoKCgpH
        QUFBQUcXahbt95KS7e3s7Ozs7Oztkvf3CgoKCgoKCgoKCgrs6+wKCpKS7e3t7Ozs7Ozt7ZL39+/vCgoK
        CgoKCgoKCuzr6uzs7ZLt7ezs7Ozs7ZKS9+/v7+/vCgoKCgoKCgrr7JLrbeyS7ezs7Ozs7ZKS9/fv7wcH
        BwcKCgoKCgoK7BLs7/fs7Ozs7Ozs7O2S9+/v7+8HBwcHBwoKCgoKCgoSbe8H7+zt7Ovs7O2Skvfv7+8H
        BwcHBwcHCgoKCgoK7ezv7++S7O3v9+zs9/fv7+8HBwcHBwcH8fAKCgoKCuwS6+ztkvfv7+8HB/f3B7y8
        vPDw8PDwvPP/8/////////////////f////3/v//8/n///Pz///z5///88////sc/u/4PAaf+GziP/Dw
        ZH/h8SR/8PGVH/h5wA/8GQgP/AYf//5gD//+cAP//jgB//8wAD/4AAAf+AAAD/gAAAP/jAAB/4AAAP8A
        AAD+AAAA/gAAAPwAAAD4AAAA
</value>
  </data>
</root>

================================================
FILE: Razor/Client/ClassicUO.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using Assistant.UI;
using CUO_API;
using System;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Threading;
using System.Windows.Forms;
using Assistant.Core;
using Assistant.Scripts;

namespace Assistant
{
    public partial class Engine
    {
        public static unsafe void Install(PluginHeader* plugin)
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            AppDomain.CurrentDomain.AssemblyResolve += (sender, e) =>
            {
                string[] fields = e.Name.Split(',');
                string name = fields[0];
                string culture = fields[2];

                if (name.EndsWith(".resources") && !culture.EndsWith("neutral"))
                {
                    return null;
                }

                AssemblyName askedassembly = new AssemblyName(e.Name);

                bool isdll = File.Exists(Path.Combine(RootPath, askedassembly.Name + ".dll"));

                return Assembly.LoadFile(Path.Combine(RootPath, askedassembly.Name + (isdll ? ".dll" : ".exe")));
            };

            SplashScreen.Start();
            m_ActiveWnd = SplashScreen.Instance;

            Client.Init(false);

            if (!(Client.Instance as ClassicUOClient).Install(plugin))
            {
                Process.GetCurrentProcess().Kill();
                return;
            }

            // load ultimasdk before or the Language.Load will throw the cliloc not found warning every time you run cuo
            string clientPath =
                ((OnGetUOFilePath) Marshal.GetDelegateForFunctionPointer(plugin->GetUOFilePath, typeof(OnGetUOFilePath))
                )();

            // just replicating the static .ctor
            Ultima.Files.ReLoadDirectory();
            Ultima.Files.LoadMulPath();

            Ultima.Files.SetMulPath(clientPath);
            Ultima.Multis.PostHSFormat = UsePostHSChanges;
            Client.Instance.ClientEncrypted = false;
            Client.Instance.ServerEncrypted = false;


            /* Load localization files */
            if (!Language.Load("ENU"))
            {
                SplashScreen.End();
                MessageBox.Show(
                    "WARNING: Razor was unable to load the file Language/Razor_lang.ENU\n.",
                    "Language Load Error", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }

            m_Running = true;

            Language.LoadCliLoc();

            /* Initialize engine */
            SplashScreen.Message = LocString.Initializing;
            Initialize(typeof(Engine).Assembly);

            /* Load Profile */
            SplashScreen.Message = LocString.LoadingLastProfile;
            Config.LoadCharList();
            Overrides.Load();
            if (!Config.LoadLastProfile())
                MessageBox.Show(
                    "The selected profile could not be loaded, using default instead.", "Profile Load Error",
                    MessageBoxButtons.OK, MessageBoxIcon.Warning);

            SplashScreen.Message = LocString.WaitingForClient;

            SplashScreen.End();

            Thread t = new Thread(() => { RunUI(); });
            t.SetApartmentState(ApartmentState.STA);
            t.IsBackground = true;
            t.Start();
        }
    }

    public class ClassicUOClient : Client
    {
        public override DateTime ConnectionStart => m_ConnectionStart;
        public override IPAddress LastConnection { get; }
        public override Process ClientProcess => m_ClientProcess;
        public override bool ClientRunning => m_ClientRunning;
        private uint m_In, m_Out;

        private DateTime m_ConnectionStart;
        private Process m_ClientProcess = null;
        private bool m_ClientRunning = false;
        private string m_ClientVersion;

        private static OnPacketSendRecv _sendToClient, _sendToServer, _recv, _send;
        private static OnGetPacketLength _getPacketLength;
        private static OnGetPlayerPosition _getPlayerPosition;
        private static OnCastSpell _castSpell;
        private static OnGetStaticImage _getStaticImage;
        private static OnTick _tick;
        private static RequestMove _requestMove;
        private static OnSetTitle _setTitle;
        private static OnGetUOFilePath _uoFilePath;


        private static OnHotkey _onHotkeyPressed;
        private static OnMouse _onMouse;
        private static OnUpdatePlayerPosition _onUpdatePlayerPosition;
        private static OnClientClose _onClientClose;
        private static OnInitialize _onInitialize;
        private static OnConnected _onConnected;
        private static OnDisconnected _onDisconnected;
        private static OnFocusGained _onFocusGained;
        private static OnFocusLost _onFocusLost;
        private IntPtr m_ClientWindow;

        public override void SetMapWndHandle(Form mapWnd)
        {
        }

        public override void RequestStatbarPatch(bool preAOS)
        {
        }

        public override void SetCustomNotoHue(int hue)
        {
        }

        public override void SetSmartCPU(bool enabled)
        {
        }

        public override void SetGameSize(int x, int y)
        {
        }

        public override Loader_Error LaunchClient(string client)
        {
            return Loader_Error.SUCCESS;
        }

        public override bool ClientEncrypted { get; set; }

        public override bool ServerEncrypted { get; set; }

        public static Assembly Assembly { get; set; }

        public unsafe bool Install(PluginHeader* header)
        {
            _sendToClient =
                (OnPacketSendRecv) Marshal.GetDelegateForFunctionPointer(header->Recv, typeof(OnPacketSendRecv));
            _sendToServer =
                (OnPacketSendRecv) Marshal.GetDelegateForFunctionPointer(header->Send, typeof(OnPacketSendRecv));
            _getPacketLength =
                (OnGetPacketLength) Marshal.GetDelegateForFunctionPointer(header->GetPacketLength,
                    typeof(OnGetPacketLength));
            _getPlayerPosition =
                (OnGetPlayerPosition) Marshal.GetDelegateForFunctionPointer(header->GetPlayerPosition,
                    typeof(OnGetPlayerPosition));
            _castSpell = (OnCastSpell) Marshal.GetDelegateForFunctionPointer(header->CastSpell, typeof(OnCastSpell));
            _getStaticImage =
                (OnGetStaticImage) Marshal.GetDelegateForFunctionPointer(header->GetStaticImage,
                    typeof(OnGetStaticImage));
            _requestMove =
                (RequestMove) Marshal.GetDelegateForFunctionPointer(header->RequestMove, typeof(RequestMove));
            _setTitle = (OnSetTitle) Marshal.GetDelegateForFunctionPointer(header->SetTitle, typeof(OnSetTitle));
            _uoFilePath =
                (OnGetUOFilePath) Marshal.GetDelegateForFunctionPointer(header->GetUOFilePath, typeof(OnGetUOFilePath));
            m_ClientVersion = new Version((byte) (header->ClientVersion >> 24), (byte) (header->ClientVersion >> 16),
                (byte) (header->ClientVersion >> 8), (byte) header->ClientVersion).ToString();
            m_ClientRunning = true;
            m_ClientWindow = header->HWND;
            _tick = Tick;
            _recv = OnRecv;
            _send = OnSend;
            _onHotkeyPressed = OnHotKeyHandler;
            _onMouse = OnMouseHandler;
            _onUpdatePlayerPosition = OnPlayerPositionChanged;
            _onClientClose = OnClientClosing;
            _onInitialize = OnInitialize;
            _onConnected = OnConnected;
            _onDisconnected = OnDisconnected;
            _onFocusGained = OnFocusGained;
            _onFocusLost = OnFocusLost;
            header->Tick = Marshal.GetFunctionPointerForDelegate(_tick);
            header->OnRecv = Marshal.GetFunctionPointerForDelegate(_recv);
            header->OnSend = Marshal.GetFunctionPointerForDelegate(_send);
            header->OnHotkeyPressed = Marshal.GetFunctionPointerForDelegate(_onHotkeyPressed);
            header->OnMouse = Marshal.GetFunctionPointerForDelegate(_onMouse);
            header->OnPlayerPositionChanged = Marshal.GetFunctionPointerForDelegate(_onUpdatePlayerPosition);
            header->OnClientClosing = Marshal.GetFunctionPointerForDelegate(_onClientClose);
            header->OnInitialize = Marshal.GetFunctionPointerForDelegate(_onInitialize);
            header->OnConnected = Marshal.GetFunctionPointerForDelegate(_onConnected);
            header->OnDisconnected = Marshal.GetFunctionPointerForDelegate(_onDisconnected);
            header->OnFocusGained = Marshal.GetFunctionPointerForDelegate(_onFocusGained);
            header->OnFocusLost = Marshal.GetFunctionPointerForDelegate(_onFocusLost);

            Assembly = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(a => a.FullName.StartsWith("ClassicUO,"));

            return true;
        }

        public unsafe override bool InstallHooks(IntPtr pluginPtr)
        {
            Engine.MainWindow.SafeAction((s) => { Engine.MainWindow.MainForm_EndLoad(); });
            return true;
        }

        private void Tick()
        {
            Timer.Slice();
        }

        private void OnPlayerPositionChanged(int x, int y, int z)
        {
            World.Player.Position = new Point3D(x, y, z);
        }

        private unsafe bool OnRecv(ref byte[] data, ref int length)
        {
            m_In += (uint) length;
            fixed (byte* ptr = data)
            {
                bool result = true;
                byte id = data[0];

                PacketReader reader = null;
                Packet packet = null;
                bool isView = PacketHandler.HasServerViewer(id);
                bool isFilter = PacketHandler.HasServerFilter(id);
                
                if (isView)
                {
                    reader = new PacketReader(ptr, length, PacketsTable.IsDynLength(id));
                    result = !PacketHandler.OnServerPacket(id, reader, packet);
                }

                if (isFilter)
                {
                    packet = new Packet(data, length, PacketsTable.IsDynLength(id));
                    result = !PacketHandler.OnServerPacket(id, reader, packet);

                    data = packet.Compile();
                    length = (int) packet.Length;
                }

                if (Packet.Logging)
                {
                    Packet.Log(PacketPath.ServerToClient, ptr, data.Length, !result);
                }

                return result;
            }
        }

        private unsafe bool OnSend(ref byte[] data, ref int length)
        {
            m_Out += (uint) length;
            fixed (byte* ptr = data)
            {
                bool result = true;
                byte id = data[0];

                PacketReader reader = null;
                Packet packet = null;
                bool isView = PacketHandler.HasClientViewer(id);
                bool isFilter = PacketHandler.HasClientFilter(id);
                
                if (isView)
                {
                    reader = new PacketReader(ptr, length, PacketsTable.IsDynLength(id));
                    result = !PacketHandler.OnClientPacket(id, reader, packet);
                }
                else if (isFilter)
                {
                    packet = new Packet(data, length, PacketsTable.IsDynLength(id));
                    result = !PacketHandler.OnClientPacket(id, reader, packet);

                    data = packet.Compile();
                    length = (int) packet.Length;
                }

                if (Packet.Logging)
                {
                    Packet.Log(PacketPath.ClientToServer, ptr, data.Length, !result);
                }

                return result;
            }
        }

        private void OnMouseHandler(int button, int wheel)
        {
            if (button > 4)
                button = 3;
            else if (button > 3)
                button = 2;
            else if (button > 2)
                button = 2;
            else if (button > 1)
                button = 1;

            HotKey.OnMouse(button, wheel);
        }

        private enum SDL_Keymod
        {
            KMOD_NONE = 0x0000,
            KMOD_LSHIFT = 0x0001,
            KMOD_RSHIFT = 0x0002,
            KMOD_LCTRL = 0x0040,
            KMOD_RCTRL = 0x0080,
            KMOD_LALT = 0x0100,
            KMOD_RALT = 0x0200,
            KMOD_LGUI = 0x0400,
            KMOD_RGUI = 0x0800,
            KMOD_NUM = 0x1000,
            KMOD_CAPS = 0x2000,
            KMOD_MODE = 0x4000,
            KMOD_RESERVED = 0x8000
        }

        private enum SDL_Keycode_Ignore
        {
            SDLK_LCTRL = 1073742048,
            SDLK_LSHIFT = 1073742049,
            SDLK_LALT = 1073742050,
            SDLK_RCTRL = 1073742052,
            SDLK_RSHIFT = 1073742053,
            SDLK_RALT = 1073742054,
        }

        private bool OnHotKeyHandler(int key, int mod, bool ispressed)
        {
            if (ispressed && !Enum.IsDefined(typeof(SDL_Keycode_Ignore), key))
            {
                ModKeys cur = ModKeys.None;
                SDL_Keymod keymod = (SDL_Keymod) mod;
                if (keymod.HasFlag(SDL_Keymod.KMOD_LCTRL) || keymod.HasFlag(SDL_Keymod.KMOD_RCTRL))
                    cur |= ModKeys.Control;
                if (keymod.HasFlag(SDL_Keymod.KMOD_LALT) || keymod.HasFlag(SDL_Keymod.KMOD_RALT))
                    cur |= ModKeys.Alt;
                if (keymod.HasFlag(SDL_Keymod.KMOD_LSHIFT) || keymod.HasFlag(SDL_Keymod.KMOD_RSHIFT))
                    cur |= ModKeys.Shift;
                return HotKey.OnKeyDown(Win32Platform.MapKey(key), cur);
            }

            return true;
        }

        private void OnDisconnected()
        {
            PacketHandlers.Party.Clear();
            //TODO reset window title
            Engine.MainWindow.UpdateTitle();
            UOAssist.PostLogout();

            World.Player = null;
            World.Items.Clear();
            World.Mobiles.Clear();
            Macros.MacroManager.Stop();
            ScriptManager.OnLogout();
            ActionQueue.Stop();
            Counter.Reset();
            GoldPerHourTimer.Stop();
            BandageTimer.Stop();
            GateTimer.Stop();
            WaypointManager.StopTimer();
            BuffDebuffManager.Stop();
            CooldownManager.Stop();
            StealthSteps.Unhide();
            Engine.MainWindow.OnLogout();
            if (Engine.MainWindow.MapWindow != null)
                Engine.MainWindow.MapWindow.Close();
            PacketHandlers.Party.Clear();
            PacketHandlers.IgnoreGumps.Clear();
            Agents.BuyAgent.OnDisconnected();
            Config.Save();
        }

        private void OnConnected()
        {
            m_ConnectionStart = DateTime.UtcNow;
        }

        private void OnClientClosing()
        {
            var last = Console.BackgroundColor;
            var lastFore = Console.ForegroundColor;
            Console.BackgroundColor = ConsoleColor.Red;
            Console.ForegroundColor = ConsoleColor.Black;
            Console.WriteLine("Closing Razor instance");
            Console.BackgroundColor = last;
            Console.ForegroundColor = lastFore;
            Engine.Close();
        }

        private void OnInitialize()
        {
            var last = Console.BackgroundColor;
            var lastFore = Console.ForegroundColor;
            Console.BackgroundColor = ConsoleColor.Green;
            Console.ForegroundColor = ConsoleColor.Black;
            Console.WriteLine("Initialized Razor instance");
            Console.BackgroundColor = last;
            Console.ForegroundColor = lastFore;
        }

        public override void SetConnectionInfo(IPAddress addr, int port)
        {
        }

        public override void SetNegotiate(bool negotiate)
        {
        }

        public override bool Attach(int pid)
        {
            return false;
        }

        public override void Close()
        {
        }

        public override void UpdateTitleBar()
        {
            if (!ClientRunning)
                return;

            if (World.Player != null && Config.GetBool("TitleBarDisplay"))
            {
                ResetTitleBarBuilder();

                TitleBarBuilder.Replace(@"{char}", World.Player.Name);

                TitleBarBuilder.Replace(@"{crimtime}",
                    World.Player.CriminalTime != 0 ? $"{World.Player.CriminalTime}" : "-");

                TitleBarBuilder.Replace(@"{hp}", $"{World.Player.Hits}");
                TitleBarBuilder.Replace(@"{mana}", $"{World.Player.Mana}");
                TitleBarBuilder.Replace(@"{stam}", $"{World.Player.Stam}");

                TitleBarBuilder.Replace(@"{weight}", World.Player.Weight.ToString());

                TitleBarBuilder.Replace(@"{bandage}", BandageTimer.Running ? $"{BandageTimer.Count}" : "-");

                TitleBarBuilder.Replace(@"{statbar}", string.Empty);
                TitleBarBuilder.Replace(@"{mediumstatbar}", string.Empty);
                TitleBarBuilder.Replace(@"{largestatbar}", string.Empty);

                foreach (Counter c in Counter.List)
                {
                    if (c.Enabled)
                        TitleBarBuilder.Replace($"{{{c.Format}}}", c.GetTitlebarString(false, false));
                }

                base.UpdateTitleBar();
            }
            else
            {
                SetTitleStr(string.Empty);
            }
        }


        public override void SetTitleStr(string str)
        {
            _setTitle(str);
        }

        public override bool OnMessage(MainForm razor, uint wParam, int lParam)
        {
            return false;
        }

        public override bool OnCopyData(IntPtr wparam, IntPtr lparam)
        {
            return false;
        }

        public override void SendToServer(Packet p)
        {
            byte[] data = p.Compile();
            int length = (int) p.Length;
            _sendToServer(ref data, ref length);
        }

        public override void SendToServer(PacketReader pr)
        {
            SendToServer(MakePacketFrom(pr));
        }

        public override void SendToClient(Packet p)
        {
            byte[] data = p.Compile();
            int length = (int) p.Length;

            _sendToClient(ref data, ref length);
        }

        public override void SendPacketToClient(byte[] packet, int length)
        {
            _sendToClient(ref packet, ref length);
        }

        public override unsafe void ForceSendToClient(Packet p)
        {
            byte[] data = p.Compile();
            int length = (int) p.Length;

            _sendToClient(ref data, ref length);

            if (Packet.Logging)
            {
                fixed (byte* ptr = data)
                {
                    Packet.Log(PacketPath.RazorToClient, ptr, data.Length);
                }
            }
        }

        public override unsafe void ForceSendToServer(Packet p)
        {
            byte[] data = p.Compile();
            int length = (int) p.Length;

            _sendToServer(ref data, ref length);

            if (Packet.Logging)
            {
                fixed (byte* ptr = data)
                {
                    Packet.Log(PacketPath.RazorToServer, ptr, data.Length);
                }
            }
        }

        public override void SetPosition(uint x, uint y, uint z, byte dir)
        {
        }

        public override string GetClientVersion()
        {
            return m_ClientVersion;
        }

        public override string GetUoFilePath()
        {
            return _uoFilePath();
        }

        public override IntPtr GetWindowHandle()
        {
            return m_ClientWindow;
        }

        public override uint TotalDataIn()
        {
            return m_In;
        }

        public override uint TotalDataOut()
        {
            return m_Out;
        }

        internal override void RequestMove(Direction m_Dir)
        {
            _requestMove((int) m_Dir, false);
        }

        public void OnFocusGained()
        {
            if (Engine.MainWindow == null)
                return;

            if (Config.GetBool("AlwaysOnTop"))
            {
                if (!Engine.MainWindow.TopMost)
                {
                    Platform.SetForegroundWindow(GetWindowHandle());

                    Engine.MainWindow.SafeAction(s =>
                    {
                        s.TopMost = true;
                        s.BringToFront();
                    });
                }
            }

            // always use smartness for the map window
            if (Engine.MainWindow.MapWindow != null && Engine.MainWindow.MapWindow.Visible)
            {
                if (!Engine.MainWindow.MapWindow.TopMost)
                {
                    Engine.MainWindow.MapWindow.SafeAction(s =>
                    {
                        s.TopMost = true;
                        s.BringToFront();
                    });
                }
            }
        }

        public void OnFocusLost()
        {
            if (Engine.MainWindow == null)
                return;

            bool razorfocus = Form.ActiveForm == Engine.MainWindow || Form.ActiveForm == Engine.MainWindow.MapWindow;
            if (Config.GetBool("AlwaysOnTop"))
            {
                if (Engine.MainWindow.TopMost && !razorfocus)
                {
                    Engine.MainWindow.SafeAction(s =>
                    {
                        s.TopMost = false;
                        s.SendToBack();
                    });
                }
            }

            // always use smartness for the map window
            if (Engine.MainWindow.MapWindow != null && Engine.MainWindow.MapWindow.Visible && !razorfocus)
            {
                if (Engine.MainWindow.MapWindow.TopMost)
                {
                    Engine.MainWindow.MapWindow.SafeAction(s =>
                    {
                        s.TopMost = false;
                        s.SendToBack();
                    });
                }
            }
        }
    }
}

================================================
FILE: Razor/Client/Client.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using Assistant.Core;
using System;
using System.Diagnostics;
using System.Net;
using System.Text;
using System.Windows.Forms;

namespace Assistant
{
    public class FeatureBit
    {
        public static readonly int WeatherFilter = 0;
        public static readonly int LightFilter = 1;
        public static readonly int SmartLT = 2;
        public static readonly int RangeCheckLT = 3;
        public static readonly int AutoOpenDoors = 4;
        public static readonly int UnequipBeforeCast = 5;
        public static readonly int AutoPotionEquip = 6;
        public static readonly int BlockHealPoisoned = 7;
        public static readonly int LoopingMacros = 8; // includes fors and macros running macros
        public static readonly int UseOnceAgent = 9;
        public static readonly int RestockAgent = 10;
        public static readonly int SellAgent = 11;
        public static readonly int BuyAgent = 12;
        public static readonly int PotionHotkeys = 13;
        public static readonly int RandomTargets = 14;
        public static readonly int ClosestTargets = 15;
        public static readonly int OverheadHealth = 16;
        // These are reserved by Steam, not used in Razor
        public static readonly int AutolootAgent = 17;
        public static readonly int BoneCutterAgent = 18;
        public static readonly int AdvancedMacros = 19;
        public static readonly int AutoRemount = 20;
        public static readonly int AutoBandage = 21;
        public static readonly int EnemyTargetShare = 22;
        public static readonly int FilterSeason = 23;
        public static readonly int SpellTargetShare = 24;
        public static readonly int HumanoidHealthChecks = 25;
        public static readonly int SpeechJournalChecks = 26;

        public static readonly int MaxBit = 26;
    }

    public abstract class Client
    {
        public static Client Instance;
        public static bool IsOSI;

        internal static void Init(bool isOSI)
        {
            IsOSI = isOSI;

            if (isOSI)
                Instance = new OSIClient();
            else
                Instance = new ClassicUOClient();
        }

        public const int WM_USER = 0x400;

        public const int WM_COPYDATA = 0x4A;
        public const int WM_UONETEVENT = WM_USER + 1;

        private ulong m_Features = 0;

        public bool AllowBit(int bit)
        {
            return (m_Features & (1U << bit)) == 0;
        }

        public void SetFeatures(ulong features)
        {
            m_Features = features;
        }

        public abstract DateTime ConnectionStart { get; }
        public abstract IPAddress LastConnection { get; }
        public abstract Process ClientProcess { get; }

        public abstract bool ClientRunning { get; }

        public abstract void SetMapWndHandle(Form mapWnd);

        public abstract void RequestStatbarPatch(bool preAOS);

        public abstract void SetCustomNotoHue(int hue);

        public abstract void SetSmartCPU(bool enabled);

        public abstract void SetGameSize(int x, int y);

        public enum Loader_Error
        {
            SUCCESS = 0,
            NO_OPEN_EXE,
            NO_MAP_EXE,
            NO_READ_EXE_DATA,

            NO_RUN_EXE,
            NO_ALLOC_MEM,

            NO_WRITE,
            NO_VPROTECT,
            NO_READ,

            UNKNOWN_ERROR = 99
        };

        public abstract Loader_Error LaunchClient(string client);

        public abstract bool ClientEncrypted { get; set; }

        public abstract bool ServerEncrypted { get; set; }

        public abstract bool InstallHooks(IntPtr mainWindow);

        public abstract void SetConnectionInfo(IPAddress addr, int port);

        public abstract void SetNegotiate(bool negotiate);

        public abstract bool Attach(int pid);

        public abstract void Close();

        public abstract void SetTitleStr(string str);

        public abstract bool OnMessage(MainForm razor, uint wParam, int lParam);

        public abstract bool OnCopyData(IntPtr wparam, IntPtr lparam);

        public abstract void SendToServer(Packet p);

        public abstract void SendToServer(PacketReader pr);

        public abstract void SendToClient(Packet p);
        public abstract void SendPacketToClient(byte[] packet, int length);

        public abstract void ForceSendToClient(Packet p);

        public abstract void ForceSendToServer(Packet p);

        public abstract void SetPosition(uint x, uint y, uint z, byte dir);

        public abstract string GetClientVersion();

        public abstract string GetUoFilePath();

        public abstract IntPtr GetWindowHandle();

        public abstract uint TotalDataIn();

        public abstract uint TotalDataOut();
        internal abstract void RequestMove(Direction m_Dir);


        public void RequestTitlebarUpdate()
        {
            // throttle updates, since things like counters might request 1000000 million updates/sec
            if (m_TBTimer == null)
                m_TBTimer = new TitleBarThrottle();

            if (!m_TBTimer.Running)
                m_TBTimer.Start();
        }

        private class TitleBarThrottle : Timer
        {
            public TitleBarThrottle() : base(TimeSpan.FromSeconds(0.25))
            {
            }

            protected override void OnTick()
            {
                Instance.UpdateTitleBar();
            }
        }

        private Timer m_TBTimer;
        public StringBuilder TitleBarBuilder = new StringBuilder();
        private string m_LastPlayerName = "";

        public void ResetTitleBarBuilder()
        {
            // reuse the same sb each time for less damn allocations
            TitleBarBuilder.Remove(0, TitleBarBuilder.Length);
            TitleBarBuilder.Insert(0, $"{Config.GetString("TitleBarText")}");
        }

        public virtual void UpdateTitleBar()
        {
            if (!ClientRunning || World.Player == null)
                return;

            StringBuilder sb = TitleBarBuilder;

            PlayerData p = World.Player;

            if (p.Name != m_LastPlayerName)
            {
                m_LastPlayerName = p.Name;

                Engine.MainWindow.UpdateTitle();
            }

            sb.Replace(@"{shard}", World.ShardName);

            sb.Replace(@"{str}", p.Str.ToString());
            sb.Replace(@"{hpmax}", p.HitsMax.ToString());

            sb.Replace(@"{dex}", World.Player.Dex.ToString());
            sb.Replace(@"{stammax}", World.Player.StamMax.ToString());

            sb.Replace(@"{int}", World.Player.Int.ToString());
            sb.Replace(@"{manamax}", World.Player.ManaMax.ToString());

            sb.Replace(@"{ar}", p.AR.ToString());
            sb.Replace(@"{tithe}", p.Tithe.ToString());

            sb.Replace(@"{physresist}", p.AR.ToString());
            sb.Replace(@"{fireresist}", p.FireResistance.ToString());
            sb.Replace(@"{coldresist}", p.ColdResistance.ToString());
            sb.Replace(@"{poisonresist}", p.PoisonResistance.ToString());
            sb.Replace(@"{energyresist}", p.EnergyResistance.ToString());

            sb.Replace(@"{luck}", p.Luck.ToString());

            sb.Replace(@"{damage}", $"{p.DamageMin}-{p.DamageMax}");

            sb.Replace(@"{maxweight}", World.Player.MaxWeight.ToString());

            sb.Replace(@"{followers}", World.Player.Followers.ToString());
            sb.Replace(@"{followersmax}", World.Player.FollowersMax.ToString());

            sb.Replace(@"{gold}", World.Player.Gold.ToString());

            sb.Replace(@"{gps}", GoldPerHourTimer.Running ? $"{GoldPerHourTimer.GoldPerSecond:N2}" : "-");
            sb.Replace(@"{gpm}", GoldPerHourTimer.Running ? $"{GoldPerHourTimer.GoldPerMinute:N2}" : "-");
            sb.Replace(@"{gph}", GoldPerHourTimer.Running ? $"{GoldPerHourTimer.GoldPerHour:N2}" : "-");
            sb.Replace(@"{goldtotal}", GoldPerHourTimer.Running ? $"{GoldPerHourTimer.GoldSinceStart}" : "-");
            sb.Replace(@"{goldtotalmin}", GoldPerHourTimer.Running ? $"{GoldPerHourTimer.TotalMinutes:N2} min" : "-");

            sb.Replace(@"{skill}", SkillTimer.Running ? $"{SkillTimer.Count}" : "-");
            sb.Replace(@"{gate}", GateTimer.Running ? $"{GateTimer.Count}" : "-");

            sb.Replace(@"{stealthsteps}", StealthSteps.Counting ? StealthSteps.Count.ToString() : "-");
            sb.Replace(@"{uptime}",
                ConnectionStart != DateTime.MinValue
                    ? Utility.FormatTime((int) ((DateTime.UtcNow - ConnectionStart).TotalSeconds))
                    : "-");

            sb.Replace(@"{dps}", DamageTracker.Running ? $"{DamageTracker.DamagePerSecond:N2}" : "-");
            sb.Replace(@"{maxdps}", DamageTracker.Running ? $"{DamageTracker.MaxDamagePerSecond:N2}" : "-");
            sb.Replace(@"{maxdamagedealt}", DamageTracker.Running ? $"{DamageTracker.MaxSingleDamageDealt}" : "-");
            sb.Replace(@"{maxdamagetaken}", DamageTracker.Running ? $"{DamageTracker.MaxSingleDamageTaken}" : "-");
            sb.Replace(@"{totaldamagedealt}", DamageTracker.Running ? $"{DamageTracker.TotalDamageDealt}" : "-");
            sb.Replace(@"{totaldamagetaken}", DamageTracker.Running ? $"{DamageTracker.TotalDamageTaken}" : "-");

            if (IsOSI)
            {
                if (World.Player.BuffsDebuffs.Count > 0)
                {
                    StringBuilder buffs = new StringBuilder();
                    foreach (BuffDebuff buff in World.Player.BuffsDebuffs)
                    {
                        int timeLeft = 0;

                        if (buff.Duration > 0)
                        {
                            TimeSpan diff = DateTime.UtcNow - buff.Timestamp;
                            timeLeft = buff.Duration - (int)diff.TotalSeconds;
                        }

                        buffs.Append(timeLeft <= 0
                            ? $"{buff.ClilocMessage1}, "
                            : $"{buff.ClilocMessage1} ({timeLeft}), ");
                    }

                    buffs.Length = Math.Max(0, buffs.Length - 2);
                    string buffList = buffs.ToString();
                    sb.Replace(@"{buffsdebuffs}", buffList);
                }
                else
                {
                    sb.Replace(@"{buffsdebuffs}", "-");
                }
            }

            SetTitleStr(sb.ToString());
        }

        public Packet MakePacketFrom(PacketReader pr)
        {
            byte[] data = pr.CopyBytes(0, pr.Length);
            return new Packet(data, pr.Length, pr.DynamicLength);
        }
    }
}

================================================
FILE: Razor/Client/OSI.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using Assistant.Core;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Windows.Forms;
using Assistant.Scripts;

namespace Assistant
{
    public unsafe class OSIClient : Client
    {
        public enum UONetMessage
        {
            Send = 1,
            Recv = 2,
            Ready = 3,
            NotReady = 4,
            Connect = 5,
            Disconnect = 6,
            KeyDown = 7,
            Mouse = 8,
            Activate = 9,
            Focus = 10,
            Close = 11,
            StatBar = 12,
            NotoHue = 13,
            DLL_Error = 14,
            SetGameSize = 19,
            SmartCPU = 21,
            Negotiate = 22,
            SetMapHWnd = 23,
            OnTick = 24,
        }

        public enum UONetMessageCopyData
        {
            Position = 1,
        }

        private enum InitError
        {
            SUCCESS,
            NO_UOWND,
            NO_TID,
            NO_HOOK,
            NO_SHAREMEM,
            LIB_DISABLED,
            NO_PATCH,
            NO_MEMCOPY,
            INVALID_PARAMS,

            UNKNOWN
        }

        private const int SHARED_BUFF_SIZE = 524288; // 262144; // 250k

        [StructLayout(LayoutKind.Explicit, Size = 8 + SHARED_BUFF_SIZE)]
        private struct Buffer
        {
            [FieldOffset(0)] public int Length;
            [FieldOffset(4)] public int Start;
            [FieldOffset(8)] public byte Buff0;
        }

        [DllImport("Crypt.dll")]
        private static unsafe extern int InstallLibrary(IntPtr thisWnd, int procid, int features);

        [DllImport("Crypt.dll")]
        private static unsafe extern void Shutdown(bool closeClient);

        [DllImport("Crypt.dll")]
        internal static unsafe extern IntPtr FindUOWindow();

        [DllImport("Crypt.dll")]
        private static unsafe extern IntPtr GetSharedAddress();

        [DllImport("Crypt.dll")]
        private static unsafe extern IntPtr GetCommMutex();

        [DllImport("Crypt.dll")]
        internal static unsafe extern uint TotalIn();

        [DllImport("Crypt.dll")]
        internal static unsafe extern uint TotalOut();

        [DllImport("Crypt.dll")]
        private static unsafe extern void WaitForWindow(int pid);

        [DllImport("Crypt.dll")]
        internal static unsafe extern void SetDataPath(string path);

        [DllImport("Crypt.dll")]
        internal static unsafe extern void CalibratePosition(uint x, uint y, uint z, byte dir);

        [DllImport("Crypt.dll")]
        private static unsafe extern void SetServer(uint ip, ushort port);

        [DllImport("Crypt.dll")]
        internal static unsafe extern IntPtr GetUOVersion();

        [DllImport("Loader.dll")]
        private static unsafe extern uint Load(string exe, string dll, string func, void* dllData, int dataLen,
            out uint pid);

        private Queue<Packet> m_SendQueue = new Queue<Packet>();
        private Queue<Packet> m_RecvQueue = new Queue<Packet>();

        private bool m_QueueRecv;
        private bool m_QueueSend;

        private Buffer* m_InRecv;
        private Buffer* m_OutRecv;
        private Buffer* m_InSend;
        private Buffer* m_OutSend;
        private byte* m_TitleStr;
        private Mutex CommMutex;
        private Process ClientProc;

        private bool m_Ready = false;
        private string m_LastStr = "";
        private DateTime m_ConnStart;
        private IPAddress m_LastConnection;

        public override DateTime ConnectionStart
        {
            get { return m_ConnStart; }
        }

        public override IPAddress LastConnection
        {
            get { return m_LastConnection; }
        }

        public override Process ClientProcess
        {
            get { return ClientProc; }
        }

        public override bool ClientRunning
        {
            get
            {
                try
                {
                    return ClientProc != null && !ClientProc.HasExited;
                }
                catch
                {
                    return ClientProc != null && FindUOWindow() != IntPtr.Zero;
                }
            }
        }

        public override void SetMapWndHandle(Form mapWnd)
        {
            Platform.PostMessage(FindUOWindow(), WM_UONETEVENT, (IntPtr) UONetMessage.SetMapHWnd, mapWnd.Handle);
        }

        public override void RequestStatbarPatch(bool preAOS)
        {
            Platform.PostMessage(FindUOWindow(), WM_UONETEVENT, (IntPtr) UONetMessage.StatBar,
                preAOS ? (IntPtr) 1 : IntPtr.Zero);
        }

        public override void SetCustomNotoHue(int hue)
        {
            Platform.PostMessage(FindUOWindow(), WM_UONETEVENT, (IntPtr) UONetMessage.NotoHue, (IntPtr) hue);
        }

        public override void SetSmartCPU(bool enabled)
        {
            if (enabled)
                try
                {
                    ClientProcess.PriorityClass = System.Diagnostics.ProcessPriorityClass.Normal;
                }
                catch
                {
                }

            Platform.PostMessage(FindUOWindow(), WM_UONETEVENT, (IntPtr) UONetMessage.SmartCPU,
                (IntPtr) (enabled ? 1 : 0));
        }

        public override void SetGameSize(int x, int y)
        {
            Platform.PostMessage(FindUOWindow(), WM_UONETEVENT, (IntPtr) UONetMessage.SetGameSize,
                (IntPtr) ((x & 0xFFFF) | ((y & 0xFFFF) << 16)));
        }

        public override Loader_Error LaunchClient(string client)
        {
            string dll = Path.Combine(Config.GetInstallDirectory(), "Crypt.dll");
            uint pid = 0;
            Loader_Error err = (Loader_Error) Load(client, dll, "OnAttach", null, 0, out pid);

            if (err == Loader_Error.SUCCESS)
            {
                try
                {
                    ClientProc = Process.GetProcessById((int) pid);
                }
                catch
                {
                    // ignore
                }
            }

            if (ClientProc == null)
                return Loader_Error.UNKNOWN_ERROR;
            else
                return err;
        }

        private bool m_ClientEnc = false;

        public override bool ClientEncrypted
        {
            get { return m_ClientEnc; }
            set { m_ClientEnc = value; }
        }

        private bool m_ServerEnc = false;

        public override bool ServerEncrypted
        {
            get { return m_ServerEnc; }
            set { m_ServerEnc = value; }
        }

        public override bool InstallHooks(IntPtr mainWindow)
        {
            InitError error;
            int flags = 0;

            if (m_Ready)
                return false; // double init

            if (Config.GetBool("Negotiate"))
                flags |= 0x04;

            if (ClientEncrypted)
                flags |= 0x08;

            if (ServerEncrypted)
                flags |= 0x10;

            WaitForWindow(ClientProc.Id);

            error = (InitError) InstallLibrary(mainWindow, ClientProc.Id, flags);
            if (error != InitError.SUCCESS)
            {
                FatalInit(error);
                return false;
            }

            // When InstallLibrary finishes, we get a UONETEVENT saying it's ready.
            return true;
        }

        private uint m_ServerIP;
        private ushort m_ServerPort;

        public override void SetConnectionInfo(IPAddress addr, int port)
        {
#pragma warning disable 618
            m_ServerIP = (uint) addr.Address;
#pragma warning restore 618
            m_ServerPort = (ushort) port;
        }

        public override void SetNegotiate(bool negotiate)
        {
            Platform.PostMessage(FindUOWindow(), WM_UONETEVENT, (IntPtr) UONetMessage.Negotiate,
                (IntPtr) (negotiate ? 1 : 0));
        }

        public override bool Attach(int pid)
        {
            ClientProc = null;
            ClientProc = Process.GetProcessById(pid);
            return ClientProc != null;
        }

        public override void Close()
        {
            Shutdown(true);
            if (ClientProc != null && !ClientProc.HasExited)
                ClientProc.CloseMainWindow();
            ClientProc = null;
        }

        private string EncodeColorStat(int val, int max)
        {
            double perc = ((double) val) / ((double) max);

            if (perc <= 0.25)
                return $"~#FF0000{val}~#~";

            if (perc <= 0.75)
                return $"~#FFFF00{val}~#~";

            return val.ToString();
        }

        public override void UpdateTitleBar()
        {
            if (!ClientRunning)
                return;

            if (World.Player != null && Config.GetBool("TitleBarDisplay"))
            {
                ResetTitleBarBuilder();

                TitleBarBuilder.Replace(@"{char}",
                    Config.GetBool("ShowNotoHue")
                        ? $"~#{World.Player.GetNotorietyColor() & 0x00FFFFFF:X6}{World.Player.Name}~#~"
                        : World.Player.Name);

                TitleBarBuilder.Replace(@"{crimtime}",
                    World.Player.CriminalTime != 0 ? $"~^C0C0C0{World.Player.CriminalTime}~#~" : "-");

                TitleBarBuilder.Replace(@"{hp}",
                    World.Player.Poisoned
                        ? $"~#FF8000{World.Player.Hits}~#~"
                        : EncodeColorStat(World.Player.Hits, World.Player.HitsMax));
                TitleBarBuilder.Replace(@"{mana}", EncodeColorStat(World.Player.Mana, World.Player.ManaMax));
                TitleBarBuilder.Replace(@"{stam}", EncodeColorStat(World.Player.Stam, World.Player.StamMax));

                TitleBarBuilder.Replace(@"{weight}",
                    World.Player.Weight >= World.Player.MaxWeight
                        ? $"~#FF0000{World.Player.Weight}~#~"
                        : World.Player.Weight.ToString());

                TitleBarBuilder.Replace(@"{bandage}", BandageTimer.Running ? $"~#FF8000{BandageTimer.Count}~#~" : "-");

                string statStr =
                    $"{(int) (World.Player.GetStatusCode())}{(int) (World.Player.HitsMax == 0 ? 0 : (double) World.Player.Hits / World.Player.HitsMax * 99):X2}{(int) (World.Player.ManaMax == 0 ? 0 : (double) World.Player.Mana / World.Player.ManaMax * 99):X2}{(int) (World.Player.StamMax == 0 ? 0 : (double) World.Player.Stam / World.Player.StamMax * 99):X2}";

                TitleBarBuilder.Replace(@"{statbar}", $"~SR{statStr}");
                TitleBarBuilder.Replace(@"{mediumstatbar}", $"~SL{statStr}");
                TitleBarBuilder.Replace(@"{largestatbar}", $"~SX{statStr}");

                bool dispImg = Config.GetBool("TitlebarImages");
                for (int i = 0; i < Counter.List.Count; i++)
                {
                    Counter c = Counter.List[i];
                    if (c.Enabled)
                        TitleBarBuilder.Replace($"{{{c.Format}}}",
                            c.GetTitlebarString(dispImg && c.DisplayImage, true));
                }

                base.UpdateTitleBar();
            }
            else
            {
                SetTitleStr(string.Empty);
            }
        }

        private const int WM_CUSTOMTITLE = Client.WM_USER + 2;

        public override void SetTitleStr(string str)
        {
            if (m_LastStr == str)
                return;

            m_LastStr = str;
            byte[] copy = System.Text.Encoding.ASCII.GetBytes(str);
            int clen = copy.Length;
            if (clen >= 512)
                clen = 511;

            CommMutex.WaitOne();
            if (clen > 0)
            {
                fixed (byte* array = copy)
                    Platform.memcpy(m_TitleStr, array, clen);
            }

            *(m_TitleStr + clen) = 0;
            CommMutex.ReleaseMutex();

            Platform.PostMessage(FindUOWindow(), WM_CUSTOMTITLE, IntPtr.Zero, IntPtr.Zero);
        }

        private void FatalInit(InitError error)
        {
            StringBuilder sb = new StringBuilder(Language.GetString(LocString.InitError));
            sb.AppendFormat("{0}\n", error);
            sb.Append(Language.GetString((int) (LocString.InitError + (int) error)));

            MessageBox.Show(Engine.ActiveWindow, sb.ToString(), "Init Error", MessageBoxButtons.OK,
                MessageBoxIcon.Stop);
        }

        private void OnLogout(bool fake)
        {
            if (!fake)
            {
                PacketHandlers.Party.Clear();

                SetTitleStr("");
                Engine.MainWindow.UpdateTitle();
                UOAssist.PostLogout();
                m_ConnStart = DateTime.MinValue;
            }

            World.Player = null;
            World.Items.Clear();
            World.Mobiles.Clear();
            Macros.MacroManager.Stop();
            ScriptManager.OnLogout();
            ActionQueue.Stop();
            Counter.Reset();
            GoldPerHourTimer.Stop();
            DamageTracker.Stop();
            BandageTimer.Stop();
            GateTimer.Stop();
            WaypointManager.StopTimer();
            BuffDebuffManager.Stop();
            CooldownManager.Stop();
            StealthSteps.Unhide();
            Engine.MainWindow.OnLogout();
            if (Engine.MainWindow.MapWindow != null)
                Engine.MainWindow.MapWindow.Close();
            PacketHandlers.Party.Clear();
            PacketHandlers.IgnoreGumps.Clear();
            Agents.BuyAgent.OnDisconnected();
            Config.Save();

            //TranslateEnabled = false;
        }

        //private DateTime m_LastActivate;
        public override bool OnMessage(MainForm razor, uint wParam, int lParam)
        {
            bool retVal = true;

            switch ((UONetMessage) (wParam & 0xFFFF))
            {
                case UONetMessage.Ready: //Patch status
                    if (lParam == (int) InitError.NO_MEMCOPY)
                    {
                        if (MessageBox.Show(Engine.ActiveWindow, Language.GetString(LocString.NoMemCpy),
                                "No Client MemCopy", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) ==
                            DialogResult.No)
                        {
                            m_Ready = false;
                            ClientProc = null;
                            Engine.MainWindow.CanClose = true;
                            Engine.MainWindow.Close();
                            break;
                        }
                    }

                    byte* baseAddr = (byte*) GetSharedAddress().ToPointer();

                    m_InRecv = (Buffer*) baseAddr;
                    m_OutRecv = (Buffer*) (baseAddr + sizeof(Buffer));
                    m_InSend = (Buffer*) (baseAddr + sizeof(Buffer) * 2);
                    m_OutSend = (Buffer*) (baseAddr + sizeof(Buffer) * 3);
                    m_TitleStr = (byte*) (baseAddr + sizeof(Buffer) * 4);

                    SetServer(m_ServerIP, m_ServerPort);

                    CommMutex = new Mutex();
#pragma warning disable 618
                    CommMutex.Handle = GetCommMutex();
#pragma warning restore 618

                    try
                    {
                        string path = Ultima.Files.GetFilePath("art.mul");
                        if (path != null && path != string.Empty)
                            SetDataPath(Path.GetDirectoryName(path));
                        else
                            SetDataPath(Path.GetDirectoryName(Ultima.Files.Directory));
                    }
                    catch
                    {
                        SetDataPath("");
                    }

                    if (Config.GetBool("OldStatBar"))
                        RequestStatbarPatch(true);

                    m_Ready = true;
                    Engine.MainWindow.MainForm_EndLoad();
                    break;

                case UONetMessage.NotReady:
                    m_Ready = false;
                    FatalInit((InitError) lParam);
                    ClientProc = null;
                    Engine.MainWindow.CanClose = true;
                    Engine.MainWindow.Close();
                    break;

                // Network events
                case UONetMessage.Recv:
                    OnRecv();
                    break;
                case UONetMessage.Send:
                    OnSend();
                    break;
                case UONetMessage.Connect:
                    m_ConnStart = DateTime.UtcNow;
                    try
                    {
                        m_LastConnection = new IPAddress((uint) lParam);
                    }
                    catch
                    {
                    }

                    break;
                case UONetMessage.Disconnect:
                    OnLogout(false);
                    break;
                case UONetMessage.Close:
                    OnLogout(true);
                    ClientProc = null;
                    Engine.MainWindow.CanClose = true;
                    Engine.MainWindow.Close();
                    break;

                // Hot Keys
                case UONetMessage.Mouse:
                    HotKey.OnMouse((ushort) (lParam & 0xFFFF), (short) (lParam >> 16));
                    break;
                case UONetMessage.KeyDown:
                    retVal = HotKey.OnKeyDown(lParam, ModKeys.None);
                    break;

                // Activation Tracking
                case UONetMessage.Activate:
                    /*if ( Config.GetBool( "AlwaysOnTop" ) )
                    {
                        if ( (lParam&0x0000FFFF) == 0 && (lParam&0xFFFF0000) != 0 && razor.WindowState != FormWindowState.Minimized && razor.Visible )
                        {// if uo is deactivating and minimized and we are not minimized
                            if ( !razor.ShowInTaskbar && razor.Visible )
                                razor.Hide();
                            razor.WindowState = FormWindowState.Minimized;
                            m_LastActivate = DateTime.UtcNow;
                        }
                        else if ( (lParam&0x0000FFFF) != 0 && (lParam&0xFFFF0000) != 0 && razor.WindowState != FormWindowState.Normal )
                        { // is UO is activating and minimized and we are minimized
                            if ( m_LastActivate+TimeSpan.FromSeconds( 0.2 ) < DateTime.UtcNow )
                            {
                                if ( !razor.ShowInTaskbar && !razor.Visible )
                                    razor.Show();
                                razor.WindowState = FormWindowState.Normal;
                                //SetForegroundWindow( FindUOWindow() );
                            }
                            m_LastActivate = DateTime.UtcNow;
                        }
                    }*/
                    break;

                case UONetMessage.Focus:
                    if (Config.GetBool("AlwaysOnTop"))
                    {
                        if (lParam != 0 && !razor.TopMost)
                        {
                            razor.TopMost = true;
                            Platform.SetForegroundWindow(FindUOWindow());
                        }
                        else if (lParam == 0 && razor.TopMost)
                        {
                            razor.TopMost = false;
                            razor.SendToBack();
                        }
                    }

                    // always use smartness for the map window
                    if (razor.MapWindow != null && razor.MapWindow.Visible)
                    {
                        if (lParam != 0 && !razor.MapWindow.TopMost)
                        {
                            razor.MapWindow.TopMost = true;
                            Platform.SetForegroundWindow(FindUOWindow());
                        }
                        else if (lParam == 0 && razor.MapWindow.TopMost)
                        {
                            razor.MapWindow.TopMost = false;
                            razor.MapWindow.SendToBack();
                        }
                    }

                    break;

                case UONetMessage.DLL_Error:
                {
                    string error = "Unknown";
                    switch ((UONetMessage) lParam)
                    {
                        case UONetMessage.StatBar:
                            error = "Unable to patch status bar.";
                            break;
                    }

                    MessageBox.Show(Engine.ActiveWindow, "An Error has occured : \n" + error, "Error Reported",
                        MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    break;
                }

                case UONetMessage.OnTick:
                    // Game engine tick
                    Timer.Slice();
                    break;

                // Unknown
                default:
                    MessageBox.Show(Engine.ActiveWindow, "Unknown message from uo client\n" + ((int) wParam).ToString(),
                        "Error?");
                    break;
            }

            return retVal;
        }

        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        private struct CopyData
        {
            public int dwData;
            public int cbDAta;
            public IntPtr lpData;
        };

        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        private struct Position
        {
            public ushort x;
            public ushort y;
            public ushort z;
        };

        public override bool OnCopyData(IntPtr wparam, IntPtr lparam)
        {
            CopyData copydata = (CopyData) Marshal.PtrToStructure(lparam, typeof(CopyData));

            switch ((UONetMessageCopyData) copydata.dwData)
            {
                case UONetMessageCopyData.Position:
                    if (World.Player != null)
                    {
                        Position pos = (Position) Marshal.PtrToStructure(copydata.lpData, typeof(Position));
                        Point3D pt = new Point3D();

                        pt.X = pos.x;
                        pt.Y = pos.y;
                        pt.Z = pos.z;

                        World.Player.Position = pt;
                    }

                    return true;
            }

            return false;
        }

        public override void SendToServer(Packet p)
        {
            if (!m_Ready)
                return;

            if (!m_QueueSend)
            {
                ForceSendToServer(p);
            }
            else
            {
                m_SendQueue.Enqueue(p);
            }
        }

        public override void SendToServer(PacketReader pr)
        {
            if (!m_Ready)
                return;

            SendToServer(MakePacketFrom(pr));
        }

        public override void SendToClient(Packet p)
        {
            if (!m_Ready || p.Length <= 0)
                return;

            if (!m_QueueRecv)
            {
                ForceSendToClient(p);
            }
            else
            {
                m_RecvQueue.Enqueue(p);
            }
        }

        public override void SendPacketToClient(byte[] packet, int length)
        {
            //_sendToClient(ref packet, ref length);
        }

        public override void ForceSendToClient(Packet p)
        {
            byte[] data = p.Compile();

            CommMutex.WaitOne();
            fixed (byte* ptr = data)
            {
                Packet.Log(PacketPath.RazorToClient, ptr, data.Length);
                CopyToBuffer(m_OutRecv, ptr, data.Length);
            }

            CommMutex.ReleaseMutex();
        }

        public override void ForceSendToServer(Packet p)
        {
            if (p == null || p.Length <= 0)
                return;

            byte[] data = p.Compile();

            CommMutex.WaitOne();
            InitSendFlush();
            fixed (byte* ptr = data)
            {
                Packet.Log(PacketPath.RazorToServer, ptr, data.Length);
                CopyToBuffer(m_OutSend, ptr, data.Length);
            }

            CommMutex.ReleaseMutex();
        }

        private void InitSendFlush()
        {
            if (m_OutSend->Length == 0)
                Platform.PostMessage(FindUOWindow(), WM_UONETEVENT, (IntPtr) UONetMessage.Send, IntPtr.Zero);
        }

        private void CopyToBuffer(Buffer* buffer, byte* data, int len)
        {
            //if ( buffer->Length + buffer->Start + len >= SHARED_BUFF_SIZE )
            //	throw new NullReferenceException( String.Format( "Buffer OVERFLOW in CopyToBuffer [{0} + {1}] <- {2}", buffer->Start, buffer->Length, len ) );

            Platform.memcpy((&buffer->Buff0) + buffer->Start + buffer->Length, data, len);
            buffer->Length += len;
        }

        private void HandleComm(Buffer* inBuff, Buffer* outBuff, Queue<Packet> queue, PacketPath path)
        {
            CommMutex.WaitOne();
            while (inBuff->Length > 0)
            {
                byte* buff = (&inBuff->Buff0) + inBuff->Start;

                short len = PacketsTable.GetPacketLength(buff, inBuff->Length);
                if (len > inBuff->Length || len <= 0)
                    break;

                inBuff->Start += len;
                inBuff->Length -= len;

                bool viewer = false;
                bool filter = false;

                switch (path)
                {
                    case PacketPath.ClientToServer:
                        viewer = PacketHandler.HasClientViewer(buff[0]);
                        filter = PacketHandler.HasClientFilter(buff[0]);
                        break;
                    case PacketPath.ServerToClient:
                        viewer = PacketHandler.HasServerViewer(buff[0]);
                        filter = PacketHandler.HasServerFilter(buff[0]);
                        break;
                }

                Packet p = null;
                PacketReader pr = null;
                if (viewer)
                {
                    pr = new PacketReader(buff, len, PacketsTable.IsDynLength(buff[0]));
                    if (filter)
                        p = MakePacketFrom(pr);
                }
                else if (filter)
                {
                    byte[] temp = new byte[len];
                    fixed (byte* ptr = temp)
                        Platform.memcpy(ptr, buff, len);
                    p = new Packet(temp, len, PacketsTable.IsDynLength(buff[0]));
                }

                bool blocked = false;
                switch (path)
                {
                    // yes it should be this way
                    case PacketPath.ClientToServer:
                    {
                        blocked = PacketHandler.OnClientPacket(buff[0], pr, p);
                        break;
                    }

                    case PacketPath.ServerToClient:
                    {
                        blocked = PacketHandler.OnServerPacket(buff[0], pr, p);
                        break;
                    }
                }

                if (filter)
                {
                    byte[] data = p.Compile();
                    fixed (byte* ptr = data)
                    {
                        Packet.Log(path, ptr, data.Length, blocked);
                        if (!blocked)
                            CopyToBuffer(outBuff, ptr, data.Length);
                    }
                }
                else
                {
                    Packet.Log(path, buff, len, blocked);
                    if (!blocked)
                        CopyToBuffer(outBuff, buff, len);
                }

                while (queue.Count > 0)
                {
                    p = (Packet) queue.Dequeue();
                    byte[] data = p.Compile();
                    fixed (byte* ptr = data)
                    {
                        CopyToBuffer(outBuff, ptr, data.Length);
                        Packet.Log((PacketPath) (((int) path) + 1), ptr, data.Length);
                    }
                }
            }

            CommMutex.ReleaseMutex();
        }

        private void OnRecv()
        {
            m_QueueRecv = true;
            HandleComm(m_InRecv, m_OutRecv, m_RecvQueue, PacketPath.ServerToClient);
            m_QueueRecv = false;
        }

        private void OnSend()
        {
            m_QueueSend = true;
            HandleComm(m_InSend, m_OutSend, m_SendQueue, PacketPath.ClientToServer);
            m_QueueSend = false;
        }

        public override void SetPosition(uint x, uint y, uint z, byte dir)
        {
            CalibratePosition(x, y, z, dir);
        }

        private static uint WM_KEYDOWN = 0x100, WM_KEYUP = 0x101;

        public void KeyPress(int keyCode)
        {
            Platform.SendMessage(FindUOWindow(), WM_KEYDOWN, (IntPtr) keyCode, (IntPtr) 1);
        }

        public override string GetClientVersion()
        {
            return Marshal.PtrToStringAnsi(GetUOVersion());
        }

        public override string GetUoFilePath()
        {
            return Config.GetAppSetting<string>("UODataDir");
        }

        public override IntPtr GetWindowHandle()
        {
            return FindUOWindow();
        }

        public override uint TotalDataIn()
        {
            return TotalIn();
        }

        public override uint TotalDataOut()
        {
            return TotalOut();
        }

        private enum KeyboardDir
        {
            North = 0x21, //page up
            Right = 0x27, // right
            East = 0x22, // page down
            Down = 0x28, // down
            South = 0x23, // end
            Left = 0x25, // left
            West = 0x24, // home
            Up = 0x26, // up
        }

        internal override void RequestMove(Direction m_Dir)
        {
            int direction;

            switch (m_Dir)
            {
                case Direction.Down:
                    direction = (int) KeyboardDir.Down;
                    break;
                case Direction.East:
                    direction = (int) KeyboardDir.East;
                    break;
                case Direction.Left:
                    direction = (int) KeyboardDir.Left;
                    break;
                case Direction.North:
                    direction = (int) KeyboardDir.North;
                    break;
                case Direction.Right:
                    direction = (int) KeyboardDir.Right;
                    break;
                case Direction.South:
                    direction = (int) KeyboardDir.South;
                    break;
                case Direction.Up:
                    direction = (int) KeyboardDir.Up;
                    break;
                case Direction.West:
                    direction = (int) KeyboardDir.West;
                    break;
                default:
                    direction = (int) KeyboardDir.Up;
                    break;
            }

            KeyPress(direction);
        }
    }
};

================================================
FILE: Razor/Client/UOAssist.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections;
using System.Text;
using System.Runtime.InteropServices;
using Ultima;

namespace Assistant
{
    public unsafe sealed class UOAssist
    {
        public const int WM_USER = 0x400;

        public enum UOAMessage
        {
            First = REGISTER,

            //incoming:
            REGISTER = WM_USER + 200,
            COUNT_RESOURCES,
            GET_COORDS,
            GET_SKILL,
            GET_STAT,
            SET_MACRO,
            PLAY_MACRO,
            DISPLAY_TEXT,
            REQUEST_MULTIS,
            ADD_CMD,
            GET_UID,
            GET_SHARDNAME,
            ADD_USER_2_PARTY,
            GET_UO_HWND,
            GET_POISON,
            SET_SKILL_LOCK,
            GET_ACCT_ID,

            //outgoing:
            RES_COUNT_DONE = WM_USER + 301,
            CAST_SPELL,
            LOGIN,
            MAGERY_LEVEL,
            INT_STATUS,
            SKILL_LEVEL,
            MACRO_DONE,
            LOGOUT,
            STR_STATUS,
            DEX_STATUS,
            ADD_MULTI,
            REM_MULTI,
            MAP_INFO,
            POWERHOUR,

            Last = POWERHOUR
        }

        private class WndCmd
        {
            public WndCmd(uint msg, IntPtr handle, string cmd)
            {
                Msg = msg;
                hWnd = handle;
                Command.Register(cmd, new CommandCallback(MyCallback));
            }

            private uint Msg;
            private IntPtr hWnd;

            private void MyCallback(string[] args)
            {
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < args.Length; i++)
                {
                    if (i != 0)
                        sb.Append(' ');
                    sb.Append(args[i]);
                }

                string str = sb.ToString();
                ushort atom = 0;
                if (str != null && str.Length > 0)
                    atom = GlobalAddAtom(str);
                PostMessage(hWnd, Msg, (IntPtr) atom, IntPtr.Zero);
            }
        }

        private class WndRegEnt
        {
            private int m_Handle;
            private int m_Type; // 1 = get multi notifcations

            public int Handle
            {
                get { return m_Handle; }
            }

            public int Type
            {
                get { return m_Type; }
            }

            public WndRegEnt(int hWnd, int type)
            {
                m_Handle = hWnd;
                m_Type = type;
            }
        }

        private static uint m_NextCmdID = WM_USER + 401;
        private static ArrayList m_WndReg;

        public static int NotificationCount
        {
            get { return m_WndReg.Count; }
        }

        static UOAssist()
        {
            m_WndReg = new ArrayList();
        }

        public static int OnUOAMessage(MainForm razor, int Msg, int wParam, int lParam)
        {
            switch ((UOAMessage) Msg)
            {
                case UOAMessage.REGISTER:
                {
                    for (int i = 0; i < m_WndReg.Count; i++)
                    {
                        if (((WndRegEnt) m_WndReg[i]).Handle == wParam)
                        {
                            m_WndReg.RemoveAt(i);
                            return 2;
                        }
                    }

                    m_WndReg.Add(new WndRegEnt(wParam, lParam == 1 ? 1 : 0));

                    if (lParam == 1 && World.Items != null)
                    {
                        foreach (Item item in World.Items.Values)
                        {
                            if (item.ItemID >= 0x4000)
                                PostMessage((IntPtr) wParam, (uint) UOAMessage.ADD_MULTI,
                                    (IntPtr) ((int) ((item.Position.X & 0xFFFF) | ((item.Position.Y & 0xFFFF) << 16))),
                                    (IntPtr) item.ItemID.Value);
                        }
                    }

                    return 1;
                }

                case UOAMessage.COUNT_RESOURCES:
                {
                    Counter.FullRecount();
                    return 0;
                }

                case UOAMessage.GET_COORDS:
                {
                    if (World.Player == null)
                        return 0;
                    return (World.Player.Position.X & 0xFFFF) | ((World.Player.Position.Y & 0xFFFF) << 16);
                }

                case UOAMessage.GET_SKILL:
                {
                    if (World.Player == null || lParam > 3 || wParam < 0 || World.Player.Skills == null ||
                        wParam > World.Player.Skills.Length || lParam < 0)
                        return 0;

                    switch (lParam)
                    {
                        case 3:
                        {
                            try
                            {
                                return GlobalAddAtom(Skills.GetSkillDisplayName(wParam));
                            }
                            catch
                            {
                                return 0;
                            }
                        }

                        case 2: return (int) (World.Player.Skills[wParam].Lock);
                        case 1: return World.Player.Skills[wParam].FixedBase;
                        case 0: return World.Player.Skills[wParam].FixedValue;
                    }

                    return 0;
                }

                case UOAMessage.GET_STAT:
                {
                    if (World.Player == null || wParam < 0 || wParam > 5)
                        return 0;

                    switch (wParam)
                    {
                        case 0: return World.Player.Str;
                        case 1: return World.Player.Int;
                        case 2: return World.Player.Dex;
                        case 3: return World.Player.Weight;
                        case 4: return World.Player.HitsMax;
                        case 5: return World.Player.Tithe;
                    }

                    return 0;
                }

                case UOAMessage.SET_MACRO:
                {
                    try
                    {
                        //if ( wParam >= 0 && wParam < Engine.MainWindow.macroList.Items.Count )
                        //	Engine.MainWindow.macroList.SelectedIndex = wParam;
                    }
                    catch
                    {
                    }

                    return 0;
                }

                case UOAMessage.PLAY_MACRO:
                {
                    if (razor != null)
                        razor.playMacro_Click(razor, new EventArgs());
                    return Macros.MacroManager.Playing ? 1 : 0;
                }

                case UOAMessage.DISPLAY_TEXT:
                {
                    if (World.Player == null)
                        return 0;

                    int hue = wParam & 0xFFFF;
                    StringBuilder sb = new StringBuilder(256);
                    if (GlobalGetAtomName((ushort) lParam, sb, 256) == 0)
                        return 0;

                    if ((wParam & 0x00010000) != 0)
                        Client.Instance.SendToClient(new UnicodeMessage(0xFFFFFFFF, -1, MessageType.Regular, hue, 3,
                            Language.CliLocName, "System", sb.ToString()));
                    else
                        World.Player.OverheadMessage(hue, sb.ToString());
                    GlobalDeleteAtom((ushort) lParam);
                    return 1;
                }

                case UOAMessage.REQUEST_MULTIS:
                {
                    return World.Player != null ? 1 : 0;
                }

                case UOAMessage.ADD_CMD:
                {
                    StringBuilder sb = new StringBuilder(256);
                    if (GlobalGetAtomName((ushort) lParam, sb, 256) == 0)
                        return 0;

                    if (wParam == 0)
                    {
                        Command.RemoveCommand(sb.ToString());
                        return 0;
                    }
                    else
                    {
                        new WndCmd(m_NextCmdID, (IntPtr) wParam, sb.ToString());
                        return (int) (m_NextCmdID++);
                    }
                }

                case UOAMessage.GET_UID:
                {
                    return World.Player != null ? (int) World.Player.Serial.Value : 0;
                }

                case UOAMessage.GET_SHARDNAME:
                {
                    if (World.ShardName != null && World.ShardName.Length > 0)
                        return GlobalAddAtom(World.ShardName);
                    else
                        return 0;
                }

                case UOAMessage.ADD_USER_2_PARTY:
                {
                    return 1; // not supported, return error
                }

                case UOAMessage.GET_UO_HWND:
                {
                    return Client.Instance.GetWindowHandle().ToInt32();
                }

                case UOAMessage.GET_POISON:
                {
                    return World.Player != null && World.Player.Poisoned ? 1 : 0;
                }

                case UOAMessage.SET_SKILL_LOCK:
                {
                    if (World.Player == null || wParam < 0 || wParam > World.Player.Skills.Length || lParam < 0 ||
                        lParam >= 3)
                        return 0;
                    Client.Instance.SendToServer(new SetSkillLock(wParam, (LockType) lParam));
                    return 1;
                }

                case UOAMessage.GET_ACCT_ID:
                {
                    // free shards don't use account ids... so just return the player's serial number
                    return World.Player == null ? 0 : (int) World.Player.Serial.Value;
                }

                default:
                {
                    return 0;
                }
            }
        }

        public static void PostCounterUpdate(int counter, int count)
        {
            PostToWndReg((uint) UOAMessage.RES_COUNT_DONE, (IntPtr) counter, (IntPtr) count);
        }

        public static void PostSpellCast(int spell)
        {
            PostToWndReg((uint) UOAMessage.CAST_SPELL, (IntPtr) spell, IntPtr.Zero);
        }

        public static void PostLogin(int serial)
        {
            PostToWndReg((uint) UOAMessage.LOGIN, (IntPtr) serial, IntPtr.Zero);
        }

        public static void PostLogout()
        {
            for (int i = 0; i < m_WndReg.Count; i++)
                PostMessage((IntPtr) ((WndRegEnt) m_WndReg[i]).Handle, (uint) UOAMessage.LOGOUT, IntPtr.Zero,
                    IntPtr.Zero);
        }

        public static void PostMacroStop()
        {
            PostToWndReg((uint) UOAMessage.MACRO_DONE, IntPtr.Zero, IntPtr.Zero);
        }

        public static void PostMapChange(int map)
        {
            PostToWndReg((uint) UOAMessage.MAP_INFO, (IntPtr) map, IntPtr.Zero);
        }

        public static void PostSkillUpdate(int skill, int val)
        {
            PostToWndReg((uint) UOAMessage.SKILL_LEVEL, (IntPtr) skill, (IntPtr) val);
            if (skill == Skills.MageryIndex)
                PostToWndReg((uint) UOAMessage.MAGERY_LEVEL, (IntPtr) ((int) (val / 10)), (IntPtr) (val % 10));
        }

        public static void PostRemoveMulti(Item item)
        {
            if (item == null)
                return;

            IntPtr pos = (IntPtr) ((int) ((item.Position.X & 0xFFFF) | ((item.Position.Y & 0xFFFF) << 16)));

            if (pos == IntPtr.Zero)
                return;

            for (int i = 0; i < m_WndReg.Count; i++)
            {
                WndRegEnt wnd = (WndRegEnt) m_WndReg[i];
                if (wnd.Type == 1)
                    PostMessage((IntPtr) wnd.Handle, (uint) UOAMessage.REM_MULTI, pos, (IntPtr) item.ItemID.Value);
            }
        }

        public static void PostAddMulti(ItemID iid, Point3D Position)
        {
            IntPtr pos = (IntPtr) ((int) ((Position.X & 0xFFFF) | ((Position.Y & 0xFFFF) << 16)));

            if (pos == IntPtr.Zero)
                return;

            for (int i = 0; i < m_WndReg.Count; i++)
            {
                WndRegEnt wnd = (WndRegEnt) m_WndReg[i];
                if (wnd.Type == 1)
                    PostMessage((IntPtr) wnd.Handle, (uint) UOAMessage.ADD_MULTI, pos, (IntPtr) iid.Value);
            }
        }

        public static void PostHitsUpdate()
        {
            if (World.Player != null)
                PostToWndReg((uint) UOAMessage.STR_STATUS, (IntPtr) World.Player.HitsMax, (IntPtr) World.Player.Hits);
        }

        public static void PostManaUpdate()
        {
            if (World.Player != null)
                PostToWndReg((uint) UOAMessage.INT_STATUS, (IntPtr) World.Player.ManaMax, (IntPtr) World.Player.Mana);
        }

        public static void PostStamUpdate()
        {
            if (World.Player != null)
                PostToWndReg((uint) UOAMessage.DEX_STATUS, (IntPtr) World.Player.StamMax, (IntPtr) World.Player.Stam);
        }

        private static void PostToWndReg(uint Msg, IntPtr wParam, IntPtr lParam)
        {
            ArrayList rem = null;
            for (int i = 0; i < m_WndReg.Count; i++)
            {
                if (PostMessage((IntPtr) ((WndRegEnt) m_WndReg[i]).Handle, Msg, wParam, lParam) == 0)
                {
                    if (rem == null)
                        rem = new ArrayList(1);
                    rem.Add(m_WndReg[i]);
                }
            }

            if (rem != null)
            {
                for (int i = 0; i < rem.Count; i++)
                    m_WndReg.Remove(rem[i]);
            }
        }

        [DllImport("user32.dll")]
        internal static extern uint PostMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);

        [DllImport("kernel32.dll")]
        private static extern ushort GlobalAddAtom(string str);

        [DllImport("kernel32.dll")]
        private static extern ushort GlobalDeleteAtom(ushort atom);

        [DllImport("kernel32.dll")]
        private static extern uint GlobalGetAtomName(ushort atom, StringBuilder buff, int bufLen);
    }
}

================================================
FILE: Razor/Core/ActionQueue.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using Assistant.Agents;

namespace Assistant
{
    public delegate void DropDoneCallback(Serial iser, Serial dser, Point3D newPos);

    public class DragDropManager
    {
        public enum ProcStatus
        {
            Nothing,
            Success,
            KeepWaiting,
            ReQueue
        }

        public static bool Debug = false;

        private static void Log(string str, params object[] args)
        {
            if (Debug)
            {
                try
                {
                    using (StreamWriter w = new StreamWriter("DragDrop.log", true))
                    {
                        w.Write(Engine.MistedDateTime.ToString("HH:mm:ss.fff"));
                        w.Write(":: ");
                        w.WriteLine(str, args);
                        w.Flush();
                    }
                }
                catch
                {
                }
            }
        }

        private class LiftReq
        {
            private static int NextID = 1;

            public LiftReq(Serial s, int a, bool cli, bool last)
            {
                Serial = s;
                Amount = a;
                FromClient = cli;
                DoLast = last;
                Id = NextID++;
            }

            public readonly Serial Serial;
            public readonly int Amount;
            public readonly int Id;
            public readonly bool FromClient;
            public readonly bool DoLast;

            public override string ToString()
            {
                return String.Format("{2}({0},{1},{3},{4})", Serial, Amount, Id, FromClient, DoLast);
            }
        }

        private class DropReq
        {
            public DropReq(Serial s, Point3D pt)
            {
                Serial = s;
                Point = pt;
            }

            public DropReq(Serial s, Layer layer)
            {
                Serial = s;
                Layer = layer;
            }

            public Serial Serial;
            public readonly Point3D Point;
            public readonly Layer Layer;
        }

        public static void Initialize()
        {
            try
            {
                File.Delete("DragDrop.log");
            }
            catch
            {
            }

            HotKey.Add(HKCategory.Misc, LocString.DropCur, new HotKeyCallback(DropCurrent));
        }

        public static void DropCurrent()
        {
            Log("Drop current requested on {0}", m_Holding);

            if (m_Holding.IsItem)
            {
                if (World.Player.Backpack != null)
                    Client.Instance.SendToServer(new DropRequest(m_Holding, Point3D.MinusOne,
                        World.Player.Backpack.Serial));
                else
                    Client.Instance.SendToServer(new DropRequest(m_Holding, World.Player.Position, Serial.Zero));
            }
            else
            {
                World.Player.SendMessage(MsgLevel.Force, LocString.NoHold);
            }

            Clear();
        }

        private static int m_LastID;

        private static Serial m_Pending, m_Holding;
        private static Item m_HoldingItem;
        private static bool m_ClientLiftReq = false;
        private static DateTime m_Lifted = DateTime.MinValue;

        private static readonly Dictionary<Serial, Queue<DropReq>>
            m_DropReqs = new Dictionary<Serial, Queue<DropReq>>();

        private static readonly LiftReq[] m_LiftReqs = new LiftReq[256];
        private static byte m_Front, m_Back;

        public static Item Holding
        {
            get { return m_HoldingItem; }
        }

        public static Serial Pending
        {
            get { return m_Pending; }
        }

        public static int LastIDLifted
        {
            get { return m_LastID; }
        }

        public static void Clear()
        {
            Log("Clearing....");

            m_DropReqs.Clear();
            for (int i = 0; i < 256; i++)
                m_LiftReqs[i] = null;
            m_Front = m_Back = 0;
            m_Holding = m_Pending = Serial.Zero;
            m_HoldingItem = null;
            m_Lifted = DateTime.MinValue;
        }

        public static void DragDrop(Item i, Serial to)
        {
            Drag(i, i.Amount);
            Drop(i, to, Point3D.MinusOne);
        }

        public static void DragDrop(Item i, Item to)
        {
            Drag(i, i.Amount);
            Drop(i, to.Serial, Point3D.MinusOne);
        }

        public static void DragDrop(Item i, Point3D dest)
        {
            Drag(i, i.Amount);
            Drop(i, Serial.MinusOne, dest);
        }

        public static void DragDrop(Item i, int amount, Item to)
        {
            Drag(i, amount);
            Drop(i, to.Serial, Point3D.MinusOne);
        }

        public static void DragDrop(Item i, Mobile to, Layer layer, bool doLast)
        {
            Drag(i, i.Amount, false, doLast);
            Drop(i, to, layer);
        }

        public static void DragDrop(Item i, Mobile to, Layer layer)
        {
            Drag(i, i.Amount, false);
            Drop(i, to, layer);
        }

        public static int Drag(Item i, int amount, bool fromClient)
        {
            return Drag(i, amount, fromClient, false);
        }

        public static int Drag(Item i, int amount)
        {
            return Drag(i, amount, false, false);
        }

        public static bool Empty
        {
            get { return m_Back == m_Front; }
        }

        public static bool Full
        {
            get { return ((byte) (m_Back + 1)) == m_Front; }
        }

        public static int Drag(Item i, int amount, bool fromClient, bool doLast)
        {
            LiftReq lr = new LiftReq(i.Serial, amount, fromClient, doLast);
            LiftReq prev = null;

            if (Full)
            {
                World.Player.SendMessage(MsgLevel.Error, LocString.DragDropQueueFull);
                if (fromClient)
                    Client.Instance.SendToClient(new LiftRej());
                return 0;
            }

            Log("Queuing Drag request {0}", lr);

            if (m_Back >= m_LiftReqs.Length)
                m_Back = 0;

            if (m_Back <= 0)
                prev = m_LiftReqs[m_LiftReqs.Length - 1];
            else if (m_Back <= m_LiftReqs.Length)
                prev = m_LiftReqs[m_Back - 1];

            // if the current last req must stay last, then insert this one in its place
            if (prev != null && prev.DoLast)
            {
                Log("Back-Queuing {0}", prev);
                if (m_Back <= 0)
                    m_LiftReqs[m_LiftReqs.Length - 1] = lr;
                else if (m_Back <= m_LiftReqs.Length)
                    m_LiftReqs[m_Back - 1] = lr;

                // and then re-insert it at the end
                lr = prev;
            }

            m_LiftReqs[m_Back++] = lr;

            ActionQueue.SignalLift(!fromClient);
            return lr.Id;
        }

        public static bool Drop(Item i, Mobile to, Layer layer)
        {
            if (m_Pending == i.Serial)
            {
                Log("Equipping {0} to {1} (@{2})", i, to.Serial, layer);
                Client.Instance.SendToServer(new EquipRequest(i.Serial, to, layer));
                m_Pending = Serial.Zero;
                EndHolding(i.Serial);
                m_Lifted = DateTime.MinValue;
                return true;
            }
            else
            {
                bool add = false;

                for (byte j = m_Front; j != m_Back && !add; j++)
                {
                    if (m_LiftReqs[j] != null && m_LiftReqs[j].Serial == i.Serial)
                    {
                        add = true;
                        break;
                    }
                }

                if (add)
                {
                    Log("Queuing Equip {0} to {1} (@{2})", i, to.Serial, layer);

                    if (!m_DropReqs.TryGetValue(i.Serial, out var q) || q == null)
                        m_DropReqs[i.Serial] = q = new Queue<DropReq>();

                    q.Enqueue(new DropReq(to == null ? Serial.Zero : to.Serial, layer));
                    return true;
                }
                else
                {
                    Log("Drop/Equip for {0} (to {1} (@{2})) not found, skipped", i,
                        to == null ? Serial.Zero : to.Serial, layer);
                    return false;
                }
            }
        }

        public static bool Drop(Item i, Serial dest, Point3D pt)
        {
            if (m_Pending == i.Serial)
            {
                Log("Dropping {0} to {1} (@{2})", i, dest, pt);

                Client.Instance.SendToServer(new DropRequest(i.Serial, pt, dest));
                m_Pending = Serial.Zero;
                EndHolding(i.Serial);
                m_Lifted = DateTime.MinValue;
                return true;
            }
            else
            {
                bool add = false;

                for (byte j = m_Front; j != m_Back && !add; j++)
                {
                    if (m_LiftReqs[j] != null && m_LiftReqs[j].Serial == i.Serial)
                    {
                        add = true;
                        break;
                    }
                }

                if (add)
                {
                    Log("Queuing Drop {0} (to {1} (@{2}))", i, dest, pt);

                    if (!m_DropReqs.TryGetValue(i.Serial, out var q) || q == null)
                        m_DropReqs[i.Serial] = q = new Queue<DropReq>();

                    q.Enqueue(new DropReq(dest, pt));
                    return true;
                }
                else
                {
                    Log("Drop for {0} (to {1} (@{2})) not found, skipped", i, dest, pt);
                    return false;
                }
            }
        }

        public static bool Drop(Item i, Item to, Point3D pt)
        {
            return Drop(i, to == null ? Serial.MinusOne : to.Serial, pt);
        }

        public static bool Drop(Item i, Item to)
        {
            return Drop(i, to.Serial, Point3D.MinusOne);
        }

        public static bool LiftReject()
        {
            Log("Server rejected lift for item {0}", m_Holding);
            if (m_Holding == Serial.Zero)
                return true;

            m_Holding = m_Pending = Serial.Zero;
            m_HoldingItem = null;
            m_Lifted = DateTime.MinValue;

            return m_ClientLiftReq;
        }

        public static bool HasDragFor(Serial s)
        {
            for (byte j = m_Front; j != m_Back; j++)
            {
                if (m_LiftReqs[j] != null && m_LiftReqs[j].Serial == s)
                    return true;
            }

            return false;
        }

        public static bool CancelDragFor(Serial s)
        {
            if (Empty)
                return false;

            int skip = 0;
            for (byte j = m_Front; j != m_Back; j++)
            {
                if (skip == 0 && m_LiftReqs[j] != null && m_LiftReqs[j].Serial == s)
                {
                    m_LiftReqs[j] = null;
                    skip++;
                    if (j == m_Front)
                    {
                        m_Front++;
                        break;
                    }
                    else
                    {
                        m_Back--;
                    }
                }

                if (skip > 0)
                    m_LiftReqs[j] = m_LiftReqs[(byte) (j + skip)];
            }

            if (skip > 0)
            {
                m_LiftReqs[m_Back] = null;
                return true;
            }
            else
            {
                return false;
            }
        }

        public static bool EndHolding(Serial s)
        {
            //if ( m_Pending == s )
            //	return false;

            if (m_Holding == s)
            {
                m_Holding = Serial.Zero;
                m_HoldingItem = null;
            }

            return true;
        }

        private static DropReq DequeueDropFor(Serial s)
        {
            DropReq dr = null;
            if (m_DropReqs.TryGetValue(s, out var q) && q != null)
            {
                if (q.Count > 0)
                    dr = q.Dequeue();
                if (q.Count <= 0)
                    m_DropReqs.Remove(s);
            }

            return dr;
        }

        public static void GracefulStop()
        {
            m_Front = m_Back = 0;

            if (m_Pending.IsValid)
            {
                m_DropReqs.TryGetValue(m_Pending, out var q);
                m_DropReqs.Clear();
                m_DropReqs[m_Pending] = q;
            }
        }

        public static ProcStatus ProcessNext(int numPending)
        {
            if (m_Pending != Serial.Zero)
            {
                if (m_Lifted + TimeSpan.FromMinutes(2) < DateTime.UtcNow)
                {
                    Item i = World.FindItem(m_Pending);

                    Log("Lift timeout, forced drop to pack for {0}", m_Pending);

                    if (World.Player != null)
                    {
                        World.Player.SendMessage(MsgLevel.Force, LocString.ForceEndHolding);

                        if (World.Player.Backpack != null)
                            Client.Instance.SendToServer(new DropRequest(m_Pending, Point3D.MinusOne,
                                World.Player.Backpack.Serial));
                        else
                            Client.Instance.SendToServer(new DropRequest(m_Pending, World.Player.Position,
                                Serial.Zero));
                    }

                    m_Holding = m_Pending = Serial.Zero;
                    m_HoldingItem = null;
                    m_Lifted = DateTime.MinValue;
                }
                else
                {
                    return ProcStatus.KeepWaiting;
                }
            }

            if (m_Front == m_Back)
            {
                m_Front = m_Back = 0;
                return ProcStatus.Nothing;
            }

            LiftReq lr = m_LiftReqs[m_Front];

            if (numPending > 0 && lr != null && lr.DoLast)
                return ProcStatus.ReQueue;

            m_LiftReqs[m_Front] = null;
            m_Front++;
            if (lr != null)
            {
                Log("Lifting {0}", lr);

                Item item = World.FindItem(lr.Serial);
                if (item != null && item.Container == null)
                {
                    // if the item is on the ground and out of range then dont grab it
                    if (Utility.Distance(item.GetWorldPosition(), World.Player.Position) > 3)
                    {
                        Log("Item is too far away... uncaching.");
                        ScavengerAgent.Instance.Uncache(item.Serial);
                        return ProcStatus.Nothing;
                    }
                }

                Client.Instance.SendToServer(new LiftRequest(lr.Serial, lr.Amount));

                m_LastID = lr.Id;
                m_Holding = lr.Serial;
                m_HoldingItem = World.FindItem(lr.Serial);
                m_ClientLiftReq = lr.FromClient;

                DropReq dr = DequeueDropFor(lr.Serial);
                if (dr != null)
                {
                    m_Pending = Serial.Zero;
                    EndHolding(lr.Serial);
                    m_Lifted = DateTime.MinValue;

                    Log("Dropping {0} to {1}", lr, dr.Serial);

                    if (dr.Serial.IsMobile && dr.Layer > Layer.Invalid && dr.Layer <= Layer.LastUserValid)
                        Client.Instance.SendToServer(new EquipRequest(lr.Serial, dr.Serial, dr.Layer));
                    else
                        Client.Instance.SendToServer(new DropRequest(lr.Serial, dr.Point, dr.Serial));
                }
                else
                {
                    m_Pending = lr.Serial;
                    m_Lifted = DateTime.UtcNow;
                }

                return ProcStatus.Success;
            }
            else
            {
                Log("No lift to be done?!");
                return ProcStatus.Nothing;
            }
        }
    }

    public class ActionQueue
    {
        private static Serial m_Last = Serial.Zero;
        private static readonly Queue m_Queue = new Queue();
        private static readonly ProcTimer m_Timer = new ProcTimer();
        private static int m_Total = 0;

        public static void DoubleClick(bool silent, Serial s)
        {
            if (s != Serial.Zero)
            {
                if (m_Last != s)
                {
                    m_Queue.Enqueue(s);
                    m_Last = s;
                    m_Total++;
                    if (m_Queue.Count == 1 && !m_Timer.Running)
                        m_Timer.StartMe();
                    else if (!silent && m_Total > 1)
                        World.Player.SendMessage(LocString.ActQueued, m_Queue.Count, TimeLeft);
                }
                else if (!silent)
                {
                    World.Player.SendMessage(LocString.QueueIgnore);
                }
            }
        }

        public static void SignalLift(bool silent)
        {
            m_Queue.Enqueue(Serial.Zero);
            m_Total++;
            if ( /*m_Queue.Count == 1 &&*/ !m_Timer.Running)
                m_Timer.StartMe();
            else if (!silent && m_Total > 1)
                World.Player.SendMessage(LocString.LiftQueued, m_Queue.Count, TimeLeft);
        }

        public static void Stop()
        {
            if (m_Timer != null && m_Timer.Running)
                m_Timer.Stop();
            m_Queue.Clear();
            DragDropManager.Clear();
        }

        public static bool Empty
        {
            get { return m_Queue.Count <= 0 && !m_Timer.Running; }
        }

        public static string TimeLeft
        {
            get
            {
                if (m_Timer.Running)
                {
                    //Config.GetBool("ObjectDelayEnabled")
                    //double time = Config.GetInt( "ObjectDelay" ) / 1000.0;

                    double time = Config.GetInt("ObjectDelay") / 1000.0;

                    if (!Config.GetBool("ObjectDelayEnabled"))
                    {
                        time = 0;
                    }

                    double init = 0;
                    if (m_Timer.LastTick != DateTime.MinValue)
                        init = time - (DateTime.UtcNow - m_Timer.LastTick).TotalSeconds;
                    time = init + time * m_Queue.Count;
                    if (time < 0)
                        time = 0;
                    return $"{time:F1} seconds";
                }
                else
                {
                    return "0.0 seconds";
                }
            }
        }

        private class ProcTimer : Timer
        {
            private DateTime m_StartTime;
            private DateTime m_LastTick;

            public DateTime LastTick
            {
                get { return m_LastTick; }
            }

            public ProcTimer() : base(TimeSpan.Zero, TimeSpan.Zero)
            {
            }

            public void StartMe()
            {
                m_LastTick = DateTime.UtcNow;
                m_StartTime = DateTime.UtcNow;

                OnTick();

                Delay = Interval;

                Start();
            }

            protected override void OnTick()
            {
                ArrayList requeue = null;

                m_LastTick = DateTime.UtcNow;

                if (m_Queue != null && m_Queue.Count > 0)
                {
                    this.Interval =
                        TimeSpan.FromMilliseconds(Config.GetBool("ObjectDelayEnabled")
                            ? Config.GetInt("ObjectDelay")
                            : 0);

                    //this.Interval = TimeSpan.FromMilliseconds( Config.GetInt( "ObjectDelay" ) );

                    while (m_Queue.Count > 0)
                    {
                        Serial s = (Serial) m_Queue.Peek();
                        if (s == Serial.Zero) // dragdrop action
                        {
                            DragDropManager.ProcStatus status = DragDropManager.ProcessNext(m_Queue.Count - 1);
                            if (status != DragDropManager.ProcStatus.KeepWaiting)
                            {
                                m_Queue.Dequeue(); // if not waiting then dequeue it

                                if (status == DragDropManager.ProcStatus.ReQueue)
                                    m_Queue.Enqueue(s);
                            }

                            if (status == DragDropManager.ProcStatus.KeepWaiting ||
                                status == DragDropManager.ProcStatus.Success)
                                break; // don't process more if we're waiting or we just processed something
                        }
                        else
                        {
                            m_Queue.Dequeue();
                            Client.Instance.SendToServer(new DoubleClick(s));
                            break;
                        }
                    }

                    if (requeue != null)
                    {
                        for (int i = 0; i < requeue.Count; i++)
                            m_Queue.Enqueue(requeue[i]);
                    }
                }
                else
                {
                    Stop();

                    if (m_Total > 1 && World.Player != null)
                        World.Player.SendMessage(LocString.QueueFinished, m_Total,
                            ((DateTime.UtcNow - m_StartTime) - this.Interval).TotalSeconds);

                    m_Last = Serial.Zero;
                    m_Total = 0;
                }
            }
        }
    }
}


================================================
FILE: Razor/Core/BandageTimer.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using Assistant.Core;

namespace Assistant
{
    public class BandageTimer
    {
        private static int _count;
        private static readonly Timer Timer;

        private static readonly int[] ClilocNums = {
            500955,
            500962,
            500963,
            500964,
            500965,
            500966,
            500967,
            500968,
            500969,
            503252,
            503253,
            503254,
            503255,
            503256,
            503257,
            503258,
            503259,
            503260,
            503261,
            1010058,
            1010648,
            1010650,
            1060088,
            1060167
        };

        static BandageTimer()
        {
            Timer = new InternalTimer();
            
            MessageManager.OnSystemMessage += OnSystemMessage;
        }

        private static void OnSystemMessage(Packet p, PacketHandlerEventArgs args, Serial source, ushort graphic, MessageType type, ushort hue, ushort font, string lang, string sourceName, string msg)
        {
            if (Running)
            {
                if (msg == "You heal what little damage you had." ||
                    msg == "You heal what little damage the patient had." ||
                    msg == "You did not stay close enough to heal your target.")
                {
                    Stop();

                    if (Config.GetBool("ShowBandageTimer") && Config.GetBool("ShowBandageEnd"))
                        ShowBandagingStatusMessage(Config.GetString("BandageEndMessage"));

                    return;
                }

                if (msg == "You begin applying the bandages.") // Timer is running and they start a new bandage
                {
                    Start();

                    if (Config.GetBool("ShowBandageTimer") && Config.GetBool("ShowBandageStart"))
                        ShowBandagingStatusMessage(Config.GetString("BandageStartMessage"));

                    return;
                }

                foreach (var t in ClilocNums)
                {
                    if (Language.GetCliloc(t) == msg)
                    {
                        Stop();

                        if (Config.GetBool("ShowBandageTimer") && Config.GetBool("ShowBandageEnd"))
                            ShowBandagingStatusMessage(Config.GetString("BandageEndMessage"));

                        break;
                    }
                }
            }
            else
            {
                // Start timer as soon as there is the "You begin applying the bandages." message
                if (msg == "You begin applying the bandages.")
                {
                    Start();

                    if (Config.GetBool("ShowBandageTimer") && Config.GetBool("ShowBandageStart"))
                        ShowBandagingStatusMessage(Config.GetString("BandageStartMessage"));
                }
            }
        }

        public static void OnLocalizedMessage(int num)
        {
            if (Running)
            {
                if (num == 500955 || (num >= 500962 && num <= 500969) || (num >= 503252 && num <= 503261) ||
                    num == 1010058 || num == 1010648 || num == 1010650 || num == 1060088 || num == 1060167)
                {
                    Stop();

                    if (Config.GetBool("ShowBandageTimer") && Config.GetBool("ShowBandageEnd"))
                        ShowBandagingStatusMessage(Config.GetString("BandageEndMessage"));

                    return;
                }

                // Check if they are re-healing before the timer ends
                if (num == 500956)
                {
                    Start();

                    if (Config.GetBool("ShowBandageTimer") && Config.GetBool("ShowBandageStart"))
                        ShowBandagingStatusMessage(Config.GetString("BandageStartMessage"));
                }
            }
            else
            {
                // Start timer as soon as there is the "You begin applying the bandages." message
                if (num == 500956)
                {
                    Start();

                    if (Config.GetBool("ShowBandageTimer") && Config.GetBool("ShowBandageStart"))
                        ShowBandagingStatusMessage(Config.GetString("BandageStartMessage"));
                }
            }
        }

        public static int Count => _count;

        public static bool Running => Timer.Running;

        private static void Start()
        {
            _count = 0;

            if (Timer.Running)
            {
                Timer.Stop();
            }

            Timer.Start();
            Client.Instance.RequestTitlebarUpdate();
        }

        public static void Stop()
        {
            Timer.Stop();
            Client.Instance.RequestTitlebarUpdate();
        }

        private static void ShowBandagingStatusMessage(string msg)
        {
            if (Config.GetInt("ShowBandageTimerLocation") == 0)
            {
                World.Player.OverheadMessage(Config.GetInt("ShowBandageTimerHue"), msg);
            }
            else
            {
                World.Player.SendMessage(Config.GetInt("ShowBandageTimerHue"), msg);
            }
        }

        private class InternalTimer : Timer
        {
            public InternalTimer() : base(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1))
            {
            }

            protected override void OnTick()
            {
                if (World.Player != null && World.Player.IsGhost)
                {
                    BandageTimer.Stop();
                    return;
                }

                _count++;

                if (Config.GetBool("ShowBandageTimer"))
                {
                    bool showMessage = !(Config.GetBool("OnlyShowBandageTimerEvery") &&
                                         _count % Config.GetInt("OnlyShowBandageTimerSeconds") != 0);

                    if (showMessage)
                        ShowBandagingStatusMessage(Config.GetString("ShowBandageTimerFormat")
                            .Replace("{count}", _count.ToString()));
                }

                if (_count > 30)
                    Stop();

                Client.Instance.RequestTitlebarUpdate();
            }
        }
    }
}

================================================
FILE: Razor/Core/BodCapture.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.IO;

namespace Assistant.Core
{
    public class BodCapture
    {
        private class Bod
        {
            public bool IsLarge { get; set; }
            public string ItemName { get; set; }
            public bool Exceptional { get; set; }
            public string Material { get; set; }
            public string TotalAmount { get; set; }
            public string CurrentAmount { get; set; }
        }

        private static readonly uint _largeBodGumpId = 2703603018;
        private static readonly uint _smallBodGumpId = 1526454082;

        private static readonly string _bodFile = Path.Combine(Config.GetInstallDirectory(), "BODs.csv");

        public static bool IsBodGump(uint gumpId)
        {
            return gumpId == _largeBodGumpId || gumpId == _smallBodGumpId;
        }

        public static void CaptureBod(List<string> bodGumpString)
        {
            // sort the gump string
            List<Bod> bods = ParseBodGumpData(bodGumpString);

            CheckFile();

            using (StreamWriter sw = File.AppendText(_bodFile))
            {
                foreach (Bod bod in bods)
                {
                    sw.WriteLine(
                        $"{bod.ItemName},{(bod.IsLarge ? "large" : "small")},{bod.Exceptional},{bod.Material},{bod.CurrentAmount},{bod.TotalAmount}");
                }
            }
        }

        public static void CheckFile()
        {
            if (File.Exists(_bodFile))
                return;

            using (StreamWriter sw = File.AppendText(_bodFile))
            {
                sw.WriteLine("itemname,type,exceptional,material,currentamount,totalamount");
            }
        }

        /*Count = 11               //// SMALL BOD
        [0]: "A bulk order"
        [1]: "Amount to make:"
        [2]: "Amount finished:"
        [3]: "Item requested:"
        [4]: "cloak"
        [5]: "Special requirements to meet:"
        [6]: "All items must be exceptional."
        [?]: "All items must be made with X.
        [7]: "Combine this deed with the item requested."
        [8]: "EXIT"
        [9]: "20"
        [10]: "0"
        
        Count = 19                /// LARGE BOD
        [0]: "A large bulk order"
        [1]: "Amount to make:"
        [2]: "Items requested:"
        [3]: "Amount finished:"
        [4]: "war axe"
        [5]: "hammer pick"
        [6]: "mace"
        [7]: "maul"
        [8]: "war hammer"
        [9]: "war mace"
        [?]: "All items must be made with X.
        [10]: "Combine this deed with another deed."
        [11]: "EXIT"
        [12]: "15"
        [13]: "0"
        [14]: "0"
        [15]: "0"
        [16]: "0"
        [17]: "0"
        [18]: "0"*/

        private static List<Bod> ParseBodGumpData(List<string> gumpData)
        {
            List<Bod> bods = new List<Bod>();

            // First item should say large if it is
            bool isLarge = gumpData[0].Contains("large");

            // EXIT on large/small is an good "split" point
            int exitIndex = gumpData.FindIndex(x => x.Equals("EXIT"));


            // This word should exist some place in the array if it's exceptional
            bool isExceptional = false;
            string material = "default";

            foreach (string data in gumpData)
            {
                if (data.Contains("exceptional"))
                {
                    isExceptional = true;
                }
                else if (data.Contains("All items must be made with"))
                {
                    material = data.Substring(data.IndexOf("with", StringComparison.Ordinal) + 5).Replace(".", "");
                }
            }

            // Based on the data above, the total amount is always after EXIT in both small and large
            string totalAmount = gumpData[exitIndex + 1];

            // BOD requirement data appears at index 4 for both small and large
            int beginningIndex = 4;

            int currentAmountIndex = 2;

            if (isLarge)
            {
                for (int i = beginningIndex; i < gumpData.Count; i++)
                {
                    // Keep adding new BODs to the array as long as you don't hit the end
                    if (!gumpData[i].Contains("Combine") && !gumpData[i].Contains("Special"))
                    {
                        bods.Add(new Bod
                        {
                            ItemName = gumpData[i],
                            IsLarge = true,
                            Exceptional = isExceptional,
                            CurrentAmount = gumpData[exitIndex + currentAmountIndex],
                            TotalAmount = totalAmount,
                            Material = material
                        });

                        currentAmountIndex++;
                    }
                    else
                    {
                        break;
                    }
                }
            }
            else // small!
            {
                bods.Add(new Bod
                {
                    ItemName = gumpData[beginningIndex],
                    IsLarge = false,
                    Exceptional = isExceptional,
                    CurrentAmount = gumpData[exitIndex + 2],
                    TotalAmount = totalAmount,
                    Material = material
                });
            }

            return bods;
        }
    }
}

================================================
FILE: Razor/Core/BuffDebuffManager.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Runtime.CompilerServices;
using Assistant.Agents;
using Assistant.Gumps.Internal;

namespace Assistant.Core
{
    public enum BuffIconType : ushort
    {
        DismountPrevention = 0x3E9,
        NoRearm = 0x3EA,
        
        //Currently, no 0x3EB or 0x3EC
        NightSight = 0x3ED, 
        DeathStrike,
        EvilOmen,
        HonoredDebuff,
        AchievePerfection,
        DivineFury,         
        EnemyOfOne,         
        HidingAndOrStealth,
        ActiveMeditation,
        BloodOathCaster,
        BloodOathCurse,
        CorpseSkin,
        Mindrot,
        PainSpike,
        Strangle,
        GiftOfRenewal,
        AttuneWeapon,
        Thunderstorm,
        EssenceOfWind,
        EtherealVoyage,
        GiftOfLife,
        ArcaneEmpowerment,
        MortalStrike,
        ReactiveArmor,
        Protection,
        ArchProtection,
        MagicReflection,
        Incognito,
        Disguised,
        AnimalForm,
        Polymorph,
        Invisibility,
        Paralyze, 
        Poison,
        Bleed,
        Clumsy, 
        FeebleMind,
        Weaken,  
        Curse,   
        MassCurse,
        Agility, 
        Cunning, 
        Strength, 
        Bless,   
        Sleep,
        StoneForm,
        SpellPlague,
        Berserk,
        MassSleep,
        Fly,
        Inspire,
        Invigorate,
        Resilience,
        Perseverance,
        TribulationTarget,
        DespairTarget,
        FishPie = 0x426,
        HitLowerAttack,
        HitLowerDefense,
        DualWield,
        Block,
        DefenseMastery,
        DespairCaster,
        Healing,
        SpellFocusingBuff,
        SpellFocusingDebuff,
        RageFocusingDebuff,
        RageFocusingBuff,
        Warding,
        TribulationCaster,
        ForceArrow,
        Disarm,
        Surge,
        Feint,
        TalonStrike,
        PsychicAttack,
        ConsecrateWeapon,
        GrapesOfWrath,
        EnemyOfOneDebuff,
        HorrificBeast,
        LichForm,
        VampiricEmbrace,
        CurseWeapon,
        ReaperForm,
        ImmolatingWeapon,
        Enchant,
        HonorableExecution,
        Confidence,
        Evasion,
        CounterAttack,
        LightningStrike,
        MomentumStrike,
        OrangePetals,
        RoseOfTrinsic,
        PoisonImmunity,
        Veterinary,
        Perfection,
        Honored,
        ManaPhase,
        FanDancerFanFire,
        Rage,
        Webbing,
        MedusaStone,
        TrueFear,
        AuraOfNausea,
        HowlOfCacophony,
        GazeDespair,
        HiryuPhysicalResistance,
        RuneBeetleCorruption,
        BloodwormAnemia,
        RotwormBloodDisease,
        SkillUseDelay,
        FactionStatLoss,
        HeatOfBattleStatus,
        CriminalStatus,
        ArmorPierce,
        SplinteringEffect,
        SwingSpeedDebuff,
        WraithForm,
        CityTradeDeal = 0x466,
        HumilityDebuff = 0x467,
        Spirituality,
        Humility,
        // Skill Masteries
        Rampage,
        Stagger, // Debuff
        Toughness,
        Thrust,
        Pierce, // Debuff
        PlayingTheOdds,
        FocusedEye,
        Onslaught, // Debuff
        ElementalFury,
        ElementalFuryDebuff, // Debuff
        CalledShot,
        Knockout,
        SavingThrow,
        Conduit,
        EtherealBurst,
        MysticWeapon,
        ManaShield,
        AnticipateHit,
        Warcry,
        Shadow,
        WhiteTigerForm,
        Bodyguard,
        HeightenedSenses,
        Tolerance,
        DeathRay,
        DeathRayDebuff,
        Intuition,
        EnchantedSummoning,
        ShieldBash,
        Whispering,
        CombatTraining,
        InjectedStrikeDebuff,
        InjectedStrike,
        UnknownTomato,
        PlayingTheOddsDebuff,
        DragonTurtleDebuff,
        Boarding,
        Potency,
        ThrustDebuff,
        FistsOfFury,
        BarrabHemolymphConcentrate,
        JukariBurnPoiltice,
        KurakAmbushersEssence,
        BarakoDraftOfMight,
        UraliTranceTonic,
        SakkhraProphylaxis,
        Sparks,
        Swarm,
        BoneBreaker,
        Unknown2,
        SwarmImmune,
        BoneBreakerImmune,
        UnknownGoblin,
        UnknownRedDrop,
        UnknownStar,
        FeintDebuff,
        CaddelliteInfused,
        PotionGloriousFortune,
        MysticalPolymorphTotem,
        UnknownDebuff
    }

    public class BuffDebuff
    {
        public ushort IconId { get; set; }
        public int Duration { get; set; }
        public string ClilocMessage1 { get; set; }
        public string ClilocMessage2 { get; set; }
        public BuffIconType BuffIconType { get; set; }
        public DateTime Timestamp { get; set; }

        public override string ToString()
        {
            return ClilocMessage1;
        }
    }

    public static class BuffDebuffManager
    {
        private static Timer BuffDebuffTimer { get; set; } = new InternalTimer();

        private static List<string> _buffDebuffFilter = new List<string>();

        private static BuffGump _gump;

        public static ushort[] BuffTable { get; } =
        {
            0x754C,
            0x754A,
            0x0000,
            0x0000,
            0x755E,
            0x7549,
            0x7551,
            0x7556,
            0x753A,
            0x754D,
            0x754E,
            0x7565,
            0x753B,
            0x7543,
            0x7544,
            0x7546,
            0x755C,
            0x755F,
            0x7566,
            0x7554,
            0x7540,
            0x7568,
            0x754F,
            0x7550,
            0x7553,
            0x753E,
            0x755D,
            0x7563,
            0x7562,
            0x753F,
            0x7559,
            0x7557,
            0x754B,
            0x753D,
            0x7561,
            0x7558,
            0x755B,
            0x7560,
            0x7541,
            0x7545,
            0x7552,
            0x7569,
            0x7548,
            0x755A,
            0x753C,
            0x7547,
            0x7567,
            0x7542,
            0x758A,
            0x758B,
            0x758C,
            0x758D,
            0x0000,
            0x758E,
            0x094B,
            0x094C,
            0x094D,
            0x094E,
            0x094F,
            0x0950,
            0x753E,
            0x5011,
            0x7590,
            0x7591,
            0x7592,
            0x7593,
            0x7594,
            0x7595,
            0x7596,
            0x7598,
            0x7599,
            0x759B,
            0x759C,
            0x759E,
            0x759F,
            0x75A0,
            0x75A1,
            0x75A3,
            0x75A4,
            0x75A5,
            0x75A6,
            0x75A7,
            0x75C0,
            0x75C1,
            0x75C2,
            0x75C3,
            0x75C4,
            0x75F2,
            0x75F3,
            0x75F4,
            0x75F5,
            0x75F6,
            0x75F7,
            0x75F8,
            0x75F9,
            0x75FA,
            0x75FB,
            0x75FC,
            0x75FD,
            0x75FE,
            0x75FF,
            0x7600,
            0x7601,
            0x7602,
            0x7603,
            0x7604,
            0x7605,
            0x7606,
            0x7607,
            0x7608,
            0x7609,
            0x760A,
            0x760B,
            0x760C,
            0x760D,
            0x760E,
            0x760F,
            0x7610,
            0x7611,
            0x7612,
            0x7613,
            0x7614,
            0x7615,
            0x75C5,
            0x75F6,
            0x761B,
            // skill masteries
            0x9bc9,
            0x9bb5,
            0x9bdd,
            0x9bc6,
            0x9bcc,
            0x9bbe,
            0x9bbd,
            0x9bcb,
            0x9bc8,
            0x9bbf,
            0x9bcd,
            0x9bc0,
            0x9bce,
            0x9bc1,
            0x9bc7,
            0x9bc2,
            0x9bb7,
            0x9bca,
            0x9bb6,
            0x9bb8,
            0x9bb9,
            0x9bba,
            0x9bbb,
            0x9bbc,
            0x9bc3,
            0x9bc4,
            0x9bc5,
            0x9bd2,
            0x9bd3,
            0x9bd4,
            0x9bd5,
            0x9bd1,
            0x9bd6,
            0x9bd7,
            0x9bcf,
            0x9bd8,
            0x9bd9,
            0x9bdb,
            0x9bdc,
            0x9bda,
            0x9bd0,
            0x9bde,
            0x9bdf,

            0xC349,
            0xC34D,
            0xC34E,
            0xC34C,
            0xC34B,
            0xC34A,
            0xC343,
            0xC345,
            0xC346,
            0xC347,
            0xC348,

            0x9CDE,

            0x5DE1,
            0x5DDF,
            0x5DE3,
            0x5DE5,
            0x5DE4,
            0x5DE6,
            0x5D51,

            0x0951
        };

        public static ushort[] BuffList { get; } =
        {
            //UNKNOWN (COULD NOT FIND A ICON)
            0x5D51,
            //GREEN ICONS
            0x094B, 0x094C, 0x094D, 0x094E, 0x5011, 0x5DDF, 0x5DE1, 0x5DE4, 0x5DE5, 0x5DE6, 0x753C, 0x753D, 0x753E, 0x753E, 0x753F,
            0x7540, 0x7542, 0x7543, 0x7547, 0x754D, 0x754E, 0x7550, 0x7553, 0x7554, 0x7558, 0x7559, 0x755E, 0x7562, 0x7563, 0x7567,
            0x758B, 0x758D, 0x7592, 0x7593, 0x7594, 0x7596, 0x7598, 0x759C, 0x759E, 0x759F, 0x75A3, 0x75A4, 0x75A7, 0x75C0, 0x75C2,
            0x75C3, 0x75C4, 0x75C5, 0x75F2, 0x75F3, 0x75F4, 0x75F5, 0x75F6, 0x75F7, 0x75F8, 0x75F9, 0x75FA, 0x75FB, 0x75FC, 0x75FD,
            0x75FE, 0x75FF, 0x7600, 0x7601, 0x7602, 0x7617, 0x7618, 0x7619, 0x761A, 0x761B, 0x9bb5, 0x9bb6, 0x9bb7, 0x9bb8, 0x9bb9,
            0x9bba, 0x9bbb, 0x9bbc, 0x9bbd, 0x9bbe, 0x9bbf, 0x9bc0, 0x9bc1, 0x9bc2, 0x9bc3, 0x9bc4, 0x9bc5, 0x9bc6, 0x9bc7, 0x9bc8,
            0x9bd0, 0x9bd1, 0x9bd2, 0x9bd4, 0x9bd5, 0x9bd6, 0x9bd7, 0x9bd8, 0x9bd9, 0x9bda, 0x9bdd, 0x9bdf, 0x9CDE, 0xC342, 0xC346,
            0xC347, 0xC348, 0xC349, 0xC34A, 0xC34B, 0xC34C, 0xC34D, 0xC34E
        };

        public static ushort[] DebuffList { get; } =
        {
            //RED ICONS
            0x094F, 0x0950, 0x0951, 0x5DE3, 0x753A, 0x7540, 0x7544, 0x7545, 0x7546, 0x7548, 0x7549, 0x754A, 0x754C, 0x754F, 0x7551,
            0x7552, 0x7555, 0x7556, 0x755A, 0x755B, 0x755C, 0x755D, 0x755F, 0x7560, 0x7564, 0x7566, 0x7568, 0x7569, 0x758A, 0x758C,
            0x758F, 0x7590, 0x7591, 0x7599, 0x759B, 0x75A0, 0x75A1, 0x75A5, 0x75A6, 0x75A8, 0x75C1, 0x7603, 0x7604, 0x7605, 0x7606,
            0x7607, 0x7608, 0x7609, 0x760A, 0x760B, 0x760C, 0x760D, 0x760E, 0x760F, 0x7610, 0x7611, 0x7612, 0x7613, 0x7614, 0x7615,
            0x7616, 0x9bc9, 0x9bca, 0x9bcb, 0x9bcc, 0x9bcd, 0x9bce, 0x9bcf, 0x9bd3, 0x9bdb, 0x9bdc, 0x9bde, 0xC343, 0xC344, 0xC345
        };

        public static ushort[] StatesList { get; } =
        {
            //BLUE ICONS
            0x753B, 0x754B, 0x7557, 0x7561, 0x7565, 0x758E, 0x7595
        };

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool IsBuff(ushort g)
        {
            return BuffList.Contains(g);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool IsDebuff(ushort g)
        {
            return DebuffList.Contains(g);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool IsState(ushort g)
        {
            return StatesList.Contains(g);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool IsValid(ushort g)
        {
            return BuffList.Contains(g);
        }
        
        private const ushort BUFF_ICON_START = 0x03E9;
        private const ushort BUFF_ICON_START_NEW = 0x466;

        public static ushort GetGraphicId(string name)
        {
            try
            {
                if (Enum.TryParse(name, true, out BuffIconType result))
                {
                    ushort iconId = (ushort) result >= BUFF_ICON_START_NEW
                        ? (ushort) (result - (BUFF_ICON_START_NEW - 125))
                        : (ushort) ((ushort) result - BUFF_ICON_START);

                    return BuffTable[iconId];
                }
            }
            catch (Exception ex)
            {
                // ignored
            }

            return 0;
        }

        public static void DisplayOverheadBuff(BuffDebuff buff, bool ignoreAction = false)
        {
            if (Config.GetBool("ShowBuffDebuffOverhead") && !IsFiltered(buff.ClilocMessage1))
            {
                TimeSpan diff = DateTime.UtcNow - buff.Timestamp;
                int timeLeft = buff.Duration - (int)diff.TotalSeconds;

                if (Config.GetBool("OverrideBuffDebuffFormat"))
                {
                    string format = Config.GetString("BuffDebuffFormat");

                    if (string.IsNullOrEmpty(format))
                    {
                        format = "[{action}{name} {duration}]";
                    }
                    
                    World.Player.OverheadMessage(Config.GetInt("BuffHue"), format.Replace("{action}", ignoreAction ? string.Empty : "+").Replace("{name}", buff.ClilocMessage1)
                            .Replace("{duration}", timeLeft < 1 ? string.Empty : $"({timeLeft}s)"));
                }
                else
                {
                    World.Player.OverheadMessage(Config.GetInt("BuffHue"), timeLeft < 1 ? $"[+{buff.ClilocMessage1}]" : $"[+{buff.ClilocMessage1} ({timeLeft}s)]");
                }
            }
        }

        public static void DisplayOverheadDebuff(BuffIconType debuffIconType)
        {
            if (Config.GetBool("ShowBuffDebuffOverhead"))
            {
                BuffDebuff debuff = World.Player.BuffsDebuffs.FirstOrDefault(b => b.BuffIconType == debuffIconType);

                if (debuff == null)
                    return;

                if (IsFiltered(debuff.ClilocMessage1))
                    return;

                if (Config.GetBool("OverrideBuffDebuffFormat"))
                {
                    string format = Config.GetString("BuffDebuffFormat");

                    if (string.IsNullOrEmpty(format))
                    {
                        format = "[{action}{name} {duration}]";
                    }
                    
                    World.Player.OverheadMessage(Config.GetInt("DebuffHue"),
                        format.Replace("{action}", "-").Replace("{name}", debuff.ClilocMessage1)
                            .Replace("{duration}", string.Empty));
                }
                else
                {
                    World.Player.OverheadMessage(Config.GetInt("DebuffHue"), $"[-{debuff.ClilocMessage1}]");
                }
            }
        }

        public static void ReloadFilter()
        {
            _buffDebuffFilter.Clear();

            foreach (string filter in Config.GetString("BuffDebuffFilter").Split(','))
            {
                if (!string.IsNullOrEmpty(filter))
                {
                    _buffDebuffFilter.Add(filter);
                }
            }
        }

        private static bool IsFiltered(string name)
        {
            if (string.IsNullOrEmpty(Config.GetString("BuffDebuffFilter")))
                return false;

            if (string.IsNullOrEmpty(name))
                return false;

            foreach (string filter in _buffDebuffFilter)
            {
                if (name.IndexOf(filter, StringComparison.OrdinalIgnoreCase) != -1)
                    return true;
            }

            return false;
        }
        
        public static bool Running => BuffDebuffTimer.Running;

        public static void Start()
        {
            if (BuffDebuffTimer.Running)
                BuffDebuffTimer.Stop();
            
            BuffDebuffTimer.Start();

            Client.Instance.RequestTitlebarUpdate();
        }

        public static void Stop()
        {
            BuffDebuffTimer.Stop();
            
            _gump?.CloseGump();
            
            Client.Instance.RequestTitlebarUpdate();
        }

        private class InternalTimer : Timer
        {
            public InternalTimer() : base(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1))
            {
            }

            protected override void OnTick()
            {
                if (World.Player == null)
                {
                    BuffDebuffTimer.Stop();
                    return;
                }

                Client.Instance.RequestTitlebarUpdate();
                
                if (Config.GetBool("ShowBuffDebuffGump"))
                {
                    _gump?.CloseGump();

                    if (World.Player.BuffsDebuffs.Count > 0)
                    {
                        _gump = new BuffGump();
                        _gump.SendGump();
                    }
                }

                if (!Config.GetBool("BuffDebuffEveryXSeconds") || !Config.GetBool("ShowBuffDebuffOverhead"))
                    return;

                foreach (BuffDebuff buffsDebuff in World.Player.BuffsDebuffs)
                {
                    TimeSpan diff = DateTime.UtcNow - buffsDebuff.Timestamp;
                    int timeLeft = buffsDebuff.Duration - (int)diff.TotalSeconds;

                    if (timeLeft % Config.GetInt("BuffDebuffSeconds") == 0)
                    {
                        BuffDebuffManager.DisplayOverheadBuff(buffsDebuff, true);
                    }
                }
            }
        }
    }
}

================================================
FILE: Razor/Core/ClassicUOManager.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace Assistant.Core
{
    public static class ClassicUOManager
    {
        private static List<string> ProfileProperties { get; set; } = new List<string>();

        /// <summary>
        /// Gets all properties.
        /// </summary>
        /// <returns></returns>
        public static List<string> GetAllProperties()
        {
            if (!Client.IsOSI)
            {
                if (ProfileProperties.Count == 0)
                {
                    var currentProfileProperty = ClassicUOClient.Assembly?.GetType("ClassicUO.Configuration.ProfileManager")?.GetProperty("CurrentProfile", BindingFlags.Public | BindingFlags.Static);
                    if (currentProfileProperty != null)
                    {
                        var profile = currentProfileProperty.GetValue(null);
                        if (profile != null)
                        {
                            var profileClass = ClassicUOClient.Assembly?.GetType("ClassicUO.Configuration.Profile");

                            foreach (var propSearch in profileClass.GetProperties())
                            {
                                ProfileProperties.Add(propSearch.Name);
                            }

                            ProfileProperties.Sort();
                        }
                    }
                }

                return ProfileProperties;
            }

            return null;
        }

        /// <summary>
        /// Determines whether [is valid property] [the specified property].
        /// </summary>
        /// <param name="property">The property.</param>
        /// <returns></returns>
        public static string IsValidProperty(string property)
        {
            foreach (string profileProperty in GetAllProperties())
            {
                if (profileProperty.Equals(property, StringComparison.OrdinalIgnoreCase))
                {
                    return profileProperty;
                }
            }

            return null;
        }

        /// <summary>
        /// Set a bool Config property in CUO by name
        /// </summary>
        public static void ProfilePropertySet(string propertyName, bool enable)
        {
            if (!Client.IsOSI)
            {
                var currentProfileProperty = ClassicUOClient.Assembly?.GetType("ClassicUO.Configuration.ProfileManager")?.GetProperty("CurrentProfile", BindingFlags.Public | BindingFlags.Static);
                if (currentProfileProperty != null)
                {
                    var profile = currentProfileProperty.GetValue(null);
                    if (profile != null)
                    {
                        var profileClass = ClassicUOClient.Assembly?.GetType("ClassicUO.Configuration.Profile");
                        PropertyInfo property = null;

                        foreach (var propSearch in profileClass.GetProperties())
                        {
                            if (propSearch.Name == propertyName)
                            {
                                property = propSearch;
                                break;
                            }
                        }

                        if (property != null)
                        {
                            property.SetValue(profile, enable);
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Set a int Config property in CUO by name
        /// </summary>
        public static void ProfilePropertySet(string propertyName, int value)
        {
            if (!Client.IsOSI)
            {
                var currentProfileProperty = ClassicUOClient.Assembly?.GetType("ClassicUO.Configuration.ProfileManager")?.GetProperty("CurrentProfile", BindingFlags.Public | BindingFlags.Static);
                if (currentProfileProperty != null)
                {
                    var profile = currentProfileProperty.GetValue(null);
                    if (profile != null)
                    {
                        var profileClass = ClassicUOClient.Assembly?.GetType("ClassicUO.Configuration.Profile");
                        PropertyInfo property = null;

                        foreach (var propSearch in profileClass.GetProperties())
                        {
                            if (propSearch.Name == propertyName)
                            {
                                property = propSearch;
                                break;
                            }
                        }

                        if (property != null)
                        {
                            property.SetValue(profile, value);
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Set a string Config property in CUO by name
        /// </summary>
        public static void ProfilePropertySet(string propertyName, string value)
        {
            if (!Client.IsOSI)
            {
                var currentProfileProperty = ClassicUOClient.Assembly?.GetType("ClassicUO.Configuration.ProfileManager")?.GetProperty("CurrentProfile", BindingFlags.Public | BindingFlags.Static);
                if (currentProfileProperty != null)
                {
                    var profile = currentProfileProperty.GetValue(null);
                    if (profile != null)
                    {
                        var profileClass = ClassicUOClient.Assembly?.GetType("ClassicUO.Configuration.Profile");
                        System.Reflection.PropertyInfo property = null;
                        foreach (var propSearch in profileClass.GetProperties())
                        {
                            if (propSearch.Name == propertyName)
                            {
                                property = propSearch;
                                break;
                            }
                        }
                        if (property != null)
                        {
                            property.SetValue(profile, value);
                        }
                    }
                }
            }
        }
    }
}


================================================
FILE: Razor/Core/Commands.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Text;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Assistant.Agents;
using Assistant.Core;
using Assistant.Gumps.Internal;
using Assistant.Macros;
using Assistant.Scripts;
using Ultima;

namespace Assistant
{
    public class Commands
    {
        public static void Initialize()
        {
            Command.Register("AddUseOnce", AddUseOnce);
            Command.Register("Time", Time);
            Command.Register("Where", Where);
            Command.Register("Ping", Ping);
            Command.Register("Help", Command.ListCommands);
            Command.Register("Echo", Echo);
            Command.Register("Macro", MacroCmd);
            Command.Register("Script", ScriptCmd);
            Command.Register("Hue", GetItemHue);
            Command.Register("Item", GetItemHue);
            Command.Register("Resync", Resync);
            Command.Register("Mobile", GetMobile);
            Command.Register("Weather", SetWeather);
            Command.Register("Season", SetSeason);
            Command.Register("Damage", DamageTrackerReport);
            Command.Register("Set", SetMacroVariable);
            Command.Register("Track", Track);
            Command.Register("Waypoint", Track);

            Command.Register("TestGump", CreateGump);
            Command.Register("Info", GetGumpInfo);

            Command.Register("SysMsgs", GetSystemMessages);
            Command.Register("SysMessages", GetSystemMessages);

            Command.Register("HotKeys", ShowHotKeyGump);

            Command.Register("Boat", ShowBoatControlGump);

            Command.Register("Skills", ShowUsableSkills);

            Command.Register("Restock", ShowRestockGump);
            Command.Register("Org", ShowOrgGump);
            Command.Register("Buy", ShowBuyGump);

            Command.Register("CUO", ClassicUoProfile);
            
            Command.Register("Sound", PlaySound);
            
            Command.Register("Cooldown", Cooldown);
        }
        
        private static void Cooldown(string[] param)
        {
            if (param.Length <= 0)
            {
                World.Player.SendMessage(MsgLevel.Error, "You must enter a name and seconds.");
                return;
            }

            if (param[0].Equals("test"))
            {
                CooldownManager.AddCooldown("Test 1", 25, 0, 0);
                CooldownManager.AddCooldown("Test 2", 20, 0, 0);
                CooldownManager.AddCooldown("Test 3", 18, 0, 0);
                CooldownManager.AddCooldown("Bandage 1", 10, 0, 30037);
                CooldownManager.AddCooldown("Attack 1", 20, 0, 0);
                CooldownManager.AddCooldown("Hue 23", 10, 23, 30051);
                CooldownManager.AddCooldown("Hue 94", 18, 94, 0);
                CooldownManager.AddCooldown("Hue 243", 12, 243, 30042);
                CooldownManager.AddCooldown("Stay 1", 18, 0, 0, 0, true);
                CooldownManager.AddCooldown("Stay 2", 12, 0, 30044, 0, true);
                CooldownManager.AddCooldown("Stay 3", 6, 0, 0, 0, true);
                CooldownManager.AddCooldown("Sound 1", 7, 0, 30037, 61);
                CooldownManager.AddCooldown("Sound 2", 20, 0, 0, 61);
                CooldownManager.AddCooldown("Hue 23 1", 22, 23, 30051);
                CooldownManager.AddCooldown("Hue 94 2", 25, 94, 0);
                CooldownManager.AddCooldown("Hue 243 3", 12, 243, 30042);
                CooldownManager.AddCooldown("Test 7", 25, 0, 0);
                CooldownManager.AddCooldown("Test 8", 9, 0, 30037);
                CooldownManager.AddCooldown("Test 9", 5, 0, 0);
            }
            else
            {
                CooldownManager.AddCooldown(param[0], Convert.ToInt32(param[1]));    
            }
            
        }
        
        private static void PlaySound(string[] param)
        {
            if (param.Length <= 0)
            {
                World.Player.SendMessage(MsgLevel.Error, "You must enter sound id.");
                return;
            }

            Client.Instance.SendToClient(new PlaySound(Utility.ToInt32(param[0], 0)));
        }

        private static void ClassicUoProfile(string[] param)
        {
            if (string.IsNullOrEmpty(param[0]))
            {
                World.Player.SendMessage(MsgLevel.Error, "You must include a valid ClassicUO profile setting. Type `>cuo list` for a list of valid settings.");
                return;
            }

            if (param[0].Equals("list"))
            {
                string[] props = ClassicUOManager.GetAllProperties().ToArray();

                for (var i = 0; i < (float)props.Length / 40; i++)
                {
                    World.Player.SendMessage(MsgLevel.Info, string.Join(", ", props.Skip(i * 40).Take(40)));
                }

                return;
            }

            string property = ClassicUOManager.IsValidProperty(param[0]);

            if (string.IsNullOrEmpty(property))
            {
                World.Player.SendMessage("Unknown ClassicUO setting/property. Type `>cuo list` for a list of valid settings.");
                return;
            }

            bool isNumeric = int.TryParse(param[1], out var value);

            if (isNumeric)
            {
                ClassicUOManager.ProfilePropertySet(property, value);
            }
            else
            {
                switch (param[1])
                {
                    case "true":
                        ClassicUOManager.ProfilePropertySet(property, true);
                        break;
                    case "false":
                        ClassicUOManager.ProfilePropertySet(property, false);
                        break;
                    default:
                        ClassicUOManager.ProfilePropertySet(property, param[1]);
                        break;
                }
            }

            World.Player.SendMessage($"ClassicUO Setting: '{property}' set to '{param[1]}'");
        }

        private static void ShowBuyGump(string[] param)
        {
            if (string.IsNullOrEmpty(param[0]))
            {
                World.Player.SendMessage(MsgLevel.Error, "You must include an id or alias");
                return;
            }

            if (int.TryParse(param[0], out int agentIndex))
            {
                BuyAgent agent = BuyAgent.Agents[agentIndex - 1];

                AgentsGump gump = new AgentsGump(agent);
                gump.SendGump();
            }
            else
            {
                foreach (BuyAgent agent in BuyAgent.Agents)
                {
                    if (agent.Alias.Equals(param[0], StringComparison.OrdinalIgnoreCase))
                    {
                        AgentsGump gump = new AgentsGump(agent);
                        gump.SendGump();

                        break;
                    }
                }
            }
        }

        private static void ShowOrgGump(string[] param)
        {
            if (string.IsNullOrEmpty(param[0]))
            {
                World.Player.SendMessage(MsgLevel.Error, "You must include an id or alias");
                return;
            }

            if (int.TryParse(param[0], out int agentIndex))
            {
                OrganizerAgent agent = OrganizerAgent.Agents[agentIndex - 1];

                AgentsGump gump = new AgentsGump(agent);
                gump.SendGump();
            }
            else
            {
                foreach (OrganizerAgent agent in OrganizerAgent.Agents)
                {
                    if (agent.Alias.Equals(param[0], StringComparison.OrdinalIgnoreCase))
                    {
                        AgentsGump gump = new AgentsGump(agent);
                        gump.SendGump();

                        break;
                    }
                }
            }
        }

        private static void ShowRestockGump(string[] param)
        {
            if (string.IsNullOrEmpty(param[0]))
            {
                World.Player.SendMessage(MsgLevel.Error, "You must include an id or alias");
                return;
            }

            if (int.TryParse(param[0], out int agentIndex))
            {
                RestockAgent agent = RestockAgent.Agents[agentIndex - 1];

                AgentsGump gump = new AgentsGump(agent);
                gump.SendGump();
            }
            else
            {
                foreach (RestockAgent agent in RestockAgent.Agents)
                {
                    if (agent.Alias.Equals(param[0], StringComparison.OrdinalIgnoreCase))
                    {
                        AgentsGump gump = new AgentsGump(agent);
                        gump.SendGump();

                        break;
                    }
                }
            }
        }

        private static void ShowUsableSkills(string[] param)
        {
            World.Player.SendMessage(MsgLevel.Info, $"Usable skills: {string.Join(", ", Skills.GetUsableSkillNames())}");
        }

        private static void GetSystemMessages(string[] param)
        {
            SystemMessagesGump gump = new SystemMessagesGump();
            gump.SendGump();            
        }

        private static void ShowHotKeyGump(string[] param)
        {
            HotKeyGump gump = new HotKeyGump(true, true, true);
            gump.SendGump();
        }

        private static void ShowBoatControlGump(string[] param)
        {
            BoatControlGump gump = new BoatControlGump(0);
            gump.SendGump();
        }

        private static void CreateGump(string[] param)
        {
            StringBuilder message = new StringBuilder();
            message.AppendLine("Razor");
            message.AppendLine();
            message.AppendLine("Another message");

            TestMessageGump gump =
                new TestMessageGump(message.ToString());
            gump.SendGump();
        }

        private static DateTime m_LastSync;
        private static string _lastMacroVariable;

        private static void Resync(string[] param)
        {
            if (DateTime.UtcNow - m_LastSync > TimeSpan.FromSeconds(1.0))
            {
                m_LastSync = DateTime.UtcNow;

                Client.Instance.SendToClient(new UnicodeMessage(0xFFFFFFFF, -1, MessageType.Regular, 0x3B2, 3,
                    Language.CliLocName, "System", "Updating and resyncing with server"));

                Client.Instance.SendToServer(new ResyncReq());
            }
        }

        private static void DamageTrackerReport(string[] param)
        {
            if (DamageTracker.Running)
                DamageTracker.SendReport();
        }

        private static void Track(string[] param)
        {
            try
            {
                if (param[0].Equals("off"))
                {
                    WaypointManager.ClearWaypoint();
                    return;
                }

                WaypointManager.Waypoint waypoint = new WaypointManager.Waypoint
                {
                    Name = "N/A",
                    X = Convert.ToUInt16(param[0]),
                    Y = Convert.ToUInt16(param[1])
                };

                WaypointManager.ShowWaypoint(waypoint);
            }
            catch
            {
                WaypointManager.ClearWaypoint();
            }
        }

        private static void SetMacroVariable(string[] param)
        {
            if (MacroManager.Playing || MacroManager.Recording || World.Player == null)
                return;

            if (string.IsNullOrEmpty(param[0]))
            {
                World.Player.SendMessage(MsgLevel.Error, "You must pass in a macro variable name.");
                return;
            }

            _lastMacroVariable = param[0];

            Targeting.OneTimeTarget(OnMacroVariableAddTarget);
            World.Player.SendMessage(MsgLevel.Force, $"Select new target for '{_lastMacroVariable}'");
        }

        private static void OnMacroVariableAddTarget(bool ground, Serial serial, Point3D pt, ushort gfx)
        {
            TargetInfo t = new TargetInfo
            {
                Gfx = gfx,
                Serial = serial,
                Type = (byte) (ground ? 1 : 0),
                X = pt.X,
                Y = pt.Y,
                Z = pt.Z
            };

            bool foundVar = false;

            foreach (MacroVariables.MacroVariable mV in MacroVariables.MacroVariableList
            )
            {
                if (mV.Name.ToLower().Equals(_lastMacroVariable.ToLower()))
                {
                    foundVar = true;
                    // macro exists, update
                    mV.TargetInfo = t;

                    World.Player.SendMessage(MsgLevel.Force, $"'{mV.Name}' macro variable updated to '{t.Serial}'");

                    break;
                }
            }

            if (!foundVar)
            {
                MacroVariables.MacroVariableList.Add(new MacroVariables.MacroVariable(_lastMacroVariable, t));
                World.Player.SendMessage(MsgLevel.Force,
                    $"'{_lastMacroVariable}' not found, created variable and set to '{t.Serial}'");
            }

            // Save and reload the macros and vars
            Engine.MainWindow.SaveMacroVariables();
        }

        private static void SetWeather(string[] param)
        {
            Client.Instance.SendToClient(new UnicodeMessage(0xFFFFFFFF, -1, MessageType.Regular, 0x3B2, 3,
                Language.CliLocName, "System", "Setting weather.."));

            Client.Instance.SendToClient(new SetWeather(Convert.ToInt32(param[0]), Convert.ToInt32(param[1])));
        }

        private static void SetSeason(string[] param)
        {
            Client.Instance.SendToClient(new UnicodeMessage(0xFFFFFFFF, -1, MessageType.Regular, 0x3B2, 3,
                Language.CliLocName, "System", "Setting season.."));

            Client.Instance.ForceSendToClient(new SeasonChange(Convert.ToInt32(param[0]), true));
        }

        private static void GetGumpInfo(string[] param)
        {
            ScriptManager.GetGumpInfo(param);
        }

        private static void GetItemHue(string[] param)
        {
            Targeting.OneTimeTarget(OnGetItemHueTarget);
            Client.Instance.SendToClient(new UnicodeMessage(0xFFFFFFFF, -1, MessageType.Regular, 0x3B2, 3,
                Language.CliLocName, "System", "Select an item to get the hue value"));
        }

        private static void OnGetItemHueTarget(bool ground, Serial serial, Point3D pt, ushort gfx)
        {
            Item item = World.FindItem(serial);
            if (item != null)
            {
                Client.Instance.SendToClient(new UnicodeMessage(0xFFFFFFFF, -1, MessageType.Regular, 0x3B2, 3,
                    Language.CliLocName, "System",
                    $"Item Name: '{item.ItemID.ItemData.Name}' Serial: '{item.Serial}' Id: '{item.ItemID.Value}' Hue: '{item.Hue}'"));
            }
        }

        private static void GetMobile(string[] param)
        {
            ScriptManager.GetGumpInfo(param);
        }

        private static void Echo(string[] param)
        {
            StringBuilder sb = new StringBuilder("Note To Self: ");
            for (int i = 0; i < param.Length; i++)
                sb.Append(param[i]);
            Client.Instance.SendToClient(new UnicodeMessage(0xFFFFFFFF, -1, MessageType.Regular, 0x3B2, 3,
                Language.CliLocName, "System", sb.ToString()));
        }

        private static void AddUseOnce(string[] param)
        {
            string use = Language.GetString(LocString.UseOnce);
            for (int i = 0; i < Agent.List.Count; i++)
            {
                Agent a = Agent.List[i];
                if (a.Name == use)
                {
                    a.OnButtonPress(1);
                    break;
                }
            }
        }

        private static void Time(string[] param)
        {
            World.Player.SendMessage(MsgLevel.Force, LocString.CurTime,
                Engine.MistedDateTime.ToString("MM/dd/yy HH:mm:ss.f"));
        }

        private static void Where(string[] param)
        {
            string mapStr;
            switch (World.Player.Map)
            {
                case 0:
                    mapStr = "Felucca";
                    break;
                case 1:
                    mapStr = "Trammel";
                    break;
                case 2:
                    mapStr = "Ilshenar";
                    break;
                case 3:
                    mapStr = "Malas";
                    break;
                case 4:
                    mapStr = "Tokuno";
                    break;
                case 0x7F:
                    mapStr = "Internal";
                    break;
                default:
                    mapStr = $"Unknown (#{World.Player.Map})";
                    break;
            }

            World.Player.SendMessage(MsgLevel.Force, LocString.CurLoc, World.Player.Position, mapStr);
        }

        private static void Ping(string[] param)
        {
            int count = 5;
            if (param.Length > 0)
                count = Utility.ToInt32(param[0], 5);

            if (count > 10)
                count = 10;

            Assistant.Ping.StartPing(count);
        }

        private static void MacroCmd(string[] param)
        {
            if (param.Length <= 0)
            {
                World.Player.SendMessage("You must enter a macro name.");
                return;
            }

            string macroName = string.Join(" ", param);

            foreach (Macro m in MacroManager.List)
            {
                if (m.ToString().ToLower().Equals(macroName.ToLower()))
                {
                    MacroManager.HotKeyPlay(m);
                    break;
                }
            }
        }

        private static void ScriptCmd(string[] param)
        {
            if (param.Length <= 0)
            {
                World.Player.SendMessage("You must enter a script name.");
                return;
            }

            string name = string.Join(" ", param);

            ScriptManager.PlayScript(name);
        }
    }

    public delegate void CommandCallback(string[] param);

    public class Command
    {
        private static Dictionary<string, CommandCallback> _commandList;

        public static List<string> GetCommands => _commandList.Keys.ToList();

        static Command()
        {
            _commandList = new Dictionary<string, CommandCallback>(16, StringComparer.OrdinalIgnoreCase);
            PacketHandler.RegisterClientToServerFilter(0xAD, OnSpeech);
        }

        public static void ListCommands(string[] param)
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder();
            foreach (string cmd in _commandList.Keys)
            {
                sb.Append(cmd);
                sb.Append(" ");
            }

            World.Player.SendMessage(MsgLevel.Force, LocString.CommandList);
            World.Player.SendMessage(MsgLevel.Force, sb.ToString());
        }

        public static void Register(string cmd, CommandCallback callback)
        {
            _commandList[cmd] = callback;
        }

        public static CommandCallback FindCommand(string cmd)
        {
            return _commandList[cmd] as CommandCallback;
        }

        public static void RemoveCommand(string cmd)
        {
            _commandList.Remove(cmd);
        }

        public static Dictionary<string, CommandCallback> List
        {
            get { return _commandList; }
        }

        public static void OnSpeech(Packet pvSrc, PacketHandlerEventArgs args)
        {
            MessageType type = (MessageType) pvSrc.ReadByte();
            ushort hue = pvSrc.ReadUInt16();
            ushort font = pvSrc.ReadUInt16();
            string lang = pvSrc.ReadString(4);
            string text = "";
            ArrayList keys = null;
            long txtOffset = 0;

            World.Player.SpeechHue = hue;

            if ((type & MessageType.Encoded) != 0)
            {
                int value = pvSrc.ReadInt16();
                int count = (value & 0xFFF0) >> 4;
                keys = new ArrayList();
                keys.Add((ushort) value);

                for (int i = 0; i < count; ++i)
                {
                    if ((i & 1) == 0)
                    {
                        keys.Add(pvSrc.ReadByte());
                    }
                    else
                    {
                        keys.Add(pvSrc.ReadByte());
                        keys.Add(pvSrc.ReadByte());
                    }
                }

                txtOffset = pvSrc.Position;
                text = pvSrc.ReadUTF8StringSafe();
                type &= ~MessageType.Encoded;
            }
            else
            {
                txtOffset = pvSrc.Position;
                text = pvSrc.ReadUnicodeStringSafe();
            }

            text = text.Trim();

            char commandToggle = Client.IsOSI ? '-' : '>';

            if (text.Length > 0)
            {
                if (text[0] != commandToggle)
                {
                    Macros.MacroManager.Action(new Macros.SpeechAction(type, hue, font, lang, keys, text));
                    ScriptManager.AddToScript($"say \'{text}\'");
                }
                else
                {
                    text = text.Substring(1);
                    string[] split = text.Split(' ', '\t');

                    if (_commandList.ContainsKey(split[0]))
                    {
                        CommandCallback call = (CommandCallback) _commandList[split[0]];

                        if (call != null)
                        {
                            string[] param = new string[split.Length - 1];
                            for (int i = 0; i < param.Length; i++)
                                param[i] = split[i + 1];
                            call(param);

                            args.Block = true;
                        }
                    }
                    else if (HotKey.ExecuteCommand(split[0]))
                    {
                        args.Block = true;
                    }
                    else
                    {
                        World.Player.SendMessage(MsgLevel.Force, "Unknown command");
                    }
                }
            }
        }
    }
}

================================================
FILE: Razor/Core/ContainerLabels.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.Xml;

namespace Assistant.Core
{
    public class ContainerLabels
    {
        public class ContainerLabel
        {
            public string Id { get; set; }
            public string Type { get; set; }
            public string Label { get; set; }
            public int Hue { get; set; }
            public string Alias { get; set; }
        }

        public static Serial LastContainerLabelDisplayed;

        public static List<ContainerLabel> ContainerLabelList = new List<ContainerLabel>();

        public static void Save(XmlTextWriter xml)
        {
            foreach (var label in ContainerLabelList)
            {
                xml.WriteStartElement("containerlabel");
                xml.WriteAttributeString("id", label.Id);
                xml.WriteAttributeString("type", label.Type);
                xml.WriteAttributeString("label", label.Label);
                xml.WriteAttributeString("hue", label.Hue.ToString());
                xml.WriteAttributeString("alias", label.Alias);
                xml.WriteEndElement();
            }
        }

        public static void Load(XmlElement node)
        {
            ClearAll();

            try
            {
                foreach (XmlElement el in node.GetElementsByTagName("containerlabel"))
                {
                    ContainerLabel label = new ContainerLabel
                    {
                        Id = el.GetAttribute("id"),
                        Type = el.GetAttribute("type"),
                        Label = el.GetAttribute("label"),
                        Hue = Convert.ToInt32(el.GetAttribute("hue")),
                        Alias = el.GetAttribute("alias")
                    };

                    ContainerLabelList.Add(label);
                }
            }
            catch
            {
                // ignored
            }
            
            MessageManager.OnLabelMessage += HandleLabelMessage;
        }
        
        private static void HandleLabelMessage(Packet p, PacketHandlerEventArgs args, Serial source, ushort graphic,
                         MessageType type, ushort hue, ushort font, string lang, string sourceName,
                         string text)
        {
            if (Config.GetBool("ShowContainerLabels") && source.IsItem)
            {
                Item item = World.FindItem(source);

                if (item == null || !item.IsContainer)
                    return;

                foreach (ContainerLabel label in ContainerLabelList)
                {
                    // Check if its the serial match and if the text matches the name (since we override that for the label)
                    if (Serial.Parse(label.Id) == source &&
                        (item.ItemID.ItemData.Name.Equals(text) ||
                         label.Alias.Equals(text, StringComparison.OrdinalIgnoreCase)))
                    {
                        string labelDisplay =
                            $"{Config.GetString("ContainerLabelFormat").Replace("{label}", label.Label).Replace("{type}", text)}";

                        //ContainerLabelStyle
                        if (Config.GetInt("ContainerLabelStyle") == 0)
                        {
                            Client.Instance.SendToClient(new AsciiMessage(source, item.ItemID.Value, MessageType.Label,
                                label.Hue, 3, Language.CliLocName, labelDisplay));
                        }
                        else
                        {
                            Client.Instance.SendToClient(new UnicodeMessage(source, item.ItemID.Value,
                                MessageType.Label, label.Hue, 3, Language.CliLocName, "", labelDisplay));
                        }

                        // block the actual message from coming through since we have it in the label
                        args.Block = true;

                        LastContainerLabelDisplayed = source;

                        break;
                    }
                }
            }
        }

        public static void ClearAll()
        {
            ContainerLabelList.Clear();
        }
    }
}

================================================
FILE: Razor/Core/CooldownManager.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using Assistant.Gumps.Internal;

namespace Assistant.Core
{
    public static class CooldownManager
    {
        private static Timer CooldownTimer { get; set; }
        public static Dictionary<string, Cooldown> Cooldowns { get; private set; }

        private static CooldownGump _gump;

        public static void Initialize()
        {
            CooldownTimer = new InternalTimer();
            Cooldowns = new Dictionary<string, Cooldown>();
        }

        public static bool Running => CooldownTimer.Running;

        public static void Start()
        {
            if (CooldownTimer.Running)
            {
                CooldownTimer.Stop();
            }

            CooldownTimer.Start();
        }

        public static void Stop()
        {
            if (!CooldownTimer.Running)
                return;

            _gump.CloseGump();
            Cooldowns.Clear();

            CooldownTimer.Stop();
        }

        private class InternalTimer : Timer
        {
            public InternalTimer() : base(TimeSpan.FromSeconds(0), TimeSpan.FromSeconds(1))
            {
            }

            protected override void OnTick()
            {
                if (World.Player == null)
                {
                    CooldownTimer.Stop();
                    return;
                }

                _gump?.CloseGump();
                
                RemoveExpired();
                
                if (Cooldowns.Count > 0)
                {
                    _gump = new CooldownGump();
                    _gump.SendGump();    
                }
            }
        }

        public static void AddCooldown(Cooldown cooldown)
        {
            Cooldowns[cooldown.Name] = cooldown;

            if (!CooldownTimer.Running)
            {
                Start();
            }
        }

        public static void AddCooldown(string name, int seconds, int hue = 0, int icon = 0, int sound = 0, bool stayVisible = false)
        {
            Cooldowns[name] = new Cooldown
            {
                Name = name,
                Seconds = seconds,
                EndTime = DateTime.UtcNow.AddSeconds(seconds),
                Hue = hue,
                Icon = icon,
                SoundId = sound,
                StayVisible = stayVisible
            };

            if (!CooldownTimer.Running)
            {
                Start();
            }
        }

        public static void RemoveExpired()
        {
            foreach (KeyValuePair<string, Cooldown> cooldown in Cooldowns.ToList())
            {
                if (cooldown.Value.StayVisible)
                {
                    continue;
                }
                
                TimeSpan diff = cooldown.Value.EndTime - DateTime.UtcNow;
                int timeLeft = (int)diff.TotalSeconds;

                if (timeLeft <= 0)
                {
                    if (cooldown.Value.SoundId > 0)
                    {
                        Client.Instance.SendToClient(new PlaySound(cooldown.Value.SoundId));
                    }
                    
                    Cooldowns.Remove(cooldown.Key);
                }
            }
        }
        
    }

    public class Cooldown
    {
        public string Name { get; set; }
        public int Seconds { get; set; }
        public DateTime EndTime { get; set; }
        public int Hue { get; set; }
        public int Icon { get; set; } //30010 - 30057
        public int SoundId { get; set; }
        public bool StayVisible { get; set; }
        public Color ForegroundColor { get; set; }
        public Color BackgroundColor { get; set; }

    }
}

================================================
FILE: Razor/Core/Counters.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.IO;
using System.Text;
using System.Collections;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Xml;
using Assistant.UI;

namespace Assistant
{
    public class CounterLVIComparer : IComparer
    {
        private static CounterLVIComparer m_Instance;

        public static CounterLVIComparer Instance
        {
            get
            {
                if (m_Instance == null)
                    m_Instance = new CounterLVIComparer();
                return m_Instance;
            }
        }

        public CounterLVIComparer()
        {
        }

        public int Compare(object a, object b)
        {
            return ((IComparable) (((ListViewItem) a).Tag)).CompareTo(((ListViewItem) b).Tag);
        }
    }

    public class ItemCountCache
    {
        private Dictionary<Item, ulong> _cache = new Dictionary<Item, ulong>();

        public long Add(Item item)
        {
            if (_cache.TryGetValue(item, out var old))
            {
                var diff = item.Amount - old;
                _cache[item] = item.Amount;
                return (long)diff;
            }
            else
            {
                _cache.Add(item, item.Amount);
                return item.Amount;
            }
        }

        public long Remove(Item item)
        {
            if (_cache.TryGetValue(item, out var old))
            {
                var diff = Math.Min(item.Amount, old);
                _cache.Remove(item);
                return -(long)diff;
            }

            // Item was untracked in the first place, hence no change
            return 0;
        }

        public void Reset()
        {
            _cache.Clear();
        }
    }

    public struct CounterID
    {
        public CounterID(ItemID itemID, ushort hue = 0xFFFF)
        {
            ItemID = itemID;
            Hue = hue;
        }

        public ItemID ItemID;
        public ushort Hue;
    }

    public class CounterChangeSet
    {
        public Dictionary<CounterID, long> Changes = new Dictionary<CounterID, long>();

        private void AddValue(CounterID id, long diff)
        {
            if (Changes.ContainsKey(id))
            {
                Changes[id] += diff;
            }
            else
            {
                Changes.Add(id, diff);
            }

            if (Changes[id] == 0)
            {
                Changes.Remove(id);
            }
        }

        public void Add(CounterChangeSet other)
        {
            foreach (var item in other.Changes)
            {
                AddValue(item.Key, item.Value);
            }
        }

        public void Add(Item item, long diff)
        {
            AddValue(new CounterID(item.ItemID, item.Hue), diff);
            AddValue(new CounterID(item.ItemID), diff);
        }

        public void Reset()
        {
            Changes.Clear();
        }
    }

    public class ItemChangeTracker
    {
        private ItemCountCache _cache = new ItemCountCache();

        public void Add(Item item, ref CounterChangeSet changes)
        {
            var diff = _cache.Add(item);
            if (diff != 0)
            {
                changes.Add(item, diff);
            }
        }

        public void Remove(Item item, ref CounterChangeSet changes)
        {
            var diff = _cache.Remove(item);
            if (diff != 0)
            {
                changes.Add(item, diff);
            }
        }

        public void Reset()
        {
            _cache.Reset();
        }
    }

    public class RecursiveItemChangeTracker
    {
        private ItemChangeTracker _tracker = new ItemChangeTracker();

        public void Add(Item item, ref CounterChangeSet changes)
        {
            _tracker.Add(item, ref changes);

            foreach (var child in item.Contains)
            {
                Add(child, ref changes);
            }
        }

        public void Remove(Item item, ref CounterChangeSet changes)
        {
            foreach (var child in item.Contains)
            {
                Remove(child, ref changes);
            }

            _tracker.Remove(item, ref changes);
        }

        public void Reset()
        {
            _tracker.Reset();
        }
    }

    public class ItemTypeCounter
    {
        private CounterChangeSet _counters = new CounterChangeSet();
        private RecursiveItemChangeTracker _tracker = new RecursiveItemChangeTracker();

        public CounterChangeSet Count(Item item)
        {
            var changes = new CounterChangeSet();
            _tracker.Add(item, ref changes);
            _counters.Add(changes);
            return changes;
        }

        public CounterChangeSet Uncount(Item item)
        {
            var changes = new CounterChangeSet();
            _tracker.Remove(item, ref changes);
            _counters.Add(changes);
            return changes;
        }

        public ulong GetValue(ItemID itemID, ushort hue)
        {
            return GetValue(new CounterID(itemID, hue));
        }

        public ulong GetValue(CounterID id)
        {
            if (_counters.Changes.TryGetValue(id, out var value))
            {
                return (value > 0) ? (ulong)value : 0;
            }

            return 0;
        }

        public void Reset()
        {
            _counters.Reset();
            _tracker.Reset();
        }
    }

    public class Counter : IComparable
    {
        private string m_Name;
        private string m_Fmt;
        private ushort m_ItemID;
        private int m_Hue;
        private int m_Count;
        private bool m_Enabled;
        private DateTime m_LastWarning;
        private bool m_Flag;
        private bool m_DispImg;
        private ListViewItem m_LVI;

        public Counter(string name, string fmt, ushort iid, int hue, bool dispImg)
        {
            m_Name = name;
            m_Fmt = fmt;
            m_ItemID = iid;
            m_Hue = hue;
            m_LVI = new ListViewItem(new string[2]);
            m_LVI.SubItems[0].Text = ToString();
            m_LVI.Tag = this;
            m_LVI.Checked = m_Enabled = false;
            m_Count = 0;
            m_DispImg = dispImg;

            m_NeedXMLSave = true;
        }

        public Counter(XmlElement node)
        {
            m_Name = GetText(node["name"], "");
            m_Fmt = GetText(node["format"], "");
            m_ItemID = (ushort) GetInt(GetText(node["itemid"], "0"), 0);
            m_Hue = GetInt(GetText(node["hue"], "-1"), -1);

            m_LVI = new ListViewItem(new string[2] {this.ToString(), ""});
            m_LVI.Tag = this;
            m_LVI.Checked = m_Enabled = false;

            m_DispImg = true;
        }

        public void Save(XmlTextWriter xml)
        {
            xml.WriteStartElement("counter");

            xml.WriteStartElement("name");
            xml.WriteString(m_Name);
            xml.WriteEndElement();

            xml.WriteStartElement("format");
            xml.WriteString(m_Fmt);
            xml.WriteEndElement();

            xml.WriteStartElement("itemid");
            xml.WriteString(m_ItemID.ToString());
            xml.WriteEndElement();

            xml.WriteStartElement("hue");
            xml.WriteString(m_Hue.ToString());
            xml.WriteEndElement();

            xml.WriteEndElement();
        }

        public string Name
        {
            get { return m_Name; }
        }

        public string Format
        {
            get { return m_Fmt; }
        }

        public ushort ItemID
        {
            get { return m_ItemID; }
        }

        public int Hue
        {
            get { return m_Hue; }
        }

        public bool Flag
        {
            get { return m_Flag; }
            set { m_Flag = value; }
        }

        public ListViewItem ViewItem
        {
            get { return m_LVI; }
        }

        public void Set(ushort iid, int hue, string name, string fmt, bool dispImg)
        {
            m_ItemID = iid;
            m_Hue = hue;
            m_Name = name;
            m_Fmt = fmt;
            m_DispImg = dispImg;

            m_LVI.SubItems[0].Text = ToString();
            m_NeedXMLSave = true;
        }

        public string GetTitlebarString(bool dispImg, bool dispColor)
        {
            StringBuilder sb = new StringBuilder();
            if (dispImg)
            {
                sb.AppendFormat("~I{0:X4}", m_ItemID);
                if (m_Hue > 0 && m_Hue < 0xFFFF)
                    sb.Append(m_Hue.ToString("X4"));
                else
                    sb.Append('~');
                sb.Append(": ");
            }

            if (!dispColor)
                sb.Append(m_Count.ToString());
            else if (m_Flag && Config.GetBool("HighlightReagents"))
                sb.AppendFormat("~^C00000{0}~#~", m_Count);
            else if (m_Count == 0 || m_Count < Config.GetInt("CounterWarnAmount"))
                sb.AppendFormat("~#FF0000{0}~#~", m_Count);
            else
                sb.Append(m_Count.ToString());

            return sb.ToString();
        }

        public CounterID CounterID
        {
            get
            {
                return new CounterID(ItemID, (ushort)((Hue == -1) ? 0xFFFF : Hue));
            }
        }

        public static int GetCount(ItemID itemID, int hue)
        {
            ushort fixedHue = (ushort)((hue == -1) ? 0xFFFF : hue);
            return (int)m_PackCounter.GetValue(itemID, fixedHue);
        }

        public static Counter FindCounter(string name)
        {
            foreach (Counter c in List)
            {
                if (c.Name.Equals(name, StringComparison.OrdinalIgnoreCase))
                {
                    return c.Enabled ? c : null;
                }
            }

            return null;
        }
        
        private void OnUpdate()
        {
            var newValue = (int)m_PackCounter.GetValue(CounterID);
            if (m_Count != newValue)
            {
                if (m_Enabled)
                {
                    if (!SupressWarnings && m_LastWarning + TimeSpan.FromSeconds(1.0) < DateTime.UtcNow &&
                        World.Player != null && newValue < m_Count && Config.GetBool("CounterWarn") &&
                        newValue < Config.GetInt("CounterWarnAmount"))
                    {
                        World.Player.SendMessage(MsgLevel.Warning, LocString.CountLow, Name, newValue);
                        m_LastWarning = DateTime.UtcNow;
                    }

                    if (UOAssist.NotificationCount > 0)
                    {
                        int wp = 0;
                        if (Format == "bm")
                            wp = 1;
                        else if (Format == "bp")
                            wp = 2;
                        else if (Format == "gl")
                            wp = 3;
                        else if (Format == "gs")
                            wp = 4;
                        else if (Format == "mr")
                            wp = 5;
                        else if (Format == "ns")
                            wp = 6;
                        else if (Format == "sa")
                            wp = 7;
                        else if (Format == "ss")
                            wp = 8;
                        else if (Format == "bw")
                            wp = 100;
                        else if (Format == "db")
                            wp = 101;
                        else if (Format == "gd")
                            wp = 102;
                        else if (Format == "nc")
                            wp = 103;
                        else if (Format == "pi")
                            wp = 104;

                        if (wp != 0)
                            UOAssist.PostCounterUpdate(wp, newValue);
                    }

                    m_Count = newValue;
                    if (m_Count < 0)
                        m_Count = 0;

                    //Engine.MainWindow.RefreshCounters();
                    Client.Instance.RequestTitlebarUpdate();
                }

                m_LVI.SubItems[1].Text = m_Count.ToString();
            }
        }

        public int Amount
        {
            get => m_Count;
        }

        public void SetEnabled(bool value)
        {
            m_Enabled = value;
            if (m_Enabled)
            {
                if (!SupressChecks)
                    QuickRecount();
                m_LVI.SubItems[1].Text = m_Count.ToString();
            }
            else
            {
                m_LVI.SubItems[1].Text = "";
            }
        }

        public bool Enabled
        {
            get { return m_Enabled; }
            set
            {
                if (m_Enabled != value)
                {
                    m_LVI.Checked = value;
                    SetEnabled(value);
                }
            }
        }

        public bool DisplayImage
        {
            get { return m_DispImg; }
            set { m_DispImg = value; }
        }

        public int CompareTo(object comp)
        {
            if (!(comp is Counter))
                return 1;
            else if (this.Enabled && ((Counter) comp).Enabled)
                return this.Name == null ? 1 :
                    ((Counter) comp).Name == null ? -1 : this.Name.CompareTo(((Counter) comp).Name);
            else if (!this.Enabled && ((Counter) comp).Enabled)
                return 1;
            else if (this.Enabled && !((Counter) comp).Enabled)
                return -1;
            else //if ( !this.Enabled && !((Counter)comp).Enabled )
                return this.Name == null ? 1 :
                    ((Counter) comp).Name == null ? -1 : this.Name.CompareTo(((Counter) comp).Name);
        }

        public override string ToString()
        {
            return $"{Name} ({Format})";
        }

        private static bool m_NeedXMLSave = false;
        private static List<Counter> m_List = new List<Counter>();
        private static bool m_SupressWarn, m_SupressChecks;
        private static ItemTypeCounter m_PackCounter = new ItemTypeCounter();

        public static List<Counter> List
        {
            get { return m_List; }
        }

        static Counter()
        {
            m_List = new List<Counter>();
            Load();
        }

        public static bool SupressWarnings
        {
            get { return m_SupressWarn; }
            set { m_SupressWarn = value; }
        }

        public static bool SupressChecks
        {
            get { return m_SupressChecks; }
        }

        private static void Load()
        {
            string file = Path.Combine(Config.GetUserDirectory(), "counters.xml");
            if (!File.Exists(file))
                return;

            try
            {
                XmlDocument doc = new XmlDocument();
                doc.Load(file);

                XmlElement root = doc["counters"];
                if (root != null)
                {
                    foreach (XmlElement node in root.GetElementsByTagName("counter"))
                        m_List.Add(new Counter(node));
                }
            }
            catch
            {
                MessageBox.Show(Engine.ActiveWindow, Language.GetString(LocString.CounterFux),
                    "Counters.xml Load Error", MessageBoxButtons.OK, MessageBoxIcon.Stop);
            }

            m_NeedXMLSave = false;
        }

        public static void Save()
        {
            if (!m_NeedXMLSave)
                return;

            try
            {
                string file = Path.Combine(Config.GetUserDirectory(), "counters.xml");
                using (StreamWriter op = new StreamWriter(file))
                {
                    XmlTextWriter xml = new XmlTextWriter(op);

                    xml.Formatting = Formatting.Indented;
                    xml.IndentChar = '\t';
                    xml.Indentation = 1;

                    xml.WriteStartDocument(true);

                    xml.WriteStartElement("counters");

                    foreach (Counter c in m_List)
                        c.Save(xml);

                    xml.WriteEndElement();
                    xml.Close();
                }

                m_NeedXMLSave = false;
            }
            catch
            {
            }
        }

        public static void SaveProfile(XmlTextWriter xml)
        {
            for (int i = 0; i < m_List.Count; i++)
            {
                Counter c = m_List[i];
                if (c.Enabled)
                {
                    xml.WriteStartElement("counter");
                    xml.WriteAttributeString("name", c.Name);
                    xml.WriteAttributeString("enabled", c.Enabled.ToString());
                    xml.WriteAttributeString("image", c.DisplayImage.ToString());
                    xml.WriteEndElement();
                }
            }
        }

        public static void Default()
        {
            for (int i = 0; i < m_List.Count; i++)
            {
                Counter c = m_List[i];

                if (c.Format == "bp" || c.Format == "bm" || c.Format == "gl" || c.Format == "gs" ||
                    c.Format == "mr" || c.Format == "ns" || c.Format == "ss" || c.Format == "sa" ||
                    c.Format == "aids")
                {
                    c.Enabled = true;
                }
            }
        }

        public static void DisableAll()
        {
            for (int i = 0; i < m_List.Count; i++)
                m_List[i].Enabled = false;
        }

        public static void LoadProfile(XmlElement xml)
        {
            Reset();
            DisableAll();

            if (xml == null)
                return;

            foreach (XmlElement el in xml.GetElementsByTagName("counter"))
            {
                try
                {
                    string name = el.GetAttribute("name");
                    string en = el.GetAttribute("enabled");
                    string img = el.GetAttribute("image");

                    for (int i = 0; i < m_List.Count; i++)
                    {
                        Counter c = m_List[i];

                        if (c.Name == name)
                        {
                            c.Enabled = Convert.ToBoolean(en);
                            try
                            {
                                c.DisplayImage = Convert.ToBoolean(img);
                            }
                            catch
                            {
                                c.DisplayImage = true;
                            }

                            break;
                        }
                    }
                }
                catch
                {
                }
            }
        }

        private static string GetText(XmlElement node, string defaultValue)
        {
            if (node == null)
                return defaultValue;

            return node.InnerText;
        }

        private static int GetInt(string value, int def)
        {
            try
            {
                return XmlConvert.ToInt32(value);
            }
            catch
            {
                try
                {
                    return Convert.ToInt32(value);
                }
                catch
                {
                    return def;
                }
            }
        }

        public static void Register(Counter c)
        {
            m_List.Add(c);
            m_NeedXMLSave = true;
            Engine.MainWindow.SafeAction(s => s.RedrawCounters());
        }

        private static void OnCountsChanged(CounterChangeSet changes)
        {
            foreach (var c in m_List)
            {
                if (changes.Changes.ContainsKey(c.CounterID))
                {
                    c.OnUpdate();
                }
            }
        }

        public static void Uncount(Item item)
        {
            var changes = m_PackCounter.Uncount(item);
            OnCountsChanged(changes);
        }

        public static void Count(Item item)
        {
            var changes = m_PackCounter.Count(item);
            OnCountsChanged(changes);
        }

        public static void QuickRecount()
        {
            Reset();

            SupressWarnings = true;
            Item pack = World.Player == null ? null : World.Player.Backpack;
            if (pack != null)
                Count(pack);
            pack = World.Player == null ? null : World.Player.Quiver;
            if (pack != null)
                Count(pack);
            SupressWarnings = false;
        }

        public static void FullRecount()
        {
            Reset();

            if (World.Player != null)
            {
                SupressWarnings = true;

                if (World.Player.Backpack != null)
                {
                    while (World.Player.Backpack.Contains.Count > 0)
                        ((Item) World.Player.Backpack.Contains[0]).Remove();

                    PacketHandlers.IgnoreGumps.Add(World.Player.Backpack);
                    PlayerData.DoubleClick(World.Player.Backpack);
                }

                if (World.Player.Quiver != null)
                {
                    while (World.Player.Quiver.Contains.Count > 0)
                        ((Item) World.Player.Quiver.Contains[0]).Remove();

                    PacketHandlers.IgnoreGumps.Add(World.Player.Quiver);
                    PlayerData.DoubleClick(World.Player.Quiver);
                }

                if (!Config.GetBool("AutoSearch"))
                    World.Player.SendMessage(MsgLevel.Info, LocString.NoAutoCount);
                SupressWarnings = false;
            }
        }

        public static void Reset()
        {
            SupressWarnings = true;
            m_PackCounter.Reset();

            foreach (var c in m_List)
            {
                c.OnUpdate();
            }
            SupressWarnings = false;
        }

        public static void Redraw(ListView list)
        {
            m_SupressChecks = true;
            list.BeginUpdate();
            list.Items.Clear();
            for (int i = 0; i < m_List.Count; i++)
                list.Items.Add(m_List[i].ViewItem);
            list.EndUpdate();
            m_SupressChecks = false;
        }
    }
}

================================================
FILE: Razor/Core/DamageTracker.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Assistant.Gumps.Internal;

namespace Assistant.Core
{
    public class DamageTracker
    {
        private static readonly Timer DamageTrackerTimer;
        private static DateTime StartTime;

        public static double DamagePerSecond { get; set; }
        public static double MaxDamagePerSecond { get; set; }
        public static int TotalDamageDealt { get; set; }
        public static int TotalDamageTaken { get; set; }

        public static int MaxSingleDamageDealt { get; set; }
        public static string MaxSingleDamageDealtName { get; set; }

        public static int MaxSingleDamageTaken { get; set; }

        public static ConcurrentDictionary<string, int> TotalDamageDealtByName;

        private static DamageTrackerGump _gump;

        static DamageTracker()
        {
            DamageTrackerTimer = new InternalTimer();
            StartTime = DateTime.UtcNow;
        }

        public static bool Running => DamageTrackerTimer.Running;

        public static void Start()
        {
            TotalDamageDealt = 0;
            MaxSingleDamageDealt = 0;
            DamagePerSecond = 0;
            MaxDamagePerSecond = 0;

            TotalDamageDealtByName = new ConcurrentDictionary<string, int>();

            StartTime = DateTime.UtcNow;

            if (DamageTrackerTimer.Running)
            {
                DamageTrackerTimer.Stop();
            }

            DamageTrackerTimer.Start();
            Client.Instance.RequestTitlebarUpdate();

            if (World.Player != null)
                World.Player.SendMessage(MsgLevel.Force, "-- [Damage Tracking Started] ---");
        }

        public static void Stop()
        {
            if (!DamageTrackerTimer.Running)
                return;

            _gump.CloseGump();

            DamageTrackerTimer.Stop();
            Client.Instance.RequestTitlebarUpdate();

            if (World.Player != null)
            {
                SendReport();
            }
        }

        public static void SendReport()
        {
            if (World.Player == null)
                return;

            World.Player.SendMessage(MsgLevel.Force, "-- [Damage Tracking Stopped] ---");
            World.Player.SendMessage(MsgLevel.Force, $"Total Damage Dealt: {TotalDamageDealt}");
            World.Player.SendMessage(MsgLevel.Force, $"Total Damage Taken: {TotalDamageTaken}");
            World.Player.SendMessage(MsgLevel.Force,
                $"Max Single Damage Dealt: {MaxSingleDamageDealt} on '{MaxSingleDamageDealtName}'");
            World.Player.SendMessage(MsgLevel.Force, $"Max Single Damage Taken: {MaxSingleDamageTaken}");
            World.Player.SendMessage(MsgLevel.Force, $"Final DPS: {DamagePerSecond:N2}");
            World.Player.SendMessage(MsgLevel.Force, $"Max DPS: {MaxDamagePerSecond:N2}");

            List<KeyValuePair<string, int>> topFive =
                (from mob in TotalDamageDealtByName orderby mob.Value descending select mob)
                .ToDictionary(pair => pair.Key, pair => pair.Value).Take(5).ToList();

            if (topFive.Count > 0)
            {
                World.Player.SendMessage(MsgLevel.Force, "-- [Top 5 Damage Dealt By Name] ---");

                int x = 1;
                foreach (KeyValuePair<string, int> top in topFive)
                {
                    World.Player.SendMessage(MsgLevel.Force, $"{x}) {top.Key} [{top.Value:N2}]");
                    x++;
                }
            }
        }

        public static List<KeyValuePair<string, int>> GetTotalDamageList()
        {
            List<KeyValuePair<string, int>> sortedList =
                (from mob in TotalDamageDealtByName orderby mob.Value descending select mob)
                .ToDictionary(pair => pair.Key, pair => pair.Value).ToList();

            return sortedList;
        }

        private class InternalTimer : Timer
        {
            private StringBuilder _damageInfo = new StringBuilder();

            public InternalTimer() : base(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1))
            {
            }

            protected override void OnTick()
            {
                if (World.Player == null)
                {
                    DamageTracker.Stop();
                    return;
                }

                _gump?.CloseGump();

                TimeSpan span = DateTime.UtcNow.Subtract(StartTime);

                DamagePerSecond = span.Seconds > 0 ? TotalDamageDealt / span.TotalSeconds : 0;

                if (DamagePerSecond > MaxDamagePerSecond)
                    MaxDamagePerSecond = DamagePerSecond;

                //Client.Instance.RequestTitlebarUpdate();

                _damageInfo.AppendLine($"Total Damage Dealt: {TotalDamageDealt}");
                _damageInfo.AppendLine($"Total Damage Taken: {TotalDamageTaken}");
                _damageInfo.AppendLine($"Max Damage Dealt: {MaxSingleDamageDealt} on '{MaxSingleDamageDealtName}'");
                _damageInfo.AppendLine($"Max Damage Taken: {MaxSingleDamageTaken}");

                _gump = new DamageTrackerGump(_damageInfo.ToString());
                _gump.SendGump();

                _damageInfo.Clear();
            }
        }

        public static void AddDamage(uint serial, ushort damage)
        {
            Mobile mob = World.FindMobile(serial);

            if (mob == null)
                return;

            if (World.Player.Serial == serial) // Track damage you taken
            {
                if (damage > MaxSingleDamageTaken)
                {
                    MaxSingleDamageTaken = damage;
                }

                TotalDamageTaken += damage;
            }
            else // track damage you deal out
            {
                if (damage > MaxSingleDamageDealt)
                {
                    MaxSingleDamageDealt = damage;
                    MaxSingleDamageDealtName = mob.Name;
                }

                TotalDamageDealt += damage;

                if (TotalDamageDealtByName.ContainsKey(mob.Name))
                {
                    TotalDamageDealtByName[mob.Name] += damage;
                }
                else
                {
                    TotalDamageDealtByName.TryAdd(mob.Name, damage);
                }
            }
        }
    }
}

================================================
FILE: Razor/Core/Dress.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

namespace Assistant.Core
{
    public static class Dress
    {
        private static Item m_Right, m_Left;

        public static void ToggleRight()
        {
            if (World.Player == null)
                return;

            Item item = World.Player.GetItemOnLayer(Layer.RightHand);
            if (item == null)
            {
                if (m_Right != null)
                    m_Right = World.FindItem(m_Right.Serial);

                if (m_Right != null && m_Right.IsChildOf(World.Player.Backpack))
                {
                    // try to also undress conflicting hand(s)
                    Item conflict = World.Player.GetItemOnLayer(Layer.LeftHand);
                    if (conflict != null && (conflict.IsTwoHanded || m_Right.IsTwoHanded))
                    {
                        Unequip(DressList.GetLayerFor(conflict));
                    }

                    Equip(m_Right, DressList.GetLayerFor(m_Right));
                }
                else
                {
                    World.Player.SendMessage(MsgLevel.Force, LocString.MustDisarm);
                }
            }
            else
            {
                Unequip(DressList.GetLayerFor(item));
                m_Right = item;
            }
        }

        public static void ToggleLeft()
        {
            if (World.Player == null || World.Player.Backpack == null)
                return;

            Item item = World.Player.GetItemOnLayer(Layer.LeftHand);
            if (item == null)
            {
                if (m_Left != null)
                    m_Left = World.FindItem(m_Left.Serial);

                if (m_Left != null && m_Left.IsChildOf(World.Player.Backpack))
                {
                    Item conflict = World.Player.GetItemOnLayer(Layer.RightHand);
                    if (conflict != null && (conflict.IsTwoHanded || m_Left.IsTwoHanded))
                    {
                        Unequip(DressList.GetLayerFor(conflict));
                    }

                    Equip(m_Left, DressList.GetLayerFor(m_Left));
                }
                else
                {
                    World.Player.SendMessage(MsgLevel.Force, LocString.MustDisarm);
                }
            }
            else
            {
                Unequip(DressList.GetLayerFor(item));
                m_Left = item;
            }
        }

        public static bool Equip(Item item, Layer layer)
        {
            if (layer == Layer.Invalid || layer > Layer.LastUserValid || item == null || item.Layer == Layer.Invalid ||
                item.Layer > Layer.LastUserValid)
                return false;

            if (item != null && World.Player != null && item.IsChildOf(World.Player.Backpack))
            {
                DragDropManager.DragDrop(item, World.Player, layer);
                return true;
            }

            return false;
        }

        public static bool Unequip(Layer layer)
        {
            if (layer == Layer.Invalid || layer > Layer.LastUserValid)
                return false;

            Item item = World.Player.GetItemOnLayer(layer);
            if (item != null)
            {
                Item pack = DressList.FindUndressBag(item);
                if (pack != null)
                {
                    DragDropManager.DragDrop(item, pack);
                    return true;
                }
            }

            return false;
        }
    }
}

================================================
FILE: Razor/Core/DressList.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.Xml;
using System.Windows.Forms;
using Assistant.Scripts;
using Assistant.UI;

namespace Assistant
{
    public class DressList
    {
        private static readonly List<DressList> m_List = new List<DressList>();
        private static ListBox _dressList;
        private static ListBox _dressItems;

        public static void SetControls(ListBox dressList, ListBox dressItems)
        {
            _dressList = dressList;
            _dressItems = dressItems;
        }

        public static void Redraw()
        {
            _dressList.SafeAction(s => s.Items.Clear());
            _dressItems.SafeAction(s => s.Items.Clear());

            _dressList.SafeAction(s => s.Items.AddRange(m_List.ToArray()));
        }

        public static void ClearAll()
        {
            _dressList?.SafeAction(s => s.Items.Clear());
            _dressItems?.SafeAction(s => s.Items.Clear());

            while (m_List.Count > 0)
                Remove(m_List[0]);
        }

        public static DressList Find(string name)
        {
            for (int i = 0; i < m_List.Count; i++)
            {
                DressList list = m_List[i];
                if (list.Name == name)
                    return list;
            }

            return null;
        }

        public static Item FindUndressBag(Item item)
        {
            Item undressBag = World.Player.Backpack;
            for (int i = 0; i < m_List.Count; i++)
            {
                DressList list = m_List[i];
                if (list != null && (list.Items.Contains(item.Serial) || list.Items.Contains(item.ItemID)))
                {
                    if (list.m_UndressBag.IsValid)
                    {
                        Item bag = World.FindItem(list.m_UndressBag);
                        if (bag != null && (bag.RootContainer == World.Player ||
                                            (bag.RootContainer == null && Utility.InRange(bag.GetWorldPosition(),
                                                 World.Player.Position, 2))))
                            undressBag = bag;
                    }

                    break;
                }
            }

            return undressBag;
        }

        public static void Load(XmlElement xml)
        {
            ClearAll();

            if (xml == null)
                return;

            foreach (XmlElement el in xml.GetElementsByTagName("list"))
            {
                try
                {
                    string name = el.GetAttribute("name");
                    DressList list = new DressList(name);
                    Add(list);

                    try
                    {
                        list.m_UndressBag = Serial.Parse(el.GetAttribute("undressbag"));
                    }
                    catch
                    {
                        list.m_UndressBag = Serial.Zero;
                    }

                    foreach (XmlElement el2 in el.GetElementsByTagName("item"))
                    {
                        try
                        {
                            string ser = el2.GetAttribute("serial");
                            list.Items.Add((Serial) Convert.ToUInt32(ser));
                        }
                        catch
                        {
                            try
                            {
                                string iid = el2.GetAttribute("id");
                                list.Items.Add((ItemID) Convert.ToUInt16(iid));
                            }
                            catch
                            {
                            }
                        }
                    }
                }
                catch
                {
                }
            }
        }

        public static void Save(XmlTextWriter xml)
        {
            foreach (DressList list in m_List)
            {
                xml.WriteStartElement("list");
                xml.WriteAttributeString("name", list.Name);

                if (list.m_UndressBag.IsItem)
                    xml.WriteAttributeString("undressbag", list.m_UndressBag.ToString());

                foreach (object o in list.Items)
                {
                    xml.WriteStartElement("item");
                    if (o is Serial)
                        xml.WriteAttributeString("serial", ((Serial) o).Value.ToString());
                    else if (o is ItemID)
                        xml.WriteAttributeString("id", ((ItemID) o).Value.ToString());
                    xml.WriteEndElement();
                }

                xml.WriteEndElement();
            }
        }

        public static void Add(DressList list)
        {
            if (Engine.MainWindow == null)
            {
                m_List.Add(list);
                HotKey.Add(HKCategory.Dress, HKSubCat.None, $"Dress: {list.Name}",
                    new HotKeyCallback(list.Dress));
                HotKey.Add(HKCategory.Dress, HKSubCat.None, $"Undress: {list.Name}",
                    new HotKeyCallback(list.Undress));
                HotKey.Add(HKCategory.Dress, HKSubCat.None, $"Toggle: {list.Name}",
                    new HotKeyCallback(list.Toggle));
            }
            else
            {
                Engine.MainWindow.SafeAction(s =>
                {
                    m_List.Add(list);
                    HotKey.Add(HKCategory.Dress, HKSubCat.None, $"Dress: {list.Name}",
                        new HotKeyCallback(list.Dress));
                    HotKey.Add(HKCategory.Dress, HKSubCat.None, $"Undress: {list.Name}",
                        new HotKeyCallback(list.Undress));
                    HotKey.Add(HKCategory.Dress, HKSubCat.None, $"Toggle: {list.Name}",
                        new HotKeyCallback(list.Toggle));
                });
            }
        }

        public static void Remove(DressList list)
        {
            if (Engine.MainWindow == null)
            {
                m_List.Remove(list);
                HotKey.Remove($"Dress: {list.Name}");
                HotKey.Remove($"Undress: {list.Name}");
                HotKey.Remove($"Toggle: {list.Name}");
            }
            else
            {
                Engine.MainWindow.SafeAction(s =>
                {
                    m_List.Remove(list);
                    HotKey.Remove($"Dress: {list.Name}");
                    HotKey.Remove($"Undress: {list.Name}");
                    HotKey.Remove($"Toggle: {list.Name}");
                });
            }
        }

        private Serial m_UndressBag;

        public DressList(string name)
        {
            Name = name;
            Items = new List<object>();
            m_UndressBag = Serial.Zero;
        }

        public DressList(XmlElement xml)
        {
            Name = xml.GetAttribute("name");
        }

        public override string ToString()
        {
            return Name;
        }

        public string Name { get; }
        public List<object> Items { get; }

        public void SetUndressBag(Serial serial)
        {
            if (serial == World.Player.Backpack.Serial || !serial.IsItem)
                m_UndressBag = Serial.Zero;
            else
                m_UndressBag = serial;
        }

        public void Toggle()
        {
            if (World.Player == null)
                return;

            int worn = 0;
            int total = Items.Count;

            for (int i = 0; i < Items.Count; i++)
            {
                Item item = null;
                if (Items[i] is Serial)
                    item = World.FindItem((Serial) Items[i]);
                else if (Items[i] is ItemID)
                    item = World.Player.FindItemByID((ItemID) Items[i]);

                if (item == null)
                    total--;
                else if (item.Container == World.Player)
                    worn++;
            }

            if (Items.Count == 1)
            {
                if (worn != 0)
                    Undress();
                else
                    Dress();
            }
            else
            {
                if (worn > total / 2)
                    Undress();
                else
                    Dress();
            }
        }

        public void Undress()
        {
            if (World.Player == null)
                return;

            int count = 0;
            Item undressBag = World.Player.Backpack;
            if (undressBag == null)
            {
                World.Player.SendMessage(LocString.NoBackpack);
                return;
            }

            if (Macros.MacroManager.AcceptActions)
                Macros.MacroManager.Action(new Macros.UnDressAction(Name));

            if (ScriptManager.Recording)
                ScriptManager.AddToScript($"undress '{Name}'");

            if (m_UndressBag.IsValid)
            {
                Item bag = World.FindItem(m_UndressBag);
                if (bag != null && (bag.RootContainer == World.Player ||
                                    (bag.RootContainer == null && Utility.InRange(bag.GetWorldPosition(),
                                         World.Player.Position, 2))))
                    undressBag = bag;
                else
                    World.Player.SendMessage(LocString.UndressBagRange);
            }

            for (int i = 0; i < Items.Count; i++)
            {
                Item item = null;
                if (Items[i] is Serial)
                    item = World.FindItem((Serial) Items[i]);
                else if (Items[i] is ItemID)
                    item = World.Player.FindItemByID((ItemID) Items[i]);

                if (item == null || DragDropManager.CancelDragFor(item.Serial) || item.Container != World.Player)
                {
                    continue;
                }
                else
                {
                    DragDropManager.DragDrop(item, undressBag);
                    count++;
                }
            }

            World.Player.SendMessage(LocString.UndressQueued, count);
        }

        public static Layer GetLayerFor(Item item)
        {
            Layer layer = item.Layer;
            if (layer == Layer.Invalid || layer > Layer.LastUserValid)
                layer = (Layer) item.ItemID.ItemData.Quality;

            return layer;
        }

        public void Dress()
        {
            if (World.Player == null)
                return;

            int skipped = 0, gone = 0, done = 0;
            List<Item> list = new List<Item>();
            bool remConflicts = Config.GetBool("UndressConflicts");

            if (World.Player.Backpack == null)
            {
                World.Player.SendMessage(LocString.NoBackpack);
                return;
            }

            if (Macros.MacroManager.AcceptActions)
                Macros.MacroManager.Action(new Macros.DressAction(Name));

            ScriptManager.AddToScript($"dress '{Name}'");

            for (int i = 0; i < Items.Count; i++)
            {
                Item item = null;
                if (Items[i] is Serial)
                {
                    item = World.FindItem((Serial) Items[i]);
                    if (item == null)
                        gone++;
                    else
                        list.Add(item);
                }
                else if (Items[i] is ItemID)
                {
                    ItemID id = (ItemID) Items[i];

                    // search to make sure they are not already wearing this...
                    item = World.Player.FindItemByID(id);
                    if (item != null)
                    {
                        skipped++;
                    }
                    else
                    {
                        item = World.Player.Backpack.FindItemById(id);
                        if (item == null)
                            gone++;
                        else
                            list.Add(item);
                    }
                }
            }

            foreach (Item item in list)
            {
                if (item.Container == World.Player)
                {
                    skipped++;
                }
                else if (item.IsChildOf(World.Player.Backpack) || item.RootContainer == null)
                {
                    Layer layer = GetLayerFor(item);
                    if (layer == Layer.Invalid || layer > Layer.LastUserValid)
                        continue;

                    if (remConflicts)
                    {
                        Item conflict = World.Player.GetItemOnLayer(layer);
                        if (conflict != null)
                            DragDropManager.DragDrop(conflict, FindUndressBag(conflict));

                        // try to also undress conflicting hand(s)
                        if (layer == Layer.RightHand)
                            conflict = World.Player.GetItemOnLayer(Layer.LeftHand);
                        else if (layer == Layer.LeftHand)
                            conflict = World.Player.GetItemOnLayer(Layer.RightHand);
                        else
                            conflict = null;

                        if (conflict != null && (conflict.IsTwoHanded || item.IsTwoHanded))
                            DragDropManager.DragDrop(conflict, FindUndressBag(conflict));
                    }

                    DragDropManager.DragDrop(item, World.Player, layer);
                    done++;
                }
            }

            if (done > 0)
                World.Player.SendMessage(LocString.DressQueued, done);
            if (skipped > 0)
                World.Player.SendMessage(LocString.AlreadyDressed, skipped);
            if (gone > 0)
                World.Player.SendMessage(LocString.ItemsNotFound, gone);
        }
    }
}

================================================
FILE: Razor/Core/EncodedSpeech.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

namespace Assistant.Core
{
    public class EncodedSpeech
    {
        internal class SpeechEntry : IComparable<SpeechEntry>
        {
            internal short m_KeywordID;
            internal string[] m_Keywords;

            internal SpeechEntry(int idKeyword, string keyword)
            {
                m_KeywordID = (short) idKeyword;
                m_Keywords = keyword.Split(new char[] {'*'});
            }

            public int CompareTo(SpeechEntry entry)
            {
                if (entry == null)
                {
                    return -1;
                }

                if (entry != this)
                {
                    if (m_KeywordID < entry.m_KeywordID)
                    {
                        return -1;
                    }

                    if (m_KeywordID > entry.m_KeywordID)
                    {
                        return 1;
                    }
                }

                return 0;
            }
        }

        private static List<SpeechEntry> m_Speech;
        internal static unsafe void LoadSpeechTable()
        {
            string path = Ultima.Files.GetFilePath("Speech.mul");

            if (!File.Exists(path))
            {
                m_Speech = new List<SpeechEntry>();
            }
            else
            {
                m_Speech = new List<SpeechEntry>();
                byte[] buffer = new byte[0x400];
                fixed (byte* numRef = buffer)
                {
                    using(var file = new FileStream(path, FileMode.Open,FileAccess.Read))
                        while (file.Position < file.Length)
                        {
                            int id = (ushort)((file.ReadByte() << 8) | file.ReadByte());
                            int length = (ushort)((file.ReadByte() << 8) | file.ReadByte());
                            if (length > 0 && file.Position + length <= file.Length)
                            {
                                file.Read(buffer, 0, length);
                                m_Speech.Add(new SpeechEntry(id, new string((sbyte*) numRef,0, length)));
                            }
                        }
                }

            }
            
        }

        internal static List<ushort> GetKeywords(string text)
        {
            List<ushort> keynumber = new List<ushort>();

            if (m_Speech == null)
            {
                LoadSpeechTable();
            }

            text = text.ToLower();

            List<SpeechEntry> keywords = new List<SpeechEntry>();
            List<SpeechEntry> speech = m_Speech.ToList();
            foreach (SpeechEntry entry in speech)
            {
                if (IsMatch(text, entry.m_Keywords))
                {
                    keywords.Add(entry);
                }
            }

            keywords.Sort();

            bool flag = false;

            int numk = keywords.Count & 15;
            int index = 0;
            while (index < keywords.Count)
            {
                SpeechEntry entry = keywords[index];
                int keywordID = entry.m_KeywordID;

                if (flag)
                {
                    keynumber.Add((byte) (keywordID >> 4));
                    numk = keywordID & 15;
                }
                else
                {
                    keynumber.Add((byte) ((numk << 4) | ((keywordID >> 8) & 15)));
                    keynumber.Add((byte) keywordID);
                }

                index++;
                flag = !flag;
            }

            if (!flag)
            {
                keynumber.Add((byte) (numk << 4));
            }

            return keynumber;
        }

        private static bool IsMatch(string input, string[] split)
        {
            int startIndex = 0;

            for (int i = 0; i < split.Length; i++)
            {
                if (split[i].Length > 0)
                {
                    int index = input.IndexOf(split[i], startIndex);
                    if ((index > 0) && (i == 0))
                    {
                        return false;
                    }

                    if (index < 0)
                    {
                        return false;
                    }

                    startIndex = index + split[i].Length;
                }
            }

            return ((split[split.Length - 1].Length <= 0) || (startIndex == input.Length));
        }
    }
}

================================================
FILE: Razor/Core/FriendsManager.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Windows.Forms;
using System.Xml;
using Assistant.UI;

namespace Assistant.Core
{
    public static class FriendsManager
    {
        private static ComboBox _friendGroups;
        private static ListBox _friendList;

        private static List<FriendGroup> FriendGroups = new List<FriendGroup>();

        public static void SetControls(ComboBox friendsGroup, ListBox friendsList)
        {
            _friendGroups = friendsGroup;
            _friendList = friendsList;
        }

        public static void OnTargetAddFriend(FriendGroup group)
        {
            World.Player.SendMessage(MsgLevel.Friend, LocString.TargFriendAdd);
            Targeting.OneTimeTarget(group.OnAddFriendTarget);
        }

        public class Friend
        {
            public string Name { get; set; }
            public Serial Serial { get; set; }

            public override string ToString()
            {
                return $"{Name} ({Serial})";
            }
        }

        public class FriendGroup
        {
            public string GroupName { get; set; }
            public bool Enabled { get; set; }
            public List<Friend> Friends { get; set; }

            public string OverheadFormat { get; set; }
            public int OverheadFormatHue { get; set; }
            public bool OverheadFormatEnabled { get; set; }

            public FriendGroup()
            {
                Friends = new List<Friend>();
            }

            public void AddHotKeys()
            {
                if (Engine.MainWindow == null)
                {
                    HotKey.Add(HKCategory.Friends, HKSubCat.None, $"Add Target To: {GroupName}", AddFriendToGroup);
                    HotKey.Add(HKCategory.Friends, HKSubCat.None, $"Toggle Group: {GroupName}", ToggleFriendGroup);
                    HotKey.Add(HKCategory.Friends, HKSubCat.None, $"Add All Mobiles: {GroupName}",
                        AddAllMobileAsFriends);
                    HotKey.Add(HKCategory.Friends, HKSubCat.None, $"Add All Humanoids: {GroupName}",
                        AddAllHumanoidsAsFriends);
                }
                else
                {
                    Engine.MainWindow.SafeAction(s =>
                    {
                        HotKey.Add(HKCategory.Friends, HKSubCat.None, $"Add Target To: {GroupName}", AddFriendToGroup);
                        HotKey.Add(HKCategory.Friends, HKSubCat.None, $"Toggle Group: {GroupName}", ToggleFriendGroup);
                        HotKey.Add(HKCategory.Friends, HKSubCat.None, $"Add All Mobiles: {GroupName}",
                            AddAllMobileAsFriends);
                        HotKey.Add(HKCategory.Friends, HKSubCat.None, $"Add All Humanoids: {GroupName}",
                            AddAllHumanoidsAsFriends);
                    });
                }
            }

            public void RemoveHotKeys()
            {
                if (Engine.MainWindow == null)
                {
                    HotKey.Remove($"Add Target To: {GroupName}");
                    HotKey.Remove($"Toggle Group: {GroupName}");
                    HotKey.Remove($"Add All Mobiles: {GroupName}");
                    HotKey.Remove($"Add All Humanoids: {GroupName}");
                }
                else
                {
                    Engine.MainWindow.SafeAction(s =>
                    {
                        HotKey.Remove($"Add Target To: {GroupName}");
                        HotKey.Remove($"Toggle Group: {GroupName}");
                        HotKey.Remove($"Add All Mobiles: {GroupName}");
                        HotKey.Remove($"Add All Humanoids: {GroupName}");
                    });
                }
            }

            public void AddFriendToGroup()
            {
                World.Player.SendMessage(MsgLevel.Friend, $"Target friend to add to group '{GroupName}'");
                Targeting.OneTimeTarget(OnAddFriendTarget);
            }

            private void ToggleFriendGroup()
            {
                if (Enabled)
                {
                    World.Player.SendMessage(MsgLevel.Warning,
                        $"Friend group '{GroupName}' ({Friends.Count} friends) has been 'Disabled'");
                    Enabled = false;
                }
                else
                {
                    World.Player.SendMessage(MsgLevel.Info,
                        $"Friend group '{GroupName}' ({Friends.Count} friends) has been 'Enabled'");
                    Enabled = true;
                }
            }

            public override string ToString()
            {
                return $"{GroupName}";
            }

            public void OnAddFriendTarget(bool location, Serial serial, Point3D loc, ushort gfx)
            {
                Engine.MainWindow.SafeAction(s => s.ShowMe());

                if (!location && serial.IsMobile && serial != World.Player.Serial)
                {
                    Mobile m = World.FindMobile(serial);

                    if (m == null)
                        return;

                    if (AddFriend(m.Name, serial))
                    {
                        m.ObjPropList.Add(Language.GetString(LocString.RazorFriend));
                        m.OPLChanged();
                    }
                    else
                    {
                        World.Player.SendMessage(MsgLevel.Warning, $"'{m.Name}' is already in '{GroupName}'");
                    }
                }
            }

            public bool AddFriend(string friendName, Serial friendSerial)
            {
                if (Friends.Any(f => f.Serial == friendSerial) == false)
                {
                    Friend newFriend = new Friend
                    {
                        Name = friendName,
                        Serial = friendSerial
                    };

                    Friends.Add(newFriend);

                    if (_friendGroups.SelectedItem == this)
                    {
                        RedrawList(this);
                    }

                    World.Player?.SendMessage(MsgLevel.Friend, $"Added '{friendName}' to '{GroupName}'");

                    return true;
                }

                return false;
            }

            public void AddAllMobileAsFriends()
            {
                List<Mobile> mobiles = World.MobilesInRange(12);

                foreach (Mobile mobile in mobiles)
                {
                    if (!IsFriend(mobile.Serial) && mobile.Serial.IsMobile && mobile.Serial != World.Player.Serial)
                    {
                        if (AddFriend(mobile.Name, mobile.Serial))
                        {
                            mobile.ObjPropList.Add(Language.GetString(LocString.RazorFriend));
                            mobile.OPLChanged();
                        }
                    }
                }
            }

            public void AddAllHumanoidsAsFriends()
            {
                List<Mobile> mobiles = World.MobilesInRange(12);

                foreach (Mobile mobile in mobiles)
                {
                    if (!IsFriend(mobile.Serial) && mobile.Serial.IsMobile && mobile.Serial != World.Player.Serial &&
                        mobile.IsHuman)
                    {
                        if (AddFriend(mobile.Name, mobile.Serial))
                        {
                            mobile.ObjPropList.Add(Language.GetString(LocString.RazorFriend));
                            mobile.OPLChanged();
                        }
                    }
                }
            }
        }

        public static bool IsFriendOverhead(Serial serial, ref FriendGroup group)
        {
            // Check if they have treat party as friends enabled and check the party if so
            if (Config.GetBool("AutoFriend") && PacketHandlers.Party.Contains(serial))
                return true;
            
            // Loop through each friends group that is enabled
            foreach (FriendGroup friendGroup in FriendGroups)
            {
                if (friendGroup.Enabled && friendGroup.Friends.Any(f => f.Serial == serial))
                {
                    group = friendGroup;

                    return true;
                }
            }

            return false;
        }

        public static bool IsFriend(Serial serial)
        {
            // Check if they have treat party as friends enabled and check the party if so
            if (Config.GetBool("AutoFriend") && PacketHandlers.Party.Contains(serial))
                return true;

            // Loop through each friends group that is enabled
            foreach (FriendGroup friendGroup in FriendGroups)
            {
                if (friendGroup.Enabled && friendGroup.Friends.Any(f => f.Serial == serial))
                {
                    return true;
                }
            }

            return false;
        }

        public static void EnableFriendsGroup(FriendGroup group, bool enabled)
        {
            foreach (FriendGroup friendGroup in FriendGroups)
            {
                if (friendGroup == group)
                {
                    friendGroup.Enabled = enabled;
                    return;
                }
            }
        }

        public static bool FriendsGroupExists(string group)
        {
            foreach (FriendGroup friendGroup in FriendGroups)
            {
                if (friendGroup.GroupName.ToLower().Equals(group.ToLower()))
                {
                    return true;
                }
            }

            return false;
        }

        public static bool IsFriendsGroupEnabled(FriendGroup group)
        {
            foreach (FriendGroup friendGroup in FriendGroups)
            {
                if (friendGroup == group)
                {
                    return friendGroup.Enabled;
                }
            }

            return false;
        }

        public static bool RemoveFriend(FriendGroup group, int index)
        {
            foreach (var friendGroup in FriendGroups)
            {
                if (friendGroup == group)
                {
                    friendGroup.Friends.RemoveAt(index);

                    RedrawList(group);

                    return true;
                }
            }

            return false;
        }

        public static void ClearFriendGroup(string group)
        {
            foreach (var friendGroup in FriendGroups)
            {
                if (friendGroup.GroupName.Equals(group))
                {
                    friendGroup.Friends.Clear();
                    return;
                }
            }
        }

        public static bool DeleteFriendGroup(FriendGroup group)
        {
            foreach (FriendGroup friendGroup in FriendGroups)
            {
                if (friendGroup == group)
                {
                    friendGroup.RemoveHotKeys();
                }
            }

            return FriendGroups.Remove(group);
        }

        public static void AddFriendGroup(string group)
        {
            FriendGroup friendGroup = new FriendGroup
            {
                Enabled = true,
                GroupName = group,
                Friends = new List<Friend>(),
                OverheadFormatHue = 63,
                OverheadFormat = "[Friend]",
                OverheadFormatEnabled = true
            };

            friendGroup.AddHotKeys();

            FriendGroups.Add(friendGroup);

            RedrawGroup();
        }

        public static void SetOverheadFormat(FriendGroup group, string format)
        {
            foreach (FriendGroup friendGroup in FriendGroups)
            {
                if (friendGroup == group)
                {
                    friendGroup.OverheadFormat = format;
                    return;
                }
            }
        }

        public static void SetOverheadHue(FriendGroup group, int hue)
        {
            foreach (FriendGroup friendGroup in FriendGroups)
            {
                if (friendGroup == group)
                {
                    friendGroup.OverheadFormatHue = hue;
                    return;
                }
            }
        }

        public static void SetOverheadFormatEnabled(FriendGroup group, bool enabled)
        {
            foreach (FriendGroup friendGroup in FriendGroups)
            {
                if (friendGroup == group)
                {
                    friendGroup.OverheadFormatEnabled = enabled;
                    return;
                }
            }
        }

        public static void ShowOverhead(Mobile mobile)
        {
            FriendGroup group = null;

            if (IsFriendOverhead(mobile.Serial, ref group))
            {
                if (group == null && Config.GetBool("ShowPartyFriendOverhead")) // If they are a friend with no group, must be a party member
                {
                    mobile.OverheadMessage(63, "[Party-Friend]");
                }
                else if (group != null && group.OverheadFormatEnabled)
                {
                    mobile.OverheadMessage(group.OverheadFormatHue, group.OverheadFormat);
                }
            }
        }

        public static void Save(XmlTextWriter xml)
        {
            foreach (var friendGroup in FriendGroups)
            {
                xml.WriteStartElement("group");
                xml.WriteAttributeString("name", friendGroup.GroupName);
                xml.WriteAttributeString("enabled", friendGroup.Enabled.ToString());
                xml.WriteAttributeString("overheadformat", friendGroup.OverheadFormat);
                xml.WriteAttributeString("overheadhue", friendGroup.OverheadFormatHue.ToString());
                xml.WriteAttributeString("overheadenabled", friendGroup.OverheadFormatEnabled.ToString());

                foreach (var friend in friendGroup.Friends)
                {
                    xml.WriteStartElement("friend");
                    xml.WriteAttributeString("name", friend.Name);
                    xml.WriteAttributeString("serial", friend.Serial.ToString());
                    xml.WriteEndElement();
                }

                xml.WriteEndElement();
            }
        }

        public static void Load(XmlElement node)
        {
            ClearAll();

            try
            {
                foreach (XmlElement el in node.GetElementsByTagName("group"))
                {
                    FriendGroup friendGroup = new FriendGroup
                    {
                        GroupName = el.GetAttribute("name"),
                        Enabled = Convert.ToBoolean(el.GetAttribute("enabled"))
                    };

                    // Newer versions didn't have these, so it will cause an error when loading for the first time
                    // If any fail, just set defaults
                    try
                    {
                        friendGroup.OverheadFormat = el.GetAttribute("overheadformat");
                        friendGroup.OverheadFormatHue = Convert.ToInt32(el.GetAttribute("overheadhue"));
                        friendGroup.OverheadFormatEnabled = Convert.ToBoolean(el.GetAttribute("overheadenabled"));
                    }
                    catch
                    {
                        friendGroup.OverheadFormat = "[Friend]";
                        friendGroup.OverheadFormatHue = 63;
                        friendGroup.OverheadFormatEnabled = true;
                    }

                    friendGroup.AddHotKeys();

                    foreach (XmlElement friendEl in el.GetElementsByTagName("friend"))
                    {
                        try
                        {
                            Friend friend = new Friend
                            {
                                Name = friendEl.GetAttribute("name"),
                                Serial = Serial.Parse(friendEl.GetAttribute("serial"))
                            };

                            friendGroup.Friends.Add(friend);
                        }
                        catch
                        {
                            // ignore this bad record, most likely a bad serial
                        }
                    }

                    FriendGroups.Add(friendGroup);
                }

                RedrawAll();
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex);
            }
        }

        public static void ClearAll()
        {
            foreach (FriendGroup friendGroup in FriendGroups)
            {
                friendGroup.RemoveHotKeys();
            }

            FriendGroups.Clear();
        }

        private static void RedrawAll()
        {
            RedrawGroup();

            if (_friendGroups?.Items.Count > 0)
            {
                RedrawList((FriendGroup) _friendGroups.Items[0]);
            }
            else
            {
                RedrawList(null); // we just want to clear the list
            }
        }

        public static void RedrawGroup()
        {
            _friendGroups?.SafeAction(s =>
            {
                s.BeginUpdate();
                s.Items.Clear();

                foreach (FriendGroup friendGroup in FriendGroups)
                {
                    s.Items.Add(friendGroup);
                }

                s.EndUpdate();

                if (s.Items.Count > 0)
                {
                    s.SelectedIndex = 0;
                }
            });
        }

        public static void RedrawList(FriendGroup group)
        {
            _friendList?.SafeAction(s =>
            {
                s.BeginUpdate();
                s.Items.Clear();

                if (group != null)
                {
                    foreach (Friend friend in group.Friends)
                    {
                        s.Items.Add(friend);
                    }
                }

                s.EndUpdate();
            });
        }
    }
}

================================================
FILE: Razor/Core/GateTimer.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Linq;
using Assistant.Core;

namespace Assistant
{
    public class GateTimer
    {
        private static int m_Count;
        private static Timer m_Timer;

        private static readonly int[] m_ClilocsStop = {502632};

        private static readonly int[] m_ClilocsRestart = {501024};

        static GateTimer()
        {
            m_Timer = new InternalTimer();
            
            MessageManager.OnSystemMessage += OnSystemMessage;
        }

        public static int Count
        {
            get { return m_Count; }
        }
        
        private static void OnSystemMessage(Packet p, PacketHandlerEventArgs args, Serial source, ushort graphic,
            MessageType type, ushort hue, ushort font, string lang, string sourceName,
            string msg)
        {
            if (Running)
            {
                if (m_ClilocsStop.Any(t => Language.GetCliloc(t) == msg))
                {
                    Stop();
                }

                if (m_ClilocsRestart.Any(t => Language.GetCliloc(t) == msg))
                {
                    Start();
                }
            }
        }

        public static bool Running
        {
            get { return m_Timer.Running; }
        }

        public static void Start()
        {
            m_Count = 0;

            if (m_Timer.Running)
            {
                m_Timer.Stop();
            }

            m_Timer.Start();
            Client.Instance.RequestTitlebarUpdate();
        }

        public static void Stop()
        {
            m_Timer.Stop();
            Client.Instance.RequestTitlebarUpdate();
        }

        private class InternalTimer : Timer
        {
            public InternalTimer() : base(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1))
            {
            }

            protected override void OnTick()
            {
                m_Count++;
                if (m_Count > 30)
                {
                    Stop();
                }

                Client.Instance.RequestTitlebarUpdate();
            }
        }
    }
}

================================================
FILE: Razor/Core/Geometry.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;

namespace Assistant
{
    public interface IPoint2D
    {
        int X { get; }
        int Y { get; }
    }

    public interface IPoint3D : IPoint2D
    {
        int Z { get; }
    }

    public struct Point2D : IPoint2D
    {
        internal int m_X;
        internal int m_Y;

        public static readonly Point2D Zero = new Point2D(0, 0);
        public static readonly Point2D MinusOne = new Point2D(-1, -1);

        public Point2D(int x, int y)
        {
            m_X = x;
            m_Y = y;
        }

        public Point2D(IPoint2D p) : this(p.X, p.Y)
        {
        }

        public int X
        {
            get { return m_X; }
            set { m_X = value; }
        }

        public int Y
        {
            get { return m_Y; }
            set { m_Y = value; }
        }

        public override string ToString()
        {
            return $"({m_X}, {m_Y})";
        }

        public override bool Equals(object o)
        {
            if (o == null || !(o is IPoint2D)) return false;

            IPoint2D p = (IPoint2D) o;

            return m_X == p.X && m_Y == p.Y;
        }

        public override int GetHashCode()
        {
            return m_X ^ m_Y;
        }

        public static bool operator ==(Point2D l, Point2D r)
        {
            return l.m_X == r.m_X && l.m_Y == r.m_Y;
        }

        public static bool operator !=(Point2D l, Point2D r)
        {
            return l.m_X != r.m_X || l.m_Y != r.m_Y;
        }

        public static bool operator ==(Point2D l, IPoint2D r)
        {
            return l.m_X == r.X && l.m_Y == r.Y;
        }

        public static bool operator !=(Point2D l, IPoint2D r)
        {
            return l.m_X != r.X || l.m_Y != r.Y;
        }

        public static bool operator >(Point2D l, Point2D r)
        {
            return l.m_X > r.m_X && l.m_Y > r.m_Y;
        }

        public static bool operator >(Point2D l, Point3D r)
        {
            return l.m_X > r.m_X && l.m_Y > r.m_Y;
        }

        public static bool operator >(Point2D l, IPoint2D r)
        {
            return l.m_X > r.X && l.m_Y > r.Y;
        }

        public static bool operator <(Point2D l, Point2D r)
        {
            return l.m_X < r.m_X && l.m_Y < r.m_Y;
        }

        public static bool operator <(Point2D l, Point3D r)
        {
            return l.m_X < r.m_X && l.m_Y < r.m_Y;
        }

        public static bool operator <(Point2D l, IPoint2D r)
        {
            return l.m_X < r.X && l.m_Y < r.Y;
        }

        public static bool operator >=(Point2D l, Point2D r)
        {
            return l.m_X >= r.m_X && l.m_Y >= r.m_Y;
        }

        public static bool operator >=(Point2D l, Point3D r)
        {
            return l.m_X >= r.m_X && l.m_Y >= r.m_Y;
        }

        public static bool operator >=(Point2D l, IPoint2D r)
        {
            return l.m_X >= r.X && l.m_Y >= r.Y;
        }

        public static bool operator <=(Point2D l, Point2D r)
        {
            return l.m_X <= r.m_X && l.m_Y <= r.m_Y;
        }

        public static bool operator <=(Point2D l, Point3D r)
        {
            return l.m_X <= r.m_X && l.m_Y <= r.m_Y;
        }

        public static bool operator <=(Point2D l, IPoint2D r)
        {
            return l.m_X <= r.X && l.m_Y <= r.Y;
        }
    }

    public struct Point3D : IPoint3D
    {
        internal int m_X;
        internal int m_Y;
        internal int m_Z;

        public static readonly Point3D Zero = new Point3D(0, 0, 0);
        public static readonly Point3D MinusOne = new Point3D(-1, -1, 0);

        public Point3D(int x, int y, int z)
        {
            m_X = x;
            m_Y = y;
            m_Z = z;
        }

        public Point3D(IPoint3D p) : this(p.X, p.Y, p.Z)
        {
        }

        public Point3D(IPoint2D p, int z) : this(p.X, p.Y, z)
        {
        }

        public int X
        {
            get { return m_X; }
            set { m_X = value; }
        }

        public int Y
        {
            get { return m_Y; }
            set { m_Y = value; }
        }

        public int Z
        {
            get { return m_Z; }
            set { m_Z = value; }
        }

        public override string ToString()
        {
            return $"({m_X}, {m_Y}, {m_Z})";
        }

        public override bool Equals(object o)
        {
            if (o == null || !(o is IPoint3D)) return false;

            IPoint3D p = (IPoint3D) o;

            return m_X == p.X && m_Y == p.Y && m_Z == p.Z;
        }

        public override int GetHashCode()
        {
            return m_X ^ m_Y ^ m_Z;
        }

        public static Point3D Parse(string value)
        {
            int start = value.IndexOf('(');
            int end = value.IndexOf(',', start + 1);

            string param1 = value.Substring(start + 1, end - (start + 1)).Trim();

            start = end;
            end = value.IndexOf(',', start + 1);

            string param2 = value.Substring(start + 1, end - (start + 1)).Trim();

            start = end;
            end = value.IndexOf(')', start + 1);

            string param3 = value.Substring(start + 1, end - (start + 1)).Trim();

            return new Point3D(Convert.ToInt32(param1), Convert.ToInt32(param2), Convert.ToInt16(param3));
        }

        public static bool operator ==(Point3D l, Point3D r)
        {
            return l.m_X == r.m_X && l.m_Y == r.m_Y && l.m_Z == r.m_Z;
        }

        public static bool operator !=(Point3D l, Point3D r)
        {
            return l.m_X != r.m_X || l.m_Y != r.m_Y || l.m_Z != r.m_Z;
        }

        public static bool operator ==(Point3D l, IPoint3D r)
        {
            return l.m_X == r.X && l.m_Y == r.Y && l.m_Z == r.Z;
        }

        public static bool operator !=(Point3D l, IPoint3D r)
        {
            return l.m_X != r.X || l.m_Y != r.Y || l.m_Z != r.Z;
        }

        public static Point3D operator +(Point3D l, Point3D r)
        {
            return new Point3D(l.m_X + r.m_X, l.m_Y + r.m_Y, l.m_Z + r.m_Z);
        }

        public static Point3D operator -(Point3D l, Point3D r)
        {
            return new Point3D(l.m_X - r.m_X, l.m_Y - r.m_Y, l.m_Z - r.m_Z);
        }
    }

    public struct Line2D
    {
        private Point2D m_Start, m_End;

        public Line2D(IPoint2D start, IPoint2D end)
        {
            m_Start = new Point2D(start);
            m_End = new Point2D(end);
            Fix();
        }

        public void Fix()
        {
            if (m_Start > m_End)
            {
                Point2D temp = m_Start;
                m_Start = m_End;
                m_End = temp;
            }
        }

        public Point2D Start
        {
            get { return m_Start; }
            set
            {
                m_Start = value;
                Fix();
            }
        }

        public Point2D End
        {
            get { return m_End; }
            set
            {
                m_End = value;
                Fix();
            }
        }

        public double Length
        {
            get
            {
                int run = m_End.X - m_Start.X;
                int rise = m_End.Y - m_Start.Y;

                return Math.Sqrt(run * run + rise * rise);
            }
        }

        public override string ToString()
        {
            return $"--{m_Start}->{m_End}--";
        }

        public override bool Equals(object o)
        {
            if (o == null || !(o is Line2D)) return false;

            Line2D ln = (Line2D) o;

            return m_Start == ln.m_Start && m_End == ln.m_End;
        }

        public override int GetHashCode()
        {
            return m_Start.GetHashCode() ^ (~m_End.GetHashCode());
        }

        public static bool operator ==(Line2D l, Line2D r)
        {
            return l.m_Start == r.m_Start && l.m_End == r.m_End;
        }

        public static bool operator !=(Line2D l, Line2D r)
        {
            return l.m_Start != r.m_Start || l.m_End != r.m_End;
        }

        public static bool operator >(Line2D l, Line2D r)
        {
            return l.m_Start > r.m_Start && l.m_End > r.m_End;
        }

        public static bool operator <(Line2D l, Line2D r)
        {
            return l.m_Start < r.m_Start && l.m_End < r.m_End;
        }

        public static bool operator >=(Line2D l, Line2D r)
        {
            return l.m_Start >= r.m_Start && l.m_End >= r.m_End;
        }

        public static bool operator <=(Line2D l, Line2D r)
        {
            return l.m_Start <= r.m_Start && l.m_End <= r.m_End;
        }
    }

    public struct Rectangle2D
    {
        private Point2D m_Start;
        private Point2D m_End;

        public Rectangle2D(IPoint2D start, IPoint2D end)
        {
            m_Start = new Point2D(start);
            m_End = new Point2D(end);
        }

        public Rectangle2D(int x, int y, int width, int height)
        {
            m_Start = new Point2D(x, y);
            m_End = new Point2D(x + width, y + height);
        }

        public void Set(int x, int y, int width, int height)
        {
            m_Start = new Point2D(x, y);
            m_End = new Point2D(x + width, y + height);
        }

        public static Rectangle2D Parse(string value)
        {
            int start = value.IndexOf('(');
            int end = value.IndexOf(',', start + 1);

            string param1 = value.Substring(start + 1, end - (start + 1)).Trim();

            start = end;
            end = value.IndexOf(',', start + 1);

            string param2 = value.Substring(start + 1, end - (start + 1)).Trim();

            start = end;
            end = value.IndexOf(',', start + 1);

            string param3 = value.Substring(start + 1, end - (start + 1)).Trim();

            start = end;
            end = value.IndexOf(')', start + 1);

            string param4 = value.Substring(start + 1, end - (start + 1)).Trim();

            return new Rectangle2D(Convert.ToInt32(param1), Convert.ToInt32(param2), Convert.ToInt32(param3),
                Convert.ToInt32(param4));
        }

        public Point2D Start
        {
            get { return m_Start; }
            set { m_Start = value; }
        }

        public Point2D End
        {
            get { return m_End; }
            set { m_End = value; }
        }

        public int X
        {
            get { return m_Start.m_X; }
            set { m_Start.m_X = value; }
        }

        public int Y
        {
            get { return m_Start.m_Y; }
            set { m_Start.m_Y = value; }
        }

        public int Width
        {
            get { return m_End.m_X - m_Start.m_X; }
            set { m_End.m_X = m_Start.m_X + value; }
        }

        public int Height
        {
            get { return m_End.m_Y - m_Start.m_Y; }
            set { m_End.m_Y = m_Start.m_Y + value; }
        }

        public void MakeHold(Rectangle2D r)
        {
            if (r.m_Start.m_X < m_Start.m_X)
                m_Start.m_X = r.m_Start.m_X;

            if (r.m_Start.m_Y < m_Start.m_Y)
                m_Start.m_Y = r.m_Start.m_Y;

            if (r.m_End.m_X > m_End.m_X)
                m_End.m_X = r.m_End.m_X;

            if (r.m_End.m_Y > m_End.m_Y)
                m_End.m_Y = r.m_End.m_Y;
        }

        // "test" must be smaller than this rectangle!
        public bool Insersects(Rectangle2D test)
        {
            Point2D e1 = new Point2D(test.Start.X + test.Width, test.Start.Y);
            Point2D e2 = new Point2D(test.Start.X, test.Start.Y + test.Width);

            return Contains(test.Start) || Contains(test.End) || Contains(e1) || Contains(e2);
        }

        public bool Contains(Rectangle2D test)
        {
            Point2D e1 = new Point2D(test.Start.X + test.Width, test.Start.Y);
            Point2D e2 = new Point2D(test.Start.X, test.Start.Y + test.Width);

            return Contains(test.Start) && Contains(test.End) && Contains(e1) && Contains(e2);
        }

        public bool Contains(Point3D p)
        {
            return (m_Start.m_X <= p.m_X && m_Start.m_Y <= p.m_Y && m_End.m_X > p.m_X && m_End.m_Y > p.m_Y);
            //return ( m_Start <= p && m_End > p );
        }

        public bool Contains(Point2D p)
        {
            return (m_Start.m_X <= p.m_X && m_Start.m_Y <= p.m_Y && m_End.m_X > p.m_X && m_End.m_Y > p.m_Y);
            //return ( m_Start <= p && m_End > p );
        }

        public bool Contains(IPoint2D p)
        {
            return (m_Start <= p && m_End > p);
        }

        public override string ToString()
        {
            return $"({X}, {Y})+({Width}, {Height})";
        }
    }
}

================================================
FILE: Razor/Core/GoldPerHourTimer.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;

namespace Assistant
{
    public class GoldPerHourTimer
    {
        private static Timer m_Timer;
        private static DateTime m_StartTime;
        private static int m_PrevGoldAmount;

        private static bool m_PickedUpGold;

        public static int GoldSinceStart { get; set; }
        public static double GoldPerSecond { get; set; }
        public static double GoldPerMinute { get; set; }
        public static double GoldPerHour { get; set; }

        static GoldPerHourTimer()
        {
            m_Timer = new InternalTimer();
            m_StartTime = DateTime.UtcNow;
        }

        public static bool Running
        {
            get { return m_Timer.Running; }
        }

        public static double TotalMinutes { get; set; }

        public static void Start()
        {
            GoldSinceStart = 0;
            m_PrevGoldAmount = (int) World.Player.Gold;
            m_StartTime = DateTime.UtcNow;

            m_PickedUpGold = false;

            if (m_Timer.Running)
            {
                m_Timer.Stop();
            }

            m_Timer.Start();
            Client.Instance.RequestTitlebarUpdate();
        }

        public static void Stop()
        {
            m_Timer.Stop();
            Client.Instance.RequestTitlebarUpdate();
        }

        private class InternalTimer : Timer
        {
            public InternalTimer() : base(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1))
            {
            }

            protected override void OnTick()
            {
                if (World.Player == null)
                {
                    GoldPerHourTimer.Stop();
                    return;
                }

                if (m_PrevGoldAmount != World.Player.Gold)
                {
                    if (GoldSinceStart + ((int) World.Player.Gold - m_PrevGoldAmount) > m_PrevGoldAmount)
                    {
                        GoldSinceStart = GoldSinceStart + ((int) World.Player.Gold - m_PrevGoldAmount);

                        m_PickedUpGold = true;
                    }
                }

                // Let's not start calculating until we've picked up gold
                if (m_PickedUpGold == false)
                {
                    m_StartTime = DateTime.UtcNow;
                    return;
                }

                TimeSpan span = DateTime.UtcNow.Subtract(m_StartTime);

                GoldPerSecond = span.Seconds > 0 ? (double) GoldSinceStart / span.TotalSeconds : 0;
                GoldPerMinute = span.Seconds > 0 ? (double) GoldSinceStart / (span.TotalSeconds / 60.0) : 0;
                GoldPerHour = span.Seconds > 0 ? (double) GoldSinceStart / (span.TotalSeconds / 3600.0) : 0;

                TotalMinutes = span.TotalMinutes;

                Client.Instance.RequestTitlebarUpdate();

                m_PrevGoldAmount = (int) World.Player.Gold;
            }
        }
    }
}

================================================
FILE: Razor/Core/Item.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.IO;
using System.Collections.Generic;
using Assistant.Agents;
using Assistant.Core;

namespace Assistant
{
    public enum Layer : byte
    {
        Invalid = 0x00,

        FirstValid = 0x01,

        RightHand = 0x01,
        LeftHand = 0x02,
        Shoes = 0x03,
        Pants = 0x04,
        Shirt = 0x05,
        Head = 0x06,
        Gloves = 0x07,
        Ring = 0x08,
        Talisman = 0x09,
        Neck = 0x0A,
        Hair = 0x0B,
        Waist = 0x0C,
        InnerTorso = 0x0D,
        Bracelet = 0x0E,
        Face = 0x0F,
        FacialHair = 0x10,
        MiddleTorso = 0x11,
        Earrings = 0x12,
        Arms = 0x13,
        Cloak = 0x14,
        Backpack = 0x15,
        OuterTorso = 0x16,
        OuterLegs = 0x17,
        InnerLegs = 0x18,

        LastUserValid = 0x18,

        Mount = 0x19,
        ShopBuy = 0x1A,
        ShopResale = 0x1B,
        ShopSell = 0x1C,
        Bank = 0x1D,

        LastValid = 0x1D
    }

    public class Item : UOEntity
    {
        private ItemID _itemId;
        private ushort _amount;
        private byte _direction;

        private bool _visible;
        private bool _movable;

        private Layer _layer;
        private string _name;
        private object _parent;
        private int _price;
        private string _buyDesc;
        private List<Item> _items;

        private bool _isNew;
        private bool _autoStack;

        private byte[] _housePacket;
        private int _houseRev;

        private byte _gridNum;
        
        public override void AfterLoad()
        {
            _items = new List<Item>();

            for (int i = 0; i < Serial.Serials.Count; i++)
            {
                Serial s = Serial.Serials[i];
                if (s.IsItem)
                {
                    Item item = World.FindItem(s);

                    if (item != null)
                    {
                        _items[i] = item;
                    }

                    Serial.Serials.RemoveAt(i);
                    i--;
                }
            }

            UpdateContainer();
        }

        public Item(Serial serial) : base(serial)
        {
            _items = new List<Item>();

            _visible = true;
            _movable = true;

            Agent.InvokeItemCreated(this);
        }

        public ItemID ItemID
        {
            get { return _itemId; }
            set { _itemId = value; }
        }

        public ushort Amount
        {
            get { return _amount; }
            set { _amount = value; }
        }

        public byte Direction
        {
            get { return _direction; }
            set { _direction = value; }
        }

        public bool Visible
        {
            get { return _visible; }
            set { _visible = value; }
        }

        public bool Movable
        {
            get { return _movable; }
            set { _movable = value; }
        }

        public string Name
        {
            get
            {
                if (!string.IsNullOrEmpty(_name))
                {
                    return _name;
                }
                else
                {
                    return _itemId.ToString();
                }
            }
            set
            {
                if (value != null)
                    _name = value.Trim();
                else
                    _name = null;
            }
        }

        public string DisplayName => _itemId.Value < Ultima.TileData.ItemTable.Length ? Ultima.TileData.ItemTable[_itemId.Value].Name : string.Empty;

        public Layer Layer
        {
            get
            {
                if ((_layer < Layer.FirstValid || _layer > Layer.LastValid) &&
                    ((this.ItemID.ItemData.Flags & Ultima.TileFlag.Wearable) != 0 ||
                     (this.ItemID.ItemData.Flags & Ultima.TileFlag.Armor) != 0 ||
                     (this.ItemID.ItemData.Flags & Ultima.TileFlag.Weapon) != 0
                    ))
                {
                    _layer = (Layer) this.ItemID.ItemData.Quality;
                }

                return _layer;
            }
            set { _layer = value; }
        }

        public Item FindItemById(ItemID id)
        {
            return FindItemById(id, true);
        }

        public List<Item> FindItemsById(ItemID id)
        {
            return FindItemsById(id, true);
        }

        public Item FindItemById(ItemID id, bool recurse)
        {
            for (int i = 0; i < _items.Count; i++)
            {
                Item item = (Item) _items[i];
                if (item.ItemID == id)
                {
                    return item;
                }

                if (recurse)
                {
                    item = item.FindItemById(id, true);
                    if (item != null)
                        return item;
                }
            }

            return null;
        }

        public List<Item> FindItemsById(ItemID id, bool recurse)
        {
            List<Item> items = new List<Item>();

            for (int i = 0; i < _items.Count; i++)
            {
                Item item = _items[i];
                if (item.ItemID == id)
                {
                    items.Add(item);
                }
                
                if (recurse)
                {
                    List<Item> recurseItems = item.FindItemsById(id, true);

                    if (recurseItems.Count > 0)
                    {
                        items.AddRange(recurseItems);
                    }
                }
            }

            return items;
        }

        public Item FindItemByName(string name, bool recurse)
        {
            foreach (var i in _items)
            {
                Item item = i;
                
                if (item.ItemID.ItemData.Name.Equals(name, StringComparison.OrdinalIgnoreCase))
                {
                    return item;
                }

                if (recurse)
                {
                    item = item.FindItemByName(name, true);
                    if (item != null)
                        return item;
                }
            }

            return null;
        }

        public List<Item> FindItemsByName(string name, bool recurse)
        {
            List<Item> items = new List<Item>();

            foreach (Item i in _items)
            {
                if (i.ItemID.ItemData.Name.Equals(name, StringComparison.OrdinalIgnoreCase))
                {
                    items.Add(i);
                }
                
                if (recurse)
                {
                    List<Item> recurseItems = i.FindItemsByName(name, true);
                    if (recurseItems.Count > 0)
                    {
                        items.AddRange(recurseItems);
                    }
                }
            }

            return items;
        }

        public int GetCount(ushort iid)
        {
            int count = 0;
            for (int i = 0; i < _items.Count; i++)
            {
                Item item = (Item) _items[i];
                if (item.ItemID == iid)
                    count += item.Amount;
                // fucking osi blank scrolls
                else if ((item.ItemID == 0x0E34 && iid == 0x0EF3) || (item.ItemID == 0x0EF3 && iid == 0x0E34))
                    count += item.Amount;
                count += item.GetCount(iid);
            }

            return count;
        }
        
        public int GetTotalCount()
        {
            int count = 0;
            
            foreach (Item item in _items)
            {
                count++;

                if (item.IsContainer)
                {
                    count += item.GetTotalCount();
                }
            }

            return count;
        }

        public object Container
        {
            get
            {
                if (_parent is Serial && UpdateContainer())
                    m_NeedContUpdate.Remove(this);
                return _parent;
            }
            set
            {
                if ((_parent != null && _parent.Equals(value))
                    || (value is Serial && _parent is UOEntity && ((UOEntity) _parent).Serial == (Serial) value)
                    || (_parent is Serial && value is UOEntity && ((UOEntity) value).Serial == (Serial) _parent))
                {
                    return;
                }

                if (_parent is Mobile)
                    ((Mobile) _parent).RemoveItem(this);
                else if (_parent is Item)
                    ((Item) _parent).RemoveItem(this);

                if (World.Player != null && (IsChildOf(World.Player.Backpack) || IsChildOf(World.Player.Quiver)))
                    Counter.Uncount(this);

                if (value is Mobile)
                    _parent = ((Mobile) value).Serial;
                else if (value is Item)
                    _parent = ((Item) value).Serial;
                else
                    _parent = value;

                if (!UpdateContainer() && m_NeedContUpdate != null)
                    m_NeedContUpdate.Add(this);
            }
        }

        public bool UpdateContainer()
        {
            if (!(_parent is Serial) || Deleted)
                return true;

            object o = null;
            Serial contSer = (Serial) _parent;
            if (contSer.IsItem)
                o = World.FindItem(contSer);
            else if (contSer.IsMobile)
                o = World.FindMobile(contSer);

            if (o == null)
                return false;

            _parent = o;

            if (_parent is Item)
                ((Item) _parent).AddItem(this);
            else if (_parent is Mobile)
                ((Mobile) _parent).AddItem(this);

            if (World.Player != null && (IsChildOf(World.Player.Backpack) || IsChildOf(World.Player.Quiver)))
            {
                bool exempt = SearchExemptionAgent.IsExempt(this);
                if (!exempt)
                    Counter.Count(this);

                if (_isNew)
                {
                    if (_autoStack)
                        AutoStackResource();

                    if (IsContainer && !exempt && (!IsPouch || !Config.GetBool("NoSearchPouches")) &&
                        Config.GetBool("AutoSearch"))
                    {
                        PacketHandlers.IgnoreGumps.Add(this);
                        PlayerData.DoubleClick(this);

                        for (int c = 0; c < Contains.Count; c++)
                        {
                            Item icheck = (Item) Contains[c];
                            if (icheck.IsContainer && !SearchExemptionAgent.IsExempt(icheck) &&
                                (!icheck.IsPouch || !Config.GetBool("NoSearchPouches")))
                            {
                                PacketHandlers.IgnoreGumps.Add(icheck);
                                PlayerData.DoubleClick(icheck);
                            }
                        }
                    }
                }
            }

            _autoStack = _isNew = false;

            return true;
        }

        private static List<Item> m_NeedContUpdate = new List<Item>();

        public static void UpdateContainers()
        {
            int i = 0;
            while (i < m_NeedContUpdate.Count)
            {
                if (((Item) m_NeedContUpdate[i]).UpdateContainer())
                    m_NeedContUpdate.RemoveAt(i);
                else
                    i++;
            }
        }

        private static List<Serial> m_AutoStackCache = new List<Serial>();

        public void AutoStackResource()
        {
            if (!IsResource || !Config.GetBool("AutoStack") || m_AutoStackCache.Contains(Serial))
                return;

            foreach (Item check in World.Items.Values)
            {
                if (check.Container == null && check.ItemID == ItemID && check.Hue == Hue &&
                    Utility.InRange(World.Player.Position, check.Position, 2))
                {
                    DragDropManager.DragDrop(this, check);
                    m_AutoStackCache.Add(Serial);
                    return;
                }
            }

            DragDropManager.DragDrop(this, World.Player.Position);
            m_AutoStackCache.Add(Serial);
        }

        public object RootContainer
        {
            get
            {
                int die = 100;
                object cont = this.Container;
                while (cont != null && cont is Item && die-- > 0)
                    cont = ((Item) cont).Container;

                return cont;
            }
        }

        public bool IsChildOf(object parent)
        {
            Serial parentSerial = 0;
            if (parent is Mobile)
                return parent == RootContainer;
            else if (parent is Item)
                parentSerial = ((Item) parent).Serial;
            else
                return false;

            object check = this;
            int die = 100;
            while (check != null && check is Item && die-- > 0)
            {
                if (((Item) check).Serial == parentSerial)
                    return true;
                else
                    check = ((Item) check).Container;
            }

            return false;
        }

        public Point3D GetWorldPosition()
        {
            int die = 100;
            object root = this.Container;
            while (root != null && root is Item && ((Item) root).Container != null && die-- > 0)
                root = ((Item) root).Container;

            if (root is Item)
                return ((Item) root).Position;
            else if (root is Mobile)
                return ((Mobile) root).Position;
            else
                return this.Position;
        }

        private void AddItem(Item item)
        {
            for (int i = 0; i < _items.Count; i++)
            {
                if (_items[i] == item)
                    return;
            }

            _items.Add(item);
        }

        private void RemoveItem(Item item)
        {
            _items.Remove(item);
        }

        public byte GetPacketFlags()
        {
            byte flags = 0;

            if (!_visible)
            {
                flags |= 0x80;
            }

            if (_movable)
            {
                flags |= 0x20;
            }

            return flags;
        }

        public int DistanceTo(Mobile m)
        {
            int x = Math.Abs(this.Position.X - m.Position.X);
            int y = Math.Abs(this.Position.Y - m.Position.Y);

            return x > y ? x : y;
        }

        public void ProcessPacketFlags(byte flags)
        {
            _visible = ((flags & 0x80) == 0);
            _movable = ((flags & 0x20) != 0);
        }

        private Timer m_RemoveTimer = null;

        public void RemoveRequest()
        {
            if (m_RemoveTimer == null)
                m_RemoveTimer = Timer.DelayedCallback(TimeSpan.FromSeconds(0.25), new TimerCallback(Remove));
            else if (m_RemoveTimer.Running)
                m_RemoveTimer.Stop();

            m_RemoveTimer.Start();
        }

        public bool CancelRemove()
        {
            if (m_RemoveTimer != null && m_RemoveTimer.Running)
            {
                m_RemoveTimer.Stop();
                return true;
            }
            else
            {
                return false;
            }
        }

        public override void Remove()
        {
            /*if ( IsMulti )
                 UOAssist.PostRemoveMulti( this );*/

            List<Item> rem = new List<Item>(_items);
            _items.Clear();
            for (int i = 0; i < rem.Count; i++)
                (rem[i]).Remove();

            Counter.Uncount(this);

            if (_parent is Mobile)
                ((Mobile) _parent).RemoveItem(this);
            else if (_parent is Item)
                ((Item) _parent).RemoveItem(this);

            World.RemoveItem(this);
            base.Remove();
        }

        public List<Item> Contains
        {
            get { return _items; }
        }

        // possibly 4 bit x/y - 16x16?
        public byte GridNum
        {
            get { return _gridNum; }
            set { _gridNum = value; }
        }

        public bool OnGround
        {
            get { return Container == null; }
        }

        public bool IsContainer
        {
            get
            {
                ushort iid = _itemId.Value;
                return (_items.Count > 0 && !IsCorpse) || (iid >= 0x9A8 && iid <= 0x9AC) ||
                       (iid >= 0x9B0 && iid <= 0x9B2) ||
                       (iid >= 0xA2C && iid <= 0xA53) || (iid >= 0xA97 && iid <= 0xA9E) ||
                       (iid >= 0xE3C && iid <= 0xE43) ||
                       (iid >= 0xE75 && iid <= 0xE80 && iid != 0xE7B) || iid == 0x1E80 || iid == 0x1E81 ||
                       iid == 0x232A || iid == 0x232B ||
                       iid == 0x2B02 || iid == 0x2B03 || iid == 0x2FB7 || iid == 0x3171;
            }
        }

        public bool IsBagOfSending
        {
            get { return Hue >= 0x0400 && _itemId.Value == 0xE76; }
        }

        public bool IsInBank
        {
            get
            {
                if (_parent is Item)
                    return ((Item) _parent).IsInBank;
                else if (_parent is Mobile)
                    return this.Layer == Layer.Bank;
                else
                    return false;
            }
        }

        public bool IsNew
        {
            get { return _isNew; }
            set { _isNew = value; }
        }

        public bool AutoStack
        {
            get { return _autoStack; }
            set { _autoStack = value; }
        }

        public bool IsMulti
        {
            get { return _itemId.Value >= 0x4000; }
        }

        public bool IsPouch
        {
            get { return _itemId.Value == 0x0E79; }
        }

        public bool IsCorpse
        {
            get { return _itemId.Value == 0x2006 || (_itemId.Value >= 0x0ECA && _itemId.Value <= 0x0ED2); }
        }

        public bool IsDoor
        {
            get
            {
                ushort iid = _itemId.Value;
                return (iid >= 0x0675 && iid <= 0x06F6) || (iid >= 0x0821 && iid <= 0x0875) ||
                       (iid >= 0x1FED && iid <= 0x1FFC) ||
                       (iid >= 0x241F && iid <= 0x2424) || (iid >= 0x2A05 && iid <= 0x2A1C);
            }
        }

        public bool IsResource
        {
            get
            {
                ushort iid = _itemId.Value;
                return (iid >= 0x19B7 && iid <= 0x19BA) || // ore
                       (iid >= 0x09CC && iid <= 0x09CF) || // fishes
                       (iid >= 0x1BDD && iid <= 0x1BE2) || // logs
                       iid == 0x1779 || // granite / stone
                       iid == 0x11EA || iid == 0x11EB // sand
                    ;
            }
        }

        public bool IsPotion
        {
            get
            {
                return (_itemId.Value >= 0x0F06 && _itemId.Value <= 0x0F0D) ||
                       _itemId.Value == 0x2790 || _itemId.Value == 0x27DB; // Ninja belt (works like a potion)
            }
        }

        public bool IsVirtueShield
        {
            get
            {
                ushort iid = _itemId.Value;
                return (iid >= 0x1bc3 && iid <= 0x1bc5); // virtue shields
            }
        }

        public bool IsTwoHanded
        {
            get
            {
                ushort iid = _itemId.Value;

                if (Overrides.TwoHanded.TryGetValue(iid, out bool value))
                {
                    return value;
                }

                return (
                           // everything in layer 2 except shields is 2handed
                           Layer == Layer.LeftHand &&
                           !((iid >= 0x1b72 && iid <= 0x1b7b) || IsVirtueShield) // shields
                       ) ||

                       // and all of these layer 1 weapons:
                       (iid == 0x13fc || iid == 0x13fd) || // hxbow
                       (iid == 0x13AF || iid == 0x13b2) || // war axe & bow
                       (iid >= 0x0F43 && iid <= 0x0F50) || // axes & xbow
                       (iid == 0x1438 || iid == 0x1439) || // war hammer
                       (iid == 0x1442 || iid == 0x1443) || // 2handed axe
                       (iid == 0x1402 || iid == 0x1403) || // short spear
                       (iid == 0x26c1 || iid == 0x26cb) || // aos blade
                       (iid == 0x26c2 || iid == 0x26cc) || // aos bow
                       (iid == 0x26c3 || iid == 0x26cd) // aos xbow
                    ;
            }
        }

        public override string ToString()
        {
            return $"{this.Name} ({this.Serial})";
        }

        public int Price
        {
            get { return _price; }
            set { _price = value; }
        }

        public string BuyDesc
        {
            get { return _buyDesc; }
            set { _buyDesc = value; }
        }

        public int HouseRevision
        {
            get { return _houseRev; }
            set { _houseRev = value; }
        }

        public byte[] HousePacket
        {
            get { return _housePacket; }
            set { _housePacket = value; }
        }

        public void MakeHousePacket()
        {
            _housePacket = null;

            try
            {
                // 3 locations... which is right? all of them? wtf?
                //"Desktop/{0}/{1}/{2}/Multicache.dat", World.AccountName, World.ShardName, World.OrigPlayerName
                //"Desktop/{0}/{1}/{2}/Multicache.dat", World.AccountName, World.ShardName, World.Player.Name );
                //"Desktop/{0}/Multicache.dat", World.AccountName );
                string path = Ultima.Files.GetFilePath(
                    $"Desktop/{World.AccountName}/{World.ShardName}/{World.OrigPlayerName}/Multicache.dat");
                if (string.IsNullOrEmpty(path) || !File.Exists(path))
                    return;

                using (StreamReader reader =
                    new StreamReader(new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)))
                {
                    string line;
                    reader.ReadLine(); // ver
                    int skip = 0;
                    int count = 0;
                    while ((line = reader.ReadLine()) != null)
                    {
                        if (count++ < skip || line == "" || line[0] == ';')
                            continue;

                        string[] split = line.Split(' ', '\t');
                        if (split.Length <= 0)
                            return;

                        skip = 0;
                        Serial ser = (uint) Utility.ToInt32(split[0], 0);
                        int rev = Utility.ToInt32(split[1], 0);
                        int lines = Utility.ToInt32(split[2], 0);

                        if (ser == this.Serial)
                        {
                            _houseRev = rev;
                            MultiTileEntry[] tiles = new MultiTileEntry[lines];
                            count = 0;

                            Ultima.MultiComponentList mcl = Ultima.Multis.GetComponents(_itemId);

                            while ((line = reader.ReadLine()) != null && count < lines)
                            {
                                split = line.Split(' ', '\t');

                                tiles[count] = new MultiTileEntry();
                                tiles[count].m_ItemID = (ushort) Utility.ToInt32(split[0], 0);
                                tiles[count].m_OffsetX = (short) (Utility.ToInt32(split[1], 0) + mcl.Center.X);
                                tiles[count].m_OffsetX = (short) (Utility.ToInt32(split[2], 0) + mcl.Center.Y);
                                tiles[count].m_OffsetX = (short) Utility.ToInt32(split[3], 0);

                                count++;
                            }

                            _housePacket = new DesignStateDetailed(Serial, _houseRev, mcl.Min.X, mcl.Min.Y, mcl.Max.X,
                                mcl.Max.Y, tiles).Compile();
                            break;
                        }
                        else
                        {
                            skip = lines;
                        }

                        count = 0;
                    }
                }
            }
            catch // ( Exception e )
            {
                //Engine.LogCrash( e );
            }
        }
    }
}

================================================
FILE: Razor/Core/ItemID.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;

namespace Assistant
{
    public struct ItemID
    {
        private ushort m_ID;

        public ItemID(ushort id)
        {
            m_ID = id;
        }

        public ushort Value
        {
            get { return m_ID; }
        }

        public static implicit operator ushort(ItemID a)
        {
            return a.m_ID;
        }

        public static implicit operator ItemID(ushort a)
        {
            return new ItemID(a);
        }

        public override string ToString()
        {
            try
            {
                return $"{Ultima.TileData.ItemTable[m_ID].Name} ({m_ID:X4})";
            }
            catch
            {
                return $" ({m_ID:X4})";
            }
        }

        public Ultima.ItemData ItemData
        {
            get
            {
                try
                {
                    return Ultima.TileData.ItemTable[m_ID];
                }
                catch
                {
                    return new Ultima.ItemData("", Ultima.TileFlag.None, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
                }
            }
        }

        public override int GetHashCode()
        {
            return m_ID;
        }

        public override bool Equals(object o)
        {
            if (o == null || !(o is ItemID)) return false;

            return ((ItemID) o).m_ID == m_ID;
        }

        public static bool operator ==(ItemID l, ItemID r)
        {
            return l.m_ID == r.m_ID;
        }

        public static bool operator !=(ItemID l, ItemID r)
        {
            return l.m_ID != r.m_ID;
        }

        public static bool operator >(ItemID l, ItemID r)
        {
            return l.m_ID > r.m_ID;
        }

        public static bool operator >=(ItemID l, ItemID r)
        {
            return l.m_ID >= r.m_ID;
        }

        public static bool operator <(ItemID l, ItemID r)
        {
            return l.m_ID < r.m_ID;
        }

        public static bool operator <=(ItemID l, ItemID r)
        {
            return l.m_ID <= r.m_ID;
        }
    }
}

================================================
FILE: Razor/Core/Main.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Reflection;
using System.Threading;
using System.Windows.Forms;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Net;
using System.Security.Principal;
using Assistant.Core;
using Assistant.UI;

namespace Assistant
{
    public partial class Engine
    {
        private static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
        {
            if (e.IsTerminating)
            {
                Client.Instance.Close();
                m_Running = false;

                new MessageDialog("Unhandled Exception", !e.IsTerminating, e.ExceptionObject.ToString()).ShowDialog(
                    Engine.ActiveWindow);
            }

            LogCrash(e.ExceptionObject as Exception);
        }

        public static void LogCrash(object exception)
        {
            if (exception == null || (exception is ThreadAbortException))
                return;

            using (StreamWriter txt = new StreamWriter("Crash.log", true))
            {
                txt.AutoFlush = true;
                txt.WriteLine("Exception @ {0}", Engine.MistedDateTime.ToString("MM-dd-yy HH:mm:ss.ffff"));
                txt.WriteLine(exception.ToString());
                txt.WriteLine("");
                txt.WriteLine("");
            }
        }

        private static Version m_ClientVersion = null;

        public static Version ClientVersion
        {
            get
            {
                if (m_ClientVersion == null || m_ClientVersion.Major < 2)
                {
                    string[] split = Client.Instance.GetClientVersion().Split('.');

                    if (split.Length < 3)
                        return new Version(4, 0, 0, 0);

                    int rev = 0;

                    if (split.Length > 3)
                        rev = Utility.ToInt32(split[3], 0);

                    m_ClientVersion = new Version(
                        Utility.ToInt32(split[0], 0),
                        Utility.ToInt32(split[1], 0),
                        Utility.ToInt32(split[2], 0),
                        rev);

                    if (m_ClientVersion.Major == 0) // sanity check if the client returns 0.0.0.0
                        m_ClientVersion = new Version(4, 0, 0, 0);
                }

                return m_ClientVersion;
            }
        }

        public static bool UseNewMobileIncoming
        {
            get
            {
                if (ClientVersion.Major > 7)
                {
                    return true;
                }
                else if (ClientVersion.Major == 7)
                {
                    if (ClientVersion.Minor > 0 || ClientVersion.Build >= 33)
                    {
                        return true;
                    }
                }

                return false;
            }
        }

        public static bool UsePostHSChanges
        {
            get
            {
                if (ClientVersion.Major > 7)
                {
                    return true;
                }
                else if (ClientVersion.Major == 7)
                {
                    if (ClientVersion.Minor > 0)
                    {
                        return true;
                    }
                    else if (ClientVersion.Build >= 9)
                    {
                        return true;
                    }
                }

                return false;
            }
        }

        public static bool UsePostSAChanges
        {
            get
            {
                if (ClientVersion.Major >= 7)
                {
                    return true;
                }

                return false;
            }
        }

        public static bool UsePostKRPackets
        {
            get
            {
                if (ClientVersion.Major >= 7)
                {
                    return true;
                }
                else if (ClientVersion.Major >= 6)
                {
                    if (ClientVersion.Minor == 0)
                    {
                        if (ClientVersion.Build == 1)
                        {
                            if (ClientVersion.Revision >= 7)
                                return true;
                        }
                        else if (ClientVersion.Build > 1)
                        {
                            return true;
                        }
                    }
                    else
                    {
                        return true;
                    }
                }

                return false;
            }
        }

        public static string ExePath
        {
            get { return Process.GetCurrentProcess().MainModule.FileName; }
        }

        public static MainForm MainWindow
        {
            get { return m_MainWnd; }
        }

        public static bool Running
        {
            get { return m_Running; }
        }

        public static Form ActiveWindow
        {
            get { return m_ActiveWnd; }
            set { m_ActiveWnd = value; }
        }

        public static string Version
        {
            get
            {
                if (m_Version == null)
                {
                    Version v = Assembly.GetCallingAssembly().GetName().Version;
                    m_Version = $"{v.Major}.{v.Minor}.{v.Build}.{v.Revision}"; //, v.Revision
                }

                return m_Version;
            }
        }

        private static MainForm m_MainWnd;
        
        private static Form m_ActiveWnd;

        //private static Thread m_TimerThread;
        private static bool m_Running;
        private static string m_Version;

        private static int _previousHour = -1;
        private static int _Differential;

        public static int Differential //to use in all cases where you rectify normal clocks obtained with utctimer!
        {
            get
            {
                if (_previousHour != DateTime.UtcNow.Hour)
                {
                    _previousHour = DateTime.UtcNow.Hour;
                    _Differential = DateTimeOffset.Now.Offset.Hours;
                }

                return _Differential;
            }
        }

        public static DateTime MistedDateTime
        {
            get { return DateTime.UtcNow.AddHours(Differential); }
        }

        public static CultureInfo Culture;

        public static void Load()
        {
            Culture = new CultureInfo("en-US", false);
            Culture.NumberFormat.NumberDecimalSeparator = ".";
            Culture.NumberFormat.NumberGroupSeparator = ",";

            /* Load localization files */
            string defLang = Config.GetAppSetting<string>("DefaultLanguage");
            if (defLang == null)
            {
                defLang = "ENU";
            }

            if (Client.IsOSI)
            {
                Ultima.Files.ReLoadDirectory();
                Ultima.Files.LoadMulPath();
            }

            if (!Language.Load(defLang))
            {
                MessageBox.Show(
                    $"WARNING: Razor was unable to load the file Language/Razor_lang.{defLang}\n.", "Language Load Error", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }

            m_Running = true;

            /* Load settings from configuration file */
            Ultima.Files.SetMulPath(Config.GetAppSetting<string>("UODataDir"));
            Client.Instance.ClientEncrypted = Config.GetAppSetting<int>("ClientEncrypted") == 1;
            Client.Instance.ServerEncrypted = Config.GetAppSetting<int>("ServerEncrypted") == 1;

            Language.LoadCliLoc();

            /* Initialize engine */
            SplashScreen.Message = LocString.Initializing;
            Initialize(typeof(Engine).Assembly);

            /* Load Profile */
            SplashScreen.Message = LocString.LoadingLastProfile;
            Config.LoadCharList();
            Overrides.Load();
            if (!Config.LoadLastProfile())
                MessageBox.Show(
                    "The selected profile could not be loaded, using default instead.", "Profile Load Error",
                    MessageBoxButtons.OK, MessageBoxIcon.Warning);

            /* Start client */
            SplashScreen.Message = LocString.LoadingClient;
            string clientPath = Ultima.Files.GetFilePath("client.exe");
            if (clientPath == null || !File.Exists(clientPath))
            {
                MessageBox.Show(SplashScreen.Instance,
                    $"Unable to find the client specified.\n\"{(clientPath != null ? clientPath : "-null-")}\"", "Could Not Find Client",
                    MessageBoxButtons.OK, MessageBoxIcon.Stop);
                SplashScreen.End();
                return;
            }

            var result = Client.Instance.LaunchClient(clientPath);
            if (result != Client.Loader_Error.SUCCESS)
            {
                MessageBox.Show(SplashScreen.Instance,
                    String.Format("Unable to launch the client specified. (Error: {1})\n \"{0}\"",
                        clientPath != null ? clientPath : "-null-", result),
                    "Could Not Start Client", MessageBoxButtons.OK, MessageBoxIcon.Stop);
                SplashScreen.End();
                return;
            }

            string addr = Config.GetAppSetting<string>("LastServer");
            int port = Config.GetAppSetting<int>("LastPort");

            IPAddress ip = Resolve(addr);
            if (ip == IPAddress.None || port == 0)
            {
                MessageBox.Show(SplashScreen.Instance, Language.GetString(LocString.BadServerAddr),
                    "Bad Server Address", MessageBoxButtons.OK, MessageBoxIcon.Stop);
                SplashScreen.End();
                return;
            }

            Client.Instance.SetConnectionInfo(ip, port);

            SplashScreen.Message = LocString.WaitingForClient;
        }

        public static void Close()
        {
            m_Running = false;

            Client.Instance.Close();
            Counter.Save();
            Macros.MacroManager.Save();
            Config.Save();
        }

        public static void RunUI()
        {
            Thread.CurrentThread.Name = "Razor UI Thread";

            m_MainWnd = new MainForm();
            m_MainWnd.Show();
            Application.Run(m_MainWnd);
        }

        [STAThread]
        public static void Main(string[] Args)
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

#if !DEBUG
			AppDomain.CurrentDomain.UnhandledException +=
 new UnhandledExceptionEventHandler( CurrentDomain_UnhandledException );
			Directory.SetCurrentDirectory( Config.GetInstallDirectory() );
#endif

            /* Load localization files */
            string defLang = Config.GetAppSetting<string>("DefaultLanguage");
            if (defLang == null)
            {
                defLang = "ENU";
            }

            Client.Init(true);

            if (Client.IsOSI)
            {
                Ultima.Files.ReLoadDirectory();
                Ultima.Files.LoadMulPath();
            }

            if (!Language.Load(defLang))
            {
                MessageBox.Show(
                    $"WARNING: Razor was unable to load the file Language/Razor_lang.{defLang}\n.", "Language Load Error", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }

            /* Show welcome screen */
            if (Config.GetAppSetting<int>("ShowWelcome") != 0)
            {
                SplashScreen.End();

                WelcomeForm welcome = new WelcomeForm();
                m_ActiveWnd = welcome;
                if (welcome.ShowDialog() == DialogResult.Cancel)
                    return;

                SplashScreen.Start();
                m_ActiveWnd = SplashScreen.Instance;
            }

            Load();
            RunUI();
            Close();
        }

        private static string _rootPath = null;

        public static string RootPath =>
            _rootPath ?? (_rootPath = Path.GetDirectoryName(Assembly.GetAssembly(typeof(Engine)).Location));

        /*public static string GetDirectory( string relPath )
        {
            string path = Path.Combine(ExeDirectory, relPath);
            EnsureDirectory( path );
            return path;
        }*/

        public static void EnsureDirectory(string dir)
        {
            if (!Directory.Exists(dir))
                Directory.CreateDirectory(dir);
        }

        private static void Initialize(Assembly a)
        {
            Type[] types = a.GetTypes();

            for (int i = 0; i < types.Length; i++)
            {
                if (types[i].Namespace == "Ultima")
                    continue;
                MethodInfo init = types[i].GetMethod("Initialize", BindingFlags.Static | BindingFlags.Public);

                if (init != null)
                    init.Invoke(null, null);
            }
        }

        private static IPAddress Resolve(string addr)
        {
            IPAddress ipAddr = IPAddress.None;

            if (string.IsNullOrEmpty(addr))
                return ipAddr;

            try
            {
                ipAddr = IPAddress.Parse(addr);
            }
            catch
            {
                try
                {
                    IPHostEntry iphe = Dns.GetHostEntry(addr);

                    if (iphe.AddressList.Length > 0)
                        ipAddr = iphe.AddressList[iphe.AddressList.Length - 1];
                }
                catch
                {
                }
            }

            return ipAddr;
        }

        public static bool IsElevated
        {
            get
            {
                return new WindowsPrincipal(WindowsIdentity.GetCurrent()).IsInRole(WindowsBuiltInRole.Administrator);
            }
        }
    }
}

================================================
FILE: Razor/Core/Map.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using Ultima;

namespace Assistant
{
    public class MultiTileEntry
    {
        public ushort m_ItemID;
        public short m_OffsetX;
        public short m_OffsetY;
        public short m_OffsetZ;
    }

    public class Map
    {
        public static Ultima.Map GetMap(int mapNum)
        {
            switch (mapNum)
            {
                case 1: return Ultima.Map.Trammel;
                case 2: return Ultima.Map.Ilshenar;
                case 3: return Ultima.Map.Malas;
                case 4: return Ultima.Map.Tokuno;
                case 5: return Ultima.Map.TerMur;
                case 0:
                default: return Ultima.Map.Felucca;
            }
        }

        public static int Parse(string name)
        {
            if (string.IsNullOrEmpty(name))
                return 0;

            name = name.ToLower();

            if (name == "felucca")
                return 0;
            else if (name == "trammel")
                return 1;
            else if (name == "ilshenar")
                return 2;
            else if (name == "malas")
                return 3;
            else if (name == "samurai" || name == "tokuno")
                return 4;
            else
                return 0;
        }

        public static HuedTile GetTileNear(int mapNum, int x, int y, int z)
        {
            try
            {
                Ultima.Map map = GetMap(mapNum);

                HuedTile[] tiles = map.Tiles.GetStaticTiles(x, y);
                if (tiles != null && tiles.Length > 0)
                {
                    for (int i = 0; i < tiles.Length; i++)
                    {
                        if (tiles[i].Z >= z - 5 && tiles[i].Z <= z + 5)
                            return tiles[i];
                    }
                }
            }
            catch
            {
            }

            return new HuedTile(0, 0, (sbyte) z);
        }

        private static void GetAverageZ(Ultima.Map map, int x, int y, ref int z, ref int avg, ref int top)
        {
            try
            {
                int zTop = map.Tiles.GetLandTile(x, y).Z;
                int zLeft = map.Tiles.GetLandTile(x, y + 1).Z;
                int zRight = map.Tiles.GetLandTile(x + 1, y).Z;
                int zBottom = map.Tiles.GetLandTile(x + 1, y + 1).Z;

                z = zTop;
                if (zLeft < z)
                    z = zLeft;
                if (zRight < z)
                    z = zRight;
                if (zBottom < z)
                    z = zBottom;

                top = zTop;
                if (zLeft > top)
                    top = zLeft;
                if (zRight > top)
                    top = zRight;
                if (zBottom > top)
                    top = zBottom;

                if (Math.Abs(zTop - zBottom) > Math.Abs(zLeft - zRight))
                    avg = (int) Math.Floor((zLeft + zRight) / 2.0);
                else
                    avg = (int) Math.Floor((zTop + zBottom) / 2.0);
            }
            catch
            {
            }
        }

        public static sbyte ZTop(int mapNum, int xCheck, int yCheck, int oldZ)
        {
            try
            {
                Ultima.Map map = GetMap(mapNum);

                Tile landTile = map.Tiles.GetLandTile(xCheck, yCheck);
                int landZ = 0, landCenter = 0, zTop = 0;

                GetAverageZ(map, xCheck, yCheck, ref landZ, ref landCenter, ref zTop);

                if (zTop > oldZ)
                    oldZ = zTop;

                bool isSet = false;
                HuedTile[] staticTiles = map.Tiles.GetStaticTiles(xCheck, yCheck);
                for (int i = 0; i < staticTiles.Length; ++i)
                {
                    HuedTile tile = staticTiles[i];
                    ItemData id = TileData.ItemTable[tile.ID & 0x3FFF];

                    int calcTop = (tile.Z + id.CalcHeight);

                    if (calcTop <= oldZ + 5 && (!isSet || calcTop > zTop) &&
                        ((id.Flags & TileFlag.Surface) != 0 || (id.Flags & TileFlag.Wet) != 0))
                    {
                        zTop = calcTop;
                        isSet = true;
                    }
                }

                return (sbyte) zTop;
            }
            catch
            {
                return (sbyte) oldZ;
            }
        }
    }
}

================================================
FILE: Razor/Core/MemHelper.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;

namespace Assistant
{
    public class MemoryHelperThinggie : Timer
    {
        private static TimeSpan Frequency = TimeSpan.FromMinutes(2.5);

        public static readonly MemoryHelperThinggie Instance = new MemoryHelperThinggie();

        public static void Initialize()
        {
            if (Environment.OSVersion.Platform == PlatformID.Win32NT)
                Instance.Start();
        }

        private MemoryHelperThinggie() : base(TimeSpan.Zero, Frequency)
        {
        }

        [System.Runtime.InteropServices.DllImport("Kernel32")]
        private static extern uint SetProcessWorkingSetSize(IntPtr hProc, int minSize, int maxSize);

        protected override void OnTick()
        {
            SetProcessWorkingSetSize(System.Diagnostics.Process.GetCurrentProcess().Handle, -1, -1);
        }
    }
}

================================================
FILE: Razor/Core/MessageInBottleCapture.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.IO;
using System.Linq;

namespace Assistant.Core
{
    public class MessageInBottleCapture
    {
        private static readonly string[] _mibGumpLayout =
        {
            "{ page 0 }{ resizepic 0 40 2520 350 300 }{ xmfhtmlgump 30 80 285 160 1018326 1 1 }{ htmlgump 35 240 230 20 0 0 0 }{ button 35 265 4005 4007 1 0 0 }{ xmfhtmlgump 70 265 100 20 1011036 0 0 }",
            "{ page 0 }{ htmlgump 200 140 230 20 0 0 0 }{ resizepic 0 40 2520 350 300 }{ xmfhtmlgump 30 80 285 160 1018326 1 1 }{ htmlgump 35 240 230 20 1 0 0 }{ button 35 265 4005 4007 1 0 0 }{ xmfhtmlgump 70 265 100 20 1011036 0 0 }"
        };

        public static bool IsMibGump(string layout)
        {
            return _mibGumpLayout.Any(
                gumpLayout => layout.IndexOf(gumpLayout, StringComparison.OrdinalIgnoreCase) != -1);
        }

        public static void CaptureMibCoordinates(string coords, bool hasXY)
        {
            string mibLog = Path.Combine(Config.GetInstallDirectory(), "MIBCapture.csv");

            if (!File.Exists(mibLog))
            {
                File.Create(mibLog);
            }

            // 130°15'N,63°16'W

            int xAxis = 0;
            int yAxis = 0;

            if (hasXY)
            {
                // 0   1 2
                // MIB|x|y
                string[] mibCoords = coords.Split('|');
                xAxis = Convert.ToInt32(mibCoords[1]);
                yAxis = Convert.ToInt32(mibCoords[2]);
            }
            else
            {
                ConvertCoords(coords, ref xAxis, ref yAxis);
            }

            using (StreamWriter sw = File.AppendText(mibLog))
            {
                sw.WriteLine($"{xAxis},{yAxis},{World.Player.Map},mib,mib,red,3");
            }

            World.Player.SendMessage(MsgLevel.Force, $"MIB Captured: {xAxis},{yAxis}");
        }


        private static void ConvertCoords(string coords, ref int xAxis, ref int yAxis)
        {
            string[] coordsSplit = coords.Split(',');

            string yCoord = coordsSplit[0];
            string xCoord = coordsSplit[1];

            // Calc Y first
            string[] ySplit = yCoord.Split('°');
            double yDegree = Convert.ToDouble(ySplit[0]);
            double yMinute = Convert.ToDouble(ySplit[1].Substring(0, ySplit[1].IndexOf("'", StringComparison.Ordinal)));

            if (yCoord.Substring(yCoord.Length - 1).Equals("N"))
            {
                yAxis = (int) (1624 - (yMinute / 60) * (4096.0 / 360) - yDegree * (4096.0 / 360));
            }
            else
            {
                yAxis = (int) (1624 + (yMinute / 60) * (4096.0 / 360) + yDegree * (4096.0 / 360));
            }

            // Calc X next
            string[] xSplit = xCoord.Split('°');
            double xDegree = Convert.ToDouble(xSplit[0]);
            double xMinute = Convert.ToDouble(xSplit[1].Substring(0, xSplit[1].IndexOf("'", StringComparison.Ordinal)));

            if (xCoord.Substring(xCoord.Length - 1).Equals("W"))
            {
                xAxis = (int) (1323 - (xMinute / 60) * (5120.0 / 360) - xDegree * (5120.0 / 360));
            }
            else
            {
                xAxis = (int) (1323 + (xMinute / 60) * (5120.0 / 360) + xDegree * (5120.0 / 360));
            }

            // Normalize values outside of map range.
            if (xAxis < 0)
                xAxis += 5120;
            else if (xAxis > 5120)
                xAxis -= 5120;

            if (yAxis < 0)
                yAxis += 4096;
            else if (yAxis > 4096)
                yAxis -= 4096;
        }
    }
}

================================================
FILE: Razor/Core/MessageManager.cs
================================================
#region license

// Razor: An Ultima Online Assistant
// Copyright (C) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#endregion

using System;
using System.IO;
using Assistant.Agents;

namespace Assistant.Core
{
    public static class MessageManager
    {
        public static Action<Packet, PacketHandlerEventArgs, Serial, ushort, MessageType, ushort, ushort, string, string, string> OnSpellMessage { get; set; }
        public static Action<Packet, PacketHandlerEventArgs, Serial, ushort, MessageType, ushort, ushort, string, string, string> OnLabelMessage { get; set; }
        public static Action<Packet, PacketHandlerEventArgs, Serial, ushort, MessageType, ushort, ushort, string, string, string> OnSystemMessage { get; set; }
        public static Action<Packet, PacketHandlerEventArgs, Serial, ushort, MessageType, ushort, ushort, string, string, string> OnMobileMessage { get; set; }

        public static bool GetLabelCommand { get; set; } = false;

        public static void Initialize()
        {
            OnMobileMessage += HandleMobileMessage;
        }

        public static void HandleMessage(Packet p, PacketHandlerEventArgs args, Serial source, ushort graphic,
                                         MessageType type, ushort hue, ushort font, string lang, string sourceName,
                                         string text)
        {
            if (World.Player == null)
            {
                return;
            }

            switch (type)
            {
                case MessageType.Spell:
                    OnSpellMessage?.Invoke(p, args, source, graphic, type, hue, font, lang, sourceName, text);
                    break;

                case MessageType.Label:
                    if (source.IsMobile)
                    {
                        Mobile m = World.FindMobile(source);
                        if (m != null)
                        {
                            m.Name = sourceName;
                        }
                    }

                    OnLabelMessage?.Invoke(p, args, source, graphic, type, hue, font, lang, sourceName, text);
                    break;

                case MessageType.Emote:

                    if (Config.GetBool("PlayEmoteSound") && source.IsMobile)
                    {
                        Mobile m = World.FindMobile(source);

                        if (m != null)
                        {
                            text = text.Trim('*');

                            if (m.Female)
                            {
                                if (Enum.TryParse(text, true, out FemaleSounds sound))
                                {
                                    if (sound != 0)
                                    {
                                        Client.Instance.SendToClient(new PlaySound((int)sound));
                                    }
                                }
                            }
                            else
                            {
                                if (Enum.TryParse(text, true, out MaleSounds sound))
                                {
                                    if (sound != 0)
                                    {
                                        Client.Instance.SendToClient(new PlaySound((int) sound));
                                    }
                                }
                            }
                        }
                    }

                    break;
            }

            OnSystemMessage?.Invoke(p, args, source, graphic, type, hue, font, lang, sourceName, text);

            if (GetLabelCommand)
            {
                OnLabelMessage?.Invoke(p, args, source, graphic, type, hue, font, lang, sourceName, text);
            }
            else
            {
                OnMobileMessage?.Invoke(p, args, source, graphic, type, hue, font, lang, sourceName, text);
            }
        }

        public static void HandleMobileMessage(Packet p, PacketHandlerEventArgs args, Serial source, ushort graphic,
                                 MessageType type, ushort hue, ushort font, string lang, string sourceName,
                                 string text)
        {
            if ((type == MessageType.Emote || type == MessageType.Regular || type == MessageType.Whisper ||
                 type == MessageType.Yell) && source.IsMobile && source != World.Player.Serial)
            {
                if (Config.GetBool("ForceSpeechHue"))
                {
                    p.Seek(10, SeekOrigin.Begin);
                    p.Write((ushort)Config.GetInt("SpeechHue"));
                }
            }
        }
    }
}

================================================
FILE: Razor/Core/Mobile.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.IO;
using System.Collections.Generic;
using System.Text;
using Assistant.Agents;
using Assistant.UI;

namespace Assistant
{
    [Flags]
    public enum Direction : byte
    {
        North = 0x0,
        Right = 0x1,
        East = 0x2,
        Down = 0x3,
        South = 0x4,
        Left = 0x5,
        West = 0x6,
        Up = 0x7,
        Mask = 0x7,
        Running = 0x80,
        ValueMask = 0x87
    }

    //public enum BodyType : byte
    //{
    //    Empty,
    //    Monster,
    //    Sea_Monster,
    //    Animal,
    //    Human,
    //    Equipment
    //}

    public class Mobile : UOEntity
    {
        private ushort m_Body;
        private Direction m_Direction;
        private string m_Name;

        private byte m_Notoriety;

        private bool m_Visible;
        private bool m_Female;
        private bool m_Poisoned;
        private bool m_Blessed;
        private bool m_Paralyze;
        private bool m_Warmode;

        //new
        private bool m_Unknown;
        private bool m_Unknown2;
        private bool m_Unknown3;

        private bool m_CanRename;
        //end new

        private ushort m_HitsMax, m_Hits;
        protected ushort m_StamMax, m_Stam, m_ManaMax, m_Mana;

        private List<Serial> m_LoadSerials;
        private List<Item> m_Items = new List<Item>();

        private byte m_Map;
        
        public override void AfterLoad()
        {
            int count = m_LoadSerials.Count;

            for (int i = count - 1; i >= 0; --i)
            {
                Item it = World.FindItem(m_LoadSerials[i]);
                if (it != null)
                    m_Items.Add(it);
            }

            m_LoadSerials = null; //per il GC e per liberare RAM
        }

        public Mobile(Serial serial) : base(serial)
        {
            m_Map = World.Player == null ? (byte) 0 : World.Player.Map;
            m_Visible = true;

            Agent.InvokeMobileCreated(this);
        }

        public string Name
        {
            get
            {
                if (m_Name == null)
                    return "";
                else
                    return m_Name;
            }
            set
            {
                if (!string.IsNullOrEmpty(value) && value != m_Name)
                {
                    string trim = ClilocConversion(value);
                    if (trim.Length > 0)
                    {
                        m_Name = trim;
                    }
                }
            }
        }

        private static StringBuilder _InternalSB = new StringBuilder(32);

        private static string ClilocConversion(string old)
        {
            _InternalSB.Clear();
            string[] arr = old.Split(' ');
            for (int i = 0; i < arr.Length; i++)
            {
                string ss = arr[i];
                if (ss.Length > 1 && ss.StartsWith("#"))
                {
                    if (int.TryParse(ss.Substring(1), out int x))
                    {
                        ss = Language.GetCliloc(x);
                        if (string.IsNullOrEmpty(ss))
                        {
                            ss = arr[i];
                        }
                    }
                }

                _InternalSB.Append(ss);
                _InternalSB.Append(' ');
            }

            return _InternalSB.ToString().Trim();
        }

        public ushort Body
        {
            get { return m_Body; }
            set { m_Body = value; }
        }

        public Direction Direction
        {
            get { return m_Direction; }
            set
            {
                if (value != m_Direction)
                {
                    var oldDir = m_Direction;
                    m_Direction = value;
                    OnDirectionChanging(oldDir);
                }
            }
        }

        public bool Visible
        {
            get { return m_Visible; }
            set { m_Visible = value; }
        }

        public bool Poisoned
        {
            get { return m_Poisoned; }
            set { m_Poisoned = value; }
        }

        public bool Blessed
        {
            get { return m_Blessed; }
            set { m_Blessed = value; }
        }

        public bool Paralyzed
        {
            get { return m_Paralyze; }
            set { m_Paralyze = value; }
        }

        public bool IsGhost
        {
            get
            {
                return m_Body == 402
                       || m_Body == 403
                       || m_Body == 607
                       || m_Body == 608
                       || m_Body == 970;
            }
        }

        public bool IsHuman
        {
            get
            {
                return m_Body >= 0
                       && (m_Body == 400
                           || m_Body == 401
                           || m_Body == 402
                           || m_Body == 403
                           || m_Body == 605
                           || m_Body == 606
                           || m_Body == 607
                           || m_Body == 608
                           || m_Body == 970); //player ghost
            }
        }

        public bool IsMonster
        {
            get { return !IsHuman; }
        }

        //new
        public bool Unknown
        {
            get { return m_Unknown; }
            set { m_Unknown = value; }
        }

        public bool Unknown2
        {
            get { return m_Unknown2; }
            set { m_Unknown2 = value; }
        }

        public bool Unknown3
        {
            get { return m_Unknown3; }
            set { m_Unknown3 = value; }
        }

        public bool CanRename //A pet! (where the health bar is open, we can add this to an arraylist of mobiles...
        {
            get { return m_CanRename; }
            set { m_CanRename = value; }
        }
        //end new

        public bool Warmode
        {
            get { return m_Warmode; }
            set { m_Warmode = value; }
        }

        public bool Female
        {
            get { return m_Female; }
            set { m_Female = value; }
        }

        public byte Notoriety
        {
            get { return m_Notoriety; }
            set
            {
                if (value != Notoriety)
                {
                    OnNotoChange(m_Notoriety, value);
                    m_Notoriety = value;
                }
            }
        }

        protected virtual void OnNotoChange(byte old, byte cur)
        {
        }

        // grey, blue, green, 'canbeattacked'
        private static uint[] m_NotoHues = new uint[8]
        {
            // hue color #30
            0x000000, // black		unused 0
            0x30d0e0, // blue		0x0059 1
            0x60e000, // green		0x003F 2
            0x9090b2, // greyish	0x03b2 3
            0x909090, // grey		   "   4
            0xd88038, // orange		0x0090 5
            0xb01000, // red		0x0022 6
            0xe0e000 // yellow		0x0035 7
        };

        private static int[] m_NotoHuesInt = new int[8]
        {
            1, // black		unused 0
            0x059, // blue		0x0059 1
            0x03F, // green		0x003F 2
            0x3B2, // greyish	0x03b2 3
            0x3B2, // grey		   "   4
            0x090, // orange		0x0090 5
            0x022, // red		0x0022 6
            0x035, // yellow		0x0035 7
        };

        public uint GetNotorietyColor()
        {
            if (m_Notoriety < 0 || m_Notoriety >= m_NotoHues.Length)
                return m_NotoHues[0];
            else
                return m_NotoHues[m_Notoriety];
        }

        public int GetNotorietyColorInt()
        {
            if (m_Notoriety < 0 || m_Notoriety >= m_NotoHues.Length)
                return m_NotoHuesInt[0];
            else
                return m_NotoHuesInt[m_Notoriety];
        }

        public byte GetStatusCode()
        {
            if (m_Poisoned)
                return 1;
            else
                return 0;
        }

        public ushort HitsMax
        {
            get { return m_HitsMax; }
            set { m_HitsMax = value; }
        }

        public ushort Hits
        {
            get { return m_Hits; }
            set { m_Hits = value; }
        }

        public ushort Stam
        {
            get { return m_Stam; }
            set { m_Stam = value; }
        }

        public ushort StamMax
        {
            get { return m_StamMax; }
            set { m_StamMax = value; }
        }

        public ushort Mana
        {
            get { return m_Mana; }
            set { m_Mana = value; }
        }

        public ushort ManaMax
        {
            get { return m_ManaMax; }
            set { m_ManaMax = value; }
        }


        public byte Map
        {
            get { return m_Map; }
            set
            {
                if (m_Map != value)
                {
                    OnMapChange(m_Map, value);
                    m_Map = value;
                }
            }
        }

        public virtual void OnMapChange(byte old, byte cur)
        {
        }

        public void AddItem(Item item)
        {
            m_Items.Add(item);
        }

        public void RemoveItem(Item item)
        {
            m_Items.Remove(item);
        }

        public override void Remove()
        {
            List<Item> rem = new List<Item>(m_Items);
            m_Items.Clear();

            for (int i = 0; i < rem.Count; i++)
                rem[i].Remove();

            if (!InParty)
            {
                base.Remove();
                World.RemoveMobile(this);
            }
            else
            {
                Visible = false;
            }
        }

        public bool InParty
        {
            get { return PacketHandlers.Party.Contains(this.Serial); }
        }

        public Item GetItemOnLayer(Layer layer)
        {
            for (int i = 0; i < m_Items.Count; i++)
            {
                Item item = (Item) m_Items[i];
                if (item.Layer == layer)
                    return item;
            }

            return null;
        }

        public Item Backpack
        {
            get { return GetItemOnLayer(Layer.Backpack); }
        }

        public Item Quiver
        {
            get
            {
                Item item = GetItemOnLayer(Layer.Cloak);

                if (item != null && item.IsContainer)
                    return item;
                else
                    return null;
            }
        }

        public Item FindItemByID(ItemID id)
        {
            for (int i = 0; i < Contains.Count; i++)
            {
                Item item = (Item) Contains[i];
                if (item.ItemID == id)
                    return item;
            }

            return null;
        }

        public override void OnPositionChanging(Point3D oldPos)
        {
            if (this != World.Player && Engine.MainWindow.MapWindow != null)
                Engine.MainWindow.SafeAction(s => s.MapWindow.CheckLocalUpdate(this));

            base.OnPositionChanging(oldPos);
        }

        public virtual void OnDirectionChanging(Direction oldDir)
        {
        }

        public int GetPacketFlags()
        {
            int flags = 0x0;

            if (m_Paralyze)
                flags |= 0x01;

            if (m_Female)
                flags |= 0x02;

            if (m_Poisoned)
                flags |= 0x04;

            if (m_Blessed)
                flags |= 0x08;

            if (m_Warmode)
                flags |= 0x40;

            if (!m_Visible)
                flags |= 0x80;

            if (m_Unknown)
                flags |= 0x01;

            if (m_Unknown2)
                flags |= 0x10;

            if (m_Unknown3)
                flags |= 0x20;

            return flags;
        }

        public void ProcessPacketFlags(byte flags)
        {
            if (!PacketHandlers.UseNewStatus)
                m_Poisoned = (flags & 0x04) != 0;

            m_Paralyze = (flags & 0x01) != 0;
            m_Female = (flags & 0x02) != 0;
            m_Blessed = (flags & 0x08) != 0;
            m_Unknown2 = (flags & 0x10) != 0; //new
            m_Unknown3 = (flags & 0x10) != 0; //new
            m_Warmode = (flags & 0x40) != 0;
            m_Visible = (flags & 0x80) == 0;
        }

        public List<Item> Contains
        {
            get { return m_Items; }
        }

        internal void OverheadMessageFrom(int hue, string from, string format, params object[] args)
        {
            OverheadMessageFrom(hue, from, String.Format(format, args));
        }

        internal void OverheadMessageFrom(int hue, string from, string text, bool ascii)
        {
            if (Config.GetBool("FilterOverheadMessages"))
            {
                if (!MessageQueue.Enqueue(this, hue, "O", text))
                {
                    return;
                }
            }

            if (ascii)
            {
                Client.Instance.SendToClient(new AsciiMessage(Serial, m_Body, MessageType.Regular, hue, 3, from, text));
            }
            else
            {
                Client.Instance.SendToClient(new UnicodeMessage(Serial, m_Body, MessageType.Regular, hue, 3,
                    Language.CliLocName, from, text));
            }
        }

        internal void OverheadMessageFrom(int hue, string from, string text)
        {
            bool ascii = Config.GetInt("OverheadStyle") == 0;

            OverheadMessageFrom(hue, from, text, ascii);
        }

        internal void OverheadMessage(string text)
        {
            OverheadMessage(Config.GetInt("SysColor"), text);
        }

        internal void OverheadMessage(string format, params object[] args)
        {
            OverheadMessage(Config.GetInt("SysColor"), String.Format(format, args));
        }

        internal void OverheadMessage(int hue, string format, params object[] args)
        {
            OverheadMessage(hue, String.Format(format, args));
        }

        internal void OverheadMessage(int hue, string text)
        {
            OverheadMessageFrom(hue, "Razor", text);
        }

        internal void OverheadMessage(LocString str)
        {
            OverheadMessage(Language.GetString(str));
        }

        internal void OverheadMessage(LocString str, params object[] args)
        {
            OverheadMessage(Language.Format(str, args));
        }

        private Point2D m_ButtonPoint = Point2D.Zero;

        internal Point2D ButtonPoint
        {
            get { return m_ButtonPoint; }
            set { m_ButtonPoint = value; }
        }

        private static List<Layer> _layers = new List<Layer>
        {
            Layer.Backpack,
            Layer.Invalid,
            Layer.FirstValid,
            Layer.RightHand,
            Layer.LeftHand,
            Layer.Shoes,
            Layer.Pants,
            Layer.Shirt,
            Layer.Head,
            Layer.Neck,
            Layer.Gloves,
            Layer.InnerTorso,
            Layer.MiddleTorso,
            Layer.Arms,
            Layer.Cloak,
            Layer.OuterTorso,
            Layer.OuterLegs,
            Layer.InnerLegs,
            Layer.LastUserValid,
            Layer.Mount,
            Layer.LastValid,
            Layer.Hair
        };

        internal void ResetLayerHue()
        {
            if (IsGhost)
                return;

            foreach (Layer l in _layers)
            {
                Item i = GetItemOnLayer(l);

                if (i == null)
                    continue;

                if (i.ItemID == 0x204E && i.Hue == 0x08FD) // death shroud
                    i.ItemID = 0x1F03;

                Client.Instance.SendToClient(new EquipmentItem(i, i.Hue, Serial));
            }
        }

        internal void SetLayerHue(int hue)
        {
            if (IsGhost)
                return;

            foreach (Layer l in _layers)
            {
                Item i = GetItemOnLayer(l);
                if (i == null)
                    continue;

                Client.Instance.SendToClient(new EquipmentItem(i, (ushort) hue, Serial));
            }
        }

        internal Packet SetMobileHue(Packet p, int hue)
        {
            if (IsGhost)
                return p;

            p = WriteHueToPacket(p, (ushort) hue);

            return p;
        }

        private static Packet WriteHueToPacket(Packet p, ushort color)
        {
            p.Seek(-3, SeekOrigin.Current);
            p.Write((short) color);
            p.Seek(+1, SeekOrigin.Current);
            return p;
        }
    }
}

================================================
FILE: Razor/Core/MsgQueue.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;

namespace Assistant
{
    public class MessageQueue
    {
        private class MsgInfo
        {
            public MsgInfo(Serial ser, Mobile m, ushort body, MessageType type, ushort hue, ushort font, string lang,
                string name)
            {
                Serial = ser;
                Body = body;
                Type = type;
                Hue = hue;
                Font = font;
                Lang = lang;
                Name = name;
                Mobile = m;
            }

            public TimeSpan Delay;
            public DateTime NextSend;
            public int Count;

            public Mobile Mobile;

            //ser, body, type, hue, font, lang, name
            public Serial Serial;
            public ushort Body, Hue, Font;
            public MessageType Type;
            public string Lang, Name;
        }

        private class MessageTimer : Timer
        {
            public MessageTimer() : base(TimeSpan.FromSeconds(0.1), TimeSpan.FromSeconds(0.1))
            {
            }

            protected override void OnTick()
            {
                if (m_Table.Count <= 0)
                    return;

                List<string> toremove = new List<string>();
                foreach (KeyValuePair<string, MsgInfo> de in m_Table)
                {
                    string txt = de.Key;
                    MsgInfo msg = de.Value;

                    if (msg.NextSend <= DateTime.UtcNow)
                    {
                        if (msg.Count > 0)
                        {
                            switch (msg.Lang)
                            {
                                case "O":
                                    msg.Mobile.OverheadMessage(msg.Hue, msg.Count > 1 ? $"{txt} [{msg.Count}]" : txt);

                                    break;
                                case "A":
                                    Client.Instance.SendToClient(new AsciiMessage(msg.Serial, msg.Body, msg.Type,
                                        msg.Hue, msg.Font, msg.Name,
                                        msg.Count > 1 ? $"{txt} [{msg.Count}]" : txt));
                                    break;
                                default:
                                    Client.Instance.SendToClient(new UnicodeMessage(msg.Serial, msg.Body, msg.Type,
                                        msg.Hue, msg.Font, msg.Lang, msg.Name,
                                        msg.Count > 1 ? $"{txt} [{msg.Count}]" : txt));
                                    break;
                            }

                            msg.Count = 0;
                            msg.NextSend = DateTime.UtcNow + msg.Delay;
                        }
                        else
                        {
                            if (txt != null)
                                toremove.Add(txt);
                        }
                    }
                }

                for (int i = toremove.Count - 1; i >= 0; --i)
                {
                    m_Table.TryRemove(toremove[i], out var msg);
                }
            }
        }

        private static Timer m_Timer = new MessageTimer();
        private static ConcurrentDictionary<string, MsgInfo> m_Table = new ConcurrentDictionary<string, MsgInfo>();

        static MessageQueue()
        {
            m_Timer.Start();
        }

        public static bool Enqueue(Mobile m, int hue, string lang, string text)
        {
            return Enqueue(0xFFFFFFFF, m, 0, MessageType.Regular, (ushort) hue, 3, lang, "System", text);
        }

        public static bool Enqueue(Serial ser, Mobile mobile, ushort body, MessageType type, ushort hue, ushort font,
            string lang,
            string name, string text)
        {
            MsgInfo m;

            if (!m_Table.TryGetValue(text, out m) || m == null)
            {
                m_Table[text] = m = new MsgInfo(ser, mobile, body, type, hue, font, lang, name);

                m.Count = 0;

                m.Delay = TimeSpan.FromSeconds((text.Length / 50 + 1) * Config.GetDouble("FilterDelay"));

                m.NextSend = DateTime.UtcNow + m.Delay;

                return true;
            }

            m.Count++;

            return false;
        }
    }
}

================================================
FILE: Razor/Core/ObjectPropertyList.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Text;
using System.Collections.Generic;

namespace Assistant
{
    public class ObjectPropertyList
    {
        private class OPLEntry
        {
            public int Number = 0;
            public string Args = null;

            public OPLEntry(int num) : this(num, null)
            {
            }

            public OPLEntry(int num, string args)
            {
                Number = num;
                Args = args;
            }
        }

        private List<int> m_StringNums = new List<int>();

        private int m_Hash = 0;
        private List<OPLEntry> m_Content = new List<OPLEntry>();

        private int m_CustomHash = 0;
        private List<OPLEntry> m_CustomContent = new List<OPLEntry>();


        private UOEntity m_Owner = null;

        public int Hash
        {
            get { return m_Hash ^ m_CustomHash; }
            set { m_Hash = value; }
        }

        public int ServerHash
        {
            get { return m_Hash; }
        }

        public bool Customized
        {
            get { return m_CustomHash != 0; }
        }

        public ObjectPropertyList(UOEntity owner)
        {
            m_Owner = owner;

            m_StringNums.AddRange(m_DefaultStringNums);
        }

        public UOEntity Owner
        {
            get { return m_Owner; }
        }

        public void Read(PacketReader p)
        {
            m_Content.Clear();

            p.Seek(5, System.IO.SeekOrigin.Begin); // seek to packet data

            p.ReadUInt32(); // serial
            p.ReadByte(); // 0
            p.ReadByte(); // 0
            m_Hash = p.ReadInt32();

            m_StringNums.Clear();
            m_StringNums.AddRange(m_DefaultStringNums);

            while (p.Position < p.Length)
            {
                int num = p.ReadInt32();
                if (num == 0)
                    break;

                m_StringNums.Remove(num);

                short bytes = p.ReadInt16();
                string args = null;
                if (bytes > 0)
                    args = p.ReadUnicodeStringBE(bytes >> 1);

                m_Content.Add(new OPLEntry(num, args));
            }

            for (int i = 0; i < m_CustomContent.Count; i++)
            {
                OPLEntry ent = (OPLEntry) m_CustomContent[i];
                if (m_StringNums.Contains(ent.Number))
                {
                    m_StringNums.Remove(ent.Number);
                }
                else
                {
                    for (int s = 0; s < m_DefaultStringNums.Length; s++)
                    {
                        if (ent.Number == m_DefaultStringNums[s])
                        {
                            ent.Number = GetStringNumber();
                            break;
                        }
                    }
                }
            }
        }

        public void Add(int number)
        {
            if (number == 0)
                return;

            AddHash(number);

            m_CustomContent.Add(new OPLEntry(number));
        }

        private static byte[] m_Buffer = new byte[0];

        public void AddHash(int val)
        {
            m_CustomHash ^= (val & 0x3FFFFFF);
            m_CustomHash ^= (val >> 26) & 0x3F;
        }

        public void Add(int number, string arguments)
        {
            if (number == 0)
                return;

            AddHash(number);
            m_CustomContent.Add(new OPLEntry(number, arguments));
        }

        public void Add(int number, string format, object arg0)
        {
            Add(number, String.Format(format, arg0));
        }

        public void Add(int number, string format, object arg0, object arg1)
        {
            Add(number, String.Format(format, arg0, arg1));
        }

        public void Add(int number, string format, object arg0, object arg1, object arg2)
        {
            Add(number, String.Format(format, arg0, arg1, arg2));
        }

        public void Add(int number, string format, params object[] args)
        {
            Add(number, String.Format(format, args));
        }

        private static int[] m_DefaultStringNums = new int[]
        {
            1042971, // ~1_NOTHING~
            1070722, // ~1_NOTHING~
            1063483, // ~1_MATERIAL~ ~2_ITEMNAME~
            1076228, // ~1_DUMMY~ ~2_DUMMY~
            1060847, // ~1_val~ ~2_val~
            1050039 // ~1_NUMBER~ ~2_ITEMNAME~
            // these are ugly:
            //1062613, // "~1_NAME~" (orange)
            //1049644, // [~1_stuff~]
        };

        private int GetStringNumber()
        {
            if (m_StringNums.Count > 0)
            {
                int num = (int) m_StringNums[0];
                m_StringNums.RemoveAt(0);
                return num;
            }
            else
            {
                return 1049644;
            }
        }

        private const string RazorHTMLFormat = " <CENTER><BASEFONT COLOR=#FF0000>{0}</BASEFONT></CENTER> ";

        public void Add(string text)
        {
            Add(GetStringNumber(), String.Format(RazorHTMLFormat, text));
        }

        public void Add(string format, string arg0)
        {
            Add(GetStringNumber(), String.Format(format, arg0));
        }

        public void Add(string format, string arg0, string arg1)
        {
            Add(GetStringNumber(), String.Format(format, arg0, arg1));
        }

        public void Add(string format, string arg0, string arg1, string arg2)
        {
            Add(GetStringNumber(), String.Format(format, arg0, arg1, arg2));
        }

        public void Add(string format, params object[] args)
        {
            Add(GetStringNumber(), String.Format(format, args));
        }

        public bool Remove(int number)
        {
            for (int i = 0; i < m_Content.Count; i++)
            {
                OPLEntry ent = (OPLEntry) m_Content[i];
                if (ent == null)
                    continue;

                if (ent.Number == number)
                {
                    for (int s = 0; s < m_DefaultStringNums.Length; s++)
                    {
                        if (m_DefaultStringNums[s] == ent.Number)
                        {
                            m_StringNums.Insert(0, ent.Number);
                            break;
                        }
                    }

                    m_Content.RemoveAt(i);
                    AddHash(ent.Number);
                    if (!string.IsNullOrEmpty(ent.Args))
                        AddHash(ent.Args.GetHashCode());

                    return true;
                }
            }

            for (int i = 0; i < m_CustomContent.Count; i++)
            {
                OPLEntry ent = (OPLEntry) m_CustomContent[i];
                if (ent == null)
                    continue;

                if (ent.Number == number)
                {
                    for (int s = 0; s < m_DefaultStringNums.Length; s++)
                    {
                        if (m_DefaultStringNums[s] == ent.Number)
                        {
                            m_StringNums.Insert(0, ent.Number);
                            break;
                        }
                    }

                    m_CustomContent.RemoveAt(i);
                    AddHash(ent.Number);
                    if (!string.IsNullOrEmpty(ent.Args))
                        AddHash(ent.Args.GetHashCode());
                    if (m_CustomContent.Count == 0)
                        m_CustomHash = 0;
                    return true;
                }
            }

            return false;
        }

        public bool Remove(string str)
        {
            string htmlStr = String.Format(RazorHTMLFormat, str);

            /*for ( int i = 0; i < m_Content.Count; i++ )
            {
                 OPLEntry ent = (OPLEntry)m_Content[i];
                 if ( ent == null )
                      continue;

                 for (int s=0;s<m_DefaultStringNums.Length;s++)
                 {
                      if ( ent.Number == m_DefaultStringNums[s] && ( ent.Args == htmlStr || ent.Args == str ) )
                      {
                           m_StringNums.Insert( 0, ent.Number );

                           m_Content.RemoveAt( i );

                           AddHash( ent.Number );
                           if ( ent.Args != null && ent.Args != "" )
                                AddHash( ent.Args.GetHashCode() );
                           return true;
                      }
                 }
            }*/

            for (int i = 0; i < m_CustomContent.Count; i++)
            {
                OPLEntry ent = (OPLEntry) m_CustomContent[i];
                if (ent == null)
                    continue;

                for (int s = 0; s < m_DefaultStringNums.Length; s++)
                {
                    if (ent.Number == m_DefaultStringNums[s] && (ent.Args == htmlStr || ent.Args == str))
                    {
                        m_StringNums.Insert(0, ent.Number);

                        m_CustomContent.RemoveAt(i);

                        AddHash(ent.Number);
                        if (!string.IsNullOrEmpty(ent.Args))
                            AddHash(ent.Args.GetHashCode());
                        return true;
                    }
                }
            }

            return false;
        }

        public Packet BuildPacket()
        {
            Packet p = new Packet(0xD6);

            p.EnsureCapacity(128);

            p.Write((short) 0x01);
            p.Write((uint) (m_Owner != null ? m_Owner.Serial : Serial.Zero));
            p.Write((byte) 0);
            p.Write((byte) 0);
            p.Write((uint) (m_Hash ^ m_CustomHash));

            foreach (OPLEntry ent in m_Content)
            {
                if (ent != null && ent.Number != 0)
                {
                    p.Write((int) ent.Number);
                    if (!string.IsNullOrEmpty(ent.Args))
                    {
                        int byteCount = Encoding.Unicode.GetByteCount(ent.Args);

                        if (byteCount > m_Buffer.Length)
                            m_Buffer = new byte[byteCount];

                        byteCount = Encoding.Unicode.GetBytes(ent.Args, 0, ent.Args.Length, m_Buffer, 0);

                        p.Write((short) byteCount);
                        p.Write(m_Buffer, 0, byteCount);
                    }
                    else
                    {
                        p.Write((short) 0);
                    }
                }
            }

            foreach (OPLEntry ent in m_CustomContent)
            {
                try
                {
                    if (ent != null && ent.Number != 0)
                    {
                        string arguments = ent.Args;

                        p.Write((int) ent.Number);

                        if (string.IsNullOrEmpty(arguments))
                            arguments = " ";
                        arguments += "\t ";

                        if (!string.IsNullOrEmpty(arguments))
                        {
                            int byteCount = Encoding.Unicode.GetByteCount(arguments);

                            if (byteCount > m_Buffer.Length)
                                m_Buffer = new byte[byteCount];

                            byteCount = Encoding.Unicode.GetBytes(arguments, 0, arguments.Length, m_Buffer, 0);

                            p.Write((short) byteCount);
                            p.Write(m_Buffer, 0, byteCount);
                        }
                        else
                        {
                            p.Write((short) 0);
                        }
                    }
                }
                catch
                {
                }
            }

            p.Write((int) 0);

            return p;
        }
    }

    public class OPLInfo : Packet
    {
        public OPLInfo(Serial ser, int hash) : base(0xDC, 9)
        {
            Write((uint) ser);
            Write((int) hash);
        }
    }
}

================================================
FILE: Razor/Core/OverheadManager.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Windows.Forms;
using System.Xml;
using Assistant.Filters;
using Assistant.UI;
using Ultima;

namespace Assistant.Core
{
    public class OverheadMessage
    {
        public string SearchMessage { get; set; }
        public string MessageOverhead { get; set; }
        public int Hue { get; set; }
        public int Sound { get; set; }
    }

    public static class OverheadManager
    {
        private static ListView _listView;

        public static List<OverheadMessage> OverheadMessages = new List<OverheadMessage>();

        public static void SetControls(ListView listView)
        {
            _listView = listView;
        }

        public static void Save(XmlTextWriter xml)
        {
            foreach (var message in OverheadMessages)
            {
                xml.WriteStartElement("overheadmessage");
                xml.WriteAttributeString("searchtext", message.SearchMessage);
                xml.WriteAttributeString("message", (message.MessageOverhead));
                xml.WriteAttributeString("hue", Convert.ToString(message.Hue));
                xml.WriteAttributeString("sound", Convert.ToString(message.Sound));
                xml.WriteEndElement();
            }
        }

        public static void Load(XmlElement node)
        {
            ClearAll();

            try
            {
                foreach (XmlElement el in node.GetElementsByTagName("overheadmessage"))
                {
                    OverheadMessage overheadMessage = new OverheadMessage
                    {
                        MessageOverhead = el.GetAttribute("message"),
                        SearchMessage = el.GetAttribute("searchtext"),
                        Hue = string.IsNullOrEmpty(el.GetAttribute("hue"))
                            ? 68
                            : Convert.ToInt32(el.GetAttribute("hue")),
                        Sound = string.IsNullOrEmpty(el.GetAttribute("sound"))
                        ? -1
                        : Convert.ToInt32(el.GetAttribute("sound"))
                    };

                    OverheadMessages.Add(overheadMessage);
                }
            }
            catch
            {
                // ignored
            }
        }

        public static void ClearAll()
        {
            OverheadMessages.Clear();
        }

        public static void Remove(string text)
        {
            foreach (OverheadMessage message in OverheadMessages)
            {
                if (message.SearchMessage.Equals(text))
                {
                    OverheadMessages.Remove(message);
                    break;
                }
            }
        }

        public static void RedrawList()
        {
            _listView.SafeAction(s => s.Items.Clear());

            foreach (OverheadMessage message in OverheadMessages)
            {
                ListViewItem item = new ListViewItem($"{message.SearchMessage}");
                item.SubItems.Add(new ListViewItem.ListViewSubItem(item, message.MessageOverhead));
                item.SubItems.Add(new ListViewItem.ListViewSubItem(item, SoundMusicManager.GetSoundName((ushort) message.Sound)));

                int hueIdx = message.Hue;

                item.SubItems[1].BackColor = hueIdx > 0 && hueIdx < 3000
                    ? Hues.GetHue(hueIdx - 1).GetColor(HueEntry.TextHueIDX)
                    : SystemColors.Control;

                item.SubItems[1].ForeColor = (item.SubItems[1].BackColor.GetBrightness() < 0.35 ? Color.White : Color.Black);

                item.UseItemStyleForSubItems = false;

                _listView.SafeAction(s => s.Items.Add(item));
            }
        }

        public static void DisplayOverheadMessage(string text)
        {
            if (Config.GetBool("ShowOverheadMessages") && OverheadMessages.Count > 0)
            {
                string overheadFormat = Config.GetString("OverheadFormat");

                foreach (OverheadMessage message in OverheadMessages)
                {
                    if (text.IndexOf(message.SearchMessage, StringComparison.OrdinalIgnoreCase) != -1)
                    {
                        string ohMessage = overheadFormat.Replace("{msg}", message.MessageOverhead);
                        string[] splitText = text.Split(' ');

                        if (splitText.Length > 0)
                        {
                            for (int wordNum = 1; wordNum < splitText.Length + 1; wordNum++)
                            {
                                ohMessage = ohMessage.Replace($"{{{wordNum}}}", splitText[wordNum - 1]);
                            }
                        }

                        World.Player.OverheadMessage(message.Hue, ohMessage);

                        if (message.Sound > -1)
                        {
                            Client.Instance.SendToClient(new PlaySound(message.Sound));
                        }

                        break;
                    }
                }
            }
        }

        public static void SetOverheadHue()
        {
            ListViewItem selectedItem = _listView.Items[_listView.SelectedIndices[0]];

            HueEntry h = new HueEntry(GetHue(selectedItem.SubItems[1].Text));

            if (h.ShowDialog(Engine.MainWindow) == DialogResult.OK)
            {
                int hueIdx = h.Hue;

                if (hueIdx > 0 && hueIdx < 3000)
                    selectedItem.SubItems[1].BackColor = Hues.GetHue(hueIdx - 1).GetColor(HueEntry.TextHueIDX);
                else
                    selectedItem.SubItems[1].BackColor = Color.White;

                selectedItem.SubItems[1].ForeColor = (selectedItem.SubItems[1].BackColor.GetBrightness() < 0.35
                    ? Color.White
                    : Color.Black);

                foreach (OverheadMessage list in OverheadManager.OverheadMessages)
                {
                    if (list.SearchMessage.Equals(selectedItem.Text))
                    {
                        list.Hue = hueIdx;
                        break;
                    }
                }
            }
        }

        public static int GetHue(string id)
        {
            int hue = 0;

            foreach (OverheadMessage list in OverheadManager.OverheadMessages)
            {
                if (list.MessageOverhead.Equals(id))
                {
                    return list.Hue;
                }
            }

            return hue;
        }

        public static void SetOverheadSound()
        {
            ListViewItem selectedItem = _listView.Items[_listView.SelectedIndices[0]];

            int soundId = SoundMusicManager.GetSoundId(selectedItem.SubItems[2].Text);

            SoundEntry soundDialog = new SoundEntry(soundId, selectedItem.SubItems[2].Text);

            if (soundDialog.ShowDialog(Engine.MainWindow) == DialogResult.OK)
            {
                selectedItem.SubItems[2].Text = SoundMusicManager.GetSoundName((ushort) soundId);
                
                foreach (OverheadMessage list in OverheadMessages)
                {
                    if (list.SearchMessage.Equals(selectedItem.Text))
                    {
                        list.Sound = soundDialog.Sound;
                        break;
                    }
                }
            }
        }
    }
}

================================================
FILE: Razor/Core/Overrides.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;

#region license

// Razor: An Ultima Online Assistant
// Copyright (C) 2021 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#endregion

namespace Assistant.Core
{
    public static class Overrides
    {
        public static Dictionary<ushort, bool> TwoHanded { get; private set; }

        public static void Load()
        {
            if (TwoHanded == null)
                TwoHanded = new Dictionary<ushort, bool>();
            else
                TwoHanded.Clear();

            string file = Path.Combine(Config.GetInstallDirectory(), "overrides.def");

            if (!File.Exists(file))
            {
                return;
            }

            string[] lines = File.ReadAllLines(file);

            foreach (string line in lines)
            {
                if (string.IsNullOrEmpty(line) || line[0] == '#')
                {
                    continue;
                }

                string[] split = line.Trim().Split(' ');

                switch (split[0])
                {
                    case "twohanded":
                        TwoHanded.Add(Convert.ToUInt16(split[1], 16), Convert.ToBoolean(split[2]));
                        break;
                }
            }
        }
    }
}


================================================
FILE: Razor/Core/PasswordMemory.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Xml;
using System.Text;
using System.Collections;
using System.Net;

namespace Assistant
{
    public class PasswordMemory
    {
        private class Entry
        {
            public Entry()
            {
            }

            public Entry(string u, string p, IPAddress a)
            {
                User = u;
                Pass = p;
                Address = a;
            }

            public string User;
            public string Pass;
            public IPAddress Address;
        }

        private static ArrayList m_List = new ArrayList();

        public static string Encrypt(string source)
        {
            byte[] buff = ASCIIEncoding.ASCII.GetBytes(source);
            int kidx = 0;
            string key = Platform.GetWindowsUserName();
            if (key == String.Empty)
                return String.Empty;
            StringBuilder sb = new StringBuilder(source.Length * 2 + 2);
            sb.Append("1+");
            for (int i = 0; i < buff.Length; i++)
            {
                sb.AppendFormat("{0:X2}", (byte) (buff[i] ^ ((byte) key[kidx++])));
                if (kidx >= key.Length)
                    kidx = 0;
            }

            return sb.ToString();
        }

        public static string Decrypt(string source)
        {
            byte[] buff = null;

            if (source.Length > 2 && source[0] == '1' && source[1] == '+')
            {
                buff = new byte[(source.Length - 2) / 2];
                string key = Platform.GetWindowsUserName();
                if (key == String.Empty)
                    return String.Empty;
                int kidx = 0;
                for (int i = 2; i < source.Length; i += 2)
                {
                    byte c;
                    try
                    {
                        c = Convert.ToByte(source.Substring(i, 2), 16);
                    }
                    catch
                    {
                        continue;
                    }

                    buff[(i - 2) / 2] = (byte) (c ^ ((byte) key[kidx++]));
                    if (kidx >= key.Length)
                        kidx = 0;
                }
            }
            else
            {
                byte key = (byte) (source.Length / 2);
                buff = new byte[key];

                for (int i = 0; i < source.Length; i += 2)
                {
                    byte c;
                    try
                    {
                        c = Convert.ToByte(source.Substring(i, 2), 16);
                    }
                    catch
                    {
                        continue;
                    }

                    buff[i / 2] = (byte) (c ^ key++);
                }
            }

            return ASCIIEncoding.ASCII.GetString(buff);
        }

        public static void Load(XmlElement xml)
        {
            ClearAll();

            if (xml == null)
                return;

            foreach (XmlElement el in xml.GetElementsByTagName("password"))
            {
                try
                {
                    string user = el.GetAttribute("user");
                    string addr = el.GetAttribute("ip");

                    if (el.InnerText == null)
                        continue;

                    m_List.Add(new Entry(user, el.InnerText, IPAddress.Parse(addr)));
                }
                catch
                {
                }
            }
        }

        public static void Save(XmlTextWriter xml)
        {
            if (m_List == null)
                return;

            foreach (Entry e in m_List)
            {
                if (e.Pass != String.Empty)
                {
                    xml.WriteStartElement("password");
                    try
                    {
                        xml.WriteAttributeString("user", e.User);
                        xml.WriteAttributeString("ip", e.Address.ToString());
                        xml.WriteString(e.Pass);
                    }
                    catch
                    {
                    }

                    xml.WriteEndElement();
                }
            }
        }

        public static void ClearAll()
        {
            m_List.Clear();
        }

        public static void Add(string user, string pass, IPAddress addr)
        {
            if (pass == "")
                return;

            user = user.ToLower();
            for (int i = 0; i < m_List.Count; i++)
            {
                Entry e = (Entry) m_List[i];
                if (e.User == user && e.Address.Equals(addr))
                {
                    e.Pass = Encrypt(pass);
                    return;
                }
            }

            m_List.Add(new Entry(user, Encrypt(pass), addr));
        }

        public static string Find(string user, IPAddress addr)
        {
            user = user.ToLower();
            for (int i = 0; i < m_List.Count; i++)
            {
                Entry e = (Entry) m_List[i];
                if (e.User == user && e.Address.Equals(addr))
                    return Decrypt(e.Pass);
            }

            return String.Empty;
        }
    }
}

================================================
FILE: Razor/Core/Ping.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;

namespace Assistant
{
    public class Ping
    {
        private static DateTime m_Start;
        private static byte m_Seq;
        private static double m_Time, m_Min, m_Max;
        private static int m_Total;
        private static int m_Count;

        public static bool Response(byte seq)
        {
            if (seq == m_Seq && m_Start != DateTime.MinValue)
            {
                double ms = (DateTime.UtcNow - m_Start).TotalMilliseconds;

                if (ms < m_Min)
                    m_Min = ms;
                if (ms > m_Max)
                    m_Max = ms;

                if (m_Count-- > 0)
                {
                    m_Time += ms;
                    World.Player.SendMessage(MsgLevel.Force, $"Response: {ms:F1}ms");
                    DoPing();
                }
                else
                {
                    m_Start = DateTime.MinValue;
                    World.Player.SendMessage(MsgLevel.Force, "Ping Result:");
                    World.Player.SendMessage(MsgLevel.Force, "Min: {0:F1}ms  Max: {1:F1}ms  Avg: {2:F1}ms", m_Min,
                        m_Max, m_Time / ((double) m_Total));
                }

                return true;
            }
            else
            {
                return false;
            }
        }

        public static void StartPing(int count)
        {
            if (count <= 0 || count > 20)
                m_Count = 5;
            else
                m_Count = count;

            m_Total = m_Count;
            m_Time = 0;
            m_Min = double.MaxValue;
            m_Max = 0;

            World.Player.SendMessage(MsgLevel.Force, "Pinging server with {0} packets ({1} bytes)...", m_Count,
                m_Count * 2);
            DoPing();
        }

        private static void DoPing()
        {
            m_Seq = (byte) Utility.Random(256);
            m_Start = DateTime.UtcNow;
            Client.Instance.SendToServer(new PingPacket(m_Seq));
        }
    }
}

================================================
FILE: Razor/Core/Player.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections;
using System.IO;
using System.Collections.Generic;
using System.Linq;
using Assistant.Agents;
using Assistant.Core;
using Assistant.Gumps;
using Assistant.Macros;
using Assistant.UI;

namespace Assistant
{
    public enum LockType : byte
    {
        Up = 0,
        Down = 1,
        Locked = 2
    }

    public enum MsgLevel
    {
        Debug = 0,
        Info = 0,
        Warning = 1,
        Error = 2,
        Force = 3,
        Friend = 4
    }

    public class Skill
    {
        private LockType _lock;
        private ushort _value;
        private ushort _base;
        private ushort _cap;
        private short _delta;
        private int _index;

        public Skill(int idx)
        {
            _index = idx;
        }

        public int Index
        {
            get { return _index; }
        }

        public LockType Lock
        {
            get { return _lock; }
            set { _lock = value; }
        }

        public ushort FixedValue
        {
            get { return _value; }
            set { _value = value; }
        }

        public ushort FixedBase
        {
            get { return _base; }
            set
            {
                _delta += (short) (value - _base);
                _base = value;
            }
        }

        public ushort FixedCap
        {
            get { return _cap; }
            set { _cap = value; }
        }

        public double Value
        {
            get { return _value / 10.0; }
            set { _value = (ushort) (value * 10.0); }
        }

        public double Base
        {
            get { return _base / 10.0; }
            set { _base = (ushort) (value * 10.0); }
        }

        public double Cap
        {
            get { return _cap / 10.0; }
            set { _cap = (ushort) (value * 10.0); }
        }

        public double Delta
        {
            get { return _delta / 10.0; }
            set { _delta = (short) (value * 10); }
        }
    }

    public enum MaleSounds
    {
        Ah = 0x419,
        Ahha = 0x41A,
        Applaud = 0x41B,
        Blownose = 0x41C,
        Burp = 0x41D,
        Cheer = 0x41E,
        Clear_Throat = 0x41F,
        Cough = 0x420,
        Coughbs = 0x421,
        Cry = 0x422,
        Death_01 = 0x423,
        Death_02 = 0x424,
        Death_03 = 0x425,
        Death_04 = 0x426,
        Death_05 = 0x427,
        Fart = 0x428,
        Gasp = 0x429,
        Giggle = 0x42A,
        Groan = 0x42B,
        Growl = 0x42C,
        Hey = 0x42D,
        Hiccup = 0x42E,
        Huh = 0x42F,
        Kiss = 0x430,
        Laugh = 0x431,
        No = 0x432,
        Oh = 0x433,
        Oomph_01 = 0x434,
        Oomph_02 = 0x435,
        Oomph_03 = 0x436,
        Oomph_04 = 0x437,
        Oomph_05 = 0x438,
        Oomph_06 = 0x439,
        Oomph_07 = 0x43A,
        Oomph_08 = 0x43B,
        Oomph_09 = 0x43C,
        Oooh = 0x43D,
        Oops = 0x43E,
        Puke = 0x43F,
        Scream = 0x440,
        Shush = 0x441,
        Sigh = 0x442,
        Sneeze = 0x443,
        Sniff = 0x444,
        Snore = 0x445,
        Spit = 0x446,
        Whistle = 0x447,
        Yawn = 0x448,
        Yea = 0x449,
        Yell = 0x44A
    }

    public enum FemaleSounds
    {
        Ah = 0x30A,
        Ahha = 0x30B,
        Applaud = 0x30C,
        Blownose = 0x30D,
        Burp = 0x30E,
        Cheer = 0x30F,
        Clear_Throat = 0x310,
        Cough = 0x311,
        Coughbs = 0x312,
        Cry = 0x313,
        Death_01 = 0x314,
        Death_02 = 0x315,
        Death_03 = 0x316,
        Death_04 = 0x317,
        Fart = 0x318,
        Gasp = 0x319,
        Giggle = 0x31A,
        Groan = 0x31B,
        Growl = 0x31C,
        Hey = 0x31D,
        Hiccup = 0x31E,
        Huh = 0x31F,
        Kiss = 0x320,
        Laugh = 0x321,
        No = 0x322,
        Oh = 0x323,
        Oomph_01 = 0x324,
        Oomph_02 = 0x325,
        Oomph_03 = 0x326,
        Oomph_04 = 0x327,
        Oomph_05 = 0x328,
        Oomph_06 = 0x329,
        Oomph_07 = 0x32A,
        Oooh = 0x32B,
        Oops = 0x32C,
        Puke = 0x32D,
        Scream = 0x32E,
        Shush = 0x32F,
        Sigh = 0x330,
        Sneeze = 0x331,
        Sniff = 0x332,
        Snore = 0x333,
        Spit = 0x334,
        Whistle = 0x335,
        Yawn = 0x336,
        Yea = 0x337,
        Yell = 0x338
    }

    public class PlayerData : Mobile
    {
        public int VisRange = 18;

        public int MultiVisRange
        {
            get { return VisRange + 5; }
        }

        private int _maxWeight = -1;

        private short _fireResist, _coldResist, _poisonResist, _energyResist, _luck;
        private ushort _damageMin, _damageMax;

        private ushort _str, _dex, _int;
        private LockType _strLock, _dexLock, _intLock;
        private uint _gold;
        private ushort _weight;
        private Skill[] _skills;
        private ushort _ar;
        private ushort _statCap;
        private byte _followers;
        private byte _followersMax;
        private int _tithe;
        private sbyte _localLight;
        private byte _globalLight;
        private uint _features;
        private byte _season;
        private byte _defaultSeason;
        private int[] _papPatches = new int[10];


        private bool _skillsSent;
        private Timer _criminalTime;
        private DateTime _criminalStart = DateTime.MinValue;

        private List<BuffDebuff> _buffsDebuffs = new List<BuffDebuff>();

        internal List<BuffDebuff> BuffsDebuffs
        {
            get { return _buffsDebuffs; }
        }

        private List<uint> _openedCorpses = new List<uint>();

        public List<uint> OpenedCorpses
        {
            get { return _openedCorpses; }
        }

        public PlayerData(Serial serial) : base(serial)
        {
            _skills = new Skill[Ultima.Skills.TotalSkills()];
            for (int i = 0; i < _skills.Length; i++)
                _skills[i] = new Skill(i);
        }

        public ushort Str
        {
            get { return _str; }
            set { _str = value; }
        }

        public ushort Dex
        {
            get { return _dex; }
            set { _dex = value; }
        }

        public ushort Int
        {
            get { return _int; }
            set { _int = value; }
        }

        public uint Gold
        {
            get { return _gold; }
            set { _gold = value; }
        }

        public ushort Weight
        {
            get { return _weight; }
            set { _weight = value; }
        }

        public ushort MaxWeight
        {
            get
            {
                if (_maxWeight == -1)
                    return (ushort) ((_str * 3.5) + 40);
                else
                    return (ushort) _maxWeight;
            }
            set { _maxWeight = value; }
        }

        public short FireResistance
        {
            get { return _fireResist; }
            set { _fireResist = value; }
        }

        public short ColdResistance
        {
            get { return _coldResist; }
            set { _coldResist = value; }
        }

        public short PoisonResistance
        {
            get { return _poisonResist; }
            set { _poisonResist = value; }
        }

        public short EnergyResistance
        {
            get { return _energyResist; }
            set { _energyResist = value; }
        }

        public short Luck
        {
            get { return _luck; }
            set { _luck = value; }
        }

        public ushort DamageMin
        {
            get { return _damageMin; }
            set { _damageMin = value; }
        }

        public ushort DamageMax
        {
            get { return _damageMax; }
            set { _damageMax = value; }
        }

        public LockType StrLock
        {
            get { return _strLock; }
            set { _strLock = value; }
        }

        public LockType DexLock
        {
            get { return _dexLock; }
            set { _dexLock = value; }
        }

        public LockType IntLock
        {
            get { return _intLock; }
            set { _intLock = value; }
        }

        public ushort StatCap
        {
            get { return _statCap; }
            set { _statCap = value; }
        }

        public ushort AR
        {
            get { return _ar; }
            set { _ar = value; }
        }

        public byte Followers
        {
            get { return _followers; }
            set { _followers = value; }
        }

        public byte FollowersMax
        {
            get { return _followersMax; }
            set { _followersMax = value; }
        }

        public int Tithe
        {
            get { return _tithe; }
            set { _tithe = value; }
        }

        public Skill[] Skills
        {
            get { return _skills; }
        }

        public bool SkillsSent
        {
            get { return _skillsSent; }
            set { _skillsSent = value; }
        }

        public int CriminalTime
        {
            get
            {
                if (_criminalStart != DateTime.MinValue)
                {
                    int sec = (int) (DateTime.UtcNow - _criminalStart).TotalSeconds;
                    if (sec > 300)
                    {
                        if (_criminalTime != null)
                            _criminalTime.Stop();
                        _criminalStart = DateTime.MinValue;
                        return 0;
                    }
                    else
                    {
                        return sec;
                    }
                }
                else
                {
                    return 0;
                }
            }
        }

        private class DoorOpenTimer : Timer
        {
            // Fire off once in 5ms
            public DoorOpenTimer() : base(TimeSpan.FromMilliseconds(5), 1)
            {
            }

            protected override void OnTick()
            {
                Client.Instance.SendToServer(new OpenDoorMacro());
            }
        }

        private readonly DoorOpenTimer _doorTimer = new DoorOpenTimer();

        private void AutoOpenDoors(bool onDirChange)
        {
            if (!Visible && !Config.GetBool("AutoOpenDoorWhenHidden"))
                return;

            if (Body != 0x03DB && !IsGhost && ((int) (Direction & Direction.Mask)) % 2 == 0 &&
                Config.GetBool("AutoOpenDoors") &&
                Client.Instance.AllowBit(FeatureBit.AutoOpenDoors))
            {
                int x = Position.X, y = Position.Y, z = Position.Z;

                /* Check if one more tile in the direction we just moved is a door */
                Utility.Offset(Direction, ref x, ref y);

                if (World.Items.Values.Any(s =>
                    s.IsDoor && s.Position.X == x && s.Position.Y == y && s.Position.Z - 15 <= z &&
                    s.Position.Z + 15 >= z))
                {
                    if (Client.IsOSI)
                    {
                        Client.Instance.SendToServer(new OpenDoorMacro());
                    }
                    else
                    {
                        // ClassicUO requires a slight pause before attempting to
                        // open a door after a direction change
                        if (onDirChange)
                        {
                            _doorTimer.Start();
                        }
                        else
                        {
                            Client.Instance.SendToServer(new OpenDoorMacro());
                        }
                    }
                }
            }
        }

        public override void OnPositionChanging(Point3D oldPos)
        {
            if (!IsGhost)
                StealthSteps.OnMove();

            AutoOpenDoors(false);

            List<Mobile> mlist = new List<Mobile>(World.Mobiles.Values);
            for (int i = 0; i < mlist.Count; i++)
            {
                Mobile m = mlist[i];
                if (m != this)
                {
                    if (!Utility.InRange(m.Position, Position, VisRange))
                        m.Remove();
                    else
                        Targeting.CheckLastTargetRange(m);
                }
            }

            mlist = null;


            List<Item> ilist = new List<Item>(World.Items.Values);
            ScavengerAgent s = ScavengerAgent.Instance;
            for (int i = 0; i < ilist.Count; i++)
            {
                Item item = ilist[i];
                if (item.Deleted || item.Container != null)
                    continue;

                int dist = Utility.Distance(item.GetWorldPosition(), Position);
                if (item != DragDropManager.Holding && (dist > MultiVisRange || (!item.IsMulti && dist > VisRange)))
                    item.Remove();
                else if (!IsGhost && Visible && dist <= 2 && s.Enabled && item.Movable)
                    s.Scavenge(item);
            }

            ilist = null;

            if (Engine.MainWindow != null && Engine.MainWindow.MapWindow != null)
                Engine.MainWindow.SafeAction(f => f.MapWindow.PlayerMoved());

            base.OnPositionChanging(oldPos);
        }

        public override void OnDirectionChanging(Direction oldDir)
        {
            AutoOpenDoors(true);
        }

        public override void OnMapChange(byte old, byte cur)
        {
            List<Mobile> list = new List<Mobile>(World.Mobiles.Values);
            for (int i = 0; i < list.Count; i++)
            {
                Mobile m = list[i];
                if (m != this && m.Map != cur)
                    m.Remove();
            }

            list = null;

            World.Items.Clear();
            Counter.Reset();
            for (int i = 0; i < Contains.Count; i++)
            {
                Item item = (Item) Contains[i];
                World.AddItem(item);
                item.Contains.Clear();
            }

            if (Config.GetBool("AutoSearch") && Backpack != null)
                PlayerData.DoubleClick(Backpack);

            UOAssist.PostMapChange(cur);

            if (Engine.MainWindow != null && Engine.MainWindow.MapWindow != null)
                Engine.MainWindow.SafeAction(s => s.MapWindow.PlayerMoved());
        }

        /*public override void OnMapChange( byte old, byte cur )
        {
             World.Mobiles.Clear();
             World.Items.Clear();
             Counter.Reset();

             Contains.Clear();

             World.AddMobile( this );

             UOAssist.PostMapChange( cur );
        }*/

        protected override void OnNotoChange(byte old, byte cur)
        {
            if ((old == 3 || old == 4) && (cur != 3 && cur != 4))
            {
                // grey is turning off
                // SendMessage( "You are no longer a criminal." );
                if (_criminalTime != null)
                    _criminalTime.Stop();
                _criminalStart = DateTime.MinValue;
                Client.Instance.RequestTitlebarUpdate();
            }
            else if ((cur == 3 || cur == 4) && (old != 3 && old != 4 && old != 0))
            {
                // grey is turning on
                ResetCriminalTimer();
            }
        }

        public void ResetCriminalTimer()
        {
            if (_criminalStart == DateTime.MinValue || DateTime.UtcNow - _criminalStart >= TimeSpan.FromSeconds(1))
            {
                _criminalStart = DateTime.UtcNow;
                if (_criminalTime == null)
                    _criminalTime = new CriminalTimer(this);
                _criminalTime.Start();
                Client.Instance.RequestTitlebarUpdate();
            }
        }

        private class CriminalTimer : Timer
        {
            private PlayerData _player;

            public CriminalTimer(PlayerData player) : base(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1))
            {
                _player = player;
            }

            protected override void OnTick()
            {
                Client.Instance.RequestTitlebarUpdate();
            }
        }

        internal void SendMessage(MsgLevel lvl, LocString loc, params object[] args)
        {
            SendMessage(lvl, Language.Format(loc, args));
        }

        internal void SendMessage(MsgLevel lvl, LocString loc)
        {
            SendMessage(lvl, Language.GetString(loc));
        }

        internal void SendMessage(LocString loc, params object[] args)
        {
            SendMessage(MsgLevel.Info, Language.Format(loc, args));
        }

        internal void SendMessage(LocString loc)
        {
            SendMessage(MsgLevel.Info, Language.GetString(loc));
        }

        internal void SendMessage(int hue, string text)
        {
            Client.Instance.SendToClient(new UnicodeMessage(0xFFFFFFFF, -1, MessageType.Regular, hue, 3,
                Language.CliLocName, "System", text));
        }

        internal void SendMessage(MsgLevel lvl, string format, params object[] args)
        {
            SendMessage(lvl, String.Format(format, args));
        }

        internal void SendMessage(string format, params object[] args)
        {
            SendMessage(MsgLevel.Info, String.Format(format, args));
        }

        internal void SendMessage(string text)
        {
            SendMessage(MsgLevel.Info, text);
        }

        internal void SendMessage(MsgLevel lvl, string text)
        {
            if (lvl >= (MsgLevel) Config.GetInt("MessageLevel") && text.Length > 0)
            {
                int hue;
                switch (lvl)
                {
                    case MsgLevel.Error:
                    case MsgLevel.Warning:
                        hue = Config.GetInt("WarningColor");
                        break;
                    case MsgLevel.Friend:
                        hue = 63;
                        break;
                    default:
                        hue = Config.GetInt("SysColor");
                        break;
                }

                SystemMessages.Add(text);

                if (Config.GetBool("FilterRazorMessages"))
                {
                    if (!MessageQueue.Enqueue(0xFFFFFFFF, null, 0, MessageType.Regular, (ushort) hue, 3,
                        Language.CliLocName, "System", text))
                    {
                        return;
                    }
                }

                Client.Instance.SendToClient(new UnicodeMessage(0xFFFFFFFF, -1, MessageType.Regular, hue, 3,
                    Language.CliLocName, "System", text));
            }
        }

        internal void Say(int hue, string msg)
        {
            List<ushort> keywords = EncodedSpeech.GetKeywords(msg);

            if (keywords.Count == 1 && (int) keywords[0] == 0)
            {
                Client.Instance.SendToServer(new ClientUniEncodedCommandMessage(MessageType.Regular, hue, 3,
                    Language.CliLocName, keywords, msg));
            }
            else
            {
                Client.Instance.SendToServer(new ClientUniEncodedCommandMessage(MessageType.Encoded, hue, 3,
                    Language.CliLocName, keywords, msg));
            }
        }

        internal void Say(string msg)
        {
            Say(Config.GetInt("SpeechHue"), msg);
        }

        internal void Whisper(string msg, int hue)
        {
            Client.Instance.SendToServer(new ClientUniMessage(MessageType.Whisper, hue, 3,
                Language.CliLocName, new ArrayList(), msg));
        }

        internal void Yell(string msg, int hue)
        {
            Client.Instance.SendToServer(new ClientUniMessage(MessageType.Yell, hue, 3,
                Language.CliLocName, new ArrayList(), msg));
        }

        internal void Emote(string msg, int hue)
        {
            msg = $"*{msg}*";

            Client.Instance.SendToServer(new ClientUniMessage(MessageType.Emote, hue, 3,
                Language.CliLocName, new ArrayList(), msg));
        }

        internal void Guild(string msg, int hue)
        {
            Client.Instance.SendToServer(new ClientUniMessage(MessageType.Guild, hue, 3,
                Language.CliLocName, new ArrayList(), msg));
        }

        internal void Alliance(string msg, int hue)
        {
            Client.Instance.SendToServer(new ClientUniMessage(MessageType.Alliance, hue, 3,
                Language.CliLocName, new ArrayList(), msg));
        }

        public uint CurrentGumpS, CurrentGumpI;
        public GumpResponseAction LastGumpResponseAction;
        public bool HasGump;
        public bool HasCompressedGump;
        public List<string> CurrentGumpStrings = new List<string>(); 
        public string CurrentGumpRawData;
        public uint CurrentMenuS;
        public ushort CurrentMenuI;
        public bool HasMenu;

        public bool HasPrompt;
        public uint PromptSenderSerial;
        public uint PromptID;
        public uint PromptType;
        public string PromptInputText;

        public Dictionary<uint, GumpInfo> GumpList { get; set; } = new Dictionary<uint, GumpInfo>();

        public class GumpInfo
        {
            private uint _serial;
            private uint _gumpId;
            List<string> _gumpContext;

            public uint GumpSerial
            {
                set => _serial = value;
                get => _serial;
            }

            public uint GumpId
            {
                set => _gumpId = value;
                get => _gumpId;
            }

            public List<string> GumpContext
            {
                set => _gumpContext = value;
                get => _gumpContext;
            }

            public GumpInfo(uint serial, uint gumpId, List<string> gumpContext)
            {
                _serial = serial;
                _gumpId = gumpId;
                _gumpContext = gumpContext;
            }

            public GumpInfo(uint serial, uint gumpId)
            {
                _serial = serial;
                _gumpId = gumpId;
            }
        }

        public GumpCollection InternalGumps { get; set; } = new GumpCollection();

        public void CancelPrompt()
        {
            Client.Instance.SendToServer(new PromptResponse(World.Player.PromptSenderSerial, World.Player.PromptID, 0,
                Language.CliLocName, string.Empty));
            World.Player.HasPrompt = false;
        }

        public void ResponsePrompt(string text)
        {
            Client.Instance.SendToServer(new PromptResponse(World.Player.PromptSenderSerial, World.Player.PromptID, 1,
                Language.CliLocName, text));

            PromptInputText = text;
            World.Player.HasPrompt = false;
        }

        private ushort _speechHue;

        public ushort SpeechHue
        {
            get { return _speechHue; }
            set { _speechHue = value; }
        }

        public sbyte LocalLightLevel
        {
            get { return _localLight; }
            set { _localLight = value; }
        }

        public byte GlobalLightLevel
        {
            get { return _globalLight; }
            set { _globalLight = value; }
        }

        public enum SeasonFlag
        {
            Spring,
            Summer,
            Fall,
            Winter,
            Desolation
        }

        public byte Season
        {
            get { return _season; }
            set { _season = value; }
        }

        public byte DefaultSeason
        {
            get { return _defaultSeason; }
            set { _defaultSeason = value; }
        }

        /// <summary>
        /// Sets the player's season, set a default to revert back if required
        /// </summary>
        /// <param name="defaultSeason"></param>
        public void SetSeason(byte defaultSeason = 0)
        {
            if (Config.GetInt("Season") < 5)
            {
                byte season = (byte) Config.GetInt("Season");

                World.Player.Season = season;
                World.Player.DefaultSeason = defaultSeason;

                if (!_seasonTimer.Running)
                    _seasonTimer.Start();
            }
            else
            {
                World.Player.Season = defaultSeason;
                World.Player.DefaultSeason = defaultSeason;
            }
        }

        public static Timer _seasonTimer = new SeasonTimer();

        private class SeasonTimer : Timer
        {
            public SeasonTimer() : base(TimeSpan.FromSeconds(3), TimeSpan.FromSeconds(3))
            {
            }

            protected override void OnTick()
            {
                if (World.Player != null && Client.Instance != null)
                {
                    Client.Instance.ForceSendToClient(new SeasonChange(World.Player.Season, true));
                    _seasonTimer.Stop();
                }
            }
        }

        public uint Features
        {
            get { return _features; }
            set { _features = value; }
        }

        public int[] MapPatches
        {
            get { return _papPatches; }
            set { _papPatches = value; }
        }

        private int _lstSkill = -1;

        public int LastSkill
        {
            get { return _lstSkill; }
            set { _lstSkill = value; }
        }

        private Serial _lastObj = Serial.Zero;

        public Serial LastObject
        {
            get { return _lastObj; }
            set { _lastObj = value; }
        }

        private int _lastSpell = -1;

        public int LastSpell
        {
            get { return _lastSpell; }
            set { _lastSpell = value; }
        }

        public bool UseItem(Item cont, ushort find)
        {
            if (!Client.Instance.AllowBit(FeatureBit.PotionHotkeys))
                return false;

            for (int i = 0; i < cont.Contains.Count; i++)
            {
                Item item = (Item)cont.Contains[i];

                if (item.ItemID == find)
                {
                    DoubleClick(item);
                    return true;
                }

                if (item.Contains != null && item.Contains.Count > 0)
                {
                    if (UseItem(item, find))
                        return true;
                }
            }

            return false;
        }

        public static bool DoubleClick(object clicked)
        {
            return DoubleClick(clicked, true);
        }

        public static bool DoubleClick(object clicked, bool silent)
        {
            Serial s;
            if (clicked is Mobile)
                s = ((Mobile) clicked).Serial.Value;
            else if (clicked is Item)
                s = ((Item) clicked).Serial.Value;
            else if (clicked is Serial)
                s = ((Serial) clicked).Value;
            else
                s = Serial.Zero;

            if (s != Serial.Zero)
            {
                Item free = null, pack = World.Player.Backpack;
                if (s.IsItem && pack != null && Config.GetBool("PotionEquip") &&
                    Client.Instance.AllowBit(FeatureBit.AutoPotionEquip))
                {
                    Item i = World.FindItem(s);
                    if (i != null && i.IsPotion && i.ItemID != 3853) // dont unequip for exploison potions
                    {
                        // dont worry about uneqipping RuneBooks or SpellBooks
                        Item left = World.Player.GetItemOnLayer(Layer.LeftHand);
                        Item right = World.Player.GetItemOnLayer(Layer.RightHand);

                        if (left != null && (right != null || left.IsTwoHanded))
                            free = left;
                        else if (right != null && right.IsTwoHanded)
                            free = right;

                        if (free != null)
                        {
                            if (DragDropManager.HasDragFor(free.Serial))
                                free = null;
                            else
                                DragDropManager.DragDrop(free, pack);
                        }
                    }
                }

                ActionQueue.DoubleClick(silent, s);

                if (free != null && Config.GetBool("PotionReequip"))
                    DragDropManager.DragDrop(free, World.Player, free.Layer, true);

                if (s.IsItem)
                    World.Player._lastObj = s;
            }

            return false;
        }

        public enum InvokeVirtues
        {
            Honor = 0x01,
            Sacrifice = 0x02,
            Valor = 0x03
        }

        public static void InvokeVirtue(InvokeVirtues virtue)
        {
            Client.Instance.SendToServer(new VirtueRequest((byte) virtue));
        }

        public static void RenameMobile(Serial serial, string newName)
        {
            Client.Instance.SendToServer(new RenamePacket(serial.Value, newName));
        }
    }
}

================================================
FILE: Razor/Core/ScreenCapture.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.IO;
using System.Windows.Forms;
using System.Drawing;
using System.Drawing.Imaging;
using System.Runtime.InteropServices;
using Assistant.UI;

namespace Assistant
{
    public class ScreenCapManager
    {
        [System.Runtime.InteropServices.DllImport("Gdi32.dll")]
        private static extern IntPtr DeleteObject(IntPtr hGdiObj);

        private static TimerCallback m_DoCaptureCall = new TimerCallback(CaptureNow);

        public static string LastMobileDeathName { get; set; }

        public static void Initialize()
        {
            HotKey.Add(HKCategory.Misc, LocString.TakeSS, new HotKeyCallback(CaptureNow));
        }

        public static void DeathCapture(double delay)
        {
            Timer.DelayedCallback(TimeSpan.FromSeconds(delay), m_DoCaptureCall).Start();
        }

        public static void CaptureNow()
        {
            string filename;
            string playerName = "Unknown";
            string path = Config.GetString("CapPath");
            string type = Config.GetString("ImageFormat").ToLower();

            if (World.Player != null)
                playerName = World.Player.Name;

            if (playerName == null || playerName.Trim() == "" ||
                playerName.IndexOfAny(Path.GetInvalidPathChars()) != -1)
                playerName = "Unknown";

            if (LastMobileDeathName == null || LastMobileDeathName.Trim() == "" ||
                LastMobileDeathName.IndexOfAny(Path.GetInvalidPathChars()) != -1)
                LastMobileDeathName = "Unknown";

            string imageTimestampTag = Config.GetBool("CapTimeStamp")
                ? $"{playerName} ({World.ShardName}) - {Engine.MistedDateTime:M/dd/yy - HH:mm:ss}"
                : "";

            playerName = !string.IsNullOrEmpty(LastMobileDeathName)
                ? $"{playerName}_{LastMobileDeathName}_{Engine.MistedDateTime:M-d_HH.mm}"
                : $"{playerName}_{Engine.MistedDateTime:M-d_HH.mm}";

            try
            {
                Engine.EnsureDirectory(path);
            }
            catch
            {
                try
                {
                    path = Config.GetUserDirectory("ScreenShots");
                    Config.SetProperty("CapPath", path);
                }
                catch
                {
                    path = "";
                }
            }

            int count = 0;
            do
            {
                filename = Path.Combine(path,
                    $"{playerName}{(count != 0 ? count.ToString() : "")}.{type}");
                count--; // cause a - to be put in front of the number
            } while (File.Exists(filename));

            try
            {
                IntPtr hBmp = Platform.CaptureScreen(Client.Instance.GetWindowHandle(), Config.GetBool("CapFullScreen"),
                    imageTimestampTag);
                using (Image img = Image.FromHbitmap(hBmp))
                    img.Save(filename, GetFormat(type));
                DeleteObject(hBmp);
            }
            catch
            {
                // ignored
            }

            LastMobileDeathName = string.Empty;

            Engine.MainWindow.SafeAction(s => s.ReloadScreenShotsList());
        }

        private static ImageFormat GetFormat(string fmt)
        {
            //string fmt = Config.GetString( "ImageFormat" ).ToLower();
            if (fmt == "jpeg" || fmt == "jpg")
                return ImageFormat.Jpeg;
            else if (fmt == "png")
                return ImageFormat.Png;
            else if (fmt == "bmp")
                return ImageFormat.Bmp;
            else if (fmt == "gif")
                return ImageFormat.Gif;
            else if (fmt == "tiff" || fmt == "tif")
                return ImageFormat.Tiff;
            else if (fmt == "wmf")
                return ImageFormat.Wmf;
            else if (fmt == "exif")
                return ImageFormat.Exif;
            else if (fmt == "emf")
                return ImageFormat.Emf;
            else
                return ImageFormat.Jpeg;
        }

        public static void DisplayTo(ListBox list)
        {
            string path = Config.GetString("CapPath");
            Engine.EnsureDirectory(path);

            //list.BeginUpdate();
            list.Items.Clear();

            AddFiles(list, path, "jpeg");
            AddFiles(list, path, "jpg");
            AddFiles(list, path, "png");
            AddFiles(list, path, "bmp");
            AddFiles(list, path, "gif");
            AddFiles(list, path, "tiff");
            AddFiles(list, path, "tif");
            AddFiles(list, path, "wmf");
            AddFiles(list, path, "exif");
            AddFiles(list, path, "emf");
            //list.EndUpdate();
        }

        public static void AddFiles(ListBox list, string path, string ext)
        {
            if (list.Items.Count >= 500)
                return;

            string[] files = Directory.GetFiles(path, $"*.{ext}");
            for (int i = 0; i < files.Length && list.Items.Count < 500; i++)
                list.Items.Add(Path.GetFileName(files[i]));
        }


        public static Image CaptureWindow(IntPtr handle)
        {
            // get te hDC of the target window
            IntPtr hdcSrc = User32.GetWindowDC(handle);
            // get the size
            User32.RECT windowRect = new User32.RECT();
            User32.GetWindowRect(handle, ref windowRect);
            int width = windowRect.right - windowRect.left;
            int height = windowRect.bottom - windowRect.top;
            // create a device context we can copy to
            IntPtr hdcDest = GDI32.CreateCompatibleDC(hdcSrc);
            // create a bitmap we can copy it to,
            // using GetDeviceCaps to get the width/height
            IntPtr hBitmap = GDI32.CreateCompatibleBitmap(hdcSrc, width, height);
            // select the bitmap object
            IntPtr hOld = GDI32.SelectObject(hdcDest, hBitmap);
            // bitblt over
            GDI32.BitBlt(hdcDest, 0, 0, width, height, hdcSrc, 0, 0, GDI32.SRCCOPY);
            // restore selection
            GDI32.SelectObject(hdcDest, hOld);
            // clean up
            GDI32.DeleteDC(hdcDest);
            User32.ReleaseDC(handle, hdcSrc);
            // get a .NET image object for it
            Image img = Image.FromHbitmap(hBitmap);
            // free up the Bitmap object
            GDI32.DeleteObject(hBitmap);
            return img;
        }

        /// <summary>
        /// Captures a screen shot of a specific window, and saves it to a file
        /// </summary>
        /// <param name="handle"></param>
        /// <param name="filename"></param>
        /// <param name="format"></param>
        public static void CaptureWindowToFile(IntPtr handle, string filename, ImageFormat format)
        {
            Image img = CaptureWindow(handle);
            img.Save(filename, format);
        }

        /// <summary>
        /// Captures a screen shot of the entire desktop, and saves it to a file
        /// </summary>
        /// <param name="filename"></param>
        /// <param name="format"></param>
        public static void CaptureScreenToFile(string filename, ImageFormat format)
        {
            Image img = CaptureScreen();
            img.Save(filename, format);
        }

        public static Image CaptureScreen()
        {
            return CaptureWindow(User32.GetDesktopWindow());
        }

        /// <summary>
        /// Helper class containing Gdi32 API functions
        /// </summary>
        private class GDI32
        {
            public const int SRCCOPY = 0x00CC0020; // BitBlt dwRop parameter

            [DllImport("gdi32.dll")]
            public static extern bool BitBlt(IntPtr hObject, int nXDest, int nYDest,
                int nWidth, int nHeight, IntPtr hObjectSource,
                int nXSrc, int nYSrc, int dwRop);

            [DllImport("gdi32.dll")]
            public static extern IntPtr CreateCompatibleBitmap(IntPtr hDC, int nWidth,
                int nHeight);

            [DllImport("gdi32.dll")]
            public static extern IntPtr CreateCompatibleDC(IntPtr hDC);

            [DllImport("gdi32.dll")]
            public static extern bool DeleteDC(IntPtr hDC);

            [DllImport("gdi32.dll")]
            public static extern bool DeleteObject(IntPtr hObject);

            [DllImport("gdi32.dll")]
            public static extern IntPtr SelectObject(IntPtr hDC, IntPtr hObject);
        }

        /// <summary>
        /// Helper class containing User32 API functions
        /// </summary>
        private class User32
        {
            [StructLayout(LayoutKind.Sequential)]
            public struct RECT
            {
                public int left;
                public int top;
                public int right;
                public int bottom;
            }

            [DllImport("user32.dll")]
            public static extern IntPtr GetDesktopWindow();

            [DllImport("user32.dll")]
            public static extern IntPtr GetWindowDC(IntPtr hWnd);

            [DllImport("user32.dll")]
            public static extern IntPtr ReleaseDC(IntPtr hWnd, IntPtr hDC);

            [DllImport("user32.dll")]
            public static extern IntPtr GetWindowRect(IntPtr hWnd, ref RECT rect);
        }
    }
}

================================================
FILE: Razor/Core/Serial.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;

namespace Assistant
{
    public struct Serial : IComparable
    {
        private uint m_Serial;
        public static List<Serial> Serials { get; set; }

        public static readonly Serial MinusOne = new Serial(0xFFFFFFFF);
        public static readonly Serial Zero = new Serial(0);

        private Serial(uint serial)
        {
            m_Serial = serial;
        }

        public uint Value
        {
            get { return m_Serial; }
        }

        public bool IsMobile
        {
            get { return (m_Serial > 0 && m_Serial < 0x40000000); }
        }

        public bool IsItem
        {
            get { return (m_Serial >= 0x40000000 && m_Serial <= 0x7FFFFF00); }
        }

        public bool IsValid
        {
            get { return (m_Serial > 0 && m_Serial <= 0x7FFFFF00); }
        }

        public override int GetHashCode()
        {
            return (int) m_Serial;
        }

        public int CompareTo(object o)
        {
            if (o == null) return 1;
            else if (!(o is Serial)) throw new ArgumentException();

            uint ser = ((Serial) o).m_Serial;

            if (m_Serial > ser) return 1;
            else if (m_Serial < ser) return -1;
            else return 0;
        }

        public override bool Equals(object o)
        {
            if (o == null || !(o is Serial)) return false;

            return ((Serial) o).m_Serial == m_Serial;
        }

        public static bool operator ==(Serial l, Serial r)
        {
            return l.m_Serial == r.m_Serial;
        }

        public static bool operator !=(Serial l, Serial r)
        {
            return l.m_Serial != r.m_Serial;
        }

        public static bool operator >(Serial l, Serial r)
        {
            return l.m_Serial > r.m_Serial;
        }

        public static bool operator <(Serial l, Serial r)
        {
            return l.m_Serial < r.m_Serial;
        }

        public static bool operator >=(Serial l, Serial r)
        {
            return l.m_Serial >= r.m_Serial;
        }

        public static bool operator <=(Serial l, Serial r)
        {
            return l.m_Serial <= r.m_Serial;
        }

        public override string ToString()
        {
            return $"0x{m_Serial:X}";
        }

        public static Serial Parse(string s)
        {
            if (s.StartsWith("0x"))
                return (Serial) Convert.ToUInt32(s.Substring(2), 16);
            else
                return (Serial) Convert.ToUInt32(s);
        }

        public static implicit operator uint(Serial a)
        {
            return a.m_Serial;
        }

        public static implicit operator int(Serial a)
        {
            return (int) a.m_Serial;
        }

        public static implicit operator Serial(uint a)
        {
            return new Serial(a);
        }
    }
}

================================================
FILE: Razor/Core/SkillTimer.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;

namespace Assistant
{
    public class SkillTimer
    {
        private static int m_Count;
        private static Timer m_Timer;

        static SkillTimer()
        {
            m_Timer = new InternalTimer();
        }

        public static int Count
        {
            get { return m_Count; }
        }

        public static bool Running
        {
            get { return m_Timer.Running; }
        }

        public static void Start()
        {
            m_Count = 0;

            if (m_Timer.Running)
            {
                m_Timer.Stop();
            }

            m_Timer.Start();
            Client.Instance.RequestTitlebarUpdate();
        }

        public static void Stop()
        {
            m_Timer.Stop();
            Client.Instance.RequestTitlebarUpdate();
        }

        private class InternalTimer : Timer
        {
            public InternalTimer() : base(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1))
            {
            }

            protected override void OnTick()
            {
                m_Count++;
                if (m_Count > 10)
                {
                    Stop();
                }

                Client.Instance.RequestTitlebarUpdate();
            }
        }
    }
}

================================================
FILE: Razor/Core/Spells.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.IO;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using Assistant.Core;

namespace Assistant
{
    public class Spell
    {
        public enum SpellFlag
        {
            None = '?',
            Beneficial = 'B',
            Harmful = 'H',
            Neutral = 'N'
        }

        public enum SpellKind
        {
            Magery,
            Necromancy,
            Chivalry,
            Bushido,
            Ninjutsu,
            Spellweaving,
            Mysticism,
            Masteries,
            Unknown
        }

        readonly public SpellFlag Flag;
        readonly public int Circle;
        readonly public int Number;
        readonly public string WordsOfPower;
        readonly public string[] Reagents;

        private static Timer m_UnflagTimer;

        public Spell(char flag, int n, int c, string power, string[] reags)
        {
            Flag = (SpellFlag) flag;
            Number = n;
            Circle = c;
            WordsOfPower = power;
            Reagents = reags;
        }

        public SpellKind Kind
        {
            get
            {
                switch(Circle)
                {
                    case int circle when circle <= 8:
                        return SpellKind.Magery;
                    case 10:
                        return SpellKind.Necromancy;
                    case 20:
                        return SpellKind.Chivalry;
                    case 40:
                        return SpellKind.Bushido;
                    case 50:
                        return SpellKind.Ninjutsu;
                    case 60:
                        return SpellKind.Spellweaving;
                    case 65:
                        return SpellKind.Mysticism;
                    case 70:
                        return SpellKind.Masteries;
                    default:
                        return SpellKind.Unknown;
                }
            }
        }

        public bool NeedsChanneling
        {
            get
            {
                return (Kind == SpellKind.Magery || Kind == SpellKind.Mysticism);
            }
        }

        public int Name
        {
            get
            {
                switch(Kind)
                {
                    case SpellKind.Magery:
                        return 3002011 + ((Circle - 1) * 8) + (Number - 1);

                    case SpellKind.Necromancy:
                        return 1060509 + Number - 1;

                    case SpellKind.Chivalry:
                        return 1060585 + Number - 1;

                    case SpellKind.Bushido:
                        return 1060595 + Number - 1;

                    case SpellKind.Ninjutsu:
                        return 1060610 + Number - 1;

                    case SpellKind.Spellweaving:
                        return 1071026 + Number - 1;

                    case SpellKind.Mysticism:
                        return 1031678 + this.Number - 28;

                    case SpellKind.Masteries:
                    {
                        if (Number <= 6)
                            return 1115683 + Number - 1;

                        return 1155896 + Number - 7;
                    }

                    default:
                        return -1;

                }
            }
        }

        public override string ToString()
        {
            return $"{Language.GetString(this.Name)} (#{GetID()})";
        }

        public string GetName()
        {
            return $"{Language.GetString(Name)}";
        }

        public int GetID()
        {
            return ToID(Circle, Number);
        }

        public int GetHue(int def)
        {
            if (Config.GetBool("ForceSpellHue"))
            {
                switch (Flag)
                {
                    case SpellFlag.Beneficial:
                        return Config.GetInt("BeneficialSpellHue");
                    case SpellFlag.Harmful:
                        return Config.GetInt("HarmfulSpellHue");
                    case SpellFlag.Neutral:
                        return Config.GetInt("NeutralSpellHue");
                    default:
                        return def;
                }
            }
            else
            {
                return def;
            }
        }

        public void OnCast(PacketReader p)
        {
            Cast();
            Client.Instance.SendToServer(p);
        }

        public void OnCast(Packet p)
        {
            Cast();
            Client.Instance.SendToServer(p);
        }

        private void Cast()
        {
            if (Config.GetBool("SpellUnequip")
                && Client.Instance.AllowBit(FeatureBit.UnequipBeforeCast)
                && NeedsChanneling)
            {
                Item pack = World.Player.Backpack;
                if (pack != null)
                {
                    // dont worry about uneqipping RuneBooks or SpellBooks
                    Item item = World.Player.GetItemOnLayer(Layer.RightHand);
#if DEBUG
                    if (item != null && item.ItemID != 0x22C5 && item.ItemID != 0xE3B && item.ItemID != 0xEFA &&
                        !item.IsVirtueShield)
#else
					if ( item != null && item.ItemID != 0x22C5 && item.ItemID != 0xE3B && item.ItemID != 0xEFA )
#endif
                    {
                        DragDropManager.Drag(item, item.Amount);
                        DragDropManager.Drop(item, pack);
                    }

                    item = World.Player.GetItemOnLayer(Layer.LeftHand);
#if DEBUG
                    if (item != null && item.ItemID != 0x22C5 && item.ItemID != 0xE3B && item.ItemID != 0xEFA &&
                        !item.IsVirtueShield)
#else
					if ( item != null && item.ItemID != 0x22C5 && item.ItemID != 0xE3B && item.ItemID != 0xEFA )
#endif
                    {
                        DragDropManager.Drag(item, item.Amount);
                        DragDropManager.Drop(item, pack);
                    }
                }
            }

            for (int i = 0; i < Counter.List.Count; i++)
                ((Counter) Counter.List[i]).Flag = false;

            if (Config.GetBool("HighlightReagents"))
            {
                for (int r = 0; r < Reagents.Length; r++)
                {
                    for (int i = 0; i < Counter.List.Count; i++)
                    {
                        Counter c = (Counter) Counter.List[i];
                        if (c.Enabled && c.Format.ToLower() == Reagents[r])
                        {
                            c.Flag = true;
                            break;
                        }
                    }
                }

                if (m_UnflagTimer != null)
                    m_UnflagTimer.Stop();
                else
                    m_UnflagTimer = new UnflagTimer();
                m_UnflagTimer.Start();
            }

            Client.Instance.RequestTitlebarUpdate();
            UOAssist.PostSpellCast(this.Number);

            if (World.Player != null)
            {
                World.Player.LastSpell = GetID();
                LastCastTime = DateTime.UtcNow;
                Targeting.SpellTargetID = 0;
            }
        }

        public static DateTime LastCastTime = DateTime.MinValue;

        private class UnflagTimer : Timer
        {
            public UnflagTimer() : base(TimeSpan.FromSeconds(30.0))
            {
            }

            protected override void OnTick()
            {
                for (int i = 0; i < Counter.List.Count; i++)
                    ((Counter) Counter.List[i]).Flag = false;
                Client.Instance.RequestTitlebarUpdate();
            }
        }

        private static Dictionary<string, Spell> m_SpellsByPower;
        private static Dictionary<int, Spell> m_SpellsByID;
        private static Dictionary<string, Spell> m_SpellsByName;
        private static HotKeyCallbackState HotKeyCallback;

        static Spell()
        {
            string filename = Path.Combine(Config.GetInstallDirectory(), "spells.def");
            m_SpellsByPower = new Dictionary<string, Spell>(64 + 10 + 16);
            m_SpellsByID = new Dictionary<int, Spell>(64 + 10 + 16);
            m_SpellsByName = new Dictionary<string, Spell>(64 + 10 + 16);

            if (!File.Exists(filename))
            {
                MessageBox.Show(Engine.ActiveWindow, Language.GetString(LocString.NoSpells), "Spells.def",
                    MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }

            using (StreamReader reader = new StreamReader(filename))
            {
                string line;
                while ((line = reader.ReadLine()) != null)
                {
                    line = line.Trim();
                    if (line.Length <= 0 || line[0] == '#')
                        continue;
                    string[] split = line.Split('|');

                    try
                    {
                        if (split.Length >= 5)
                        {
                            string[] reags = new string[split.Length - 5];
                            for (int i = 5; i < split.Length; i++)
                                reags[i - 5] = split[i].ToLower().Trim();
                            Spell s = new Spell(split[0].Trim()[0], Convert.ToInt32(split[1].Trim()),
                                Convert.ToInt32(split[2].Trim()), /*split[3].Trim(),*/ split[4].Trim(), reags);

                            m_SpellsByID[s.GetID()] = s;

                            line = Language.GetString(s.Name);
                            if (string.IsNullOrEmpty(line))
                                line = split[3].Trim();
                            if (!string.IsNullOrEmpty(line))
                                m_SpellsByName[line.ToLower()] = s;

                            if (s.WordsOfPower != null && s.WordsOfPower.Trim().Length > 0)
                                m_SpellsByPower[s.WordsOfPower] = s;
                        }
                    }
                    catch
                    {
                    }
                }
            }

            HotKeyCallback = new HotKeyCallbackState(OnHotKey);
            foreach (Spell s in m_SpellsByID.Values)
                HotKey.Add(HKCategory.Spells, HKSubCat.SpellOffset + s.Circle, s.Name, HotKeyCallback,
                    (ushort) s.GetID());
            HotKey.Add(HKCategory.Spells, LocString.HealOrCureSelf, new HotKeyCallback(HealOrCureSelf));
            HotKey.Add(HKCategory.Spells, LocString.MiniHealOrCureSelf, new HotKeyCallback(MiniHealOrCureSelf));
            HotKey.Add(HKCategory.Spells, LocString.GHealOrCureSelf, new HotKeyCallback(GHealOrCureSelf));
            HotKey.Add(HKCategory.Spells, LocString.Interrupt, new HotKeyCallback(Interrupt));
            
            MessageManager.OnSpellMessage += HandleSpellMessage;
        }
        
        private static StringBuilder SpellPowerwordsBuilder { get; set; } = new StringBuilder(Config.GetString("SpellFormat"));
        
        private static void ResetSpellPowerwordsBuilder()
        {
            SpellPowerwordsBuilder.Remove(0, SpellPowerwordsBuilder.Length);
            SpellPowerwordsBuilder.Insert(0, Config.GetString("SpellFormat"));
        }
        
        private static void HandleSpellMessage(Packet p, PacketHandlerEventArgs args, Serial source, ushort graphic,
            MessageType type, ushort hue, ushort font, string lang, string sourceName,
            string text)
        {
            Spell s = Get(text.Trim());

            if (Config.GetBool("OverrideSpellFormat") && s != null)
            {
                ResetSpellPowerwordsBuilder();

                StringBuilder sb = SpellPowerwordsBuilder;
                sb.Replace(@"{power}", s.WordsOfPower);
                string spell = Language.GetString(s.Name);
                sb.Replace(@"{spell}", spell);
                sb.Replace(@"{name}", spell);
                sb.Replace(@"{circle}", s.Circle.ToString());

                string newText = sb.ToString();

                if (newText != null && newText != "" && newText != text)
                {
                    Client.Instance.SendToClient(new AsciiMessage(source, graphic, MessageType.Spell, s.GetHue(hue), font,
                        sourceName, newText));

                    args.Block = true;
                    return;
                }
            }

            if (Config.GetBool("ForceSpellHue"))
            {
                p.Seek(10, SeekOrigin.Begin);
                if (s != null)
                    p.Write((ushort)s.GetHue(hue));
                else
                    p.Write((ushort)Config.GetInt("NeutralSpellHue"));
            }
        }

        public static void HealOrCureSelf()
        {
            Spell s = null;

            if (!Client.Instance.AllowBit(FeatureBit.BlockHealPoisoned))
            {
                if (World.Player.Hits + 30 < World.Player.HitsMax && World.Player.Mana >= 12)
                    s = Get(4, 5); // greater heal
                else
                    s = Get(1, 4); // mini heal
            }
            else
            {
                if (World.Player.Poisoned && Client.Instance.AllowBit(FeatureBit.BlockHealPoisoned))
                {
                    s = Get(2, 3); // cure
                }
                else if (World.Player.Hits + 2 < World.Player.HitsMax)
                {
                    if (World.Player.Hits + 30 < World.Player.HitsMax && World.Player.Mana >= 12)
                        s = Get(4, 5); // greater heal
                    else
                        s = Get(1, 4); // mini heal
                }
                else
                {
                    if (World.Player.Mana >= 12)
                        s = Get(4, 5); // greater heal
                    else
                        s = Get(1, 4); // mini heal
                }
            }

            if (s != null)
            {
                if (World.Player.Poisoned || World.Player.Hits < World.Player.HitsMax)
                    Targeting.TargetSelf(true);
                Client.Instance.SendToServer(new CastSpellFromMacro((ushort) s.GetID()));
                s.Cast();
            }
        }

        public static void MiniHealOrCureSelf()
        {
            Spell s = null;

            if (!Client.Instance.AllowBit(FeatureBit.BlockHealPoisoned))
            {
                s = Get(1, 4); // mini heal
            }
            else
            {
                if (World.Player.Poisoned)
                    s = Get(2, 3); // cure
                else
                    s = Get(1, 4); // mini heal
            }

            if (s != null)
            {
                if (World.Player.Poisoned || World.Player.Hits < World.Player.HitsMax)
                    Targeting.TargetSelf(true);
                Client.Instance.SendToServer(new CastSpellFromMacro((ushort) s.GetID()));
                s.Cast();
            }
        }

        public static void GHealOrCureSelf()
        {
            Spell s = null;

            if (!Client.Instance.AllowBit(FeatureBit.BlockHealPoisoned))
            {
                s = Get(4, 5); // gheal
            }
            else
            {
                if (World.Player.Poisoned)
                    s = Get(2, 3); // cure
                else
                    s = Get(4, 5); // gheal
            }

            if (s != null)
            {
                if (World.Player.Poisoned || World.Player.Hits < World.Player.HitsMax)
                    Targeting.TargetSelf(true);
                Client.Instance.SendToServer(new CastSpellFromMacro((ushort) s.GetID()));
                s.Cast();
            }
        }
        
        public static void Interrupt(Layer layer)
        {
            Item item = World.Player.GetItemOnLayer(layer);

            if (item != null)
            {
                Client.Instance.SendToServer(new LiftRequest(item, 1)); // unequip
                Client.Instance.SendToServer(new EquipRequest(item.Serial, World.Player, item.Layer)); // Equip
            }
        }

        public static void Interrupt()
        {
            Item item = FindUsedLayer();

            if (item != null)
            {
                Client.Instance.SendToServer(new LiftRequest(item, 1)); // unequip
                Client.Instance.SendToServer(new EquipRequest(item.Serial, World.Player, item.Layer)); // Equip
            }
        }

        private static Item FindUsedLayer()
        {
            Item layeredItem = World.Player.GetItemOnLayer(Layer.Shirt);
            if (layeredItem != null)
                return layeredItem;

            layeredItem = World.Player.GetItemOnLayer(Layer.Shoes);
            if (layeredItem != null)
                return layeredItem;

            layeredItem = World.Player.GetItemOnLayer(Layer.Pants);
            if (layeredItem != null)
                return layeredItem;

            layeredItem = World.Player.GetItemOnLayer(Layer.Head);
            if (layeredItem != null)
                return layeredItem;

            layeredItem = World.Player.GetItemOnLayer(Layer.Gloves);
            if (layeredItem != null)
                return layeredItem;

            layeredItem = World.Player.GetItemOnLayer(Layer.Ring);
            if (layeredItem != null)
                return layeredItem;

            layeredItem = World.Player.GetItemOnLayer(Layer.Neck);
            if (layeredItem != null)
                return layeredItem;

            layeredItem = World.Player.GetItemOnLayer(Layer.Waist);
            if (layeredItem != null)
                return layeredItem;

            layeredItem = World.Player.GetItemOnLayer(Layer.InnerTorso);
            if (layeredItem != null)
                return layeredItem;

            layeredItem = World.Player.GetItemOnLayer(Layer.Bracelet);
            if (layeredItem != null)
                return layeredItem;

            layeredItem = World.Player.GetItemOnLayer(Layer.MiddleTorso);
            if (layeredItem != null)
                return layeredItem;

            layeredItem = World.Player.GetItemOnLayer(Layer.Earrings);
            if (layeredItem != null)
                return layeredItem;

            layeredItem = World.Player.GetItemOnLayer(Layer.Arms);
            if (layeredItem != null)
                return layeredItem;

            layeredItem = World.Player.GetItemOnLayer(Layer.Cloak);
            if (layeredItem != null)
                return layeredItem;

            layeredItem = World.Player.GetItemOnLayer(Layer.OuterTorso);
            if (layeredItem != null)
                return layeredItem;

            layeredItem = World.Player.GetItemOnLayer(Layer.OuterLegs);
            if (layeredItem != null)
                return layeredItem;

            layeredItem = World.Player.GetItemOnLayer(Layer.InnerLegs);
            if (layeredItem != null)
                return layeredItem;

            layeredItem = World.Player.GetItemOnLayer(Layer.RightHand);
            if (layeredItem != null)
                return layeredItem;

            layeredItem = World.Player.GetItemOnLayer(Layer.LeftHand);
            if (layeredItem != null)
                return layeredItem;

            return null;
        }

        public static void Initialize()
        {
            // no code, this is here to make sure out static ctor is init'd by the core
        }

        public static void OnHotKey(ref object state)
        {
            ushort id = (ushort) state;
            Spell s = Spell.Get(id);
            if (s != null)
            {
                s.OnCast(new CastSpellFromMacro(id));
                //if ( Macros.MacroManager.AcceptActions )
                //	Macros.MacroManager.Action( new Macros.MacroCastSpellAction( s ) );
            }
        }

        public static int ToID(int circle, int num)
        {
            if (circle < 10)
                return ((circle - 1) * 8) + num;
            else
                return (circle * 10) + num;
        }

        public static Spell Get(string power)
        {
            Spell s;
            m_SpellsByPower.TryGetValue(power, out s);
            return s;
        }

        public static Spell Get(int num)
        {
            Spell s;
            m_SpellsByID.TryGetValue(num, out s);
            return s;
        }

        public static Spell GetByName(string name)
        {
            m_SpellsByName.TryGetValue(name.ToLower(), out Spell s);
            return s;
        }

        public static string GetName(int num)
        {
            if (m_SpellsByID.TryGetValue(num, out Spell spell))
            {
                return spell.GetName();
            }

            return string.Empty;
        }

        public static Spell Get(int circle, int num)
        {
            return Get(Spell.ToID(circle, num));
        }
    }
}

================================================
FILE: Razor/Core/StaffToolsManager.cs
================================================
#region license

// Razor: An Ultima Online Assistant
// Copyright (C) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#endregion

using System;
using System.IO;
using System.Windows.Forms;
using System.Xml;
using Assistant.UI;
using FastColoredTextBoxNS;
using Ultima;

namespace Assistant.Core
{
    public static class StaffToolsManager
    {
        public static void Initialize()
        {
           
        }

        public static void LoadItems(TreeView tree)
        {
            XmlDocument xDoc = new XmlDocument();
            xDoc.Load(Path.Combine(Config.GetInstallDirectory(), "items.xml"));

            tree.SafeAction(s =>
            {
                s.BeginUpdate();

                s.Nodes.Clear();
                s.Nodes.Add(new TreeNode(xDoc.DocumentElement.Name));

                TreeNode tNode = s.Nodes[0];
                AddItemTreeNode(xDoc.DocumentElement, tNode);

                s.Nodes[0].Expand();

                s.EndUpdate();
            });
        }
        
        public static void LoadDoors(TreeView tree)
        {
            XmlDocument xDoc = new XmlDocument();
            xDoc.Load(Path.Combine(Config.GetInstallDirectory(), "doors.xml"));

            tree.SafeAction(s =>
            {
                s.BeginUpdate();

                s.Nodes.Clear();
                s.Nodes.Add(new TreeNode(xDoc.DocumentElement.Name));

                TreeNode tNode = s.Nodes[0];
                AddDoorTreeNode(xDoc.DocumentElement, tNode);

                s.Nodes[0].Expand();

                s.EndUpdate();
            });
        }

        private static void AddItemTreeNode(XmlNode xmlNode, TreeNode treeNode)
        {
            if (xmlNode.HasChildNodes)
            {
                XmlNodeList xNodeList = xmlNode.ChildNodes;

                for (int x = 0; x <= xNodeList.Count - 1; x++)
                {
                    XmlNode xNode = xmlNode.ChildNodes[x];

                    if (xNode.Attributes != null)
                    {
                        XmlAttribute name = xNode.Attributes["name"];

                        treeNode.Nodes.Add(name != null ? new TreeNode(name.Value) : new TreeNode(xNode.Name));
                    }
                    else
                    {
                        treeNode.Nodes.Add(new TreeNode(xNode.Name));
                    }

                    TreeNode tNode = treeNode.Nodes[x];
                    AddItemTreeNode(xNode, tNode);
                }
            }
            else
            {
                XmlAttribute id = xmlNode.Attributes?["ID"];

                if (id != null)
                {
                    int itemId = Utility.ToInt32(id.Value, 0x0);
                    string itemName = TileData.ItemTable[itemId].Name;

                    treeNode.Text = string.IsNullOrEmpty(itemName) ? $"{id.Value}" : $"{itemName} ({id.Value})";

                    treeNode.Tag = itemId;

                }
                else
                {
                    xmlNode.OuterXml.Trim();
                }
            }
        }


        private static void AddDoorTreeNode(XmlNode xmlNode, TreeNode treeNode)
        {
            if (xmlNode.HasChildNodes)
            {
                XmlNodeList xNodeList = xmlNode.ChildNodes;

                for (int x = 0; x <= xNodeList.Count - 1; x++)
                {
                    XmlNode xNode = xmlNode.ChildNodes[x];

                    if (xNode.Attributes != null)
                    {
                        DoorInfo doorInfo = DoorInfo.FromXmlNode(xNode);

                        treeNode.Nodes.Add(new TreeNode(doorInfo.Name));
                    }
                    else
                    {
                        treeNode.Nodes.Add(new TreeNode(xNode.Name));
                    }

                    TreeNode tNode = treeNode.Nodes[x];
                    AddDoorTreeNode(xNode, tNode);
                }
            }
            else
            {
                XmlAttribute id = xmlNode.Attributes?["base"];

                if (id != null)
                {
                    //<Door name="Stone 1" base="232" item="SecretStoneDoor1"></Door>
                    DoorInfo doorInfo = DoorInfo.FromXmlNode(xmlNode);
                    treeNode.Tag = doorInfo;

                }
                else
                {
                    xmlNode.OuterXml.Trim();
                }
            }
        }

        public static void AddDoor(DoorInfo door, string facing)
        {
            string command = $"[add {door.Item} {facing}";

            World.Player.SendMessage(MsgLevel.Info, $"Command: {command}");
            World.Player.Say(command);
        }

        public static int GetDoorOffset(string facing)
        {
            var offset = 0;

            if (facing.Contains("WestCW"))
            {
                offset = 0;
            }
            else if (facing.Contains("EastCCW"))
            {
                offset = 2;
            }
            else if (facing.Contains("WestCCW"))
            {
                offset = 4;
            }
            else if (facing.Contains("EastCW"))
            {
                offset = 6;
            }
            else if (facing.Contains("NorthCW"))
            {
                offset = 14;
            }
            else if (facing.Contains("SouthCCW"))
            {
                offset = 8;
            }
            else if (facing.Contains("NorthCCW"))
            {
                offset = 10;
            }
            else if (facing.Contains("SouthCW"))
            {
                offset = 12;
            }

            return offset;
        }
    }

    public class DoorInfo
    {
        /// <summary>
        ///     Gets or sets the door name
        /// </summary>
        public string Name { get; private set; }

        /// <summary>
        ///     Gets or sets the door's item name
        /// </summary>
        public string Item { get; private set; }

        /// <summary>
        ///     Gets or sets the door's base ID
        /// </summary>
        public int BaseId { get; private set; }

        /// <summary>
        ///     Creates a new DoorInfo object
        /// </summary>
        private DoorInfo()
        { }

        /// <summary>
        ///     Creates a DoorInfo from an Xml node
        /// </summary>
        /// <param name="xNode">The XmlNode to convert to a door info</param>
        /// <returns>A Door Info object</returns>
        public static DoorInfo FromXmlNode(XmlNode xNode)
        {
            var door = new DoorInfo
            {
                Name = xNode.Attributes["name"].Value,
                Item = xNode.Attributes["item"]?.Value,
                BaseId = xNode.Attributes["base"]?.Value != null ? int.Parse(xNode.Attributes["base"].Value) : 0
            };

            return door;
        }
    }
}

================================================
FILE: Razor/Core/StealthSteps.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

namespace Assistant
{
    public class StealthSteps
    {
        private static int m_Count;
        private static bool m_Hidden = false;

        public static int Count
        {
            get { return m_Count; }
        }

        public static bool Counting
        {
            get { return m_Hidden; }
        }

        public static bool Hidden
        {
            get { return m_Hidden; }
        }

        public static void OnMove()
        {
            if (m_Hidden && Config.GetBool("CountStealthSteps") && World.Player != null)
            {
                m_Count++;

                string message = Config.GetString("StealthStepsFormat").Replace("{step}", m_Count.ToString());

                if (string.IsNullOrEmpty(message))
                    message = $"Steps: {m_Count}";

                if (Config.GetBool("StealthOverhead"))
                {
                    World.Player.OverheadMessage(message);
                }
                else
                {
                    World.Player.SendMessage(MsgLevel.Error, message);
                }

                if (m_Count > 30)
                    Unhide();
            }
        }

        public static void Hide()
        {
            m_Hidden = true;
            m_Count = 0;
        }

        public static void Unhide()
        {
            m_Hidden = false;
            m_Count = 0;
        }
    }
}

================================================
FILE: Razor/Core/SystemMessages.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;

namespace Assistant.Core
{
    public static class SystemMessages
    {
        public static List<string> Messages { get; } = new List<string>();
        
        public static void Initialize()
        {
            MessageManager.OnSystemMessage += HandleSystemMessage;
        }
        
        private static void HandleSystemMessage(Packet p, PacketHandlerEventArgs args, Serial source, ushort graphic,
            MessageType type, ushort hue, ushort font, string lang, string sourceName,
            string text)
        {
            if (source == Serial.MinusOne && sourceName == "System")
            {
                if (Config.GetBool("FilterSnoopMsg") && text.IndexOf(World.Player.Name) == -1 &&
                    text.StartsWith("You notice") && text.IndexOf("attempting to peek into") != -1 &&
                    text.IndexOf("belongings") != -1)
                {
                    args.Block = true;
                    return;
                }

                if (text.StartsWith("You've committed a criminal act") || text.StartsWith("You are now a criminal"))
                {
                    World.Player.ResetCriminalTimer();
                }

                // Overhead message override
                OverheadManager.DisplayOverheadMessage(text);
            }

            if (!source.IsValid || source == World.Player.Serial || source.IsItem)
            {
                Add(text);
            }

            if (Config.GetBool("FilterSystemMessages") && source == Serial.MinusOne || source == Serial.Zero)
            {
                if (!MessageQueue.Enqueue(source, null, graphic, type, hue, font, lang, sourceName, text))
                {
                    args.Block = true;
                }
            }
        }

        public static void Add(string text)
        {
            if (string.IsNullOrEmpty(text))
            {
                return;
            }

            Messages.Add(text);

            if (Messages.Count >= 100)
            {
                Messages.RemoveRange(0, 10);
            }
        }

        public static bool Exists(string text)
        {
            if (string.IsNullOrEmpty(text))
            {
                return false;
            }

            for (int i = Messages.Count - 1; i >= 0; i--)
            {
                if (Messages[i].IndexOf(text, StringComparison.OrdinalIgnoreCase) != -1)
                {
                    Messages.RemoveRange(0, i + 1);
                    return true;
                }
            }

            return false;
        }
    }
}


================================================
FILE: Razor/Core/Targeting.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using Assistant.Agents;
using Assistant.Core;
using Assistant.Macros;
using Assistant.Scripts;

namespace Assistant
{
    public class TargetInfo
    {
        public byte Type;
        public uint TargID;
        public byte Flags;
        public Serial Serial;
        public int X, Y;
        public int Z;
        public ushort Gfx;
    }

    public partial class Targeting
    {
        public const uint LocalTargID = 0x7FFFFFFF; // uid for target sent from razor

        public delegate void TargetResponseCallback(bool location, Serial serial, Point3D p, ushort gfxid);

        public delegate void CancelTargetCallback();

        private static CancelTargetCallback _onCancel;
        private static TargetResponseCallback _onTarget;

        private static bool _intercept;
        private static bool _hasTarget;
        private static bool _clientTarget;
        private static TargetInfo _lastTarget { get; set; }
        private static TargetInfo _lastGroundTarget;
        private static TargetInfo _lastBeneTarget;
        private static TargetInfo _lastHarmTarget;


        private static bool _fromGrabHotKey;

        private static bool _allowGround;
        private static uint _currentID;
        private static byte _curFlags;

        private static uint _previousID;
        private static bool _previousGround;
        private static byte _prevFlags;

        private static Serial _lastCombatant;

        private delegate bool QueueTarget();

        private static readonly QueueTarget TargetSelfAction = new QueueTarget(DoTargetSelf);
        private static readonly QueueTarget LastTargetAction = new QueueTarget(DoLastTarget);
        private static QueueTarget _queueTarget;


        public static uint SpellTargetID { get; set; } = 0;

        private static List<uint> _filterCancel = new List<uint>();

        public static bool HasTarget
        {
            get { return _hasTarget; }
        }

        public static short CursorType => _curFlags;

        public static TargetInfo LastTargetInfo
        {
            get { return _lastTarget; }
        }

        public static bool FromGrabHotKey
        {
            get { return _fromGrabHotKey; }
        }

        private static List<ushort> _monsterIds = new List<ushort>()
        {
            0x1, 0x2, 0x3, 0x4, 0x7, 0x8, 0x9, 0xC, 0xD, 0xE, 0xF,
            0x10, 0x11, 0x12, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C,
            0x1E, 0x1F, 0x21, 0x23, 0x24, 0x25, 0x27, 0x29, 0x2A, 0x2C,
            0x2D, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
            0x39, 0x3B, 0x3C, 0x3D, 0x42, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
            0x4B, 0x4F, 0x50, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x59, 0x5A,
            0x5B, 0x5C, 0x5D, 0x5E, 0x60, 0x61, 0x62, 0x69, 0x6A, 0x6B, 0x6C,
            0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x87, 0x88, 0x89,
            0x8A, 0x8B, 0x8C, 0x8E, 0x8F, 0x91, 0x93, 0x96, 0x99, 0x9B, 0x9E,
            0x9F, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xB4, 0x4C, 0x4D, 0x3D
        };

        public enum TargetType
        {
            Invalid, // invalid/across server line
            Innocent, //Blue
            GuildAlly, //Green,
            Attackable, //Attackable but not criminal (gray)
            Criminal, //gray
            Enemy, //orange
            Murderer, //red

            // Razor specfic
            NonFriendly, //Attackable, Criminal, Enemy, Murderer
            Friendly, //Innocent, Guild/Ally 
            Red, //Murderer
            Blue, //Innocent
            //Friend, //Friend list
            Gray, //Attackable, Criminal
            Grey, //Attackable, Criminal
            Green, //GuildAlly
            Guild, //GuildAlly
        }


        public static void Initialize()
        {
            PacketHandler.RegisterClientToServerViewer(0x6C, TargetResponse);
            PacketHandler.RegisterServerToClientViewer(0x6C, NewTarget);
            PacketHandler.RegisterServerToClientViewer(0xAA, CombatantChange);

            HotKey.Add(HKCategory.Targets, LocString.LastTarget, LastTarget);
            HotKey.Add(HKCategory.Targets, LocString.TargetSelf, TargetSelf);
            HotKey.Add(HKCategory.Targets, LocString.ClearTargQueue, OnClearQueue);

            HotKey.Add(HKCategory.Targets, LocString.SetLT, TargetSetLastTarget);
            HotKey.Add(HKCategory.Targets, LocString.SetLastBeneficial, SetLastTargetBeneficial);
            HotKey.Add(HKCategory.Targets, LocString.SetLastHarmful, SetLastTargetHarmful);

            HotKey.Add(HKCategory.Targets, LocString.AttackLastComb, AttackLastComb);
            HotKey.Add(HKCategory.Targets, LocString.AttackLastTarg, AttackLastTarg);
            HotKey.Add(HKCategory.Targets, LocString.CancelTarget, CancelTarget);

            InitRandomTarget();
            InitNextPrevTargets();
            InitClosestTargets();
        }


        private static void CombatantChange(PacketReader p, PacketHandlerEventArgs e)
        {
            Serial ser = p.ReadUInt32();
            if (ser.IsMobile && ser != World.Player.Serial && ser != Serial.Zero && ser != Serial.MinusOne)
                _lastCombatant = ser;
        }

        private static void AttackLastComb()
        {
            if (_lastCombatant.IsMobile)
            {
                Client.Instance.SendToServer(new AttackReq(_lastCombatant));
                ShowAttackOverhead(_lastCombatant);
            }
                
        }

        public static void AttackLastTarg()
        {
            TargetInfo targ;
            if (IsSmartTargetingEnabled())
            {
                // If Smart Targetting is being used we'll assume that the user would like to attack the harmful target.
                targ = _lastHarmTarget;

                // If there is no last harmful target, then we'll attack the last target.
                if (targ == null)
                    targ = _lastTarget;
            }
            else
            {
                targ = _lastTarget;
            }

            if (targ != null && targ.Serial.IsMobile)
            {
                Client.Instance.SendToServer(new AttackReq(targ.Serial));
                ShowAttackOverhead(targ.Serial);
            }
        }

        private static Serial _lastOverheadMessageAttack;

        public static void ShowAttackOverhead(Serial serial)
        {
            if (!Config.GetBool("ShowAttackTargetOverhead"))
                return;

            if (Config.GetBool("ShowAttackTargetNewOnly") && serial == _lastOverheadMessageAttack)
                return;

            Mobile m = World.FindMobile(serial);
            if (m == null)
                return;

            World.Player.OverheadMessage(FriendsManager.IsFriend(m.Serial) ? 63 : m.GetNotorietyColorInt(),
                $"Attack: {m.Name}");

            _lastOverheadMessageAttack = serial;
        }

        public static void OnClearQueue()
        {
            ClearQueue();

            if (Config.GetBool("ShowTargetSelfLastClearOverhead"))
            {
                World.Player.OverheadMessage(LocString.TQCleared);
            }
            else
            {
                World.Player.SendMessage(MsgLevel.Force, LocString.TQCleared);
            }
        }

        internal static void OneTimeTarget(TargetResponseCallback onTarget)
        {
            OneTimeTarget(false, onTarget, null);
        }

        internal static void OneTimeTarget(TargetResponseCallback onTarget, bool fromGrab)
        {
            _fromGrabHotKey = fromGrab;

            OneTimeTarget(false, onTarget, null);
        }

        internal static void OneTimeTarget(bool ground, TargetResponseCallback onTarget)
        {
            OneTimeTarget(ground, onTarget, null);
        }

        internal static void OneTimeTarget(TargetResponseCallback onTarget, CancelTargetCallback onCancel)
        {
            OneTimeTarget(false, onTarget, onCancel);
        }

        internal static void OneTimeTarget(bool ground, TargetResponseCallback onTarget, CancelTargetCallback onCancel)
        {
            if (_intercept && _onCancel != null)
            {
                _onCancel();
                CancelOneTimeTarget();
            }

            if (_hasTarget && _currentID != 0 && _currentID != LocalTargID)
            {
                _previousID = _currentID;
                _previousGround = _allowGround;
                _prevFlags = _curFlags;

                _filterCancel.Add(_previousID);
            }

            _intercept = true;
            _currentID = LocalTargID;
            _onTarget = onTarget;
            _onCancel = onCancel;

            _clientTarget = _hasTarget = true;
            Client.Instance.SendToClient(new Target(LocalTargID, ground));
            ClearQueue();
        }

        internal static void CancelOneTimeTarget()
        {
            _clientTarget = _hasTarget = _fromGrabHotKey = false;

            Client.Instance.SendToClient(new CancelTarget(LocalTargID));
            EndIntercept();
        }

        private static bool _lastTargetWasSet;

        public static void TargetSetLastTarget()
        {
            if (World.Player != null)
            {
                _lastTargetWasSet = false;
                OneTimeTarget(false, OnSetLastTarget, OnSetLastTargetCancel);
                World.Player.SendMessage(MsgLevel.Force, LocString.TargSetLT);
            }
        }

        public static void SetLastTarget(Mobile mobile)
        {
            if (World.Player != null)
            {
                OnSetLastTarget(false, mobile.Serial, mobile.Position, mobile.Body);
            }
        }

        public static void SetLastTarget(Item item)
        {
            if (World.Player != null)
            {
                OnSetLastTarget(false, item.Serial, item.Position, item.ItemID.Value);
            }
        }

        public static void SetLastTarget(Serial serial)
        {
            if (World.Player != null)
            {
                OnSetLastTarget(false, serial, new Point3D(0, 0, 0), 0);
            }
        }

        private static void OnSetLastTargetCancel()
        {
            if (_lastTarget != null)
                _lastTargetWasSet = true;
        }

        private static void OnSetLastTarget(bool location, Serial serial, Point3D p, ushort gfxid)
        {
            if (serial == World.Player.Serial)
            {
                OnSetLastTargetCancel();
                return;
            }

            _lastBeneTarget = _lastHarmTarget = _lastGroundTarget = _lastTarget = new TargetInfo();
            _lastTarget.Flags = 0;
            _lastTarget.Gfx = gfxid;
            _lastTarget.Serial = serial;
            _lastTarget.Type = (byte) (location ? 1 : 0);
            _lastTarget.X = p.X;
            _lastTarget.Y = p.Y;
            _lastTarget.Z = p.Z;

            _lastTargetWasSet = true;

            World.Player.SendMessage(MsgLevel.Force, LocString.LTSet);

            if (serial.IsMobile)
            {
                LastTargetChanged();
                Client.Instance.SendToClient(new ChangeCombatant(serial));
                _lastCombatant = serial;
            }
        }

        private static bool m_LTBeneWasSet;

        /// <summary>
        /// Sets the beneficial target
        /// </summary>
        private static void SetLastTargetBeneficial()
        {
            if (!IsSmartTargetingEnabled())
            {
                World.Player.SendMessage(MsgLevel.Error, "Smart Targeting is disabled");
                return;
            }

            if (World.Player != null)
            {
                m_LTBeneWasSet = false;
                OneTimeTarget(false, OnSetLastTargetBeneficial, OnSLTBeneficialCancel);
                World.Player.SendMessage(MsgLevel.Force, LocString.NewBeneficialTarget);
            }
        }

        private static void OnSLTBeneficialCancel()
        {
            if (_lastBeneTarget != null)
                m_LTBeneWasSet = true;
        }

        private static void OnSetLastTargetBeneficial(bool location, Serial serial, Point3D p, ushort gfxid)
        {
            if (serial == World.Player.Serial)
            {
                OnSLTBeneficialCancel();
                return;
            }

            _lastBeneTarget = new TargetInfo
            {
                Flags = 0,
                Gfx = gfxid,
                Serial = serial,
                Type = (byte) (location ? 1 : 0),
                X = p.X,
                Y = p.Y,
                Z = p.Z
            };

            m_LTBeneWasSet = true;

            World.Player.SendMessage(MsgLevel.Force, LocString.SetLTBene);

            if (serial.IsMobile)
            {
                LastBeneficialTargetChanged();
            }
        }

        private static bool m_LTHarmWasSet;

        /// <summary>
        /// Sets the harmful target
        /// </summary>
        private static void SetLastTargetHarmful()
        {
            if (!IsSmartTargetingEnabled())
            {
                World.Player.SendMessage(MsgLevel.Error, "Smart Targeting is disabled");
                return;
            }

            if (World.Player != null)
            {
                OneTimeTarget(false, OnSetLastTargetHarmful, OnSLTHarmfulCancel);
                World.Player.SendMessage(MsgLevel.Force, LocString.NewHarmfulTarget);
            }
        }

        private static void OnSLTHarmfulCancel()
        {
            if (_lastTarget != null)
                m_LTHarmWasSet = true;
        }

        private static void OnSetLastTargetHarmful(bool location, Serial serial, Point3D p, ushort gfxid)
        {
            if (serial == World.Player.Serial)
            {
                OnSLTHarmfulCancel();
                return;
            }

            _lastHarmTarget = new TargetInfo
            {
                Flags = 0,
                Gfx = gfxid,
                Serial = serial,
                Type = (byte) (location ? 1 : 0),
                X = p.X,
                Y = p.Y,
                Z = p.Z
            };

            m_LTHarmWasSet = true;

            World.Player.SendMessage(MsgLevel.Force, LocString.SetLTHarm);

            if (serial.IsMobile)
            {
                LastHarmfulTargetChanged();
            }
        }

        private static Serial m_OldLT = Serial.Zero;
        private static Serial m_OldBeneficialLT = Serial.Zero;
        private static Serial m_OldHarmfulLT = Serial.Zero;

        private static void RemoveTextFlags(UOEntity m)
        {
            if (m != null)
            {
                bool oplchanged = false;

                oplchanged |= m.ObjPropList.Remove(Language.GetString(LocString.LastTarget));
                oplchanged |= m.ObjPropList.Remove(Language.GetString(LocString.HarmfulTarget));
                oplchanged |= m.ObjPropList.Remove(Language.GetString(LocString.BeneficialTarget));

                if (oplchanged)
                    m.OPLChanged();
            }
        }

        private static void AddTextFlags(UOEntity m)
        {
            if (m != null)
            {
                bool oplchanged = false;

                if (IsSmartTargetingEnabled())
                {
                    if (_lastHarmTarget != null && _lastHarmTarget.Serial == m.Serial)
                    {
                        oplchanged = true;
                        m.ObjPropList.Add(Language.GetString(LocString.HarmfulTarget));
                    }

                    if (_lastBeneTarget != null && _lastBeneTarget.Serial == m.Serial)
                    {
                        oplchanged = true;
                        m.ObjPropList.Add(Language.GetString(LocString.BeneficialTarget));
                    }
                }

                if (!oplchanged && _lastTarget != null && _lastTarget.Serial == m.Serial)
                {
                    oplchanged = true;
                    m.ObjPropList.Add(Language.GetString(LocString.LastTarget));
                }

                if (oplchanged)
                    m.OPLChanged();
            }
        }

        private static void LastTargetChanged()
        {
            if (_lastTarget != null)
            {
                bool lth = Config.GetInt("LTHilight") != 0;

                if (m_OldLT.IsItem)
                {
                    RemoveTextFlags(World.FindItem(m_OldLT));
                }
                else
                {
                    Mobile m = World.FindMobile(m_OldLT);
                    if (m != null)
                    {
                        if (lth)
                            Client.Instance.SendToClient(new MobileIncoming(m));

                        RemoveTextFlags(m);
                    }
                }

                if (_lastTarget.Serial.IsItem)
                {
                    AddTextFlags(World.FindItem(_lastTarget.Serial));
                }
                else
                {
                    Mobile m = World.FindMobile(_lastTarget.Serial);
                    if (m != null)
                    {
                        if (IsLastTarget(m) && lth)
                            Client.Instance.SendToClient(new MobileIncoming(m));

                        CheckLastTargetRange(m);

                        AddTextFlags(m);
                    }
                }

                m_OldLT = _lastTarget.Serial;
            }
        }

        private static void LastBeneficialTargetChanged()
        {
            if (_lastBeneTarget != null)
            {
                if (m_OldBeneficialLT.IsItem)
                {
                    RemoveTextFlags(World.FindItem(m_OldBeneficialLT));
                }
                else
                {
                    Mobile m = World.FindMobile(m_OldBeneficialLT);
                    if (m != null)
                    {
                        RemoveTextFlags(m);
                    }
                }

                if (_lastBeneTarget.Serial.IsItem)
                {
                    AddTextFlags(World.FindItem(_lastBeneTarget.Serial));
                }
                else
                {
                    Mobile m = World.FindMobile(_lastBeneTarget.Serial);
                    if (m != null)
                    {
                        CheckLastTargetRange(m);

                        AddTextFlags(m);
                    }
                }

                m_OldBeneficialLT = _lastBeneTarget.Serial;
            }
        }

        private static void LastHarmfulTargetChanged()
        {
            if (_lastHarmTarget != null)
            {
                if (m_OldHarmfulLT.IsItem)
                {
                    RemoveTextFlags(World.FindItem(m_OldHarmfulLT));
                }
                else
                {
                    Mobile m = World.FindMobile(m_OldHarmfulLT);
                    if (m != null)
                    {
                        RemoveTextFlags(m);
                    }
                }

                if (_lastHarmTarget.Serial.IsItem)
                {
                    AddTextFlags(World.FindItem(_lastHarmTarget.Serial));
                }
                else
                {
                    Mobile m = World.FindMobile(_lastHarmTarget.Serial);
                    if (m != null)
                    {
                        CheckLastTargetRange(m);

                        AddTextFlags(m);
                    }
                }

                m_OldHarmfulLT = _lastHarmTarget.Serial;
            }
        }


        public static bool LastTargetWasSet
        {
            get { return _lastTargetWasSet; }
        }


        public static void SetLastTargetTo(Mobile m)
        {
            SetLastTargetTo(m, 0);
        }

        public static void SetLastTargetTo(Mobile m, byte flagType)
        {
            TargetInfo targ = new TargetInfo();
            _lastGroundTarget = _lastTarget = targ;

            if ((_hasTarget && _curFlags == 1) || flagType == 1)
                _lastHarmTarget = targ;
            else if ((_hasTarget && _curFlags == 2) || flagType == 2)
                _lastBeneTarget = targ;
            else if (flagType == 0)
                _lastHarmTarget = _lastBeneTarget = targ;

            targ.Type = 0;
            if (_hasTarget)
                targ.Flags = _curFlags;
            else
                targ.Flags = flagType;

            targ.Gfx = m.Body;
            targ.Serial = m.Serial;
            targ.X = m.Position.X;
            targ.Y = m.Position.Y;
            targ.Z = m.Position.Z;

            Client.Instance.SendToClient(new ChangeCombatant(m));
            _lastCombatant = m.Serial;
            World.Player.SendMessage(MsgLevel.Force, LocString.NewTargSet);

            OverheadTargetMessage(targ);

            bool wasSmart = Config.GetBool("SmartLastTarget");
            if (wasSmart)
                Config.SetProperty("SmartLastTarget", false);
            LastTarget();
            if (wasSmart)
                Config.SetProperty("SmartLastTarget", true);
            LastTargetChanged();
        }

        private static void EndIntercept()
        {
            _intercept = false;
            _onTarget = null;
            _onCancel = null;
            _fromGrabHotKey = false;
        }

        public static void TargetSelf()
        {
            TargetSelf(false);
        }

        public static void TargetSelf(bool forceQ)
        {
            if (World.Player == null)
                return;

            //if ( Macros.MacroManager.AcceptActions )
            //	MacroManager.Action( new TargetSelfAction() );

            if (_hasTarget)
            {
                if (!DoTargetSelf())
                    ResendTarget();
            }
            else if (forceQ || Config.GetBool("QueueTargets"))
            {
                if (!forceQ)
                {
                    if (Config.GetBool("ShowTargetSelfLastClearOverhead"))
                    {
                        World.Player.OverheadMessage(LocString.QueuedTS);
                    }
                    else
                    {
                        World.Player.SendMessage(MsgLevel.Force, LocString.QueuedTS);
                    }
                }

                _queueTarget = TargetSelfAction;
            }
        }

        public static bool DoTargetSelf()
        {
            if (World.Player == null)
                return false;

            if (CheckHealPoisonTarg(_currentID, World.Player.Serial))
                return false;

            CancelClientTarget();
            _hasTarget = false;
            _fromGrabHotKey = false;

            if (_intercept)
            {
                TargetInfo targ = new TargetInfo();
                targ.Serial = World.Player.Serial;
                targ.Gfx = World.Player.Body;
                targ.Type = 0;
                targ.X = World.Player.Position.X;
                targ.Y = World.Player.Position.Y;
                targ.Z = World.Player.Position.Z;
                targ.TargID = LocalTargID;
                targ.Flags = 0;

                OneTimeResponse(targ);
            }
            else
            {
                Client.Instance.SendToServer(new TargetResponse(_currentID, World.Player));
            }

            return true;
        }

        public static void LastTarget()
        {
            LastTarget(false);
        }

        public static void LastTarget(bool forceQ)
        {
            //if ( Macros.MacroManager.AcceptActions )
            //	MacroManager.Action( new LastTargetAction() );

            if (FromGrabHotKey)
                return;

            if (_hasTarget)
            {
                if (!DoLastTarget())
                    ResendTarget();
            }
            else if (forceQ || Config.GetBool("QueueTargets"))
            {
                if (!forceQ)
                {
                    if (Config.GetBool("ShowTargetSelfLastClearOverhead"))
                    {
                        World.Player.OverheadMessage(LocString.QueuedLT);
                    }
                    else
                    {
                        World.Player.SendMessage(MsgLevel.Force, LocString.QueuedLT);
                    }
                }

                _queueTarget = LastTargetAction;
            }
        }

        public static bool DoLastTarget()
        {
            if (FromGrabHotKey)
                return true;

            TargetInfo targ;
            if (IsSmartTargetingEnabled())
            {
                if (_allowGround && _lastGroundTarget != null)
                    targ = _lastGroundTarget;
                else if (_curFlags == 1)
                    targ = _lastHarmTarget;
                else if (_curFlags == 2)
                    targ = _lastBeneTarget;
                else
                    targ = _lastTarget;

                if (targ == null)
                    targ = _lastTarget;
            }
            else
            {
                if (_allowGround && _lastGroundTarget != null)
                    targ = _lastGroundTarget;
                else
                    targ = _lastTarget;
            }

            if (targ == null)
                return false;

            Point3D pos = Point3D.Zero;
            if (targ.Serial.IsMobile)
            {
                Mobile m = World.FindMobile(targ.Serial);
                if (m != null)
                {
                    pos = m.Position;

                    targ.X = pos.X;
                    targ.Y = pos.Y;
                    targ.Z = pos.Z;
                }
                else
                {
                    pos = Point3D.Zero;
                }
            }
            else if (targ.Serial.IsItem)
            {
                Item i = World.FindItem(targ.Serial);
                if (i != null)
                {
                    pos = i.GetWorldPosition();

                    targ.X = i.Position.X;
                    targ.Y = i.Position.Y;
                    targ.Z = i.Position.Z;
                }
                else
                {
                    pos = Point3D.Zero;
                    targ.X = targ.Y = targ.Z = 0;
                }
            }
            else
            {
                if (!_allowGround && (targ.Serial == Serial.Zero || targ.Serial >= 0x80000000))
                {
                    World.Player.SendMessage(MsgLevel.Warning, LocString.LTGround);
                    return false;
                }
                else
                {
                    pos = new Point3D(targ.X, targ.Y, targ.Z);
                }
            }

            if (Config.GetBool("RangeCheckLT") && Client.Instance.AllowBit(FeatureBit.RangeCheckLT) &&
                (pos == Point3D.Zero || !Utility.InRange(World.Player.Position, pos, Config.GetInt("LTRange"))))
            {
                if (Config.GetBool("QueueTargets"))
                    _queueTarget = LastTargetAction;
                World.Player.SendMessage(MsgLevel.Warning, LocString.LTOutOfRange);
                return false;
            }

            if (CheckHealPoisonTarg(_currentID, targ.Serial))
                return false;

            CancelClientTarget();
            _hasTarget = false;

            targ.TargID = _currentID;

            if (_intercept)
                OneTimeResponse(targ);
            else
                Client.Instance.SendToServer(new TargetResponse(targ));
            return true;
        }

        public static void ClearQueue()
        {
            _queueTarget = null;
        }

        private static TimerCallbackState m_OneTimeRespCallback = new TimerCallbackState(OneTimeResponse);

        private static void OneTimeResponse(object state)
        {
            TargetInfo info = state as TargetInfo;

            if (info != null)
            {
                if ((info.X == 0xFFFF && info.X == 0xFFFF) && (info.Serial == 0 || info.Serial >= 0x80000000))
                {
                    if (_onCancel != null)
                        _onCancel();
                }
                else
                {
                    if (Macros.MacroManager.AcceptActions)
                        MacroManager.Action(new AbsoluteTargetAction(info));

                    ScriptManager.AddToScript($"target {info.Serial}");

                    if (_onTarget != null)
                        _onTarget(info.Type == 1 ? true : false, info.Serial, new Point3D(info.X, info.Y, info.Z),
                            info.Gfx);
                }
            }

            EndIntercept();
        }

        public static void CancelTarget()
        {
            OnClearQueue();
            CancelClientTarget();

            _fromGrabHotKey = false;

            ScriptManager.SetVariableActive = false;

            if (_hasTarget)
            {
                Client.Instance.SendToServer(new TargetCancelResponse(_currentID));
                _hasTarget = false;
            }
        }

        private static void CancelClientTarget()
        {
            if (_clientTarget)
            {
                _filterCancel.Add((uint) _currentID);
                Client.Instance.SendToClient(new CancelTarget(_currentID));
                _clientTarget = false;
            }
        }

        public static void Target(TargetInfo info)
        {
            if (_intercept)
            {
                OneTimeResponse(info);
            }
            else if (_hasTarget)
            {
                info.TargID = _currentID;
                _lastGroundTarget = _lastTarget = info;
                Client.Instance.SendToServer(new TargetResponse(info));
            }

            CancelClientTarget();
            _hasTarget = false;
            _fromGrabHotKey = false;
        }

        public static void Target(Point3D pt)
        {
            TargetInfo info = new TargetInfo();
            info.Type = 1;
            info.Flags = 0;
            info.Serial = 0;
            info.X = pt.X;
            info.Y = pt.Y;
            info.Z = pt.Z;
            info.Gfx = 0;

            Target(info);
        }

        public static void Target(Point3D pt, int gfx)
        {
            TargetInfo info = new TargetInfo();
            info.Type = 1;
            info.Flags = 0;
            info.Serial = 0;
            info.X = pt.X;
            info.Y = pt.Y;
            info.Z = pt.Z;
            info.Gfx = (ushort) (gfx & 0x3FFF);

            Target(info);
        }

        public static void Target(Serial s)
        {
            TargetInfo info = new TargetInfo();
            info.Type = 0;
            info.Flags = 0;
            info.Serial = s;

            if (s.IsItem)
            {
                Item item = World.FindItem(s);
                if (item != null)
                {
                    info.X = item.Position.X;
                    info.Y = item.Position.Y;
                    info.Z = item.Position.Z;
                    info.Gfx = item.ItemID;
                }
            }
            else if (s.IsMobile)
            {
                Mobile m = World.FindMobile(s);
                if (m != null)
                {
                    info.X = m.Position.X;
                    info.Y = m.Position.Y;
                    info.Z = m.Position.Z;
                    info.Gfx = m.Body;
                }
            }

            Target(info);
        }

        public static void Target(object o)
        {
            if (o is Item)
            {
                Item item = (Item) o;
                TargetInfo info = new TargetInfo();
                info.Type = 0;
                info.Flags = 0;
                info.Serial = item.Serial;
                info.X = item.Position.X;
                info.Y = item.Position.Y;
                info.Z = item.Position.Z;
                info.Gfx = item.ItemID;
                Target(info);
            }
            else if (o is Mobile)
            {
                Mobile m = (Mobile) o;
                TargetInfo info = new TargetInfo();
                info.Type = 0;
                info.Flags = 0;
                info.Serial = m.Serial;
                info.X = m.Position.X;
                info.Y = m.Position.Y;
                info.Z = m.Position.Z;
                info.Gfx = m.Body;
                Target(info);
            }
            else if (o is Serial)
            {
                Target((Serial) o);
            }
            else if (o is TargetInfo)
            {
                Target((TargetInfo) o);
            }
        }

        private static DateTime _lastFlagCheck = DateTime.UtcNow;
        private static Serial _lastFlagCheckSerial;

        public static void CheckTextFlags(Mobile m)
        {
            if (DateTime.UtcNow - _lastFlagCheck < TimeSpan.FromMilliseconds(250) && m.Serial == _lastFlagCheckSerial)
                return;

            if (IgnoreAgent.IsIgnored(m.Serial))
            {
                m.OverheadMessage(Config.GetInt("SysColor"), "[Ignored]");
            }

            if (IsSmartTargetingEnabled())
            {
                bool harm = _lastHarmTarget != null && _lastHarmTarget.Serial == m.Serial;
                bool bene = _lastBeneTarget != null && _lastBeneTarget.Serial == m.Serial;

                if (harm)
                    m.OverheadMessage(0x90, $"[{Language.GetString(LocString.HarmfulTarget)}]");
                if (bene)
                    m.OverheadMessage(0x3F, $"[{Language.GetString(LocString.BeneficialTarget)}]");
            }

            if (_lastTarget != null && _lastTarget.Serial == m.Serial)
                m.OverheadMessage(0x3B2, $"[{Language.GetString(LocString.LastTarget)}]");

            _lastFlagCheck = DateTime.UtcNow;
            _lastFlagCheckSerial = m.Serial;
        }

        public static bool IsLastTarget(Mobile m)
        {
            if (m != null)
            {
                if (IsSmartTargetingEnabled())
                {
                    if (_lastHarmTarget != null && _lastHarmTarget.Serial == m.Serial)
                        return true;
                }
                else
                {
                    if (_lastTarget != null && _lastTarget.Serial == m.Serial)
                        return true;
                }
            }

            return false;
        }

        public static bool IsBeneficialTarget(Mobile m)
        {
            if (m != null)
            {
                if (IsSmartTargetingEnabled())
                {
                    if (_lastBeneTarget != null && _lastBeneTarget.Serial == m.Serial)
                        return true;
                }
                else
                {
                    if (_lastTarget != null && _lastTarget.Serial == m.Serial)
                        return true;
                }
            }

            return false;
        }

        public static bool IsHarmfulTarget(Mobile m)
        {
            if (m != null)
            {
                if (IsSmartTargetingEnabled())
                {
                    if (_lastHarmTarget != null && _lastHarmTarget.Serial == m.Serial)
                        return true;
                }
                else
                {
                    if (_lastTarget != null && _lastTarget.Serial == m.Serial)
                        return true;
                }
            }

            return false;
        }

        public static void CheckLastTargetRange(Mobile m)
        {
            if (World.Player == null)
                return;

            if (_hasTarget && m != null && _lastTarget != null && m.Serial == _lastTarget.Serial &&
                _queueTarget == LastTargetAction)
            {
                if (Config.GetBool("RangeCheckLT") && Client.Instance.AllowBit(FeatureBit.RangeCheckLT))
                {
                    if (Utility.InRange(World.Player.Position, m.Position, Config.GetInt("LTRange")))
                    {
                        if (_queueTarget())
                            ClearQueue();
                    }
                }
            }
        }

        private static bool CheckHealPoisonTarg(uint targID, Serial ser)
        {
            if (World.Player == null)
                return false;

            if (targID == SpellTargetID && ser.IsMobile &&
                (World.Player.LastSpell == Spell.ToID(1, 4) || World.Player.LastSpell == Spell.ToID(4, 5)) &&
                Config.GetBool("BlockHealPoison") && Client.Instance.AllowBit(FeatureBit.BlockHealPoisoned))
            {
                Mobile m = World.FindMobile(ser);

                if (m != null && m.Poisoned)
                {
                    World.Player.SendMessage(MsgLevel.Warning, LocString.HealPoisonBlocked);
                    return true;
                }
            }

            return false;
        }

        private static void TargetResponse(PacketReader p, PacketHandlerEventArgs args)
        {
            if (World.Player == null)
                return;

            TargetInfo info = new TargetInfo
            {
                Type = p.ReadByte(),
                TargID = p.ReadUInt32(),
                Flags = p.ReadByte(),
                Serial = p.ReadUInt32(),
                X = p.ReadUInt16(),
                Y = p.ReadUInt16(),
                Z = p.ReadInt16(),
                Gfx = p.ReadUInt16()
            };

            _clientTarget = false;

            OverheadTargetMessage(info);

            // check for cancel
            if (info.X == 0xFFFF && info.X == 0xFFFF && (info.Serial <= 0 || info.Serial >= 0x80000000))
            {
                _hasTarget = false;
                _fromGrabHotKey = false;

                if (_intercept)
                {
                    args.Block = true;
                    Timer.DelayedCallbackState(TimeSpan.Zero, m_OneTimeRespCallback, info).Start();
                    EndIntercept();

                    if (_previousID != 0)
                    {
                        _currentID = _previousID;
                        _allowGround = _previousGround;
                        _curFlags = _prevFlags;

                        _previousID = 0;

                        ResendTarget();
                    }
                }
                else if (_filterCancel.Contains((uint) info.TargID) || info.TargID == LocalTargID)
                {
                    args.Block = true;
                }

                _filterCancel.Clear();
                return;
            }

            ClearQueue();

            if (_intercept)
            {
                if (info.TargID == LocalTargID)
                {
                    Timer.DelayedCallbackState(TimeSpan.Zero, m_OneTimeRespCallback, info).Start();

                    _hasTarget = false;
                    _fromGrabHotKey = false;
                    args.Block = true;

                    if (_previousID != 0)
                    {
                        _currentID = _previousID;
                        _allowGround = _previousGround;
                        _curFlags = _prevFlags;

                        _previousID = 0;

                        ResendTarget();
                    }

                    _filterCancel.Clear();

                    return;
                }
                else
                {
                    EndIntercept();
                }
            }

            _hasTarget = false;

            if (CheckHealPoisonTarg(_currentID, info.Serial))
            {
                ResendTarget();
                args.Block = true;
            }

            if (info.Serial != World.Player.Serial)
            {
                if (info.Serial.IsValid)
                {
                    // only let lasttarget be a non-ground target

                    _lastTarget = info;
                    if (info.Flags == 1)
                        _lastHarmTarget = info;
                    else if (info.Flags == 2)
                        _lastBeneTarget = info;

                    LastTargetChanged();
                    LastBeneficialTargetChanged();
                    LastHarmfulTargetChanged();
                }

                _lastGroundTarget = info; // ground target is the true last target

                if (Macros.MacroManager.AcceptActions)
                    MacroManager.Action(new AbsoluteTargetAction(info));

                ScriptManager.AddToScript(info.Serial == Serial.Zero
                    ? $"target 0x0 {info.X} {info.Y} {info.Z}"
                    : $"target {info.Serial}");


                if (ScriptManager.Recording)
                {
                    if (info.Serial == Serial.Zero)
                    {
                    }
                    else
                    {
                    }
                }
            }
            else
            {
                KeyData hk = HotKey.Get((int)LocString.TargetSelf);

                if (MacroManager.AcceptActions)
                {
                    if (hk != null)
                    {
                        MacroManager.Action(new HotKeyAction(hk));
                    }
                    else
                    {
                        MacroManager.Action(new AbsoluteTargetAction(info));
                    }
                }

                ScriptManager.AddToScript(hk != null ? "target 'self'" : $"target {info.Serial}");
            }

            if (World.Player.LastSpell == 52 && !GateTimer.Running)
            {
                GateTimer.Start();
            }

            _filterCancel.Clear();
        }

        private static void NewTarget(PacketReader p, PacketHandlerEventArgs args)
        {
            bool prevAllowGround = _allowGround;
            uint prevID = _currentID;
            byte prevFlags = _curFlags;
            bool prevClientTarget = _clientTarget;

            _allowGround = p.ReadBoolean(); // allow ground
            _currentID = p.ReadUInt32(); // target uid
            _curFlags = p.ReadByte(); // flags
            // the rest of the packet is 0s

            // check for a server cancel command
            if (!_allowGround && _currentID == 0 && _curFlags == 3)
            {
                _hasTarget = false;
                _fromGrabHotKey = false;

                _clientTarget = false;
                if (_intercept)
                {
                    EndIntercept();
                    World.Player.SendMessage(MsgLevel.Error, LocString.OTTCancel);
                }

                return;
            }

            if (Spell.LastCastTime + TimeSpan.FromSeconds(3.0) > DateTime.UtcNow &&
                Spell.LastCastTime + TimeSpan.FromSeconds(0.5) <= DateTime.UtcNow && SpellTargetID == 0)
                SpellTargetID = _currentID;

            _hasTarget = true;
            _clientTarget = false;

            if (_queueTarget == null && Macros.MacroManager.AcceptActions &&
                MacroManager.Action(new WaitForTargetAction()))
            {
                args.Block = true;
            }
            else if (_queueTarget == null && ScriptManager.AddToScript("waitfortarget"))
            {
                //args.Block = true;
            }
            else if (_queueTarget != null && _queueTarget())
            {
                ClearQueue();
                args.Block = true;
            }

            if (args.Block)
            {
                if (prevClientTarget)
                {
                    _allowGround = prevAllowGround;
                    _currentID = prevID;
                    _curFlags = prevFlags;

                    _clientTarget = true;

                    if (!_intercept)
                        CancelClientTarget();
                }
            }
            else
            {
                _clientTarget = true;

                if (_intercept)
                {
                    if (_onCancel != null)
                        _onCancel();
                    EndIntercept();
                    World.Player.SendMessage(MsgLevel.Error, LocString.OTTCancel);

                    _filterCancel.Add((uint) prevID);
                }
            }
        }

        public static void ResendTarget()
        {
            if (!_clientTarget || !_hasTarget)
            {
                CancelClientTarget();
                _clientTarget = _hasTarget = true;
                Client.Instance.SendToClient(new Target(_currentID, _allowGround, _curFlags));
            }
        }

        private static TargetInfo _lastOverheadMessageTarget = new TargetInfo();

        public static void OverheadTargetMessage(TargetInfo info)
        {
            if (info == null)
                return;

            if (Config.GetBool("ShowAttackTargetNewOnly") && info.Serial == _lastOverheadMessageTarget.Serial)
                return;

            Mobile m = null;

            if (Config.GetBool("ShowAttackTargetOverhead") && info.Serial != 0 && info.Serial.IsMobile)
            {
                m = World.FindMobile(info.Serial);

                if (m == null)
                    return;

                World.Player.OverheadMessage(FriendsManager.IsFriend(m.Serial) ? 63 : m.GetNotorietyColorInt(),
                    $"Target: {m.Name}");
            }

            if (Config.GetBool("ShowTextTargetIndicator") && info.Serial != 0 && info.Serial.IsMobile)
            {
                // lets not look it up again they had the previous feature enabled
                if (m == null)
                    m = World.FindMobile(info.Serial);

                if (m == null)
                    return;

                m.OverheadMessage(Config.GetInt("TargetIndicatorHue"),
                    Config.GetString("TargetIndicatorFormat").Replace("{name}", m.Name));
            }

            _lastOverheadMessageTarget = info;
        }

        private static bool IsSmartTargetingEnabled()
        {
            return Config.GetBool("SmartLastTarget") && Client.Instance.AllowBit(FeatureBit.SmartLT);
        }
    }
}

================================================
FILE: Razor/Core/TargetingClosest.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System.Collections.Generic;
using Assistant.Core;
using Assistant.Filters;
using Assistant.Scripts;

namespace Assistant
{
    public partial class Targeting
    {
        private static void InitClosestTargets()
        {
            HotKey.Add(HKCategory.Targets, LocString.TargClosest, TargetClosest);

            HotKey.Add(HKCategory.Targets, LocString.TargClosestFriend, TargetClosestFriend);

            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetMurderer, LocString.TargCloseRed,
                TargetCloseRed);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetMurderer, LocString.TargCloseRedHumanoid,
                TargetCloseRedHumanoid);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetMurderer, LocString.TargCloseRedMonster,
                TargetCloseRedMonster);

            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetNonFriendly, LocString.TargCloseNFriend,
                TargetCloseNonFriendly);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetNonFriendly, LocString.TargClosestNFriendlyHuman,
                TargetCloseNonFriendlyHumanoid);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetNonFriendly, LocString.TargClosestNFriendlyMonster,
                TargetCloseNonFriendlyMonster);

            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetFriendly, LocString.TargCloseFriend,
                TargetCloseFriendly);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetFriendly, LocString.TargClosestFriendlyHuman,
                TargetCloseFriendlyHumanoid);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetFriendly, LocString.TargClosestFriendlyMonster,
                TargetCloseFriendlyMonster);

            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetInnocent, LocString.TargCloseBlue,
                TargetCloseInnocent);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetInnocent, LocString.TargCloseInnocentHuman,
                TargetCloseInnocentHumanoid);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetInnocent, LocString.TargClosestInnocentMonster,
                TargetCloseInnocentMonster);

            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetGrey, LocString.TargCloseGrey,
                TargetCloseGrey);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetGrey, LocString.TargCloseGreyHuman,
                TargetCloseGreyHumanoid);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetGrey, LocString.TargCloseGreyMonster,
                TargetCloseGreyMonster);

            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetCriminal, LocString.TargCloseCriminal,
                TargetCloseCriminal);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetCriminal, LocString.TargCloseCriminalHuman,
                TargetCloseCriminalHumanoid);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetCriminal, LocString.TargClosestCriminalMonster,
                TargetCloseCriminalMonster);

            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetEnemy, LocString.TargCloseEnemy,
                TargetCloseEnemy);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetEnemy, LocString.TargCloseEnemyHuman,
                TargetCloseEnemyHumanoid);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetEnemy, LocString.TargCloseEnemyMonster,
                TargetCloseEnemyMonster);
        }


        public static void TargetCloseNonFriendly()
        {
            ClosestTarget((int) TargetType.Attackable, (int) TargetType.Criminal, (int) TargetType.Enemy,
                (int) TargetType.Murderer);
        }

        public static void TargetCloseNonFriendlyHumanoid()
        {
            ClosestHumanoidTarget((int) TargetType.Attackable, (int) TargetType.Criminal, (int) TargetType.Enemy,
                (int) TargetType.Murderer);
        }

        public static void TargetCloseNonFriendlyMonster()
        {
            ClosestMonsterTarget((int) TargetType.Attackable, (int) TargetType.Criminal, (int) TargetType.Enemy,
                (int) TargetType.Murderer);
        }

        public static void TargetCloseFriendly()
        {
            ClosestTarget((int) TargetType.Invalid, (int) TargetType.Innocent, (int) TargetType.GuildAlly);
        }

        public static void TargetCloseFriendlyHumanoid()
        {
            ClosestHumanoidTarget((int) TargetType.Invalid, (int) TargetType.Innocent, (int) TargetType.GuildAlly);
        }

        public static void TargetCloseFriendlyMonster()
        {
            ClosestMonsterTarget((int) TargetType.Invalid, (int) TargetType.Innocent, (int) TargetType.GuildAlly);
        }

        public static void TargetCloseEnemy()
        {
            ClosestTarget((int) TargetType.Enemy);
        }

        public static void TargetCloseEnemyHumanoid()
        {
            ClosestHumanoidTarget((int) TargetType.Enemy);
        }

        public static void TargetCloseEnemyMonster()
        {
            ClosestMonsterTarget((int) TargetType.Enemy);
        }

        public static void TargetCloseRed()
        {
            ClosestTarget((int) TargetType.Murderer);
        }

        public static void TargetCloseRedMonster()
        {
            ClosestMonsterTarget((int) TargetType.Murderer);
        }

        public static void TargetCloseRedHumanoid()
        {
            ClosestHumanoidTarget((int) TargetType.Murderer);
        }

        public static void TargetCloseGrey()
        {
            ClosestTarget((int) TargetType.Attackable, (int) TargetType.Criminal);
        }

        public static void TargetCloseGreyMonster()
        {
            ClosestMonsterTarget((int) TargetType.Attackable, (int) TargetType.Criminal);
        }

        public static void TargetCloseGreyHumanoid()
        {
            ClosestHumanoidTarget((int) TargetType.Attackable, (int) TargetType.Criminal);
        }

        public static void TargetCloseCriminal()
        {
            ClosestTarget((int) TargetType.Criminal);
        }

        public static void TargetCloseCriminalHumanoid()
        {
            ClosestHumanoidTarget((int) TargetType.Criminal);
        }

        public static void TargetCloseCriminalMonster()
        {
            ClosestHumanoidTarget((int) TargetType.Criminal);
        }

        public static void TargetCloseInnocent()
        {
            ClosestTarget((int) TargetType.Innocent);
        }

        public static void TargetCloseInnocentHumanoid()
        {
            ClosestHumanoidTarget((int) TargetType.Innocent);
        }

        public static void TargetCloseInnocentMonster()
        {
            ClosestMonsterTarget((int) TargetType.Innocent);
        }

        public static void TargetClosestFriend()
        {
            ClosestFriendTarget();
        }

        public static void TargetClosest()
        {
            ClosestTarget();
        }

        public static void ClosestTarget(params int[] noto)
        {
            if (!Client.Instance.AllowBit(FeatureBit.ClosestTargets))
                return;

            var list = new List<Mobile>();
            foreach (var m in World.MobilesInRange(12))
                if ((!FriendsManager.IsFriend(m.Serial) || noto.Length > 0 && noto[0] == 0) &&
                    !m.Blessed && !m.IsGhost && m.Serial != World.Player.Serial &&
                    !TargetFilterManager.IsFilteredTarget(m.Serial) &&
                    Utility.InRange(World.Player.Position, m.Position, Config.GetInt("LTRange")))
                {
                    for (var i = 0; i < noto.Length; i++)
                        if (noto[i] == m.Notoriety)
                        {
                            list.Add(m);
                            break;
                        }

                    if (noto.Length == 0)
                        list.Add(m);
                }

            Mobile closest = null;
            var closestDist = double.MaxValue;

            foreach (var m in list)
            {
                var dist = Utility.DistanceSqrt(m.Position, World.Player.Position);

                if (dist < closestDist || closest == null)
                {
                    closestDist = dist;
                    closest = m;
                }
            }

            if (closest != null)
            {
                SetLastTargetTo(closest);
                ScriptManager.TargetFound = true;
            }
            else
            {
                World.Player.SendMessage(MsgLevel.Warning, LocString.TargNoOne);
            }
        }

        public static void ClosestHumanoidTarget(params int[] noto)
        {
            if (!Client.Instance.AllowBit(FeatureBit.ClosestTargets))
                return;

            var list = new List<Mobile>();
            foreach (var m in World.MobilesInRange(12))
            {
                if (m.Body != 0x0190 && m.Body != 0x0191 && m.Body != 0x025D && m.Body != 0x025E)
                    continue;

                if ((!FriendsManager.IsFriend(m.Serial) || noto.Length > 0 && noto[0] == 0) &&
                    !m.Blessed && !m.IsGhost && m.Serial != World.Player.Serial &&
                    !TargetFilterManager.IsFilteredTarget(m.Serial) &&
                    Utility.InRange(World.Player.Position, m.Position, Config.GetInt("LTRange")))
                {
                    for (var i = 0; i < noto.Length; i++)
                        if (noto[i] == m.Notoriety)
                        {
                            list.Add(m);
                            break;
                        }

                    if (noto.Length == 0)
                        list.Add(m);
                }
            }

            Mobile closest = null;
            var closestDist = double.MaxValue;

            foreach (var m in list)
            {
                var dist = Utility.DistanceSqrt(m.Position, World.Player.Position);

                if (dist < closestDist || closest == null)
                {
                    closestDist = dist;
                    closest = m;
                }
            }

            if (closest != null)
            {
                SetLastTargetTo(closest);
                ScriptManager.TargetFound = true;
            }
            else
            {
                World.Player.SendMessage(MsgLevel.Warning, LocString.TargNoOne);
            }
        }

        public static void ClosestMonsterTarget(params int[] noto)
        {
            if (!Client.Instance.AllowBit(FeatureBit.ClosestTargets))
                return;

            var list = new List<Mobile>();
            foreach (var m in World.MobilesInRange(12))
            {
                if (!m.IsMonster)
                    continue;

                if ((!FriendsManager.IsFriend(m.Serial) || noto.Length > 0 && noto[0] == 0) &&
                    !m.Blessed && !m.IsGhost && m.Serial != World.Player.Serial &&
                    !TargetFilterManager.IsFilteredTarget(m.Serial) &&
                    Utility.InRange(World.Player.Position, m.Position, Config.GetInt("LTRange")))
                {
                    for (var i = 0; i < noto.Length; i++) 
                        if (noto[i] == m.Notoriety)
                        {
                            list.Add(m);
                            break;
                        }

                    if (noto.Length == 0)
                        list.Add(m);
                }
            }

            Mobile closest = null;
            var closestDist = double.MaxValue;

            foreach (var m in list)
            {
                var dist = Utility.DistanceSqrt(m.Position, World.Player.Position);

                if (dist < closestDist || closest == null)
                {
                    closestDist = dist;
                    closest = m;
                }
            }

            if (closest != null)
            {
                SetLastTargetTo(closest);
                ScriptManager.TargetFound = true;
            }
            else
            {
                World.Player.SendMessage(MsgLevel.Warning, LocString.TargNoOne);
            }
        }

        public static void ClosestFriendTarget()
        {
            if (!Client.Instance.AllowBit(FeatureBit.ClosestTargets))
                return;

            var list = new List<Mobile>();
            foreach (var m in World.MobilesInRange(12))
            {
                if (FriendsManager.IsFriend(m.Serial) && !m.Blessed && !m.IsGhost && m.Serial != World.Player.Serial &&
                    !TargetFilterManager.IsFilteredTarget(m.Serial) &&
                    Utility.InRange(World.Player.Position, m.Position, Config.GetInt("LTRange")))
                {
                    list.Add(m);
                }
            }                

            Mobile closest = null;
            var closestDist = double.MaxValue;

            foreach (var m in list)
            {
                var dist = Utility.DistanceSqrt(m.Position, World.Player.Position);

                if (dist < closestDist || closest == null)
                {
                    closestDist = dist;
                    closest = m;
                }
            }

            if (closest != null)
            {
                SetLastTargetTo(closest);
                ScriptManager.TargetFound = true;
            }
            else
            {
                World.Player.SendMessage(MsgLevel.Warning, LocString.TargNoOne);
            }
        }
    }
}

================================================
FILE: Razor/Core/TargetingNextPrevious.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using Assistant.Core;
using Assistant.Filters;
using Assistant.Scripts;

namespace Assistant
{
    public partial class Targeting
    {
        /// <summary>
        ///     Index used to keep track of the current Next/Prev target
        /// </summary>
        private static int _nextPrevTargetIndex;

        private static void InitNextPrevTargets()
        {
            //Next targets
            HotKey.Add(HKCategory.Targets, LocString.NextTarget, NextTarget);
            HotKey.Add(HKCategory.Targets, LocString.NextTargetFriend, NextTargetFriend);
            HotKey.Add(HKCategory.Targets, LocString.NextTargetNonFriendly, NextTargetNonFriend);

            // Next humanoids
            HotKey.Add(HKCategory.Targets, LocString.NextTargetHumanoid, NextTargetHumanoid);

            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetEnemy, LocString.NextTargetEnemyHumanoid,
                NextTargetEnemyHumanoid);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetCriminal, LocString.NextTargetCriminalHumanoid,
                NextTargetCriminalHumanoid);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetMurderer, LocString.NextTargetMurdererHumanoid,
                NextTargetMurdererHumanoid);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetInnocent, LocString.NextTargetInnocentHumanoid,
                NextTargetInnocentHumanoid);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetFriendly, LocString.NextTargetFriendlyHumanoid,
                NextTargetFriendlyHumanoid);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetFriendly, LocString.NextTargetFriendly,
                NextTargetFriendly);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetGrey, LocString.NextTargetGreyHumanoid,
                NextTargetGreyHumanoid);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetNonFriendly, LocString.NextTargetNonFriendlyHumanoid,
                NextTargetNonFriendlyHumanoid);

            // Next monsters
            HotKey.Add(HKCategory.Targets, LocString.NextTargetMonster, NextTargetMonster);

            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetEnemy, LocString.NextTargetEnemyMonster,
                NextTargetEnemyMonster);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetCriminal, LocString.NextTargetCriminalMonster,
                NextTargetCriminalMonster);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetMurderer, LocString.NextTargetMurdererMonster,
                NextTargetMurdererMonster);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetInnocent, LocString.NextTargetInnocentMonster,
                NextTargetInnocentMonster);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetFriendly, LocString.NextTargetFriendlyMonster,
                NextTargetFriendlyMonster);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetGrey, LocString.NextTargetGreyMonster,
                NextTargetGreyMonster);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetNonFriendly, LocString.NextTargetNonFriendlyMonster,
                NextTargetNonFriendlyMonster);

            //Previous targets
            HotKey.Add(HKCategory.Targets, LocString.PrevTarget, PrevTarget);
            HotKey.Add(HKCategory.Targets, LocString.PrevTargetNonFriendly, PrevTargetNonFriend);

            HotKey.Add(HKCategory.Targets, LocString.PrevTargetHumanoid, PrevTargetHumanoid);
            HotKey.Add(HKCategory.Targets, LocString.PrevTargetMonster, PrevTargetMonster);
            HotKey.Add(HKCategory.Targets, LocString.PrevTargetFriend, PrevTargetFriend);

            // Previous humanoids
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetEnemy, LocString.PrevTargetEnemyHumanoid,
                PrevTargetEnemyHumanoid);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetFriendly, LocString.PrevTargetFriendlyHumanoid,
                PrevTargetFriendlyHumanoid);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetFriendly, LocString.PrevTargetFriendly,
                PrevTargetFriendly);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetGrey, LocString.PrevTargetGreyHumanoid,
                PrevTargetGreyHumanoid);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetNonFriendly, LocString.PrevTargetNonFriendlyHumanoid,
                PrevTargetNonFriendlyHumanoid);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetCriminal, LocString.PrevTargetCriminalHumanoid,
                PrevTargetCriminalHumanoid);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetMurderer, LocString.PrevTargetMurdererHumanoid,
                PrevTargetMurdererHumanoid);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetInnocent, LocString.PrevTargetInnocentHumanoid,
                PrevTargetInnocentHumanoid);

            // Previous monsters
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetEnemy, LocString.PrevTargetEnemyMonster,
                PrevTargetEnemyMonster);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetFriendly, LocString.PrevTargetFriendlyMonster,
                PrevTargetFriendlyMonster);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetGrey, LocString.PrevTargetGreyMonster,
                PrevTargetGreyMonster);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetNonFriendly, LocString.PrevTargetNonFriendlyMonster,
                PrevTargetNonFriendlyMonster);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetCriminal, LocString.PrevTargetCriminalMonster,
                PrevTargetCriminalMonster);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetMurderer, LocString.PrevTargetMurdererMonster,
                PrevTargetMurdererMonster);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetInnocent, LocString.PrevTargetInnocentMonster,
                PrevTargetInnocentMonster);
        }

        public static bool IsNextPrevFriend(Mobile mobile)
        {
            return Config.GetBool("NextPrevTargetIgnoresFriends") && FriendsManager.IsFriend(mobile.Serial);
        }

        /// <summary>
        ///     Handles the common Next/Prev logic based on a list of targets passed in already filtered by the calling
        ///     functions conditions.
        /// </summary>
        /// <param name="targets">The list of targets (already filtered)</param>
        /// <param name="nextTarget">next target true, previous target false</param>
        /// <param name="isFriend">Indicates this was the Next/Prev Friend hot key</param>
        /// <param name="isFriendly"></param>
        /// <param name="isNonFriendly"></param>
        public static void NextPrevTarget(List<Mobile> targets, bool nextTarget, bool isFriend = false,
            bool isFriendly = false, bool isNonFriendly = false)
        {
            if (targets.Count <= 0)
            {
                World.Player.SendMessage(MsgLevel.Warning, LocString.TargNoOne);
                return;
            }

            if (Config.GetBool("NextPrevAlphabetical"))
            {
                targets = targets.OrderBy(m => m.Name).ToList();
            }

            Mobile mobile = null, old = World.FindMobile(_lastTarget?.Serial ?? Serial.Zero);
            var target = new TargetInfo();

            // Loop through 3 times and break out if you can't get a target for some reason
            for (var i = 0; i < 3; i++)
            {
                if (nextTarget)
                {
                    _nextPrevTargetIndex++;

                    if (_nextPrevTargetIndex >= targets.Count)
                        _nextPrevTargetIndex = 0;
                }
                else
                {
                    _nextPrevTargetIndex--;

                    if (_nextPrevTargetIndex < 0)
                        _nextPrevTargetIndex = targets.Count - 1;
                }

                try
                {
                    mobile = targets[_nextPrevTargetIndex];
                }
                catch
                {
                    mobile = null;
                }

                if (mobile != null && mobile != World.Player && mobile != old) break;

                mobile = null;
            }

            if (mobile == null)
                mobile = old;

            if (mobile == null)
            {
                World.Player.SendMessage(MsgLevel.Warning, LocString.TargNoOne);
                return;
            }

            _lastGroundTarget = _lastTarget = target;

            if (IsSmartTargetingEnabled())
            {
                if (Config.GetBool("OnlyNextPrevBeneficial") && isFriend ||
                    Config.GetBool("FriendlyBeneficialOnly") && isFriendly)
                {
                    _lastBeneTarget = target;
                }
                else if (Config.GetBool("OnlyNextPrevBeneficial") && !isFriend ||
                         Config.GetBool("NonFriendlyHarmfulOnly") && isNonFriendly)
                {
                    _lastHarmTarget = target;
                }
                else
                {
                    _lastBeneTarget = _lastHarmTarget = target;
                }
            }
            else
            {
                _lastBeneTarget = _lastHarmTarget = target;
            }

            if (_hasTarget)
                target.Flags = _curFlags;
            else
                target.Type = 0;

            target.Gfx = mobile.Body;
            target.Serial = mobile.Serial;
            target.X = mobile.Position.X;
            target.Y = mobile.Position.Y;
            target.Z = mobile.Position.Z;

            if (!isFriend || Config.GetBool("HighlightFriend"))
            {
                Client.Instance.SendToClient(new ChangeCombatant(mobile));
                _lastCombatant = mobile.Serial;
            }

            World.Player.SendMessage(MsgLevel.Force, LocString.NewTargSet);

            OverheadTargetMessage(target);

            ScriptManager.TargetFound = true;
        }

        public static void NextTarget()
        {
            var mobiles = World.MobilesInRange()
                .Where(x => !IsNextPrevFriend(x) && !TargetFilterManager.IsFilteredTarget(x.Serial)).ToList();

            NextPrevTarget(mobiles, true);
        }

        public static void NextTargetHumanoid()
        {
            var mobiles = World.MobilesInRange().Where(x =>
                    x.IsHuman && !IsNextPrevFriend(x) && !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial &&
                    !TargetFilterManager.IsFilteredTarget(x.Serial))
                .ToList();

            NextPrevTarget(mobiles, true);
        }

        public static void NextTargetEnemyHumanoid()
        {
            var mobiles = World.MobilesInRange().Where(x =>
                    x.IsHuman && x.Notoriety == (int) TargetType.Enemy && !IsNextPrevFriend(x) && !x.Blessed &&
                    !x.IsGhost && x.Serial != World.Player.Serial && !TargetFilterManager.IsFilteredTarget(x.Serial))
                .ToList();

            NextPrevTarget(mobiles, true);
        }

        public static void NextTargetEnemyMonster()
        {
            var mobiles = World.MobilesInRange().Where(x =>
                    x.IsMonster && x.Notoriety == (int) TargetType.Enemy && !IsNextPrevFriend(x) && !x.Blessed &&
                    !x.IsGhost && x.Serial != World.Player.Serial && !TargetFilterManager.IsFilteredTarget(x.Serial))
                .ToList();

            NextPrevTarget(mobiles, true);
        }

        public static void NextTargetMonster()
        {
            var mobiles = World.MobilesInRange().Where(x =>
                    x.IsMonster && !IsNextPrevFriend(x) && !x.Blessed && !x.IsGhost &&
                    x.Serial != World.Player.Serial && !TargetFilterManager.IsFilteredTarget(x.Serial))
                .ToList();

            NextPrevTarget(mobiles, true);
        }

        public static void NextTargetFriend()
        {
            var mobiles = World.MobilesInRange().Where(x =>
                    FriendsManager.IsFriend(x.Serial) && !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial)
                .ToList();

            NextPrevTarget(mobiles, true, true);
        }

        public static void NextTargetNonFriend()
        {
            var mobiles = World.MobilesInRange()
                .Where(x => (x.Notoriety == (int) TargetType.Attackable ||
                                          x.Notoriety == (int) TargetType.Criminal ||
                                          x.Notoriety == (int) TargetType.Enemy ||
                                          x.Notoriety == (int) TargetType.Murderer) &&
                            !IsNextPrevFriend(x) && !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial &&
                            !TargetFilterManager.IsFilteredTarget(x.Serial)
                ).ToList();

            NextPrevTarget(mobiles, true, false, false, true);
        }

        public static void PrevTarget()
        {
            var mobiles = World.MobilesInRange()
                .Where(x => !IsNextPrevFriend(x) && !TargetFilterManager.IsFilteredTarget(x.Serial)).ToList();

            NextPrevTarget(mobiles, false);
        }

        public static void PrevTargetHumanoid()
        {
            var mobiles = World.MobilesInRange().Where(x =>
                    x.IsHuman && !IsNextPrevFriend(x) && !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial &&
                    !TargetFilterManager.IsFilteredTarget(x.Serial))
                .ToList();

            NextPrevTarget(mobiles, false);
        }

        public static void PrevTargetEnemyHumanoid()
        {
            var mobiles = World.MobilesInRange().Where(x =>
                    x.IsHuman && x.Notoriety == (int) TargetType.Enemy && !IsNextPrevFriend(x) && !x.Blessed &&
                    !x.IsGhost && x.Serial != World.Player.Serial && !TargetFilterManager.IsFilteredTarget(x.Serial))
                .ToList();

            NextPrevTarget(mobiles, false);
        }

        public static void PrevTargetEnemyMonster()
        {
            var mobiles = World.MobilesInRange().Where(x =>
                    x.IsMonster && x.Notoriety == (int) TargetType.Enemy && !IsNextPrevFriend(x) && !x.Blessed &&
                    !x.IsGhost && x.Serial != World.Player.Serial && !TargetFilterManager.IsFilteredTarget(x.Serial))
                .ToList();

            NextPrevTarget(mobiles, false);
        }

        public static void PrevTargetMonster()
        {
            var mobiles = World.MobilesInRange().Where(x =>
                    x.IsMonster && !IsNextPrevFriend(x) && !x.Blessed && !x.IsGhost &&
                    x.Serial != World.Player.Serial && !TargetFilterManager.IsFilteredTarget(x.Serial))
                .ToList();

            NextPrevTarget(mobiles, false);
        }

        public static void PrevTargetFriend()
        {
            var mobiles = World.MobilesInRange().Where(x =>
                FriendsManager.IsFriend(x.Serial) && !x.Blessed && !x.IsGhost &&
                x.Serial != World.Player.Serial).ToList();

            NextPrevTarget(mobiles, false, true);
        }

        public static void NextTargetCriminalHumanoid()
        {
            var mobiles = World.MobilesInRange().Where(x =>
                    x.IsHuman && x.Notoriety == (int) TargetType.Criminal && !IsNextPrevFriend(x) && !x.Blessed &&
                    !x.IsGhost && x.Serial != World.Player.Serial && !TargetFilterManager.IsFilteredTarget(x.Serial))
                .ToList();

            NextPrevTarget(mobiles, true);
        }

        public static void NextTargetMurdererHumanoid()
        {
            var mobiles = World.MobilesInRange()
                .Where(x => x.IsHuman && x.Notoriety == (int) TargetType.Murderer && !IsNextPrevFriend(x) &&
                            !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial &&
                            !TargetFilterManager.IsFilteredTarget(x.Serial)).ToList();

            NextPrevTarget(mobiles, true);
        }

        public static void NextTargetInnocentHumanoid()
        {
            var mobiles = World.MobilesInRange()
                .Where(x => x.IsHuman && x.Notoriety == (int) TargetType.Innocent && !IsNextPrevFriend(x) &&
                            !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial &&
                            !TargetFilterManager.IsFilteredTarget(x.Serial)).ToList();

            NextPrevTarget(mobiles, true);
        }

        public static void NextTargetCriminalMonster()
        {
            var mobiles = World.MobilesInRange().Where(x =>
                    x.IsMonster && x.Notoriety == (int) TargetType.Criminal && !IsNextPrevFriend(x) && !x.Blessed &&
                    !x.IsGhost && x.Serial != World.Player.Serial && !TargetFilterManager.IsFilteredTarget(x.Serial))
                .ToList();

            NextPrevTarget(mobiles, true);
        }

        public static void NextTargetMurdererMonster()
        {
            var mobiles = World.MobilesInRange()
                .Where(x => x.IsMonster && x.Notoriety == (int) TargetType.Murderer && !IsNextPrevFriend(x) &&
                            !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial &&
                            !TargetFilterManager.IsFilteredTarget(x.Serial)).ToList();

            NextPrevTarget(mobiles, true);
        }

        public static void NextTargetInnocentMonster()
        {
            var mobiles = World.MobilesInRange()
                .Where(x => x.IsMonster && x.Notoriety == (int) TargetType.Innocent && !IsNextPrevFriend(x) &&
                            !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial &&
                            !TargetFilterManager.IsFilteredTarget(x.Serial)).ToList();

            NextPrevTarget(mobiles, true);
        }

        public static void PrevTargetCriminalHumanoid()
        {
            var mobiles = World.MobilesInRange()
                .Where(x => x.IsHuman && x.Notoriety == (int) TargetType.Criminal && !IsNextPrevFriend(x) &&
                            !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial &&
                            !TargetFilterManager.IsFilteredTarget(x.Serial)).ToList();

            NextPrevTarget(mobiles, false);
        }

        public static void PrevTargetCriminalMonster()
        {
            var mobiles = World.MobilesInRange()
                .Where(x => x.IsMonster && x.Notoriety == (int) TargetType.Criminal && !IsNextPrevFriend(x) &&
                            !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial &&
                            !TargetFilterManager.IsFilteredTarget(x.Serial)).ToList();

            NextPrevTarget(mobiles, false);
        }

        public static void PrevTargetMurdererHumanoid()
        {
            var mobiles = World.MobilesInRange()
                .Where(x => x.IsHuman && x.Notoriety == (int) TargetType.Murderer && !IsNextPrevFriend(x) &&
                            !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial &&
                            !TargetFilterManager.IsFilteredTarget(x.Serial)).ToList();

            NextPrevTarget(mobiles, false);
        }

        public static void PrevTargetMurdererMonster()
        {
            var mobiles = World.MobilesInRange()
                .Where(x => x.IsMonster && x.Notoriety == (int) TargetType.Murderer && !IsNextPrevFriend(x) &&
                            !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial &&
                            !TargetFilterManager.IsFilteredTarget(x.Serial)).ToList();

            NextPrevTarget(mobiles, false);
        }

        public static void PrevTargetInnocentHumanoid()
        {
            var mobiles = World.MobilesInRange()
                .Where(x => x.IsHuman && x.Notoriety == (int) TargetType.Innocent && !IsNextPrevFriend(x) &&
                            !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial &&
                            !TargetFilterManager.IsFilteredTarget(x.Serial)).ToList();

            NextPrevTarget(mobiles, false);
        }

        public static void PrevTargetInnocentMonster()
        {
            var mobiles = World.MobilesInRange()
                .Where(x => x.IsMonster && x.Notoriety == (int) TargetType.Innocent && !IsNextPrevFriend(x) &&
                            !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial &&
                            !TargetFilterManager.IsFilteredTarget(x.Serial)).ToList();

            NextPrevTarget(mobiles, false);
        }

        public static void NextTargetFriendlyHumanoid()
        {
            var mobiles = World.MobilesInRange()
                .Where(x => x.IsHuman && (x.Notoriety == (int) TargetType.Innocent ||
                                          x.Notoriety == (int) TargetType.Invalid ||
                                          x.Notoriety == (int) TargetType.GuildAlly) &&
                            !IsNextPrevFriend(x) && !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial &&
                            !TargetFilterManager.IsFilteredTarget(x.Serial))
                .ToList();

            NextPrevTarget(mobiles, true, false, true);
        }

        public static void NextTargetFriendly()
        {
            var mobiles = World.MobilesInRange()
                .Where(x => (x.Notoriety == (int)TargetType.Innocent ||
                                          x.Notoriety == (int)TargetType.Invalid ||
                                          x.Notoriety == (int)TargetType.GuildAlly) &&
                            !IsNextPrevFriend(x) && !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial &&
                            !TargetFilterManager.IsFilteredTarget(x.Serial))
                .ToList();

            NextPrevTarget(mobiles, true, false, true);
        }

        public static void NextTargetFriendlyMonster()
        {
            var mobiles = World.MobilesInRange()
                .Where(x => x.IsMonster && (x.Notoriety == (int) TargetType.Innocent ||
                                            x.Notoriety == (int) TargetType.Invalid ||
                                            x.Notoriety == (int) TargetType.GuildAlly) &&
                            !IsNextPrevFriend(x) && !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial &&
                            !TargetFilterManager.IsFilteredTarget(x.Serial))
                .ToList();

            NextPrevTarget(mobiles, true, false, true);
        }

        public static void NextTargetGreyHumanoid()
        {
            var mobiles = World.MobilesInRange()
                .Where(x => x.IsHuman && (x.Notoriety == (int) TargetType.Attackable ||
                                          x.Notoriety == (int) TargetType.Criminal) &&
                            !IsNextPrevFriend(x) && !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial &&
                            !TargetFilterManager.IsFilteredTarget(x.Serial))
                .ToList();

            NextPrevTarget(mobiles, true);
        }

        public static void NextTargetGreyMonster()
        {
            var mobiles = World.MobilesInRange()
                .Where(x => x.IsMonster && (x.Notoriety == (int) TargetType.Attackable ||
                                            x.Notoriety == (int) TargetType.Criminal) &&
                            !IsNextPrevFriend(x) && !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial &&
                            !TargetFilterManager.IsFilteredTarget(x.Serial))
                .ToList();

            NextPrevTarget(mobiles, true);
        }

        public static void NextTargetNonFriendlyHumanoid()
        {
            var mobiles = World.MobilesInRange()
                .Where(x => x.IsHuman && (x.Notoriety == (int) TargetType.Attackable ||
                                          x.Notoriety == (int) TargetType.Criminal ||
                                          x.Notoriety == (int) TargetType.Enemy ||
                                          x.Notoriety == (int) TargetType.Murderer) &&
                            !IsNextPrevFriend(x) && !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial &&
                            !TargetFilterManager.IsFilteredTarget(x.Serial)
                ).ToList();

            NextPrevTarget(mobiles, true, false, false, true);
        }

        public static void NextTargetNonFriendlyMonster()
        {
            var mobiles = World.MobilesInRange()
                .Where(x => x.IsMonster && (x.Notoriety == (int) TargetType.Attackable ||
                                            x.Notoriety == (int) TargetType.Criminal ||
                                            x.Notoriety == (int) TargetType.Enemy ||
                                            x.Notoriety == (int) TargetType.Murderer) &&
                            !IsNextPrevFriend(x) && !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial &&
                            !TargetFilterManager.IsFilteredTarget(x.Serial)
                ).ToList();

            NextPrevTarget(mobiles, true, false, false, true);
        }

        public static void PrevTargetFriendlyHumanoid()
        {
            var mobiles = World.MobilesInRange()
                .Where(x => x.IsHuman && (x.Notoriety == (int) TargetType.Innocent ||
                                          x.Notoriety == (int) TargetType.Invalid ||
                                          x.Notoriety == (int) TargetType.GuildAlly) &&
                            !IsNextPrevFriend(x) && !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial &&
                            !TargetFilterManager.IsFilteredTarget(x.Serial))
                .ToList();

            NextPrevTarget(mobiles, false, false, true);
        }

        public static void PrevTargetFriendly()
        {
            var mobiles = World.MobilesInRange()
                .Where(x => (x.Notoriety == (int)TargetType.Innocent ||
                                          x.Notoriety == (int)TargetType.Invalid ||
                                          x.Notoriety == (int)TargetType.GuildAlly) &&
                            !IsNextPrevFriend(x) && !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial &&
                            !TargetFilterManager.IsFilteredTarget(x.Serial))
                .ToList();

            NextPrevTarget(mobiles, false, false, true);
        }

        public static void PrevTargetFriendlyMonster()
        {
            var mobiles = World.MobilesInRange()
                .Where(x => x.IsMonster && (x.Notoriety == (int) TargetType.Innocent ||
                                            x.Notoriety == (int) TargetType.Invalid ||
                                            x.Notoriety == (int) TargetType.GuildAlly) &&
                            !IsNextPrevFriend(x) && !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial &&
                            !TargetFilterManager.IsFilteredTarget(x.Serial))
                .ToList();

            NextPrevTarget(mobiles, false, false, true);
        }

        public static void PrevTargetGreyHumanoid()
        {
            var mobiles = World.MobilesInRange()
                .Where(x => x.IsHuman && (x.Notoriety == (int) TargetType.Attackable ||
                                          x.Notoriety == (int) TargetType.Criminal) &&
                            !IsNextPrevFriend(x) && !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial &&
                            !TargetFilterManager.IsFilteredTarget(x.Serial))
                .ToList();

            NextPrevTarget(mobiles, false);
        }

        public static void PrevTargetGreyMonster()
        {
            var mobiles = World.MobilesInRange()
                .Where(x => x.IsMonster && (x.Notoriety == (int) TargetType.Attackable ||
                                            x.Notoriety == (int) TargetType.Criminal) &&
                            !IsNextPrevFriend(x) && !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial &&
                            !TargetFilterManager.IsFilteredTarget(x.Serial))
                .ToList();

            NextPrevTarget(mobiles, false);
        }

        public static void PrevTargetNonFriendlyHumanoid()
        {
            var mobiles = World.MobilesInRange()
                .Where(x => x.IsHuman && (x.Notoriety == (int) TargetType.Attackable ||
                                          x.Notoriety == (int) TargetType.Criminal ||
                                          x.Notoriety == (int) TargetType.Enemy ||
                                          x.Notoriety == (int) TargetType.Murderer) &&
                            !IsNextPrevFriend(x) && !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial &&
                            !TargetFilterManager.IsFilteredTarget(x.Serial))
                .ToList();

            NextPrevTarget(mobiles, false, false, false, true);
        }

        public static void PrevTargetNonFriendlyMonster()
        {
            var mobiles = World.MobilesInRange()
                .Where(x => x.IsMonster && (x.Notoriety == (int) TargetType.Attackable ||
                                            x.Notoriety == (int) TargetType.Criminal ||
                                            x.Notoriety == (int) TargetType.Enemy ||
                                            x.Notoriety == (int) TargetType.Murderer) &&
                            !IsNextPrevFriend(x) && !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial &&
                            !TargetFilterManager.IsFilteredTarget(x.Serial))
                .ToList();

            NextPrevTarget(mobiles, false, false, false, true);
        }

        public static void PrevTargetNonFriend()
        {
            var mobiles = World.MobilesInRange()
                .Where(x => (x.Notoriety == (int) TargetType.Attackable ||
                                            x.Notoriety == (int) TargetType.Criminal ||
                                            x.Notoriety == (int) TargetType.Enemy ||
                                            x.Notoriety == (int) TargetType.Murderer) &&
                            !IsNextPrevFriend(x) && !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial &&
                            !TargetFilterManager.IsFilteredTarget(x.Serial))
                .ToList();

            NextPrevTarget(mobiles, false, false, false, true);
        }

        public static void NextPrevTargetNotoriety(bool next, params int[] notoriety)
        {
            var mobiles = World.MobilesInRange()
                .Where(x => notoriety.Contains(x.Notoriety) &&
                            !IsNextPrevFriend(x) && !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial &&
                            !TargetFilterManager.IsFilteredTarget(x.Serial))
                .ToList();

            NextPrevTarget(mobiles, next);
        }

        public static void NextPrevTargetNotorietyMonster(bool next, params int[] notoriety)
        {
            var mobiles = World.MobilesInRange()
                .Where(x => x.IsMonster && notoriety.Contains(x.Notoriety) &&
                            !IsNextPrevFriend(x) && !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial &&
                            !TargetFilterManager.IsFilteredTarget(x.Serial))
                .ToList();

            NextPrevTarget(mobiles, next);
        }

        public static void NextPrevTargetNotorietyHumanoid(bool next, params int[] notoriety)
        {
            var mobiles = World.MobilesInRange()
                .Where(x => x.IsHuman && notoriety.Contains(x.Notoriety) &&
                            !IsNextPrevFriend(x) && !x.Blessed && !x.IsGhost && x.Serial != World.Player.Serial &&
                            !TargetFilterManager.IsFilteredTarget(x.Serial))
                .ToList();

            NextPrevTarget(mobiles, next);
        }
    }
}

================================================
FILE: Razor/Core/TargetingRandom.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System.Collections.Generic;
using Assistant.Core;
using Assistant.Filters;
using Assistant.Scripts;

namespace Assistant
{
    public partial class Targeting
    {
        private static void InitRandomTarget()
        {
            HotKey.Add(HKCategory.Targets, LocString.TargetRandom, TargetRandAnyone);

            HotKey.Add(HKCategory.Targets, LocString.TargRandomFriend, TargetRandFriend);

            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetMurderer, LocString.TargRandRed,
                TargetRandRed);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetMurderer, LocString.TargRandomRedHuman,
                TargetRandRedHumanoid);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetMurderer, LocString.TargRandomRedMonster,
                TargetRandRedMonster);

            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetNonFriendly, LocString.TargRandNFriend,
                TargetRandNonFriendly);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetNonFriendly, LocString.TargRandomNFriendlyHuman,
                TargetRandNonFriendlyHumanoid);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetNonFriendly, LocString.TargRandomNFriendlyMonster,
                TargetRandNonFriendlyMonster);

            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetFriendly, LocString.TargRandFriend,
                TargetRandFriendly);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetFriendly, LocString.TargRandomFriendlyHuman,
                TargetRandFriendlyHumanoid);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetFriendly, LocString.TargRandomFriendlyMonster,
                TargetRandFriendlyMonster);

            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetInnocent, LocString.TargRandBlue,
                TargetRandInnocent);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetInnocent, LocString.TargRandInnocentHuman,
                TargetRandInnocentHumanoid);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetInnocent, LocString.TargRandomInnocentMonster,
                TargetRandInnocentMonster);

            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetGrey, LocString.TargRandGrey, TargetRandGrey);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetGrey, LocString.TargRandGreyHuman,
                TargetRandGreyHumanoid);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetGrey, LocString.TargRandGreyMonster,
                TargetRandGreyMonster);

            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetEnemy, LocString.TargRandEnemy,
                TargetRandEnemy);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetEnemy, LocString.TargRandEnemyHuman,
                TargetRandEnemyHumanoid);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetEnemy, LocString.TargRandEnemyMonster,
                TargetRandEnemyMonster);

            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetCriminal, LocString.TargRandCriminal,
                TargetRandCriminal);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetCriminal, LocString.TargRandCriminalHuman,
                TargetRandCriminalHumanoid);
            HotKey.Add(HKCategory.Targets, HKSubCat.SubTargetCriminal, LocString.TargRandomCriminalMonster,
                TargetRandCriminalMonster);
        }


        public static void TargetRandNonFriendly()
        {
            RandomTarget((int) TargetType.Attackable, (int) TargetType.Criminal, (int) TargetType.Enemy,
                (int) TargetType.Murderer);
        }

        public static void TargetRandNonFriendlyHumanoid()
        {
            RandomHumanoidTarget((int) TargetType.Attackable, (int) TargetType.Criminal, (int) TargetType.Enemy,
                (int) TargetType.Murderer);
        }

        public static void TargetRandNonFriendlyMonster()
        {
            RandomMonsterTarget((int) TargetType.Attackable, (int) TargetType.Criminal, (int) TargetType.Enemy,
                (int) TargetType.Murderer);
        }

        public static void TargetRandFriendly()
        {
            RandomTarget((int) TargetType.Invalid, (int) TargetType.Innocent, (int) TargetType.GuildAlly);
        }

        public static void TargetRandFriendlyHumanoid()
        {
            RandomHumanoidTarget((int) TargetType.Invalid, (int) TargetType.Innocent, (int) TargetType.GuildAlly);
        }

        public static void TargetRandFriendlyMonster()
        {
            RandomMonsterTarget((int) TargetType.Invalid, (int) TargetType.Innocent, (int) TargetType.GuildAlly);
        }

        public static void TargetRandEnemy()
        {
            RandomTarget((int) TargetType.Enemy);
        }

        public static void TargetRandEnemyMonster()
        {
            RandomMonsterTarget((int) TargetType.Enemy);
        }

        public static void TargetRandEnemyHumanoid()
        {
            RandomHumanoidTarget((int) TargetType.Enemy);
        }

        public static void TargetRandRed()
        {
            RandomTarget((int) TargetType.Murderer);
        }

        public static void TargetRandRedHumanoid()
        {
            RandomHumanoidTarget((int) TargetType.Murderer);
        }

        public static void TargetRandRedMonster()
        {
            RandomMonsterTarget((int) TargetType.Murderer);
        }

        public static void TargetRandGrey()
        {
            RandomTarget((int) TargetType.Attackable, (int) TargetType.Criminal);
        }

        public static void TargetRandGreyMonster()
        {
            RandomMonsterTarget((int) TargetType.Attackable, (int) TargetType.Criminal);
        }

        public static void TargetRandGreyHumanoid()
        {
            RandomHumanoidTarget((int) TargetType.Attackable, (int) TargetType.Criminal);
        }

        public static void TargetRandCriminal()
        {
            RandomTarget((int) TargetType.Criminal);
        }

        public static void TargetRandCriminalHumanoid()
        {
            RandomHumanoidTarget((int) TargetType.Criminal);
        }

        public static void TargetRandCriminalMonster()
        {
            RandomMonsterTarget((int) TargetType.Criminal);
        }

        public static void TargetRandInnocent()
        {
            RandomTarget((int) TargetType.Innocent);
        }

        public static void TargetRandInnocentHumanoid()
        {
            RandomHumanoidTarget((int) TargetType.Innocent);
        }

        public static void TargetRandInnocentMonster()
        {
            RandomMonsterTarget((int) TargetType.Innocent);
        }

        public static void TargetRandFriend()
        {
            RandomFriendTarget();
        }

        public static void TargetRandAnyone()
        {
            RandomTarget();
        }

        public static void RandomTarget(params int[] noto)
        {
            if (!Client.Instance.AllowBit(FeatureBit.RandomTargets))
                return;

            var list = new List<Mobile>();
            foreach (var m in World.MobilesInRange(12))
                if ((!FriendsManager.IsFriend(m.Serial) || noto.Length > 0 && noto[0] == 0) &&
                    !m.Blessed && !m.IsGhost && m.Serial != World.Player.Serial &&
                    !TargetFilterManager.IsFilteredTarget(m.Serial) &&
                    Utility.InRange(World.Player.Position, m.Position, Config.GetInt("LTRange")))
                {
                    for (var i = 0; i < noto.Length; i++)
                        if (noto[i] == m.Notoriety)
                        {
                            list.Add(m);
                            break;
                        }

                    if (noto.Length == 0)
                        list.Add(m);
                }

            if (list.Count > 0)
            {
                SetLastTargetTo(list[Utility.Random(list.Count)]);
                ScriptManager.TargetFound = true;
            }
            else
            {
                World.Player.SendMessage(MsgLevel.Warning, LocString.TargNoOne);
            }
        }

        public static void RandomHumanoidTarget(params int[] noto)
        {
            if (!Client.Instance.AllowBit(FeatureBit.RandomTargets))
                return;

            var list = new List<Mobile>();
            foreach (var m in World.MobilesInRange(12))
            {
                if (m.Body != 0x0190 && m.Body != 0x0191 && m.Body != 0x025D && m.Body != 0x025E)
                    continue;

                if ((!FriendsManager.IsFriend(m.Serial) || noto.Length > 0 && noto[0] == 0) &&
                    !m.Blessed && !m.IsGhost && m.Serial != World.Player.Serial &&
                    !TargetFilterManager.IsFilteredTarget(m.Serial) &&
                    Utility.InRange(World.Player.Position, m.Position, Config.GetInt("LTRange")))
                {
                    for (var i = 0; i < noto.Length; i++)
                        if (noto[i] == m.Notoriety)
                        {
                            list.Add(m);
                            break;
                        }

                    if (noto.Length == 0)
                        list.Add(m);
                }
            }

            if (list.Count > 0)
            {
                SetLastTargetTo(list[Utility.Random(list.Count)]);
                ScriptManager.TargetFound = true;
            }
            else
            {
                World.Player.SendMessage(MsgLevel.Warning, LocString.TargNoOne);
            }
        }

        public static void RandomMonsterTarget(params int[] noto)
        {
            if (!Client.Instance.AllowBit(FeatureBit.RandomTargets))
                return;

            var list = new List<Mobile>();
            foreach (var m in World.MobilesInRange(12))
            {
                if (!m.IsMonster)
                    continue;

                if ((!FriendsManager.IsFriend(m.Serial) || noto.Length > 0 && noto[0] == 0) &&
                    !m.Blessed && !m.IsGhost && m.Serial != World.Player.Serial &&
                    !TargetFilterManager.IsFilteredTarget(m.Serial) &&
                    Utility.InRange(World.Player.Position, m.Position, Config.GetInt("LTRange")))
                {
                    for (var i = 0; i < noto.Length; i++)
                        if (noto[i] == m.Notoriety)
                        {
                            list.Add(m);
                            break;
                        }

                    if (noto.Length == 0)
                        list.Add(m);
                }
            }

            if (list.Count > 0)
            {
                SetLastTargetTo(list[Utility.Random(list.Count)]);
                ScriptManager.TargetFound = true;
            }
            else
            {
                World.Player.SendMessage(MsgLevel.Warning, LocString.TargNoOne);
            }
        }

        public static void RandomFriendTarget()
        {
            if (!Client.Instance.AllowBit(FeatureBit.RandomTargets))
                return;

            var list = new List<Mobile>();
            foreach (var m in World.MobilesInRange(12))
                if (FriendsManager.IsFriend(m.Serial) &&
                    !m.Blessed && !m.IsGhost && m.Serial != World.Player.Serial &&
                    !TargetFilterManager.IsFilteredTarget(m.Serial) &&
                    Utility.InRange(World.Player.Position, m.Position, Config.GetInt("LTRange")))
                    list.Add(m);

            if (list.Count > 0)
            {
                SetLastTargetTo(list[Utility.Random(list.Count)]);
                ScriptManager.TargetFound = true;
            }
            else
            {
                World.Player.SendMessage(MsgLevel.Warning, LocString.TargNoOne);
            }
        }
    }
}

================================================
FILE: Razor/Core/TextFilterManager.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Windows.Forms;
using System.Xml;
using Assistant.Agents;
using Assistant.UI;

namespace Assistant.Core
{
    public static class TextFilterManager
    {
        private static ListBox _filterTextList;

        public static List<string> FilteredText = new List<string>();
        
        public static void Initialize()
        {
            MessageManager.OnMobileMessage += HandleMobileMessage;
        }
        
        public static void HandleMobileMessage(Packet p, PacketHandlerEventArgs args, Serial source, ushort graphic,
            MessageType type, ushort hue, ushort font, string lang, string sourceName,
            string text)
        {
            if ((type == MessageType.Emote || type == MessageType.Regular || type == MessageType.Whisper || type == MessageType.Yell) && source.IsMobile && source != World.Player.Serial)
            {
                if (IgnoreAgent.IsIgnored(source))
                {
                    args.Block = true;
                    return;
                }

                if (IsFiltered(text))
                {
                    args.Block = true;
                }
            }
        }

        public static void SetControls(ListBox filterTextList)
        {
            _filterTextList = filterTextList;
        }

        public static void AddFilter(string filter)
        {
            FilteredText.Add(filter);

            RedrawList();
        }

        public static void RemoveFilter(string filter)
        {
            FilteredText.Remove(filter);

            RedrawList();
        }

        public static void Save(XmlTextWriter xml)
        {
            foreach (var text in FilteredText)
            {
                xml.WriteStartElement("filter");
                xml.WriteAttributeString("text", text);
                xml.WriteEndElement();
            }
        }

        public static bool IsFiltered(string text)
        {
            if (!Config.GetBool("EnableTextFilter"))
                return false;

            foreach (string filteredText in FilteredText)
            {
                if (text.IndexOf(filteredText, StringComparison.OrdinalIgnoreCase) != -1)
                {
                    return true;
                }
            }

            return false;
        }

        public static void Load(XmlElement node)
        {
            ClearAll();

            try
            {
                foreach (XmlElement el in node.GetElementsByTagName("filter"))
                {
                    FilteredText.Add(Convert.ToString(el.GetAttribute("text")));
                }

                RedrawList();
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex);
            }
        }

        public static void ClearAll()
        {
            FilteredText.Clear();
        }

        public static void RedrawList()
        {
            _filterTextList?.SafeAction(s =>
            {
                s.BeginUpdate();
                s.Items.Clear();

                foreach (string text in FilteredText)
                {
                    s.Items.Add(text);
                }

                s.EndUpdate();
            });
        }
    }
}

================================================
FILE: Razor/Core/Timer.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections;

namespace Assistant
{
    public class MinHeap
    {
        private ArrayList m_List;
        private int m_Size;

        public MinHeap() : this(1)
        {
        }

        public MinHeap(int capacity)
        {
            m_List = new ArrayList(capacity + 1);
            m_Size = 0;
            m_List.Add(null); // 0th index is never used, always null
        }

        public MinHeap(ICollection c) : this(c.Count)
        {
            foreach (IComparable o in c)
                m_List.Add(o);
            m_Size = c.Count;
            Heapify();
        }

        public void Heapify()
        {
            for (int i = m_Size / 2; i > 0; i--)
                PercolateDown(i);
        }

        private void PercolateDown(int hole)
        {
            IComparable tmp = (IComparable) m_List[hole];
            int child;

            for (; hole * 2 <= m_Size; hole = child)
            {
                child = hole * 2;
                if (child != m_Size && ((IComparable) m_List[child + 1]).CompareTo(m_List[child]) < 0)
                    child++;

                if (tmp.CompareTo(m_List[child]) >= 0)
                    m_List[hole] = m_List[child];
                else
                    break;
            }

            m_List[hole] = tmp;
        }

        public IComparable Peek()
        {
            return m_List[1] as IComparable;
        }

        public IComparable Pop()
        {
            IComparable top = Peek();

            m_List[1] = m_List[m_Size--];
            PercolateDown(1);

            return top;
        }

        public void Remove(IComparable o)
        {
            for (int i = 1; i <= m_Size; i++)
            {
                if (m_List[i] == o)
                {
                    m_List[i] = m_List[m_Size--];
                    PercolateDown(i);
                    // TODO: Do we ever need to shrink?
                    return;
                }
            }
        }

        public void Clear()
        {
            int capacity = m_List.Count / 2;
            if (capacity < 2)
                capacity = 2;
            m_Size = 0;
            m_List = new ArrayList(capacity);
            m_List.Add(null);
        }

        public void Add(IComparable o)
        {
            // PercolateUp
            int hole = ++m_Size;

            // Grow the list if needed
            while (m_List.Count <= m_Size)
                m_List.Add(null);

            for (; hole > 1 && o.CompareTo(m_List[hole / 2]) < 0; hole /= 2)
                m_List[hole] = m_List[hole / 2];
            m_List[hole] = o;
        }

        public void AddMultiple(ICollection col)
        {
            if (col != null && col.Count > 0)
            {
                foreach (object o in col)
                {
                    int hole = ++m_Size;

                    // Grow the list as needed
                    while (m_List.Count <= m_Size)
                        m_List.Add(null);

                    m_List[hole] = o;
                }

                Heapify();
            }
        }

        public int Count
        {
            get { return m_Size; }
        }

        public bool IsEmpty
        {
            get { return Count <= 0; }
        }

        public ArrayList GetRawList()
        {
            ArrayList copy = new ArrayList(m_Size);
            for (int i = 1; i <= m_Size; i++)
                copy.Add(m_List[i]);
            return copy;
        }
    }

    public delegate void TimerCallback();

    public delegate void TimerCallbackState(object state);

    public abstract class Timer : IComparable
    {
        private DateTime m_Next;
        private TimeSpan m_Delay;
        private TimeSpan m_Interval;
        private bool m_Running;
        private int m_Index, m_Count;

        protected abstract void OnTick();

        public Timer(TimeSpan delay) : this(delay, TimeSpan.Zero, 1)
        {
        }

        public Timer(TimeSpan interval, int count) : this(interval, interval, count)
        {
        }

        public Timer(TimeSpan delay, TimeSpan interval) : this(delay, interval, 0)
        {
        }

        public Timer(TimeSpan delay, TimeSpan interval, int count)
        {
            m_Delay = delay;
            m_Interval = interval;
            m_Count = count;
        }

        public void Start()
        {
            if (!m_Running)
            {
                m_Index = 0;
                m_Next = DateTime.UtcNow + m_Delay;
                m_Running = true;
                m_Heap.Add(this);
                ChangedNextTick(true);
            }
        }

        public void Stop()
        {
            if (m_Running)
            {
                m_Running = false;
                m_Heap.Remove(this);
                //ChangedNextTick();
            }
        }

        public int CompareTo(object obj)
        {
            if (obj is Timer)
                return this.TimeUntilTick.CompareTo(((Timer) obj).TimeUntilTick);
            else
                return -1;
        }

        public TimeSpan TimeUntilTick
        {
            get { return m_Running ? m_Next - DateTime.UtcNow : TimeSpan.MaxValue; }
        }

        public bool Running
        {
            get { return m_Running; }
        }

        public TimeSpan Delay
        {
            get { return m_Delay; }
            set { m_Delay = value; }
        }

        public TimeSpan Interval
        {
            get { return m_Interval; }
            set { m_Interval = value; }
        }

        private static MinHeap m_Heap = new MinHeap();

        private static void ChangedNextTick()
        {
            ChangedNextTick(false);
        }

        private static void ChangedNextTick(bool allowImmediate)
        {
            if (!m_Heap.IsEmpty)
            {
                int interval = (int) Math.Round(((Timer) m_Heap.Peek()).TimeUntilTick.TotalMilliseconds);
                if (allowImmediate && interval <= 0)
                {
                    Slice();
                }
                else
                {
                    if (interval <= 0)
                        interval = 1;
                }
            }
        }

        public static void Slice()
        {
            int breakCount = 100;
            ArrayList readd = new ArrayList();

            while (!m_Heap.IsEmpty && ((Timer) m_Heap.Peek()).TimeUntilTick < TimeSpan.Zero)
            {
                if (breakCount-- <= 0)
                    break;

                Timer t = (Timer) m_Heap.Pop();

                if (t != null && t.Running)
                {
                    t.OnTick();

                    if (t.Running && (t.m_Count == 0 || (++t.m_Index) < t.m_Count))
                    {
                        t.m_Next = DateTime.UtcNow + t.m_Interval;
                        readd.Add(t);
                    }
                    else
                    {
                        t.Stop();
                    }
                }
            }

            m_Heap.AddMultiple(readd);

            ChangedNextTick();
        }

        private class OneTimeTimer : Timer
        {
            private TimerCallback m_Call;

            public OneTimeTimer(TimeSpan d, TimerCallback call) : base(d)
            {
                m_Call = call;
            }

            protected override void OnTick()
            {
                m_Call();
            }
        }

        public static Timer DelayedCallback(TimeSpan delay, TimerCallback call)
        {
            return new OneTimeTimer(delay, call);
        }

        private class OneTimeTimerState : Timer
        {
            private TimerCallbackState m_Call;
            private object m_State;

            public OneTimeTimerState(TimeSpan d, TimerCallbackState call, object state) : base(d)
            {
                m_Call = call;
                m_State = state;
            }

            protected override void OnTick()
            {
                m_Call(m_State);
            }
        }

        public static Timer DelayedCallbackState(TimeSpan delay, TimerCallbackState call, object state)
        {
            return new OneTimeTimerState(delay, call, state);
        }
    }
}

================================================
FILE: Razor/Core/UOEntity.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System.IO;
using System.Collections.Generic;

namespace Assistant
{
    public class UOEntity
    {
        public class ContextMenuList : List<KeyValuePair<ushort, ushort>>
        {
            public void Add(ushort key, ushort value)
            {
                var element = new KeyValuePair<ushort, ushort>(key, value);
                Add(element);
            }
        }

        private Serial _serial;
        private Point3D _pos;
        private ushort _hue;
        private bool _deleted;
        private ContextMenuList _contextMenu = new ContextMenuList();
        protected ObjectPropertyList _objPropList = null;

        public ObjectPropertyList ObjPropList
        {
            get { return _objPropList; }
        }

        public virtual void AfterLoad()
        {
        }

        public UOEntity(Serial ser)
        {
            _objPropList = new ObjectPropertyList(this);

            _serial = ser;
            _deleted = false;
        }

        public Serial Serial
        {
            get { return _serial; }
        }

        public virtual Point3D Position
        {
            get { return _pos; }
            set
            {
                if (value != _pos)
                {
                    var oldPos = _pos;
                    _pos = value;
                    OnPositionChanging(oldPos);
                }
            }
        }

        public bool Deleted
        {
            get { return _deleted; }
        }

        public ContextMenuList ContextMenu
        {
            get { return _contextMenu; }
        }

        public virtual ushort Hue
        {
            get { return _hue; }
            set { _hue = value; }
        }

        public virtual void Remove()
        {
            _deleted = true;
        }

        public virtual void OnPositionChanging(Point3D oldPos)
        {
        }

        public override int GetHashCode()
        {
            return _serial.GetHashCode();
        }

        public int OPLHash
        {
            get
            {
                if (_objPropList != null)
                    return _objPropList.Hash;
                else
                    return 0;
            }
            set
            {
                if (_objPropList != null)
                    _objPropList.Hash = value;
            }
        }

        public bool ModifiedOPL
        {
            get { return _objPropList.Customized; }
        }

        public void ReadPropertyList(PacketReader p)
        {
            _objPropList.Read(p);
        }

        /*public Packet BuildOPLPacket()
        { 
            return m_ObjPropList.BuildPacket();
        }*/

        public void OPLChanged()
        {
            //Client.Instance.SendToClient( m_ObjPropList.BuildPacket() );
            Client.Instance.SendToClient(new OPLInfo(Serial, OPLHash));
        }
    }
}

================================================
FILE: Razor/Core/Utility.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.IO;
using System.Text;
using System.Globalization;
using System.Runtime.InteropServices;
using System.Diagnostics;
using System.Windows.Forms;

namespace Assistant
{
    public class Utility
    {
        private static Random m_Random = new Random();

        public static int Random(int min, int max)
        {
            return m_Random.Next(max - min + 1) + min;
        }

        public static int Random(int num)
        {
            return m_Random.Next(num);
        }

        public static bool InRange(IPoint2D from, IPoint2D to, int range)
        {
            return (to.X >= (from.X - range))
                   && (to.X <= (from.X + range))
                   && (to.Y >= (from.Y - range))
                   && (to.Y <= (from.Y + range));
        }

        public static int Distance(int fx, int fy, int tx, int ty)
        {
            int xDelta = Math.Abs(fx - tx);
            int yDelta = Math.Abs(fy - ty);

            return (xDelta > yDelta ? xDelta : yDelta);
        }

        public static int Distance(IPoint2D from, IPoint2D to)
        {
            int xDelta = Math.Abs(from.X - to.X);
            int yDelta = Math.Abs(from.Y - to.Y);

            return (xDelta > yDelta ? xDelta : yDelta);
        }

        public static double DistanceSqrt(IPoint2D from, IPoint2D to)
        {
            float xDelta = Math.Abs(from.X - to.X);
            float yDelta = Math.Abs(from.Y - to.Y);

            return Math.Sqrt(xDelta * xDelta + yDelta * yDelta);
        }

        public static void Offset(Direction d, ref int x, ref int y)
        {
            switch (d & Direction.Mask)
            {
                case Direction.North:
                    --y;
                    break;
                case Direction.South:
                    ++y;
                    break;
                case Direction.West:
                    --x;
                    break;
                case Direction.East:
                    ++x;
                    break;
                case Direction.Right:
                    ++x;
                    --y;
                    break;
                case Direction.Left:
                    --x;
                    ++y;
                    break;
                case Direction.Down:
                    ++x;
                    ++y;
                    break;
                case Direction.Up:
                    --x;
                    --y;
                    break;
            }
        }

        public static void FormatBuffer(TextWriter output, Stream input, int length)
        {
            output.WriteLine("        0  1  2  3  4  5  6  7   8  9  A  B  C  D  E  F");
            output.WriteLine("       -- -- -- -- -- -- -- --  -- -- -- -- -- -- -- --");

            int byteIndex = 0;

            int whole = length >> 4;
            int rem = length & 0xF;

            for (int i = 0; i < whole; ++i, byteIndex += 16)
            {
                StringBuilder bytes = new StringBuilder(49);
                StringBuilder chars = new StringBuilder(16);

                for (int j = 0; j < 16; ++j)
                {
                    int c = input.ReadByte();

                    bytes.Append(c.ToString("X2"));

                    if (j != 7)
                    {
                        bytes.Append(' ');
                    }
                    else
                    {
                        bytes.Append("  ");
                    }

                    if (c >= 0x20 && c < 0x80)
                    {
                        chars.Append((char) c);
                    }
                    else
                    {
                        chars.Append('.');
                    }
                }

                output.Write(byteIndex.ToString("X4"));
                output.Write("   ");
                output.Write(bytes.ToString());
                output.Write("  ");
                output.WriteLine(chars.ToString());
            }

            if (rem != 0)
            {
                StringBuilder bytes = new StringBuilder(49);
                StringBuilder chars = new StringBuilder(rem);

                for (int j = 0; j < 16; ++j)
                {
                    if (j < rem)
                    {
                        int c = input.ReadByte();

                        bytes.Append(c.ToString("X2"));

                        if (j != 7)
                        {
                            bytes.Append(' ');
                        }
                        else
                        {
                            bytes.Append("  ");
                        }

                        if (c >= 0x20 && c < 0x80)
                        {
                            chars.Append((char) c);
                        }
                        else
                        {
                            chars.Append('.');
                        }
                    }
                    else
                    {
                        bytes.Append("   ");
                    }
                }

                output.Write(byteIndex.ToString("X4"));
                output.Write("   ");
                output.Write(bytes.ToString());
                if (rem <= 8)
                    output.Write("   ");
                else
                    output.Write("  ");
                output.WriteLine(chars.ToString());
            }
        }

        public static unsafe void FormatBuffer(TextWriter output, byte* buff, int length)
        {
            output.WriteLine("        0  1  2  3  4  5  6  7   8  9  A  B  C  D  E  F");
            output.WriteLine("       -- -- -- -- -- -- -- --  -- -- -- -- -- -- -- --");

            int byteIndex = 0;

            int whole = length >> 4;
            int rem = length & 0xF;

            for (int i = 0; i < whole; ++i, byteIndex += 16)
            {
                StringBuilder bytes = new StringBuilder(49);
                StringBuilder chars = new StringBuilder(16);

                for (int j = 0; j < 16; ++j)
                {
                    int c = *buff++;

                    bytes.Append(c.ToString("X2"));

                    if (j != 7)
                    {
                        bytes.Append(' ');
                    }
                    else
                    {
                        bytes.Append("  ");
                    }

                    if (c >= 0x20 && c < 0x80)
                    {
                        chars.Append((char) c);
                    }
                    else
                    {
                        chars.Append('.');
                    }
                }

                output.Write(byteIndex.ToString("X4"));
                output.Write("   ");
                output.Write(bytes.ToString());
                output.Write("  ");
                output.WriteLine(chars.ToString());
            }

            if (rem != 0)
            {
                StringBuilder bytes = new StringBuilder(49);
                StringBuilder chars = new StringBuilder(rem);

                for (int j = 0; j < 16; ++j)
                {
                    if (j < rem)
                    {
                        int c = *buff++;

                        bytes.Append(c.ToString("X2"));

                        if (j != 7)
                        {
                            bytes.Append(' ');
                        }
                        else
                        {
                            bytes.Append("  ");
                        }

                        if (c >= 0x20 && c < 0x80)
                        {
                            chars.Append((char) c);
                        }
                        else
                        {
                            chars.Append('.');
                        }
                    }
                    else
                    {
                        bytes.Append("   ");
                    }
                }

                output.Write(byteIndex.ToString("X4"));
                output.Write("   ");
                output.Write(bytes.ToString());
                if (rem <= 8)
                    output.Write("   ");
                else
                    output.Write("  ");
                output.WriteLine(chars.ToString());
            }
        }

        private static char[] pathChars = new char[] {'\\', '/'};

        public static string PathDisplayStr(string path, int maxLen)
        {
            if (path == null || path.Length <= maxLen || path.Length < 5)
                return path;

            int first = (maxLen - 3) / 2;
            int last = path.LastIndexOfAny(pathChars);
            if (last == -1 || last < maxLen / 4)
                last = path.Length - first;
            first = maxLen - last - 3;
            if (first < 0)
                first = 1;
            if (last < first)
                last = first;

            return $"{path.Substring(0, first)}...{path.Substring(last)}";
        }

        public static string FormatSize(long size)
        {
            if (size < 1024) // 1 K
                return $"{size:#,##0} B";
            else if (size < 1048576) // 1 M
                return $"{size / 1024.0:#,###.0} KB";
            else
                return $"{size / 1048576.0:#,###.0} MB";
        }

        public static string FormatTime(int sec)
        {
            int m = sec / 60;
            int h = m / 60;
            m = m % 60;
            return $"{h:#0}:{m:00}:{sec % 60:00}";
        }

        public static string FormatTimeMS(int ms)
        {
            int s = ms / 1000;
            int m = s / 60;
            int h = m / 60;

            ms = ms % 1000;
            s = s % 60;
            m = m % 60;

            if (h > 0 || m > 55)
                return $"{h:#0}:{m:00}:{s:00}.{ms:000}";
            else
                return $"{m:00}:{s:00}.{ms:000}";
        }

        public static int ToInt32(string str, int def)
        {
            if (str == null)
                return def;

            if (str == null)
                return def;

            int val;
            if (str.StartsWith("0x"))
            {
                if (int.TryParse(str.Substring(2), NumberStyles.HexNumber, Engine.Culture, out val))
                    return val;
            }
            else if (int.TryParse(str, out val))
                return val;

            return def;
        }

        public static uint ToUInt32(string str, uint def)
        {
            if (str == null)
                return def;

            uint val;
            if (str.StartsWith("0x"))
            {
                if (uint.TryParse(str.Substring(2), NumberStyles.HexNumber, Engine.Culture, out val))
                    return val;
            }
            else if (uint.TryParse(str, out val))
                return val;

            return def;
        }

        public static double ToDouble(string str, double def)
        {
            if (str == null)
                return def;

            if (double.TryParse(str, out double d))
                return d;
            return def;
        }

        public static ushort ToUInt16(string str, ushort def)
        {
            if (str == null)
                return def;

            ushort val;
            if (str.StartsWith("0x"))
            {
                if (ushort.TryParse(str.Substring(2), NumberStyles.HexNumber, Engine.Culture, out val))
                    return val;
            }
            else if (ushort.TryParse(str, out val))
                return val;

            return def;
        }
        
        public static long ToLong(string str, ushort def)
        {
            if (str == null)
                return def;

            long val;
            if (str.StartsWith("0x"))
            {
                if (long.TryParse(str.Substring(2), NumberStyles.HexNumber, Engine.Culture, out val))
                    return val;
            }
            else if (long.TryParse(str, out val))
                return val;

            return def;
        }

        public static void LaunchBrowser(string url)
        {
            try
            {
                Process.Start(url);

                /*if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
                {
                    ProcessStartInfo psi = new ProcessStartInfo
                    {
                        FileName = url,
                        UseShellExecute = true
                    };
                    Process.Start(psi);
                }
                else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
                {
                    Process.Start("open", url);
                }
                else
                {
                    Process.Start("xdg-open", url);
                }*/
            }
            catch (Exception ex)
            {
                MessageBox.Show(null, ex.Message, "Unable to open directory", MessageBoxButtons.OK,
                                MessageBoxIcon.Warning);
            }
        }
    }
}

================================================
FILE: Razor/Core/WaypointManager.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Windows.Forms;
using System.Xml;
using Assistant.UI;

namespace Assistant.Core
{
    public static class WaypointManager
    {
        private static ListBox _waypointList;
        private static WaypointDistanceTimer _waypointTimer;

        public static Waypoint CurrentWaypoint;
        private static int _curWaypointIndex;

        public static List<Waypoint> Waypoints = new List<Waypoint>();

        public static void Initialize()
        {
            HotKey.Add(HKCategory.Misc, LocString.NextWaypoint, new HotKeyCallback(NextWaypoint));
            HotKey.Add(HKCategory.Misc, LocString.PrevWaypoint, new HotKeyCallback(PrevWaypoint));
            HotKey.Add(HKCategory.Misc, LocString.HideWaypoint, new HotKeyCallback(ClearWaypoint));
        }

        public static void SetControls(ListBox waypointList)
        {
            _waypointList = waypointList;
            _waypointTimer = new WaypointDistanceTimer();
            _waypointTimer.Stop();
        }

        public class Waypoint
        {
            public int X { get; set; }
            public int Y { get; set; }
            public string Name { get; set; }

            public override string ToString()
            {
                return $"{Name} ({X}, {Y})";
            }
        }

        public static void NextWaypoint()
        {
            _curWaypointIndex++;

            if (_curWaypointIndex >= Waypoints.Count)
                _curWaypointIndex = 0;

            ShowWaypoint(Waypoints[_curWaypointIndex]);
        }

        public static void PrevWaypoint()
        {
            _curWaypointIndex--;

            if (_curWaypointIndex < 0)
                _curWaypointIndex = Waypoints.Count - 1;

            ShowWaypoint(Waypoints[_curWaypointIndex]);
        }

        public static void AddWaypoint(Waypoint waypoint)
        {
            Waypoints.Add(waypoint);

            RedrawList();
        }

        public static void RemoveWaypoint(Waypoint waypoint)
        {
            ClearWaypoint();

            Waypoints.Remove(waypoint);

            RedrawList();
        }

        public static void ShowWaypoint(Waypoint waypoint)
        {
            Client.Instance.SendToClient(new QuestArrow(true, Convert.ToUInt16(waypoint.X), Convert.ToUInt16(waypoint.Y)));
            
            CurrentWaypoint = waypoint;

            SendMessage($"Waypoint: {CurrentWaypoint}");

            if (Config.GetBool("ShowWaypointDistance"))
            {
                _waypointTimer.Start();
            }
        }

        public static void ClearWaypoint()
        {
            Client.Instance.SendToClient(new QuestArrow(false, 0, 0));

            CurrentWaypoint = null;

            _waypointTimer.Stop();
        }

        public static void ResetTimer()
        {
            if (_waypointTimer.Running)
            {
                _waypointTimer.Stop();
                _waypointTimer = new WaypointDistanceTimer();
                _waypointTimer.Start();
            }
            else
            {
                _waypointTimer = new WaypointDistanceTimer();
                _waypointTimer.Stop();
            }
        }

        public static void StartTimer()
        {
            _waypointTimer.Start();
        }

        public static void StopTimer()
        {
            _waypointTimer.Stop();
        }

        private static void SendMessage(string msg)
        {
            if (Config.GetBool("ShowWaypointOverhead"))
            {
                World.Player.OverheadMessage(msg);
            }
            else
            {
                World.Player.SendMessage(MsgLevel.Info, msg);
            }
        }

        private class WaypointDistanceTimer : Timer
        {
            public WaypointDistanceTimer() : base(TimeSpan.FromSeconds(Config.GetInt("ShowWaypointSeconds")),
                TimeSpan.FromSeconds(Config.GetInt("ShowWaypointSeconds")))
            {
            }

            protected override void OnTick()
            {
                if (World.Player == null || CurrentWaypoint == null)
                {
                    Stop();
                    return;
                }

                int dist = Utility.Distance(World.Player.Position.X, World.Player.Position.Y, CurrentWaypoint.X,
                    CurrentWaypoint.Y);

                if (Config.GetBool("ClearWaypoint") && dist <= Config.GetInt("HideWaypointDistance"))
                {
                    SendMessage($"Arrived at '{CurrentWaypoint}'");

                    Stop();
                    ClearWaypoint();
                }
                else
                {
                    SendMessage($"{CurrentWaypoint.Name}: {dist} tiles away");
                }
            }
        }

        public static void Save(XmlTextWriter xml)
        {
            foreach (var waypoint in Waypoints)
            {
                xml.WriteStartElement("waypoint");
                xml.WriteAttributeString("x", waypoint.X.ToString());
                xml.WriteAttributeString("y", waypoint.Y.ToString());
                xml.WriteAttributeString("name", waypoint.Name);
                xml.WriteEndElement();
            }
        }

        public static void Load(XmlElement node)
        {
            ClearAll();

            try
            {
                foreach (XmlElement el in node.GetElementsByTagName("waypoint"))
                {
                    Waypoint waypoint = new Waypoint
                    {
                        X = Convert.ToInt32(el.GetAttribute("x")),
                        Y = Convert.ToInt32(el.GetAttribute("y")),
                        Name = el.GetAttribute("name")
                    };

                    Waypoints.Add(waypoint);
                }

                RedrawList();
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex);
            }
        }

        public static void ClearAll()
        {
            Waypoints.Clear();
        }

        public static void RedrawList()
        {
            _waypointList?.SafeAction(s =>
            {
                s.BeginUpdate();
                s.Items.Clear();

                foreach (Waypoint waypoint in Waypoints)
                {
                    s.Items.Add(waypoint);
                }

                s.EndUpdate();
            });
        }
    }
}

================================================
FILE: Razor/Core/World.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;

namespace Assistant
{
    public class World
    {
        private static Dictionary<Serial, Item> m_Items;
        private static Dictionary<Serial, Mobile> m_Mobiles;
        private static PlayerData m_Player;
        private static string m_ShardName, m_PlayerName, m_AccountName;
        private static Dictionary<ushort, string> m_Servers;

        static World()
        {
            m_Servers = new Dictionary<ushort, string>();
            m_Items = new Dictionary<Serial, Item>();
            m_Mobiles = new Dictionary<Serial, Mobile>();
            m_ShardName = "[None]";
        }

        internal static Dictionary<ushort, string> Servers
        {
            get { return m_Servers; }
        }

        internal static Dictionary<Serial, Item> Items
        {
            get { return m_Items; }
        }

        internal static Dictionary<Serial, Mobile> Mobiles
        {
            get { return m_Mobiles; }
        }

        internal static Item FindItem(Serial serial)
        {
            m_Items.TryGetValue(serial, out Item it);
            return it;
        }

        internal static Item FindItemByType(int itemId)
        {
            foreach (KeyValuePair<Serial, Item> item in m_Items)
            {
                if (item.Value.ItemID.Value == itemId)
                    return item.Value;
            }

            return null;
        }

        internal static List<Item> FindItemsByName(string name)
        {
            List<Item> items = new List<Item>();

            foreach (KeyValuePair<Serial, Item> item in m_Items)
            {
                if (item.Value.ItemID.ItemData.Name.Equals(name, StringComparison.OrdinalIgnoreCase))
                    items.Add(item.Value);
            }

            return items;
        }

        internal static List<Item> FindItemsById(ushort id)
        {
            List<Item> items = new List<Item>();

            foreach (KeyValuePair<Serial, Item> item in m_Items)
            {
                if (item.Value.ItemID == id)
                    items.Add(item.Value);
            }

            return items;
        }

        internal static Mobile FindMobile(Serial serial)
        {
            m_Mobiles.TryGetValue(serial, out Mobile m);
            return m;
        }

        internal static List<Mobile> FindMobilesByName(string name)
        {
            List<Mobile> mobiles = new List<Mobile>();
            foreach (KeyValuePair<Serial, Mobile> item in m_Mobiles)
            {
                if (item.Value.Name.IndexOf(name, StringComparison.OrdinalIgnoreCase) != -1)
                    mobiles.Add(item.Value);
            }

            return mobiles;
        }

        internal static List<Mobile> MobilesInRange(int range)
        {
            List<Mobile> list = new List<Mobile>();

            if (World.Player == null)
                return list;

            foreach (Mobile m in World.Mobiles.Values)
            {
                if (Utility.InRange(World.Player.Position, m.Position, World.Player.VisRange))
                    list.Add(m);
            }

            return list;
        }

        internal static List<Mobile> MobilesInRange()
        {
            if (Player == null)
                return MobilesInRange(18);
            else
                return MobilesInRange(Player.VisRange);
        }

        internal static void AddItem(Item item)
        {
            m_Items[item.Serial] = item;
        }

        internal static void AddMobile(Mobile mob)
        {
            m_Mobiles[mob.Serial] = mob;
        }

        internal static void RequestMobileStatus(Mobile m)
        {
            Client.Instance.SendToServer(new StatusQuery(m));
        }

        internal static void RemoveMobile(Mobile mob)
        {
            m_Mobiles.Remove(mob.Serial);
        }

        internal static void RemoveItem(Item item)
        {
            m_Items.Remove(item.Serial);
        }

        internal static PlayerData Player
        {
            get { return m_Player; }
            set { m_Player = value; }
        }

        internal static string ShardName
        {
            get { return m_ShardName; }
            set { m_ShardName = value; }
        }

        internal static string OrigPlayerName
        {
            get { return m_PlayerName; }
            set { m_PlayerName = value; }
        }

        internal static string AccountName
        {
            get { return m_AccountName; }
            set { m_AccountName = value; }
        }
    }
}

================================================
FILE: Razor/Core/ZLib.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.IO;
using System.Runtime.InteropServices;

namespace Assistant
{
    public enum ZLibError : int
    {
        Z_OK = 0,
        Z_STREAM_END = 1,
        Z_NEED_DICT = 2,
        Z_ERRNO = (-1),
        Z_STREAM_ERROR = (-2),
        Z_DATA_ERROR = (-3), // Data was corrupt
        Z_MEM_ERROR = (-4), //  Not Enough Memory
        Z_BUF_ERROR = (-5), // Not enough buffer space
        Z_VERSION_ERROR = (-6)
    }

    [Flags]
    public enum ZLibCompressionLevel : int
    {
        Z_NO_COMPRESSION = 0,
        Z_BEST_SPEED = 1,
        Z_BEST_COMPRESSION = 9,
        Z_DEFAULT_COMPRESSION = (-1)
    }

    public class ZLib
    {
        [DllImport("zlib")]
        internal static extern string zlibVersion();

        [DllImport("zlib")]
        internal static extern ZLibError compress(byte[] dest, ref int destLength, byte[] source, int sourceLength);

        [DllImport("zlib")]
        internal static extern ZLibError compress2(byte[] dest, ref int destLength, byte[] source, int sourceLength,
            ZLibCompressionLevel level);

        [DllImport("zlib")]
        internal static extern ZLibError uncompress(byte[] dest, ref int destLen, byte[] source, int sourceLen);
    }

    // Be careful when writing raw data, as it may confuse the GZBlockIn if not accounted for when reading.
    // Seeking in the compressed stream is HIGHLY unrecommended
    // If you need to seek, use BufferAll to keep all data in the buffer, seek as much as you want, then
    // turn off BufferAll and flush the data to disk.
    // Once the data is flushed, you CANNOT seek back to it!
    public class GZBlockOut : Stream
    {
        private BinaryWriter m_Out;
        private MemoryStream m_Buffer;
        private BinaryWriter m_Self;
        private int m_BlockSize;
        private bool m_BufferAll;
        private bool m_IsCompressed;

        public override bool CanSeek
        {
            get { return false; }
        }

        public override bool CanRead
        {
            get { return false; }
        }

        public override bool CanWrite
        {
            get { return true; }
        }

        public override long Length
        {
            get { return RawStream.Length; }
        }

        public override long Position
        {
            get { return m_IsCompressed ? m_Buffer.Position : RawStream.Position; }
            set { }
        }

        public Stream RawStream
        {
            get { return m_Out.BaseStream; }
        }

        public BinaryWriter Raw
        {
            get { return m_Out; }
        }

        public BinaryWriter Compressed
        {
            get { return m_Self; }
        }

        public MemoryStream Buffer
        {
            get { return m_Buffer; }
        }

        public int BlockSize
        {
            get { return m_BlockSize; }
            set { m_BlockSize = value; }
        }

        public bool BufferAll
        {
            get { return m_BufferAll; }
            set { m_BufferAll = value; }
        }

        public bool IsCompressed
        {
            get { return m_IsCompressed; }
            set
            {
                ForceFlush();
                m_IsCompressed = value;
            }
        }

        public GZBlockOut(string filename, int blockSize)
        {
            m_IsCompressed = true;

            m_Out = new BinaryWriter(new FileStream(filename, FileMode.Create, FileAccess.ReadWrite, FileShare.None));
            m_BlockSize = blockSize;
            m_Buffer = new MemoryStream(blockSize + 1024);

            m_Self = new BinaryWriter(this);
        }

        public override void Write(byte[] buffer, int offset, int count)
        {
            if (m_IsCompressed)
            {
                m_Buffer.Write(buffer, offset, count);
                if (m_Buffer.Position >= m_BlockSize)
                    FlushBuffer();
            }
            else
            {
                RawStream.Write(buffer, offset, count);
            }
        }

        public override void WriteByte(byte value)
        {
            if (m_IsCompressed)
            {
                m_Buffer.WriteByte(value);
                if (m_Buffer.Position >= m_BlockSize)
                    FlushBuffer();
            }
            else
            {
                RawStream.WriteByte(value);
            }
        }

        private static byte[] m_CompBuff = null;

        public void FlushBuffer()
        {
            if (!m_IsCompressed || m_BufferAll || m_Buffer.Position <= 0)
                return;

            int outLen = (int) (m_Buffer.Position * 1.1);
            if (m_CompBuff == null || m_CompBuff.Length < outLen)
                m_CompBuff = new byte[outLen];
            else
                outLen = m_CompBuff.Length;

            ZLibError error = ZLib.compress2(m_CompBuff, ref outLen, m_Buffer.ToArray(), (int) m_Buffer.Position,
                ZLibCompressionLevel.Z_BEST_COMPRESSION);
            if (error != ZLibError.Z_OK)
                throw new Exception("ZLib error during copression: " + error.ToString());

            Raw.Write((int) outLen);
            Raw.Write((int) m_Buffer.Position);
            Raw.Write(m_CompBuff, 0, outLen);

            m_Buffer.Position = 0;
        }

        public override void Flush()
        {
            FlushBuffer();
            RawStream.Flush();
        }

        public void ForceFlush()
        {
            bool old = m_BufferAll;
            m_BufferAll = false;
            Flush();
            m_BufferAll = old;
        }

        public override long Seek(long offset, SeekOrigin origin)
        {
            if (m_IsCompressed)
                return m_Buffer.Seek(offset, origin);
            else
                return RawStream.Seek(offset, origin);
        }

        public override void SetLength(long value)
        {
            RawStream.SetLength(value);
        }

        public override int Read(byte[] buffer, int offset, int count)
        {
            return 0;
        }

        public override void Close()
        {
            ForceFlush();

            base.Close();
            m_Out.Close();
            m_Buffer.Close();
            m_Self = null;
        }
    }

    // Represents a block compressed stream written by GZBlockOut
    // If there is uncompressed data in the stream, you may seek to
    // it and read from is as you wish using Raw/RawStream.  If you have
    // not yet started reading compressed data, you must position rawstream
    // at the begining of the compressed data.  If you've already read
    // compressed data, you must reposition the file pointer back to its previous
    // position in the stream.  This is really important.
    //
    // Seeking in the compressed stream should be okay, DO NOT attempt to seek outside
    // of the compressed data.
    public class GZBlockIn : Stream
    {
        private MemoryStream m_Uncomp;
        private BinaryReader m_In;
        private BinaryReader m_Self;
        private bool m_Compressed;

        public Stream RawStream
        {
            get { return m_In.BaseStream; }
        }

        public BinaryReader Raw
        {
            get { return m_In; }
        }

        public BinaryReader Compressed
        {
            get { return m_Compressed ? m_Self : m_In; }
        }

        public bool IsCompressed
        {
            get { return m_Compressed; }
            set { m_Compressed = value; }
        }

        public override bool CanSeek
        {
            get { return true; }
        }

        public override bool CanRead
        {
            get { return true; }
        }

        public override bool CanWrite
        {
            get { return false; }
        }

        public override long Length
        {
            get
            {
                return m_Compressed
                    ? (RawStream.Position < RawStream.Length ? int.MaxValue : m_Uncomp.Length)
                    : RawStream.Length;
            }
        }

        public override long Position
        {
            get { return m_Compressed ? m_Uncomp.Position : RawStream.Position; }
            set
            {
                if (m_Compressed) m_Uncomp.Position = value;
                else RawStream.Position = value;
            }
        }

        public GZBlockIn(string filename)
        {
            m_Compressed = true;

            m_In = new BinaryReader(new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read));
            m_Uncomp = new MemoryStream();
            m_Self = new BinaryReader(this);
        }

        public override void Write(byte[] buffer, int offset, int count)
        {
        }

        public override void Flush()
        {
            RawStream.Flush();
            m_Uncomp.Flush();
        }

        private static byte[] m_ReadBuff = null;
        private static byte[] m_CompBuff = null;

        public override long Seek(long offset, SeekOrigin origin)
        {
            if (m_Compressed)
            {
                long absPos = offset;
                if (origin == SeekOrigin.Current)
                    absPos += m_Uncomp.Position;

                if (absPos < 0)
                    throw new Exception("Cannot seek past the begining of the stream.");

                long pos = m_Uncomp.Position;
                m_Uncomp.Seek(0, SeekOrigin.End);

                while ((origin == SeekOrigin.End || absPos >= m_Uncomp.Length) && RawStream.Position < RawStream.Length)
                {
                    int block = Raw.ReadInt32();
                    int ucLen = Raw.ReadInt32();
                    if (m_ReadBuff == null || m_ReadBuff.Length < block)
                        m_ReadBuff = new byte[block];

                    if (m_CompBuff == null || m_CompBuff.Length < ucLen)
                        m_CompBuff = new byte[ucLen];
                    else
                        ucLen = m_CompBuff.Length;

                    Raw.Read(m_ReadBuff, 0, block);

                    ZLibError error = ZLib.uncompress(m_CompBuff, ref ucLen, m_ReadBuff, block);
                    if (error != ZLibError.Z_OK)
                        throw new Exception("ZLib error uncompressing: " + error.ToString());

                    m_Uncomp.Write(m_CompBuff, 0, ucLen);
                }

                m_Uncomp.Position = pos;
                return m_Uncomp.Seek(offset, origin);
            }
            else
            {
                return RawStream.Seek(offset, origin);
            }
        }

        public override void SetLength(long value)
        {
        }

        public override int Read(byte[] buffer, int offset, int count)
        {
            if (m_Compressed)
            {
                long pos = m_Uncomp.Position;
                m_Uncomp.Seek(0, SeekOrigin.End);

                while (pos + count > m_Uncomp.Length && RawStream.Position + 8 < RawStream.Length)
                {
                    int block = Raw.ReadInt32();
                    int ucLen = Raw.ReadInt32();

                    if (block > 0x10000000 || block <= 0 || ucLen > 0x10000000 || ucLen <= 0)
                        break;

                    if (RawStream.Position + block > RawStream.Length)
                        break;

                    if (m_ReadBuff == null || m_ReadBuff.Length < block)
                        m_ReadBuff = new byte[block];

                    if (m_CompBuff == null || m_CompBuff.Length < ucLen)
                        m_CompBuff = new byte[ucLen];
                    else
                        ucLen = m_CompBuff.Length;

                    Raw.Read(m_ReadBuff, 0, block);

                    ZLibError error = ZLib.uncompress(m_CompBuff, ref ucLen, m_ReadBuff, block);
                    if (error != ZLibError.Z_OK)
                        throw new Exception("ZLib error uncompressing: " + error.ToString());

                    m_Uncomp.Write(m_CompBuff, 0, ucLen);
                }

                m_Uncomp.Position = pos;
                return m_Uncomp.Read(buffer, offset, count);
            }
            else
            {
                return RawStream.Read(buffer, offset, count);
            }
        }

        public override void Close()
        {
            m_In.Close();
            m_Uncomp.Close();
            m_Self = null;
        }

        public bool EndOfFile
        {
            get
            {
                return ((!m_Compressed || m_Uncomp.Position >= m_Uncomp.Length) &&
                        RawStream.Position >= RawStream.Length);
            }
        }
    }
}

================================================
FILE: Razor/Filters/Death.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

namespace Assistant.Filters
{
    public class DeathFilter : Filter
    {
        public static void Initialize()
        {
            Filter.Register(new DeathFilter());
        }

        private DeathFilter()
        {
        }

        public override byte[] PacketIDs
        {
            get { return new byte[] {0x2C}; }
        }

        public override LocString Name
        {
            get { return LocString.DeathStatus; }
        }

        public override void OnFilter(PacketReader p, PacketHandlerEventArgs args)
        {
            args.Block = true;
        }
    }
}

================================================
FILE: Razor/Filters/Filter.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections;
using System.Windows.Forms;
using System.Xml;

namespace Assistant.Filters
{
    public abstract class Filter
    {
        private static ArrayList m_Filters = new ArrayList();

        public static ArrayList List
        {
            get { return m_Filters; }
        }

        public static void Register(Filter filter)
        {
            m_Filters.Add(filter);
        }

        public static void Load(XmlElement xml)
        {
            DisableAll();

            if (xml == null)
                return;

            foreach (XmlElement el in xml.GetElementsByTagName("filter"))
            {
                try
                {
                    LocString name = (LocString) Convert.ToInt32(el.GetAttribute("name"));
                    string enable = el.GetAttribute("enable");

                    for (int i = 0; i < m_Filters.Count; i++)
                    {
                        Filter f = (Filter) m_Filters[i];
                        if (f.Name == name)
                        {
                            if (Convert.ToBoolean(enable))
                                f.OnEnable();
                            break;
                        }
                    }
                }
                catch
                {
                }
            }
        }

        public static void DisableAll()
        {
            for (int i = 0; i < m_Filters.Count; i++)
                ((Filter) m_Filters[i]).OnDisable();
        }

        public static void Save(XmlTextWriter xml)
        {
            for (int i = 0; i < m_Filters.Count; i++)
            {
                Filter f = (Filter) m_Filters[i];
                if (f.Enabled)
                {
                    xml.WriteStartElement("filter");
                    xml.WriteAttributeString("name", ((int) f.Name).ToString());
                    xml.WriteAttributeString("enable", f.Enabled.ToString());
                    xml.WriteEndElement();
                }
            }
        }

        public static void Draw(CheckedListBox list)
        {
            list.BeginUpdate();
            list.Items.Clear();

            for (int i = 0; i < m_Filters.Count; i++)
            {
                Filter f = (Filter) m_Filters[i];
                list.Items.Add(f);
                list.SetItemChecked(i, f.Enabled);
            }

            list.EndUpdate();
        }

        public abstract void OnFilter(PacketReader p, PacketHandlerEventArgs args);
        public abstract byte[] PacketIDs { get; }
        public abstract LocString Name { get; }

        public bool Enabled
        {
            get { return m_Enabled; }
        }

        private bool m_Enabled;
        private PacketViewerCallback m_Callback;

        protected Filter()
        {
            m_Enabled = false;
            m_Callback = new PacketViewerCallback(this.OnFilter);
        }

        public override string ToString()
        {
            return Language.GetString(this.Name);
        }

        public virtual void OnEnable()
        {
            m_Enabled = true;
            for (int i = 0; i < PacketIDs.Length; i++)
                PacketHandler.RegisterServerToClientViewer(PacketIDs[i], m_Callback);
        }

        public virtual void OnDisable()
        {
            m_Enabled = false;
            for (int i = 0; i < PacketIDs.Length; i++)
                PacketHandler.RemoveServerToClientViewer(PacketIDs[i], m_Callback);
        }

        public void OnCheckChanged(CheckState newValue)
        {
            if (Enabled && newValue == CheckState.Unchecked)
                OnDisable();
            else if (!Enabled && newValue == CheckState.Checked)
                OnEnable();
        }
    }
}

================================================
FILE: Razor/Filters/Light.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

namespace Assistant.Filters
{
    public class LightFilter : Filter
    {
        public static void Initialize()
        {
            Filter.Register(new LightFilter());
        }

        private LightFilter()
        {
        }

        public override byte[] PacketIDs
        {
            get { return new byte[] {0x4E, 0x4F}; }
        }

        public override LocString Name
        {
            get { return LocString.LightFilter; }
        }

        public override void OnFilter(PacketReader p, PacketHandlerEventArgs args)
        {
            if (Client.Instance.AllowBit(FeatureBit.LightFilter))
            {
                args.Block = true;
                if (World.Player != null)
                {
                    World.Player.LocalLightLevel = 0;
                    World.Player.GlobalLightLevel = 0;
                }
            }
        }

        public override void OnEnable()
        {
            base.OnEnable();

            if (Client.Instance.AllowBit(FeatureBit.LightFilter) && World.Player != null)
            {
                World.Player.LocalLightLevel = 0;
                World.Player.GlobalLightLevel = 0;

                Client.Instance.SendToClient(new GlobalLightLevel(0));
                Client.Instance.SendToClient(new PersonalLightLevel(World.Player));
            }
        }

        public override void OnDisable()
        {
            base.OnDisable();

            if (Client.Instance.AllowBit(FeatureBit.LightFilter) && World.Player != null)
            {
                World.Player.LocalLightLevel = 6;
                World.Player.GlobalLightLevel = 2;

                Client.Instance.SendToClient(new GlobalLightLevel(26));
                Client.Instance.SendToClient(new PersonalLightLevel(World.Player));
            }
        }
    }
}

================================================
FILE: Razor/Filters/MessageFilter.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

namespace Assistant.Filters
{
    public class AsciiMessageFilter : Filter
    {
        private LocString m_Name;
        private string[] m_Strings;
        private MessageType m_Type;

        private AsciiMessageFilter(LocString name, MessageType type, string[] msgs)
        {
            m_Name = name;
            m_Strings = msgs;
            m_Type = type;
        }

        public override byte[] PacketIDs
        {
            get { return new byte[] {0x1C}; }
        }

        public override LocString Name
        {
            get { return m_Name; }
        }

        public override void OnFilter(PacketReader p, PacketHandlerEventArgs args)
        {
            if (args.Block)
                return;

            // 0, 1, 2
            Serial serial = p.ReadUInt32(); // 3, 4, 5, 6
            ushort body = p.ReadUInt16(); // 7, 8
            MessageType type = (MessageType) p.ReadByte(); // 9

            if (type != m_Type)
                return;

            ushort hue = p.ReadUInt16(); // 10, 11
            ushort font = p.ReadUInt16();
            string name = p.ReadStringSafe(30);
            string text = p.ReadStringSafe();

            for (int i = 0; i < m_Strings.Length; i++)
            {
                if (text.IndexOf(m_Strings[i]) != -1)
                {
                    args.Block = true;
                    return;
                }
            }
        }
    }

    public class LocMessageFilter : Filter
    {
        public static void Initialize()
        {
        }

        private LocString m_Name;
        private int[] m_Nums;
        private MessageType m_Type;

        private LocMessageFilter(LocString name, MessageType type, int[] msgs)
        {
            m_Name = name;
            m_Nums = msgs;
            m_Type = type;
        }

        public override byte[] PacketIDs
        {
            get { return new byte[] {0xC1}; }
        }

        public override LocString Name
        {
            get { return m_Name; }
        }

        public override void OnFilter(PacketReader p, PacketHandlerEventArgs args)
        {
            if (args.Block)
                return;

            Serial serial = p.ReadUInt32();
            ushort body = p.ReadUInt16();
            MessageType type = (MessageType) p.ReadByte();
            ushort hue = p.ReadUInt16();
            ushort font = p.ReadUInt16();
            int num = p.ReadInt32();

            // paladin spells
            if (num >= 1060718 && num <= 1060727)
                type = MessageType.Spell;
            if (type != m_Type)
                return;

            for (int i = 0; i < m_Nums.Length; i++)
            {
                if (num == m_Nums[i])
                {
                    args.Block = true;
                    return;
                }
            }
        }
    }
}

================================================
FILE: Razor/Filters/MobileFilter.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System.IO;

namespace Assistant.Filters
{
    public static class MobileFilter
    {
        private static ushort[] _filters;

        public static void Load()
        {
            _filters = new ushort[4];
            _filters[0] = (ushort) Config.GetInt("DragonGraphic");
            _filters[1] = (ushort) Config.GetInt("DrakeGraphic");
            _filters[2] = (ushort) Config.GetInt("DaemonGraphic");
            _filters[3] = (ushort) Config.GetInt("WyrmGraphic");
        }

        public static void Apply(Packet p, Mobile m)
        {
            Apply(p, m.Body);
        }

        public static void Apply(Packet p, ushort body)
        {
            if ((body == 0xC || body == 0x3B) && Config.GetBool("FilterDragonGraphics"))
            {
                p.Seek(-2, SeekOrigin.Current);
                p.Write(_filters[0]);
            }
            else if ((body == 0x3C || body == 0x3D) && Config.GetBool("FilterDrakeGraphics"))
            {
                p.Seek(-2, SeekOrigin.Current);
                p.Write(_filters[1]);
            }
            else if (body == 0x9 && Config.GetBool("FilterDaemonGraphics"))
            {
                p.Seek(-2, SeekOrigin.Current);
                p.Write(_filters[2]);
            }
            else if ((body == 0x31 || body == 0xB4) && Config.GetBool("FilterWyrmGraphics"))
            {
                p.Seek(-2, SeekOrigin.Current);
                p.Write(_filters[3]);
            }
        }

        private static int Get(ushort body)
        {
            switch (body)
            {
                case 0xC:
                case 0x3B:
                    return _filters[0];
                case 0x3C:
                case 0x3D:
                    return _filters[1];
                case 0x9:
                    return _filters[2];
                case 0x31:
                case 0xB4:
                    return _filters[3];
                default:
                    return body;
            }
        }

        public static void ApplyToMobiles()
        {
            foreach (Mobile mobile in World.MobilesInRange())
            {
                ushort body = (ushort)Get(mobile.Body);

                if (mobile.Body != body)
                {
                    mobile.Body = body;
                    Client.Instance.SendToClient(new MobileIncoming(mobile));
                }
            }
        }
    }
}

================================================
FILE: Razor/Filters/SoundFilters.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

namespace Assistant.Filters
{
    public class SoundFilter : Filter
    {
        public static void Initialize()
        {
            Filter.Register(new SoundFilter(LocString.BardMusic, 0x38, 0x39, 0x43, 0x44, 0x45, 0x46, 0x4C, 0x4D, 0x52,
                0x53));
            Filter.Register(new SoundFilter(LocString.DogSounds, GetRange(0x85, 0x89)));
            Filter.Register(new SoundFilter(LocString.CatSounds, GetRange(0x69, 0x6D)));
            Filter.Register(new SoundFilter(LocString.HorseSounds, GetRange(0xA8, 0xAC)));
            Filter.Register(new SoundFilter(LocString.SheepSounds, GetRange(0xD6, 0xDA)));
            Filter.Register(new SoundFilter(LocString.SS_Sound, 0x24A));
            Filter.Register(new SoundFilter(LocString.FizzleSound, 0x5C));
            Filter.Register(new SoundFilter(LocString.PackSound, 0x48));
            Filter.Register(new SoundFilter(LocString.DeerSounds, 0x82, 0x83, 0x84, 0x85, 0x2BE, 0x2BF, 0x2C0, 0x4CB,
                0x4CC));
            Filter.Register(new SoundFilter(LocString.CyclopTitanSounds, 0x25D, 0x25E, 0x25F, 0x260, 0x261, 0x262,
                0x263, 0x264, 0x265, 0x266));
            Filter.Register(new SoundFilter(LocString.BullSounds, 0x065, 0x066, 0x067, 0x068, 0x069));

            Filter.Register(new SoundFilter(LocString.DragonSounds, 0x2C8, 0x2C9, 0x2CA, 0x2CB, 0x2CC, 0x2CD, 0x2CE,
                0x2CF,
                0x2D0, 0x2D1, 0x2D2, 0x2D3, 0x2D4, 0x2D5, 0x2D6, 0x16B, 0x16C, 0x16D, 0x16E, 0x16F, 0x15F, 0x160,
                0x161));

            Filter.Register(new SoundFilter(LocString.ChickenSounds, 0x06F, 0x070, 0x071, 0x072, 0x073));

            Filter.Register(new SoundFilter(LocString.BirdSounds, 0x017, 0x018, 0x019, 0x01A, 0x01B, 0x01C, 0x01D,
                0x01E, 0x01F, 0x270, 0x271, 0x272, 0x273, 0x274, 0x29B, 0x275, 0x29C, 0x276, 0x29D, 0x277, 0x29E, 0x278,
                0x29F, 0x279, 0x2A0));
        }

        public static ushort[] GetRange(ushort min, ushort max)
        {
            if (max < min)
                return new ushort[0];

            ushort[] range = new ushort[max - min + 1];
            for (ushort i = min; i <= max; i++)
                range[i - min] = i;
            return range;
        }

        private LocString m_Name;
        private ushort[] m_Sounds;

        private SoundFilter(LocString name, params ushort[] blockSounds)
        {
            m_Name = name;
            m_Sounds = blockSounds;
        }

        public override byte[] PacketIDs
        {
            get { return new byte[] {0x54}; }
        }

        public override LocString Name
        {
            get { return m_Name; }
        }

        public override void OnFilter(PacketReader p, PacketHandlerEventArgs args)
        {
            p.ReadByte(); // flags

            ushort sound = p.ReadUInt16();
            for (int i = 0; i < m_Sounds.Length; i++)
            {
                if (m_Sounds[i] == sound)
                {
                    args.Block = true;
                    return;
                }
            }
        }
    }
}

================================================
FILE: Razor/Filters/SoundMusicManager.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Windows.Forms;
using System.Xml;
using Assistant.UI;

namespace Assistant.Filters
{
    public static class SoundMusicManager
    {
        private static CheckedListBox _soundFilterList;
        private static ComboBox _playableMusicList;

        private static List<Sound> SoundFilters = new List<Sound>();
        private static List<Sound> SoundList = new List<Sound>();

        private static List<Music> MusicList = new List<Music>();

        public static void SetControls(CheckedListBox soundFilterList, ComboBox playableMusicList)
        {
            _soundFilterList = soundFilterList;
            _playableMusicList = playableMusicList;
        }

        public class Sound
        {
            public string Name { get; set; }
            public Serial Serial { get; set; }

            public override string ToString()
            {
                return $"{Name} ({Serial})";
            }
        }

        public class Music
        {
            public string Name { get; set; }
            public int Id { get; set; }
            public bool Loop { get; set; }

            public override string ToString()
            {
                return $"{Name} ({Id})";
            }
        }

        public static bool IsFilteredSound(Serial serial, out string name)
        {
            foreach (Sound filter in SoundFilters)
            {
                if (filter.Serial == serial)
                {
                    name = filter.Name;
                    return true;
                }
            }

            name = string.Empty;
            return false;
        }

        public static bool IsFilteredSound(ushort serial, out string name)
        {
            foreach (Sound filter in SoundFilters)
            {
                if (filter.Serial == serial)
                {
                    name = filter.Name;
                    return true;
                }
            }

            name = string.Empty;
            return false;
        }

        public static string GetSoundName(ushort soundId)
        {
            if (SoundList.Count == 0)
                RedrawList();

            foreach (Sound sound in SoundList)
            {
                if (sound.Serial == soundId)
                {
                    return sound.Name;
                }
            }

            return "(unknown)";
        }
        
        public static int GetSoundId(string name)
        {
            if (SoundList.Count == 0)
                RedrawList();

            foreach (Sound sound in SoundList)
            {
                if (sound.Name.Equals(name))
                {
                    return sound.Serial;
                }
            }

            return Serial.MinusOne;
        }

        public static List<Sound> GetAllSounds()
        {
            if (SoundList.Count == 0)
                RedrawList();

            return SoundList;
        }

        public static string GetMusicName(int musicId, out bool loop)
        {
            if (MusicList.Count == 0)
                RedrawList();

            foreach (Music music in MusicList)
            {
                if (music.Id == musicId)
                {
                    loop = music.Loop;
                    return music.Name;
                }
            }

            loop = false;
            return "(unknown)";
        }

        public static void AddSoundFilter(Sound filter)
        {
            int index = SoundFilters.FindIndex(x => x.Name == filter.Name && x.Serial == filter.Serial);

            if (index < 0)
            {
                SoundFilters.Add(filter);
            }
        }

        public static void RemoveSoundFilter(Sound filter)
        {
            int index = SoundFilters.FindIndex(x => x.Name == filter.Name && x.Serial == filter.Serial);

            if (index >= 0)
            {
                SoundFilters.RemoveAt(index);
            }
        }

        public static void LoadMusic()
        {
            MusicList.Clear();

            if (File.Exists($"{Client.Instance.GetUoFilePath()}\\Music\\Digital\\Config.txt"))
            {
                string[] musicInfo =
                    File.ReadAllLines($"{Client.Instance.GetUoFilePath()}\\Music\\Digital\\Config.txt");

                foreach (string music in musicInfo)
                {
                    if (music.StartsWith("#"))
                    {
                        continue;
                    }

                    string[] parsedMusic = music.Split(' ');

                    try
                    {
                        MusicList.Add(new Music
                        {
                            Id = Convert.ToInt32(parsedMusic[0]),
                            Name = parsedMusic[1].Split(',')[0],
                            Loop = parsedMusic[1].Contains(",") && parsedMusic[1].Split(',')[1].Equals("loop")
                        });
                    }
                    catch
                    {
                        // ignored, just don't load that line
                    }
                }
            }
            else
            {
                MusicList.Add(new Music
                {
                    Id = 0,
                    Name = "oldult01",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 1,
                    Name = "create1",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 2,
                    Name = "dragflit",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 3,
                    Name = "oldult02",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 4,
                    Name = "oldult03",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 5,
                    Name = "oldult04",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 6,
                    Name = "oldult05",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 7,
                    Name = "oldult06",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 8,
                    Name = "stones2",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 9,
                    Name = "britain1",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 10,
                    Name = "britain2",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 11,
                    Name = "bucsden",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 12,
                    Name = "jhelom",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 13,
                    Name = "lbcastle",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 14,
                    Name = "linelle",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 15,
                    Name = "magincia",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 16,
                    Name = "minoc",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 17,
                    Name = "ocllo",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 18,
                    Name = "samlethe",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 19,
                    Name = "serpents",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 20,
                    Name = "skarabra",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 21,
                    Name = "trinsic",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 22,
                    Name = "vesper",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 23,
                    Name = "wind",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 24,
                    Name = "yew",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 25,
                    Name = "cave01",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 26,
                    Name = "dungeon9",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 27,
                    Name = "forest_a",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 28,
                    Name = "intown01",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 29,
                    Name = "jungle_a",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 30,
                    Name = "mountn_a",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 31,
                    Name = "plains_a",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 32,
                    Name = "sailing",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 33,
                    Name = "swamp_a",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 34,
                    Name = "tavern01",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 35,
                    Name = "tavern02",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 36,
                    Name = "tavern03",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 37,
                    Name = "tavern04",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 38,
                    Name = "combat1",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 39,
                    Name = "combat2",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 40,
                    Name = "combat3",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 41,
                    Name = "approach",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 42,
                    Name = "death",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 43,
                    Name = "victory",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 44,
                    Name = "btcastle",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 45,
                    Name = "nujelm",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 46,
                    Name = "dungeon2",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 47,
                    Name = "cove",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 48,
                    Name = "moonglow",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 49,
                    Name = "zento",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 50,
                    Name = "tokunodungeon",
                    Loop = false
                });


                MusicList.Add(new Music
                {
                    Id = 51,
                    Name = "Taiko",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 52,
                    Name = "dreadhornarea",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 53,
                    Name = "elfcity",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 54,
                    Name = "grizzledungeon",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 55,
                    Name = "melisandeslair",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 56,
                    Name = "paroxysmuslair",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 57,
                    Name = "gwennoconversation",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 58,
                    Name = "goodendgame",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 59,
                    Name = "goodvsevil",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 60,
                    Name = "greatearthserpents",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 61,
                    Name = "humanoids_u9",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 62,
                    Name = "minocnegative",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 63,
                    Name = "paws",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 64,
                    Name = "selimsbar",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 65,
                    Name = "serpentislecombat_u7",
                    Loop = false
                });

                MusicList.Add(new Music
                {
                    Id = 66,
                    Name = "valoriaships",
                    Loop = false
                });
            }
        }

        public static void LoadSounds()
        {
            SoundList.Clear();

            for (int i = 0; i <= 0xFFE; ++i)
            {
                if (Ultima.Sounds.IsValidSound(i, out string wavName))
                {
                    Serial serial = Serial.Parse($"0x{i:X3}");

                    Sound sound = new Sound
                    {
                        Name = wavName,
                        Serial = serial
                    };

                    SoundList.Add(sound);
                }
            }

            SoundList = SoundList.OrderBy(s => s.Name).ToList();
        }

        public static void Save(XmlTextWriter xml)
        {
            foreach (var filter in SoundFilters)
            {
                xml.WriteStartElement("soundfilter");
                xml.WriteAttributeString("name", filter.Name);
                xml.WriteAttributeString("serial", filter.Serial.ToString());
                xml.WriteEndElement();
            }
        }

        public static void Load(XmlElement node)
        {
            ClearAll();

            try
            {
                foreach (XmlElement el in node.GetElementsByTagName("soundfilter"))
                {
                    try
                    {
                        Sound filter = new Sound
                        {
                            Name = el.GetAttribute("name"),
                            Serial = Serial.Parse(el.GetAttribute("serial")),
                        };

                        SoundFilters.Add(filter);
                    }
                    catch
                    {
                        // bad entry, ignore
                    }
                }
            }
            catch
            {
                // must not be in the profile, move on
            }

            RedrawList();
        }

        public static void ClearAll()
        {
            SoundFilters.Clear();
        }

        public static void RedrawList()
        {
            _soundFilterList?.SafeAction(s =>
            {
                s.BeginUpdate();
                s.Items.Clear();

                if (SoundList.Count == 0)
                {
                    LoadSounds();
                }

                foreach (Sound sound in SoundList)
                {
                    bool isFiltered = IsFilteredSound(sound.Serial, out string name);
                    s.Items.Add(sound, isFiltered);
                }

                s.EndUpdate();
            });

            _playableMusicList?.SafeAction(s =>
            {
                s.BeginUpdate();
                s.Items.Clear();

                if (MusicList.Count == 0)
                {
                    LoadMusic();
                }

                foreach (Music music in MusicList)
                {
                    s.Items.Add(music);
                }

                s.SelectedIndex = 0;
                s.EndUpdate();
            });
        }
    }
}

================================================
FILE: Razor/Filters/StaffItems.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

namespace Assistant.Filters
{
    public class StaffItemFilter : Filter
    {
        public static void Initialize()
        {
            Filter.Register(new StaffItemFilter());
        }

        private StaffItemFilter()
        {
        }

        public override byte[] PacketIDs
        {
            get { return new byte[] {0x1A}; }
        }

        public override LocString Name
        {
            get { return LocString.StaffOnlyItems; }
        }

        private static bool IsStaffItem(ItemID itemID)
        {
            return (
                itemID == 0x36FF || // LOS blocker
                itemID == 0x1183 // Movement blocker
            );
        }

        private static bool IsStaffItem(Item i)
        {
            return i.OnGround && (IsStaffItem(i.ItemID) || !i.Visible);
        }

        public override void OnFilter(PacketReader p, PacketHandlerEventArgs args)
        {
            uint serial = p.ReadUInt32();
            ushort itemID = p.ReadUInt16();

            if ((serial & 0x80000000) != 0)
                p.ReadUInt16(); // amount

            if ((itemID & 0x8000) != 0)
                itemID = (ushort) ((itemID & 0x7FFF) + p.ReadSByte()); // itemID offset

            ushort x = p.ReadUInt16();
            ushort y = p.ReadUInt16();

            if ((x & 0x8000) != 0)
                p.ReadByte(); // direction

            short z = p.ReadSByte();

            if ((y & 0x8000) != 0)
                p.ReadUInt16(); // hue

            bool visable = true;
            if ((y & 0x4000) != 0)
            {
                int flags = p.ReadByte();

                visable = ((flags & 0x80) == 0);
            }

            if (IsStaffItem(itemID) || !visable)
                args.Block = true;
        }

        public override void OnEnable()
        {
            base.OnEnable();

            if (World.Player != null)
            {
                foreach (Item i in World.Items.Values)
                {
                    if (IsStaffItem(i))
                        Client.Instance.SendToClient(new RemoveObject(i));
                }
            }
        }

        public override void OnDisable()
        {
            base.OnDisable();

            if (World.Player != null)
            {
                foreach (Item i in World.Items.Values)
                {
                    if (IsStaffItem(i))
                        Client.Instance.SendToClient(new WorldItem(i));
                }
            }
        }
    }
}

================================================
FILE: Razor/Filters/TargetFilterManager.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
using System.Xml;
using Assistant.Core;
using Assistant.UI;

namespace Assistant.Filters
{
    public static class TargetFilterManager
    {
        private static ListBox _targetFilterList;

        private static List<TargetFilter> TargetFilters = new List<TargetFilter>();

        public static void SetControls(ListBox targetFilterList)
        {
            _targetFilterList = targetFilterList;
        }

        public static void OnTargetAddTargetFilter()
        {
            World.Player.SendMessage(MsgLevel.Friend, "Target mobile to be filtered");
            Targeting.OneTimeTarget(OnAddFriendTargetFilter);
        }

        public static void OnAddFriendTargetFilter(bool location, Serial serial, Point3D loc, ushort gfx)
        {
            Engine.MainWindow.SafeAction(s => s.ShowMe());

            if (!location && serial.IsMobile && serial != World.Player.Serial)
            {
                Mobile m = World.FindMobile(serial);

                if (m == null)
                    return;

                AddTargetFilter(m.Name, serial);

                RedrawList();
            }
        }

        public class TargetFilter
        {
            public string Name { get; set; }
            public Serial Serial { get; set; }

            public override string ToString()
            {
                return $"{Name} ({Serial})";
            }
        }

        public static void AddTargetFilter(string name, Serial serial)
        {
            if (TargetFilters.Any(f => f.Serial == serial) == false)
            {
                if (FriendsManager.IsFriend(serial))
                {
                    World.Player.SendMessage(MsgLevel.Warning,
                        $"'{name}' ({serial}) is a friend, not adding to target filter list");
                    return;
                }

                TargetFilter newFilter = new TargetFilter
                {
                    Name = name,
                    Serial = serial
                };

                TargetFilters.Add(newFilter);

                World.Player.SendMessage(MsgLevel.Info, $"Added '{name}' ({serial}) to the target filter list");
            }
            else
            {
                World.Player.SendMessage(MsgLevel.Warning, $"'{name}' ({serial}) is already on the target filter");
            }
        }

        public static void AddAllMobileAsTargetFilters()
        {
            List<Mobile> mobiles = World.MobilesInRange(12);

            foreach (Mobile mobile in mobiles)
            {
                if (!FriendsManager.IsFriend(mobile.Serial) && mobile.Serial.IsMobile &&
                    mobile.Serial != World.Player.Serial)
                {
                    AddTargetFilter(mobile.Name, mobile.Serial);
                    /*if (AddTargetFilter(mobile.Name, mobile.Serial))
                    {
                        mobile.ObjPropList.Add(Language.GetString(LocString.RazorFriend));
                        mobile.OPLChanged();
                    }*/
                }
            }
        }

        public static void AddAllHumanoidsAsTargetFilters()
        {
            List<Mobile> mobiles = World.MobilesInRange(12);

            foreach (Mobile mobile in mobiles)
            {
                if (!FriendsManager.IsFriend(mobile.Serial) && mobile.Serial.IsMobile &&
                    mobile.Serial != World.Player.Serial &&
                    mobile.IsHuman)
                {
                    AddTargetFilter(mobile.Name, mobile.Serial);
                    /*if (AddFriend(mobile.Name, mobile.Serial))
                    {
                        mobile.ObjPropList.Add(Language.GetString(LocString.RazorFriend));
                        mobile.OPLChanged();
                    }*/
                }
            }
        }

        public static bool IsFilteredTarget(Serial serial)
        {
            if (!Config.GetBool("TargetFilterEnabled"))
                return false;

            foreach (var filter in TargetFilters)
            {
                if (filter.Serial == serial)
                {
                    return true;
                }
            }

            return false;
        }

        public static bool RemoveTargetFilter(int index)
        {
            TargetFilters.RemoveAt(index);
            RedrawList();

            return true;
        }

        public static void ClearTargetFilters()
        {
            TargetFilters.Clear();
            RedrawList();
        }

        public static void Save(XmlTextWriter xml)
        {
            foreach (var filter in TargetFilters)
            {
                xml.WriteStartElement("targetfilter");
                xml.WriteAttributeString("name", filter.Name);
                xml.WriteAttributeString("serial", filter.Serial.ToString());
                xml.WriteEndElement();
            }
        }

        public static void Load(XmlElement node)
        {
            ClearAll();

            try
            {
                foreach (XmlElement el in node.GetElementsByTagName("targetfilter"))
                {
                    try
                    {
                        TargetFilter filter = new TargetFilter
                        {
                            Name = el.GetAttribute("name"),
                            Serial = Serial.Parse(el.GetAttribute("serial"))
                        };

                        TargetFilters.Add(filter);
                    }
                    catch
                    {
                        // bad entry, ignore
                    }
                }
            }
            catch
            {
                // must not be in the profile, move on
            }

            RedrawList();
        }

        public static void ClearAll()
        {
            TargetFilters.Clear();
        }

        public static void RedrawList()
        {
            _targetFilterList?.SafeAction(s =>
            {
                s.BeginUpdate();
                s.Items.Clear();

                foreach (var target in TargetFilters)
                {
                    s.Items.Add(target);
                }

                s.EndUpdate();
            });
        }
    }
}

================================================
FILE: Razor/Filters/VetRewardGump.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;

namespace Assistant.Filters
{
    public class VetRewardGumpFilter : Filter
    {
        // 1006046 = You have reward items available.  Click 'ok' below to get the selection menu or 'cancel' to be prompted upon your next login.
        private static string m_VetRewardStr = "{ xmfhtmlgump 52 35 420 55 1006046 1 1 }";

        public static void Initialize()
        {
            Filter.Register(new VetRewardGumpFilter());
        }

        private VetRewardGumpFilter()
        {
        }

        public override byte[] PacketIDs
        {
            get { return new byte[] {0xB0, 0xDD}; }
        }

        public override LocString Name
        {
            get { return LocString.VetRewardGump; }
        }

        public override void OnFilter(PacketReader p, PacketHandlerEventArgs args)
        {
            // completely skip this filter if we've been connected for more thn 1 minute
            if (Client.Instance.ConnectionStart + TimeSpan.FromMinutes(1.0) < DateTime.UtcNow)
                return;

            try
            {
                p.Seek(0, System.IO.SeekOrigin.Begin);
                byte packetID = p.ReadByte();

                p.MoveToData();

                uint ser = p.ReadUInt32();
                uint tid = p.ReadUInt32();
                int x = p.ReadInt32();
                int y = p.ReadInt32();
                string layout = null;

                if (packetID == 0xDD)
                {
                    layout = p.GetCompressedReader().ReadString();
                }
                else
                {
                    ushort layoutLength = p.ReadUInt16();
                    layout = p.ReadString(layoutLength);
                }

                if (layout != null && layout.IndexOf(m_VetRewardStr) != -1)
                    args.Block = true;
            }
            catch
            {
            }
        }
    }
}

================================================
FILE: Razor/Filters/WallStaticFilter.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

namespace Assistant.Filters
{
    public class WallStaticFilter
    {
        const ushort WallStaticID = 0x28A8;
        const ushort WallStaticIDStone = 0x0750;

        internal enum WallColor : ushort
        {
            Stone = 0x3B1,
            Fire = 0x0845,
            Poison = 0x016A,
            Paralyze = 0x00DA,
            Energy = 0x0125
        }

        internal static bool MakeWallStatic(Assistant.Item wall)
        {
            switch (wall.ItemID)
            {
                case 0x0080:
                case 0x0082:
                    wall.ItemID = WallStaticIDStone;
                    wall.Hue = (ushort) WallColor.Stone;
                    Client.Instance.SendToClient(new WorldItem(wall));
                    if (Config.GetBool("ShowStaticWallLabels"))
                        Client.Instance.SendToClient(new UnicodeMessage(wall.Serial, wall.ItemID, MessageType.Regular,
                            (ushort) WallColor.Stone, 3, Language.CliLocName, wall.Name, "[Wall Of Stone]"));
                    return true;
                case 0x3996:
                case 0x398C:
                    wall.ItemID = WallStaticID;
                    wall.Hue = (ushort) WallColor.Fire;
                    Client.Instance.SendToClient(new WorldItem(wall));
                    if (Config.GetBool("ShowStaticWallLabels"))
                        Client.Instance.SendToClient(new UnicodeMessage(wall.Serial, wall.ItemID, MessageType.Regular,
                            (ushort) WallColor.Fire, 3, Language.CliLocName, wall.Name, "[Fire Field]"));
                    return true;
                case 0x3915:
                case 0x3920:
                case 0x3922:
                    wall.ItemID = WallStaticID;
                    wall.Hue = (ushort) WallColor.Poison;
                    Client.Instance.SendToClient(new WorldItem(wall));
                    if (Config.GetBool("ShowStaticWallLabels"))
                        Client.Instance.SendToClient(new UnicodeMessage(wall.Serial, wall.ItemID, MessageType.Regular,
                            (ushort) WallColor.Poison, 3, Language.CliLocName, wall.Name, "[Poison Field]"));
                    return true;
                case 0x3967:
                case 0x3979:
                    wall.ItemID = WallStaticID;
                    wall.Hue = (ushort) WallColor.Paralyze;
                    Client.Instance.SendToClient(new WorldItem(wall));
                    if (Config.GetBool("ShowStaticWallLabels"))
                        Client.Instance.SendToClient(new UnicodeMessage(wall.Serial, wall.ItemID, MessageType.Regular,
                            (ushort) WallColor.Paralyze, 3, Language.CliLocName, wall.Name, "[Paralyze Field]"));
                    return true;
                case 0x3946:
                case 0x3956:
                    wall.ItemID = WallStaticID;
                    wall.Hue = (ushort) WallColor.Energy;
                    Client.Instance.SendToClient(new WorldItem(wall));
                    if (Config.GetBool("ShowStaticWallLabels"))
                        Client.Instance.SendToClient(new UnicodeMessage(wall.Serial, wall.ItemID, MessageType.Regular,
                            (ushort) WallColor.Energy, 3, Language.CliLocName, wall.Name, "[Energy Field]"));
                    return true;
                default:
                    return false;
            }
        }
    }
}

================================================
FILE: Razor/Filters/Weather.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

namespace Assistant.Filters
{
    public class WeatherFilter : Filter
    {
        public static void Initialize()
        {
            Filter.Register(new WeatherFilter());
        }

        private WeatherFilter()
        {
        }

        public override byte[] PacketIDs
        {
            get { return new byte[] {0x65}; }
        }

        public override LocString Name
        {
            get { return LocString.Weather; }
        }

        public override void OnFilter(PacketReader p, PacketHandlerEventArgs args)
        {
            if (Client.Instance.AllowBit(FeatureBit.WeatherFilter))
                args.Block = true;
        }
    }
}

================================================
FILE: Razor/Gumps/Gump.cs
================================================
#region license
/* Copyright (C) 2009 Matthew Geyer
 * 
 * This file is part of UO Machine.
 * 
 * UO Machine is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * UO Machine is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with UO Machine.  If not, see <http://www.gnu.org/licenses/>. */
#endregion

using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using Assistant.Core.Gumps;
using Assistant.Network;

namespace Assistant.Gumps
{
    public class Gump
    {
        private static readonly Random _random = new Random();

        private static readonly byte[] BeginLayout = StringToBuffer("{ ");
        private static readonly byte[] EndLayout = StringToBuffer(" }");

        private static readonly byte[] NoMove = StringToBuffer("{ nomove }");
        private static readonly byte[] NoClose = StringToBuffer("{ noclose }");
        private static readonly byte[] NoDispose = StringToBuffer("{ nodispose }");
        private static readonly byte[] NoResize = StringToBuffer("{ noresize }");

        private static readonly byte[] True = StringToBuffer(" 1");
        private static readonly byte[] False = StringToBuffer(" 0");

        private static readonly byte[] BeginTextSeparator = StringToBuffer(" @");
        private static readonly byte[] EndTextSeparator = StringToBuffer("@");

        public readonly string Layout;
        public readonly GumpPage[] Pages;

        private List<GumpElement> _elements;
        private List<string> _strings;
        public int Serial;
        public int X;
        public int Y;

        public Gump(int x, int y, uint id, int serial, string layout, string[] strings, GumpElement[] elements,
            GumpPage[] pages)
        {
            X = x;
            Y = y;
            ID = id;
            Serial = serial;
            Layout = layout;
            Strings = strings;
            GumpElements = elements;
            Pages = pages;

            foreach (GumpPage gp in pages)
            {
                gp.ParentGump = this;
            }
        }

        public Gump(int x, int y, int serial = 0, uint id = 0)
        {
            X = x;
            Y = y;

            Serial = serial;
            ID = id;

            string fullName = GetType().FullName;

            if (ID == 0 && fullName != null)
            {
                ID = (uint) fullName.GetHashCode();
            }

            if (Serial == 0 && fullName != null)
            {
                uint hashCode = (uint) fullName.GetHashCode();

                hashCode &= 0x0000FFFF;
                hashCode <<= 8;
                hashCode |= (uint) 0xFF << 24;

                Serial = (int) (hashCode + _random.Next(0, 0xFF));
            }

            _elements = new List<GumpElement>();
            _strings = new List<string>();
        }

        public bool Closable { get; set; }

        public bool Disposable { get; set; }

        public GumpElement[] GumpElements
        {
            get => _elements.ToArray();
            set
            {
                _elements = new List<GumpElement>();

                for (int i = 0; i < value.Length; i++)
                {
                    _elements.Add(value[i]);
                }
            }
        }

        public uint ID { get; }

        public bool Movable { get; set; }

        public bool Resizable { get; set; }

        public bool Resend { get; set; }

        public string[] Strings
        {
            get => _strings.ToArray();
            set
            {
                _strings = new List<string>();

                for (int i = 0; i < value.Length; i++)
                {
                    _strings.Add(value[i]);
                }
            }
        }

        /// <summary>
        ///     Get array of GumpElements which match the specified ElementType from all pages.
        /// </summary>
        public GumpElement[] GetElementsByType(ElementType type)
        {
            List<GumpElement> elementList = new List<GumpElement>();

            if (GumpElements != null)
            {
                elementList.AddRange(GumpElements.Where(ge => ge.Type == type));
            }

            if (Pages != null)
            {
                elementList.AddRange(from p in Pages from ge in p.GumpElements where ge.Type == type select ge);
            }

            return elementList.ToArray();
        }

        /// <summary>
        ///     Get the GumpElement with the specified ID.  Searches all pages/elements.
        /// </summary>
        /// <returns>True on success.</returns>
        public bool GetElementByID(int id, out GumpElement element)
        {
            if (GumpElements != null)
            {
                foreach (GumpElement ge in GumpElements)
                {
                    if (ge.ElementID == id)
                    {
                        element = ge;
                        return true;
                    }
                }
            }

            if (Pages != null)
            {
                foreach (GumpPage p in Pages)
                {
                    foreach (GumpElement ge in p.GumpElements)
                    {
                        if (ge.ElementID == id)
                        {
                            element = ge;
                            return true;
                        }
                    }
                }
            }

            element = null;
            return false;
        }

        /// <summary>
        ///     Get the GumpElement nearest to the specified GumpElement.
        /// </summary>
        /// <returns>True on success.</returns>
        public bool GetNearestElement(GumpElement source, out GumpElement element)
        {
            GumpElement nearest = null;
            double closest = 0;

            if (source.ParentPage != null)
            {
                return source.ParentPage.GetNearestElement(source, out element);
            }

            foreach (GumpElement ge in GumpElements)
            {
                if (ge == source)
                {
                    continue;
                }

                double distance = Utility.Distance(source.X, source.Y, ge.X, ge.Y);

                if (nearest == null)
                {
                    closest = distance;
                    nearest = ge;
                }
                else
                {
                    if (distance < closest)
                    {
                        closest = distance;
                        nearest = ge;
                    }
                }
            }

            element = nearest;
            return nearest != null;
        }

        /// <summary>
        ///     Get nearest GumpElement to source, but only if it's ElementType is contained in the include list.
        /// </summary>
        /// <param name="source">Source GumpElement</param>
        /// <param name="includeTypes">Array of ElementTypes which specifies valid GumpElements to search.</param>
        /// <param name="element">GumpElement (out).</param>
        /// <returns>True on success.</returns>
        public bool GetNearestElement(GumpElement source, ElementType[] includeTypes, out GumpElement element)
        {
            GumpElement nearest = null;
            double closest = 0;

            if (source.ParentPage != null)
            {
                return source.ParentPage.GetNearestElement(source, includeTypes, out element);
            }

            foreach (GumpElement ge in GumpElements)
            {
                if (ge == source)
                {
                    continue;
                }

                bool found = includeTypes.Any(et => ge.Type == et);

                if (!found)
                {
                    continue;
                }

                double distance = Utility.Distance(source.X, source.Y, ge.X, ge.Y);

                if (nearest == null)
                {
                    closest = distance;
                    nearest = ge;
                }
                else
                {
                    if (distance < closest)
                    {
                        closest = distance;
                        nearest = ge;
                    }
                }
            }

            element = nearest;
            return nearest != null;
        }

        public bool GetElementByXY(int x, int y, out GumpElement gumpElement)
        {
            gumpElement = null;

            if (GumpElements == null)
            {
                return false;
            }

            GumpElement element = GumpElements.FirstOrDefault(m => m.X == x && m.Y == y);

            if (element != null)
            {
                gumpElement = element;
            }

            return gumpElement != null;
        }

        public GumpElement GetElementByXY(int x, int y)
        {
            return GetElementByXY(x, y, out GumpElement element) ? element : null;
        }

        public bool GetElementByCliloc(int cliloc, out GumpElement gumpElement)
        {
            gumpElement = null;

            if (GumpElements == null)
            {
                return false;
            }

            GumpElement element = GumpElements.FirstOrDefault(m => m.Cliloc == cliloc);

            if (element != null)
            {
                gumpElement = element;
            }

            return gumpElement != null;
        }

        public GumpElement GetElementByCliloc(int cliloc)
        {
            return GetElementByCliloc(cliloc, out GumpElement element) ? element : null;
        }

        public override int GetHashCode()
        {
            return ID.GetHashCode() ^ Layout?.GetHashCode() ?? 0;
        }

        public virtual void OnResponse(int buttonID, int[] switches, GumpTextEntry[] textEntries = null)
        {
            if (Resend)
                SendGump();
        }

        public virtual void SendGump()
        {
            byte[] bytes = Compile();

            World.Player.InternalGumps.Add(this);

            Client.Instance.SendPacketToClient(bytes, bytes.Length);
        }

        public void CloseGump()
        {
            Client.Instance.SendToClient(new CloseGump(ID));
        }

        public int GetButtonId(int type, int index) => 1 + index * 11 + type;

        public void Add(GumpElement e)
        {
            e.ParentGump = this;
            _elements.Add(e);
        }

        public void AddPage(int page)
        {
            GumpElement ge = new GumpElement {Type = ElementType.page, PageNumber = page};
            Add(ge);
        }

        public void AddAlphaRegion(int x, int y, int width, int height)
        {
            GumpElement ge = new GumpElement
            {
                Type = ElementType.checkertrans,
                X = x,
                Y = y,
                Width = width,
                Height = height
            };
            Add(ge);
        }

        public void AddBackground(int x, int y, int width, int height, int gumpID)
        {
            GumpElement ge = new GumpElement
            {
                Type = ElementType.resizepic,
                X = x,
                Y = y,
                Width = width,
                Height = height,
                ElementID = gumpID
            };
            Add(ge);
        }

        public void AddButton(int x, int y, int normalID, int pressedID, int buttonID, GumpButtonType type, int param)
        {
            GumpElement ge = new GumpElement
            {
                Type = ElementType.button,
                X = x,
                Y = y,
                InactiveID = normalID,
                ActiveID = pressedID,
                ButtonType = (int) type,
                ElementID = buttonID,
                Param = param
            };
            Add(ge);
        }

        public void AddCheck(int x, int y, int inactiveID, int activeID, bool initialState, int switchID)
        {
            GumpElement ge = new GumpElement
            {
                Type = ElementType.checkbox,
                X = x,
                Y = y,
                InactiveID = inactiveID,
                ActiveID = activeID,
                InitialState = initialState,
                ElementID = switchID
            };
            Add(ge);
        }

        public void AddGroup(int group)
        {
            GumpElement ge = new GumpElement {Type = ElementType.group, Group = group};
            Add(ge);
        }

        public void AddTooltip(int number)
        {
            GumpElement ge = new GumpElement {Type = ElementType.tooltip, Cliloc = number};
            Add(ge);
        }

        public void AddHtml(int x, int y, int width, int height, string text, bool background, bool scrollbar)
        {
            GumpElement ge = new GumpElement
            {
                Type = ElementType.htmlgump,
                X = x,
                Y = y,
                Width = width,
                Height = height,
                Text = text,
                ScrollBar = scrollbar,
                Background = background
            };
            Add(ge);
        }

        public void AddHtmlLocalized(int x, int y, int width, int height, int number, bool background, bool scrollbar)
        {
            GumpElement ge = new GumpElement
            {
                Type = ElementType.xmfhtmlgump,
                X = x,
                Y = y,
                Width = width,
                Height = height,
                Cliloc = number,
                Background = background,
                ScrollBar = scrollbar
            };
            Add(ge);
        }

        public void AddHtmlLocalized(int x, int y, int width, int height, int number, int color, bool background,
            bool scrollbar)
        {
            GumpElement ge = new GumpElement
            {
                Type = ElementType.xmfhtmlgumpcolor,
                X = x,
                Y = y,
                Width = width,
                Height = height,
                Cliloc = number,
                Hue = color,
                Background = background,
                ScrollBar = scrollbar
            };
            Add(ge);
        }

        public void AddHtmlLocalized(int x, int y, int width, int height, int number, string args, int color,
            bool background, bool scrollbar)
        {
            GumpElement ge = new GumpElement
            {
                Type = ElementType.xmfhtmltok,
                X = x,
                Y = y,
                Width = width,
                Height = height,
                Cliloc = number,
                Args = args,
                Hue = color,
                Background = background,
                ScrollBar = scrollbar
            };
            Add(ge);
        }

        public void AddImage(int x, int y, int gumpID)
        {
            AddImage(x, y, gumpID, 0);
        }

        public void AddImage(int x, int y, int gumpID, int hue)
        {
            GumpElement ge = new GumpElement
            {
                Type = ElementType.gumppic,
                X = x,
                Y = y,
                ElementID = gumpID,
                Hue = hue
            };
            Add(ge);
        }

        public void AddImageTiled(int x, int y, int width, int height, int gumpID)
        {
            GumpElement ge = new GumpElement
            {
                Type = ElementType.gumppictiled,
                X = x,
                Y = y,
                Width = width,
                Height = height,
                ElementID = gumpID
            };
            Add(ge);
        }

        public void AddImageTiledButton(int x, int y, int normalID, int pressedID, int buttonID, GumpButtonType type,
            int param, int itemID, int hue, int width, int height)
        {
            AddImageTiledButton(x, y, normalID, pressedID, buttonID, type, param, itemID, hue, width, height, -1);
        }

        public void AddImageTiledButton(int x, int y, int normalID, int pressedID, int buttonID, GumpButtonType type,
            int param, int itemID, int hue, int width, int height, int localizedTooltip)
        {
            GumpElement ge = new GumpElement
            {
                Type = ElementType.buttontileart,
                X = x,
                Y = y,
                InactiveID = normalID,
                ActiveID = pressedID,
                ElementID = buttonID,
                ButtonType = (int) type,
                Param = param,
                ItemID = itemID,
                Hue = hue,
                Height = height,
                Width = width,
                Cliloc = localizedTooltip
            };
            Add(ge);
        }

        public void AddItem(int x, int y, int itemID)
        {
            GumpElement ge = new GumpElement {Type = ElementType.tilepic, X = x, Y = y, ItemID = itemID};
            Add(ge);
        }

        public void AddItem(int x, int y, int itemID, int hue)
        {
            GumpElement ge = new GumpElement
            {
                Type = ElementType.tilepic,
                X = x,
                Y = y,
                ItemID = itemID,
                Hue = hue
            };
            Add(ge);
        }

        public void AddLabel(int x, int y, int hue, string text)
        {
            GumpElement ge = new GumpElement
            {
                Type = ElementType.text,
                X = x,
                Y = y,
                Hue = hue,
                Text = text
            };
            Add(ge);
        }

        public void AddLabelCropped(int x, int y, int width, int height, int hue, string text)
        {
            GumpElement ge = new GumpElement
            {
                Type = ElementType.croppedtext,
                X = x,
                Y = y,
                Width = width,
                Height = height,
                Hue = hue,
                Text = text
            };
            Add(ge);
        }

        public void AddRadio(int x, int y, int inactiveID, int activeID, bool initialState, int switchID)
        {
            GumpElement ge = new GumpElement
            {
                Type = ElementType.radio,
                X = x,
                Y = y,
                InactiveID = inactiveID,
                ActiveID = activeID,
                InitialState = initialState,
                ElementID = switchID
            };
            Add(ge);
        }

        public void AddTextEntry(int x, int y, int width, int height, int hue, int entryID, string initialText)
        {
            GumpElement ge = new GumpElement
            {
                Type = ElementType.textentry,
                X = x,
                Y = y,
                Width = width,
                Height = height,
                Hue = hue,
                ElementID = entryID,
                Text = initialText
            };
            Add(ge);
        }

        public void AddTextEntry(int x, int y, int width, int height, int hue, int entryID, string initialText,
            int size)
        {
            GumpElement ge = new GumpElement
            {
                Type = ElementType.textentrylimited,
                X = x,
                Y = y,
                Width = width,
                Height = height,
                Hue = hue,
                ElementID = entryID,
                Text = initialText,
                Size = size
            };
            Add(ge);
        }

        public void AddItemProperty(int serial)
        {
            GumpElement ge = new GumpElement {Type = ElementType.itemproperty, Serial = serial};
            Add(ge);
        }
        
        public void AddProgressBar(int x, int y, int w, int h, double min, double max, Color color, Color back, Color fore)
        {
            string bg = $"<BODYBGCOLOR=#{back.ToArgb():X}>";
            string fg = $"<BODYBGCOLOR=#{fore.ToArgb():X}>";

            AddHtml(x, y, w, h, bg, false, false);
            AddHtml(x + 2, y + 2, (int) Math.Ceiling((w - 4) * (min / max)), h - 4, fg, false, false);
        }

        public int Intern(string value)
        {
            int indexOf = _strings.IndexOf(value);

            if (indexOf >= 0)
            {
                return indexOf;
            }

            _strings.Add(value);
            return _strings.Count - 1;
        }

        internal static byte[] StringToBuffer(string str)
        {
            return Encoding.ASCII.GetBytes(str);
        }

        private byte[] Compile()
        {
            IGumpWriter disp = new GumpWriter(this);

            if (!Movable)
            {
                disp.AppendLayout(NoMove);
            }

            if (!Closable)
            {
                disp.AppendLayout(NoClose);
            }

            if (!Disposable)
            {
                disp.AppendLayout(NoDispose);
            }

            if (!Resizable)
            {
                disp.AppendLayout(NoResize);
            }

            int count = GumpElements.Length;

            for (int i = 0; i < count; ++i)
            {
                GumpElement e = GumpElements[i];

                disp.AppendLayout(BeginLayout);
                e.AppendTo(disp);
                disp.AppendLayout(EndLayout);
            }

            List<string> strings = new List<string>();

            if (Strings != null)
            {
                for (int i = 0; i < Strings.Length; i++)
                {
                    strings.Add(Strings[i]);
                }
            }

            disp.WriteStrings(strings);

            disp.Flush();

            return disp.ToArray();
        }

        internal interface IGumpWriter
        {
            int Switches { get; set; }
            int TextEntries { get; set; }

            void AppendLayout(bool val);
            void AppendLayout(int val);
            void AppendLayoutNS(int val);
            void AppendLayout(string text);
            void AppendLayout(byte[] buffer);
            void WriteStrings(List<string> strings);
            void Flush();
            byte[] ToArray();
        }

        internal class GumpWriter : IGumpWriter, IDisposable
        {
            private readonly byte[] _buffer = new byte[48];

            private readonly PacketWriter _packet;

            private int m_LayoutLength;
            private int m_PacketLength;
            private int m_StringsLength;

            public GumpWriter(Gump g)
            {
                /*_packet = new Packet(0xB0);

                _packet.EnsureCapacity(4096);

                //_packet.Write((short)0);
                _packet.Write( g.Serial );
                _packet.Write( g.ID );
                _packet.Write( g.X );
                _packet.Write( g.Y );
                _packet.Write( (ushort) 0xFFFF );*/

                _packet = new PacketWriter(4096);
                _buffer[0] = (byte) ' ';
                _packet.Write((byte) 0xB0);
                _packet.Write((short) 0);
                _packet.Write(g.Serial);
                _packet.Write(g.ID);
                _packet.Write(g.X);
                _packet.Write(g.Y);
                _packet.Write((ushort) 0xFFFF);
            }

            public PacketWriter GetPacket()
            {
                return _packet;
            }

            public int Switches { get; set; }
            public int TextEntries { get; set; }

            public void AppendLayout(byte[] buffer)
            {
                int length = buffer.Length;
                _packet.Write(buffer, 0, length);
                m_LayoutLength += length;
            }

            public void AppendLayout(string text)
            {
                AppendLayout(BeginTextSeparator);

                int length = text.Length;
                _packet.WriteAsciiFixed(text, length);
                m_LayoutLength += length;

                AppendLayout(EndTextSeparator);
            }

            public void AppendLayout(int val)
            {
                string toString = val.ToString();
                int bytes = Encoding.ASCII.GetBytes(toString, 0, toString.Length, _buffer, 1) + 1;

                _packet.Write(_buffer, 0, bytes);
                m_LayoutLength += bytes;
            }

            public void AppendLayout(bool val)
            {
                AppendLayout(val ? True : False);
            }

            public void AppendLayoutNS(int val)
            {
                string toString = val.ToString();
                int bytes = Encoding.ASCII.GetBytes(toString, 0, toString.Length, _buffer, 1);

                _packet.Write(_buffer, 1, bytes);
                m_LayoutLength += bytes;
            }

            public void Flush()
            {
                int length = 23 + m_LayoutLength + m_StringsLength;
                _packet.Seek(1, SeekOrigin.Begin);
                _packet.Write((short) length);
                m_PacketLength = length;
            }

            public void WriteStrings(List<string> text)
            {
                _packet.Seek(19, SeekOrigin.Begin);
                _packet.Write((ushort) m_LayoutLength);
                _packet.Seek(0, SeekOrigin.End);

                _packet.Write((ushort) text.Count);

                for (int i = 0; i < text.Count; ++i)
                {
                    string v = text[i] ?? string.Empty;

                    int length = (ushort) v.Length;
                    m_StringsLength += length * 2 + 2;

                    _packet.Write((ushort) length);
                    _packet.WriteBigUniFixed(v, length);
                }
            }

            public byte[] ToArray()
            {
                byte[] packet = new byte[m_PacketLength];
                Buffer.BlockCopy(_packet.ToArray(), 0, packet, 0, m_PacketLength);
                return packet;
            }

            #region IDisposable Support

            private bool disposedValue; // To detect redundant calls

            protected virtual void Dispose(bool disposing)
            {
                if (disposedValue)
                {
                    return;
                }

                if (disposing)
                {
                    //_packet.Dispose();
                }

                disposedValue = true;
            }

            public void Dispose()
            {
                Dispose(true);
                GC.SuppressFinalize(this);
            }

            #endregion
        }
    }
}

================================================
FILE: Razor/Gumps/GumpButtonType.cs
================================================
#region license
/* Copyright (C) 2009 Matthew Geyer
 * 
 * This file is part of UO Machine.
 * 
 * UO Machine is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * UO Machine is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with UO Machine.  If not, see <http://www.gnu.org/licenses/>. */
#endregion

namespace Assistant.Gumps
{
    public enum GumpButtonType
    {
        Page = 0,
        Reply = 1
    }
}

================================================
FILE: Razor/Gumps/GumpCollection.cs
================================================
#region license
/* Copyright (C) 2009 Matthew Geyer
 * 
 * This file is part of UO Machine.
 * 
 * UO Machine is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * UO Machine is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with UO Machine.  If not, see <http://www.gnu.org/licenses/>. */
#endregion

using System.Collections.Concurrent;
using System.Linq;

namespace Assistant.Gumps
{
    public sealed class GumpCollection
    {
        private readonly ConcurrentDictionary<uint, Gump> _dictionary;

        public GumpCollection()
        {
            _dictionary = new ConcurrentDictionary<uint, Gump>();
        }

        public void Add(Gump gump)
        {
            bool result = _dictionary.AddOrUpdate(gump.ID, gump, (k, v) => gump) != null;

            if (result)
            {
                OnCollectionChanged();
            }
        }

        public bool Remove(uint id, int buttonId = 0, int[] switches = null, GumpTextEntry[] textEntries = null)
        {
            bool result = _dictionary.TryRemove(id, out Gump g);

            g?.OnResponse(buttonId, switches, textEntries);

            if (result)
            {
                OnCollectionChanged();
            }

            if (g.Resend)
                g.SendGump();

            return result;
        }

        public bool GetGump(uint id, out Gump gump)
        {
            return _dictionary.TryGetValue(id, out gump);
        }

        public bool FindGump(int serial, out Gump gump)
        {
            gump = _dictionary.Values.FirstOrDefault(g => g.Serial == serial);

            return gump != null;
        }

        public bool GetGumps(out Gump[] gumps)
        {
            gumps = null;

            if (_dictionary.Values.Count == 0)
            {
                return false;
            }

            gumps = _dictionary.Values.ToArray();

            return gumps.Length > 0;
        }

        public void Clear()
        {
            int previousCount = _dictionary.Count;

            _dictionary.Clear();

            if (previousCount > 0)
            {
                OnCollectionChanged();
            }
        }

        private void OnCollectionChanged()
        {
        }
    }
}

================================================
FILE: Razor/Gumps/GumpElement.cs
================================================
#region license
/* Copyright (C) 2009 Matthew Geyer
 * 
 * This file is part of UO Machine.
 * 
 * UO Machine is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * UO Machine is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with UO Machine.  If not, see <http://www.gnu.org/licenses/>. */
#endregion

using System;
using Assistant.Core.Gumps;

namespace Assistant.Gumps
{
    public class GumpElement
    {
        private Gump _parentGump;
        public int ActiveID { get; set; }
        public string Args { get; set; }
        public bool Background { get; set; }
        public int ButtonType { get; set; }
        public int Cliloc { get; set; }
        public int ElementID { get; set; }
        public int Group { get; set; }
        public int Height { get; set; }
        public int Hue { get; set; }
        public int InactiveID { get; set; }
        public bool InitialState { get; set; }
        public int ItemID { get; set; }
        public int PageNumber { get; set; }
        public int Param { get; set; }

        public Gump ParentGump
        {
            get => _parentGump ?? ParentPage?.ParentGump;
            set => _parentGump = value;
        }

        public GumpPage ParentPage { get; set; }
        public bool ScrollBar { get; set; }
        public int Serial { get; set; }
        public int Size { get; set; }
        public string Text { get; set; }
        public int Tooltip { get; set; }
        public ElementType Type { get; set; }
        public int Width { get; set; }
        public int X { get; set; }
        public int Y { get; set; }

        /// <summary>
        ///     Get nearest GumpElement.
        /// </summary>
        /// <returns>True on success.</returns>
        public bool GetNearestElement(out GumpElement element)
        {
            if (ParentPage != null)
            {
                return ParentPage.GetNearestElement(this, out element);
            }

            element = null;
            return false;
        }

        /// <summary>
        ///     Get nearest GumpElement, but only if it's ElementType is contained in the include list.
        /// </summary>
        /// <param name="includeTypes">Array of ElementTypes which specifies valid GumpElements to search.</param>
        /// <param name="element">GumpElement (out).</param>
        /// <returns>True on success.</returns>
        public bool GetNearestElement(ElementType[] includeTypes, out GumpElement element)
        {
            if (ParentPage != null)
            {
                return ParentPage.GetNearestElement(this, includeTypes, out element);
            }

            element = null;
            return false;
        }

        public void Click()
        {
            Gump g = ParentGump;

            if (g != null && g.ID != 461 && Type == ElementType.button)
            {
                //TODO
                //Macros.MacroEx.CloseClientGump( g.Client, g.ID );
                //Macros.MacroEx.GumpButtonClick( g.Client, g.ID, g.Serial, this.ElementID );
            }
        }

        internal void AppendTo(Gump.IGumpWriter disp)
        {
            switch (Type)
            {
                case ElementType.textentrylimited:
                {
                    disp.AppendLayout(Gump.StringToBuffer("textentrylimited"));
                    disp.AppendLayout(X);
                    disp.AppendLayout(Y);
                    disp.AppendLayout(Width);
                    disp.AppendLayout(Height);
                    disp.AppendLayout(Hue);
                    disp.AppendLayout(ElementID);
                    disp.AppendLayout(ParentGump.Intern(Text));
                    disp.AppendLayout(Size);
                    disp.TextEntries++;
                    break;
                }
                case ElementType.textentry:
                {
                    disp.AppendLayout(Gump.StringToBuffer("textentry"));
                    disp.AppendLayout(X);
                    disp.AppendLayout(Y);
                    disp.AppendLayout(Width);
                    disp.AppendLayout(Height);
                    disp.AppendLayout(Hue);
                    disp.AppendLayout(ElementID);
                    disp.AppendLayout(ParentGump.Intern(Text));
                    disp.TextEntries++;
                    break;
                }
                case ElementType.radio:
                {
                    disp.AppendLayout(Gump.StringToBuffer("radio"));
                    disp.AppendLayout(X);
                    disp.AppendLayout(Y);
                    disp.AppendLayout(InactiveID);
                    disp.AppendLayout(ActiveID);
                    disp.AppendLayout(InitialState);
                    disp.AppendLayout(ElementID);
                    disp.Switches++;
                    break;
                }
                case ElementType.croppedtext:
                {
                    disp.AppendLayout(Gump.StringToBuffer("croppedtext"));
                    disp.AppendLayout(X);
                    disp.AppendLayout(Y);
                    disp.AppendLayout(Width);
                    disp.AppendLayout(Height);
                    disp.AppendLayout(Hue);
                    disp.AppendLayout(ParentGump.Intern(Text));
                    break;
                }
                case ElementType.buttontileart:
                {
                    disp.AppendLayout(Gump.StringToBuffer("buttontileart"));
                    disp.AppendLayout(X);
                    disp.AppendLayout(Y);
                    disp.AppendLayout(InactiveID);
                    disp.AppendLayout(ActiveID);
                    disp.AppendLayout(ButtonType);
                    disp.AppendLayout(Param);
                    disp.AppendLayout(ElementID);
                    disp.AppendLayout(ItemID);
                    disp.AppendLayout(Hue);
                    disp.AppendLayout(Width);
                    disp.AppendLayout(Height);

                    if (Cliloc != -1)
                    {
                        disp.AppendLayout(Gump.StringToBuffer(" }{ tooltip"));
                        disp.AppendLayout(Cliloc);
                    }

                    break;
                }
                case ElementType.tilepic:
                case ElementType.tilepichue:
                {
                    disp.AppendLayout(Gump.StringToBuffer(Hue == 0 ? "tilepic" : "tilepichue"));
                    disp.AppendLayout(X);
                    disp.AppendLayout(Y);
                    disp.AppendLayout(ItemID);

                    if (Hue != 0)
                    {
                        disp.AppendLayout(Hue);
                    }

                    break;
                }
                case ElementType.itemproperty:
                {
                    disp.AppendLayout(Gump.StringToBuffer("itemproperty"));
                    disp.AppendLayout(Serial);
                    break;
                }
                case ElementType.gumppictiled:
                {
                    disp.AppendLayout(Gump.StringToBuffer("gumppictiled"));
                    disp.AppendLayout(X);
                    disp.AppendLayout(Y);
                    disp.AppendLayout(Width);
                    disp.AppendLayout(Height);
                    disp.AppendLayout(ElementID);
                    break;
                }
                case ElementType.gumppic:
                {
                    disp.AppendLayout(Gump.StringToBuffer("gumppic"));
                    disp.AppendLayout(X);
                    disp.AppendLayout(Y);
                    disp.AppendLayout(ElementID);

                    if (Hue != 0)
                    {
                        disp.AppendLayout(Gump.StringToBuffer(" hue="));
                        disp.AppendLayoutNS(Hue);
                    }

                    break;
                }
                case ElementType.xmfhtmlgump:
                {
                    disp.AppendLayout(Gump.StringToBuffer("xmfhtmlgump"));
                    disp.AppendLayout(X);
                    disp.AppendLayout(Y);
                    disp.AppendLayout(Width);
                    disp.AppendLayout(Height);
                    disp.AppendLayout(Cliloc);
                    disp.AppendLayout(Background);
                    disp.AppendLayout(ScrollBar);
                    break;
                }
                case ElementType.xmfhtmlgumpcolor:
                {
                    disp.AppendLayout(Gump.StringToBuffer("xmfhtmlgumpcolor"));
                    disp.AppendLayout(X);
                    disp.AppendLayout(Y);
                    disp.AppendLayout(Width);
                    disp.AppendLayout(Height);
                    disp.AppendLayout(Cliloc);
                    disp.AppendLayout(Background);
                    disp.AppendLayout(ScrollBar);
                    disp.AppendLayout(Hue);
                    break;
                }
                case ElementType.xmfhtmltok:
                {
                    disp.AppendLayout(Gump.StringToBuffer("xmfhtmltok"));
                    disp.AppendLayout(X);
                    disp.AppendLayout(Y);
                    disp.AppendLayout(Width);
                    disp.AppendLayout(Height);
                    disp.AppendLayout(Background);
                    disp.AppendLayout(ScrollBar);
                    disp.AppendLayout(Hue);
                    disp.AppendLayout(Cliloc);
                    disp.AppendLayout(Args);
                    break;
                }
                case ElementType.htmlgump:
                {
                    disp.AppendLayout(Gump.StringToBuffer("htmlgump"));
                    disp.AppendLayout(X);
                    disp.AppendLayout(Y);
                    disp.AppendLayout(Width);
                    disp.AppendLayout(Height);
                    disp.AppendLayout(ParentGump.Intern(Text));
                    disp.AppendLayout(Background);
                    disp.AppendLayout(ScrollBar);
                    break;
                }
                case ElementType.tooltip:
                {
                    disp.AppendLayout(Gump.StringToBuffer("tooltip"));
                    disp.AppendLayout(Cliloc);
                    break;
                }
                case ElementType.group:
                {
                    disp.AppendLayout(Gump.StringToBuffer("group"));
                    disp.AppendLayout(Group);
                    break;
                }
                case ElementType.resizepic:
                {
                    disp.AppendLayout(Gump.StringToBuffer("resizepic"));
                    disp.AppendLayout(X);
                    disp.AppendLayout(Y);
                    disp.AppendLayout(ElementID);
                    disp.AppendLayout(Width);
                    disp.AppendLayout(Height);
                    break;
                }
                case ElementType.checkertrans:
                {
                    disp.AppendLayout(Gump.StringToBuffer("checkertrans"));
                    disp.AppendLayout(X);
                    disp.AppendLayout(Y);
                    disp.AppendLayout(Width);
                    disp.AppendLayout(Height);
                    break;
                }
                case ElementType.page:
                {
                    disp.AppendLayout(Gump.StringToBuffer("page"));
                    disp.AppendLayout(PageNumber);
                    break;
                }
                case ElementType.button:
                {
                    disp.AppendLayout(Gump.StringToBuffer("button"));
                    disp.AppendLayout(X);
                    disp.AppendLayout(Y);
                    disp.AppendLayout(InactiveID);
                    disp.AppendLayout(ActiveID);
                    disp.AppendLayout(ButtonType);
                    disp.AppendLayout(Param);
                    disp.AppendLayout(ElementID);
                    break;
                }
                case ElementType.text:
                {
                    disp.AppendLayout(Gump.StringToBuffer("text"));
                    disp.AppendLayout(X);
                    disp.AppendLayout(Y);
                    disp.AppendLayout(Hue);
                    disp.AppendLayout(ParentGump.Intern(Text));
                    break;
                }
                case ElementType.invalid:
                    break;
                case ElementType.checkbox:
                {
                    disp.AppendLayout(Gump.StringToBuffer("checkbox"));
                    disp.AppendLayout(X);
                    disp.AppendLayout(Y);
                    disp.AppendLayout(InactiveID);
                    disp.AppendLayout(ActiveID);
                    disp.AppendLayout(InitialState);
                    disp.AppendLayout(ElementID);

                    disp.Switches++;
                    break;
                }
                case ElementType.kr_xmfhtmlgump:
                    break;
                case ElementType.mastergump:
                    break;
                default:
                    throw new ArgumentOutOfRangeException();
            }
        }
    }
}

================================================
FILE: Razor/Gumps/GumpPage.cs
================================================
#region license
/* Copyright (C) 2009 Matthew Geyer
 * 
 * This file is part of UO Machine.
 * 
 * UO Machine is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * UO Machine is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with UO Machine.  If not, see <http://www.gnu.org/licenses/>. */
#endregion

using System.Linq;
using Assistant.Core.Gumps;

namespace Assistant.Gumps
{
    public sealed class GumpPage
    {
        public GumpElement[] GumpElements { get; internal set; }
        public int Page { get; internal set; }
        public Gump ParentGump { get; internal set; }

        /// <summary>
        ///     Get array of GumpElements which match the specified ElementType.
        /// </summary>
        public GumpElement[] GetElementsByType(ElementType type)
        {
            return GumpElements.Where(ge => ge.Type == type).ToArray();
        }

        /// <summary>
        ///     Get nearest GumpElement to source, but only if it's ElementType is contained in the include list.
        /// </summary>
        /// <param name="source">Source element.</param>
        /// <param name="includeTypes">Array of ElementTypes which specifies valid GumpElements to search.</param>
        /// <param name="element">GumpElement (out).</param>
        /// <returns>True on success.</returns>
        public bool GetNearestElement(GumpElement source, ElementType[] includeTypes, out GumpElement element)
        {
            GumpElement nearest = null;
            double closest = 0;

            foreach (GumpElement ge in GumpElements)
            {
                if (ge == source)
                {
                    continue;
                }

                bool found = includeTypes.Any(et => ge.Type == et);

                if (!found)
                {
                    continue;
                }

                double distance = Utility.Distance(source.X, source.Y, ge.X, ge.Y);

                if (nearest == null)
                {
                    closest = distance;
                    nearest = ge;
                }
                else
                {
                    if (!(distance < closest))
                    {
                        continue;
                    }

                    closest = distance;
                    nearest = ge;
                }
            }

            element = nearest;
            return nearest != null;
        }

        /// <summary>
        ///     Get nearest GumpElement from source.
        /// </summary>
        /// <returns>True on success.</returns>
        public bool GetNearestElement(GumpElement source, out GumpElement element)
        {
            GumpElement nearest = null;
            double closest = 0;

            foreach (GumpElement ge in GumpElements)
            {
                if (ge == source)
                {
                    continue;
                }

                double distance = Utility.Distance(source.X, source.Y, ge.X, ge.Y);

                if (nearest == null)
                {
                    closest = distance;
                    nearest = ge;
                }
                else
                {
                    if (!(distance < closest))
                    {
                        continue;
                    }

                    closest = distance;
                    nearest = ge;
                }
            }

            element = nearest;
            return nearest != null;
        }

        public bool GetElementByXY(int x, int y, out GumpElement gumpElement)
        {
            gumpElement = null;

            if (GumpElements == null)
            {
                return false;
            }

            GumpElement element = GumpElements.FirstOrDefault(m => m.X == x && m.Y == y);

            if (element != null)
            {
                gumpElement = element;
            }

            return gumpElement != null;
        }

        public GumpElement GetElementByXY(int x, int y)
        {
            if (GetElementByXY(x, y, out GumpElement element))
            {
                return element;
            }

            return null;
        }

        public bool GetElementByCliloc(int cliloc, out GumpElement gumpElement)
        {
            gumpElement = null;

            if (GumpElements == null)
            {
                return false;
            }

            GumpElement element = GumpElements.FirstOrDefault(m => m.Cliloc == cliloc);

            if (element != null)
            {
                gumpElement = element;
            }

            return gumpElement != null;
        }

        public GumpElement GetElementByCliloc(int cliloc)
        {
            return GetElementByCliloc(cliloc, out GumpElement element) ? element : null;
        }
    }
}

================================================
FILE: Razor/Gumps/GumpType.cs
================================================
#region license
/* Copyright (C) 2009 Matthew Geyer
 * 
 * This file is part of UO Machine.
 * 
 * UO Machine is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * UO Machine is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with UO Machine.  If not, see <http://www.gnu.org/licenses/>. */
#endregion

namespace Assistant.Core.Gumps
{
    public enum ElementType : byte
    {
        invalid,
        button,
        buttontileart,
        checkbox,
        checkertrans,
        croppedtext,
        gumppic,
        gumppictiled,
        htmlgump,
        kr_xmfhtmlgump,
        mastergump,
        radio,
        resizepic,
        text,
        textentry,
        textentrylimited,
        tilepic,
        tilepichue,
        xmfhtmlgump,
        xmfhtmlgumpcolor,
        xmfhtmltok,
        itemproperty,
        page,
        group,
        tooltip
    }
}

================================================
FILE: Razor/Gumps/Internal/AgentsGump.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System.Windows.Forms.VisualStyles;
using Assistant.Agents;

namespace Assistant.Gumps.Internal
{
    public sealed class AgentsGump : Gump
    {
        private Agent Agent { get; set; }

        public AgentsGump(Agent agent) : base(500, 250, 5000)
        {
            Closable = true;
            Disposable = true;
            Movable = true;
            Resizable = false;
            Resend = false;

            int pageCount = 1;
            Agent = agent;

            AddPage(pageCount);

            AddPage(0);

            if (agent is RestockAgent restockAgent)
            {
                AddBackground(1, 0, 453, 397, 3600);

                AddButton(21, 355, 4029, 4031, (int)Buttons.AddTarget, GumpButtonType.Reply, 0);
                AddLabel(58, 357, 990, Language.GetString(LocString.AddTarg));
                AddLabel(300, 25, 990, "Set Amount  Remove");
                
                AddButton(152, 355, 4014, 4016, (int)Buttons.AgentAction, GumpButtonType.Reply, 0);
                AddLabel(191, 357, 990, "Restock Now");

                string title = !string.IsNullOrEmpty(agent.Alias)
                    ? $"Restock Agent {agent.Number} ({agent.Alias})"
                    : $"Restock Agent {agent.Number}";

                AddLabel(27, 23, 252, title);

                int count = 0;
                int labelY = 66;

                if (restockAgent.Items.Count > 0)
                {
                    foreach (RestockAgent.RestockItem item in restockAgent.Items)
                    {
                        //AddItem(5, labelY, item.ItemID.Value);
                        AddImage(25, labelY + 4, 2224);
                        AddLabel(50, labelY, 342, $"{item.ItemID}");
                        AddLabel(250, labelY, 372, $"{item.Amount:N0}");

                        AddButton(390, labelY - 2, 4017, 4019, GetButtonId(0, item.ItemID.Value), GumpButtonType.Reply, 0); //remove
                        AddButton(324, labelY - 2, 4008, 4010, GetButtonId(1, item.ItemID.Value), GumpButtonType.Reply, 0); //set amount

                        count++;
                        labelY += 20;

                        if (count == 14)
                        {
                            AddButton(410, 356, 9904, 9905, pageCount + 2, GumpButtonType.Page, pageCount + 1);

                            pageCount++;
                            count = 0;
                            labelY = 66;

                            AddPage(pageCount);

                            AddBackground(1, 0, 453, 397, 3600);

                            AddLabel(27, 23, 252, title);

                            AddButton(21, 355, 4029, 4031, (int)Buttons.AddTarget, GumpButtonType.Reply, 0);
                            AddLabel(58, 357, 990, Language.GetString(LocString.AddTarg));
                            AddLabel(300, 25, 990, "Set Amount  Remove");

                            AddButton(152, 355, 4014, 4016, (int)Buttons.AgentAction, GumpButtonType.Reply, 0);
                            AddLabel(191, 357, 990, "Restock Now");

                            AddButton(388, 356, 9910, 9911, pageCount + 1, GumpButtonType.Page, pageCount - 1);

                            AddLabel(312, 357, 900, $"Page {pageCount}");
                        }
                    }
                }
                else
                {
                    AddImage(25, labelY + 4, 2224);
                    AddLabel(50, labelY, 342, "No items on this agent");
                }
            }
            else if (agent is OrganizerAgent orgAgent)
            {
                AddBackground(1, 0, 453, 397, 3600);

                AddButton(21, 355, 4029, 4031, (int)Buttons.AddTarget, GumpButtonType.Reply, 0);
                AddLabel(58, 357, 990, Language.GetString(LocString.AddTarg));
                AddLabel(380, 25, 990, "Remove");

                AddButton(152, 355, 4014, 4016, (int)Buttons.AgentAction, GumpButtonType.Reply, 0);
                AddLabel(191, 357, 990, "Organize Now");

                string title = !string.IsNullOrEmpty(agent.Alias)
                    ? $"Organizer Agent {agent.Number} ({agent.Alias})"
                    : $"Organizer Agent {agent.Number}";

                AddLabel(27, 23, 252, title);

                int count = 0;
                int labelY = 66;

                if (orgAgent.Items.Count > 0)
                {
                    foreach (ItemID item in orgAgent.Items)
                    {
                        //AddItem(5, labelY, item.Value);
                        AddImage(25, labelY + 4, 2224);
                        AddLabel(50, labelY, 342, $"{item}");

                        AddButton(390, labelY - 2, 4017, 4019, GetButtonId(0, item.Value), GumpButtonType.Reply, 0); //remove

                        count++;
                        labelY += 20;

                        if (count == 14)
                        {
                            AddButton(410, 356, 9904, 9905, pageCount + 2, GumpButtonType.Page, pageCount + 1);

                            pageCount++;
                            count = 0;
                            labelY = 66;

                            AddPage(pageCount);

                            AddBackground(1, 0, 453, 397, 3600);

                            AddLabel(27, 23, 252, title);

                            AddButton(21, 355, 4029, 4031, (int)Buttons.AddTarget, GumpButtonType.Reply, 0);
                            AddLabel(58, 357, 990, Language.GetString(LocString.AddTarg));
                            AddLabel(380, 25, 990, "Remove");

                            AddButton(152, 355, 4014, 4016, (int)Buttons.AgentAction, GumpButtonType.Reply, 0);
                            AddLabel(191, 357, 990, "Organize Now");

                            AddButton(388, 356, 9910, 9911, pageCount + 1, GumpButtonType.Page, pageCount - 1);

                            AddLabel(312, 357, 900, $"Page {pageCount}");
                        }
                    }
                }
                else
                {
                    AddImage(25, labelY + 4, 2224);
                    AddLabel(50, labelY, 342, "No items on this agent");
                }
            }
            else if (agent is BuyAgent buyAgent)
            {
                AddBackground(1, 0, 453, 397, 3600);

                AddButton(21, 355, 4029, 4031, (int)Buttons.AddTarget, GumpButtonType.Reply, 0);
                AddLabel(58, 357, 990, Language.GetString(LocString.AddTarg));
                AddLabel(300, 25, 990, "Set Amount  Remove");

                string title = !string.IsNullOrEmpty(agent.Alias)
                    ? $"Buy Agent {agent.Number} ({agent.Alias})"
                    : $"Buy Agent {agent.Number}";

                AddLabel(27, 23, 252, title);

                int count = 0;
                int labelY = 66;

                if (buyAgent.Items.Count > 0)
                {
                    foreach (BuyAgent.BuyEntry item in buyAgent.Items)
                    {
                        //AddItem(5, labelY, item.Id);
                        AddImage(25, labelY + 4, 2224);
                        AddLabel(50, labelY, 342, $"{item.Id}");
                        AddLabel(250, labelY, 372, $"{item.Amount}");

                        AddButton(390, labelY - 2, 4017, 4019, GetButtonId(0, item.Id), GumpButtonType.Reply, 0); //remove
                        AddButton(324, labelY - 2, 4008, 4010, GetButtonId(1, item.Id), GumpButtonType.Reply, 0); //set amount

                        count++;
                        labelY += 20;

                        if (count == 14)
                        {
                            AddButton(410, 356, 9904, 9905, pageCount + 2, GumpButtonType.Page, pageCount + 1);

                            pageCount++;
                            count = 0;
                            labelY = 66;

                            AddPage(pageCount);

                            AddBackground(1, 0, 453, 397, 3600);

                            AddLabel(27, 23, 252, title);

                            AddButton(21, 355, 4029, 4031, (int)Buttons.AddTarget, GumpButtonType.Reply, 0);
                            AddLabel(58, 357, 990, Language.GetString(LocString.AddTarg));
                            AddLabel(300, 25, 990, "Set Amount  Remove");

                            AddButton(388, 356, 9910, 9911, pageCount + 1, GumpButtonType.Page, pageCount - 1);

                            AddLabel(312, 357, 900, $"Page {pageCount}");
                        }
                    }
                }
                else
                {
                    AddImage(25, labelY + 4, 2224);
                    AddLabel(50, labelY, 342, "No items on this agent");
                }
            }
        }

        public enum Buttons
        {
            AddTarget = 1,
            Remove,
            SetAmount,
            NextPage,
            PrevPage,
            AgentAction
        }

        public override void OnResponse(int buttonId, int[] switches, GumpTextEntry[] textEntries = null)
        {
            if (buttonId > 0)
            {
                var type = buttonId % 11;
                var index = buttonId / 11;

                if (Agent is RestockAgent restockAgent)
                {
                    switch (buttonId)
                    {
                        case (int)Buttons.AddTarget:
                            restockAgent.AddItemTarget(true);
                            break;
                        case (int) Buttons.AgentAction:
                            restockAgent.OnHotKey();
                            break;
                        default:
                        {
                            switch (type)
                            {
                                // remove
                                case 1:
                                    restockAgent.RemoveItem(index);
                                    break;
                                // set amount
                                case 2:
                                    restockAgent.SetItemAmount(index);
                                    break;
                            }

                            break;
                        }
                    }

                    AgentsGump gump = new AgentsGump(Agent);
                    gump.SendGump();
                }
                else if (Agent is OrganizerAgent orgAgent)
                {
                    switch (buttonId)
                    {
                        case (int)Buttons.AddTarget:
                            orgAgent.AddItemTarget(true);
                            break;
                        case (int)Buttons.AgentAction:
                            orgAgent.Organize();
                            break;
                        default:
                        {
                            if (type == 1) // remove
                            {
                                orgAgent.RemoveItem(index);
                            }

                            break;
                        }
                    }

                    AgentsGump gump = new AgentsGump(Agent);
                    gump.SendGump();
                }
                else if (Agent is BuyAgent buyAgent)
                {
                    switch (buttonId)
                    {
                        case (int)Buttons.AddTarget:
                            buyAgent.AddItemTarget(true);
                            break;
                        default:
                            switch (type)
                            {
                                // remove
                                case 1:
                                    buyAgent.RemoveItem(index);
                                    break;
                                // set amount
                                case 2:
                                    buyAgent.SetItemAmount(index, true);
                                    break;
                            }

                            break;
                    }

                    AgentsGump gump = new AgentsGump(Agent);
                    gump.SendGump();
                }
            }

            base.OnResponse(buttonId, switches, textEntries);
        }
    }
}

================================================
FILE: Razor/Gumps/Internal/BoatControlGump.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

namespace Assistant.Gumps.Internal
{
    public sealed class BoatControlGump : Gump
    {
        public BoatControlGump(int speed) : base(0, 0)
        {
            Closable = true;
            Disposable = true;
            Movable = true;
            Resizable = false;

            AddPage(0);
            AddBackground(48, 28, 182, 195, 9270);

            AddButton(130, 69, 5600, 5604, (int) Buttons.OneForward, GumpButtonType.Reply, 0);
            AddButton(130, 109, 5602, 5606, (int) Buttons.OneBackwards, GumpButtonType.Reply, 0);
            AddButton(108, 89, 5603, 5607, (int) Buttons.OneLeft, GumpButtonType.Reply, 0);
            AddButton(150, 89, 5601, 5605, (int) Buttons.OneRight, GumpButtonType.Reply, 0);
            AddButton(173, 86, 9903, 9905, (int) Buttons.Right, GumpButtonType.Reply, 0);
            AddButton(81, 86, 9909, 9911, (int) Buttons.Left, GumpButtonType.Reply, 0);
            AddButton(128, 47, 9900, 9902, (int) Buttons.Forward, GumpButtonType.Reply, 0);
            AddButton(128, 129, 9906, 9908, (int) Buttons.Back, GumpButtonType.Reply, 0);
            AddButton(130, 90, 2117, 2118, (int) Buttons.Stop, GumpButtonType.Reply, 0);
            AddButton(69, 118, 22406, 22407, (int) Buttons.TurnLeft, GumpButtonType.Reply, 0);
            AddButton(189, 118, 22400, 22401, (int) Buttons.TurnRight, GumpButtonType.Reply, 0);
            AddButton(162, 66, 5106, 5106, (int) Buttons.ForwardRight, GumpButtonType.Reply, 0);
            AddButton(162, 120, 5100, 5100, (int) Buttons.BackRight, GumpButtonType.Reply, 0);
            AddButton(106, 120, 5102, 5102, (int) Buttons.BackLeft, GumpButtonType.Reply, 0);
            AddButton(106, 66, 5108, 5108, (int) Buttons.ForwardLeft, GumpButtonType.Reply, 0);

            AddCheck(64, 188, 210, 211, speed == 0, (int) Buttons.Reg);
            AddLabel(87, 189, 990, "Reg");
            AddCheck(115, 189, 210, 211, speed == 1, (int) Buttons.Slow);
            AddLabel(135, 189, 990, "Slow");
            AddCheck(169, 189, 210, 211, speed == 2, (int) Buttons.One);
            AddLabel(189, 189, 990, "One");

            AddButton(66, 157, 5600, 5604, (int) Buttons.AnchorUp, GumpButtonType.Reply, 0);
            AddButton(83, 157, 5602, 5606, (int) Buttons.AnchorDown, GumpButtonType.Reply, 0);
        }

        public override void OnResponse(int buttonID, int[] switches, GumpTextEntry[] textEntries = null)
        {
            int speed = 0;

            foreach (int check in switches)
            {
                if (check == (int) Buttons.Reg)
                {
                    speed = 0;
                    break;
                }

                if (check == (int)Buttons.Slow)
                {
                    speed = 1;
                    break;
                }

                if (check == (int)Buttons.One)
                {
                    speed = 2;
                    break;
                }
            }

            switch (buttonID)
            {
                case (int) Buttons.AnchorDown:
                    SendBoatCommand("Lower Anchor");
                    break;
                case (int) Buttons.AnchorUp:
                    SendBoatCommand("Raise Anchor");
                    break;
                case (int) Buttons.Back:
                    SendBoatCommand("Back", speed);
                    break;
                case (int) Buttons.BackLeft:
                    SendBoatCommand("Back Left", speed);
                    break;
                case (int) Buttons.BackRight:
                    SendBoatCommand("Back Right", speed);
                    break;
                case (int) Buttons.Forward:
                    SendBoatCommand("Forward", speed);
                    break;
                case (int) Buttons.ForwardLeft:
                    SendBoatCommand("Forward Left", speed);
                    break;
                case (int) Buttons.ForwardRight:
                    SendBoatCommand("Forward Right", speed);
                    break;
                case (int) Buttons.Left:
                    SendBoatCommand("Left", speed);
                    break;
                case (int) Buttons.OneBackwards:
                    SendBoatCommand("Back", 2);
                    break;
                case (int) Buttons.OneForward:
                    SendBoatCommand("Forward", 2);
                    break;
                case (int) Buttons.OneLeft:
                    SendBoatCommand("Left", 2);
                    break;
                case (int) Buttons.OneRight:
                    SendBoatCommand("Right", 2);
                    break;
                case (int) Buttons.Right:
                    SendBoatCommand("Right", speed);
                    break;
                case (int) Buttons.TurnLeft:
                    SendBoatCommand("Turn Left");
                    break;
                case (int) Buttons.TurnRight:
                    SendBoatCommand("Turn Right");
                    break;
                case (int) Buttons.Stop:
                    SendBoatCommand("Stop");
                    break;
            }

            if (buttonID != 0)
            {
                CloseGump();

                BoatControlGump gump = new BoatControlGump(speed);
                gump.SendGump();
            }
        }

        /// <summary>
        /// Handles basic logic on sending boat commands
        /// </summary>
        /// <param name="command"></param>
        /// <param name="speed">0 = reg, 1 = slow, 2 = one</param>
        /// <param name="directionCommand"></param>
        private void SendBoatCommand(string command, int speed = 0, bool directionCommand = true)
        {
            string boatCommand = command;

            if (speed == 2 && directionCommand)
            {
                boatCommand = $"{command} One";
            }
            else if (speed == 1 && directionCommand)
            {
                boatCommand = $"Slow {command}";
            }

            if (World.Player != null)
            {
                World.Player.Say(boatCommand);
            }
        }

        public enum Buttons
        {
            OneForward = 1,
            OneBackwards,
            OneLeft,
            OneRight,
            Right,
            Left,
            Forward,
            Back,
            Stop,
            TurnLeft,
            TurnRight,
            ForwardRight,
            BackRight,
            BackLeft,
            ForwardLeft,
            Reg,
            Slow,
            One,
            AnchorUp,
            AnchorDown,
        }
    }
}

================================================
FILE: Razor/Gumps/Internal/BuffGump.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Security.Cryptography;
using Assistant.Core;
using Ultima;

namespace Assistant.Gumps.Internal
{
    public sealed class BuffGump : Gump
    {
        public BuffGump() : base(50, 50, -1)
        {
            Closable = true;
            Disposable = true;
            Movable = true;
            Resizable = false;
            
            AddPage(0);
            
            int currentY = 100;

            int barHeight = Config.GetInt("ShowBuffDebuffHeight");
            int barWidth = Config.GetInt("ShowBuffDebuffWidth");
            bool showIcons = Config.GetBool("ShowBuffDebuffIcons");

            IOrderedEnumerable<BuffDebuff> buffDebuffs;

            switch (Config.GetInt("ShowBuffDebuffSort"))
            {
                case 0:
                    buffDebuffs = World.Player.BuffsDebuffs.OrderBy(buff => buff.ClilocMessage1).ThenBy(buff => BuffDebuffManager.IsBuff(buff.IconId) ? 1 : 0);
                    break;
                case 1:
                    buffDebuffs = World.Player.BuffsDebuffs.OrderBy(buff => (buff.Duration - (DateTime.UtcNow - buff.Timestamp).TotalSeconds)).ThenBy(buff => BuffDebuffManager.IsBuff(buff.IconId) ? 1 : 0);
                    break;
                case 2:
                    buffDebuffs = World.Player.BuffsDebuffs.OrderByDescending(buff => (buff.Duration - (DateTime.UtcNow - buff.Timestamp).TotalSeconds)).ThenBy(buff => BuffDebuffManager.IsBuff(buff.IconId) ? 1 : 0);
                    break;
                default:
                    buffDebuffs = World.Player.BuffsDebuffs.OrderByDescending(buff => (buff.Duration - (DateTime.UtcNow - buff.Timestamp).TotalSeconds)).ThenBy(buff => BuffDebuffManager.IsBuff(buff.IconId) ? 1 : 0);
                    break;
            }

            foreach (BuffDebuff buff in buffDebuffs)
            {
                TimeSpan diff = DateTime.UtcNow - buff.Timestamp;
                var timeLeft = buff.Duration - (int)diff.TotalSeconds;

                string timeLeftDisplay;

                if (timeLeft < 0)
                {
                    timeLeft = 0; 
                    timeLeftDisplay = "-";
                }
                else
                {
                    timeLeftDisplay = $"{timeLeft}s";
                }

                Color barColor;
                Color bgColor;
                int labelHue;

                if (BuffDebuffManager.IsBuff(buff.IconId))
                {
                    barColor = Color.Green;
                    bgColor = Config.GetBool("UseBlackBuffDebuffBg") ? Color.Black : Color.DarkGreen; 

                    labelHue = 62;
                }
                else if (BuffDebuffManager.IsDebuff(buff.IconId))
                {
                    barColor = Color.Red;
                    bgColor = Config.GetBool("UseBlackBuffDebuffBg") ? Color.Black : Color.DarkRed;

                    labelHue = 32;
                } 
                else if (BuffDebuffManager.IsState(buff.IconId))
                {
                    barColor = Color.Blue;
                    bgColor = Config.GetBool("UseBlackBuffDebuffBg") ? Color.Black : Color.DarkBlue;

                    labelHue = 102;
                }
                else
                {
                    barColor = Color.Gray;
                    bgColor = Config.GetBool("UseBlackBuffDebuffBg") ? Color.Black : Color.DarkGray;

                    labelHue = 922;
                }

                if (showIcons)
                {
                    AddImage(80, currentY, buff.IconId);
                }

                AddProgressBar(110, currentY, barWidth, barHeight, timeLeft, buff.Duration == 0 ? 100 : buff.Duration,
                    Color.Black, bgColor, barColor);

                switch (Config.GetInt("ShowBuffDebuffTimeType"))
                {
                    case 0: //next to name
                        AddLabelCropped(114, currentY, barWidth, barHeight, labelHue, $"{buff} ({timeLeftDisplay})");
                        break;
                    case 1: // outside of bar (left)
                        AddLabelCropped(114, currentY, barWidth, barHeight, labelHue, $"{buff}");
                        AddHtml(114 + barWidth, currentY, 50, barHeight, $"<BIG><BASEFONT COLOR=#FFFFFF>{timeLeftDisplay}</BASEFONT></BIG>", false, false);
                        break;
                    case 2: // right side of bar (inside)
                        AddLabelCropped(114, currentY, barWidth, barHeight, labelHue, $"{buff}");
                        AddHtml(114, currentY, barWidth, barHeight, $"<DIV ALIGN=\"RIGHT\"><BIG><BASEFONT COLOR=#FFFFFF>{timeLeftDisplay}</BASEFONT></BIG></DIV>", false, false);
                        break;
                    case 3: // under icon (28x28 icon)
                        AddLabelCropped(114, currentY, barWidth, barHeight, labelHue, $"{buff}");
                        AddHtml(80, currentY + 32, 50, barHeight, $"<BIG><BASEFONT COLOR=#FFFFFF>{timeLeftDisplay}</BASEFONT></BIG>", false, false);
                        break;
                    case 4: //none
                        AddLabelCropped(114, currentY, barWidth, barHeight, labelHue, $"{buff}");
                        break;
                    default:
                        AddLabelCropped(114, currentY, barWidth, barHeight, labelHue, $"{buff} ({timeLeftDisplay})");
                        break;
                }

                if (barHeight > 28)
                {
                    currentY += barHeight + 4;
                }
                else
                {
                    currentY += 32;
                }
            }
        }

        public override void OnResponse(int buttonId, int[] switches, GumpTextEntry[] textEntries = null)
        {
            /*if (buttonId == 0)
            {
                World.Player?.SendMessage("All cooldowns have been stopped");
                CooldownManager.Stop();
            }*/
            
            base.OnResponse(buttonId, switches, textEntries);
        }
    }
}

================================================
FILE: Razor/Gumps/Internal/CooldownGump.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using Assistant.Core;
using Ultima;

namespace Assistant.Gumps.Internal
{
    public sealed class CooldownGump : Gump
    {
        public CooldownGump() : base(100, 100, -1)
        {
            Closable = true;
            Disposable = true;
            Movable = true;
            Resizable = false;
            
            AddPage(0);
            AddHtml(110, 77, 106, 24, "<CENTER><BIG><BASEFONT COLOR=#E0E70B>Cooldowns</BASEFONT></BIG></CENTER>", false, false);

            int currentY = 100;
            
            foreach (KeyValuePair<string, Cooldown> cooldown in CooldownManager.Cooldowns.OrderByDescending(c => (c.Value.EndTime - DateTime.UtcNow).TotalSeconds))
            {
                //get the number of seconds left
                TimeSpan diff = cooldown.Value.EndTime - DateTime.UtcNow;
                int timeLeft = (int)diff.TotalSeconds;

                if (timeLeft < 0)
                {
                    timeLeft = 0;
                }
                
                Color backColor = cooldown.Value.BackgroundColor == Color.Empty ? Color.Black : cooldown.Value.BackgroundColor;
                Color foreColor;

                int labelHue;
                
                if (timeLeft > 10) //green
                {
                    foreColor = cooldown.Value.ForegroundColor == Color.Empty ? Color.Green : cooldown.Value.ForegroundColor;
                    labelHue = 62;
                }
                else if (timeLeft > 5) //yellow
                {
                    foreColor = cooldown.Value.ForegroundColor == Color.Empty ? Color.FromArgb(253, 216, 53) : cooldown.Value.ForegroundColor;
                    labelHue = 52;
                }
                else //red
                {
                    foreColor = cooldown.Value.ForegroundColor == Color.Empty ? Color.DarkRed : cooldown.Value.ForegroundColor;
                    labelHue = 32;
                }

                if (cooldown.Value.Hue > 0)
                {
                    labelHue = cooldown.Value.Hue;
                }

                if (cooldown.Value.Icon > 0)
                {
                    AddImage(80, currentY, cooldown.Value.Icon);
                }

                AddProgressBar(110, currentY, Config.GetInt("CooldownWidth"), Config.GetInt("CooldownHeight"), timeLeft, cooldown.Value.Seconds, Color.Black, backColor, foreColor);
                AddLabelCropped(114, currentY, Config.GetInt("CooldownWidth") - 10, Config.GetInt("CooldownHeight"), labelHue, $"{cooldown.Key} ({timeLeft}s)");

                if (timeLeft == 0)
                {
                    AddImage(224, currentY + 4, 9009);
                }

                currentY += 2 + Config.GetInt("CooldownHeight");
            }
        }

        public override void OnResponse(int buttonId, int[] switches, GumpTextEntry[] textEntries = null)
        {
            if (buttonId == 0)
            {
                World.Player?.SendMessage("All cooldowns have been stopped");
                CooldownManager.Stop();
            }
            
            base.OnResponse(buttonId, switches, textEntries);
        }
    }
}

================================================
FILE: Razor/Gumps/Internal/DamageTrackerGump.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System.Collections.Generic;
using System.Text;
using Assistant.Core;

namespace Assistant.Gumps.Internal
{
    public sealed class DamageTrackerGump : Gump
    {
        public DamageTrackerGump(string message) : base(100, 100)
        {
            Movable = true;
            Closable = false;
            Disposable = false;

            AddPage(0);
            AddBackground(0, 0, 253, 203, 9270);

            AddLabel(20, 20, 2954, "DPS:");
            AddLabel(60, 20, 67, $"{DamageTracker.DamagePerSecond:N2}");

            AddLabel(120, 20, 2954, "Max DPS:");
            AddLabel(190, 20, 67, $"{DamageTracker.MaxDamagePerSecond:N2}");

            AddHtml(20, 50, 213, 100, message, true, true);

            AddButton(20, 160, 4008, 4010, 1, GumpButtonType.Reply, 0);
            
        }

        public override void OnResponse(int buttonId, int[] switches, GumpTextEntry[] textEntries = null)
        {
            if (buttonId == 1)
            {
                StringBuilder sb = new StringBuilder();

                int x = 1;
                foreach (KeyValuePair<string, int> dmg in DamageTracker.GetTotalDamageList())
                {
                    sb.AppendLine($"{x}) {dmg.Key} [{dmg.Value:N2}]");
                    x++;
                }

                DamageTrackerListGump dmgList = new DamageTrackerListGump(sb.ToString());
                dmgList.SendGump();
            }

            base.OnResponse(buttonId, switches, textEntries);
        }
    }
}

================================================
FILE: Razor/Gumps/Internal/DamageTrackerListGump.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

namespace Assistant.Gumps.Internal
{
    public sealed class DamageTrackerListGump : Gump
    {
        public DamageTrackerListGump(string message) : base(100, 100)
        {
            Movable = true;
            Closable = true;
            Disposable = false;

            AddPage(0);
            AddBackground(0, 0, 273, 318, 9380);
            AddLabel(69, 5, 2954, "Damage Dealt (by name)");
			AddHtml(30, 40, 213, 239, message, true, true);
        }
    }
}

================================================
FILE: Razor/Gumps/Internal/HotKeyGump.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System.Linq;

namespace Assistant.Gumps.Internal
{
    public sealed class HotKeyGump : Gump
    {
        private bool _showAlt { get; }
        private bool _showCtrl { get; }
        private bool _showShift { get; }

        public HotKeyGump(bool alt, bool ctrl, bool shift) : base(100, 100)
        {
            Closable = true;
            Disposable = true;
            Movable = true;
            Resizable = false;

            _showAlt = alt;
            _showCtrl = ctrl;
            _showShift = shift;

            int pageCount = 1;

            AddPage(pageCount);

            AddBackground(0, 0, 326, 474, 9270);
            AddHtml(16, 16, 450, 20, $"<BASEFONT COLOR=#EC760D>Assigned Hot Keys</BASEFONT> <BASEFONT COLOR=#0DB6EC>({Config.CurrentProfile.Name})</BASEFONT>", false, false);

            AddFilterElements();

            int labelY = 64;
            int count = 0;

            foreach (KeyData data in HotKey.List.Where(hk => hk.Key != 0).OrderBy(hk => hk.DisplayName))
            {
                if (!_showAlt && (data.Mod & ModKeys.Alt) != 0 || !_showCtrl && (data.Mod & ModKeys.Control) != 0 ||
                    !_showShift && (data.Mod & ModKeys.Shift) != 0)
                    continue;

                AddHtml(20, labelY, 500, 20, $"<BASEFONT COLOR=#FFFFFF>{data.DisplayName}</BASEFONT> <BASEFONT COLOR=#E0E70B>({data.KeyString()})</BASEFONT>", false, false);

                labelY += 20;
                count++;

                if (count % 20 == 0)
                {
                    AddButton(292, 17, 9903, 9905, pageCount + 2, GumpButtonType.Page, pageCount + 1);

                    pageCount++;
                    labelY = 64;

                    AddPage(pageCount);

                    AddBackground(0, 0, 326, 480, 9270);
                    AddHtml(16, 16, 450, 20, $"<BASEFONT COLOR=#EC760D>Assigned Hot Keys</BASEFONT> <BASEFONT COLOR=#0DB6EC>({Config.CurrentProfile.Name})</BASEFONT>", false, false);
                    AddButton(270, 18, 9909, 9911, pageCount + 1, GumpButtonType.Page, pageCount - 1);
                }
            }
        }

        public void AddFilterElements()
        {
            AddCheck(16, 38, 210, 211, _showAlt, 1);
            AddLabel(40, 38, 67, "Alt");
            AddCheck(68, 38, 210, 211, _showCtrl, 2);
            AddLabel(92, 38, 67, "Ctrl");
            AddCheck(127, 38, 210, 211, _showShift, 3);
            AddLabel(151, 38, 67, "Shift");
            AddButton(197, 38, 4011, 4012, 1, GumpButtonType.Reply, 0);
        }

        public override void OnResponse(int buttonID, int[] switches, GumpTextEntry[] textEntries = null)
        {
            if (buttonID == 1)
            {
                bool alt = false;
                bool ctrl = false;
                bool shift = false;

                foreach (int check in switches)
                {
                    switch (check)
                    {
                        case 1:
                            alt = true;
                            break;
                        case 2:
                            ctrl = true;
                            break;
                        case 3:
                            shift = true;
                            break;
                    }
                }

                CloseGump();
                HotKeyGump gump = new HotKeyGump(alt, ctrl, shift);
                gump.SendGump();

            }

            base.OnResponse(buttonID, switches, textEntries);
        }
    }
}


================================================
FILE: Razor/Gumps/Internal/InputDialogGump.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using Assistant.Agents;

namespace Assistant.Gumps.Internal
{
    public sealed class InputDialogGump : Gump
    {
        private enum Controls
        {
            Okay,
            InputEntry,
        }
        
        private int _inputReference { get; set; }
        //private InputDialogTypes _type { get; set; }
        private readonly Func<int, string, bool> _inputCallback;

        /// <summary>
        /// Simple input dialog to replace UI based input boxes
        /// </summary>
        /// <param name="inputCallback">Method to execute when Okay is pressed</param>
        /// <param name="inputReference">Optional int to be used as a reference on the callback</param>
        /// <param name="inputRequest">The text in the gump asking the user to enter something specific</param>
        /// <param name="defaultInput">Optional string to pre-populate the gump textbox input with</param>
        public InputDialogGump(Func<int, string, bool> inputCallback, int inputReference, string inputRequest, string defaultInput = "") : base(100, 100)
        {
            Closable = true;
            Disposable = true;
            Movable = true;
            Resizable = false;
            Resend = false;

            _inputReference = inputReference;
            _inputCallback = inputCallback;

            AddBackground(105, 70, 253, 121, 3600);
            AddBackground(129, 115, 209, 22, 9200);
            AddLabel(125, 90, 2954, inputRequest);
            AddButton(273, 145, 247, 248, (int)Controls.Okay, GumpButtonType.Reply, 0);
            AddTextEntry(133, 117, 204, 20, 2954, (int)Controls.InputEntry, defaultInput);

        }

        public override void OnResponse(int buttonID, int[] switches, GumpTextEntry[] textEntries = null)
        {
            if (buttonID == (int)Controls.Okay)
            {
                if (!string.IsNullOrEmpty(textEntries?[0]?.Text))
                {
                    _inputCallback(_inputReference, textEntries[0].Text);

                    CloseGump();
                }
            }
        }
    }
}


================================================
FILE: Razor/Gumps/Internal/ItemInfoGump.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System.Windows.Forms;

namespace Assistant.Gumps.Internal
{
    public sealed class ItemInfoGump : Gump
    {
        private enum ItemInfoButtons
        {
            Okay,
            CopyItemName,
            CopySerial,
            CopyId,
            CopyHue,
            ItemName,
            Serial,
            Id,
            Hue
        }

        private Item _item { get; }

        public ItemInfoGump(Item item) : base(271, 130, -1)
        {
            _item = item;

            Closable = true;
            Disposable = true;
            Movable = true;
            Resizable = false;
            Resend = true;

            AddPage(0);
            
            AddBackground(106, 70, 253, 189, 3600);

            AddLabel(197, 87, 154, "Item Data");
            AddItem(290, 98, item.ItemID);

            AddLabel(143, 115, 900, "Item Name:");
            AddLabel(142, 140, 900, "Serial:");
            AddLabel(142, 164, 900, "Id:");
            AddLabel(142, 188, 900, "Hue:");

            AddButton(274, 217, 247, 248, (int)ItemInfoButtons.Okay, GumpButtonType.Reply, 0);
            AddButton(124, 120, 2103, 2104, (int)ItemInfoButtons.CopyItemName, GumpButtonType.Reply, 0);
            AddButton(124, 143, 2103, 2104, (int)ItemInfoButtons.CopySerial, GumpButtonType.Reply, 0);
            AddButton(124, 168, 2103, 2104, (int)ItemInfoButtons.CopyId, GumpButtonType.Reply, 0);
            AddButton(124, 191, 2103, 2104, (int)ItemInfoButtons.CopyHue, GumpButtonType.Reply, 0);
            
            AddTextEntry(219, 115, 116, 20, 62, (int)ItemInfoButtons.ItemName, $"{item.ItemID.ItemData.Name}");
            AddTextEntry(219, 141, 116, 20, 62, (int)ItemInfoButtons.Serial, $"{item.Serial}");
            AddTextEntry(219, 165, 116, 20, 62, (int)ItemInfoButtons.Id, $"{item.ItemID.Value}");

            if (item.Hue == 0)
                AddTextEntry(219, 188, 116, 20, 62, (int)ItemInfoButtons.Hue, "Default (0)");
            else
                AddTextEntry(219, 188, 116, 20, item.Hue - 1, (int)ItemInfoButtons.Hue, $"{item.Hue}");

        }

        public override void OnResponse(int buttonId, int[] switches, GumpTextEntry[] textEntries = null)
        {
            switch (buttonId)
            {
                case (int)ItemInfoButtons.CopyItemName:
                    Clipboard.SetText(_item.ItemID.ItemData.Name);
                    World.Player.SendMessage(MsgLevel.Force, Language.Format(LocString.ScriptCopied, _item.ItemID.ItemData.Name), false);
                    break;
                case (int)ItemInfoButtons.CopySerial:
                    Clipboard.SetText(_item.Serial.ToString());
                    World.Player.SendMessage(MsgLevel.Force, Language.Format(LocString.ScriptCopied, _item.Serial.ToString()), false);
                    break;
                case (int)ItemInfoButtons.CopyId:
                    Clipboard.SetText(_item.ItemID.Value.ToString());
                    World.Player.SendMessage(MsgLevel.Force, Language.Format(LocString.ScriptCopied, _item.ItemID.Value.ToString()), false);
                    break;
                case (int)ItemInfoButtons.CopyHue:
                    Clipboard.SetText(_item.Hue.ToString());
                    World.Player.SendMessage(MsgLevel.Force, Language.Format(LocString.ScriptCopied, _item.Hue.ToString()), false);
                    break;
                case (int)ItemInfoButtons.Okay:
                    Resend = false;
                    break;
            }

            base.OnResponse(buttonId, switches, textEntries);
        }
    }
}

================================================
FILE: Razor/Gumps/Internal/MobileInfoGump.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System.Text;
using System.Windows.Forms;

namespace Assistant.Gumps.Internal
{
    public sealed class MobileInfoGump : Gump
    {
        private enum MobileInfoButtons
        {
            Okay,
            CopyName,
            CopySerial,
            CopyHue,
            CopyBody,
            Name,
            Serial,
            Hue,
            Body
        }

        private Mobile _mobile { get; }

        public MobileInfoGump(Mobile mobile) : base(500, 250, -1)
        {
            _mobile = mobile;

            Closable = true;
            Disposable = true;
            Movable = true;
            Resizable = false;
            Resend = true;

            AddPage(0);

            AddBackground(106, 72, 253, 289, 3600);

            AddLabel(143, 115, 900, "Name:");
            AddLabel(142, 140, 900, "Serial:");
            AddLabel(142, 164, 900, "Hue:");
            AddLabel(142, 188, 900, "Body:");
            AddLabel(197, 87, 154, "Mobile Data");

            AddButton(276, 318, 247, 248, (int)MobileInfoButtons.Okay, GumpButtonType.Reply, 0);

            AddButton(124, 121, 2103, 2104, (int)MobileInfoButtons.CopyName, GumpButtonType.Reply, 0);
            AddButton(124, 144, 2103, 2104, (int)MobileInfoButtons.CopySerial, GumpButtonType.Reply, 0);
            AddButton(124, 169, 2103, 2104, (int)MobileInfoButtons.CopyHue, GumpButtonType.Reply, 0);
            AddButton(124, 194, 2103, 2104, (int)MobileInfoButtons.CopyBody, GumpButtonType.Reply, 0);

            AddTextEntry(219, 118, 116, 20, 62, (int)MobileInfoButtons.Name, $"{mobile.Name}");
            AddTextEntry(219, 142, 116, 20, 62, (int)MobileInfoButtons.Serial, $"{mobile.Serial}");
            AddTextEntry(219, 166, 116, 20, 62, (int)MobileInfoButtons.Hue, $"{mobile.Hue}");

            AddTextEntry(219, 190, 116, 20, 62, (int) MobileInfoButtons.Body, $"{mobile.Body}");

            StringBuilder sb = new StringBuilder();
            sb.AppendLine($"Position: {_mobile.Position}");
            sb.AppendLine($"Notoriety: {_mobile.Notoriety}");
            sb.AppendLine($"IsGhost: {mobile.IsGhost}");
            sb.AppendLine($"IsHuman: {mobile.IsHuman}");
            sb.AppendLine($"IsMonster: {mobile.IsMonster}");
            sb.AppendLine($"Blessed: {mobile.Blessed}");

            AddHtml(124, 223, 211, 88, sb.ToString(), true, true);
        }

        public override void OnResponse(int buttonId, int[] switches, GumpTextEntry[] textEntries = null)
        {
            switch (buttonId)
            {
                case (int)MobileInfoButtons.CopyName:
                    Clipboard.SetText(_mobile.Name);
                    World.Player.SendMessage(MsgLevel.Force, Language.Format(LocString.ScriptCopied, _mobile.Name), false);
                    break;
                case (int)MobileInfoButtons.CopySerial:
                    Clipboard.SetText(_mobile.Serial.ToString());
                    World.Player.SendMessage(MsgLevel.Force, Language.Format(LocString.ScriptCopied, _mobile.Serial.ToString()), false);
                    break;
                case (int)MobileInfoButtons.CopyHue:
                    Clipboard.SetText(_mobile.Hue.ToString());
                    World.Player.SendMessage(MsgLevel.Force, Language.Format(LocString.ScriptCopied, _mobile.Hue.ToString()), false);
                    break;
                case (int)MobileInfoButtons.CopyBody:
                    Clipboard.SetText(_mobile.Body.ToString());
                    World.Player.SendMessage(MsgLevel.Force, Language.Format(LocString.ScriptCopied, _mobile.Body.ToString()), false);
                    break;
                case (int)MobileInfoButtons.Okay:
                    Resend = false;
                    break;
            }

            base.OnResponse(buttonId, switches, textEntries);
        }
    }
}

================================================
FILE: Razor/Gumps/Internal/SystemMessagesGump.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System.Linq;
using System.Windows.Forms;
using Assistant.Core;

namespace Assistant.Gumps.Internal
{
    public sealed class SystemMessagesGump : Gump
    {
        public SystemMessagesGump() : base(0, 0)
        {
            Closable = true;
            Disposable = true;
            Movable = true;
            Resizable = false;
            Resend = true;

            int pageCount = 1;

            AddPage(pageCount);
            AddBackground(0, 0, 527, 201, 9270);
            AddLabel(18, 13, 252, $"System Messages ({SystemMessages.Messages.Count})");
            AddButton(460, 15, 9909, 9911, 1234, GumpButtonType.Page, pageCount);
            AddButton(483, 14, 9903, 9905, 1235, GumpButtonType.Page, pageCount + 1);

            int textY = 40;
            int buttonY = 42;
            int id = 0;
            int count = 0;

            foreach (string message in SystemMessages.Messages.ToArray().Reverse())
            {
                AddButton(18, buttonY, 1209, 1210, id, GumpButtonType.Reply, 0);
                AddTextEntry(44, textY, 463, 20, 2954, id, SystemMessages.Messages[count]);

                id++;
                count++;
                buttonY += 30;
                textY += 30;

                if (count % 5 == 0)
                {
                    AddButton(483, 14, 9903, 9905, pageCount + 2, GumpButtonType.Page, pageCount + 1);

                    pageCount++;
                    textY = 40;
                    buttonY = 42;

                    AddPage(pageCount);
                    AddBackground(0, 0, 527, 201, 9270);
                    AddLabel(18, 13, 252, $"System Messages ({SystemMessages.Messages.Count})");
                    AddButton(460, 15, 9909, 9911, pageCount + 1, GumpButtonType.Page, pageCount - 1);
                }
            }
        }

        public override void OnResponse(int buttonId, int[] switches, GumpTextEntry[] textEntries = null)
        {
            if (buttonId == 0)
            {
                Resend = false;
                CloseGump();

                return;
            }

            if (buttonId > SystemMessages.Messages.Count)
                return;

            Clipboard.SetText(SystemMessages.Messages[buttonId]);
            World.Player.SendMessage(MsgLevel.Force, Language.Format(LocString.ScriptCopied, SystemMessages.Messages[buttonId]), false);
        }
    }
}


================================================
FILE: Razor/Gumps/Internal/TestMessageGump.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

namespace Assistant.Gumps.Internal
{
    public sealed class TestMessageGump : Gump
    {
        public TestMessageGump(string message) : base(500, 250, -1)
        {
            X = 300;
            Y = 200;

            Movable = true;
            Closable = true;
            Disposable = false;

            AddPage(0);
            AddBackground(0, 0, 500, 400, 9270);
            AddHtml(20, 20, 460, 330, message, true, true);
            AddButton(200, 360, 247, 248, 0, GumpButtonType.Reply, 0);
            AddButton(420, 360, 247, 248, 1, GumpButtonType.Reply, 0);
        }

        public override void OnResponse(int buttonId, int[] switches, GumpTextEntry[] textEntries = null)
        {
            World.Player.OverheadMessage($"Button {buttonId}");
            base.OnResponse(buttonId, switches, textEntries);
        }
    }
}

================================================
FILE: Razor/HotKeys/Counters.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

namespace Assistant.HotKeys
{
    public class CounterHotKeys
    {
        public static void Initialize()
        {
            HotKey.Add(HKCategory.Misc, LocString.DispCounters, new HotKeyCallback(DispCounters));
            HotKey.Add(HKCategory.Misc, LocString.RecountCounters, new HotKeyCallback(Recount));
        }

        private static void Recount()
        {
            Counter.FullRecount();
        }

        private static void DispCounters()
        {
            for (int i = 0; i < Counter.List.Count; i++)
            {
                Counter c = (Counter) Counter.List[i];

                if (c.Enabled)
                    World.Player.SendMessage(MsgLevel.Force, "{0}: {1}", c.Name, c.Amount);
            }
        }
    }
}

================================================
FILE: Razor/HotKeys/HotKeys.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Text;
using System.Xml;
using Assistant.Scripts;
using Assistant.UI;

namespace Assistant
{
    [Flags]
    public enum ModKeys : int
    {
        None = 0,
        Alt = 0x0001,
        Control = 0x0002,
        Shift = 0x0004
    }

    public delegate void HotKeyCallback();

    public delegate void HotKeyCallbackState(ref object state);

    public enum HKCategory
    {
        None = 0,
        Items,
        Targets,
        Agents,
        Dress,
        Macros,
        Spells,
        Skills,
        Misc,
        Friends,
        Scripts
    }

    public enum HKSubCat
    {
        None = 0,

        // spells: (these all are # oriented, so be careful)
        SpellOffset,
        FirstC,
        SecondC,
        ThirdC,
        FourthC,
        FifthC,
        SixthC,
        SeventhC,
        EighthC,
        NecroC = SpellOffset + 10,
        PaladinC = SpellOffset + 20,

        //items
        Potions,

        // misc:
        SpecialMoves,

        // more # oriented, CAUTION!
        BushidoC = SpellOffset + 40,
        NinjisuC = SpellOffset + 50,
        SpellWeaveC = SpellOffset + 60,
        MystC = SpellOffset + 65,
        MasteriesC = SpellOffset + 70,

        // pet commands
        PetCommands = 780, //1749

        SubTargetCriminal = 796,
        SubTargetEnemy,
        SubTargetFriendly,
        SubTargetGrey,
        SubTargetInnocent,
        SubTargetMurderer,
        SubTargetNonFriendly,
    }

    public class KeyData
    {
        private int _name;
        private string _sName;
        private HotKeyCallback _callback;
        private HotKeyCallbackState _callbackState;
        private bool _sendToUO;
        private int _key;
        private ModKeys _mod;
        private TreeNode _node;
        private object _state;
        private string _command;

        public object pState => _state;

        private DateTime _lastTriggerTime = DateTime.MinValue;

        public string DisplayName => _name != 0 ? Language.GetString(_name) : _sName;

        public int LocName => _name;

        public string StrName => _sName;

        public string Command
        {
            get => _command;
            set => _command = value;
        }

        public KeyData(int name, HKCategory cat, HKSubCat sub, HotKeyCallback call)
        {
            _name = name;
            _sName = null;
            _callback = call;
            _callbackState = null;
            _node = HotKey.MakeNode(HotKey.FindParent(cat, sub), ToString(), this);
        }

        public KeyData(int name, HKCategory cat, HKSubCat sub, HotKeyCallbackState call, object state)
        {
            _name = name;
            _sName = null;
            _callback = null;
            _callbackState = call;
            _state = state;
            _node = HotKey.MakeNode(HotKey.FindParent(cat, sub), ToString(), this);
        }

        public KeyData(string name, HKCategory cat, HKSubCat sub, HotKeyCallback call)
        {
            _name = 0;
            _sName = name;
            _callback = call;
            _callbackState = null;
            _node = HotKey.MakeNode(HotKey.FindParent(cat, sub), ToString(), this);
        }

        public KeyData(string name, HKCategory cat, HKSubCat sub, HotKeyCallbackState call, object state)
        {
            _name = 0;
            _sName = name;
            _callback = null;
            _callbackState = call;
            _state = state;
            _node = HotKey.MakeNode(HotKey.FindParent(cat, sub), ToString(), this);
        }

        public void Callback()
        {
            // protect again weird keyboard oddities which "double press" the keys when the user only wanted to do an action once
            if (_lastTriggerTime + TimeSpan.FromMilliseconds(20) <= DateTime.UtcNow)
            {
                _lastTriggerTime = DateTime.UtcNow;

                if (_callback != null)
                    _callback();
                else if (_callbackState != null)
                    _callbackState(ref _state);
            }
        }

        public void Remove()
        {
            _node.Remove();
            _node.Text = "removed";
        }

        public bool SendToUO
        {
            get => _sendToUO;
            set => _sendToUO = value;
        }

        public int Key
        {
            get => _key;
            set
            {
                if (_key != value)
                {
                    _key = value;
                    _node.Text = ToString();
                }
            }
        }

        public ModKeys Mod
        {
            get => _mod;
            set
            {
                if (_mod != value)
                {
                    _mod = value;
                    _node.Text = ToString();
                }
            }
        }

        public string KeyString(bool smallNames = false)
        {
            if (Key != 0)
            {
                StringBuilder sb = new StringBuilder();
                bool np = false;

                if ((Mod & ModKeys.Control) != 0)
                {
                    sb.Append(smallNames ? "Ctrl" : "Control");

                    np = true;
                }

                if ((Mod & ModKeys.Alt) != 0)
                {
                    if (np)
                        sb.Append("+");
                    sb.Append("Alt");
                    np = true;
                }

                if ((Mod & ModKeys.Shift) != 0)
                {
                    if (np)
                        sb.Append("+");
                    sb.Append(smallNames ? "Sft" : "Shift");
                    np = true;
                }

                if (np)
                    sb.Append("+");

                switch (Key)
                {
                    case -1:
                        sb.Append("Wheel UP");
                        break;
                    case -2:
                        sb.Append("Wheel DOWN");
                        break;
                    case -3:
                        sb.Append("Middle Button");
                        break;
                    case -4:
                        sb.Append("XButton 1");
                        break;
                    case -5:
                        sb.Append("XButton 2");
                        break;
                    default:
                        sb.Append(((Keys) Key).ToString());
                        break;
                }

                return sb.ToString();
            }
            else
            {
                return null;
            }
        }


        public override string ToString()
        {
            if (Key != 0)
                return $"{this.DisplayName} ({KeyString()})";
            
            return $"{this.DisplayName} ({Language.GetString(LocString.NotAssigned)})";
        }
    }

    public class HotKey
    {
        private static List<KeyData> m_List = new List<KeyData>();
        private static TreeNode m_Root = new TreeNode("Hot Keys");
        private static bool m_Enabled;
        private static System.Windows.Forms.Label m_Status;
        private static KeyData m_HK_En;

        private static KeyData _hotKeyEnableToggle;
        private static KeyData _hotKeyDisableToggle;

        public static List<KeyData> List
        {
            get { return m_List; }
        }

        public static TreeNode RootNode
        {
            get { return m_Root; }
        }

        public static System.Windows.Forms.Label Status
        {
            get { return m_Status; }
            set
            {
                m_Status = value;
                UpdateStatus();
            }
        }


        public static bool KeyDown(Keys k)
        {
            return (Platform.GetAsyncKeyState((int) k) & 0xFF00) != 0; //|| Client.IsKeyDown( (int)k );
        }

        public static void Initialize()
        {
            m_HK_En = Add(HKCategory.None, LocString.ToggleHKEnable, new HotKeyCallback(OnToggleEnableDisable));

            _hotKeyEnableToggle = Add(HKCategory.None, LocString.EnableHotkeys, OnToggleEnable);
            _hotKeyDisableToggle = Add(HKCategory.None, LocString.DisableHotkeys, OnToggleDisable);
        }

        private static void OnToggleEnableDisable()
        {
            m_Enabled = !m_Enabled;

            MsgLevel type = MsgLevel.Warning;

            if (m_Enabled)
            {
                type = MsgLevel.Info;
            }

            if (World.Player != null)
                World.Player.SendMessage(type, UpdateStatus());
        }

        private static void OnToggleEnable()
        {
            if (m_Enabled)
            {
                if (World.Player != null)
                    World.Player.SendMessage(MsgLevel.Warning, "HotKeys are already enabled");
            }
            else
            {
                m_Enabled = !m_Enabled;
                if (World.Player != null)
                    World.Player.SendMessage(MsgLevel.Info, UpdateStatus());
            }
        }

        private static void OnToggleDisable()
        {
            if (!m_Enabled)
            {
                if (World.Player != null)
                    World.Player.SendMessage(MsgLevel.Warning, "HotKeys are already disabled");
            }
            else
            {
                m_Enabled = !m_Enabled;
                if (World.Player != null)
                    World.Player.SendMessage(MsgLevel.Warning, UpdateStatus());
            }
        }


        public static string UpdateStatus()
        {
            KeyData kd = Get((int) LocString.ToggleHKEnable);
            string ks = null;
            if (kd != null)
                ks = kd.KeyString();

            string msg;
            if (ks != null)
            {
                if (m_Enabled)
                    msg = Language.Format(LocString.HKEnabledPress, ks);
                else
                    msg = Language.Format(LocString.HKDisabledPress, ks);
            }
            else
            {
                if (m_Enabled)
                    msg = Language.GetString(LocString.HKEnabled);
                else
                    msg = Language.GetString(LocString.HKDisabled);
            }

            m_Status?.SafeAction(s => { s.Text = msg; });

            return msg;
        }

        public static bool ValidateCommand(string command)
        {
            if (string.IsNullOrEmpty(command))
            {
                return false;
            }

            foreach (KeyData keyData in List)
            {
                if (!string.IsNullOrEmpty(keyData.Command) && keyData.Command.Equals(command, StringComparison.OrdinalIgnoreCase))
                {
                    return false;
                }
            }

            foreach (string cmd in Command.GetCommands)
            {
                if (!string.IsNullOrEmpty(cmd) && cmd.Equals(command, StringComparison.OrdinalIgnoreCase))
                {
                    return false;
                }
            }

            return true;
        }

        public static bool ExecuteCommand(string command)
        {
            foreach (KeyData keyData in List)
            {
                if (!string.IsNullOrEmpty(keyData.Command) && keyData.Command.Equals(command, StringComparison.OrdinalIgnoreCase))
                {
                    keyData.Callback();
                    return true;
                }
            }

            return false;
        }

        static HotKey()
        {
            m_Enabled = true;

            m_Root.Tag = (int) LocString.HotKeys;

            TreeNode items = MakeNode("Items", HKCategory.Items);

            MakeNode(items, "Potions", HKSubCat.Potions);

            TreeNode targets = MakeNode("Targets", HKCategory.Targets);

            MakeNode(targets, "Criminal Targets", HKSubCat.SubTargetCriminal);
            MakeNode(targets, "Enemy Targets", HKSubCat.SubTargetEnemy);
            MakeNode(targets, "Friendly Targets", HKSubCat.SubTargetFriendly);
            MakeNode(targets, "Grey Targets", HKSubCat.SubTargetGrey);
            MakeNode(targets, "Innocent Targets", HKSubCat.SubTargetInnocent);
            MakeNode(targets, "Murderer Targets", HKSubCat.SubTargetMurderer);
            MakeNode(targets, "Non-Friendly Targets", HKSubCat.SubTargetNonFriendly);

            MakeNode("Agents", HKCategory.Agents);

            MakeNode("Dress", HKCategory.Dress);

            MakeNode("Macros", HKCategory.Macros);

            TreeNode spells = MakeNode("Spells", HKCategory.Spells);
            MakeNode(spells, "1st", HKSubCat.FirstC);
            MakeNode(spells, "2nd", HKSubCat.SecondC);
            MakeNode(spells, "3rd", HKSubCat.ThirdC);
            MakeNode(spells, "4th", HKSubCat.FourthC);
            MakeNode(spells, "5th", HKSubCat.FifthC);
            MakeNode(spells, "6th", HKSubCat.SixthC);
            MakeNode(spells, "7th", HKSubCat.SeventhC);
            MakeNode(spells, "8th", HKSubCat.EighthC);
            MakeNode(spells, "Necro", HKSubCat.NecroC);
            MakeNode(spells, "Paladin", HKSubCat.PaladinC);
            MakeNode(spells, "Bushido", HKSubCat.BushidoC);
            MakeNode(spells, "Ninjisu", HKSubCat.NinjisuC);
            MakeNode(spells, "Spellweaving", HKSubCat.SpellWeaveC);
            MakeNode(spells, "Mysticism", HKSubCat.MystC);
            MakeNode(spells, "Masteries", HKSubCat.MasteriesC);

            MakeNode("Skills", HKCategory.Skills);

            TreeNode misc = MakeNode("Misc", HKCategory.Misc);
            MakeNode(misc, "Special Moves", HKSubCat.SpecialMoves);
            MakeNode(misc, "Pet Commands", HKSubCat.PetCommands);

            MakeNode("Friends", HKCategory.Friends);
            MakeNode("Scripts", HKCategory.Scripts);
        }

        public static void RebuildList(TreeView tree)
        {
            tree.BeginUpdate();
            UpdateNode(m_Root);

            tree.Nodes.Clear();
            tree.Nodes.Add(m_Root);
            m_Root.Expand();
            tree.EndUpdate();
        }

        private static void UpdateNode(TreeNode node)
        {
            if (node != null)
            {
                if (node.Tag is KeyData)
                    node.Text = ((KeyData) node.Tag).ToString();
                else if (node.Tag is HKCategory)
                    node.Text = Language.GetString((int) LocString.HotKeys + (int) ((HKCategory) node.Tag));
                else if (node.Tag is HKSubCat)
                    node.Text = Language.GetString(GetHKSubCatLangKey((HKSubCat) node.Tag));
                else if (node.Tag is Int32)
                    node.Text = Language.GetString((int) node.Tag);

                if (node != m_Root && node.NextNode != null)
                    UpdateNode(node.NextNode);
                if (node.GetNodeCount(true) > 0)
                    UpdateNode(node.FirstNode);
            }
        }

        private static int GetHKSubCatLangKey(HKSubCat tag)
        {
            switch (tag)
            {
                case HKSubCat.MystC:
                    return 2103;
                case HKSubCat.MasteriesC:
                    return 2104;
                default:
                    return (int)LocString.HKSubOffset + (int) tag;
            }
        }

        public static void ClearAll()
        {
            for (int i = 0; i < m_List.Count; i++)
            {
                KeyData kd = m_List[i];
                kd.Key = 0;
                kd.Mod = ModKeys.None;
                kd.SendToUO = false;
            }
        }

        public static KeyData GetFromObj(object other)
        {
            for (int i = 0; i < m_List.Count; i++)
            {
                if (m_List[i].pState == other)
                    return m_List[i];
            }

            return null;
        }

        public static KeyData Get(int name)
        {
            for (int i = 0; i < m_List.Count; i++)
            {
                if (((KeyData) m_List[i]).LocName == name)
                    return (KeyData) m_List[i];
            }

            return null;
        }

        public static KeyData Get(string name)
        {
            for (int i = 0; i < m_List.Count; i++)
            {
                if (((KeyData) m_List[i]).StrName == name)
                    return (KeyData) m_List[i];
            }

            return null;
        }

        public static KeyData GetByNameOrId(string query)
        {
            foreach (KeyData key in m_List)
            {
                if (key.DisplayName.ToLower().Equals(query.ToLower()))
                    return key;
            }

            int hkIndex = Utility.ToInt32(query, -1);

            return hkIndex != -1 ? m_List[hkIndex] : null;
        }

        public static KeyData Get(int key, ModKeys mod)
        {
            for (int i = 0; i < m_List.Count; i++)
            {
                KeyData hk = (KeyData) m_List[i];
                if (hk.Key == key && hk.Mod == mod && hk.Key != 0)
                    return hk;
            }

            return null;
        }

        public static TreeNode FindParent(TreeNode root, HKCategory cat, HKSubCat sub)
        {
            TreeNode parent = root;
            if (cat != HKCategory.None)
            {
                parent = FindNode(root, cat);
                if (sub != HKSubCat.None && parent != null)
                {
                    TreeNode subNode = FindNode(parent, sub);
                    if (subNode != null)
                        parent = subNode;
                }
            }

            return parent;
        }

        public static TreeNode FindParent(HKCategory cat, HKSubCat sub)
        {
            return FindParent(m_Root, cat, sub);
        }

        public static TreeNode MakeNode(TreeNode parent, string text, object tag)
        {
            TreeNode n = new TreeNode(text);
            n.Tag = tag;
            parent.Nodes.Add(n);
            return n;
        }

        public static TreeNode MakeNode(string text, object tag)
        {
            return MakeNode(m_Root, text, tag);
        }

        public static TreeNode FindNode(TreeNode parent, object tag, bool recurse)
        {
            if (tag == null)
                return null;

            TreeNode n = parent.FirstNode;
            while (n != null)
            {
                if (tag.ToString() == n.Tag.ToString())
                    break;

                if (recurse)
                {
                    TreeNode r = FindNode(n, tag, true);
                    if (r != null)
                        return r;
                }

                n = n.NextNode;
            }

            return n;
        }

        public static TreeNode FindNode(TreeNode parent, object tag)
        {
            return FindNode(parent, tag, false);
        }

        public static bool OnKeyDown(int key, ModKeys mod)
        {
            if (World.Player == null)
                return true;
            ModKeys cur = mod;
            if (KeyDown(Keys.ControlKey))
                cur |= ModKeys.Control;
            if (KeyDown(Keys.Menu))
                cur |= ModKeys.Alt;
            if (KeyDown(Keys.ShiftKey))
                cur |= ModKeys.Shift;

            if (m_HK_En != null && m_HK_En.Key > 0 && m_HK_En.Mod == cur &&
                (m_HK_En.Key == key || KeyDown((Keys) m_HK_En.Key)))
            {
                m_HK_En.Callback();
                return m_HK_En.SendToUO;
            }

            if (_hotKeyEnableToggle != null && _hotKeyEnableToggle.Key > 0 && _hotKeyEnableToggle.Mod == cur &&
                (_hotKeyEnableToggle.Key == key || KeyDown((Keys) _hotKeyEnableToggle.Key)))
            {
                _hotKeyEnableToggle.Callback();
                return _hotKeyEnableToggle.SendToUO;
            }

            if (_hotKeyDisableToggle != null && _hotKeyDisableToggle.Key > 0 && _hotKeyDisableToggle.Mod == cur &&
                (_hotKeyDisableToggle.Key == key || KeyDown((Keys) _hotKeyDisableToggle.Key)))
            {
                _hotKeyDisableToggle.Callback();
                return _hotKeyDisableToggle.SendToUO;
            }

            if (m_Enabled)
            {
                for (int i = 0; i < m_List.Count; i++)
                {
                    KeyData hk = (KeyData) m_List[i];
                    if (hk.Mod == cur && hk.Key > 0)
                    {
                        if (hk.Key == key)
                        {
                            if (Macros.MacroManager.AcceptActions)
                                Macros.MacroManager.Action(new Macros.HotKeyAction(hk));

                            ScriptManager.AddToScript($"hotkey '{hk.DisplayName}'");

                            hk.Callback();
                            return hk.SendToUO;
                        }
                    }
                }

                // if pressed key didn't match a hotkey, check for any key currently down
                for (int i = 0; i < m_List.Count; i++)
                {
                    KeyData hk = (KeyData) m_List[i];
                    if (hk.Mod == cur && hk.Key > 0)
                    {
                        if (KeyDown((Keys) hk.Key))
                        {
                            if (Macros.MacroManager.AcceptActions)
                                Macros.MacroManager.Action(new Macros.HotKeyAction(hk));

                            ScriptManager.AddToScript($"hotkey '{hk.DisplayName}'");

                            hk.Callback();
                            return hk.SendToUO;
                        }
                    }
                }
            }

            return true;
        }

        public static void OnMouse(int button, int wheel)
        {
            if (World.Player == null || !m_Enabled)
                return;

            ModKeys cur = ModKeys.None;
            int key = 0;
            switch (button)
            {
                case 0:
                    key = wheel > 0 ? -1 : -2;
                    break;
                case 1:
                    key = -3;
                    break;
                case 2:
                    key = -4;
                    break;
                case 3:
                    key = -5;
                    break;
            }

            if (KeyDown(Keys.ControlKey))
                cur |= ModKeys.Control;
            if (KeyDown(Keys.Menu))
                cur |= ModKeys.Alt;
            if (KeyDown(Keys.ShiftKey))
                cur |= ModKeys.Shift;

            KeyData hk = Get(key, cur);
            if (hk != null)
                hk.Callback();
        }

        public static KeyData Add(HKCategory cat, int name, HotKeyCallback callback)
        {
            return Add(cat, HKSubCat.None, name, callback);
        }

        public static KeyData Add(HKCategory cat, LocString name, HotKeyCallback callback)
        {
            return Add(cat, HKSubCat.None, (int) name, callback);
        }

        public static KeyData Add(HKCategory cat, HKSubCat sub, int name, HotKeyCallback callback)
        {
            KeyData kd = new KeyData(name, cat, sub, callback);
            m_List.Add(kd);
            return kd;
        }

        public static KeyData Add(HKCategory cat, HKSubCat sub, LocString name, HotKeyCallback callback)
        {
            KeyData kd = new KeyData((int) name, cat, sub, callback);
            m_List.Add(kd);
            return kd;
        }

        public static KeyData Add(HKCategory cat, HKSubCat sub, string name, HotKeyCallback callback)
        {
            KeyData kd = new KeyData(name, cat, sub, callback);
            m_List.Add(kd);
            return kd;
        }

        public static KeyData Add(HKCategory cat, int name, HotKeyCallbackState callback, object state)
        {
            return Add(cat, HKSubCat.None, name, callback, state);
        }

        public static KeyData Add(HKCategory cat, LocString name, HotKeyCallbackState callback, object state)
        {
            return Add(cat, HKSubCat.None, (int) name, callback, state);
        }

        public static KeyData Add(HKCategory cat, HKSubCat sub, int name, HotKeyCallbackState callback, object state)
        {
            KeyData kd = new KeyData(name, cat, sub, callback, state);
            m_List.Add(kd);
            return kd;
        }

        public static KeyData Add(HKCategory cat, HKSubCat sub, LocString name, HotKeyCallbackState callback,
            object state)
        {
            KeyData kd = new KeyData((int) name, cat, sub, callback, state);
            m_List.Add(kd);
            return kd;
        }

        public static KeyData Add(HKCategory cat, HKSubCat sub, string name, HotKeyCallbackState callback, object state)
        {
            KeyData kd = new KeyData(name, cat, sub, callback, state);
            m_List.Add(kd);
            return kd;
        }

        public static bool Remove(int name)
        {
            if (name == 0)
                return false;

            for (int i = 0; i < m_List.Count; i++)
            {
                KeyData hk = (KeyData) m_List[i];
                if (hk.LocName == name)
                {
                    hk.Remove();
                    m_List.RemoveAt(i);
                    return true;
                }
            }

            return false;
        }

        public static bool Remove(string name)
        {
            if (name == null)
                return false;

            for (int i = 0; i < m_List.Count; i++)
            {
                KeyData hk = (KeyData) m_List[i];
                if (hk.StrName == name)
                {
                    hk.Remove();
                    m_List.RemoveAt(i);
                    return true;
                }
            }

            return false;
        }

        public static void Load(XmlElement xml)
        {
            if (xml == null)
                return;

            ClearAll();

            foreach (XmlElement el in xml.GetElementsByTagName("key"))
            {
                try
                {
                    string name = el.GetAttribute("name");
                    string loc = el.GetAttribute("loc");
                    string mod = el.GetAttribute("mod");
                    string key = el.GetAttribute("key");
                    string send = el.GetAttribute("send");
                    string command = el.GetAttribute("command");

                    if (!ValidateCommand(command))
                    {
                        command = string.Empty;
                    }

                    KeyData k = null;

                    if (loc != null && loc.Length > 0)
                    {
                        k = Get(Convert.ToInt32(loc));
                    }
                    else if (name != null && name.Length > 0)
                    {
                        k = Get(name);
                    }
                    else if (el.InnerText != null && el.InnerText.Length > 1)
                    {
                        if (el.InnerText[0] == 'L' && el.InnerText[1] == ':')
                        {
                            try
                            {
                                k = Get(Convert.ToInt32(el.InnerText.Substring(2)));
                            }
                            catch
                            {
                                // ignored
                            }
                        }
                        else
                        {
                            k = Get(el.InnerText);
                        }
                    }

                    if (k != null)
                    {
                        k.Mod = (ModKeys) Convert.ToInt32(mod);
                        k.Key = Convert.ToInt32(key);
                        k.SendToUO = Convert.ToBoolean(send);
                        k.Command = command;
                    }
                }
                catch
                {
                    // ignored
                }
            }
        }

        public static void Save(XmlTextWriter xml)
        {
            for (int i = 0; i < m_List.Count; i++)
            {
                KeyData k = (KeyData) m_List[i];

                if (k.Key != 0)
                {
                    xml.WriteStartElement("key");
                    xml.WriteAttributeString("mod", ((int) k.Mod).ToString());
                    xml.WriteAttributeString("key", k.Key.ToString());
                    xml.WriteAttributeString("send", k.SendToUO.ToString());
                    xml.WriteAttributeString("command", string.IsNullOrEmpty(k.Command) ? string.Empty : k.Command);

                    //xml.WriteAttributeString( "name", ((int)k.LocName).ToString() );
                    if (k.LocName != 0)
                        xml.WriteString("L:" + k.LocName.ToString());
                    else
                        xml.WriteString(k.StrName); //xml.WriteAttributeString( "name", k.StrName );

                    xml.WriteEndElement();
                }
            }
        }
    }
}


================================================
FILE: Razor/HotKeys/Misc.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using Assistant.Core;
using Assistant.Gumps.Internal;

namespace Assistant.HotKeys
{
    public class UseHotKeys
    {
        private static Serial _grabHotBag = Serial.Zero;

        public static void Initialize()
        {
            HotKey.Add(HKCategory.Misc, LocString.Resync, new HotKeyCallback(Resync));

            HotKey.Add(HKCategory.Misc, LocString.GoldPerHotkey, new HotKeyCallback(ToggleGoldPer));
            HotKey.Add(HKCategory.Misc, LocString.DamageTracker, new HotKeyCallback(ToggleDamage));

            HotKey.Add(HKCategory.Misc, LocString.CaptureBod, new HotKeyCallback(CaptureBod));

            HotKey.Add(HKCategory.Misc, LocString.ClearDragDropQueue, new HotKeyCallback(DragDropManager.GracefulStop));

            HotKey.Add(HKCategory.Misc, LocString.LastSpell, new HotKeyCallback(LastSpell));
            HotKey.Add(HKCategory.Misc, LocString.LastSkill, new HotKeyCallback(LastSkill));
            HotKey.Add(HKCategory.Misc, LocString.LastObj, new HotKeyCallback(LastObj));
            HotKey.Add(HKCategory.Misc, LocString.AllNames, new HotKeyCallback(AllNames));
            HotKey.Add(HKCategory.Misc, LocString.AllCorpses, new HotKeyCallback(AllCorpses));
            HotKey.Add(HKCategory.Misc, LocString.AllMobiles, new HotKeyCallback(AllMobiles));
            HotKey.Add(HKCategory.Misc, LocString.Dismount, new HotKeyCallback(Dismount));

            HotKey.Add(HKCategory.Items, LocString.BandageSelf, new HotKeyCallback(BandageSelf));
            HotKey.Add(HKCategory.Items, LocString.BandageLT, new HotKeyCallback(BandageLastTarg));
            HotKey.Add(HKCategory.Items, LocString.UseHand, new HotKeyCallback(UseItemInHand));
            HotKey.Add(HKCategory.Items, LocString.UseRightHand, new HotKeyCallback(UseItemInRightHand));
            HotKey.Add(HKCategory.Items, LocString.UseLeftHand, new HotKeyCallback(UseItemInLeftHand));

            HotKey.Add(HKCategory.Misc, LocString.PartyAccept, new HotKeyCallback(PartyAccept));
            HotKey.Add(HKCategory.Misc, LocString.PartyDecline, new HotKeyCallback(PartyDecline));
            HotKey.Add(HKCategory.Misc, LocString.PartyAdd, new HotKeyCallback(PartyAdd));

            HotKey.Add(HKCategory.Misc, HKSubCat.PetCommands, LocString.AllCome, new HotKeyCallback(PetAllCome));
            HotKey.Add(HKCategory.Misc, HKSubCat.PetCommands, LocString.AllFollowMe,
                new HotKeyCallback(PetAllFollowMe));
            HotKey.Add(HKCategory.Misc, HKSubCat.PetCommands, LocString.AllFollow, new HotKeyCallback(PetAllFollow));
            HotKey.Add(HKCategory.Misc, HKSubCat.PetCommands, LocString.AllGuardMe, new HotKeyCallback(PetAllGuardMe));
            HotKey.Add(HKCategory.Misc, HKSubCat.PetCommands, LocString.AllGuard, new HotKeyCallback(PetAllGuard));
            HotKey.Add(HKCategory.Misc, HKSubCat.PetCommands, LocString.AllKill, new HotKeyCallback(PetAllKill));
            HotKey.Add(HKCategory.Misc, HKSubCat.PetCommands, LocString.AllStay, new HotKeyCallback(PetAllStay));
            HotKey.Add(HKCategory.Misc, HKSubCat.PetCommands, LocString.AllStop, new HotKeyCallback(PetAllStop));

            HotKeyCallbackState call = new HotKeyCallbackState(OnUseItem);
            HotKey.Add(HKCategory.Items, LocString.UseBandage, call, (ushort) 3617);
            HotKey.Add(HKCategory.Items, HKSubCat.Potions, LocString.DrinkHeal, call, (ushort) 3852);
            HotKey.Add(HKCategory.Items, HKSubCat.Potions, LocString.DrinkCure, call, (ushort) 3847);
            HotKey.Add(HKCategory.Items, HKSubCat.Potions, LocString.DrinkRef, call, (ushort) 3851);
            HotKey.Add(HKCategory.Items, HKSubCat.Potions, LocString.DrinkNS, call, (ushort) 3846);
            HotKey.Add(HKCategory.Items, HKSubCat.Potions, LocString.DrinkExp, call, (ushort) 3853);
            HotKey.Add(HKCategory.Items, HKSubCat.Potions, LocString.DrinkStr, call, (ushort) 3849);
            HotKey.Add(HKCategory.Items, HKSubCat.Potions, LocString.DrinkAg, call, (ushort) 3848);
            HotKey.Add(HKCategory.Items, HKSubCat.Potions, LocString.DrinkApple, new HotKeyCallback(OnDrinkApple));


            // Set the packet handler for single click and establish hotkeys for grab item
            PacketHandler.RegisterClientToServerViewer(0x09, new PacketViewerCallback(OnGrabItemSingleClick));
            HotKey.Add(HKCategory.Misc, LocString.GrabItem, new HotKeyCallback(GrabItem));
            HotKey.Add(HKCategory.Misc, LocString.SetGrabItemHotBag, new HotKeyCallback(SetGrabItemHotBag));

            _grabHotBag = Convert.ToUInt32(Config.GetString("GrabHotBag"));

            HotKey.Add(HKCategory.Misc, LocString.GumpInfo, GetInfoGump);
            HotKey.Add(HKCategory.Misc, LocString.GumpSysMsg, GetSysMsgGump);
            HotKey.Add(HKCategory.Misc, LocString.GumpHotKeys, GetHotKeysGump);
            HotKey.Add(HKCategory.Misc, LocString.GumpBoatControl, GetBoatControlGump);
        }

        private static void ToggleGoldPer()
        {
            if (GoldPerHourTimer.Running)
            {
                World.Player.SendMessage(MsgLevel.Force, "Stopping 'GoldPer Timer'");
                GoldPerHourTimer.Stop();
            }
            else
            {
                World.Player.SendMessage(MsgLevel.Force, "Starting 'GoldPer Timer' when you loot your first gold");
                GoldPerHourTimer.Start();
            }
        }

        private static void ToggleDamage()
        {
            Engine.MainWindow.ToggleDamageTracker(!DamageTracker.Running);
        }

        private enum PetCommands
        {
            AllCome,
            AllFollowMe,
            AllFollow,
            AllGuardMe,
            AllGuard,
            AllKill,
            AllStay,
            AllStop
        }

        private static void PetAllCome()
        {
            World.Player.Say(Language.GetString(LocString.AllCome));
        }

        private static void PetAllFollowMe()
        {
            World.Player.Say(Language.GetString(LocString.AllFollowMe));
        }

        private static void PetAllFollow()
        {
            World.Player.Say(Language.GetString(LocString.AllFollow));
        }

        private static void PetAllGuardMe()
        {
            World.Player.Say(Language.GetString(LocString.AllGuardMe));
        }

        private static void PetAllGuard()
        {
            World.Player.Say(Language.GetString(LocString.AllGuard));
        }

        private static void PetAllKill()
        {
            World.Player.Say(Language.GetString(LocString.AllKill));
        }

        private static void PetAllStay()
        {
            World.Player.Say(Language.GetString(LocString.AllStay));
        }

        private static void PetAllStop()
        {
            World.Player.Say(Language.GetString(LocString.AllStop));
        }

        private static void CaptureBod()
        {
            try
            {
                if (BodCapture.IsBodGump(World.Player.CurrentGumpI))
                {
                    BodCapture.CaptureBod(World.Player.CurrentGumpStrings);

                    World.Player.SendMessage(MsgLevel.Force, "BOD has been captured and saved to BODs.csv");
                }
                else
                {
                    World.Player.SendMessage(MsgLevel.Force, "The last gump you had open doesn't appear to be a BOD");
                }
            }
            catch
            {
                World.Player.SendMessage(MsgLevel.Force, "Unable to capture BOD, probably unknown format");
            }
        }


        private static void PartyAccept()
        {
            if (PacketHandlers.PartyLeader != Serial.Zero)
            {
                Client.Instance.SendToServer(new AcceptParty(PacketHandlers.PartyLeader));
                PacketHandlers.PartyLeader = Serial.Zero;
            }
        }

        private static void PartyDecline()
        {
            if (PacketHandlers.PartyLeader != Serial.Zero)
            {
                Client.Instance.SendToServer(new DeclineParty(PacketHandlers.PartyLeader));
                PacketHandlers.PartyLeader = Serial.Zero;
            }
        }

        private static void PartyAdd()
        {
            Client.Instance.SendToServer(new AddParty());
        }

        private static void Dismount()
        {
            if (World.Player.GetItemOnLayer(Layer.Mount) != null)
                ActionQueue.DoubleClick(true, World.Player.Serial);
            else
                World.Player.SendMessage("You are not mounted.");
        }

        private static void AllNames()
        {
            bool textFlags = Config.GetBool("LastTargTextFlags");

            foreach (Mobile m in World.MobilesInRange())
            {
                if (m != World.Player)
                    Client.Instance.SendToServer(new SingleClick(m));

                if (textFlags)
                    Targeting.CheckTextFlags(m);

                FriendsManager.ShowOverhead(m);
            }

            foreach (Item i in World.Items.Values)
            {
                if (i.IsCorpse)
                    Client.Instance.SendToServer(new SingleClick(i));
            }
        }

        private static void AllCorpses()
        {
            foreach (Item i in World.Items.Values)
            {
                if (i.IsCorpse)
                    Client.Instance.SendToServer(new SingleClick(i));
            }
        }

        private static void AllMobiles()
        {
            bool textFlags = Config.GetBool("LastTargTextFlags");

            foreach (Mobile m in World.MobilesInRange())
            {
                if (m != World.Player)
                    Client.Instance.SendToServer(new SingleClick(m));

                if (textFlags)
                    Targeting.CheckTextFlags(m);

                FriendsManager.ShowOverhead(m);
            }
        }

        private static void LastSkill()
        {
            if (World.Player != null && World.Player.LastSkill != -1)
                Client.Instance.SendToServer(new UseSkill(World.Player.LastSkill));
        }

        private static void LastObj()
        {
            if (World.Player != null && World.Player.LastObject != Serial.Zero)
                PlayerData.DoubleClick(World.Player.LastObject);
        }

        private static void LastSpell()
        {
            if (World.Player != null && World.Player.LastSpell != -1)
            {
                ushort id = (ushort) World.Player.LastSpell;
                object o = id;
                Spell.OnHotKey(ref o);
            }
        }

        private static DateTime m_LastSync;

        private static void Resync()
        {
            if (DateTime.UtcNow - m_LastSync > TimeSpan.FromSeconds(1.0))
            {
                m_LastSync = DateTime.UtcNow;

                Client.Instance.SendToServer(new ResyncReq());
            }
        }

        public static void BandageLastTarg()
        {
            Item pack = World.Player.Backpack;
            if (pack != null)
            {
                if (!World.Player.UseItem(pack, 3617))
                {
                    World.Player.SendMessage(MsgLevel.Warning, LocString.NoBandages);
                }
                else
                {
                    Targeting.LastTarget(true); //force a targetself to be queued
                    //BandageTimer.Start(); // Bandage timer will be started automatically after the "You begin applying the bandages." message
                }
            }
        }

        public static void BandageSelf()
        {
            Item pack = World.Player.Backpack;
            if (pack != null)
            {
                if (!World.Player.UseItem(pack, 3617))
                {
                    World.Player.SendMessage(MsgLevel.Warning, LocString.NoBandages);
                }
                else
                {
                    Targeting.ClearQueue();
                    Targeting.TargetSelf(true); //force a targetself to be queued
                    //BandageTimer.Start(); // Bandage timer will be started automatically after the "You begin applying the bandages." message
                }
            }
        }

        private static bool DrinkApple(Item cont)
        {
            for (int i = 0; i < cont.Contains.Count; i++)
            {
                Item item = (Item) cont.Contains[i];

                if (item.ItemID == 12248 && item.Hue == 1160)
                {
                    PlayerData.DoubleClick(item);
                    return true;
                }
                else if (item.Contains != null && item.Contains.Count > 0)
                {
                    if (DrinkApple(item))
                        return true;
                }
            }

            return false;
        }

        private static void OnDrinkApple()
        {
            if (World.Player.Backpack == null)
                return;

            if (!DrinkApple(World.Player.Backpack))
                World.Player.SendMessage(LocString.NoItemOfType, (ItemID) 12248);
        }

        private static void OnUseItem(ref object state)
        {
            Item pack = World.Player.Backpack;
            if (pack == null)
                return;

            ushort id = (ushort) state;
            if (id == 3852 && World.Player.Poisoned && Config.GetBool("BlockHealPoison") &&
                Client.Instance.AllowBit(FeatureBit.BlockHealPoisoned))
            {
                World.Player.SendMessage(MsgLevel.Force, LocString.HealPoisonBlocked);
                return;
            }

            if (!World.Player.UseItem(pack, id))
                World.Player.SendMessage(LocString.NoItemOfType, (ItemID) id);
        }

        private static void UseItemInHand()
        {
            Item item = World.Player.GetItemOnLayer(Layer.RightHand);
            if (item == null)
                item = World.Player.GetItemOnLayer(Layer.LeftHand);

            if (item != null)
                PlayerData.DoubleClick(item);
        }

        private static void UseItemInRightHand()
        {
            Item item = World.Player.GetItemOnLayer(Layer.RightHand);

            if (item != null)
                PlayerData.DoubleClick(item);
        }

        private static void UseItemInLeftHand()
        {
            Item item = World.Player.GetItemOnLayer(Layer.LeftHand);

            if (item != null)
                PlayerData.DoubleClick(item);
        }

        private static void GrabItem()
        {
            World.Player.SendMessage(MsgLevel.Force, LocString.GrabItemTarget);
            Targeting.OneTimeTarget(OnGrabItem, true);
        }

        private static void OnGrabItem(bool loc, Serial serial, Point3D pt, ushort itemId)
        {
            Item item = World.FindItem(serial);

            if (item != null && item.Serial.IsItem && item.Movable && item.Visible)
            {
                Item hotbag = World.FindItem(_grabHotBag) ?? World.Player.Backpack;

                DragDropManager.DragDrop(item, item.Amount, hotbag);
            }
            else
            {
                World.Player.SendMessage(MsgLevel.Error, "Invalid or inaccessible item.", false);
            }
        }

        private static void SetGrabItemHotBag()
        {
            World.Player.SendMessage(MsgLevel.Force, LocString.SetGrabItemHotBag);
            Targeting.OneTimeTarget(OnSetGrabItemHotBag);
        }

        private static void OnSetGrabItemHotBag(bool loc, Serial serial, Point3D pt, ushort itemId)
        {
            if (!loc && serial.IsItem)
            {
                Item hb = World.FindItem(serial);

                if (hb != null)
                {
                    _grabHotBag = serial;
                    Config.SetProperty("GrabHotBag", serial.Value.ToString());

                    hb.ObjPropList.Add(Language.GetString(LocString.GrabHB));
                    hb.OPLChanged();

                    World.Player.SendMessage(MsgLevel.Force, "Grab Item HotBag Set");
                }
                else
                {
                    _grabHotBag = Serial.Zero;
                    Config.SetProperty("GrabHotBag", "0");
                }
            }
        }

        private static void OnGrabItemSingleClick(PacketReader pvSrc, PacketHandlerEventArgs args)
        {
            Serial serial = pvSrc.ReadUInt32();
            if (_grabHotBag == serial)
            {
                ushort gfx = 0;
                Item c = World.FindItem(_grabHotBag);
                if (c != null)
                {
                    gfx = c.ItemID.Value;
                }

                Client.Instance.SendToClient(new UnicodeMessage(_grabHotBag, gfx, MessageType.Label, 0x3B2, 3,
                    Language.CliLocName, "", Language.GetString(LocString.GrabHB)));
            }
        }

        private static void GetInfoGump()
        {
            World.Player.SendMessage(MsgLevel.Force, "Select an item or mobile to view/inspect");
            Targeting.OneTimeTarget(OnGetItemInfoTarget);
        }

        private static void OnGetItemInfoTarget(bool ground, Serial serial, Point3D pt, ushort gfx)
        {
            Item item = World.FindItem(serial);

            if (item == null)
            {
                Mobile mobile = World.FindMobile(serial);

                if (mobile == null)
                    return;

                MobileInfoGump gump = new MobileInfoGump(mobile);
                gump.SendGump();
            }
            else
            {
                ItemInfoGump gump = new ItemInfoGump(item);
                gump.SendGump();
            }
        }

        private static void GetSysMsgGump()
        {
            World.Player.SendMessage(MsgLevel.Force, "Displaying current System Message buffer");
            SystemMessagesGump gump = new SystemMessagesGump();
            gump.SendGump();
        }

        private static void GetHotKeysGump()
        {
            World.Player.SendMessage(MsgLevel.Force, "Displaying currently assigned hotkeys");
            HotKeyGump gump = new HotKeyGump(true, true, true);
            gump.SendGump();
        }
        private static void GetBoatControlGump()
        {
            World.Player.SendMessage(MsgLevel.Force, "Displaying boat control gump");
            BoatControlGump gump = new BoatControlGump(0);
            gump.SendGump();
        }
    }
}

================================================
FILE: Razor/HotKeys/SkillHotKeys.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System.Collections.Generic;
using Ultima;

namespace Assistant.HotKeys
{
    public class SkillHotKeys
    {
        private static HotKeyCallbackState _callback;
        
        public static void Initialize()
        {
            _callback = new HotKeyCallbackState(OnHotKey);
            //1044060 = Alchemy in UO cliloc
            
            foreach (int t in Skills.GetUsableSkillIndexes())
            {
                HotKey.Add(HKCategory.Skills, (1044060 + t), _callback, t);
            }
        }

        private static void OnHotKey(ref object state)
        {
            int sk = (int) state;
            Client.Instance.SendToServer(new UseSkill(sk));
            if (World.Player != null)
            {
                World.Player.LastSkill = sk;
            }

            if (sk == Skills.StealthIndex && !World.Player.Visible)
            {
                StealthSteps.Hide();
            }

            SkillTimer.Start();
        }
    }
}

================================================
FILE: Razor/HotKeys/SpecialMoves.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;


namespace Assistant
{
    public enum AOSAbility
    {
        Clear,
        ArmorIgnore,
        BleedAttack,
        ConcussionBlow,
        CrushingBlow,
        Disarm,
        Dismount,
        DoubleStrike,
        InfectiousStrike,
        MortalStrike,
        MovingShot,
        ParalyzingBlow,
        ShadowStrike,
        WhirlwindAttack,
        Invalid
    }

    public class SpecialMoves
    {
        private class AbilityInfo
        {
            private AOSAbility m_Ability;
            private int[][] m_Items;

            public AbilityInfo(AOSAbility ab, params int[][] items)
            {
                m_Ability = (AOSAbility) ab;
                m_Items = items;
            }

            public AOSAbility Ability
            {
                get { return m_Ability; }
            }

            public bool HasItem(int item)
            {
                for (int a = 0; a < m_Items.Length; a++)
                {
                    for (int b = 0; b < m_Items[a].Length; b++)
                    {
                        if (m_Items[a][b] == item)
                            return true;
                    }
                }

                return false;
            }
        }

        private static DateTime m_LastToggle = DateTime.MinValue;

        private static int[] HatchetID = new int[] {0xF43, 0xF44};
        private static int[] LongSwordID = new int[] {0xF60, 0xF61};
        private static int[] BroadswordID = new int[] {0xF5E, 0xF5F};
        private static int[] KatanaID = new int[] {0x13FE, 0x13FF};
        private static int[] BladedStaffID = new int[] {0x26BD, 0x26C7};
        private static int[] HammerPickID = new int[] {0x143C, 0x143D};
        private static int[] WarAxeID = new int[] {0x13AF, 0x13B0};
        private static int[] KryssID = new int[] {0x1400, 0x1401};
        private static int[] SpearID = new int[] {0xF62, 0xF63};
        private static int[] CompositeBowID = new int[] {0x26C2, 0x26CC};
        private static int[] CleaverID = new int[] {0xEC2, 0xEC3};
        private static int[] LargeBattleAxeID = new int[] {0x13FA, 0x13FB};
        private static int[] BattleAxeID = new int[] {0xF47, 0xF48};
        private static int[] ExecAxeID = new int[] {0xF45, 0xF46};
        private static int[] CutlassID = new int[] {0x1440, 0x1441};
        private static int[] ScytheID = new int[] {0x26BA, 0x26C4};
        private static int[] WarMaceID = new int[] {0x1406, 0x1407};
        private static int[] PitchforkID = new int[] {0xE87, 0xE88};
        private static int[] WarForkID = new int[] {0x1404, 0x1405};
        private static int[] HalberdID = new int[] {0x143E, 0x143F};
        private static int[] MaulID = new int[] {0x143A, 0x143B};
        private static int[] MaceID = new int[] {0xF5C, 0x45D};
        private static int[] GnarledStaffID = new int[] {0x13F8, 0x13F9};
        private static int[] QuarterStaffID = new int[] {0xE89, 0xE8A};
        private static int[] LanceID = new int[] {0x26C0, 0x26CA};
        private static int[] CrossbowID = new int[] {0xF4F, 0xF50};
        private static int[] VikingSwordID = new int[] {0x13B9, 0x13BA};
        private static int[] AxeID = new int[] {0xF49, 0xF4A};
        private static int[] ShepherdsCrookID = new int[] {0xE81, 0xE82};
        private static int[] SmithsHammerID = new int[] {0x13EC, 0x13E4};
        private static int[] WarHammerID = new int[] {0x1438, 0x1439};
        private static int[] ScepterID = new int[] {0x26BC, 0x26C6};
        private static int[] SledgeHammerID = new int[] {0xFB4, 0xFB5};
        private static int[] ButcherKnifeID = new int[] {0x13F6, 0x13F7};
        private static int[] PickaxeID = new int[] {0xE85, 0xE86};
        private static int[] SkinningKnifeID = new int[] {0xEC4, 0xEC5};
        private static int[] WandID = new int[] {0xDF2, 0xDF3, 0xDF4, 0xDF5};
        private static int[] BardicheID = new int[] {0xF4D, 0xF4E};
        private static int[] ClubID = new int[] {0x13B3, 0x13B4};
        private static int[] ScimitarID = new int[] {0x13B5, 0x13B6};
        private static int[] HeavyCrossbowID = new int[] {0x13FC, 0x13FD};
        private static int[] TwoHandedAxeID = new int[] {0x1442, 0x1443};
        private static int[] DoubleAxeID = new int[] {0xF4B, 0xF4C};
        private static int[] CrescentBladeID = new int[] {0x26C1, 0x26C2};
        private static int[] DoubleBladedStaffID = new int[] {0x26BF, 0x26C9};
        private static int[] RepeatingCrossbowID = new int[] {0x26C3, 0x26CD};
        private static int[] DaggerID = new int[] {0xF51, 0xF52};
        private static int[] PikeID = new int[] {0x26BE, 0x26C8};
        private static int[] BoneHarvesterID = new int[] {0x26BB, 0x26C5};
        private static int[] ShortSpearID = new int[] {0x1402, 0x1403};
        private static int[] BowID = new int[] {0x13B1, 0x13B2};
        private static int[] BlackStaffID = new int[] {0xDF0, 0xDF1};
        private static int[] FistsID = new int[] {0};

        private static AbilityInfo[] m_Primary = new AbilityInfo[]
        {
            new AbilityInfo(AOSAbility.ArmorIgnore, HatchetID, LongSwordID, BladedStaffID, HammerPickID, WarAxeID,
                KryssID, SpearID, CompositeBowID),
            new AbilityInfo(AOSAbility.BleedAttack, CleaverID, BattleAxeID, ExecAxeID, CutlassID, ScytheID, PitchforkID,
                WarForkID),
            new AbilityInfo(AOSAbility.ConcussionBlow, MaceID, GnarledStaffID, CrossbowID),
            new AbilityInfo(AOSAbility.CrushingBlow, VikingSwordID, AxeID, BroadswordID, ShepherdsCrookID,
                SmithsHammerID, MaulID, WarMaceID, ScepterID, SledgeHammerID),
            new AbilityInfo(AOSAbility.Disarm, FistsID),
            new AbilityInfo(AOSAbility.Dismount, WandID, LanceID),
            new AbilityInfo(AOSAbility.DoubleStrike, PickaxeID, TwoHandedAxeID, DoubleAxeID, ScimitarID, KatanaID,
                CrescentBladeID, QuarterStaffID, DoubleBladedStaffID, RepeatingCrossbowID),
            new AbilityInfo(AOSAbility.InfectiousStrike, ButcherKnifeID, DaggerID),
            //new AbilityInfo( AOSAbility.MortalStrike ), // not primary for anything
            new AbilityInfo(AOSAbility.MovingShot, HeavyCrossbowID),
            new AbilityInfo(AOSAbility.ParalyzingBlow, BardicheID, BoneHarvesterID, PikeID, BowID),
            new AbilityInfo(AOSAbility.ShadowStrike, SkinningKnifeID, ClubID, ShortSpearID),
            new AbilityInfo(AOSAbility.WhirlwindAttack, LargeBattleAxeID, HalberdID, WarHammerID, BlackStaffID)
        };

        private static AbilityInfo[] m_Secondary = new AbilityInfo[]
        {
            new AbilityInfo(AOSAbility.ArmorIgnore, LargeBattleAxeID, BroadswordID, KatanaID),
            new AbilityInfo(AOSAbility.BleedAttack, WarMaceID, WarAxeID),
            new AbilityInfo(AOSAbility.ConcussionBlow, LongSwordID, BattleAxeID, HalberdID, MaulID, QuarterStaffID,
                LanceID),
            new AbilityInfo(AOSAbility.CrushingBlow, WarHammerID),
            new AbilityInfo(AOSAbility.Disarm, ButcherKnifeID, PickaxeID, SkinningKnifeID, HatchetID, WandID,
                ShepherdsCrookID, MaceID, WarForkID),
            new AbilityInfo(AOSAbility.Dismount, BardicheID, AxeID, BladedStaffID, ClubID, PitchforkID,
                HeavyCrossbowID),
            //new AbilityInfo( AOSAbility.DoubleStrike ), // secondary on none
            new AbilityInfo(AOSAbility.InfectiousStrike, CleaverID, PikeID, KryssID, DoubleBladedStaffID),
            new AbilityInfo(AOSAbility.MortalStrike, ExecAxeID, BoneHarvesterID, CrescentBladeID, HammerPickID,
                ScepterID, ShortSpearID, CrossbowID, BowID),
            new AbilityInfo(AOSAbility.MovingShot, CompositeBowID, RepeatingCrossbowID),
            new AbilityInfo(AOSAbility.ParalyzingBlow, VikingSwordID, ScimitarID, ScytheID, GnarledStaffID,
                BlackStaffID, SpearID, FistsID),
            new AbilityInfo(AOSAbility.ShadowStrike, TwoHandedAxeID, CutlassID, SmithsHammerID, DaggerID,
                SledgeHammerID),
            new AbilityInfo(AOSAbility.WhirlwindAttack, DoubleAxeID)
        };

        public static void Initialize()
        {
            HotKey.Add(HKCategory.Misc, HKSubCat.None, LocString.ToggleWarPeace, new HotKeyCallback(ToggleWarPeace));
            HotKey.Add(HKCategory.Misc, HKSubCat.None, LocString.ToggleWar, new HotKeyCallback(ToggleWar));
            HotKey.Add(HKCategory.Misc, HKSubCat.None, LocString.TogglePeace, new HotKeyCallback(TogglePeace));

            HotKey.Add(HKCategory.Misc, HKSubCat.SpecialMoves, LocString.ClearAbility,
                new HotKeyCallback(ClearAbilities));

            HotKey.Add(HKCategory.Misc, HKSubCat.SpecialMoves, LocString.SetPrimAb,
                new HotKeyCallback(SetPrimaryAbility));
            HotKey.Add(HKCategory.Misc, HKSubCat.SpecialMoves, LocString.SetSecAb,
                new HotKeyCallback(SetSecondaryAbility));

            HotKey.Add(HKCategory.Misc, HKSubCat.SpecialMoves, LocString.ToggleStun, new HotKeyCallback(OnStun));
            HotKey.Add(HKCategory.Misc, HKSubCat.SpecialMoves, LocString.ToggleDisarm, new HotKeyCallback(OnDisarm));
        }

        private static void ToggleWarPeace()
        {
            Client.Instance.SendToServer(new SetWarMode(!World.Player.Warmode));
        }

        private static void ToggleWar()
        {
            Client.Instance.ForceSendToClient(new SetWarMode(true));
            Client.Instance.SendToServer(new SetWarMode(true));
        }

        private static void TogglePeace()
        {
            Client.Instance.ForceSendToClient(new SetWarMode(false));
            Client.Instance.SendToServer(new SetWarMode(false));
        }

        private static void OnStun()
        {
            if (m_LastToggle + TimeSpan.FromSeconds(0.5) < DateTime.UtcNow)
            {
                m_LastToggle = DateTime.UtcNow;
                Client.Instance.SendToServer(new StunRequest());
            }
        }

        private static void OnDisarm()
        {
            if (m_LastToggle + TimeSpan.FromSeconds(0.5) < DateTime.UtcNow)
            {
                m_LastToggle = DateTime.UtcNow;
                Client.Instance.SendToServer(new DisarmRequest());
            }
        }

        private static AOSAbility GetAbility(int item, AbilityInfo[] list)
        {
            for (int a = 0; a < list.Length; a++)
            {
                if (list[a].HasItem(item))
                    return list[a].Ability;
            }

            return AOSAbility.Invalid;
        }

        public static void SetPrimaryAbility()
        {
            Item right = World.Player.GetItemOnLayer(Layer.RightHand);
            Item left = World.Player.GetItemOnLayer(Layer.LeftHand);

            AOSAbility a = AOSAbility.Invalid;
            if (right != null)
                a = GetAbility(right.ItemID.Value, m_Primary);

            if (a == AOSAbility.Invalid && left != null)
                a = GetAbility(left.ItemID.Value, m_Primary);

            if (a == AOSAbility.Invalid)
                a = GetAbility(FistsID[0], m_Primary);

            if (a != AOSAbility.Invalid)
            {
                Client.Instance.SendToServer(new UseAbility(a));
                Client.Instance.SendToClient(ClearAbility.Instance);
                World.Player.SendMessage(LocString.SettingAOSAb, a);
            }
        }

        public static void SetSecondaryAbility()
        {
            Item right = World.Player.GetItemOnLayer(Layer.RightHand);
            Item left = World.Player.GetItemOnLayer(Layer.LeftHand);

            AOSAbility a = AOSAbility.Invalid;
            if (right != null)
                a = GetAbility(right.ItemID.Value, m_Secondary);

            if (a == AOSAbility.Invalid && left != null)
                a = GetAbility(left.ItemID.Value, m_Secondary);

            if (a == AOSAbility.Invalid)
                a = GetAbility(FistsID[0], m_Secondary);

            if (a != AOSAbility.Invalid)
            {
                Client.Instance.SendToServer(new UseAbility(a));
                Client.Instance.SendToClient(ClearAbility.Instance);
                World.Player.SendMessage(LocString.SettingAOSAb, a);
            }
        }

        public static void ClearAbilities()
        {
            Client.Instance.SendToServer(new UseAbility(AOSAbility.Clear));
            Client.Instance.SendToClient(ClearAbility.Instance);
            World.Player.SendMessage(LocString.AOSAbCleared);
        }
    }
}

================================================
FILE: Razor/HotKeys/Undress.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using Assistant.Core;

namespace Assistant.HotKeys
{
    public class UndressHotKeys
    {
        public static void Initialize()
        {
            HotKey.Add(HKCategory.Dress, LocString.ArmDisarmRight, new HotKeyCallback(Dress.ToggleRight));
            HotKey.Add(HKCategory.Dress, LocString.ArmDisarmLeft, new HotKeyCallback(Dress.ToggleLeft));

            HotKey.Add(HKCategory.Dress, LocString.UndressAll, new HotKeyCallback(OnUndressAll));
            HotKey.Add(HKCategory.Dress, LocString.UndressHands, new HotKeyCallback(OnUnequipBothHands));
            HotKey.Add(HKCategory.Dress, LocString.UndressLeft, new HotKeyCallback(OnUnequipLeft));
            HotKey.Add(HKCategory.Dress, LocString.UndressRight, new HotKeyCallback(OnUnequipRight));
            HotKey.Add(HKCategory.Dress, LocString.UndressHat, new HotKeyCallback(OnUnequipHat));
            HotKey.Add(HKCategory.Dress, LocString.UndressJewels, new HotKeyCallback(OnUnequipJewelry));
        }

        public static void OnUndressAll()
        {
            for (int i = 0; i < World.Player.Contains.Count; i++)
            {
                Item item = (Item) World.Player.Contains[i];
                if (item.Layer <= Layer.LastUserValid && item.Layer != Layer.Backpack && item.Layer != Layer.Hair &&
                    item.Layer != Layer.FacialHair)
                {
                    Item pack = DressList.FindUndressBag(item);
                    if (pack != null)
                        DragDropManager.DragDrop(item, pack);
                }
            }

            //if ( Macros.MacroManager.AcceptActions )
            //	MacroManager.Action( new Macros.UnDressAction( (byte)0 ) );
        }

        public static void OnUnequipJewelry()
        {
            Dress.Unequip(Layer.Ring); // ring
            Dress.Unequip(Layer.Bracelet); // bracelet
            Dress.Unequip(Layer.Earrings); // earrings
        }

        public static void OnUnequipHat()
        {
            Dress.Unequip(Layer.Head);
        }

        public static void OnUnequipBothHands()
        {
            Dress.Unequip(Layer.RightHand);
            Dress.Unequip(Layer.LeftHand);
        }

        public static void OnUnequipRight()
        {
            Dress.Unequip(Layer.RightHand);
        }

        public static void OnUnequipLeft()
        {
            Dress.Unequip(Layer.LeftHand);
        }
    }
}

================================================
FILE: Razor/Macros/Actions.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using Assistant.Core;
using Assistant.UI;
using Ultima;

namespace Assistant.Macros
{
    public delegate void MacroMenuCallback(object[] Args);

    public class MacroMenuItem : ToolStripMenuItem
    {
        private MacroMenuCallback m_Call;
        private object[] m_Args;

        public MacroMenuItem(LocString name, MacroMenuCallback call, params object[] args) : base(
            Language.GetString(name))
        {
            base.Click += new EventHandler(OnMenuClick);
            m_Call = call;
            m_Args = args;
        }

        private void OnMenuClick(object sender, System.EventArgs e)
        {
            m_Call(m_Args);
        }
    }

    public abstract class MacroAction
    {
        protected Macro m_Parent;

        public MacroAction()
        {
        }

        public override string ToString()
        {
            return $"?{GetType().Name}?";
        }

        public abstract string ToScript();

        public virtual string Serialize()
        {
            return GetType().FullName;
        }

        protected string DoSerialize(params object[] args)
        {
            StringBuilder sb = new StringBuilder(GetType().FullName);
            for (int i = 0; i < args.Length; i++)
                sb.AppendFormat("|{0}", args[i]);
            return sb.ToString();
        }

        public virtual ToolStripMenuItem[] GetContextMenuItems()
        {
            return null;
        }

        public Macro Parent
        {
            get { return m_Parent; }
            set { m_Parent = value; }
        }

        public abstract bool Perform();
    }

    public abstract class MacroWaitAction : MacroAction
    {
        protected TimeSpan m_Timeout = TimeSpan.FromMinutes(5);
        private DateTime m_Start;
        private MacroMenuItem m_MenuItem = null;

        public MacroWaitAction()
        {
        }

        public abstract bool PerformWait();

        public TimeSpan Timeout
        {
            get { return m_Timeout; }
        }

        public DateTime StartTime
        {
            get { return m_Start; }
            set { m_Start = value; }
        }

        public MacroMenuItem EditTimeoutMenuItem
        {
            get
            {
                if (m_MenuItem == null)
                    m_MenuItem = new MacroMenuItem(LocString.EditTimeout, new MacroMenuCallback(EditTimeout));
                return m_MenuItem;
            }
        }

        private void EditTimeout(object[] args)
        {
            if (InputBox.Show(Language.GetString(LocString.NewTimeout), Language.GetString(LocString.ChangeTimeout),
                ((int) (m_Timeout.TotalSeconds)).ToString()))
                m_Timeout = TimeSpan.FromSeconds(InputBox.GetInt(60));
        }

        public virtual bool CheckMatch(MacroAction a)
        {
            return false; // a.GetType() == this.GetType();
        }
    }

    public class MacroComment : MacroAction
    {
        private string m_Comment;

        public MacroComment(string comment)
        {
            if (comment == null)
                comment = "";

            m_Comment = comment.Trim();
        }

        public override bool Perform()
        {
            return true;
        }

        public override string ToScript()
        {
            return $"# {m_Comment}";
        }

        public override string Serialize()
        {
            return ToString();
        }

        public string Comment
        {
            get { return m_Comment; }
            set { m_Comment = value; }
        }

        public override string ToString()
        {
            if (m_Comment == null)
                m_Comment = "";

            return $"// {m_Comment}";
        }

        private ToolStripMenuItem[] m_MenuItems;

        public override ToolStripMenuItem[] GetContextMenuItems()
        {
            if (m_MenuItems == null)
            {
                m_MenuItems = new MacroMenuItem[]
                {
                    new MacroMenuItem(LocString.Edit, new MacroMenuCallback(Edit))
                };
            }

            return m_MenuItems;
        }

        private void Edit(object[] args)
        {
            if (InputBox.Show(Language.GetString(LocString.InsComment), Language.GetString(LocString.InputReq),
                m_Comment))
            {
                if (m_Comment == null)
                    m_Comment = "";

                m_Comment = InputBox.GetString();

                if (m_Comment == null)
                    m_Comment = "";

                if (m_Parent != null)
                    m_Parent.Update();
            }
        }
    }

    public class ClearSysMessages : MacroAction
    {
        public ClearSysMessages()
        {
        }

        public override bool Perform()
        {
            SystemMessages.Messages.Clear();

            return true;
        }

        public override string ToScript()
        {
            return "clearsysmsg";
        }

        public override string Serialize()
        {
            return DoSerialize();
        }

        public override string ToString()
        {
            return Language.GetString(LocString.ClearSysMsg);
        }
    }


    public class DoubleClickAction : MacroAction
    {
        private Serial m_Serial;
        private ushort m_Gfx;

        public DoubleClickAction(Serial obj, ushort gfx)
        {
            m_Serial = obj;
            m_Gfx = gfx;
        }

        public DoubleClickAction(string[] args)
        {
            m_Serial = Serial.Parse(args[1]);
            m_Gfx = Convert.ToUInt16(args[2]);
        }

        public override bool Perform()
        {
            PlayerData.DoubleClick(m_Serial);
            return true;
        }

        public override string ToScript()
        {
            return $"dclick '{m_Serial.ToString()}'";
        }

        public override string Serialize()
        {
            return DoSerialize(m_Serial.Value, m_Gfx);
        }

        public override string ToString()
        {
            return Language.Format(LocString.DClickA1, m_Serial);
        }

        private ToolStripMenuItem[] m_MenuItems;

        public override ToolStripMenuItem[] GetContextMenuItems()
        {
            if (m_MenuItems == null)
            {
                m_MenuItems = new MacroMenuItem[]
                {
                    new MacroMenuItem(LocString.ReTarget, new MacroMenuCallback(ReTarget)),
                    new MacroMenuItem(LocString.Conv2DCT, new MacroMenuCallback(ConvertToByType))
                };
            }

            return m_MenuItems;
        }

        private void ConvertToByType(object[] args)
        {
            if (m_Gfx != 0 && m_Serial.IsItem && m_Parent != null)
                m_Parent.Convert(this, new DoubleClickTypeAction(m_Gfx, m_Serial.IsItem));
        }

        private void ReTarget(object[] args)
        {
            Targeting.OneTimeTarget(new Targeting.TargetResponseCallback(OnReTarget));
            World.Player.SendMessage(MsgLevel.Force, LocString.SelTargAct);
        }

        private void OnReTarget(bool ground, Serial serial, Point3D pt, ushort gfx)
        {
            if (serial.IsItem || serial.IsMobile)
            {
                m_Serial = serial;
                m_Gfx = gfx;
            }

            Engine.MainWindow.SafeAction(s => s.ShowMe());

            if (m_Parent != null)
                m_Parent.Update();
        }
    }

    public class DoubleClickTypeAction : MacroAction
    {
        private ushort m_Gfx;
        public bool m_Item;

        public DoubleClickTypeAction(string[] args)
        {
            m_Gfx = Convert.ToUInt16(args[1]);
            try
            {
                m_Item = Convert.ToBoolean(args[2]);
            }
            catch
            {
            }
        }

        public DoubleClickTypeAction(ushort gfx, bool item)
        {
            m_Gfx = gfx;
            m_Item = item;
        }

        public override bool Perform()
        {
            Serial click = Serial.Zero;

            if (m_Item)
            {
                Item item = World.Player.Backpack != null ? World.Player.Backpack.FindItemById(m_Gfx) : null;
                ArrayList list = new ArrayList();
                if (item == null)
                {
                    foreach (Item i in World.Items.Values)
                    {
                        if (i.ItemID == m_Gfx && i.RootContainer == null)
                        {
                            if (Config.GetBool("RangeCheckDoubleClick"))
                            {
                                if (Utility.InRange(World.Player.Position, i.Position, 2))
                                {
                                    list.Add(i);
                                }
                            }
                            else
                            {
                                list.Add(i);
                            }
                        }
                    }

                    if (list.Count == 0)
                    {
                        foreach (Item i in World.Items.Values)
                        {
                            if (i.ItemID == m_Gfx && !i.IsInBank)
                            {
                                if (Config.GetBool("RangeCheckDoubleClick"))
                                {
                                    if (Utility.InRange(World.Player.Position, i.Position, 2) || i.RootContainer == World.Player)
                                    {
                                        list.Add(i);
                                    }
                                }
                                else
                                {
                                    list.Add(i);
                                }
                            }
                        }
                    }

                    if (list.Count > 0)
                        click = ((Item) list[Utility.Random(list.Count)]).Serial;
                }
                else
                {
                    click = item.Serial;
                }
            }
            else
            {
                ArrayList list = new ArrayList();
                foreach (Mobile m in World.MobilesInRange())
                {
                    if (m.Body == m_Gfx)
                    {
                        if (Config.GetBool("RangeCheckDoubleClick"))
                        {
                            if (Utility.InRange(World.Player.Position, m.Position, 2))
                            {
                                list.Add(m);
                            }
                        }
                        else
                        {
                            list.Add(m);
                        }
                    }
                }

                if (list.Count > 0)
                    click = ((Mobile) list[Utility.Random(list.Count)]).Serial;
            }

            if (click != Serial.Zero)
                PlayerData.DoubleClick(click);
            else
                World.Player.SendMessage(MsgLevel.Force, LocString.NoItemOfType,
                    m_Item ? ((ItemID) m_Gfx).ToString() : $"(Character) 0x{m_Gfx:X}");
            return true;
        }

        public override string ToScript()
        {
            return $"dclicktype '{m_Gfx}'";
        }

        public override string Serialize()
        {
            return DoSerialize(m_Gfx, m_Item);
        }

        public override string ToString()
        {
            return Language.Format(LocString.DClickA1,
                m_Item ? ((ItemID) m_Gfx).ToString() : $"(Character) 0x{m_Gfx:X}");
        }

        private ToolStripMenuItem[] m_MenuItems;

        public override ToolStripMenuItem[] GetContextMenuItems()
        {
            if (m_MenuItems == null)
            {
                m_MenuItems = new MacroMenuItem[]
                {
                    new MacroMenuItem(LocString.ReTarget, new MacroMenuCallback(ReTarget))
                };
            }

            return m_MenuItems;
        }

        private void ReTarget(object[] args)
        {
            Targeting.OneTimeTarget(new Targeting.TargetResponseCallback(OnReTarget));
            World.Player.SendMessage(LocString.SelTargAct);
        }

        private void OnReTarget(bool ground, Serial serial, Point3D pt, ushort gfx)
        {
            m_Gfx = gfx;
            m_Item = serial.IsItem;

            Engine.MainWindow.SafeAction(s => s.ShowMe());
            if (m_Parent != null)
                m_Parent.Update();
        }
    }

    public class LiftAction : MacroWaitAction
    {
        private ushort m_Amount;
        private Serial m_Serial;
        private ushort m_Gfx;

        private static Item m_LastLift;

        public static Item LastLift
        {
            get { return m_LastLift; }
            set { m_LastLift = value; }
        }

        public LiftAction(string[] args)
        {
            m_Serial = Serial.Parse(args[1]);
            m_Amount = Convert.ToUInt16(args[2]);
            m_Gfx = Convert.ToUInt16(args[3]);
        }

        public LiftAction(Serial ser, ushort amount, ushort gfx)
        {
            m_Serial = ser;
            m_Amount = amount;
            m_Gfx = gfx;
        }

        private int m_Id;

        public override bool Perform()
        {
            Item item = World.FindItem(m_Serial);
            if (item != null)
            {
                //DragDropManager.Holding = item;
                m_LastLift = item;
                m_Id = DragDropManager.Drag(item, m_Amount <= item.Amount ? m_Amount : item.Amount);
            }
            else
            {
                World.Player.SendMessage(MsgLevel.Warning, LocString.MacroItemOutRange);
            }

            return false;
        }

        public override bool PerformWait()
        {
            return DragDropManager.LastIDLifted < m_Id;
        }

        public override string ToScript()
        {
            return $"lift '{m_Serial}' {m_Amount}";
        }

        public override string Serialize()
        {
            return DoSerialize(m_Serial.Value, m_Amount, m_Gfx);
        }

        public override string ToString()
        {
            return Language.Format(LocString.LiftA10, m_Serial, m_Amount);
        }

        private ToolStripMenuItem[] m_MenuItems;

        public override ToolStripMenuItem[] GetContextMenuItems()
        {
            if (m_MenuItems == null)
            {
                m_MenuItems = new MacroMenuItem[]
                {
                    new MacroMenuItem(LocString.ReTarget, new MacroMenuCallback(ReTarget)),
                    new MacroMenuItem(LocString.ConvLiftByType, new MacroMenuCallback(ConvertToByType)),
                    new MacroMenuItem(LocString.Edit, new MacroMenuCallback(EditAmount))
                };
            }

            return m_MenuItems;
        }

        private void ReTarget(object[] args)
        {
            Targeting.OneTimeTarget(!m_Serial.IsValid, new Targeting.TargetResponseCallback(ReTargetResponse));
            World.Player.SendMessage(MsgLevel.Force, LocString.SelTargAct);
        }

        private void ReTargetResponse(bool ground, Serial serial, Point3D pt, ushort gfx)
        {
            m_Serial = serial;
            m_Gfx = gfx;

            Engine.MainWindow.ShowMe();

            m_Parent?.Update();
        }

        private void EditAmount(object[] args)
        {
            if (InputBox.Show(Engine.MainWindow, Language.GetString(LocString.EnterAmount),
                Language.GetString(LocString.InputReq), m_Amount.ToString()))
            {
                m_Amount = (ushort) InputBox.GetInt(m_Amount);

                if (m_Parent != null)
                    m_Parent.Update();
            }
        }

        private void ConvertToByType(object[] args)
        {
            if (m_Gfx != 0 && m_Parent != null)
                m_Parent.Convert(this, new LiftTypeAction(m_Gfx, m_Amount));
        }
    }

    public class LiftTypeAction : MacroWaitAction
    {
        private ushort m_Gfx;
        private ushort m_Amount;

        public LiftTypeAction(string[] args)
        {
            m_Gfx = Convert.ToUInt16(args[1]);
            m_Amount = Convert.ToUInt16(args[2]);
        }

        public LiftTypeAction(ushort gfx, ushort amount)
        {
            m_Gfx = gfx;
            m_Amount = amount;
        }

        private int m_Id;

        public override bool Perform()
        {
            Item item = World.Player.Backpack != null ? World.Player.Backpack.FindItemById(m_Gfx) : null;
            /*if ( item == null )
            {
                 ArrayList list = new ArrayList();

                 foreach ( Item i in World.Items.Values )
                 {
                      if ( i.ItemID == m_Gfx && ( i.RootContainer == null || i.IsChildOf( World.Player.Quiver ) ) )
                           list.Add( i );
                 }

                 if ( list.Count > 0 )
                      item = (Item)list[ Utility.Random( list.Count ) ];
            }*/

            if (item != null)
            {
                //DragDropManager.Holding = item;
                ushort amount = m_Amount;
                if (item.Amount < amount)
                    amount = item.Amount;
                LiftAction.LastLift = item;
                //ActionQueue.Enqueue( new LiftRequest( item, amount ) );
                m_Id = DragDropManager.Drag(item, amount);
            }
            else
            {
                World.Player.SendMessage(MsgLevel.Warning, LocString.NoItemOfType, (ItemID) m_Gfx);
                //MacroManager.Stop();
            }

            return false;
        }

        public override bool PerformWait()
        {
            return DragDropManager.LastIDLifted < m_Id && !DragDropManager.Empty;
        }

        public override string ToScript()
        {
            return $"lifttype '{m_Gfx}' {m_Amount}";
        }

        public override string Serialize()
        {
            return DoSerialize(m_Gfx, m_Amount);
        }

        private ToolStripMenuItem[] m_MenuItems;

        public override ToolStripMenuItem[] GetContextMenuItems()
        {
            if (m_MenuItems == null)
            {
                m_MenuItems = new MacroMenuItem[]
                {
                    new MacroMenuItem(LocString.ReTarget, new MacroMenuCallback(ReTarget)),
                    new MacroMenuItem(LocString.Edit, new MacroMenuCallback(EditAmount))
                };
            }

            return m_MenuItems;
        }

        private void ReTarget(object[] args)
        {
            Targeting.OneTimeTarget(false, new Targeting.TargetResponseCallback(ReTargetResponse));
            World.Player.SendMessage(MsgLevel.Force, LocString.SelTargAct);
        }

        private void ReTargetResponse(bool ground, Serial serial, Point3D pt, ushort gfx)
        {
            m_Gfx = gfx;

            Engine.MainWindow.ShowMe();

            m_Parent?.Update();
        }

        private void EditAmount(object[] args)
        {
            if (InputBox.Show(Engine.MainWindow, Language.GetString(LocString.EnterAmount),
                Language.GetString(LocString.InputReq), m_Amount.ToString()))
            {
                m_Amount = (ushort) InputBox.GetInt(m_Amount);

                if (m_Parent != null)
                    m_Parent.Update();
            }
        }

        public override string ToString()
        {
            return Language.Format(LocString.LiftA10, m_Amount, (ItemID) m_Gfx);
        }
    }

    public class DropAction : MacroAction
    {
        private Serial m_To;
        private Point3D m_At;
        private Layer m_Layer;

        public DropAction(string[] args)
        {
            m_To = Serial.Parse(args[1]);
            m_At = Point3D.Parse(args[2]);
            try
            {
                m_Layer = (Layer) Byte.Parse(args[3]);
            }
            catch
            {
                m_Layer = Layer.Invalid;
            }
        }

        public DropAction(Serial to, Point3D at) : this(to, at, 0)
        {
        }

        public DropAction(Serial to, Point3D at, Layer layer)
        {
            m_To = to;
            m_At = at;
            m_Layer = layer;
        }

        public override bool Perform()
        {
            if (DragDropManager.Holding != null)
            {
                if (m_Layer > Layer.Invalid && m_Layer <= Layer.LastUserValid)
                {
                    Mobile m = World.FindMobile(m_To);
                    if (m != null)
                        DragDropManager.Drop(DragDropManager.Holding, m, m_Layer);
                }
                else
                {
                    DragDropManager.Drop(DragDropManager.Holding, m_To, m_At);
                }
            }
            else
            {
                World.Player.SendMessage(MsgLevel.Warning, LocString.MacroNoHold);
            }

            return true;
        }

        public override string ToScript()
        {
            if (!m_To.IsValid)
            {
                return $"droprelloc {m_At.X} {m_At.Y}";
            }

            return m_Layer != Layer.Invalid ? $"drop '{m_To}' {m_Layer}" : $"drop '{m_To}' {m_At.X} {m_At.Y} {m_At.Z}";
        }

        public override string Serialize()
        {
            return DoSerialize(m_To, m_At, (byte) m_Layer);
        }

        public override string ToString()
        {
            if (m_Layer != Layer.Invalid)
                return Language.Format(LocString.EquipTo, m_To, m_Layer);
            else
                return Language.Format(LocString.DropA2, m_To.IsValid ? m_To.ToString() : "Ground", m_At);
        }

        private ToolStripMenuItem[] m_MenuItems;

        public override ToolStripMenuItem[] GetContextMenuItems()
        {
            if (m_To.IsValid)
            {
                return null; // Dont allow conversion(s)
            }
            else
            {
                if (m_MenuItems == null)
                {
                    m_MenuItems = new MacroMenuItem[]
                    {
                        new MacroMenuItem(LocString.ConvRelLoc, new MacroMenuCallback(ConvertToRelLoc))
                    };
                }

                return m_MenuItems;
            }
        }

        private void ConvertToRelLoc(object[] args)
        {
            if (!m_To.IsValid && m_Parent != null)
                m_Parent.Convert(this,
                    new DropRelLocAction((sbyte) (m_At.X - World.Player.Position.X),
                        (sbyte) (m_At.Y - World.Player.Position.Y), (sbyte) (m_At.Z - World.Player.Position.Z)));
        }
    }

    public class DropRelLocAction : MacroAction
    {
        private sbyte[] m_Loc;

        public DropRelLocAction(string[] args)
        {
            m_Loc = new sbyte[3]
            {
                Convert.ToSByte(args[1]),
                Convert.ToSByte(args[2]),
                Convert.ToSByte(args[3])
            };
        }

        public DropRelLocAction(sbyte x, sbyte y, sbyte z)
        {
            m_Loc = new sbyte[3] {x, y, z};
        }

        public override bool Perform()
        {
            if (DragDropManager.Holding != null)
                DragDropManager.Drop(DragDropManager.Holding, null,
                    new Point3D((ushort) (World.Player.Position.X + m_Loc[0]),
                        (ushort) (World.Player.Position.Y + m_Loc[1]), (short) (World.Player.Position.Z + m_Loc[2])));
            else
                World.Player.SendMessage(LocString.MacroNoHold);
            return true;
        }

        public override string ToScript()
        {
            return $"droprelloc {m_Loc[0]} {m_Loc[1]}";
        }

        public override string Serialize()
        {
            return DoSerialize(m_Loc[0], m_Loc[1], m_Loc[2]);
        }

        public override string ToString()
        {
            return Language.Format(LocString.DropRelA3, m_Loc[0], m_Loc[1], m_Loc[2]);
        }
    }

    public class GumpResponseAction : MacroAction
    {
        private int m_ButtonID;
        private int[] m_Switches;
        private GumpTextEntry[] m_TextEntries;

        public GumpResponseAction(string[] args)
        {
            m_ButtonID = Convert.ToInt32(args[1]);
            m_Switches = new int[Convert.ToInt32(args[2])];
            for (int i = 0; i < m_Switches.Length; i++)
                m_Switches[i] = Convert.ToInt32(args[3 + i]);
            m_TextEntries = new GumpTextEntry[Convert.ToInt32(args[3 + m_Switches.Length])];
            for (int i = 0; i < m_TextEntries.Length; i++)
            {
                string[] split = args[4 + m_Switches.Length + i].Split('&');

                m_TextEntries[i] = new GumpTextEntry(Convert.ToUInt16(split[0]), split[1]);
            }
        }

        public GumpResponseAction(int button, int[] switches, GumpTextEntry[] entries)
        {
            m_ButtonID = button;
            m_Switches = switches;
            m_TextEntries = entries;
        }

        public override bool Perform()
        {
            Client.Instance.SendToClient(new CloseGump(World.Player.CurrentGumpI));
            Client.Instance.SendToServer(new GumpResponse(World.Player.CurrentGumpS, World.Player.CurrentGumpI,
                m_ButtonID, m_Switches, m_TextEntries));
            World.Player.HasGump = false;
            World.Player.HasCompressedGump = false;
            return true;
        }

        public override string ToScript()
        {
            return m_ButtonID == 0 ? "gumpclose" : $"gumpresponse {m_ButtonID}";
        }

        public override string Serialize()
        {
            ArrayList list = new ArrayList(3 + m_Switches.Length + m_TextEntries.Length);
            list.Add(m_ButtonID);
            list.Add(m_Switches.Length);
            list.AddRange(m_Switches);
            list.Add(m_TextEntries.Length);
            for (int i = 0; i < m_TextEntries.Length; i++)
                list.Add($"{m_TextEntries[i].EntryID}&{m_TextEntries[i].Text}");
            return DoSerialize((object[]) list.ToArray(typeof(object)));
        }

        public override string ToString()
        {
            if (m_ButtonID != 0)
                return Language.Format(LocString.GumpRespB, m_ButtonID);
            else
                return Language.Format(LocString.CloseGump);
        }

        private ToolStripMenuItem[] m_MenuItems;

        public override ToolStripMenuItem[] GetContextMenuItems()
        {
            if (this.m_MenuItems == null)
                this.m_MenuItems = (ToolStripMenuItem[]) new MacroMenuItem[]
                {
                    new MacroMenuItem(LocString.UseLastGumpResponse, new MacroMenuCallback(this.UseLastResponse),
                        new object[0]),
                    new MacroMenuItem(LocString.Edit, new MacroMenuCallback(this.Edit), new object[0])
                };
            return this.m_MenuItems;
        }

        private void Edit(object[] args)
        {
            if (InputBox.Show(Language.GetString(LocString.EnterNewText), "Input Box", this.m_ButtonID.ToString()))
                this.m_ButtonID = InputBox.GetInt();

            Parent?.Update();
        }

        private void UseLastResponse(object[] args)
        {
            m_ButtonID = World.Player.LastGumpResponseAction.m_ButtonID;
            m_Switches = World.Player.LastGumpResponseAction.m_Switches;
            m_TextEntries = World.Player.LastGumpResponseAction.m_TextEntries;

            World.Player.SendMessage(MsgLevel.Force, "Set GumpResponse to last response");

            Parent?.Update();
        }
    }

    public class MenuResponseAction : MacroAction
    {
        private ushort m_Index, m_ItemID, m_Hue;

        public MenuResponseAction(string[] args)
        {
            m_Index = Convert.ToUInt16(args[1]);
            m_ItemID = Convert.ToUInt16(args[2]);
            m_Hue = Convert.ToUInt16(args[3]);
        }

        public MenuResponseAction(ushort idx, ushort iid, ushort hue)
        {
            m_Index = idx;
            m_ItemID = iid;
            m_Hue = hue;
        }

        public override bool Perform()
        {
            Client.Instance.SendToServer(new MenuResponse(World.Player.CurrentMenuS, World.Player.CurrentMenuI, m_Index,
                m_ItemID, m_Hue));
            World.Player.HasMenu = false;
            return true;
        }

        public override string ToScript()
        {
            return $"menuresponse {m_Index} {m_ItemID} {m_Hue}";
        }

        public override string Serialize()
        {
            return DoSerialize(m_Index, m_ItemID, m_Hue);
        }

        public override string ToString()
        {
            return Language.Format(LocString.MenuRespA1, m_Index);
        }
    }

    public class AbsoluteTargetAction : MacroAction
    {
        private TargetInfo m_Info;

        public AbsoluteTargetAction(string[] args)
        {
            m_Info = new TargetInfo();

            m_Info.Type = Convert.ToByte(args[1]);
            m_Info.Flags = Convert.ToByte(args[2]);
            m_Info.Serial = Convert.ToUInt32(args[3]);
            m_Info.X = Convert.ToUInt16(args[4]);
            m_Info.Y = Convert.ToUInt16(args[5]);
            m_Info.Z = Convert.ToInt16(args[6]);
            m_Info.Gfx = Convert.ToUInt16(args[7]);
        }

        public AbsoluteTargetAction(TargetInfo info)
        {
            m_Info = new TargetInfo();
            m_Info.Type = info.Type;
            m_Info.Flags = info.Flags;
            m_Info.Serial = info.Serial;
            m_Info.X = info.X;
            m_Info.Y = info.Y;
            m_Info.Z = info.Z;
            m_Info.Gfx = info.Gfx;
        }

        public override bool Perform()
        {
            Targeting.Target(m_Info);
            return true;
        }

        public override string ToScript()
        {
            return $"target {m_Info.Serial}";
        }

        public override string Serialize()
        {
            return DoSerialize(m_Info.Type, m_Info.Flags, m_Info.Serial.Value, m_Info.X, m_Info.Y, m_Info.Z,
                m_Info.Gfx);
        }

        public override string ToString()
        {
            return Language.GetString(LocString.AbsTarg);
        }

        private ToolStripMenuItem[] m_MenuItems;

        public override ToolStripMenuItem[] GetContextMenuItems()
        {
            if (m_MenuItems == null)
            {
                m_MenuItems = new MacroMenuItem[]
                {
                    new MacroMenuItem(LocString.ReTarget, new MacroMenuCallback(ReTarget)),
                    new MacroMenuItem(LocString.ConvLT, new MacroMenuCallback(ConvertToLastTarget)),
                    new MacroMenuItem(LocString.ConvTargType, new MacroMenuCallback(ConvertToByType)),
                    new MacroMenuItem(LocString.ConvRelLoc, new MacroMenuCallback(ConvertToRelLoc))
                };
            }

            return m_MenuItems;
        }

        private void ReTarget(object[] args)
        {
            Targeting.OneTimeTarget(!m_Info.Serial.IsValid, new Targeting.TargetResponseCallback(ReTargetResponse));
            World.Player.SendMessage(MsgLevel.Force, LocString.SelTargAct);
        }

        private void ReTargetResponse(bool ground, Serial serial, Point3D pt, ushort gfx)
        {
            m_Info.Gfx = gfx;
            m_Info.Serial = serial;
            m_Info.Type = (byte) (ground ? 1 : 0);
            m_Info.X = pt.X;
            m_Info.Y = pt.Y;
            m_Info.Z = pt.Z;

            Engine.MainWindow.SafeAction(s => s.ShowMe());
            if (m_Parent != null)
                m_Parent.Update();
        }

        private void ConvertToLastTarget(object[] args)
        {
            if (m_Parent != null)
                m_Parent.Convert(this, new LastTargetAction());
        }

        private void ConvertToByType(object[] args)
        {
            if (m_Parent != null)
                m_Parent.Convert(this, new TargetTypeAction(m_Info.Serial.IsMobile, m_Info.Gfx));
        }

        private void ConvertToRelLoc(object[] args)
        {
            if (m_Parent != null)
                m_Parent.Convert(this,
                    new TargetRelLocAction((sbyte) (m_Info.X - World.Player.Position.X),
                        (sbyte) (m_Info.Y - World.Player.Position
                                     .Y))); //, (sbyte)(m_Info.Z - World.Player.Position.Z) ) );
        }
    }

    /// <summary>
    /// Action to handle variable macros to alleviate the headache of having multiple macros for the same thing
    ///
    /// This Action does break the pattern that you see in every other action because the data that is stored for this
    /// action exists not in the Macro file, but in a different file that has all the variables in the profile
    /// </summary>
    public class AbsoluteTargetVariableAction : MacroAction
    {
        private TargetInfo _target;
        private readonly string _variableName;

        public AbsoluteTargetVariableAction(string[] args)
        {
            _variableName = args.Length > 1 ? args[1] : args[0];
        }

        public override bool Perform()
        {
            _target = null;

            foreach (MacroVariables.MacroVariable mV in MacroVariables.MacroVariableList)
            {
                if (mV.Name.Equals(_variableName))
                {
                    _target = mV.TargetInfo;
                    break;
                }
            }

            if (_target != null)
            {
                Targeting.Target(_target);
                return true;
            }
            else
            {
                return false;
            }
        }

        public override string ToScript()
        {
            return $"target '{_variableName}'";
        }

        public override string Serialize()
        {
            return DoSerialize(_variableName);
        }

        public override string ToString()
        {
            return $"{Language.GetString(LocString.AbsTarg)} (${_variableName})";
        }

        /*private MenuItem[] m_MenuItems;
        public override MenuItem[] GetContextMenuItems()
        {
            if (m_MenuItems == null)
            {
                m_MenuItems = new MacroMenuItem[]
                {
                    new MacroMenuItem( LocString.ReTarget, ReTarget )
                };
            }

            return m_MenuItems;
        }

        private void ReTarget(object[] args)
        {
            Targeting.OneTimeTarget(!_target.Serial.IsValid, new Targeting.TargetResponseCallback(ReTargetResponse));
            World.Player.SendMessage(MsgLevel.Force, LocString.SelTargAct);
        }

        private void ReTargetResponse(bool ground, Serial serial, Point3D pt, ushort gfx)
        {
            _target.Gfx = gfx;
            _target.Serial = serial;
            _target.Type = (byte)(ground ? 1 : 0);
            _target.X = pt.X;
            _target.Y = pt.Y;
            _target.Z = pt.Z;

            Engine.MainWindow.SafeAction(s => s.ShowMe());

            m_Parent?.Update();
        }*/
    }

    /// <summary>
    /// Action to handle variable macros to alleviate the headache of having multiple macros for the same thing
    ///
    /// This Action does break the pattern that you see in every other action because the data that is stored for this
    /// action exists not in the Macro file, but in a different file that has all the variables in the profile
    /// </summary>
    public class DoubleClickVariableAction : MacroAction
    {
        private Serial _serial;
        private readonly string _variableName;

        public DoubleClickVariableAction(string[] args)
        {
            _variableName = args.Length > 1 ? args[1] : args[0];
        }

        public override bool Perform()
        {
            _serial = Serial.Zero;

            foreach (MacroVariables.MacroVariable mV in MacroVariables.MacroVariableList)
            {
                if (mV.Name.Equals(_variableName))
                {
                    _serial = mV.TargetInfo.Serial;
                    break;
                }
            }

            if (_serial != null && _serial != Serial.Zero)
            {
                PlayerData.DoubleClick(_serial);
                return true;
            }

            return false;
        }

        public override string ToScript()
        {
            return $"dclick '{_variableName}'";
        }

        public override string Serialize()
        {
            return DoSerialize(_variableName);
        }

        public override string ToString()
        {
            return $"DoubleClick (${_variableName})";
        }
    }

    public class TargetTypeAction : MacroAction
    {
        private bool m_Mobile;
        private ushort m_Gfx;
        private object _previousObject;

        public TargetTypeAction(string[] args)
        {
            m_Mobile = Convert.ToBoolean(args[1]);
            m_Gfx = Convert.ToUInt16(args[2]);
        }

        public TargetTypeAction(bool mobile, ushort gfx)
        {
            m_Mobile = mobile;
            m_Gfx = gfx;
        }

        public override bool Perform()
        {
            if (Targeting.FromGrabHotKey)
                return false;

            ArrayList list = new ArrayList();
            if (m_Mobile)
            {
                foreach (Mobile find in World.MobilesInRange())
                {
                    if (find.Body == m_Gfx)
                    {
                        if (Config.GetBool("RangeCheckTargetByType"))
                        {
                            if (Utility.InRange(World.Player.Position, find.Position, 2))
                            {
                                list.Add(find);
                            }
                        }
                        else
                        {
                            list.Add(find);
                        }
                    }
                }
            }
            else
            {
                foreach (Item i in World.Items.Values)
                {
                    if (i.ItemID == m_Gfx && !i.IsInBank)
                    {
                        if (Config.GetBool("RangeCheckTargetByType"))
                        {
                            if (Utility.InRange(World.Player.Position, i.Position, 2) || i.RootContainer == World.Player)
                            {
                                list.Add(i);
                            }
                        }
                        else
                        {
                            list.Add(i);
                        }
                    }
                }
            }

            if (list.Count > 0)
            {
                if (Config.GetBool("DiffTargetByType") && list.Count > 1)
                {
                    object currentObject = list[Utility.Random(list.Count)];

                    while (_previousObject != null && _previousObject == currentObject)
                    {
                        currentObject = list[Utility.Random(list.Count)];
                    }

                    Targeting.Target(currentObject);

                    _previousObject = currentObject;
                }
                else
                {
                    Targeting.Target(list[Utility.Random(list.Count)]);
                }
            }
            else
            {
                World.Player.SendMessage(MsgLevel.Warning, LocString.NoItemOfType,
                    m_Mobile ? $"Character [{m_Gfx}]" : ((ItemID) m_Gfx).ToString());
            }

            return true;
        }

        public override string ToScript()
        {
            return $"targettype '{m_Gfx}'";
        }

        public override string Serialize()
        {
            return DoSerialize(m_Mobile, m_Gfx);
        }

        public override string ToString()
        {
            if (m_Mobile)
                return Language.Format(LocString.TargByType, m_Gfx);
            else
                return Language.Format(LocString.TargByType, (ItemID) m_Gfx);
        }

        private ToolStripMenuItem[] m_MenuItems;

        public override ToolStripMenuItem[] GetContextMenuItems()
        {
            if (m_MenuItems == null)
            {
                m_MenuItems = new MacroMenuItem[]
                {
                    new MacroMenuItem(LocString.ReTarget, new MacroMenuCallback(ReTarget)),
                    new MacroMenuItem(LocString.ConvLT, new MacroMenuCallback(ConvertToLastTarget))
                };
            }

            return m_MenuItems;
        }

        private void ReTarget(object[] args)
        {
            Targeting.OneTimeTarget(false, new Targeting.TargetResponseCallback(ReTargetResponse));
            World.Player.SendMessage(MsgLevel.Force, LocString.SelTargAct);
        }

        private void ReTargetResponse(bool ground, Serial serial, Point3D pt, ushort gfx)
        {
            if (!ground && serial.IsValid)
            {
                m_Mobile = serial.IsMobile;
                m_Gfx = gfx;
            }

            Engine.MainWindow.SafeAction(s => s.ShowMe());
            if (m_Parent != null)
                m_Parent.Update();
        }

        private void ConvertToLastTarget(object[] args)
        {
            if (m_Parent != null)
                m_Parent.Convert(this, new LastTargetAction());
        }
    }

    public class TargetRelLocAction : MacroAction
    {
        private sbyte m_X, m_Y;

        public TargetRelLocAction(string[] args)
        {
            m_X = Convert.ToSByte(args[1]);
            m_Y = Convert.ToSByte(args[2]);
        }

        public TargetRelLocAction(sbyte x, sbyte y)
        {
            m_X = x;
            m_Y = y;
        }

        public override bool Perform()
        {
            ushort x = (ushort) (World.Player.Position.X + m_X);
            ushort y = (ushort) (World.Player.Position.Y + m_Y);
            short z = (short) World.Player.Position.Z;
            try
            {
                Ultima.HuedTile tile = Map.GetTileNear(World.Player.Map, x, y, z);
                Targeting.Target(new Point3D(x, y, tile.Z), (ushort) tile.ID);
            }
            catch (Exception e)
            {
                World.Player.SendMessage(MsgLevel.Debug, "Error Executing TargetRelLoc: {0}", e.Message);
            }

            return true;
        }

        public override string ToScript()
        {
            return $"targetrelloc {m_X} {m_Y}";
        }

        public override string Serialize()
        {
            return DoSerialize(m_X, m_Y);
        }

        public override string ToString()
        {
            return Language.Format(LocString.TargRelLocA3, m_X, m_Y, 0);
        }

        private ToolStripMenuItem[] m_MenuItems;

        public override ToolStripMenuItem[] GetContextMenuItems()
        {
            if (m_MenuItems == null)
            {
                m_MenuItems = new MacroMenuItem[]
                {
                    new MacroMenuItem(LocString.ReTarget, new MacroMenuCallback(ReTarget))
                };
            }

            return m_MenuItems;
        }

        private void ReTarget(object[] args)
        {
            Engine.MainWindow.SafeAction(s => s.ShowMe());

            Targeting.OneTimeTarget(true, new Targeting.TargetResponseCallback(ReTargetResponse));
            World.Player.SendMessage(LocString.SelTargAct);
        }

        private void ReTargetResponse(bool ground, Serial serial, Point3D pt, ushort gfx)
        {
            m_X = (sbyte) (pt.X - World.Player.Position.X);
            m_Y = (sbyte) (pt.Y - World.Player.Position.Y);
            // m_Z = (sbyte)(pt.Z - World.Player.Position.Z);
            if (m_Parent != null)
                m_Parent.Update();
        }
    }

    public class LastTargetAction : MacroAction
    {
        public LastTargetAction()
        {
        }

        public override bool Perform()
        {
            if (Targeting.FromGrabHotKey)
                return false;

            if (!Targeting.DoLastTarget()) //Targeting.LastTarget( true );
                Targeting.ResendTarget();
            return true;
        }

        public override string ToString()
        {
            return $"Exec: {Language.GetString(LocString.LastTarget)}";
        }

        public override string ToScript()
        {
            return "lasttarget";
        }
    }

    public class SetLastTargetAction : MacroWaitAction
    {
        public SetLastTargetAction()
        {
        }

        public override bool Perform()
        {
            Targeting.TargetSetLastTarget();
            return !PerformWait();
        }

        public override bool PerformWait()
        {
            return !Targeting.LastTargetWasSet;
        }

        public override string ToString()
        {
            return Language.GetString(LocString.SetLT);
        }

        public override string ToScript()
        {
            return "setlasttarget";
        }
    }

    public class SetMacroVariableTargetAction : MacroWaitAction
    {
        private string m_VarName;
        private MacroVariables.MacroVariable m_MacroVariable;

        public SetMacroVariableTargetAction(string[] args)
        {
            m_VarName = args.Length > 1 ? args[1] : args[0];

            FindMacroVariable();
        }

        public SetMacroVariableTargetAction(string varName)
        {
            m_VarName = varName;

            FindMacroVariable();
        }

        private bool FindMacroVariable()
        {
            foreach (MacroVariables.MacroVariable mV in MacroVariables.MacroVariableList)
            {
                if (mV.Name.ToLower().Equals(m_VarName.ToLower()))
                {
                    m_MacroVariable = mV;
                    break;
                }
            }

            if (m_MacroVariable == null)
            {
                m_VarName = $"?{m_VarName}?";
                return false;
            }

            return true;
        }

        public override bool Perform()
        {
            if (m_MacroVariable == null)
            {
                return false;
            }

            m_MacroVariable.TargetSetMacroVariable();

            return !PerformWait();
        }

        public override bool PerformWait()
        {
            if (m_MacroVariable == null)
            {
                return false;
            }

            return !m_MacroVariable.TargetWasSet;
        }

        public override string ToString()
        {
            return $"Set Macro Variable (${m_VarName})";
        }

        public override string ToScript()
        {
            return $"setvar {m_VarName}";
        }

        public override string Serialize()
        {
            return DoSerialize(m_VarName);
        }
    }

    public class SpeechAction : MacroAction
    {
        private MessageType m_Type;
        private ushort m_Font;
        private ushort m_Hue;
        private string m_Lang;
        private ArrayList m_Keywords;
        private string m_Speech;

        public SpeechAction(string[] args)
        {
            m_Type = ((MessageType) Convert.ToInt32(args[1])) & ~MessageType.Encoded;
            m_Hue = Convert.ToUInt16(args[2]);
            m_Font = Convert.ToUInt16(args[3]);
            m_Lang = args[4];

            int count = Convert.ToInt32(args[5]);
            if (count > 0)
            {
                m_Keywords = new ArrayList(count);
                m_Keywords.Add(Convert.ToUInt16(args[6]));

                for (int i = 1; i < count; i++)
                    m_Keywords.Add(Convert.ToByte(args[6 + i]));
            }

            m_Speech = args[6 + count];
        }

        public SpeechAction(MessageType type, ushort hue, ushort font, string lang, ArrayList kw, string speech)
        {
            m_Type = type;
            m_Hue = hue;
            m_Font = font;
            m_Lang = lang;
            m_Keywords = kw;
            m_Speech = speech;
        }

        public override bool Perform()
        {
            if (m_Speech.Length > 1 && m_Speech[0] == '-')
            {
                string text = m_Speech.Substring(1);
                string[] split = text.Split(' ', '\t');
                CommandCallback call = (CommandCallback) Command.List[split[0]];
                if (call == null && text[0] == '-')
                {
                    call = (CommandCallback) Command.List["-"];
                    if (call != null && split.Length > 1 && split[1] != null && split[1].Length > 1)
                        split[1] = split[1].Substring(1);
                }

                if (call != null)
                {
                    ArrayList list = new ArrayList();
                    for (int i = 1; i < split.Length; i++)
                    {
                        if (split[i] != null && split[i].Length > 0)
                            list.Add(split[i]);
                    }

                    call((string[]) list.ToArray(typeof(string)));
                    return true;
                }
            }

            int hue = m_Hue;

            if (m_Type != MessageType.Emote)
            {
                if (World.Player.SpeechHue == 0)
                    World.Player.SpeechHue = m_Hue;
                hue = World.Player.SpeechHue;
            }

            Client.Instance.SendToServer(new ClientUniMessage(m_Type, hue, m_Font, m_Lang, m_Keywords, m_Speech));
            return true;
        }

        public override string ToScript()
        {
            switch (m_Type)
            {
                case MessageType.Emote:
                    return $"emote '{m_Speech}'";
                case MessageType.Whisper:
                    return $"whisper '{m_Speech}'";
                case MessageType.Yell:
                    return $"yell '{m_Speech}'";
                case MessageType.Alliance:
                    return $"alliance '{m_Speech}'";
                case MessageType.Guild:
                    return $"guild '{m_Speech}'";
                case MessageType.Regular:
                default:
                    return $"say '{m_Speech}'";
            }
        }

        public override string Serialize()
        {
            ArrayList list = new ArrayList(6);
            list.Add((int) m_Type);
            list.Add(m_Hue);
            list.Add(m_Font);
            list.Add(m_Lang);
            if (m_Keywords != null && m_Keywords.Count > 1)
            {
                list.Add((int) m_Keywords.Count);
                for (int i = 0; i < m_Keywords.Count; i++)
                    list.Add(m_Keywords[i]);
            }
            else
            {
                list.Add("0");
            }

            list.Add(m_Speech);

            return DoSerialize((object[]) list.ToArray(typeof(object)));
        }

        public override string ToString()
        {
            //return Language.Format( LocString.SayQA1, m_Speech );
            StringBuilder sb = new StringBuilder();
            switch (m_Type)
            {
                case MessageType.Emote:
                    sb.Append("Emote: ");
                    break;
                case MessageType.Whisper:
                    sb.Append("Whisper: ");
                    break;
                case MessageType.Yell:
                    sb.Append("Yell: ");
                    break;
                case MessageType.Alliance:
                    sb.Append("Alliance: ");
                    break;
                case MessageType.Guild:
                    sb.Append("Guild: ");
                    break;
                case MessageType.Regular:
                default:
                    sb.Append("Say: ");
                    break;
            }

            sb.Append(m_Speech);
            return sb.ToString();
        }

        private ToolStripMenuItem[] m_MenuItems;

        public override ToolStripMenuItem[] GetContextMenuItems()
        {
            if (this.m_MenuItems == null)
                this.m_MenuItems = (ToolStripMenuItem[]) new MacroMenuItem[1]
                {
                    new MacroMenuItem(LocString.Edit, new MacroMenuCallback(this.Edit), new object[0])
                };
            return this.m_MenuItems;
        }

        private void Edit(object[] args)
        {
            if (InputBox.Show(Language.GetString(LocString.EnterNewText), "Input Box", this.m_Speech))
                this.m_Speech = InputBox.GetString();
            if (this.Parent == null)
                return;
            this.Parent.Update();
        }
    }

    public class OverheadMessageAction : MacroAction
    {
        private ushort _hue;
        private string _message;

        public OverheadMessageAction(string[] args)
        {
            _hue = Convert.ToUInt16(args[1]);

            List<string> message = new List<string>();

            for (int i = 2; i < args.Length; i++)
            {
                message.Add(args[i]);
            }

            _message = string.Join(" ", message);
        }

        public OverheadMessageAction(ushort hue, string message)
        {
            _hue = hue;
            _message = message;
        }

        public override bool Perform()
        {
            if (_message.Length > 0)
            {
                World.Player.OverheadMessage(_hue, _message);
            }

            return true;
        }

        public override string ToScript()
        {
            return $"overhead '{_message}' {_hue}";
        }

        public override string Serialize()
        {
            ArrayList list = new ArrayList(2) {_hue, _message};

            return DoSerialize((object[]) list.ToArray(typeof(object)));
        }

        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();
            sb.Append($"Overhead ({_hue}): ");
            sb.Append(_message);
            return sb.ToString();
        }

        private ToolStripMenuItem[] _menuItems;

        public override ToolStripMenuItem[] GetContextMenuItems()
        {
            return _menuItems ?? (_menuItems = new MacroMenuItem[]
            {
                new MacroMenuItem(LocString.Edit, Edit),
                new MacroMenuItem(LocString.SetHue, SetHue)
            });
        }

        private void Edit(object[] args)
        {
            if (InputBox.Show(Language.GetString(LocString.EnterNewText), "Input Box", _message))
                _message = InputBox.GetString();

            Parent?.Update();
        }

        private void SetHue(object[] args)
        {
            HueEntry h = new HueEntry(_hue);

            if (h.ShowDialog(Engine.MainWindow) == DialogResult.OK)
            {
                _hue = (ushort)h.Hue;
            }

            Parent?.Update();
        }

    }

    public class UseSkillAction : MacroAction
    {
        private int m_Skill;

        public UseSkillAction(string[] args)
        {
            m_Skill = Convert.ToInt32(args[1]);
        }

        public UseSkillAction(int sk)
        {
            m_Skill = sk;
        }

        public override bool Perform()
        {
            Client.Instance.SendToServer(new UseSkill(m_Skill));

            if (m_Skill == Skills.StealthIndex && !World.Player.Visible)
            {
                StealthSteps.Hide();
            }

            World.Player.LastSkill = m_Skill;

            return true;
        }

        public override string ToScript()
        {
            return $"skill '{Skills.GetSkillDisplayName(m_Skill)}'";
        }

        public override string Serialize()
        {
            return DoSerialize(m_Skill);
        }

        public override string ToString()
        {
            return Language.Format(LocString.UseSkillA1, Skills.GetSkillDisplayName(m_Skill));
        }
    }

    public class ExtCastSpellAction : MacroAction
    {
        private Spell m_Spell;
        private Serial m_Book;

        public ExtCastSpellAction(string[] args)
        {
            m_Spell = Spell.Get(Convert.ToInt32(args[1]));
            m_Book = Serial.Parse(args[2]);
        }

        public ExtCastSpellAction(int s, Serial book)
        {
            m_Spell = Spell.Get(s);
            m_Book = book;
        }

        public ExtCastSpellAction(Spell s, Serial book)
        {
            m_Spell = s;
            m_Book = book;
        }

        public override bool Perform()
        {
            m_Spell.OnCast(new ExtCastSpell(m_Book, (ushort) m_Spell.GetID()));
            return true;
        }

        public override string ToScript()
        {
            return $"cast '{m_Spell.GetName()}'";
        }

        public override string Serialize()
        {
            return DoSerialize(m_Spell.GetID(), m_Book.Value);
        }

        public override string ToString()
        {
            return Language.Format(LocString.CastSpellA1, m_Spell);
        }
    }

    public class BookCastSpellAction : MacroAction
    {
        private Spell m_Spell;
        private Serial m_Book;

        public BookCastSpellAction(string[] args)
        {
            m_Spell = Spell.Get(Convert.ToInt32(args[1]));
            m_Book = Serial.Parse(args[2]);
        }

        public BookCastSpellAction(int s, Serial book)
        {
            m_Spell = Spell.Get(s);
            m_Book = book;
        }

        public BookCastSpellAction(Spell s, Serial book)
        {
            m_Spell = s;
            m_Book = book;
        }

        public override bool Perform()
        {
            m_Spell.OnCast(new CastSpellFromBook(m_Book, (ushort) m_Spell.GetID()));
            return true;
        }

        public override string ToScript()
        {
            return $"cast '{m_Spell.GetName()}'";
        }

        public override string Serialize()
        {
            return DoSerialize(m_Spell.GetID(), m_Book.Value);
        }

        public override string ToString()
        {
            return Language.Format(LocString.CastSpellA1, m_Spell);
        }
    }

    public class MacroCastSpellAction : MacroAction
    {
        private Spell m_Spell;

        public MacroCastSpellAction(string[] args)
        {
            m_Spell = Spell.Get(Convert.ToInt32(args[1]));
        }

        public MacroCastSpellAction(int s)
        {
            m_Spell = Spell.Get(s);
        }

        public MacroCastSpellAction(Spell s)
        {
            m_Spell = s;
        }

        public override bool Perform()
        {
            m_Spell.OnCast(new CastSpellFromMacro((ushort) m_Spell.GetID()));
            return true;
        }

        public override string ToScript()
        {
            return $"cast '{m_Spell.GetName()}'";
        }

        public override string Serialize()
        {
            return DoSerialize(m_Spell.GetID());
        }

        public override string ToString()
        {
            return Language.Format(LocString.CastSpellA1, m_Spell);
        }
    }

    public class SetAbilityAction : MacroAction
    {
        private AOSAbility m_Ability;

        public SetAbilityAction(string[] args)
        {
            m_Ability = (AOSAbility) Convert.ToInt32(args[1]);
        }

        public SetAbilityAction(AOSAbility a)
        {
            m_Ability = a;
        }

        public override bool Perform()
        {
            Client.Instance.SendToServer(new UseAbility(m_Ability));
            return true;
        }

        public override string ToScript()
        {
            return $"setability '{m_Ability}'";
        }

        public override string Serialize()
        {
            return DoSerialize((int) m_Ability);
        }

        public override string ToString()
        {
            return Language.Format(LocString.SetAbilityA1, m_Ability);
        }
    }

    public class DressAction : MacroWaitAction
    {
        private string m_Name;

        public DressAction(string[] args)
        {
            m_Name = args[1];
        }

        public DressAction(string name)
        {
            m_Name = name;
        }

        public override bool Perform()
        {
            DressList list = DressList.Find(m_Name);
            if (list != null)
            {
                list.Dress();
                return false;
            }
            else
            {
                return true;
            }
        }

        public override bool PerformWait()
        {
            return !ActionQueue.Empty;
        }

        public override string ToScript()
        {
            return $"dress '{m_Name}'";
        }

        public override string Serialize()
        {
            return DoSerialize(m_Name);
        }

        public override string ToString()
        {
            return Language.Format(LocString.DressA1, m_Name);
        }
    }

    public class UnDressAction : MacroWaitAction
    {
        private string m_Name;
        private byte m_Layer;

        public UnDressAction(string[] args)
        {
            try
            {
                m_Layer = Convert.ToByte(args[2]);
            }
            catch
            {
                m_Layer = 255;
            }

            if (m_Layer == 255)
                m_Name = args[1];
            else
                m_Name = "";
        }

        public UnDressAction(string name)
        {
            m_Name = name;
            m_Layer = 255;
        }

        public UnDressAction(byte layer)
        {
            m_Layer = layer;
            m_Name = "";
        }

        public override bool Perform()
        {
            if (m_Layer == 255)
            {
                DressList list = DressList.Find(m_Name);
                if (list != null)
                {
                    list.Undress();
                    return false;
                }
                else
                {
                    return true;
                }
            }
            else if (m_Layer == 0)
            {
                HotKeys.UndressHotKeys.OnUndressAll();
                return false;
            }
            else
            {
                return !Dress.Unequip((Layer) m_Layer);
            }
        }

        public override bool PerformWait()
        {
            return !ActionQueue.Empty;
        }

        public override string ToScript()
        {
            if (m_Layer == 255)
            {
                return $"undress '{m_Name}'";
            }

            return m_Layer == 0 ? "undress" : $"undress '{m_Layer}'";
        }

        public override string Serialize()
        {
            return DoSerialize(m_Name, m_Layer);
        }

        public override string ToString()
        {
            if (m_Layer == 255)
                return Language.Format(LocString.UndressA1, m_Name);
            else if (m_Layer == 0)
                return Language.GetString(LocString.UndressAll);
            else
                return Language.Format(LocString.UndressLayerA1, (Layer) m_Layer);
        }
    }

    public class WalkAction : MacroWaitAction
    {
        private Direction m_Dir;
        private static DateTime m_LastWalk = DateTime.MinValue;

        public static DateTime LastWalkTime
        {
            get { return m_LastWalk; }
            set { m_LastWalk = value; }
        }

        public WalkAction(string[] args)
        {
            m_Dir = (Direction) (Convert.ToByte(args[1])) & Direction.Mask;
        }

        public WalkAction(Direction dir)
        {
            m_Dir = dir & Direction.Mask;
        }

        //private static int m_LastSeq = -1;
        public override bool Perform()
        {
            return !PerformWait();
        }

        //public static bool IsMacroWalk(byte seq)
        //{
        //    return m_LastSeq != -1 && m_LastSeq == (int)seq && World.Player.HasWalkEntry((byte)m_LastSeq);
        //}

        public override bool PerformWait()
        {
            if (m_LastWalk + TimeSpan.FromSeconds(0.4) >= DateTime.UtcNow)
            {
                return true;
            }
            else
            {
                //m_LastSeq = World.Player.WalkSequence;
                m_LastWalk = DateTime.UtcNow;

                //Client.Instance.SendToClient(new MobileUpdate(World.Player));
                //Client.Instance.SendToClient(new ForceWalk(m_Dir));
                //Client.Instance.SendToServer(new WalkRequest(m_Dir, World.Player.WalkSequence));
                //World.Player.MoveReq(m_Dir, World.Player.WalkSequence);

                Client.Instance.RequestMove(m_Dir);
                return false;
            }
        }

        public override string ToScript()
        {
            return m_Dir == Direction.Mask ? $"walk 'Up'" : $"walk '{m_Dir}'";
        }

        public override string Serialize()
        {
            return DoSerialize((byte) m_Dir);
        }

        public override string ToString()
        {
            return Language.Format(LocString.WalkA1, m_Dir != Direction.Mask ? m_Dir.ToString() : "Up");
        }
    }

    public class WaitForMenuAction : MacroWaitAction
    {
        private uint m_MenuID;

        public WaitForMenuAction(uint gid)
        {
            m_MenuID = gid;
        }

        public WaitForMenuAction(string[] args)
        {
            if (args.Length > 1)
                m_MenuID = Convert.ToUInt32(args[1]);

            try
            {
                m_Timeout = TimeSpan.FromSeconds(Convert.ToDouble(args[2]));
            }
            catch
            {
            }
        }

        public override bool Perform()
        {
            return !PerformWait();
        }

        public override bool PerformWait()
        {
            return !(World.Player.HasMenu && (World.Player.CurrentGumpI == m_MenuID || m_MenuID == 0));
        }

        public override string ToString()
        {
            if (m_MenuID == 0)
                return Language.GetString(LocString.WaitAnyMenu);
            else
                return Language.Format(LocString.WaitMenuA1, m_MenuID);
        }

        public override string ToScript()
        {
            return $"waitformenu {m_MenuID}";
        }

        public override string Serialize()
        {
            return DoSerialize(m_MenuID, m_Timeout.TotalSeconds);
        }

        public override bool CheckMatch(MacroAction a)
        {
            if (a is WaitForMenuAction)
            {
                if (m_MenuID == 0 || ((WaitForMenuAction) a).m_MenuID == m_MenuID)
                    return true;
            }

            return false;
        }

        private ToolStripMenuItem[] m_MenuItems;

        public override ToolStripMenuItem[] GetContextMenuItems()
        {
            if (m_MenuItems == null)
            {
                m_MenuItems = new MacroMenuItem[]
                {
                    new MacroMenuItem(LocString.Edit, new MacroMenuCallback(Edit)),
                    this.EditTimeoutMenuItem
                };
            }

            return m_MenuItems;
        }

        private void Edit(object[] args)
        {
            new MacroInsertWait(this).ShowDialog(Engine.MainWindow);
        }
    }

    public class WaitForGumpAction : MacroWaitAction
    {
        private uint m_GumpID;
        private bool m_Strict;

        public WaitForGumpAction()
        {
            m_GumpID = 0;
            m_Strict = false;
        }

        public WaitForGumpAction(uint gid)
        {
            m_GumpID = gid;
            m_Strict = false;
        }

        public WaitForGumpAction(string[] args)
        {
            m_GumpID = Convert.ToUInt32(args[1]);
            try
            {
                m_Strict = Convert.ToBoolean(args[2]);
            }
            catch
            {
                m_Strict = false;
            }

            try
            {
                m_Timeout = TimeSpan.FromSeconds(Convert.ToDouble(args[3]));
            }
            catch
            {
            }
        }

        public override bool Perform()
        {
            return !PerformWait();
        }

        public override bool PerformWait()
        {
            return !((World.Player.HasGump || World.Player.HasCompressedGump) &&
                     (World.Player.CurrentGumpI == m_GumpID || !m_Strict || m_GumpID == 0));

            //if (!World.Player.HasGump) // Does the player even have a gump?
            //    return true;

            //if ((int)World.Player.CurrentGumpI != (int)m_GumpID && m_Strict)
            //    return m_GumpID > 0;

            //return false;
        }

        public override string ToString()
        {
            if (m_GumpID == 0 || !m_Strict)
                return Language.GetString(LocString.WaitAnyGump);
            else
                return Language.Format(LocString.WaitGumpA1, m_GumpID);
        }

        public override string ToScript()
        {
            return $"waitforgump {m_GumpID}";
        }

        public override string Serialize()
        {
            return DoSerialize(m_GumpID, m_Strict, m_Timeout.TotalSeconds);
        }

        public override bool CheckMatch(MacroAction a)
        {
            if (a is WaitForGumpAction)
            {
                if (m_GumpID == 0 || ((WaitForGumpAction) a).m_GumpID == m_GumpID)
                    return true;
            }

            return false;
        }

        private ToolStripMenuItem[] m_MenuItems;

        public override ToolStripMenuItem[] GetContextMenuItems()
        {
            if (m_MenuItems == null)
            {
                m_MenuItems = new MacroMenuItem[]
                {
                    new MacroMenuItem(LocString.Edit, new MacroMenuCallback(Edit)),
                    new MacroMenuItem(LocString.Null, new MacroMenuCallback(ToggleStrict)),
                    this.EditTimeoutMenuItem
                };
            }

            if (!m_Strict)
                m_MenuItems[1].Text =
                    $"Change to \"{Language.Format(LocString.WaitGumpA1, m_GumpID)}\"";
            else
                m_MenuItems[1].Text = $"Change to \"{Language.GetString(LocString.WaitAnyGump)}\"";
            m_MenuItems[1].Enabled = m_GumpID != 0 || m_Strict;

            return m_MenuItems;
        }

        private void Edit(object[] args)
        {
            new MacroInsertWait(this).ShowDialog(Engine.MainWindow);
        }

        private void ToggleStrict(object[] args)
        {
            m_Strict = !m_Strict;
            if (m_Parent != null)
                m_Parent.Update();
        }
    }

    public class WaitForTargetAction : MacroWaitAction
    {
        public WaitForTargetAction()
        {
            m_Timeout = TimeSpan.FromSeconds(30.0);
        }

        public WaitForTargetAction(string[] args)
        {
            try
            {
                m_Timeout = TimeSpan.FromSeconds(Convert.ToDouble(args[1]));
            }
            catch
            {
                m_Timeout = TimeSpan.FromSeconds(30.0);
            }
        }

        public override bool Perform()
        {
            return !PerformWait();
        }

        public override bool PerformWait()
        {
            return !Targeting.HasTarget;
        }

        public override string ToString()
        {
            return Language.GetString(LocString.WaitTarg);
        }

        public override string ToScript()
        {
            return $"waitfortarget";
        }

        public override string Serialize()
        {
            return DoSerialize(m_Timeout.TotalSeconds);
        }

        private ToolStripMenuItem[] m_MenuItems;

        public override ToolStripMenuItem[] GetContextMenuItems()
        {
            if (m_MenuItems == null)
            {
                m_MenuItems = new MacroMenuItem[]
                {
                    new MacroMenuItem(LocString.Edit, new MacroMenuCallback(Edit)),
                    this.EditTimeoutMenuItem
                };
            }

            return m_MenuItems;
        }

        public override bool CheckMatch(MacroAction a)
        {
            return (a is WaitForTargetAction);
        }

        private void Edit(object[] args)
        {
            new MacroInsertWait(this).ShowDialog(Engine.MainWindow);
        }
    }

    public class PauseAction : MacroWaitAction
    {
        public PauseAction(string[] args)
        {
            m_Timeout = TimeSpan.Parse(args[1]);
        }

        public PauseAction(int ms)
        {
            m_Timeout = TimeSpan.FromMilliseconds(ms);
        }

        public PauseAction(TimeSpan time)
        {
            m_Timeout = time;
        }

        public override string ToScript()
        {
            return $"wait {m_Timeout.TotalMilliseconds}";
        }

        public override string Serialize()
        {
            return DoSerialize(m_Timeout);
        }

        public override bool Perform()
        {
            this.StartTime = DateTime.UtcNow;
            return !PerformWait();
        }

        public override bool PerformWait()
        {
            return (StartTime + m_Timeout >= DateTime.UtcNow);
        }

        public override string ToString()
        {
            return Language.Format(LocString.PauseA1, m_Timeout.TotalSeconds);
        }

        private ToolStripMenuItem[] m_MenuItems;

        public override ToolStripMenuItem[] GetContextMenuItems()
        {
            if (m_MenuItems == null)
            {
                m_MenuItems = new MacroMenuItem[]
                {
                    new MacroMenuItem(LocString.Edit, new MacroMenuCallback(Edit))
                };
            }

            return m_MenuItems;
        }

        private void Edit(object[] args)
        {
            new MacroInsertWait(this).ShowDialog(Engine.MainWindow);
        }
    }

    public class WaitForStatAction : MacroWaitAction
    {
        private byte m_Direction;
        private int m_Value;
        private IfAction.IfVarType m_Stat;

        public byte Op
        {
            get { return m_Direction; }
        }

        public int Amount
        {
            get { return m_Value; }
        }

        public IfAction.IfVarType Stat
        {
            get { return m_Stat; }
        }

        public WaitForStatAction(string[] args)
        {
            m_Stat = (IfAction.IfVarType) Convert.ToInt32(args[1]);
            m_Direction = Convert.ToByte(args[2]);
            m_Value = Convert.ToInt32(args[3]);

            try
            {
                m_Timeout = TimeSpan.FromSeconds(Convert.ToDouble(args[4]));
            }
            catch
            {
                m_Timeout = TimeSpan.FromMinutes(60.0);
            }
        }

        public WaitForStatAction(IfAction.IfVarType stat, byte dir, int val)
        {
            m_Stat = stat;
            m_Direction = dir;
            m_Value = val;

            m_Timeout = TimeSpan.FromMinutes(60.0);
        }

        public override string ToScript()
        {
            string op = m_Direction > 0 ? ">=" : "<=";
            string stat = "unknown";

            switch (m_Stat)
            {
                case IfAction.IfVarType.Hits:
                    stat = "hits";
                    break;
                case IfAction.IfVarType.Mana:
                    stat = "mana";
                    break;
                case IfAction.IfVarType.Stamina:
                    stat = "stam";
                    break;
            }

            return $"if {stat} {op} {m_Value}";
        }

        public override string Serialize()
        {
            return DoSerialize((int) m_Stat, m_Direction, m_Value, m_Timeout.TotalSeconds);
        }

        public override bool Perform()
        {
            return !PerformWait();
        }

        public override bool PerformWait()
        {
            if (m_Direction > 0)
            {
                // wait for m_Stat >= m_Value
                switch (m_Stat)
                {
                    case IfAction.IfVarType.Hits:
                        return World.Player.Hits < m_Value;
                    case IfAction.IfVarType.Mana:
                        return World.Player.Mana < m_Value;
                    case IfAction.IfVarType.Stamina:
                        return World.Player.Stam < m_Value;
                }
            }
            else
            {
                // wait for m_Stat <= m_Value
                switch (m_Stat)
                {
                    case IfAction.IfVarType.Hits:
                        return World.Player.Hits > m_Value;
                    case IfAction.IfVarType.Mana:
                        return World.Player.Mana > m_Value;
                    case IfAction.IfVarType.Stamina:
                        return World.Player.Stam > m_Value;
                }
            }

            return false;
        }

        public override string ToString()
        {
            return Language.Format(LocString.WaitA3, m_Stat, m_Direction > 0 ? ">=" : "<=", m_Value);
        }

        private ToolStripMenuItem[] m_MenuItems;

        public override ToolStripMenuItem[] GetContextMenuItems()
        {
            if (m_MenuItems == null)
            {
                m_MenuItems = new MacroMenuItem[]
                {
                    new MacroMenuItem(LocString.Edit, new MacroMenuCallback(Edit)),
                    this.EditTimeoutMenuItem
                };
            }

            return m_MenuItems;
        }

        private void Edit(object[] args)
        {
            new MacroInsertWait(this).ShowDialog(Engine.MainWindow);
        }
    }

    public class IfAction : MacroAction
    {
        public enum IfVarType : int
        {
            Hits = 0,
            Mana,
            Stamina,
            Poisoned,
            SysMessage,
            Weight,
            Mounted,
            RHandEmpty,
            LHandEmpty,

            BeginCountersMarker,

            Counter = 50,
            Skill = 100
        }

        // 0 <=,1 >=,2 <,3 >
        private sbyte m_Direction;
        private object m_Value;
        private IfVarType m_Var;
        private string m_Counter;
        private int m_SkillId = -1;
        private Assistant.Counter m_CountObj;

        public sbyte Op
        {
            get { return m_Direction; }
        }

        public object Value
        {
            get { return m_Value; }
        }

        public IfVarType Variable
        {
            get { return m_Var; }
        }

        public string Counter
        {
            get { return m_Counter; }
        }

        public int SkillId
        {
            get { return m_SkillId; }
        }

        public IfAction(string[] args)
        {
            m_Var = (IfVarType) Convert.ToInt32(args[1]);
            try
            {
                m_Direction = Convert.ToSByte(args[2]);
                if (m_Direction > 3)
                    m_Direction = 0;
            }
            catch
            {
                m_Direction = -1;
            }

            if (m_Var == IfVarType.SysMessage)
            {
                m_Value = args[3].ToLower();
            }
            else if (m_Var == IfVarType.Skill)
            {
                if (args[3] is string strVal)
                {
                    m_Value = strVal;
                }
                else
                {
                    m_Value = Convert.ToDouble(args[3]);
                }
            }
            else
            {
                if (args[3] is string strVal)
                {
                    m_Value = strVal;
                }
                else
                {
                    m_Value = Convert.ToInt32(args[3]);
                }
            }

            if (m_Var == IfVarType.Counter)
                m_Counter = args[4];

            if (m_Var == IfVarType.Skill)
                m_SkillId = Convert.ToInt32(args[4]);
        }

        public IfAction(IfVarType var, sbyte dir, int val)
        {
            m_Var = var;
            m_Direction = dir;
            m_Value = val;
        }

        public IfAction(IfVarType var, sbyte dir, string val)
        {
            m_Var = var;
            m_Direction = dir;
            m_Value = val;
        }

        public IfAction(IfVarType var, sbyte dir, int val, string counter)
        {
            m_Var = var;
            m_Direction = dir;
            m_Value = val;
            m_Counter = counter;
        }

        public IfAction(IfVarType var, sbyte dir, double val, int skillId)
        {
            m_Var = var;
            m_Direction = dir;
            m_Value = val;
            m_SkillId = skillId;
        }

        public IfAction(IfVarType var, string text)
        {
            m_Var = var;
            m_Value = text.ToLower();
        }

        public override string ToScript()
        {
            string op = "??";
            string expression = "unknown";

            bool useValue = true;

            switch (m_Direction)
            {
                case 0:
                    // if stat <= m_Value
                    op = "<=";
                    break;
                case 1:
                    // if stat >= m_Value
                    op = ">=";
                    break;
                case 2:
                    // if stat < m_Value
                    op = "<";
                    break;
                case 3:
                    // if stat > m_Value
                    op = ">";
                    break;
            }

            switch (m_Var)
            {
                case IfAction.IfVarType.Hits:
                    expression = "hits";
                    break;
                case IfAction.IfVarType.Mana:
                    expression = "mana";
                    break;
                case IfAction.IfVarType.Stamina:
                    expression = "stam";
                    break;
                case IfVarType.Poisoned:
                    expression = "poisoned";
                    break;
                case IfVarType.SysMessage:
                    expression = $"insysmsg '{m_Value}'";
                    useValue = false;
                    break;
                case IfVarType.Weight:
                    expression = "weight";
                    break;
                case IfVarType.Mounted:
                    expression = "mounted";
                    break;
                case IfVarType.RHandEmpty:
                    expression = "rhandempty";
                    break;
                case IfVarType.LHandEmpty:
                    expression = "lhandempty";
                    break;
                case IfVarType.Counter:
                    expression = $"count '{m_Counter}'";
                    break;
                case IfVarType.Skill:
                    expression = $"skill '{Skills.GetSkillDisplayName(m_SkillId)}'";
                    break;
                default:
                    throw new ArgumentOutOfRangeException();
            }
            
            return useValue ? $"if {expression} {op} {m_Value}" : $"if {expression}";

        }

        public override string Serialize()
        {
            if (m_Var == IfVarType.Counter && m_Counter != null)
                return DoSerialize((int) m_Var, m_Direction, m_Value, m_Counter);
            else if (m_Var == IfVarType.Skill && m_SkillId != -1)
                return DoSerialize((int) m_Var, m_Direction, m_Value, m_SkillId);
            else
                return DoSerialize((int) m_Var, m_Direction, m_Value);
        }

        public override bool Perform()
        {
            return true;
        }

        public bool Evaluate()
        {
            switch (m_Var)
            {
                case IfVarType.Hits:
                case IfVarType.Mana:
                case IfVarType.Stamina:
                case IfVarType.Weight:
                {
                    bool isNumeric = true;
                    int val;

                    if (m_Value is string value)
                    {
                        isNumeric = int.TryParse(value, out val);
                    }
                    else
                    {
                        val = Convert.ToInt32(m_Value);
                    }

                    if (!isNumeric && m_Value is string strVal)
                    {
                        if (strVal.Equals("{maxhp}"))
                        {
                            val = World.Player.HitsMax;
                        }
                        else if (strVal.Equals("{maxstam}"))
                        {
                            val = World.Player.StamMax;
                        }
                        else if (strVal.Equals("{maxmana}"))
                        {
                            val = World.Player.ManaMax;
                        }
                        else
                        {
                            val = 0;
                        }
                    }

                    switch (m_Direction)
                    {
                        case 0:
                            // if stat <= m_Value
                            switch (m_Var)
                            {
                                case IfVarType.Hits:
                                    return World.Player.Hits <= val;
                                case IfVarType.Mana:
                                    return World.Player.Mana <= val;
                                case IfVarType.Stamina:
                                    return World.Player.Stam <= val;
                                case IfVarType.Weight:
                                    return World.Player.Weight <= val;
                            }

                            break;
                        case 1:
                            // if stat >= m_Value
                            switch (m_Var)
                            {
                                case IfVarType.Hits:
                                    return World.Player.Hits >= val;
                                case IfVarType.Mana:
                                    return World.Player.Mana >= val;
                                case IfVarType.Stamina:
                                    return World.Player.Stam >= val;
                                case IfVarType.Weight:
                                    return World.Player.Weight >= val;
                            }

                            break;
                        case 2:
                            // if stat < m_Value
                            switch (m_Var)
                            {
                                case IfVarType.Hits:
                                    return World.Player.Hits < val;
                                case IfVarType.Mana:
                                    return World.Player.Mana < val;
                                case IfVarType.Stamina:
                                    return World.Player.Stam < val;
                                case IfVarType.Weight:
                                    return World.Player.Weight < val;
                            }

                            break;
                        case 3:
                            // if stat > m_Value
                            switch (m_Var)
                            {
                                case IfVarType.Hits:
                                    return World.Player.Hits > val;
                                case IfVarType.Mana:
                                    return World.Player.Mana > val;
                                case IfVarType.Stamina:
                                    return World.Player.Stam > val;
                                case IfVarType.Weight:
                                    return World.Player.Weight > val;
                            }

                            break;
                    }

                    return false;
                }

                case IfVarType.Poisoned:
                {
                    if (Client.Instance.AllowBit(FeatureBit.BlockHealPoisoned))
                        return World.Player.Poisoned;
                    else
                        return false;
                }

                case IfVarType.SysMessage:
                {
                    string text = (string) m_Value;

                    return SystemMessages.Exists(text);

                }

                case IfVarType.Mounted:
                {
                    return World.Player.GetItemOnLayer(Layer.Mount) != null;
                }

                case IfVarType.RHandEmpty:
                {
                    return World.Player.GetItemOnLayer(Layer.RightHand) == null;
                }

                case IfVarType.LHandEmpty:
                {
                    return World.Player.GetItemOnLayer(Layer.LeftHand) == null;
                }

                case IfVarType.Skill:

                    double skillValToCompare;

                    if (m_Value is string skillVal)
                    {
                        double.TryParse(skillVal, out skillValToCompare);
                    }
                    else
                    {
                        skillValToCompare = Convert.ToDouble(m_Value);
                    }

                    switch (m_Direction)
                    {
                        case 0:
                            return World.Player.Skills[m_SkillId].Value <= skillValToCompare;
                        case 1:
                            return World.Player.Skills[m_SkillId].Value >= skillValToCompare;
                        case 2:
                            return World.Player.Skills[m_SkillId].Value < skillValToCompare;
                        case 3:
                            return World.Player.Skills[m_SkillId].Value > skillValToCompare;
                        default:
                            return World.Player.Skills[m_SkillId].Value <= skillValToCompare;
                    }

                case IfVarType.Counter:
                {
                    if (m_CountObj == null)
                    {
                        foreach (Assistant.Counter c in Assistant.Counter.List)
                        {
                            if (c.Name == m_Counter)
                            {
                                m_CountObj = c;
                                break;
                            }
                        }
                    }

                    if (m_CountObj == null || !m_CountObj.Enabled)
                        return false;

                    int val;

                    if (m_Value is string value)
                    {
                        int.TryParse(value, out val);
                    }
                    else
                    {
                        val = Convert.ToInt32(m_Value);
                    }

                    switch (m_Direction)
                    {
                        case 0:
                            return m_CountObj.Amount <= val;
                        case 1:
                            return m_CountObj.Amount >= val;
                        case 2:
                            return m_CountObj.Amount < val;
                        case 3:
                            return m_CountObj.Amount > val;
                        default:
                            return m_CountObj.Amount <= val;
                    }
                }

                default:
                    return false;
            }
        }

        private string DirectionString()
        {
            switch (m_Direction)
            {
                case 0:
                    return "<=";
                case 1:
                    return ">=";
                case 2:
                    return "<";
                case 3:
                    return ">";
                default:
                    return "<=";
            }
        }

        public override string ToString()
        {
            switch (m_Var)
            {
                case IfVarType.Hits:
                case IfVarType.Mana:
                case IfVarType.Stamina:
                case IfVarType.Weight:
                    return $"If ( {m_Var} {DirectionString()} {m_Value} )";
                case IfVarType.Poisoned:
                    return "If ( Poisoned )";
                case IfVarType.SysMessage:
                {
                    string str = (string) m_Value;
                    if (str.Length > 10)
                        str = str.Substring(0, 7) + "...";
                    return $"If ( SysMessage \"{str}\" )";
                }

                case IfVarType.Skill:
                    return $"If ( \"{Skills.GetSkillDisplayName(m_SkillId)}\" {DirectionString()} {m_Value})";
                case IfVarType.Mounted:
                    return "If ( Mounted )";
                case IfVarType.RHandEmpty:
                    return "If ( R-Hand Empty )";
                case IfVarType.LHandEmpty:
                    return "If ( L-Hand Empty )";
                case IfVarType.Counter:
                    return $"If ( \"{m_Counter} count\" {DirectionString()} {m_Value} )";
                default:
                    return "If ( ??? )";
            }
        }

        private ToolStripMenuItem[] m_MenuItems;

        public override ToolStripMenuItem[] GetContextMenuItems()
        {
            if (m_MenuItems == null)
            {
                m_MenuItems = new MacroMenuItem[]
                {
                    new MacroMenuItem(LocString.Edit, new MacroMenuCallback(Edit))
                };
            }

            return m_MenuItems;
        }

        private void Edit(object[] args)
        {
            new MacroInsertIf(this).ShowDialog(Engine.MainWindow);
        }
    }

    public class ElseAction : MacroAction
    {
        public ElseAction()
        {
        }

        public override bool Perform()
        {
            return true;
        }

        public override string ToString()
        {
            return "Else";
        }

        public override string ToScript()
        {
            return "else";
        }
    }

    public class EndIfAction : MacroAction
    {
        public EndIfAction()
        {
        }

        public override bool Perform()
        {
            return true;
        }

        public override string ToString()
        {
            return "End If";
        }

        public override string ToScript()
        {
            return "endif";
        }
    }

    public class HotKeyAction : MacroAction
    {
        private KeyData m_Key;

        public HotKeyAction(KeyData hk)
        {
            m_Key = hk;
        }

        public HotKeyAction(string[] args)
        {
            try
            {
                int loc = Convert.ToInt32(args[1]);
                if (loc != 0)
                    m_Key = HotKey.Get(loc);
            }
            catch
            {
            }

            if (m_Key == null)
                m_Key = HotKey.Get(args[2]);

            if (m_Key == null)
                throw new Exception("HotKey not found.");
        }

        public override bool Perform()
        {
            if (Client.Instance.AllowBit(FeatureBit.LoopingMacros) ||
                m_Key.DisplayName.IndexOf(Language.GetString(LocString.PlayA1).Replace(@"{0}", "")) == -1)
                m_Key.Callback();
            return true;
        }

        public override string ToScript()
        {
            return $"hotkey '{m_Key.DisplayName}'";
        }

        public override string Serialize()
        {
            return DoSerialize(m_Key.LocName, m_Key.StrName == null ? "" : m_Key.StrName);
        }

        public override string ToString()
        {
            return $"Exec: {m_Key.DisplayName}";
        }
    }

    public class ForAction : MacroAction
    {
        private int m_Max, m_Count;

        public int Count
        {
            get { return m_Count; }
            set { m_Count = value; }
        }

        public int Max
        {
            get { return m_Max; }
        }

        public ForAction(string[] args)
        {
            m_Max = Convert.ToInt32(args[1]);
        }

        public ForAction(int max)
        {
            m_Max = max;
        }

        public override string ToScript()
        {
            return $"for {m_Max}";
        }

        public override string Serialize()
        {
            return DoSerialize(m_Max);
        }

        public override bool Perform()
        {
            return true;
        }

        public override string ToString()
        {
            return $"For ( 1 to {m_Max} )";
        }

        private ToolStripMenuItem[] m_MenuItems;

        public override ToolStripMenuItem[] GetContextMenuItems()
        {
            if (m_MenuItems == null)
            {
                m_MenuItems = new MacroMenuItem[]
                {
                    new MacroMenuItem(LocString.Edit, new MacroMenuCallback(Edit))
                };
            }

            return m_MenuItems;
        }

        private void Edit(object[] args)
        {
            if (InputBox.Show(Language.GetString(LocString.NumIter), "Input Box", m_Max.ToString()))
                m_Max = InputBox.GetInt(m_Max);
            if (Parent != null)
                Parent.Update();
        }
    }

    public class EndForAction : MacroAction
    {
        public EndForAction()
        {
        }

        public override bool Perform()
        {
            return true;
        }

        public override string ToString()
        {
            return "End For";
        }

        public override string ToScript()
        {
            return "endfor";
        }
    }

    public class WhileAction : MacroAction
    {
        public enum WhileVarType : int
        {
            Hits = 0,
            Mana,
            Stamina,
            Poisoned,
            SysMessage,
            Weight,
            Mounted,
            RHandEmpty,
            LHandEmpty,

            BeginCountersMarker,

            Counter = 50,
            Skill = 100
        }

        // 0 <=,1 >=,2 <,3 >
        private sbyte m_Direction;
        private object m_Value;
        private WhileVarType m_Var;
        private string m_Counter;
        private int m_SkillId = -1;
        private Assistant.Counter m_CountObj;

        public sbyte Op
        {
            get { return m_Direction; }
        }

        public object Value
        {
            get { return m_Value; }
        }

        public WhileVarType Variable
        {
            get { return m_Var; }
        }

        public string Counter
        {
            get { return m_Counter; }
        }

        public int SkillId
        {
            get { return m_SkillId; }
        }

        public WhileAction(string[] args)
        {
            m_Var = (WhileVarType) Convert.ToInt32(args[1]);
            try
            {
                m_Direction = Convert.ToSByte(args[2]);
                if (m_Direction > 3)
                    m_Direction = 0;
            }
            catch
            {
                m_Direction = -1;
            }

            if (m_Var == WhileVarType.SysMessage)
            {
                m_Value = args[3].ToLower();
            }
            else if (m_Var == WhileVarType.Skill)
            {
                if (args[3] is string strVal)
                {
                    m_Value = strVal;
                }
                else
                {
                    m_Value = Convert.ToDouble(args[3]);
                }
            }
            else
            {
                if (args[3] is string strVal)
                {
                    m_Value = strVal;
                }
                else
                {
                    m_Value = Convert.ToInt32(args[3]);
                }
            }

            if (m_Var == WhileVarType.Counter)
                m_Counter = args[4];

            if (m_Var == WhileVarType.Skill)
                m_SkillId = Convert.ToInt32(args[4]);
        }

        public WhileAction(WhileVarType var, sbyte dir, int val)
        {
            m_Var = var;
            m_Direction = dir;
            m_Value = val;
        }

        public WhileAction(WhileVarType var, sbyte dir, string val)
        {
            m_Var = var;
            m_Direction = dir;
            m_Value = val;
        }

        public WhileAction(WhileVarType var, sbyte dir, int val, string counter)
        {
            m_Var = var;
            m_Direction = dir;
            m_Value = val;
            m_Counter = counter;
        }

        public WhileAction(WhileVarType var, sbyte dir, double val, int skillId)
        {
            m_Var = var;
            m_Direction = dir;
            m_Value = val;
            m_SkillId = skillId;
        }

        public WhileAction(WhileVarType var, string text)
        {
            m_Var = var;
            m_Value = text.ToLower();
        }

        public override string ToScript()
        {
            string op = "??";
            string expression = "unknown";

            bool useValue = true;

            switch (m_Direction)
            {
                case 0:
                    // if stat <= m_Value
                    op = "<=";
                    break;
                case 1:
                    // if stat >= m_Value
                    op = ">=";
                    break;
                case 2:
                    // if stat < m_Value
                    op = "<";
                    break;
                case 3:
                    // if stat > m_Value
                    op = ">";
                    break;
            }

            switch (m_Var)
            {
                case WhileVarType.Hits:
                    expression = "hits";
                    break;
                case WhileVarType.Mana:
                    expression = "mana";
                    break;
                case WhileVarType.Stamina:
                    expression = "stam";
                    break;
                case WhileVarType.Poisoned:
                    expression = "poisoned";
                    break;
                case WhileVarType.SysMessage:
                    expression = $"insysmsg '{m_Value}'";
                    useValue = false;
                    break;
                case WhileVarType.Weight:
                    expression = "weight";
                    break;
                case WhileVarType.Mounted:
                    expression = "mounted";
                    break;
                case WhileVarType.RHandEmpty:
                    expression = "rhandempty";
                    break;
                case WhileVarType.LHandEmpty:
                    expression = "lhandempty";
                    break;
                case WhileVarType.Counter:
                    expression = $"count '{m_Counter}'";
                    break;
                case WhileVarType.Skill:
                    expression = $"skill '{Skills.GetSkillDisplayName(m_SkillId)}'";
                    break;
                default:
                    throw new ArgumentOutOfRangeException();
            }
            
            return useValue ? $"while {expression} {op} {m_Value}" : $"while {expression}";
        }

        public override string Serialize()
        {
            if (m_Var == WhileVarType.Counter && m_Counter != null)
                return DoSerialize((int) m_Var, m_Direction, m_Value, m_Counter);
            else if (m_Var == WhileVarType.Skill && m_SkillId != -1)
                return DoSerialize((int) m_Var, m_Direction, m_Value, m_SkillId);
            else
                return DoSerialize((int) m_Var, m_Direction, m_Value);
        }

        public override bool Perform()
        {
            return true;
        }

        public bool Evaluate()
        {
            switch (m_Var)
            {
                case WhileVarType.Hits:
                case WhileVarType.Mana:
                case WhileVarType.Stamina:
                case WhileVarType.Weight:
                {
                    bool isNumeric = true;
                    int val;

                    if (m_Value is string value)
                    {
                        isNumeric = int.TryParse(value, out val);
                    }
                    else
                    {
                        val = Convert.ToInt32(m_Value);
                    }

                    if (!isNumeric && m_Value is string strVal)
                    {
                        if (strVal.Equals("{maxhp}"))
                        {
                            val = World.Player.HitsMax;
                        }
                        else if (strVal.Equals("{maxstam}"))
                        {
                            val = World.Player.StamMax;
                        }
                        else if (strVal.Equals("{maxmana}"))
                        {
                            val = World.Player.ManaMax;
                        }
                        else
                        {
                            val = 0;
                        }
                    }

                    switch (m_Direction)
                    {
                        case 0:
                            // if stat <= m_Value
                            switch (m_Var)
                            {
                                case WhileVarType.Hits:
                                    return World.Player.Hits <= val;
                                case WhileVarType.Mana:
                                    return World.Player.Mana <= val;
                                case WhileVarType.Stamina:
                                    return World.Player.Stam <= val;
                                case WhileVarType.Weight:
                                    return World.Player.Weight <= val;
                            }

                            break;
                        case 1:
                            // if stat >= m_Value
                            switch (m_Var)
                            {
                                case WhileVarType.Hits:
                                    return World.Player.Hits >= val;
                                case WhileVarType.Mana:
                                    return World.Player.Mana >= val;
                                case WhileVarType.Stamina:
                                    return World.Player.Stam >= val;
                                case WhileVarType.Weight:
                                    return World.Player.Weight >= val;
                            }

                            break;
                        case 2:
                            // if stat < m_Value
                            switch (m_Var)
                            {
                                case WhileVarType.Hits:
                                    return World.Player.Hits < val;
                                case WhileVarType.Mana:
                                    return World.Player.Mana < val;
                                case WhileVarType.Stamina:
                                    return World.Player.Stam < val;
                                case WhileVarType.Weight:
                                    return World.Player.Weight < val;
                            }

                            break;
                        case 3:
                            // if stat > m_Value
                            switch (m_Var)
                            {
                                case WhileVarType.Hits:
                                    return World.Player.Hits > val;
                                case WhileVarType.Mana:
                                    return World.Player.Mana > val;
                                case WhileVarType.Stamina:
                                    return World.Player.Stam > val;
                                case WhileVarType.Weight:
                                    return World.Player.Weight > val;
                            }

                            break;
                    }

                    return false;
                }

                case WhileVarType.Poisoned:
                {
                    if (Client.Instance.AllowBit(FeatureBit.BlockHealPoisoned))
                        return World.Player.Poisoned;
                    else
                        return false;
                }

                case WhileVarType.SysMessage:
                {
                    string text = (string) m_Value;

                    return SystemMessages.Exists(text);
                }

                case WhileVarType.Mounted:
                {
                    return World.Player.GetItemOnLayer(Layer.Mount) != null;
                }

                case WhileVarType.RHandEmpty:
                {
                    return World.Player.GetItemOnLayer(Layer.RightHand) == null;
                }

                case WhileVarType.LHandEmpty:
                {
                    return World.Player.GetItemOnLayer(Layer.LeftHand) == null;
                }

                case WhileVarType.Skill:

                    double skillValToCompare;

                    if (m_Value is string skillVal)
                    {
                        double.TryParse(skillVal, out skillValToCompare);
                    }
                    else
                    {
                        skillValToCompare = Convert.ToDouble(m_Value);
                    }

                    switch (m_Direction)
                    {
                        case 0:
                            return World.Player.Skills[m_SkillId].Value <= skillValToCompare;
                        case 1:
                            return World.Player.Skills[m_SkillId].Value >= skillValToCompare;
                        case 2:
                            return World.Player.Skills[m_SkillId].Value < skillValToCompare;
                        case 3:
                            return World.Player.Skills[m_SkillId].Value > skillValToCompare;
                        default:
                            return World.Player.Skills[m_SkillId].Value <= skillValToCompare;
                    }

                case WhileVarType.Counter:
                {
                    if (m_CountObj == null)
                    {
                        foreach (Assistant.Counter c in Assistant.Counter.List)
                        {
                            if (c.Name == m_Counter)
                            {
                                m_CountObj = c;
                                break;
                            }
                        }
                    }

                    if (m_CountObj == null || !m_CountObj.Enabled)
                        return false;

                    int val;

                    if (m_Value is string value)
                    {
                        int.TryParse(value, out val);
                    }
                    else
                    {
                        val = Convert.ToInt32(m_Value);
                    }

                    switch (m_Direction)
                    {
                        case 0:
                            return m_CountObj.Amount <= val;
                        case 1:
                            return m_CountObj.Amount >= val;
                        case 2:
                            return m_CountObj.Amount < val;
                        case 3:
                            return m_CountObj.Amount > val;
                        default:
                            return m_CountObj.Amount <= val;
                    }
                }

                default:
                    return false;
            }
        }

        private string DirectionString()
        {
            switch (m_Direction)
            {
                case 0:
                    return "<=";
                case 1:
                    return ">=";
                case 2:
                    return "<";
                case 3:
                    return ">";
                default:
                    return "<=";
            }
        }

        public override string ToString()
        {
            switch (m_Var)
            {
                case WhileVarType.Hits:
                case WhileVarType.Mana:
                case WhileVarType.Stamina:
                case WhileVarType.Weight:
                    return $"While ( {m_Var} {DirectionString()} {m_Value} )";
                case WhileVarType.Poisoned:
                    return "While ( Poisoned )";
                case WhileVarType.SysMessage:
                {
                    string str = (string) m_Value;
                    if (str.Length > 10)
                        str = str.Substring(0, 7) + "...";
                    return $"While ( SysMessage \"{str}\" )";
                }

                case WhileVarType.Skill:
                    return $"While ( \"{Skills.GetSkillDisplayName(m_SkillId)}\" {DirectionString()} {m_Value})";
                case WhileVarType.Mounted:
                    return "While ( Mounted )";
                case WhileVarType.RHandEmpty:
                    return "While ( R-Hand Empty )";
                case WhileVarType.LHandEmpty:
                    return "While ( L-Hand Empty )";
                case WhileVarType.Counter:
                    return $"While ( \"{m_Counter} count\" {DirectionString()} {m_Value} )";
                default:
                    return "While ( ??? )";
            }
        }

        private ToolStripMenuItem[] m_MenuItems;

        public override ToolStripMenuItem[] GetContextMenuItems()
        {
            if (m_MenuItems == null)
            {
                m_MenuItems = new MacroMenuItem[]
                {
                    new MacroMenuItem(LocString.Edit, new MacroMenuCallback(Edit))
                };
            }

            return m_MenuItems;
        }

        private void Edit(object[] args)
        {
            new MacroInsertWhile(this).ShowDialog(Engine.MainWindow);
        }
    }

    public class EndWhileAction : MacroAction
    {
        public EndWhileAction()
        {
        }

        public override bool Perform()
        {
            return true;
        }

        public override string ToString()
        {
            return "End While";
        }

        public override string ToScript()
        {
            return "endwhile";
        }
    }

    public class StartDoWhileAction : MacroAction
    {
        public StartDoWhileAction()
        {
        }

        public override bool Perform()
        {
            return true;
        }

        public override string ToString()
        {
            return "Do";
        }

        public override string ToScript()
        {
            return "# do-while not implemented, use while";
        }
    }

    public class DoWhileAction : MacroAction
    {
        public enum DoWhileVarType : int
        {
            Hits = 0,
            Mana,
            Stamina,
            Poisoned,
            SysMessage,
            Weight,
            Mounted,
            RHandEmpty,
            LHandEmpty,

            BeginCountersMarker,

            Counter = 50,
            Skill = 100
        }

        // 0 <=,1 >=,2 <,3 >
        private sbyte m_Direction;
        private object m_Value;
        private DoWhileVarType m_Var;
        private string m_Counter;
        private int m_SkillId = -1;
        private Assistant.Counter m_CountObj;

        public sbyte Op
        {
            get { return m_Direction; }
        }

        public object Value
        {
            get { return m_Value; }
        }

        public DoWhileVarType Variable
        {
            get { return m_Var; }
        }

        public string Counter
        {
            get { return m_Counter; }
        }

        public int SkillId
        {
            get { return m_SkillId; }
        }

        public DoWhileAction(string[] args)
        {
            m_Var = (DoWhileVarType) Convert.ToInt32(args[1]);
            try
            {
                m_Direction = Convert.ToSByte(args[2]);
                if (m_Direction > 3)
                    m_Direction = 0;
            }
            catch
            {
                m_Direction = -1;
            }

            if (m_Var == DoWhileVarType.SysMessage)
            {
                m_Value = args[3].ToLower();
            }
            else if (m_Var == DoWhileVarType.Skill)
            {
                if (args[3] is string strVal)
                {
                    m_Value = strVal;
                }
                else
                {
                    m_Value = Convert.ToDouble(args[3]);
                }
            }
            else
            {
                if (args[3] is string strVal)
                {
                    m_Value = strVal;
                }
                else
                {
                    m_Value = Convert.ToInt32(args[3]);
                }
            }

            if (m_Var == DoWhileVarType.Counter)
                m_Counter = args[4];

            if (m_Var == DoWhileVarType.Skill)
                m_SkillId = Convert.ToInt32(args[4]);
        }

        public DoWhileAction(DoWhileVarType var, sbyte dir, int val)
        {
            m_Var = var;
            m_Direction = dir;
            m_Value = val;
        }

        public DoWhileAction(DoWhileVarType var, sbyte dir, string val)
        {
            m_Var = var;
            m_Direction = dir;
            m_Value = val;
        }

        public DoWhileAction(DoWhileVarType var, sbyte dir, int val, string counter)
        {
            m_Var = var;
            m_Direction = dir;
            m_Value = val;
            m_Counter = counter;
        }

        public DoWhileAction(DoWhileVarType var, sbyte dir, double val, int skillId)
        {
            m_Var = var;
            m_Direction = dir;
            m_Value = val;
            m_SkillId = skillId;
        }

        public DoWhileAction(DoWhileVarType var, string text)
        {
            m_Var = var;
            m_Value = text.ToLower();
        }

        public override string ToScript()
        {
            return "# do-while not implemented, use while";
        }

        public override string Serialize()
        {
            if (m_Var == DoWhileVarType.Counter && m_Counter != null)
                return DoSerialize((int) m_Var, m_Direction, m_Value, m_Counter);
            else if (m_Var == DoWhileVarType.Skill && m_SkillId != -1)
                return DoSerialize((int) m_Var, m_Direction, m_Value, m_SkillId);
            else
                return DoSerialize((int) m_Var, m_Direction, m_Value);
        }

        public override bool Perform()
        {
            return true;
        }

        public bool Evaluate()
        {
            switch (m_Var)
            {
                case DoWhileVarType.Hits:
                case DoWhileVarType.Mana:
                case DoWhileVarType.Stamina:
                case DoWhileVarType.Weight:
                {
                    bool isNumeric = true;
                    int val;

                    if (m_Value is string value)
                    {
                        isNumeric = int.TryParse(value, out val);
                    }
                    else
                    {
                        val = Convert.ToInt32(m_Value);
                    }

                    if (!isNumeric && m_Value is string strVal)
                    {
                        if (strVal.Equals("{maxhp}"))
                        {
                            val = World.Player.HitsMax;
                        }
                        else if (strVal.Equals("{maxstam}"))
                        {
                            val = World.Player.StamMax;
                        }
                        else if (strVal.Equals("{maxmana}"))
                        {
                            val = World.Player.ManaMax;
                        }
                        else
                        {
                            val = 0;
                        }
                    }

                    switch (m_Direction)
                    {
                        case 0:
                            // if stat <= m_Value
                            switch (m_Var)
                            {
                                case DoWhileVarType.Hits:
                                    return World.Player.Hits <= val;
                                case DoWhileVarType.Mana:
                                    return World.Player.Mana <= val;
                                case DoWhileVarType.Stamina:
                                    return World.Player.Stam <= val;
                                case DoWhileVarType.Weight:
                                    return World.Player.Weight <= val;
                            }

                            break;
                        case 1:
                            // if stat >= m_Value
                            switch (m_Var)
                            {
                                case DoWhileVarType.Hits:
                                    return World.Player.Hits >= val;
                                case DoWhileVarType.Mana:
                                    return World.Player.Mana >= val;
                                case DoWhileVarType.Stamina:
                                    return World.Player.Stam >= val;
                                case DoWhileVarType.Weight:
                                    return World.Player.Weight >= val;
                            }

                            break;
                        case 2:
                            // if stat < m_Value
                            switch (m_Var)
                            {
                                case DoWhileVarType.Hits:
                                    return World.Player.Hits < val;
                                case DoWhileVarType.Mana:
                                    return World.Player.Mana < val;
                                case DoWhileVarType.Stamina:
                                    return World.Player.Stam < val;
                                case DoWhileVarType.Weight:
                                    return World.Player.Weight < val;
                            }

                            break;
                        case 3:
                            // if stat > m_Value
                            switch (m_Var)
                            {
                                case DoWhileVarType.Hits:
                                    return World.Player.Hits > val;
                                case DoWhileVarType.Mana:
                                    return World.Player.Mana > val;
                                case DoWhileVarType.Stamina:
                                    return World.Player.Stam > val;
                                case DoWhileVarType.Weight:
                                    return World.Player.Weight > val;
                            }

                            break;
                    }

                    return false;
                }

                case DoWhileVarType.Poisoned:
                {
                    if (Client.Instance.AllowBit(FeatureBit.BlockHealPoisoned))
                        return World.Player.Poisoned;
                    else
                        return false;
                }

                case DoWhileVarType.SysMessage:
                {
                    string text = (string) m_Value;

                    return SystemMessages.Exists(text);
                }

                case DoWhileVarType.Mounted:
                {
                    return World.Player.GetItemOnLayer(Layer.Mount) != null;
                }

                case DoWhileVarType.RHandEmpty:
                {
                    return World.Player.GetItemOnLayer(Layer.RightHand) == null;
                }

                case DoWhileVarType.LHandEmpty:
                {
                    return World.Player.GetItemOnLayer(Layer.LeftHand) == null;
                }

                case DoWhileVarType.Skill:

                    double skillValToCompare;

                    if (m_Value is string skillVal)
                    {
                        double.TryParse(skillVal, out skillValToCompare);
                    }
                    else
                    {
                        skillValToCompare = Convert.ToDouble(m_Value);
                    }

                    switch (m_Direction)
                    {
                        case 0:
                            return World.Player.Skills[m_SkillId].Value <= skillValToCompare;
                        case 1:
                            return World.Player.Skills[m_SkillId].Value >= skillValToCompare;
                        case 2:
                            return World.Player.Skills[m_SkillId].Value < skillValToCompare;
                        case 3:
                            return World.Player.Skills[m_SkillId].Value > skillValToCompare;
                        default:
                            return World.Player.Skills[m_SkillId].Value <= skillValToCompare;
                    }

                case DoWhileVarType.Counter:
                {
                    if (m_CountObj == null)
                    {
                        foreach (Assistant.Counter c in Assistant.Counter.List)
                        {
                            if (c.Name == m_Counter)
                            {
                                m_CountObj = c;
                                break;
                            }
                        }
                    }

                    if (m_CountObj == null || !m_CountObj.Enabled)
                        return false;

                    int val;

                    if (m_Value is string value)
                    {
                        int.TryParse(value, out val);
                    }
                    else
                    {
                        val = Convert.ToInt32(m_Value);
                    }

                    switch (m_Direction)
                    {
                        case 0:
                            return m_CountObj.Amount <= val;
                        case 1:
                            return m_CountObj.Amount >= val;
                        case 2:
                            return m_CountObj.Amount < val;
                        case 3:
                            return m_CountObj.Amount > val;
                        default:
                            return m_CountObj.Amount <= val;
                    }
                }

                default:
                    return false;
            }
        }

        private string DirectionString()
        {
            switch (m_Direction)
            {
                case 0:
                    return "<=";
                case 1:
                    return ">=";
                case 2:
                    return "<";
                case 3:
                    return ">";
                default:
                    return "<=";
            }
        }

        public override string ToString()
        {
            switch (m_Var)
            {
                case DoWhileVarType.Hits:
                case DoWhileVarType.Mana:
                case DoWhileVarType.Stamina:
                case DoWhileVarType.Weight:
                    return $"Do While ( {m_Var} {DirectionString()} {m_Value} )";
                case DoWhileVarType.Poisoned:
                    return "Do While ( Poisoned )";
                case DoWhileVarType.SysMessage:
                {
                    string str = (string) m_Value;
                    if (str.Length > 10)
                        str = str.Substring(0, 7) + "...";
                    return $"Do While ( SysMessage \"{str}\" )";
                }

                case DoWhileVarType.Skill:
                    return $"Do While ( \"{Skills.GetSkillDisplayName(m_SkillId)}\" {DirectionString()} {m_Value})";
                case DoWhileVarType.Mounted:
                    return "Do While ( Mounted )";
                case DoWhileVarType.RHandEmpty:
                    return "Do While ( R-Hand Empty )";
                case DoWhileVarType.LHandEmpty:
                    return "Do While ( L-Hand Empty )";
                case DoWhileVarType.Counter:
                    return $"Do While ( \"{m_Counter} count\" {DirectionString()} {m_Value} )";
                default:
                    return "Do While ( ??? )";
            }
        }

        private ToolStripMenuItem[] m_MenuItems;

        public override ToolStripMenuItem[] GetContextMenuItems()
        {
            if (m_MenuItems == null)
            {
                m_MenuItems = new MacroMenuItem[]
                {
                    new MacroMenuItem(LocString.Edit, new MacroMenuCallback(Edit))
                };
            }

            return m_MenuItems;
        }

        private void Edit(object[] args)
        {
            new MacroInsertDoWhile(this).ShowDialog(Engine.MainWindow);
        }
    }

    public class ContextMenuAction : MacroAction
    {
        private ushort m_CtxName;
        private ushort m_Idx;
        private Serial m_Entity;

        public ContextMenuAction(UOEntity ent, ushort idx, ushort ctxName)
        {
            m_Entity = ent != null ? ent.Serial : Serial.MinusOne;

            if (World.Player != null && World.Player.Serial == m_Entity)
                m_Entity = Serial.Zero;

            m_Idx = idx;
            m_CtxName = ctxName;
        }

        public ContextMenuAction(string[] args)
        {
            m_Entity = Serial.Parse(args[1]);
            m_Idx = Convert.ToUInt16(args[2]);
            try
            {
                m_CtxName = Convert.ToUInt16(args[3]);
            }
            catch
            {
            }
        }

        public override bool Perform()
        {
            Serial s = m_Entity;

            if (s == Serial.Zero && World.Player != null)
                s = World.Player.Serial;

            Client.Instance.SendToServer(new ContextMenuRequest(s));
            Client.Instance.SendToServer(new ContextMenuResponse(s, m_Idx));
            return true;
        }

        public override string ToScript()
        {
            return $"menu {m_Entity} {m_Idx}";
        }

        public override string Serialize()
        {
            return DoSerialize(m_Entity, m_Idx, m_CtxName);
        }

        public override string ToString()
        {
            string ent;

            if (m_Entity == Serial.Zero)
                ent = "(self)";
            else
                ent = m_Entity.ToString();
            return String.Format("ContextMenu: {1} ({0})", ent, m_Idx);
        }
    }

    public class PromptAction : MacroAction
    {
        private string m_Response;

        public PromptAction(string[] args)
        {
            m_Response = args[1];
        }

        public PromptAction(string response)
        {
            m_Response = response;
        }

        public override bool Perform()
        {
            if (m_Response.Length > 1)
            {
                World.Player.ResponsePrompt(m_Response);

                return true;
            }

            return false;
        }

        public override string ToScript()
        {
            return $"promptresponse '{m_Response}'";
        }

        public override string Serialize()
        {
            return DoSerialize(m_Response);
        }

        public override string ToString()
        {
            return $"PromptAction: {m_Response}";
        }

        private ToolStripMenuItem[] m_MenuItems;

        public override ToolStripMenuItem[] GetContextMenuItems()
        {
            if (this.m_MenuItems == null)
                this.m_MenuItems = (ToolStripMenuItem[]) new MacroMenuItem[1]
                {
                    new MacroMenuItem(LocString.Edit, new MacroMenuCallback(this.Edit), new object[0])
                };
            return this.m_MenuItems;
        }

        private void Edit(object[] args)
        {
            if (InputBox.Show(Language.GetString(LocString.EnterNewText), "Input Box", this.m_Response))
                m_Response = InputBox.GetString();

            Parent?.Update();
        }
    }

    public class WaitForPromptAction : MacroWaitAction
    {
        private uint m_PromptID;
        private bool m_Strict;

        public WaitForPromptAction()
        {
            m_PromptID = 0;
            m_Strict = false;
        }

        public WaitForPromptAction(uint gid)
        {
            m_PromptID = gid;
            m_Strict = false;
        }

        public WaitForPromptAction(string[] args)
        {
            m_PromptID = Convert.ToUInt32(args[1]);
            try
            {
                m_Strict = Convert.ToBoolean(args[2]);
            }
            catch
            {
                m_Strict = false;
            }

            try
            {
                m_Timeout = TimeSpan.FromSeconds(Convert.ToDouble(args[3]));
            }
            catch
            {
            }
        }

        public override bool Perform()
        {
            return !PerformWait();
        }

        public override bool PerformWait()
        {
            return !(World.Player.HasPrompt && (World.Player.PromptID == m_PromptID || !m_Strict || m_PromptID == 0));
        }

        public override string ToString()
        {
            //if (m_PromptID == 0 || !m_Strict)
            //    return Language.GetString(LocString.WaitAnyGump);
            //else
            //    return Language.Format(LocString.WaitGumpA1, m_GumpID);

            if (m_PromptID == 0 || !m_Strict)
                return "Wait For Prompt (Any)";

            return $"Wait For Prompt ({m_PromptID})";
        }

        public override string ToScript()
        {
            return m_PromptID == 0 || !m_Strict ? "waitforprompt" : $"waitforprompt '{m_PromptID}'";
        }

        public override string Serialize()
        {
            return DoSerialize(m_PromptID, m_Strict, m_Timeout.TotalSeconds);
        }

        public override bool CheckMatch(MacroAction a)
        {
            if (a is WaitForGumpAction)
            {
                if (m_PromptID == 0 || ((WaitForPromptAction) a).m_PromptID == m_PromptID)
                    return true;
            }

            return false;
        }

        private ToolStripMenuItem[] m_MenuItems;

        public override ToolStripMenuItem[] GetContextMenuItems()
        {
            if (m_MenuItems == null)
            {
                m_MenuItems = new MacroMenuItem[]
                {
                    new MacroMenuItem(LocString.Edit, new MacroMenuCallback(Edit)),
                    new MacroMenuItem(LocString.Null, new MacroMenuCallback(ToggleStrict)),
                    this.EditTimeoutMenuItem
                };
            }

            if (!m_Strict)
                m_MenuItems[1].Text = $"Change to \"Wait For Prompt ({m_PromptID})\"";
            else
                m_MenuItems[1].Text = $"Change to \"Wait For Prompt (Any)\"";

            m_MenuItems[1].Enabled = m_PromptID != 0 || m_Strict;

            return m_MenuItems;
        }

        private void Edit(object[] args)
        {
            new MacroInsertWait(this).ShowDialog(Engine.MainWindow);
        }

        private void ToggleStrict(object[] args)
        {
            m_Strict = !m_Strict;
            if (m_Parent != null)
                m_Parent.Update();
        }
    }
}

================================================
FILE: Razor/Macros/Actions.resx
================================================
<?xml version="1.0" encoding="utf-8" ?>
<root>
	<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
		<xsd:element name="root" msdata:IsDataSet="true">
			<xsd:complexType>
				<xsd:choice maxOccurs="unbounded">
					<xsd:element name="data">
						<xsd:complexType>
							<xsd:sequence>
								<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
								<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
							</xsd:sequence>
							<xsd:attribute name="name" type="xsd:string" />
							<xsd:attribute name="type" type="xsd:string" />
							<xsd:attribute name="mimetype" type="xsd:string" />
						</xsd:complexType>
					</xsd:element>
					<xsd:element name="resheader">
						<xsd:complexType>
							<xsd:sequence>
								<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
							</xsd:sequence>
							<xsd:attribute name="name" type="xsd:string" use="required" />
						</xsd:complexType>
					</xsd:element>
				</xsd:choice>
			</xsd:complexType>
		</xsd:element>
	</xsd:schema>
	<resheader name="ResMimeType">
		<value>text/microsoft-resx</value>
	</resheader>
	<resheader name="Version">
		<value>1.0.0.0</value>
	</resheader>
	<resheader name="Reader">
		<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
	</resheader>
	<resheader name="Writer">
		<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
	</resheader>
</root>


================================================
FILE: Razor/Macros/Macro.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections;
using System.Windows.Forms;
using System.Reflection;
using System.IO;
using System.Text;
using Assistant.UI;

namespace Assistant.Macros
{
    public class Macro
    {
        private string m_Path;
        private ArrayList m_Actions;
        private bool m_Recording, m_Playing;
        private MacroWaitAction m_Wait;
        private int m_CurrentAction;
        private bool m_Loop;
        private bool m_Loaded;
        private ListBox m_ListBox;
        private Stack m_IfStatus;

        public Macro(string path)
        {
            m_Actions = new ArrayList();
            m_Path = path;
            m_Loaded = false;
            m_IfStatus = new Stack();
        }

        public string GetName()
        {
            return Path.GetFileNameWithoutExtension(m_Path);
        }

        public string Filename
        {
            get { return m_Path; }
            set { m_Path = value; }
        }

        public ArrayList Actions
        {
            get { return m_Actions; }
        }

        public bool Recording
        {
            get { return m_Recording; }
        }

        public bool Playing
        {
            get { return m_Playing; }
        }

        public bool StepThrough { get; set; }

        public bool Waiting
        {
            get { return m_Wait != null; }
        }

        public int CurrentAction
        {
            get { return m_CurrentAction; }
        }

        public bool Loop
        {
            get { return m_Loop && Client.Instance.AllowBit(FeatureBit.LoopingMacros); }
            set { m_Loop = value; }
        }

        public void DisplayTo(ListBox list)
        {
            m_ListBox = list;

            m_ListBox.SafeAction(s => s.Items.Clear());

            if (!m_Loaded)
                Load();

            m_ListBox.SafeAction(s =>
            {
                s.BeginUpdate();
                if (m_Actions.Count > 0)
                    s.Items.AddRange((object[]) m_Actions.ToArray(typeof(object)));
                if (m_Playing && m_CurrentAction >= 0 && m_CurrentAction < m_Actions.Count)
                    s.SelectedIndex = m_CurrentAction;
                else
                    s.SelectedIndex = -1;
                s.EndUpdate();
            });
        }

        public override string ToString()
        {
            //return Path.GetFileNameWithoutExtension( m_Path );
            StringBuilder sb = new StringBuilder(Path.GetFullPath(m_Path));
            sb.Remove(sb.Length - 6, 6);
            sb.Remove(0, Config.GetUserDirectory("Macros").Length + 1);
            return sb.ToString();
        }

        public void Insert(int idx, MacroAction a)
        {
            a.Parent = this;
            if (idx < 0 || idx > m_Actions.Count)
                idx = m_Actions.Count;
            m_Actions.Insert(idx, a);
        }

        public void Record()
        {
            m_Actions.Clear();
            if (m_ListBox != null)
                m_ListBox.SafeAction(s => s.Items.Clear());
            RecordAt(0);
        }

        public void RecordAt(int at)
        {
            Stop();
            m_Recording = true;
            m_Loaded = true;
            m_CurrentAction = at;
            if (m_CurrentAction > m_Actions.Count)
                m_CurrentAction = m_Actions.Count;
        }

        public void Play()
        {
            Stop();
            if (!m_Loaded)
                Load();
            else
                Save();

            if (m_Actions.Count > 0)
            {
                m_IfStatus.Clear();
                m_Playing = true;
                m_CurrentAction = -1;
                if (m_ListBox != null)
                    m_ListBox.SafeAction(s => s.SelectedIndex = -1);
            }
        }

        public void PlayAt(int at)
        {
            Stop();
            if (!m_Loaded)
                Load();
            else
                Save();

            if (m_Actions.Count > 0)
            {
                m_IfStatus.Clear();
                m_Playing = true;
                m_CurrentAction = at - 1;
                if (m_CurrentAction >= 0)
                    m_CurrentAction--;
            }
        }

        public void Reset()
        {
            if (m_Playing && World.Player != null && DragDropManager.Holding != null &&
                DragDropManager.Holding == LiftAction.LastLift)
                Client.Instance.SendToServer(new DropRequest(DragDropManager.Holding, World.Player.Serial));

            m_Wait = null;

            m_IfStatus.Clear();

            foreach (MacroAction a in m_Actions)
            {
                if (a is ForAction)
                    ((ForAction) a).Count = 0;
            }
        }

        public void Stop()
        {
            if (m_Recording)
                Save();

            m_Recording = m_Playing = false;
            Reset();
        }

        // returns true if the were waiting for this action
        public bool Action(MacroAction action)
        {
            if (m_Recording)
            {
                action.Parent = this;
                m_Actions.Insert(m_CurrentAction, action);
                if (m_ListBox != null)
                    m_ListBox.SafeAction(s => s.Items.Insert(m_CurrentAction, action));
                m_CurrentAction++;

                return false;
            }
            else if (m_Playing && m_Wait != null && m_Wait.CheckMatch(action))
            {
                m_Wait = null;
                ExecNext();
                return true;
            }

            return false;
        }

        public void Save()
        {
            if (m_Actions.Count == 0)
                return;

            using (StreamWriter writer = new StreamWriter(m_Path))
            {
                if (m_Loop)
                    writer.WriteLine("!Loop");

                for (int i = 0; i < m_Actions.Count; i++)
                {
                    MacroAction a = (MacroAction) m_Actions[i];
                    try
                    {
                        writer.WriteLine(a.Serialize());
                    }
                    catch
                    {
                    }
                }
            }
        }

        private static Type[] ctorArgs = new Type[1] {typeof(string[])};

        public void Load()
        {
            m_Actions.Clear();
            m_Loaded = false;

            if (!File.Exists(m_Path))
                return;

            using (StreamReader reader = new StreamReader(m_Path))
            {
                string line;
                while ((line = reader.ReadLine()) != null)
                {
                    if (line.Length <= 2)
                        continue;

                    if (line == "!Loop")
                    {
                        m_Loop = true;
                        continue;
                    }

                    if (line[0] == '#')
                    {
                        m_Actions.Add(new MacroComment(line.Substring(1)));
                        continue;
                    }
                    else if (line[0] == '/' && line[1] == '/')
                    {
                        MacroAction a = new MacroComment(line.Substring(2));
                        a.Parent = this;
                        m_Actions.Add(a);
                        continue;
                    }

                    string[] args = line.Split('|');
                    object[] invokeArgs = new object[1] {args};

                    Type at = null;
                    try
                    {
                        at = Type.GetType(args[0], false);
                    }
                    catch
                    {
                    }

                    if (at == null)
                        continue;

                    if (args.Length > 1)
                    {
                        try
                        {
                            ConstructorInfo ctor = at.GetConstructor(ctorArgs);
                            if (ctor == null)
                                continue;

                            MacroAction a = (MacroAction) ctor.Invoke(invokeArgs);
                            a.Parent = this;
                            m_Actions.Add(a);
                        }
                        catch
                        {
                        }
                    }
                    else
                    {
                        try
                        {
                            ConstructorInfo ctor = at.GetConstructor(Type.EmptyTypes);
                            if (ctor == null)
                                continue;

                            MacroAction a = (MacroAction) ctor.Invoke(null);
                            a.Parent = this;
                            m_Actions.Add(a);
                        }
                        catch
                        {
                        }
                    }
                }
            }

            m_Loaded = true;
        }

        public void Convert(MacroAction old, MacroAction newAct)
        {
            for (int i = 0; i < m_Actions.Count; i++)
            {
                if (m_Actions[i] == old)
                {
                    m_Actions[i] = newAct;
                    newAct.Parent = this;
                    Update();
                    break;
                }
            }
        }

        public void Update()
        {
            if (m_ListBox != null)
            {
                int sel = m_ListBox.SelectedIndex;
                DisplayTo(m_ListBox);
                try
                {
                    m_ListBox.SafeAction(s => s.SelectedIndex = sel);
                }
                catch
                {
                }
            }
        }

        private bool NextIsInstantWait()
        {
            int nextAct = m_CurrentAction + 1;

            if (nextAct >= 0 && nextAct < m_Actions.Count)
                return m_Actions[nextAct] is WaitForTargetAction || m_Actions[nextAct] is WaitForGumpAction ||
                       m_Actions[nextAct] is
                           WaitForMenuAction; //|| m_Actions[nextAct] is ElseAction || m_Actions[nextAct] is EndIfAction;
            else
                return false;
        }

        private static MacroWaitAction PauseB4Loop = new PauseAction(TimeSpan.FromSeconds(0.1));

        //return true to continue the macro, false to stop (macro's over)
        public bool ExecNext()
        {
            try
            {
                if (!m_Playing)
                    return false;

                if (m_Wait != null)
                {
                    TimeSpan waitLen = DateTime.UtcNow - m_Wait.StartTime;
                    if (!(m_Wait is PauseAction) && waitLen >= m_Wait.Timeout)
                    {
                        if (Loop)
                        {
                            if (Engine.MainWindow.WaitDisplay != null)
                                Engine.MainWindow.WaitDisplay.SafeAction(s => s.Text = string.Empty);
                            m_CurrentAction = -1;
                            m_IfStatus.Clear();
                            PauseB4Loop.Perform();
                            PauseB4Loop.Parent = this;
                            m_Wait = PauseB4Loop;
                            return true;
                        }
                        else
                        {
                            Stop();
                            return false;
                        }
                    }
                    else
                    {
                        if (!m_Wait.PerformWait())
                        {
                            m_Wait = null; // done waiting
                            if (Engine.MainWindow.WaitDisplay != null)
                                Engine.MainWindow.WaitDisplay.SafeAction(s => s.Text = string.Empty);
                        }
                        else
                        {
                            if (waitLen >= TimeSpan.FromSeconds(4.0) && Engine.MainWindow.WaitDisplay != null)
                            {
                                StringBuilder sb = new StringBuilder(Language.GetString(LocString.WaitingTimeout));

                                sb.AppendLine("\n");

                                int s = (int) (m_Wait.Timeout - waitLen).TotalSeconds;
                                int m = 0;

                                if (s > 60)
                                {
                                    m = s / 60;
                                    s %= 60;
                                    if (m > 60)
                                    {
                                        sb.AppendFormat("{0}:", m / 60);
                                        m %= 60;
                                    }
                                }

                                sb.AppendFormat("{0:00}:{1:00}", m, s);

                                Engine.MainWindow.WaitDisplay.SafeAction(w => w.Text = sb.ToString());
                            }

                            return true; // keep waiting
                        }
                    }
                }

                m_CurrentAction++;
                //MacroManager.ActionUpdate( this, m_CurrentAction );
                if (m_ListBox != null)
                {
                    if (m_CurrentAction < m_ListBox.Items.Count)
                        m_ListBox.SafeAction(s => s.SelectedIndex = m_CurrentAction);
                    else
                        m_ListBox.SafeAction(s => s.SelectedIndex = -1);
                }

                if (m_CurrentAction >= 0 && m_CurrentAction < m_Actions.Count)
                {
                    MacroAction action = (MacroAction) m_Actions[m_CurrentAction];

                    if (action is IfAction)
                    {
                        bool val = ((IfAction) action).Evaluate();
                        m_IfStatus.Push(val);

                        if (!val)
                        {
                            // false so skip to an else or an endif
                            int ifcount = 0;
                            while (m_CurrentAction + 1 < m_Actions.Count)
                            {
                                if (m_Actions[m_CurrentAction + 1] is IfAction)
                                {
                                    ifcount++;
                                }
                                else if (m_Actions[m_CurrentAction + 1] is ElseAction && ifcount <= 0)
                                {
                                    break;
                                }
                                else if (m_Actions[m_CurrentAction + 1] is EndIfAction)
                                {
                                    if (ifcount <= 0)
                                        break;
                                    else
                                        ifcount--;
                                }

                                m_CurrentAction++;
                            }
                        }
                    }
                    else if (action is ElseAction && m_IfStatus.Count > 0)
                    {
                        bool val = (bool) m_IfStatus.Peek();
                        if (val)
                        {
                            // the if was true, so skip to an endif
                            int ifcount = 0;
                            while (m_CurrentAction + 1 < m_Actions.Count)
                            {
                                if (m_Actions[m_CurrentAction + 1] is IfAction)
                                {
                                    ifcount++;
                                }
                                else if (m_Actions[m_CurrentAction + 1] is EndIfAction)
                                {
                                    if (ifcount <= 0)
                                        break;
                                    else
                                        ifcount--;
                                }

                                m_CurrentAction++;
                            }
                        }
                    }
                    else if (action is EndIfAction && m_IfStatus.Count > 0)
                    {
                        m_IfStatus.Pop();
                    }
                    else if (action is ForAction)
                    {
                        ForAction fa = (ForAction) action;
                        fa.Count++;

                        if (fa.Count > fa.Max)
                        {
                            fa.Count = 0;

                            int forcount = 0;
                            m_CurrentAction++;
                            while (m_CurrentAction < m_Actions.Count)
                            {
                                if (m_Actions[m_CurrentAction] is ForAction)
                                {
                                    forcount++;
                                }
                                else if (m_Actions[m_CurrentAction] is EndForAction)
                                {
                                    if (forcount <= 0)
                                        break;
                                    else
                                        forcount--;
                                }

                                m_CurrentAction++;
                            }

                            if (m_CurrentAction < m_Actions.Count)
                                action = (MacroAction) m_Actions[m_CurrentAction];
                        }
                    }
                    else if (action is EndForAction && Client.Instance.AllowBit(FeatureBit.LoopingMacros))
                    {
                        int ca = m_CurrentAction - 1;
                        int forcount = 0;

                        while (ca >= 0)
                        {
                            if (m_Actions[ca] is EndForAction)
                            {
                                forcount--;
                            }
                            else if (m_Actions[ca] is ForAction)
                            {
                                if (forcount >= 0)
                                    break;
                                else
                                    forcount++;
                            }

                            ca--;
                        }

                        if (ca >= 0 && m_Actions[ca] is ForAction)
                            m_CurrentAction = ca - 1;
                    }
                    else if (action is WhileAction && Client.Instance.AllowBit(FeatureBit.LoopingMacros))
                    {
                        bool val = ((WhileAction) action).Evaluate();

                        if (!val)
                        {
                            // false so skip to the endwhile
                            int whilecount = 0;
                            while (m_CurrentAction + 1 < m_Actions.Count)
                            {
                                if (m_Actions[m_CurrentAction + 1] is WhileAction)
                                {
                                    whilecount++;
                                }
                                else if (m_Actions[m_CurrentAction + 1] is EndWhileAction)
                                {
                                    if (whilecount <= 0)
                                    {
                                        // Skip over the end while
                                        m_CurrentAction++;
                                        break;
                                    }

                                    whilecount--;
                                }

                                m_CurrentAction++;
                            }
                        }
                    }
                    else if (action is EndWhileAction && Client.Instance.AllowBit(FeatureBit.LoopingMacros))
                    {
                        int ca = m_CurrentAction - 1;
                        int whilecount = 0;

                        while (ca >= 0)
                        {
                            if (m_Actions[ca] is EndWhileAction)
                            {
                                whilecount--;
                            }
                            else if (m_Actions[ca] is WhileAction)
                            {
                                if (whilecount >= 0)
                                    break;
                                else
                                    whilecount++;
                            }

                            ca--;
                        }

                        if (ca >= 0 && m_Actions[ca] is WhileAction)
                            m_CurrentAction = ca - 1;
                    }
                    else if (action is DoWhileAction && Client.Instance.AllowBit(FeatureBit.LoopingMacros))
                    {
                        bool val = ((DoWhileAction) action).Evaluate();

                        if (val)
                        {
                            int ca = m_CurrentAction - 1;
                            int dowhilecount = 0;

                            while (ca >= 0)
                            {
                                if (m_Actions[ca] is DoWhileAction)
                                {
                                    dowhilecount--;
                                }
                                else if (m_Actions[ca] is StartDoWhileAction)
                                {
                                    if (dowhilecount >= 0)
                                        break;
                                    else
                                        dowhilecount++;
                                }

                                ca--;
                            }

                            if (ca >= 0 && m_Actions[ca] is StartDoWhileAction)
                                m_CurrentAction = ca - 1;
                        }
                    }

                    bool isWait = action is MacroWaitAction;
                    if (!action.Perform() && isWait)
                    {
                        m_Wait = (MacroWaitAction) action;
                        m_Wait.StartTime = DateTime.UtcNow;
                    }
                    else if (NextIsInstantWait() && !isWait)
                    {
                        return ExecNext();
                    }
                }
                else
                {
                    if (Engine.MainWindow.WaitDisplay != null)
                        Engine.MainWindow.WaitDisplay.SafeAction(s => s.Text = string.Empty);

                    if (Loop)
                    {
                        m_CurrentAction = -1;

                        Reset();

                        PauseB4Loop.Perform();
                        PauseB4Loop.Parent = this;
                        m_Wait = PauseB4Loop;
                    }
                    else
                    {
                        Stop();
                        return false;
                    }
                }
            }
            catch (Exception e)
            {
                new MessageDialog("Macro Exception", true, e.ToString()).Show();
                return false;
            }

            return true;
        }
    }
}

================================================
FILE: Razor/Macros/MacroManager.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.IO;
using System.Windows.Forms;
using Assistant.Scripts;
using Assistant.UI;

namespace Assistant.Macros
{
    public class MacroManager
    {
        private static List<Macro> m_MacroList;
        private static Macro m_Current, m_PrevPlay;
        private static bool m_Paused;
        private static MacroTimer m_Timer;

        public static void Initialize()
        {
            HotKey.Add(HKCategory.Macros, LocString.StopCurrent, new HotKeyCallback(HotKeyStop));
            HotKey.Add(HKCategory.Macros, LocString.PauseCurrent, new HotKeyCallback(HotKeyPause));

            string path = Config.GetUserDirectory("Macros");
            Recurse(null, path);
        }

        static MacroManager()
        {
            m_MacroList = new List<Macro>();
            m_Timer = new MacroTimer();
        }

        /// <summary>
        /// Saves all the macros and variable lists
        /// </summary>
        public static void Save()
        {
            Engine.EnsureDirectory(Config.GetUserDirectory("Macros"));

            foreach (Macro macro in m_MacroList)
            {
                macro.Save();
            }
        }

        public static List<Macro> List
        {
            get { return m_MacroList; }
        }

        public static bool Recording
        {
            get { return m_Current != null && m_Current.Recording; }
        }

        public static bool Playing
        {
            get { return m_Current != null && m_Current.Playing && m_Timer != null && m_Timer.Running; }
        }

        public static bool StepThrough
        {
            get { return m_Current != null && m_Current.StepThrough && m_Current.Playing; }
        }

        public static Macro Current
        {
            get { return m_Current; }
        }

        public static bool AcceptActions
        {
            get { return Recording || (Playing && m_Current.Waiting); }
        }
        //public static bool IsWaiting{ get{ return Playing && m_Current != null && m_Current.Waiting; } }

        public static void Add(Macro m)
        {
            HotKey.Add(HKCategory.Macros, HKSubCat.None, Language.Format(LocString.PlayA1, m),
                new HotKeyCallbackState(HotKeyPlay), m);
            m_MacroList.Add(m);
        }

        public static void Remove(Macro m)
        {
            HotKey.Remove(Language.Format(LocString.PlayA1, m));
            m_MacroList.Remove(m);
        }

        public static void RecordAt(Macro m, int at)
        {
            if (m_Current != null)
                m_Current.Stop();
            m_Current = m;
            m_Current.RecordAt(at);
        }

        public static void Record(Macro m)
        {
            if (m_Current != null)
                m_Current.Stop();
            m_Current = m;
            m_Current.Record();
        }

        public static void PlayAt(Macro m, int at)
        {
            ScriptManager.StopScript();

            if (m_Current != null)
            {
                if (m_Current.Playing && m_Current.Loop && !m.Loop)
                    m_PrevPlay = m_Current;
                else
                    m_PrevPlay = null;

                m_Current.Stop();
            }
            else
            {
                m_PrevPlay = null;
            }

            LiftAction.LastLift = null;
            m_Current = m;
            m_Current.PlayAt(at);

            m_Timer.Macro = m_Current;

            if (!Config.GetBool("StepThroughMacro"))
            {
                m_Timer.Start();
            }

            if (Engine.MainWindow.WaitDisplay != null)
                Engine.MainWindow.SafeAction(s => s.WaitDisplay.Text = "");
        }

        private static void HotKeyPlay(ref object state)
        {
            HotKeyPlay(state as Macro);
        }

        public static void HotKeyPlay(Macro m)
        {
            if (m != null)
            {
                Play(m);

                if (!Config.GetBool("DisableMacroPlayFinish"))
                    World.Player.SendMessage(LocString.PlayingA1, m);

                Engine.MainWindow.SafeAction(s => s.PlayMacro(m));
            }
        }

        public static void Play(Macro m)
        {
            ScriptManager.StopScript();

            if (m_Current != null)
            {
                if (m_Current.Playing && m_Current.Loop && !m.Loop)
                    m_PrevPlay = m_Current;
                else
                    m_PrevPlay = null;

                m_Current.Stop();
            }
            else
            {
                m_PrevPlay = null;
            }

            LiftAction.LastLift = null;
            m_Current = m;
            m_Current.Play();

            m_Timer.Macro = m_Current;

            if (!Config.GetBool("StepThroughMacro"))
            {
                m_Timer.Start();
            }

            if (Engine.MainWindow.WaitDisplay != null)
                Engine.MainWindow.SafeAction(s => s.WaitDisplay.Text = "");
        }

        public static void PlayNext()
        {
            if (m_Current == null)
                return;

            m_Timer.PerformNextAction();
        }

        private static void HotKeyPause()
        {
            Pause();
        }

        private static void HotKeyStop()
        {
            Stop();
        }

        public static void Stop()
        {
            Stop(false);
        }

        public static void Stop(bool restartPrev)
        {
            m_Timer.Stop();
            if (m_Current != null)
            {
                m_Current.Stop();
                m_Current = null;
            }

            UOAssist.PostMacroStop();

            if (Engine.MainWindow.WaitDisplay != null)
                Engine.MainWindow.SafeAction(s => s.WaitDisplay.Text = "");

            Engine.MainWindow.SafeAction(s => s.OnMacroStop());

            //if ( restartPrev )
            //	Play( m_PrevPlay );
            m_PrevPlay = null;
        }

        public static void Pause()
        {
            if (m_Current == null)
                return;

            if (m_Paused)
            {
                // unpause
                int sel = m_Current.CurrentAction;
                if (sel < 0 || sel > m_Current.Actions.Count)
                    sel = m_Current.Actions.Count;

                //m_Current.PlayAt(sel);
                m_Timer.Start();

                m_Paused = false;

                World.Player.SendMessage(LocString.MacroResuming);
            }
            else
            {
                // pause
                m_Timer.Stop();

                if (Engine.MainWindow.WaitDisplay != null)
                    Engine.MainWindow.SafeAction(s => s.WaitDisplay.Text = "Paused");

                World.Player.SendMessage(LocString.MacroPaused);

                m_Paused = true;
            }
        }

        public static void DisplayTo(TreeView tree)
        {
            tree.BeginUpdate();
            tree.Nodes.Clear();
            Recurse(tree.Nodes, Config.GetUserDirectory("Macros"));
            tree.EndUpdate();
            tree.Refresh();
            tree.Update();
        }

        public static void DisplayMacroVariables(ListBox list)
        {
            list.BeginUpdate();
            list.Items.Clear();

            foreach (MacroVariables.MacroVariable at in MacroVariables.MacroVariableList)
            {
                list.Items.Add($"${at.Name} ({at.TargetInfo.Serial})");
            }

            list.EndUpdate();
            list.Refresh();
            list.Update();
        }

        private static void Recurse(TreeNodeCollection nodes, string path)
        {
            try
            {
                string[] macros = Directory.GetFiles(path, "*.macro");
                for (int i = 0; i < macros.Length; i++)
                {
                    Macro m = null;
                    for (int j = 0; j < m_MacroList.Count; j++)
                    {
                        Macro check = m_MacroList[j];

                        if (check.Filename == macros[i])
                        {
                            m = check;
                            break;
                        }
                    }

                    if (m == null)
                        Add(m = new Macro(macros[i]));

                    if (nodes != null)
                    {
                        TreeNode node = new TreeNode(Path.GetFileNameWithoutExtension(m.Filename));
                        node.Tag = m;
                        nodes.Add(node);
                    }
                }
            }
            catch
            {
            }

            try
            {
                string[] dirs = Directory.GetDirectories(path);
                for (int i = 0; i < dirs.Length; i++)
                {
                    if (dirs[i] != "" && dirs[i] != "." && dirs[i] != "..")
                    {
                        if (nodes != null)
                        {
                            TreeNode node = new TreeNode($"[{Path.GetFileName(dirs[i])}]");
                            node.Tag = dirs[i];
                            nodes.Add(node);
                            Recurse(node.Nodes, dirs[i]);
                        }
                        else
                        {
                            Recurse(null, dirs[i]);
                        }
                    }
                }
            }
            catch
            {
            }
        }

        public static void Select(Macro m, ListBox actionList, Button play, Button rec, CheckBox loop)
        {
            if (m == null)
                return;

            m.DisplayTo(actionList);

            if (Recording)
            {
                play.Enabled = false;
                play.Text = "Play";
                rec.Enabled = true;
                rec.Text = "Stop";
            }
            else
            {
                play.Enabled = true;
                if (m.Playing)
                {
                    play.Text = "Stop";
                    rec.Enabled = false;
                }
                else
                {
                    play.Text = "Play";
                    rec.Enabled = true;
                }

                rec.Text = "Record";
                loop.Checked = m.Loop;
            }
        }

        public static bool Action(MacroAction a)
        {
            if (m_Current != null)
                return m_Current.Action(a);
            else
                return false;
        }

        private class MacroTimer : Timer
        {
            private Macro m_Macro;

            // The default Razor delay has always been 50ms, but for CUO, that delay isn't needed since it isn't
            // passing messages back and forth.
            public MacroTimer() : base(TimeSpan.FromMilliseconds(Config.GetBool("MacroActionDelay") ? 50 : 0),
                TimeSpan.FromMilliseconds(Config.GetBool("MacroActionDelay") ? 50 : 0))
            {
            }

            public Macro Macro
            {
                get { return m_Macro; }
                set { m_Macro = value; }
            }

            public void PerformNextAction()
            {
                ExecuteNextAction();
            }

            protected override void OnTick()
            {
                ExecuteNextAction();
            }

            private void ExecuteNextAction()
            {
                try
                {
                    if (m_Macro == null || World.Player == null)
                    {
                        this.Stop();
                        MacroManager.Stop();
                    }
                    else if (!m_Macro.ExecNext())
                    {
                        this.Stop();
                        MacroManager.Stop(true);

                        if (!Config.GetBool("DisableMacroPlayFinish"))
                            World.Player.SendMessage(LocString.MacroFinished, m_Macro);
                    }
                }
                catch
                {
                    this.Stop();
                    MacroManager.Stop();
                }
            }
        }
    }
}

================================================
FILE: Razor/Macros/MacroVariables.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.Xml;

namespace Assistant.Macros
{
    public class MacroVariables
    {
        public class MacroVariable
        {
            public TargetInfo TargetInfo { get; set; }
            public string Name { get; set; }

            public bool TargetWasSet { get; set; }

            public MacroVariable(string targetVarName, TargetInfo t)
            {
                TargetInfo = t;
                Name = targetVarName;
                TargetWasSet = true;
            }

            public void TargetSetMacroVariable()
            {
                if (World.Player != null)
                {
                    TargetWasSet = false;

                    Targeting.OneTimeTarget(OnMacroVariableTarget);
                    World.Player.SendMessage(MsgLevel.Force, $"Select target for ${Name}");

                    //OneTimeTarget(false, new Targeting.TargetResponseCallback(OnMacroVariableTarget), new Targeting.CancelTargetCallback(OnSLTCancel));
                }
            }

            private void OnMacroVariableTarget(bool ground, Serial serial, Point3D pt, ushort gfx)
            {
                TargetInfo t = new TargetInfo
                {
                    Gfx = gfx,
                    Serial = serial,
                    Type = (byte) (ground ? 1 : 0),
                    X = pt.X,
                    Y = pt.Y,
                    Z = pt.Z
                };

                bool foundVar = false;

                foreach (MacroVariables.MacroVariable mV in MacroVariables.MacroVariableList
                )
                {
                    if (mV.Name.ToLower().Equals(Name.ToLower()))
                    {
                        foundVar = true;
                        // macro exists, update
                        mV.TargetInfo = t;

                        World.Player.SendMessage(MsgLevel.Force, $"'{mV.Name}' macro variable updated to '{t.Serial}'");

                        break;
                    }
                }

                if (!foundVar)
                {
                    //MacroVariables.MacroVariableList.Add(new MacroVariables.MacroVariable(_lastMacroVariable, t));
                    //World.Player.SendMessage(MsgLevel.Force, $"'{_lastMacroVariable}' not found, created variable and set to '{t.Serial}'");
                }

                // Save and reload the macros and vars
                Engine.MainWindow.SaveMacroVariables();

                TargetWasSet = true;
            }

            /*
            private void OnSLTCancel()
            {
                if (m_LastTarget != null)
                    m_LTWasSet = true;
            }*/
        }

        public static List<MacroVariable> MacroVariableList = new List<MacroVariable>();

        public static void Save(XmlTextWriter xml)
        {
            foreach (MacroVariable target in MacroVariableList)
            {
                xml.WriteStartElement("macrovariable");
                xml.WriteAttributeString("type", target.TargetInfo.Type.ToString());
                xml.WriteAttributeString("flags", target.TargetInfo.Flags.ToString());
                xml.WriteAttributeString("serial", target.TargetInfo.Serial.ToString());
                xml.WriteAttributeString("x", target.TargetInfo.X.ToString());
                xml.WriteAttributeString("y", target.TargetInfo.Y.ToString());
                xml.WriteAttributeString("z", target.TargetInfo.X.ToString());
                xml.WriteAttributeString("gfx", target.TargetInfo.Gfx.ToString());
                xml.WriteAttributeString("name", target.Name);
                xml.WriteEndElement();
            }
        }

        public static void Load(XmlElement node)
        {
            ClearAll();

            try
            {
                foreach (XmlElement el in node.GetElementsByTagName("macrovariable"))
                {
                    TargetInfo target = new TargetInfo
                    {
                        Type = Convert.ToByte(el.GetAttribute("type")),
                        Flags = Convert.ToByte(el.GetAttribute("flags")),
                        Serial = Convert.ToUInt32(Serial.Parse(el.GetAttribute("serial"))),
                        X = Convert.ToUInt16(el.GetAttribute("x")),
                        Y = Convert.ToUInt16(el.GetAttribute("y")),
                        Z = Convert.ToUInt16(el.GetAttribute("z")),
                        Gfx = Convert.ToUInt16(el.GetAttribute("gfx"))
                    };

                    MacroVariable macroVariable = new MacroVariable(el.GetAttribute("name"), target);
                    MacroVariableList.Add(macroVariable);
                }
            }
            catch
            {
                // ignored
            }
        }

        public static void Import(XmlElement node)
        {
            //import absolutetargets and doubleclickvariables to macrovariables

            try
            {
                foreach (XmlElement el in node["absolutetargets"].GetElementsByTagName("absolutetarget"))
                {
                    TargetInfo target = new TargetInfo
                    {
                        Type = Convert.ToByte(el.GetAttribute("type")),
                        Flags = Convert.ToByte(el.GetAttribute("flags")),
                        Serial = Convert.ToUInt32(Serial.Parse(el.GetAttribute("serial"))),
                        X = Convert.ToUInt16(el.GetAttribute("x")),
                        Y = Convert.ToUInt16(el.GetAttribute("y")),
                        Z = Convert.ToUInt16(el.GetAttribute("z")),
                        Gfx = Convert.ToUInt16(el.GetAttribute("gfx"))
                    };

                    MacroVariable macroVariable = new MacroVariable(el.GetAttribute("name"), target);
                    MacroVariableList.Add(macroVariable);
                }
            }
            catch
            {
                // ignored
            }

            try
            {
                foreach (XmlElement el in node["doubleclickvariables"].GetElementsByTagName("doubleclickvariable"))
                {
                    TargetInfo target = new TargetInfo
                    {
                        Type = 0,
                        Flags = 0,
                        Serial = Convert.ToUInt32(Serial.Parse(el.GetAttribute("serial"))),
                        X = 0,
                        Y = 0,
                        Z = 0,
                        Gfx = Convert.ToUInt16(el.GetAttribute("gfx"))
                    };

                    MacroVariable macroVariable = new MacroVariable(el.GetAttribute("name"), target);
                    MacroVariableList.Add(macroVariable);
                }
            }
            catch
            {
                // ignored
            }
        }

        public static void ClearAll()
        {
            MacroVariableList.Clear();
        }
    }
}

================================================
FILE: Razor/Map/MapWindow.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using Assistant.UI;

namespace Assistant.MapUO
{
    /// <summary>
    /// Summary description for MapWindow.
    /// </summary>
    public class MapWindow : System.Windows.Forms.Form
    {
        public const int WM_NCLBUTTONDOWN = 0xA1;
        public const int HT_CAPTION = 0x2;
        private Assistant.MapUO.UOMapControl Map;

        [DllImport("user32.dll")]
        private static extern IntPtr SendMessage(IntPtr hWnd, int Msg, IntPtr wParam, IntPtr lParam);

        [DllImport("user32.dll")]
        internal static extern bool ReleaseCapture();

        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.Container components = null;

        public MapWindow()
        {
            //
            // Required for Windows Form Designer support
            //
            InitializeComponent();
            this.ContextMenuStrip = new ContextMenuStrip();
            this.ContextMenuStrip.Opening += ContextMenu_Popup;
            this.Location = new Point(Config.GetInt("MapX"), Config.GetInt("MapY"));
            this.ClientSize = new Size(Config.GetInt("MapW"), Config.GetInt("MapH"));

            if (this.Location.X < -10 || this.Location.Y < -10)
                this.Location = Point.Empty;

            if (this.Width < 50)
                this.Width = 50;
            if (this.Height < 50)
                this.Height = 50;

            //
            // TODO: Add any constructor code after InitializeComponent call
            //

            this.Map.FullUpdate();
            Client.Instance.SetMapWndHandle(this);
        }

        public class MapMenuItem : ToolStripMenuItem
        {
            public MapMenuItem(System.String text, System.EventHandler onClick) : base(text, null, onClick)
            {
                Tag = null;
            }
        }

        void ContextMenu_Popup(object sender, EventArgs e)
        {
            ContextMenuStrip cm = this.ContextMenuStrip;
            cm.Items.Clear();
            if (World.Player != null && PacketHandlers.Party.Count > 0)
            {
                MapMenuItem mi = new MapMenuItem("You", new EventHandler(FocusChange));
                mi.Tag = World.Player.Serial;
                cm.Items.Add(mi);
                foreach (Serial s in PacketHandlers.Party)
                {
                    Mobile m = World.FindMobile(s);
                    if (m.Name != null)
                    {
                        mi = new MapMenuItem(m.Name, new EventHandler(FocusChange));
                        mi.Tag = s;
                        if (this.Map.FocusMobile == m)
                            mi.Checked = true;
                        cm.Items.Add(mi);
                    }
                }
            }

            this.ContextMenuStrip = cm;
        }


        private void FocusChange(object sender, System.EventArgs e)
        {
            if (sender != null)
            {
                MapMenuItem mItem = sender as MapMenuItem;

                if (mItem != null)
                {
                    Serial s = (Serial) mItem.Tag;
                    Mobile m = World.FindMobile(s);
                    this.Map.FocusMobile = m;
                    this.Map.FullUpdate();
                }
            }
        }

        public static void Initialize()
        {
            new ReqPartyLocTimer().Start();

            HotKey.Add(HKCategory.Misc, LocString.ToggleMap, new HotKeyCallback(ToggleMap));
        }

        public static void ToggleMap()
        {
            if (World.Player != null && Engine.MainWindow != null)
            {
                if (Engine.MainWindow.MapWindow == null)
                {
                    Engine.MainWindow.SafeAction(s =>
                    {
                        s.MapWindow = new Assistant.MapUO.MapWindow();
                        s.MapWindow.Show();
                        s.MapWindow.BringToFront();
                    });
                }
                else
                {
                    if (Engine.MainWindow.MapWindow.Visible)
                    {
                        Engine.MainWindow.SafeAction(s =>
                        {
                            s.MapWindow.Hide();
                            s.BringToFront();
                        });
                        Platform.BringToFront(Client.Instance.GetWindowHandle());
                    }
                    else
                    {
                        Engine.MainWindow.MapWindow.Show();
                        Engine.MainWindow.MapWindow.BringToFront();
                        Engine.MainWindow.MapWindow.TopMost = true;
                        Client.Instance.SetMapWndHandle(Engine.MainWindow.MapWindow);
                    }
                }
            }
        }

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (components != null)
                {
                    components.Dispose();
                }
            }

            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            System.Resources.ResourceManager resources = new System.Resources.ResourceManager(typeof(MapWindow));
            this.Map = new Assistant.MapUO.UOMapControl();
            this.SuspendLayout();
            //
            // Map
            //
            this.Map.Active = true;
            this.Map.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D;
            this.Map.FocusMobile = null;
            this.Map.Location = new System.Drawing.Point(0, 0);
            this.Map.Name = "Map";
            this.Map.Size = new System.Drawing.Size(296, 272);
            this.Map.TabIndex = 0;
            this.Map.TabStop = false;
            this.Map.MouseDown += new System.Windows.Forms.MouseEventHandler(this.Map_MouseDown);
            //
            // MapWindow
            //
            this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
            this.BackColor = System.Drawing.Color.Black;
            this.ClientSize = new System.Drawing.Size(292, 266);
            this.Controls.Add(this.Map);
            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.SizableToolWindow;
            this.Icon = ((System.Drawing.Icon) (resources.GetObject("$this.Icon")));
            this.MaximizeBox = false;
            this.Name = "MapWindow";
            this.ShowInTaskbar = false;
            this.StartPosition = System.Windows.Forms.FormStartPosition.Manual;
            this.Text = "UO Positioning System";
            this.TopMost = true;
            this.Resize += new System.EventHandler(this.MapWindow_Resize);
            this.MouseDown += new System.Windows.Forms.MouseEventHandler(this.MapWindow_MouseDown);
            this.Closing += new System.ComponentModel.CancelEventHandler(this.MapWindow_Closing);
            this.Move += new System.EventHandler(this.MapWindow_Move);
            this.Deactivate += new System.EventHandler(this.MapWindow_Deactivate);
            this.ResumeLayout(false);
        }

        #endregion

        public void CheckLocalUpdate(Mobile mob)
        {
            if (mob.InParty)
                this.Map.FullUpdate();
        }

        private static Font m_RegFont = new Font("Courier New", 8);
        /*private   int ButtonRows;
        protected override void OnPaint(PaintEventArgs e)
        {
        base.OnPaint(e);
        if ( PacketHandlers.Party.Count > 0 )
        {
        //75x15
        int xcount = 0;
        int ycount = 0;
        Point org = new Point(0, (ButtonRows * 15));
        if (this.FormBorderStyle == FormBorderStyle.None)
        {
        org = new Point(0,  (ButtonRows * 15) + 32);
        }

        foreach ( Serial s in PacketHandlers.Party )
        {
        Mobile mob = World.FindMobile( s );
        if ( mob == null )
             continue;

        if (((75 * (xcount+1)) - this.Width) > 0)
        {
             xcount = 0;
             ycount++;
        }
        string name = mob.Name;
        if ( name != null && name.Length > 8)
        {
             name = name.Substring(0, 8);
             name += "...";
        }
        else if ( name == null || name.Length < 1 )
        {
             name = "(Not Seen)";
        }

        Point drawPoint = new Point(org.X + (75 * xcount), org.Y + (15*ycount));
        mob.ButtonPoint = new Point2D( drawPoint.X, drawPoint.Y );
        e.Graphics.FillRectangle( Brushes.Black, drawPoint.X, drawPoint.Y, 75, 15 );
        e.Graphics.DrawRectangle(Pens.Gray, drawPoint.X, drawPoint.Y, 75, 15 );
        e.Graphics.DrawString(name, m_RegFont, Brushes.White, drawPoint);
        xcount++;
        }
        if(ycount > 0)
        ButtonRows = ycount;
        }

        }*/

        private class ReqPartyLocTimer : Timer
        {
            public ReqPartyLocTimer() : base(TimeSpan.FromSeconds(1.0), TimeSpan.FromSeconds(1.0))
            {
            }

            protected override void OnTick()
            {
                // never send this packet to encrypted servers (could lead to OSI detecting razor)
                if (Client.Instance.ServerEncrypted)
                {
                    Stop();
                    return;
                }

                if (Engine.MainWindow == null || Engine.MainWindow.MapWindow == null ||
                    !Engine.MainWindow.MapWindow.Visible)
                    return; // don't bother when the map window isnt visible

                if (World.Player != null && PacketHandlers.Party.Count > 0)
                {
                    if (PacketHandlers.SpecialPartySent > PacketHandlers.SpecialPartyReceived)
                    {
                        // If we sent more than we received then the server stopped responding
                        // in that case, wait a long while before trying again
                        PacketHandlers.SpecialPartySent = PacketHandlers.SpecialPartyReceived = 0;
                        this.Interval = TimeSpan.FromSeconds(5.0);
                        return;
                    }
                    else
                    {
                        this.Interval = TimeSpan.FromSeconds(1.0);
                    }

                    bool send = false;
                    foreach (Serial s in PacketHandlers.Party)
                    {
                        Mobile m = World.FindMobile(s);

                        if (m == World.Player)
                            continue;

                        if (m == null || Utility.Distance(World.Player.Position, m.Position) > World.Player.VisRange ||
                            !m.Visible)
                        {
                            send = true;
                            break;
                        }
                    }

                    if (send)
                    {
                        PacketHandlers.SpecialPartySent++;
                        Client.Instance.SendToServer(new QueryPartyLocs());
                    }
                }
                else
                {
                    this.Interval = TimeSpan.FromSeconds(1.0);
                }
            }
        }

        private void RequestPartyLocations()
        {
            if (World.Player != null && PacketHandlers.Party.Count > 0)
                Client.Instance.SendToServer(new QueryPartyLocs());
        }

        public void UpdateMap()
        {
            Client.Instance.SetMapWndHandle(this);
            this.Map.UpdateMap();
        }

        private void MapWindow_Closing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            if (Engine.Running)
            {
                Engine.MainWindow.MapWindow.SafeAction(s =>
                {
                    e.Cancel = true;
                    s.Hide();
                });
            }
        }

        public void PlayerMoved()
        {
            if (this.Visible && this.Map != null)
                this.Map.FullUpdate();
        }

        private void MapWindow_Resize(object sender, System.EventArgs e)
        {
            this.Map.Height = this.Height;
            this.Map.Width = this.Width;

            if (this.Width < 50)
                this.Width = 50;
            if (this.Height < 50)
                this.Height = 50;

            this.Refresh();

            Config.SetProperty("MapX", this.Location.X);
            Config.SetProperty("MapY", this.Location.Y);
            Config.SetProperty("MapW", this.ClientSize.Width);
            Config.SetProperty("MapH", this.ClientSize.Height);
        }

        private void MapWindow_MouseDown(object sender, System.Windows.Forms.MouseEventArgs e)
        {
            if (e.Clicks == 2)
            {
                if (this.FormBorderStyle == FormBorderStyle.None)
                    this.FormBorderStyle = FormBorderStyle.SizableToolWindow;
                else
                    this.FormBorderStyle = FormBorderStyle.None;
            }

            if (e.Button == MouseButtons.Left)
            {
                ReleaseCapture();
                SendMessage(Handle, WM_NCLBUTTONDOWN, (IntPtr) HT_CAPTION, IntPtr.Zero);
                /*foreach ( Serial s in PacketHandlers.Party )
                {
                Mobile m = World.FindMobile( s );
                if ( m == null )
                     continue;
                Rectangle rec = new Rectangle( m.ButtonPoint.X, m.ButtonPoint.Y, 75, 15 );
                if ( rec.Contains( e.X, e.Y ) )
                {
                     this.Map.FocusMobile = m;
                     this.Map.Refresh();
                }
                }*/
            }

            this.Map.MapClick(e);
        }

        private void Map_MouseDown(object sender, System.Windows.Forms.MouseEventArgs e)
        {
            MapWindow_MouseDown(sender, e);
        }

        private void MapWindow_Move(object sender, System.EventArgs e)
        {
            Config.SetProperty("MapX", this.Location.X);
            Config.SetProperty("MapY", this.Location.Y);
            Config.SetProperty("MapW", this.ClientSize.Width);
            Config.SetProperty("MapH", this.ClientSize.Height);
        }

        private void MapWindow_Deactivate(object sender, System.EventArgs e)
        {
            if (this.TopMost)
                this.TopMost = false;
        }
    }
}

================================================
FILE: Razor/Map/MapWindow.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 1.3
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">1.3</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1">this is my long string</data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        [base64 mime encoded serialized .NET Framework object]
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        [base64 mime encoded string representing a byte array form of the .NET Framework object]
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used forserialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>1.3</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="Map.Locked" type="System.Boolean, mscorlib, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
    <value>False</value>
  </data>
  <data name="Map.DefaultModifiers" type="System.CodeDom.MemberAttributes, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
    <value>Private</value>
  </data>
  <data name="Map.Modifiers" type="System.CodeDom.MemberAttributes, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
    <value>Private</value>
  </data>
  <data name="$this.Locked" type="System.Boolean, mscorlib, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
    <value>False</value>
  </data>
  <data name="$this.Language" type="System.Globalization.CultureInfo, mscorlib, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
    <value>(Default)</value>
  </data>
  <data name="$this.TrayLargeIcon" type="System.Boolean, mscorlib, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
    <value>False</value>
  </data>
  <data name="$this.Localizable" type="System.Boolean, mscorlib, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
    <value>False</value>
  </data>
  <data name="$this.GridSize" type="System.Drawing.Size, System.Drawing, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
    <value>8, 8</value>
  </data>
  <data name="$this.DrawGrid" type="System.Boolean, mscorlib, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
    <value>True</value>
  </data>
  <data name="$this.TrayHeight" type="System.Int32, mscorlib, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
    <value>80</value>
  </data>
  <data name="$this.Name">
    <value>MapWindow</value>
  </data>
  <data name="$this.SnapToGrid" type="System.Boolean, mscorlib, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
    <value>True</value>
  </data>
  <data name="$this.DefaultModifiers" type="System.CodeDom.MemberAttributes, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
    <value>Private</value>
  </data>
  <data name="$this.Icon" type="System.Drawing.Icon, System.Drawing, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" mimetype="application/x-microsoft.net.object.bytearray.base64">
    <value>
        AAABAAEAEBAQAAAAAAAoAQAAFgAAACgAAAAQAAAAIAAAAAEABAAAAAAAgAAAAAAAAAAAAAAAEAAAABAA
        AAAAAAAAAACAAACAAAAAgIAAgAAAAIAAgACAgAAAgICAAMDAwAAAAP8AAP8AAAD//wD/AAAA/wD/AP//
        AAD///8AIiIiIiiIiCIAAAAAAIiAAAAAAAAACAAAAAAAAAAIAAAACIiIAAgAAAAAAHiICAAAAAAAB3iI
        AAAAAAAAiIAAAAAAAAiIeAAAAAC7AYB4gAAAAACwAAeAAAC7AAsAAIAAAACwCwAAgAAAAAsAAACAAAuw
        CwAAAAAAALAAAAAAAAAAAAAA/8cAAP/vAAD/7wAA4O8AAPwvAAD+DwAA/x8AAP4PAADyRwAA/ecAAM73
        AAD29wAA+/cAAJv/AADf/wAA
</value>
  </data>
</root>

================================================
FILE: Razor/Map/Region.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System.IO;
using System.Collections;

namespace Assistant.MapUO
{
    class Region
    {
        private int m_Height;
        private int m_Width;
        private int m_X;
        private int m_Y;

        public Region(string line)
        {
            string[] textArray1 = line.Split(new char[] {' '});
            this.m_X = int.Parse(textArray1[0]);
            this.m_Y = int.Parse(textArray1[1]);
            this.m_Width = int.Parse(textArray1[2]);
            this.m_Height = int.Parse(textArray1[3]);
        }

        public Region(int x, int y, int width, int height)
        {
            this.m_X = x;
            this.m_Y = y;
            this.m_Width = width;
            this.m_Height = height;
        }


        public static Region[] Load(string path)
        {
            if (!File.Exists(path))
            {
                return new Region[0];
            }

            ArrayList list1 = new ArrayList();
            try
            {
                using (StreamReader reader1 = new StreamReader(path))
                {
                    string text1;
                    while ((text1 = reader1.ReadLine()) != null)
                    {
                        if ((text1.Length != 0) && !text1.StartsWith("#"))
                        {
                            list1.Add(new Region(text1));
                        }
                    }
                }
            }
            catch
            {
            }

            return (Region[]) list1.ToArray(typeof(Region));
        }

        public int X
        {
            get { return m_X; }
            set { m_X = value; }
        }

        public int Y
        {
            get { return m_Y; }
            set { m_Y = value; }
        }

        public int Length
        {
            get { return m_Height; }
            set { m_Height = value; }
        }

        public int Width
        {
            get { return m_Width; }
            set { m_Width = value; }
        }
    }
}

================================================
FILE: Razor/Map/UOMapControl.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Collections;
using System.Drawing.Drawing2D;
using System.IO;

namespace Assistant.MapUO
{
    public class UOMapControl : PictureBox
    {
        delegate void UpdateMapCallback();

        private bool m_Active;
        private Region[] m_Regions;
        private ArrayList m_MapButtons;
        private Point prevPoint;
        private Mobile m_Focus;
        private const double RotateAngle = Math.PI / 4 + Math.PI;
        private Bitmap m_Background;
        private DateTime LastRefresh;

        public Mobile FocusMobile
        {
            get
            {
                if (m_Focus == null || m_Focus.Deleted || !PacketHandlers.Party.Contains(m_Focus.Serial))
                {
                    /*if ( World.Player == null )
                         return new Mobile( Serial.Zero );
                    else*/
                    return World.Player;
                }

                return m_Focus;
            }
            set { m_Focus = value; }
        }

        public UOMapControl()
        {
            Active = false;
            this.prevPoint = new Point(0, 0);
            this.BorderStyle = BorderStyle.Fixed3D;
            this.m_MapButtons = new ArrayList();
            m_Regions = Assistant.MapUO.Region.Load(Path.Combine(Config.GetInstallDirectory(), "guardlines.def"));
            m_MapButtons = UOMapRuneButton.Load("test.xml");
        }

        private static Font m_BoldFont = new Font("Courier New", 8, FontStyle.Bold);
        private static Font m_SmallFont = new Font("Arial", 6);
        private static Font m_RegFont = new Font("Arial", 8);

        public override void Refresh()
        {
            TimeSpan now = DateTime.UtcNow - LastRefresh;
            if (now.TotalMilliseconds <= 100)
                return;
            LastRefresh = DateTime.UtcNow;
            base.Refresh();
        }

        private PointF AdjustPoint(PointF center, PointF pos)
        {
            PointF newp = new PointF(center.X - pos.X, center.Y - pos.Y);
            float dis = (float) Distance(center, pos);
            dis += dis * 0.50f;
            float slope = 0;
            if (newp.X != 0)
                slope = (float) newp.Y / (float) newp.X;
            else
                return new PointF(0 + center.X, -1f * (newp.Y + (newp.Y * 0.25f)) + center.Y);
            slope *= -1;
            //Both of these algorithms oddly produce the same results.
            //float x = dis / (float)(Math.Sqrt(1f + Math.Pow(slope, 2)));
            float x = newp.X + (newp.X * 0.5f);
            // if (newp.X > 0)
            x *= -1;
            float y = (-1) * slope * x;

            PointF def = new PointF(x + center.X, y + center.Y);

            return def;
        }

        public double Distance(PointF center, PointF pos)
        {
            PointF newp = new PointF(center.X - pos.X, center.Y - pos.Y);
            double distX = Math.Pow(newp.X, 2);
            double distY = Math.Pow(newp.Y, 2);
            return Math.Sqrt(distX + distY);
        }

        private PointF RotatePoint(PointF center, PointF pos)
        {
            PointF newp = new PointF(center.X - pos.X, center.Y - pos.Y);
            double x = newp.X * Math.Cos(RotateAngle) - newp.Y * Math.Sin(RotateAngle);
            double y = newp.X * Math.Sin(RotateAngle) + newp.Y * Math.Sin(RotateAngle);
            return AdjustPoint(center, new PointF((float) (x) + center.X, (float) (y) + center.Y));
        }

        public void FullUpdate()
        {
            if (!Active)
                return;

            if (m_Background != null)
                m_Background.Dispose();
            m_Background = new Bitmap(this.Width, this.Height);

            int xLong = 0, yLat = 0;
            int xMins = 0, yMins = 0;
            bool xEast = false, ySouth = false;

            int w = (this.Width) >> 3;
            int h = (this.Height) >> 3;
            int xtrans = this.Width / 2;
            int ytrans = this.Height / 2;
            Point3D focus = this.FocusMobile.Position;
            Point offset = new Point(focus.X & 7, focus.Y & 7);
            Point mapOrigin = new Point((focus.X >> 3) - (w / 2), (focus.Y >> 3) - (h / 2));
            Point pntPlayer = new Point((focus.X) - (mapOrigin.X << 3) - offset.X,
                (focus.Y) - (mapOrigin.Y << 3) - offset.Y);

            Graphics gfx = Graphics.FromImage(m_Background);

            gfx.FillRectangle(Brushes.Black, 0, 0, this.Width, this.Height);

            gfx.TranslateTransform(-xtrans, -ytrans, MatrixOrder.Append);
            gfx.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.NearestNeighbor;
            gfx.PageUnit = GraphicsUnit.Pixel;
            gfx.ScaleTransform(1.5f, 1.5f, MatrixOrder.Append);
            gfx.RotateTransform(45, MatrixOrder.Append);
            gfx.TranslateTransform(xtrans, ytrans, MatrixOrder.Append);

            Ultima.Map map = Map.GetMap(this.FocusMobile.Map);
            if (map == null)
                map = Ultima.Map.Felucca;

            gfx.DrawImage(map.GetImage(mapOrigin.X, mapOrigin.Y, w + offset.X, h + offset.Y, true), -offset.X,
                -offset.Y);

            gfx.ScaleTransform(1.0f, 1.0f, MatrixOrder.Append);

            ArrayList regions = new ArrayList();
            ArrayList mButtons = new ArrayList();
            if (this.Width > this.Height)
            {
                regions = RegionList(focus.X, focus.Y, this.Width);
                mButtons = ButtonList(focus.X, focus.Y, this.Width);
            }
            else
            {
                regions = RegionList(focus.X, focus.Y, this.Height);
                mButtons = ButtonList(focus.X, focus.Y, this.Height);
            }

            foreach (Assistant.MapUO.Region region in regions)
                gfx.DrawRectangle(Pens.LimeGreen, (region.X) - ((mapOrigin.X << 3) + offset.X),
                    (region.Y) - ((mapOrigin.Y << 3) + offset.Y), region.Width, region.Length);

            gfx.DrawLine(Pens.Silver, pntPlayer.X - 2, pntPlayer.Y - 2, pntPlayer.X + 2, pntPlayer.Y + 2);
            gfx.DrawLine(Pens.Silver, pntPlayer.X - 2, pntPlayer.Y + 2, pntPlayer.X + 2, pntPlayer.Y - 2);
            gfx.FillRectangle(Brushes.Red, pntPlayer.X, pntPlayer.Y, 1, 1);
            //gfx.DrawEllipse( Pens.Silver, pntPlayer.X - 2, pntPlayer.Y - 2, 4, 4 );

            gfx.DrawString("W", m_BoldFont, Brushes.Red, pntPlayer.X - 35, pntPlayer.Y - 5);
            gfx.DrawString("E", m_BoldFont, Brushes.Red, pntPlayer.X + 25, pntPlayer.Y - 5);
            gfx.DrawString("N", m_BoldFont, Brushes.Red, pntPlayer.X - 5, pntPlayer.Y - 35);
            gfx.DrawString("S", m_BoldFont, Brushes.Red, pntPlayer.X - 5, pntPlayer.Y + 25);

            gfx.ResetTransform();


            if (Format(new Point(focus.X, focus.Y), Ultima.Map.Felucca, ref xLong, ref yLat, ref xMins, ref yMins,
                ref xEast, ref ySouth))
            {
                string locString =
                    $"{yLat}°{yMins}'{(ySouth ? "S" : "N")} {xLong}°{xMins}'{(xEast ? "E" : "W")} | ({World.Player.Position.X},{World.Player.Position.Y})";
                SizeF size = gfx.MeasureString(locString, m_RegFont);
                gfx.FillRectangle(Brushes.Wheat, 0, 0, size.Width + 2, size.Height + 2);
                gfx.DrawRectangle(Pens.Black, 0, 0, size.Width + 2, size.Height + 2);
                gfx.DrawString(locString, m_RegFont, Brushes.Black, 1, 1);
            }

            gfx.ResetTransform();
            gfx.Dispose();

            this.Refresh();
        }

        protected override void OnPaint(PaintEventArgs pe)
        {
            try
            {
                if (Active)
                {
                    Graphics gfx = pe.Graphics;

                    gfx.DrawImageUnscaled(m_Background, 0, 0);

                    int w = (this.Width) >> 3;
                    int h = (this.Height) >> 3;
                    int xtrans = this.Width / 2;
                    int ytrans = this.Height / 2;
                    Point3D focus = this.FocusMobile.Position;
                    Point offset = new Point(focus.X & 7, focus.Y & 7);
                    Point mapOrigin = new Point((focus.X >> 3) - (w / 2), (focus.Y >> 3) - (h / 2));

                    gfx.TranslateTransform(-xtrans, -ytrans, MatrixOrder.Append);
                    gfx.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.NearestNeighbor;
                    gfx.PageUnit = GraphicsUnit.Pixel;
                    gfx.ScaleTransform(1.5f, 1.5f, MatrixOrder.Append);
                    gfx.RotateTransform(45, MatrixOrder.Append);
                    gfx.TranslateTransform(xtrans, ytrans, MatrixOrder.Append);
                    gfx.ScaleTransform(1.0f, 1.0f, MatrixOrder.Append);
                    gfx.ResetTransform();

                    //Point pntTest2 = new Point((3256) - (mapOrigin.X << 3) - offset.X, (326) - (mapOrigin.Y << 3) - offset.Y);
                    //PointF pntTest2F = RotatePoint(new Point(xtrans, ytrans), pntTest2);
                    //gfx.FillRectangle(Brushes.LimeGreen, pntTest2F.X, pntTest2F.Y, 4, 4);
                    /*foreach ( Serial s in PacketHandlers.Party )
                    {
                         Mobile mob = World.FindMobile( s );
                         if ( mob == null )
                              continue;
                         if (mob == this.FocusMobile)
                              continue;
                         Point drawPoint = new Point((mob.Position.X) - (mapOrigin.X << 3) - offset.X, (mob.Position.Y) - (mapOrigin.Y << 3) - offset.Y);

                         if (drawPoint.X < 0)
                              drawPoint.X = 0;
                         if (drawPoint.X > this.Width)
                              drawPoint.X = this.Width;
                         if (drawPoint.Y < 0)
                              drawPoint.Y = 0;
                         if (drawPoint.Y > this.Height)
                              drawPoint.Y = this.Height;
                         PointF drawPointF = RotatePoint(new Point(xtrans,ytrans),drawPoint);
                         //gfx.FillRectangle(Brushes.Gold, drawPointF.X, drawPointF.Y, 2f, 2f);
                    }*/
                    foreach (Serial s in PacketHandlers.Party)
                    {
                        Mobile mob = World.FindMobile(s);
                        if (mob == null)
                            continue;

                        if (mob == this.FocusMobile && mob == World.Player)
                            continue;

                        string name = mob.Name;
                        if (name == null || name.Length < 1)
                            name = "(Not Seen)";
                        if (name != null && name.Length > 8)
                            name = name.Substring(0, 8);
                        Point drawPoint = new Point((mob.Position.X) - (mapOrigin.X << 3) - offset.X,
                            (mob.Position.Y) - (mapOrigin.Y << 3) - offset.Y);
                        if (drawPoint.X < 0)
                            drawPoint.X = 0;
                        if (drawPoint.X > this.Width)
                            drawPoint.X = this.Width;
                        if (drawPoint.Y < 0)
                            drawPoint.Y = 0;
                        if (drawPoint.Y > this.Height)
                            drawPoint.Y = this.Height;

                        PointF drawPointF = RotatePoint(new Point(xtrans, ytrans), drawPoint);
                        gfx.FillRectangle(Brushes.Gold, drawPointF.X, drawPointF.Y, 2f, 2f);
                        gfx.DrawString(name, m_RegFont, Brushes.White, drawPointF.X, drawPointF.Y);
                    }

                    if (World.Player != null)
                    {
                        if (World.Player != this.FocusMobile)
                        {
                            Mobile mob = World.Player;
                            Point drawPoint = new Point((mob.Position.X) - (mapOrigin.X << 3) - offset.X,
                                (mob.Position.Y) - (mapOrigin.Y << 3) - offset.Y);
                            PointF drawPointF = RotatePoint(new Point(xtrans, ytrans), drawPoint);
                            gfx.FillRectangle(Brushes.Gold, drawPointF.X, drawPointF.Y, 2, 2);
                            drawPoint = new Point((mob.Position.X) - (mapOrigin.X << 3) - offset.X,
                                (mob.Position.Y) - (mapOrigin.Y << 3) - offset.Y);
                            drawPointF = RotatePoint(new Point(xtrans, ytrans), drawPoint);
                            string name = mob.Name;
                            if (name != null && name.Length > 8)
                                name = name.Substring(0, 8);

                            gfx.DrawString(name, m_RegFont, Brushes.White, drawPointF.X, drawPointF.Y);
                        }
                    }
                }
            }
            catch
            {
            }

            base.OnPaint(pe);
        }

        public void MapClick(System.Windows.Forms.MouseEventArgs e)
        {
            if (Active)
            {
                Point clickedbox = MousePointToMapPoint(new Point(e.X, e.Y));
                UOMapRuneButton button = ButtonCheck(new Rectangle(clickedbox.X - 2, clickedbox.Y - 2, 5, 5));
                if (button != null)
                    button.OnClick(e);
            }
        }

        private Point MousePointToMapPoint(Point p)
        {
            double rad = (Math.PI / 180) * 45;
            int w = (this.Width) >> 3;
            int h = (this.Height) >> 3;
            Point3D focus = this.FocusMobile.Position;

            Point mapOrigin = new Point((focus.X >> 3) - (w / 2), (focus.Y >> 3) - (h / 2));
            Point pnt1 = new Point((mapOrigin.X << 3) + (p.X), (mapOrigin.Y << 3) + (p.Y));
            Point check = new Point(pnt1.X - focus.X, pnt1.Y - focus.Y);
            check = RotatePoint(new Point((int) (check.X * 0.695), (int) (check.Y * 0.68)), rad, 1);
            return new Point(check.X + focus.X, check.Y + focus.Y);
        }

        private Point RotatePoint(Point p, double angle, double dist)
        {
            int x = (int) ((p.X * Math.Cos(angle) + p.Y * Math.Sin(angle)) * dist);
            int y = (int) ((-p.X * Math.Sin(angle) + p.Y * Math.Cos(angle)) * dist);

            return new Point(x, y);
        }

        private UOMapRuneButton ButtonCheck(Rectangle rec)
        {
            ArrayList buttons = new ArrayList();
            foreach (UOMapRuneButton mbutton in this.m_MapButtons)
            {
                Rectangle rec2 = new Rectangle(mbutton.X, mbutton.Y, 10, 10);
                if (rec2.IntersectsWith(rec))
                    return mbutton;
            }

            return null;
        }

        protected override void Dispose(bool disposing)
        {
            m_Background.Dispose();
            m_Background = null;
            base.Dispose(disposing);
        }

        protected override void OnResize(EventArgs e)
        {
            base.OnResize(e);
            FullUpdate();
        }

        public void UpdateMap()
        {
            try
            {
                if (this.InvokeRequired)
                {
                    UpdateMapCallback d = new UpdateMapCallback(UpdateMap);
                    this.Invoke(d, new object[0]);
                }
                else
                {
                    this.Refresh();
                }
            }
            catch
            {
            }
        }

        private ArrayList RegionList(int x, int y, int maxDist)
        {
            int count = m_Regions.Length;
            ArrayList aList = new ArrayList();
            for (int i = 0; i < count; i++)
            {
                Assistant.MapUO.Region rg1 = this.m_Regions[i];
                if (Utility.Distance(rg1.X, rg1.Y, x, y) <= maxDist * 2)
                {
                    aList.Add(rg1);
                }
            }

            return aList;
        }

        private ArrayList ButtonList(int x, int y, int maxDist)
        {
            if (this.m_MapButtons == null)
                return null;
            int count = this.m_MapButtons.Count;
            ArrayList aList = new ArrayList();
            for (int i = 0; i < count; i++)
            {
                UOMapRuneButton btn = (UOMapRuneButton) this.m_MapButtons[i];
                if (Utility.Distance(btn.X, btn.Y, x, y) <= maxDist * 2)
                {
                    aList.Add(btn);
                }
            }

            return aList;
        }

        public static bool Format(Point p, Ultima.Map map, ref int xLong, ref int yLat, ref int xMins, ref int yMins,
            ref bool xEast, ref bool ySouth)
        {
            if (map == null)
                return false;

            int x = p.X, y = p.Y;
            int xCenter, yCenter;
            int xWidth, yHeight;

            if (!ComputeMapDetails(map, x, y, out xCenter, out yCenter, out xWidth, out yHeight))
                return false;

            double absLong = (double) ((x - xCenter) * 360) / xWidth;
            double absLat = (double) ((y - yCenter) * 360) / yHeight;

            if (absLong > 180.0)
                absLong = -180.0 + (absLong % 180.0);

            if (absLat > 180.0)
                absLat = -180.0 + (absLat % 180.0);

            bool east = (absLong >= 0), south = (absLat >= 0);

            if (absLong < 0.0)
                absLong = -absLong;

            if (absLat < 0.0)
                absLat = -absLat;

            xLong = (int) absLong;
            yLat = (int) absLat;

            xMins = (int) ((absLong % 1.0) * 60);
            yMins = (int) ((absLat % 1.0) * 60);

            xEast = east;
            ySouth = south;

            return true;
        }

        public static bool ComputeMapDetails(Ultima.Map map, int x, int y, out int xCenter, out int yCenter,
            out int xWidth, out int yHeight)
        {
            xWidth = 5120;
            yHeight = 4096;

            if (map == Ultima.Map.Trammel || map == Ultima.Map.Felucca)
            {
                if (x >= 0 && y >= 0 && x < 5120 && y < map.Height)
                {
                    xCenter = 1323;
                    yCenter = 1624;
                }
                else if (x >= 5120 && y >= 2304 && x < 6144 && y < map.Height)
                {
                    xCenter = 5936;
                    yCenter = 3112;
                }
                else
                {
                    xCenter = 0;
                    yCenter = 0;
                    return false;
                }
            }
            else if (x >= 0 && y >= 0 && x < map.Width && y < map.Height)
            {
                xCenter = 1323;
                yCenter = 1624;
            }
            else
            {
                xCenter = map.Width / 2;
                yCenter = map.Height / 2;
                return false;
            }

            return true;
        }

        public bool Active
        {
            get { return m_Active; }
            set
            {
                m_Active = value;
                if (value)
                {
                    FullUpdate();
                }
            }
        }

        public ArrayList MapButtons
        {
            get { return m_MapButtons; }
            set { m_MapButtons = value; }
        }
    }
}

================================================
FILE: Razor/Map/UOMapControl.resx
================================================
<?xml version="1.0" encoding="utf-8" ?>
<root>
	<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
		<xsd:element name="root" msdata:IsDataSet="true">
			<xsd:complexType>
				<xsd:choice maxOccurs="unbounded">
					<xsd:element name="data">
						<xsd:complexType>
							<xsd:sequence>
								<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
								<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
							</xsd:sequence>
							<xsd:attribute name="name" type="xsd:string" />
							<xsd:attribute name="type" type="xsd:string" />
							<xsd:attribute name="mimetype" type="xsd:string" />
						</xsd:complexType>
					</xsd:element>
					<xsd:element name="resheader">
						<xsd:complexType>
							<xsd:sequence>
								<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
							</xsd:sequence>
							<xsd:attribute name="name" type="xsd:string" use="required" />
						</xsd:complexType>
					</xsd:element>
				</xsd:choice>
			</xsd:complexType>
		</xsd:element>
	</xsd:schema>
	<resheader name="ResMimeType">
		<value>text/microsoft-resx</value>
	</resheader>
	<resheader name="Version">
		<value>1.0.0.0</value>
	</resheader>
	<resheader name="Reader">
		<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
	</resheader>
	<resheader name="Writer">
		<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
	</resheader>
</root>


================================================
FILE: Razor/Map/UOMapRuneButton.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Drawing;
using System.Collections;
using System.Windows.Forms;

namespace Assistant.MapUO
{
    class UOMapRuneButton
    {
        private int m_BookID;
        private int m_RuneSpot;
        private int m_X;
        private int m_Y;
        private Bitmap m_Icon;

        public UOMapRuneButton(int bookid, int runeSpot, int x, int y)
        {
            this.m_BookID = bookid;
            this.m_RuneSpot = runeSpot;
            this.m_X = x;
            this.m_Y = y;
            if (Environment.OSVersion.Platform == PlatformID.Win32NT)
                this.m_Icon = Ultima.Art.GetStatic(7956);
        }

        public static ArrayList Load(string path)
        {
            ArrayList buttonlist = new ArrayList();
            //if (!File.Exists(path))
            // {
            //    return buttonlist;
            // }
            buttonlist.Add(new UOMapRuneButton(0, 0, 1158, 743));
            buttonlist.Add(new UOMapRuneButton(0, 0, 3230, 305));
            //XML shit
            return buttonlist;
        }

        public void OnClick(MouseEventArgs e)
        {
            switch (e.Button)
            {
                case MouseButtons.Left:
                    //recall
                    break;
                case MouseButtons.Right:
                    //gate
                    break;
            }
        }

        public int X
        {
            get { return m_X; }
            set { m_X = value; }
        }

        public int Y
        {
            get { return m_Y; }
            set { m_Y = value; }
        }

        public int BookID
        {
            get { return m_BookID; }
            set { m_BookID = value; }
        }

        public int RuneSpot
        {
            get { return m_RuneSpot; }
            set { m_RuneSpot = value; }
        }

        public Bitmap Icon
        {
            get { return m_Icon; }
            set { m_Icon = value; }
        }
    }
}

================================================
FILE: Razor/Network/Handlers.cs
================================================
#region license

// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#endregion

using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using Assistant.Agents;
using Assistant.Core;
using Assistant.Filters;
using Assistant.Gumps;
using Assistant.Macros;
using Assistant.Scripts;
using Assistant.UI;
using Ultima;

namespace Assistant
{
    public class PacketHandlers
    {
        private static List<Item> _ignoreGumps = new List<Item>();

        public static List<Item> IgnoreGumps => _ignoreGumps;

        public static void Initialize()
        {
            //Client -> Server handlers
            PacketHandler.RegisterClientToServerViewer(0x00, CreateCharacter);
            //PacketHandler.RegisterClientToServerViewer(0x01, new PacketViewerCallback(Disconnect));
            PacketHandler.RegisterClientToServerFilter(0x02, MovementRequest);
            PacketHandler.RegisterClientToServerFilter(0x05, AttackRequest);
            PacketHandler.RegisterClientToServerViewer(0x06, ClientDoubleClick);
            PacketHandler.RegisterClientToServerViewer(0x07, LiftRequest);
            PacketHandler.RegisterClientToServerViewer(0x08, DropRequest);
            PacketHandler.RegisterClientToServerViewer(0x09, ClientSingleClick);
            PacketHandler.RegisterClientToServerViewer(0x12, ClientTextCommand);
            PacketHandler.RegisterClientToServerViewer(0x13, EquipRequest);
            // 0x29 - UOKR confirm drop.  0 bytes payload (just a single byte, 0x29, no length or data)
            PacketHandler.RegisterClientToServerViewer(0x3A, SetSkillLock);
            PacketHandler.RegisterClientToServerViewer(0x5D, PlayCharacter);
            PacketHandler.RegisterClientToServerViewer(0x7D, MenuResponse);
            PacketHandler.RegisterClientToServerFilter(0x80, ServerListLogin);
            PacketHandler.RegisterClientToServerFilter(0x91, GameLogin);
            PacketHandler.RegisterClientToServerViewer(0x95, HueResponse);
            PacketHandler.RegisterClientToServerViewer(0xA0, PlayServer);
            PacketHandler.RegisterClientToServerViewer(0xB1, ClientGumpResponse);
            PacketHandler.RegisterClientToServerFilter(0xBF, ExtendedClientCommand);
            //PacketHandler.RegisterClientToServerViewer( 0xD6, new PacketViewerCallback( BatchQueryProperties ) );
            PacketHandler.RegisterClientToServerFilter(0xC2, UnicodePromptSend);
            PacketHandler.RegisterClientToServerViewer(0xD7, ClientEncodedPacket);
            PacketHandler.RegisterClientToServerViewer(0xF8, CreateCharacter);

            //Server -> Client handlers
            PacketHandler.RegisterServerToClientViewer(0x0B, Damage);
            PacketHandler.RegisterServerToClientViewer(0x11, MobileStatus);
            PacketHandler.RegisterServerToClientViewer(0x17, NewMobileStatus);
            PacketHandler.RegisterServerToClientViewer(0x1A, WorldItem);
            PacketHandler.RegisterServerToClientViewer(0x1B, LoginConfirm);
            PacketHandler.RegisterServerToClientViewer(0x55, CompleteLogin);
            PacketHandler.RegisterServerToClientFilter(0x1C, AsciiSpeech);
            PacketHandler.RegisterServerToClientViewer(0x1D, RemoveObject);
            PacketHandler.RegisterServerToClientFilter(0x20, MobileUpdate);
            PacketHandler.RegisterServerToClientViewer(0x24, BeginContainerContent);
            PacketHandler.RegisterServerToClientFilter(0x25, ContainerContentUpdate);
            PacketHandler.RegisterServerToClientViewer(0x27, LiftReject);
            PacketHandler.RegisterServerToClientViewer(0x2D, MobileStatInfo);
            PacketHandler.RegisterServerToClientFilter(0x2E, EquipmentUpdate);
            PacketHandler.RegisterServerToClientViewer(0x3A, PlayerSkills);
            PacketHandler.RegisterServerToClientFilter(0x3C, ContainerContent);
            PacketHandler.RegisterServerToClientViewer(0x4E, PersonalLight);
            PacketHandler.RegisterServerToClientViewer(0x4F, GlobalLight);
            PacketHandler.RegisterServerToClientViewer(0x6F, TradeRequest);
            PacketHandler.RegisterServerToClientViewer(0x72, ServerSetWarMode);
            PacketHandler.RegisterServerToClientViewer(0x73, PingResponse);
            PacketHandler.RegisterServerToClientViewer(0x76, ServerChange);
            PacketHandler.RegisterServerToClientFilter(0x77, MobileMoving);
            PacketHandler.RegisterServerToClientFilter(0x78, MobileIncoming);
            PacketHandler.RegisterServerToClientViewer(0x7C, SendMenu);
            PacketHandler.RegisterServerToClientFilter(0x8C, ServerAddress);
            PacketHandler.RegisterServerToClientViewer(0xA1, HitsUpdate);
            PacketHandler.RegisterServerToClientViewer(0xA2, ManaUpdate);
            PacketHandler.RegisterServerToClientViewer(0xA3, StamUpdate);
            PacketHandler.RegisterServerToClientViewer(0xA8, ServerList);
            PacketHandler.RegisterServerToClientViewer(0xAB, DisplayStringQuery);
            PacketHandler.RegisterServerToClientViewer(0xAF, DeathAnimation);
            PacketHandler.RegisterServerToClientFilter(0xAE, UnicodeSpeech);
            PacketHandler.RegisterServerToClientViewer(0xB0, SendGump);
            PacketHandler.RegisterServerToClientViewer(0xB9, Features);
            PacketHandler.RegisterServerToClientViewer(0xBC, ChangeSeason);
            PacketHandler.RegisterServerToClientFilter(0xBE, OnAssistVersion);
            PacketHandler.RegisterServerToClientViewer(0xBF, ExtendedPacket);
            PacketHandler.RegisterServerToClientFilter(0xC1, OnLocalizedMessage);
            PacketHandler.RegisterServerToClientFilter(0xC2, UnicodePromptReceived);
            PacketHandler.RegisterServerToClientFilter(0xC8, SetUpdateRange);
            PacketHandler.RegisterServerToClientFilter(0xCC, OnLocalizedMessageAffix);
            PacketHandler.RegisterServerToClientViewer(0xD6, EncodedPacket); //0xD6 "encoded" packets
            PacketHandler.RegisterServerToClientViewer(0xD8, CustomHouseInfo);
            //PacketHandler.RegisterServerToClientFilter( 0xDC, new PacketFilterCallback( ServOPLHash ) );
            PacketHandler.RegisterServerToClientViewer(0xDD, CompressedGump);
            PacketHandler.RegisterServerToClientViewer(0xF0,
                RunUOProtocolExtention); // Special RunUO protocol extentions (for KUOC/Razor)

            PacketHandler.RegisterServerToClientViewer(0xF3, SAWorldItem);

            PacketHandler.RegisterServerToClientViewer(0x2C, ResurrectionGump);

            PacketHandler.RegisterServerToClientViewer(0xDF, BuffDebuff);

            PacketHandler.RegisterServerToClientFilter(0x54, PlaySoundEffect);
            PacketHandler.RegisterServerToClientFilter(0x6D, PlayMusic);
        }

        private static void DisplayStringQuery(PacketReader p, PacketHandlerEventArgs args)
        {
            // See also Packets.cs: StringQueryResponse
            /*if ( MacroManager.AcceptActions )
            {
                 int serial = p.ReadInt32();
                 byte type = p.ReadByte();
                 byte index = p.ReadByte();

                 MacroManager.Action( new WaitForTextEntryAction( serial, type, index ) );
            }*/
        }

        private static void SetUpdateRange(Packet p, PacketHandlerEventArgs args)
        {
            if (World.Player != null)
                World.Player.VisRange = p.ReadByte();
        }

        private static void EncodedPacket(PacketReader p, PacketHandlerEventArgs args)
        {
            /*ushort id = p.ReadUInt16();

            switch ( id )
            {
                 case 1: // object property list
                 {
                      Serial s = p.ReadUInt32();

                      if ( s.IsItem )
                      {
                           Item item = World.FindItem( s );
                           if ( item == null )
                                World.AddItem( item=new Item( s ) );

                           item.ReadPropertyList( p );
                           if ( item.ModifiedOPL )
                           {
                                args.Block = true;
                                Client.Instance.SendToClient( item.ObjPropList.BuildPacket() );
                           }
                      }
                      else if ( s.IsMobile )
                      {
                           Mobile m = World.FindMobile( s );
                           if ( m == null )
                                World.AddMobile( m=new Mobile( s ) );

                           m.ReadPropertyList( p );
                           if ( m.ModifiedOPL )
                           {
                                args.Block = true;
                                Client.Instance.SendToClient( m.ObjPropList.BuildPacket() );
                           }
                      }
                      break;
                 }
            }*/
        }

        private static void ServOPLHash(Packet p, PacketHandlerEventArgs args)
        {
            /*Serial s = p.ReadUInt32();
            int hash = p.ReadInt32();

            if ( s.IsItem )
            {
                 Item item = World.FindItem( s );
                 if ( item != null && item.OPLHash != hash )
                 {
                      item.OPLHash = hash;
                      p.Seek( -4, SeekOrigin.Current );
                      p.Write( (uint)item.OPLHash );
                 }
            }
            else if ( s.IsMobile )
            {
                 Mobile m = World.FindMobile( s );
                 if ( m != null && m.OPLHash != hash )
                 {
                      m.OPLHash = hash;
                      p.Seek( -4, SeekOrigin.Current );
                      p.Write( (uint)m.OPLHash );
                 }
            }*/
        }

        private static void ClientSingleClick(PacketReader p, PacketHandlerEventArgs args)
        {
            Serial ser = p.ReadUInt32();

            Mobile m = World.FindMobile(ser);

            if (m == null)
                return;

            // if you modify this, don't forget to modify the allnames hotkey
            if (Config.GetBool("LastTargTextFlags"))
                Targeting.CheckTextFlags(m);

            FriendsManager.ShowOverhead(m);
        }

        private static void ClientDoubleClick(PacketReader p, PacketHandlerEventArgs args)
        {
            Serial ser = p.ReadUInt32();
            if (Config.GetBool("BlockDismount") && World.Player != null && ser == World.Player.Serial &&
                World.Player.Warmode && World.Player.GetItemOnLayer(Layer.Mount) != null)
            {
                // mount layer = 0x19
                World.Player.SendMessage(LocString.DismountBlocked);
                args.Block = true;
                return;
            }

            if (Config.GetBool("QueueActions"))
                args.Block = !PlayerData.DoubleClick(ser, false);

            if (ser.IsItem && World.Player != null)
                World.Player.LastObject = ser;

            if (Macros.MacroManager.AcceptActions || ScriptManager.Recording)
            {
                ushort gfx = 0;
                if (ser.IsItem)
                {
                    Item i = World.FindItem(ser);
                    if (i != null)
                        gfx = i.ItemID;
                }
                else
                {
                    Mobile m = World.FindMobile(ser);
                    if (m != null)
                        gfx = m.Body;
                }

                if (gfx != 0)
                {
                    MacroManager.Action(new DoubleClickAction(ser, gfx));

                    ScriptManager.AddToScript($"dclick {ser}");
                }
            }
        }

        private static void DeathAnimation(PacketReader p, PacketHandlerEventArgs args)
        {
            Serial killed = p.ReadUInt32();
            Mobile m = World.FindMobile(killed);

            if (Config.GetBool("CaptureOthersDeath"))
            {
                if (m != null && ((m.Body >= 0x0190 && m.Body <= 0x0193) || (m.Body >= 0x025D && m.Body <= 0x0260)) &&
                    Utility.Distance(World.Player.Position, m.Position) <= 12)
                {
                    if (!string.IsNullOrEmpty(m.Name))
                        ScreenCapManager.LastMobileDeathName = m.Name;

                    ScreenCapManager.DeathCapture(Config.GetDouble("CaptureOthersDeathDelay"));
                }
            }
        }

        private static void ExtendedClientCommand(Packet p, PacketHandlerEventArgs args)
        {
            ushort ext = p.ReadUInt16();
            switch (ext)
            {
                case 0x10: // query object properties
                {
                    break;
                }

                case 0x15: // context menu response
                {
                    UOEntity ent = null;
                    Serial ser = p.ReadUInt32();
                    ushort idx = p.ReadUInt16();

                    if (ser.IsMobile)
                        ent = World.FindMobile(ser);
                    else if (ser.IsItem)
                        ent = World.FindItem(ser);

                    if (ent != null && ent.ContextMenu != null)
                    {
                        if (MacroManager.AcceptActions)
                        {
                            try
                            {
                                MacroManager.Action(new ContextMenuAction(ent, idx, ent.ContextMenu[idx].Value));
                            }
                            catch
                            {
                                // ignored
                            }
                        }

                        if (ScriptManager.Recording)
                        {
                            try
                            {
                                ScriptManager.AddToScript(ent.Serial == World.Player.Serial
                                    ? $"menu 'self' {idx}"
                                    : $"menu {ent.Serial} {idx}");
                            }
                            catch
                            {
                                // ignored
                            }
                        }
                    }

                    break;
                }

                case 0x1C: // cast spell
                {
                    Serial ser = Serial.MinusOne;
                    if (p.ReadUInt16() == 1)
                        ser = p.ReadUInt32();
                    ushort sid = p.ReadUInt16();
                    Spell s = Spell.Get(sid);
                    if (s != null)
                    {
                        s.OnCast(p);
                        args.Block = true;

                        if (Macros.MacroManager.AcceptActions)
                            MacroManager.Action(new ExtCastSpellAction(s, ser));

                        ScriptManager.AddToScript($"cast '{Spell.GetName(sid)}'");
                    }

                    break;
                }

                case 0x24:
                {
                    // for the cheatx0r part 2...  anything outside this range indicates some haxing, just hide it with 0x30s
                    byte b = p.ReadByte();
                    if (b < 0x25 || b >= 0x5E + 0x25)
                    {
                        p.Seek(-1, SeekOrigin.Current);
                        p.Write((byte) 0x30);
                    }

                    //using ( StreamWriter w = new StreamWriter( "bf24.txt", true ) )
                    //	w.WriteLine( "{0} : 0x{1:X2}", Engine.MistedDateTime.ToString( "HH:mm:ss.ffff" ), b );
                    break;
                }
            }
        }

        private static void ClientTextCommand(PacketReader p, PacketHandlerEventArgs args)
        {
            int type = p.ReadByte();
            string command = p.ReadString();

            switch (type)
            {
                case 0x24: // Use skill
                {
                    int skillIndex;

                    try
                    {
                        skillIndex = Convert.ToInt32(command.Split(' ')[0]);
                    }
                    catch
                    {
                        break;
                    }

                    if (World.Player != null)
                        World.Player.LastSkill = skillIndex;

                    if (MacroManager.AcceptActions)
                        MacroManager.Action(new UseSkillAction(skillIndex));

                    if (Skills.SkillsByIndex.TryGetValue(skillIndex, out SkillInfo skill))
                    {
                        ScriptManager.AddToScript($"skill '{skill.Name}'");
                    }

                    if (World.Player != null && (skillIndex == Skills.StealthIndex && !World.Player.Visible))
                        StealthSteps.Hide();

                    SkillTimer.Start();
                    break;
                }

                case 0x27: // Cast spell from book
                {
                    try
                    {
                        string[] split = command.Split(' ');

                        if (split.Length > 0)
                        {
                            ushort spellID = Convert.ToUInt16(split[0]);
                            Serial serial = Convert.ToUInt32(split.Length > 1 ? Utility.ToInt32(split[1], -1) : -1);
                            Spell s = Spell.Get(spellID);
                            if (s != null)
                            {
                                s.OnCast(p);
                                args.Block = true;
                                if (Macros.MacroManager.AcceptActions)
                                    MacroManager.Action(new BookCastSpellAction(s, serial));

                                ScriptManager.AddToScript($"cast '{Spell.GetName(spellID)}'");
                            }
                        }
                    }
                    catch
                    {
                    }

                    break;
                }

                case 0x56: // Cast spell from macro
                {
                    try
                    {
                        ushort spellID = Convert.ToUInt16(command);
                        Spell s = Spell.Get(spellID);
                        if (s != null)
                        {
                            s.OnCast(p);
                            args.Block = true;
                            if (Macros.MacroManager.AcceptActions)
                                MacroManager.Action(new MacroCastSpellAction(s));

                            ScriptManager.AddToScript($"cast '{Spell.GetName(spellID)}'");
                        }
                    }
                    catch
                    {
                    }

                    break;
                }
            }
        }

        public static DateTime PlayCharTime = DateTime.MinValue;

        private static void CreateCharacter(PacketReader p, PacketHandlerEventArgs args)
        {
            p.Seek(1 + 4 + 4 + 1, SeekOrigin.Begin); // skip begining crap
            World.OrigPlayerName = p.ReadStringSafe(30);

            PlayCharTime = DateTime.UtcNow;

            if (Engine.MainWindow != null)
                Engine.MainWindow.SafeAction(s => s.UpdateControlLocks());
        }

        private static void PlayCharacter(PacketReader p, PacketHandlerEventArgs args)
        {
            p.ReadUInt32(); //0xedededed
            World.OrigPlayerName = p.ReadStringSafe(30);

            PlayCharTime = DateTime.UtcNow;

            if (Engine.MainWindow != null)
                Engine.MainWindow.SafeAction(s => s.UpdateControlLocks());

            //Client.TranslateLogin( World.OrigPlayerName, World.ShardName );
        }

        private static void ServerList(PacketReader p, PacketHandlerEventArgs args)
        {
            p.ReadByte(); //unknown
            ushort numServers = p.ReadUInt16();

            for (int i = 0; i < numServers; ++i)
            {
                ushort num = p.ReadUInt16();
                World.Servers[num] = p.ReadString(32);
                p.ReadByte(); // full %
                p.ReadSByte(); // time zone
                p.ReadUInt32(); // ip
            }
        }

        private static void PlayServer(PacketReader p, PacketHandlerEventArgs args)
        {
            ushort index = p.ReadUInt16();
            string name;
            if (World.Servers.TryGetValue(index, out name) && !string.IsNullOrEmpty(name))
                World.ShardName = name;
            else
                World.ShardName = "[Unknown]";
        }

        private static void LiftRequest(PacketReader p, PacketHandlerEventArgs args)
        {
            Serial serial = p.ReadUInt32();
            ushort amount = p.ReadUInt16();

            Item item = World.FindItem(serial);
            ushort iid = 0;

            if (item != null)
                iid = item.ItemID.Value;

            if (Config.GetBool("QueueActions"))
            {
                if (item == null)
                {
                    World.AddItem(item = new Item(serial));
                    item.Amount = amount;
                }

                DragDropManager.Drag(item, amount, true);
                //Client.Instance.SendToClient( new RemoveObject( serial ) ); // remove the object from the client view
                args.Block = true;
            }

            if (Macros.MacroManager.AcceptActions)
            {
                MacroManager.Action(new LiftAction(serial, amount, iid));
                //MacroManager.Action( new PauseAction( TimeSpan.FromMilliseconds( Config.GetInt( "ObjectDelay" ) ) ) );
            }

            ScriptManager.AddToScript($"lift {serial} {amount}");
        }

        private static void LiftReject(PacketReader p, PacketHandlerEventArgs args)
        {
            /*
            if ( ActionQueue.FilterLiftReject() )
                 args.Block = true;
            */
            int reason = p.ReadByte();

            if (!DragDropManager.LiftReject())
                args.Block = true;
            //MacroManager.PlayError( MacroError.LiftRej );
        }

        private static void EquipRequest(PacketReader p, PacketHandlerEventArgs args)
        {
            Serial iser = p.ReadUInt32(); // item being dropped serial
            Layer layer = (Layer) p.ReadByte();
            Serial mser = p.ReadUInt32();

            Item item = World.FindItem(iser);

            if (MacroManager.AcceptActions || ScriptManager.Recording)
            {
                if (layer == Layer.Invalid || layer > Layer.LastValid)
                {
                    if (item != null)
                    {
                        layer = item.Layer;
                        if (layer == Layer.Invalid || layer > Layer.LastValid)
                            layer = (Layer) item.ItemID.ItemData.Quality;
                    }
                }

                if (layer > Layer.Invalid && layer <= Layer.LastUserValid)
                {
                    if (MacroManager.AcceptActions)
                        MacroManager.Action(new DropAction(mser, Point3D.Zero, layer));

                    ScriptManager.AddToScript($"drop {mser} {layer}");
                }
            }

            if (item == null)
                return;

            Mobile m = World.FindMobile(mser);
            if (m == null)
                return;

            if (Config.GetBool("QueueActions"))
                args.Block = DragDropManager.Drop(item, m, layer);
        }

        private static void DropRequest(PacketReader p, PacketHandlerEventArgs args)
        {
            Serial iser = p.ReadUInt32();
            int x = p.ReadInt16();
            int y = p.ReadInt16();
            int z = p.ReadSByte();
            if (Engine.UsePostKRPackets)
                /* grid num */
                p.ReadByte();
            Point3D newPos = new Point3D(x, y, z);
            Serial dser = p.ReadUInt32();

            if (Macros.MacroManager.AcceptActions)
                MacroManager.Action(new DropAction(dser, newPos));

            ScriptManager.AddToScript($"drop {dser} {newPos.X} {newPos.Y} {newPos.Z}");

            Item i = World.FindItem(iser);
            if (i == null)
                return;

            Item dest = World.FindItem(dser);
            if (dest != null && dest.IsContainer && World.Player != null &&
                (dest.IsChildOf(World.Player.Backpack) || dest.IsChildOf(World.Player.Quiver)))
                i.IsNew = true;

            if (Config.GetBool("QueueActions"))
                args.Block = DragDropManager.Drop(i, dser, newPos);
        }

        private static void MovementRequest(Packet p, PacketHandlerEventArgs args)
        {
            if (World.Player != null)
            {
                Direction dir = (Direction) p.ReadByte();
                byte seq = p.ReadByte();

                World.Player.Direction = (dir & Direction.Mask);

                WalkAction.LastWalkTime = DateTime.UtcNow;
                if (MacroManager.AcceptActions)
                    MacroManager.Action(new WalkAction(dir));

                ScriptManager.AddToScript($"walk '{dir}'");
            }
        }

        private static void ContainerContentUpdate(Packet p, PacketHandlerEventArgs args)
        {
            // This function will ignore the item if the container item has not been sent to the client yet.
            // We can do this because we can't really count on getting all of the container info anyway.
            // (So we'd need to request the container be updated, so why bother with the extra stuff required to find the container once its been sent?)
            Serial serial = p.ReadUInt32();
            ushort itemid = p.ReadUInt16();
            itemid = (ushort) (itemid + p.ReadSByte()); // signed, itemID offset
            ushort amount = p.ReadUInt16();
            if (amount == 0)
                amount = 1;
            Point3D pos = new Point3D(p.ReadUInt16(), p.ReadUInt16(), 0);
            byte gridPos = 0;
            if (Engine.UsePostKRPackets)
                gridPos = p.ReadByte();
            Serial cser = p.ReadUInt32();
            ushort hue = p.ReadUInt16();

            Item i = World.FindItem(serial);
            if (i == null)
            {
                if (!serial.IsItem)
                    return;

                World.AddItem(i = new Item(serial));
                i.IsNew = i.AutoStack = true;
            }
            else
            {
                i.CancelRemove();
            }

            if (serial != DragDropManager.Pending)
            {
                if (!DragDropManager.EndHolding(serial))
                    return;
            }

            i.ItemID = itemid;
            i.Amount = amount;
            i.Position = pos;
            i.GridNum = gridPos;
            i.Hue = hue;

            if (SearchExemptionAgent.Contains(i))
            {
                p.Seek(-2, System.IO.SeekOrigin.Current);
                p.Write((short) Config.GetInt("ExemptColor"));
            }

            i.Container = cser;
            if (i.IsNew)
                Item.UpdateContainers();
            if (!SearchExemptionAgent.IsExempt(i) &&
                (i.IsChildOf(World.Player.Backpack) || i.IsChildOf(World.Player.Quiver)))
                Counter.Count(i);
        }

        private static void BeginContainerContent(PacketReader p, PacketHandlerEventArgs args)
        {
            Serial ser = p.ReadUInt32();
            if (!ser.IsItem)
                return;
            Item item = World.FindItem(ser);
            if (item != null)
            {
                if (_ignoreGumps.Contains(item))
                {
                    _ignoreGumps.Remove(item);
                    args.Block = true;
                }
            }
            else
            {
                World.AddItem(new Item(ser));
                Item.UpdateContainers();
            }
        }

        private static void ContainerContent(Packet p, PacketHandlerEventArgs args)
        {
            int count = p.ReadUInt16();

            for (int i = 0; i < count; i++)
            {
                Serial serial = p.ReadUInt32();
                // serial is purposely not checked to be valid, sometimes buy lists dont have "valid" item serials (and we are okay with that).
                Item item = World.FindItem(serial);
                if (item == null)
                {
                    World.AddItem(item = new Item(serial));
                    item.IsNew = true;
                    item.AutoStack = false;
                }
                else
                {
                    item.CancelRemove();
                }

                if (!DragDropManager.EndHolding(serial))
                    continue;

                item.ItemID = p.ReadUInt16();
                item.ItemID = (ushort) (item.ItemID + p.ReadSByte()); // signed, itemID offset
                item.Amount = p.ReadUInt16();
                if (item.Amount == 0)
                    item.Amount = 1;
                item.Position = new Point3D(p.ReadUInt16(), p.ReadUInt16(), 0);
                if (Engine.UsePostKRPackets)
                    item.GridNum = p.ReadByte();
                Serial cont = p.ReadUInt32();
                item.Hue = p.ReadUInt16();
                if (SearchExemptionAgent.Contains(item))
                {
                    p.Seek(-2, System.IO.SeekOrigin.Current);
                    p.Write((short) Config.GetInt("ExemptColor"));
                }

                item.Container = cont; // must be done after hue is set (for counters)
                if (World.Player != null && !SearchExemptionAgent.IsExempt(item) &&
                    (item.IsChildOf(World.Player.Backpack) || item.IsChildOf(World.Player.Quiver)))
                    Counter.Count(item);
            }

            Item.UpdateContainers();
        }

        private static void EquipmentUpdate(Packet p, PacketHandlerEventArgs args)
        {
            Serial serial = p.ReadUInt32();

            Item i = World.FindItem(serial);
            bool isNew = false;
            if (i == null)
            {
                World.AddItem(i = new Item(serial));
                isNew = true;
                Item.UpdateContainers();
            }
            else
            {
                i.CancelRemove();
            }

            if (!DragDropManager.EndHolding(serial))
                return;

            ushort iid = p.ReadUInt16();
            i.ItemID = (ushort) (iid + p.ReadSByte()); // signed, itemID offset
            i.Layer = (Layer) p.ReadByte();
            Serial ser = p.ReadUInt32(); // cont must be set after hue (for counters)
            i.Hue = p.ReadUInt16();

            i.Container = ser;

            int ltHue = Config.GetInt("LTHilight");
            if (ltHue != 0 && Targeting.IsLastTarget(i.Container as Mobile))
            {
                p.Seek(-2, SeekOrigin.Current);
                p.Write((ushort) (ltHue & 0x3FFF));
            }

            if (i.Layer == Layer.Backpack && isNew && Config.GetBool("AutoSearch") && ser == World.Player.Serial)
            {
                _ignoreGumps.Add(i);
                PlayerData.DoubleClick(i);
            }
        }

        private static void SetSkillLock(PacketReader p, PacketHandlerEventArgs args)
        {
            int i = p.ReadUInt16();

            if (i >= 0 && i < Skills.TotalSkills())
            {
                Skill skill = World.Player.Skills[i];

                skill.Lock = (LockType) p.ReadByte();
                Engine.MainWindow.SafeAction(s => s.UpdateSkill(skill));
            }
        }

        private static void PlayerSkills(PacketReader p, PacketHandlerEventArgs args)
        {
            if (World.Player == null || World.Player.Skills == null || Engine.MainWindow == null)
                return;
            byte type = p.ReadByte();

            switch (type)
            {
                case 0x02: //list (with caps, 3.0.8 and up)
                {
                    int i;
                    while ((i = p.ReadUInt16()) > 0)
                    {
                        if (i > 0 && i <= Skills.TotalSkills())
                        {
                            Skill skill = World.Player.Skills[i - 1];

                            if (skill == null)
                                continue;

                            skill.FixedValue = p.ReadUInt16();
                            skill.FixedBase = p.ReadUInt16();
                            skill.Lock = (LockType) p.ReadByte();
                            skill.FixedCap = p.ReadUInt16();
                            if (!World.Player.SkillsSent)
                                skill.Delta = 0;

                            UOAssist.PostSkillUpdate(i - 1, skill.FixedBase);
                        }
                        else
                        {
                            p.Seek(7, SeekOrigin.Current);
                        }
                    }

                    World.Player.SkillsSent = true;
                    Engine.MainWindow.SafeAction(s => s.RedrawSkills());
                    break;
                }

                case 0x00: // list (without caps, older clients)
                {
                    int i;
                    while ((i = p.ReadUInt16()) > 0)
                    {
                        if (i > 0 && i <= Skills.TotalSkills())
                        {
                            Skill skill = World.Player.Skills[i - 1];

                            if (skill == null)
                                continue;

                            skill.FixedValue = p.ReadUInt16();
                            skill.FixedBase = p.ReadUInt16();
                            skill.Lock = (LockType) p.ReadByte();
                            skill.FixedCap = 100; //p.ReadUInt16();
                            if (!World.Player.SkillsSent)
                                skill.Delta = 0;

                            UOAssist.PostSkillUpdate(i - 1, skill.FixedBase);
                        }
                        else
                        {
                            p.Seek(5, SeekOrigin.Current);
                        }
                    }

                    World.Player.SkillsSent = true;
                    Engine.MainWindow.SafeAction(s => s.RedrawSkills());
                    break;
                }

                case 0xDF: //change (with cap, new clients)
                {
                    int i = p.ReadUInt16();

                    if (i >= 0 && i < Skills.TotalSkills())
                    {
                        Skill skill = World.Player.Skills[i];

                        if (skill == null)
                            break;

                        ushort old = skill.FixedBase;
                        skill.FixedValue = p.ReadUInt16();
                        skill.FixedBase = p.ReadUInt16();
                        skill.Lock = (LockType) p.ReadByte();
                        skill.FixedCap = p.ReadUInt16();
                        Engine.MainWindow.SafeAction(s => s.UpdateSkill(skill));

                        //Your skill in {0} has changed by {4}{5:F1}, it is now {3:F1} ({1}{2:F1}).
                        if (Config.GetBool("DisplaySkillChanges") && skill.FixedBase != old)
                        {
                            if (Config.GetBool("DisplaySkillChangesOverhead"))
                            {
                                World.Player.OverheadMessage(LocString.SkillChangeOverhead,
                                    Skills.GetSkillDisplayName(i),
                                    skill.Delta > 0 ? "+" : "", skill.Delta, skill.Value,
                                    skill.FixedBase - old > 0 ? "+" : "",
                                    (skill.FixedBase - old) / 10.0);
                            }
                            else
                            {
                                World.Player.SendMessage(MsgLevel.Force, LocString.SkillChanged,
                                    Skills.GetSkillDisplayName(i),
                                    skill.Delta > 0 ? "+" : "", skill.Delta, skill.Value,
                                    skill.FixedBase - old > 0 ? "+" : "", ((double) (skill.FixedBase - old)) / 10.0);
                            }
                        }

                        UOAssist.PostSkillUpdate(i, skill.FixedBase);
                    }

                    break;
                }

                case 0xFF: //change (without cap, older clients)
                {
                    int i = p.ReadUInt16();

                    if (i >= 0 && i < Skills.TotalSkills())
                    {
                        Skill skill = World.Player.Skills[i];

                        if (skill == null)
                            break;

                        ushort old = skill.FixedBase;
                        skill.FixedValue = p.ReadUInt16();
                        skill.FixedBase = p.ReadUInt16();
                        skill.Lock = (LockType) p.ReadByte();
                        skill.FixedCap = 100;
                        Engine.MainWindow.SafeAction(s => s.UpdateSkill(skill));
                        if (Config.GetBool("DisplaySkillChanges") && skill.FixedBase != old)
                        {
                            if (Config.GetBool("DisplaySkillChangesOverhead"))
                            {
                                World.Player.OverheadMessage(LocString.SkillChangeOverhead,
                                    Skills.GetSkillDisplayName(i),
                                    skill.Delta > 0 ? "+" : "", skill.Delta, skill.Value,
                                    skill.FixedBase - old > 0 ? "+" : "",
                                    (skill.FixedBase - old) / 10.0);
                            }
                            else
                            {
                                World.Player.SendMessage(MsgLevel.Force, LocString.SkillChanged,
                                    Skills.GetSkillDisplayName(i),
                                    skill.Delta > 0 ? "+" : "", skill.Delta, skill.Value,
                                    ((double) (skill.FixedBase - old)) / 10.0, skill.FixedBase - old > 0 ? "+" : "");
                            }
                        }

                        UOAssist.PostSkillUpdate(i, skill.FixedBase);
                    }

                    break;
                }
            }
        }

        private static void LoginConfirm(PacketReader p, PacketHandlerEventArgs args)
        {
            World.Items.Clear();
            World.Mobiles.Clear();

            UseNewStatus = false;

            Serial serial = p.ReadUInt32();

            PlayerData m = new PlayerData(serial);
            m.Name = World.OrigPlayerName;

            Mobile test = World.FindMobile(serial);
            if (test != null)
                test.Remove();

            World.AddMobile(World.Player = m);
            Config.LoadProfileFor(World.Player);

            p.ReadUInt32(); // always 0?
            m.Body = p.ReadUInt16();
            m.Position = new Point3D(p.ReadUInt16(), p.ReadUInt16(), p.ReadInt16());
            m.Direction = (Direction) p.ReadByte();

            Client.Instance.RequestTitlebarUpdate();
            UOAssist.PostLogin((int) serial.Value);
            Engine.MainWindow.SafeAction(s => s.UpdateTitle()); // update player name & shard name

            Client.Instance.SetPosition((uint) m.Position.X, (uint) m.Position.Y, (uint) m.Position.Z,
                (byte) m.Direction);

            if (World.Player != null)
                World.Player.SetSeason();
            
            ScriptManager.OnLogin();
        }

        private static void CompleteLogin(PacketReader p, PacketHandlerEventArgs args)
        {
            // Set the default min light level if they have limits set
            if (World.Player != null)
                EnforceLightLevels(-1);
        }

        private static void MobileMoving(Packet p, PacketHandlerEventArgs args)
        {
            Serial serial = p.ReadUInt32();
            Mobile m = World.FindMobile(serial);

            if (m == null)
            {
                World.AddMobile(m = new Mobile(serial));
                World.RequestMobileStatus(m);
            }

            if (m != null)
            {
                m.Body = p.ReadUInt16();

                MobileFilter.Apply(p, m);

                m.Position = new Point3D(p.ReadUInt16(), p.ReadUInt16(), p.ReadSByte());

                if (World.Player != null && !Utility.InRange(World.Player.Position, m.Position, World.Player.VisRange))
                {
                    m.Remove();
                    return;
                }

                Targeting.CheckLastTargetRange(m);

                m.Direction = (Direction) p.ReadByte();
                m.Hue = p.ReadUInt16();
                int ltHue = Config.GetInt("LTHilight");
                if (ltHue != 0 && Targeting.IsLastTarget(m))
                {
                    p.Seek(-2, SeekOrigin.Current);
                    p.Write((short) (ltHue | 0x8000));
                }

                bool wasPoisoned = m.Poisoned;
                m.ProcessPacketFlags(p.ReadByte());
                byte oldNoto = m.Notoriety;
                m.Notoriety = p.ReadByte();

                if (m == World.Player)
                {
                    Client.Instance.SetPosition((uint) m.Position.X, (uint) m.Position.Y, (uint) m.Position.Z,
                        (byte) m.Direction);

                    if (wasPoisoned != m.Poisoned || (oldNoto != m.Notoriety && Config.GetBool("ShowNotoHue")))
                        Client.Instance.RequestTitlebarUpdate();
                }
            }
        }

        private static readonly int[] HealthHues = new int[] {428, 333, 37, 44, 49, 53, 158, 263, 368, 473, 578};

        private static void HitsUpdate(PacketReader p, PacketHandlerEventArgs args)
        {
            Mobile m = World.FindMobile(p.ReadUInt32());

            if (m != null)
            {
                int oldPercent = (int) (m.Hits * 100 / (m.HitsMax == 0 ? (ushort) 1 : m.HitsMax));

                m.HitsMax = p.ReadUInt16();
                m.Hits = p.ReadUInt16();

                if (m == World.Player)
                {
                    Client.Instance.RequestTitlebarUpdate();
                    UOAssist.PostHitsUpdate();
                }

                if (Client.Instance.AllowBit(FeatureBit.OverheadHealth) && Config.GetBool("ShowHealth"))
                {
                    int percent = (int) (m.Hits * 100 / (m.HitsMax == 0 ? (ushort) 1 : m.HitsMax));

                    // Limit to people who are on screen and check the previous value so we dont get spammed.
                    if (oldPercent != percent && World.Player != null &&
                        Utility.Distance(World.Player.Position, m.Position) <= 12)
                    {
                        try
                        {
                            m.OverheadMessageFrom(HealthHues[((percent + 5) / 10) % HealthHues.Length],
                                m.Name ?? string.Empty,
                                Config.GetString("HealthFmt"), percent);
                        }
                        catch
                        {
                        }
                    }
                }
            }
        }

        private static void StamUpdate(PacketReader p, PacketHandlerEventArgs args)
        {
            Mobile m = World.FindMobile(p.ReadUInt32());

            if (m != null)
            {
                int oldPercent = (int) (m.Stam * 100 / (m.StamMax == 0 ? (ushort) 1 : m.StamMax));

                m.StamMax = p.ReadUInt16();
                m.Stam = p.ReadUInt16();

                if (m == World.Player)
                {
                    Client.Instance.RequestTitlebarUpdate();
                    UOAssist.PostStamUpdate();
                }

                if (m != World.Player && Client.Instance.AllowBit(FeatureBit.OverheadHealth) &&
                    Config.GetBool("ShowPartyStats"))
                {
                    int stamPercent = (int) (m.Stam * 100 / (m.StamMax == 0 ? (ushort) 1 : m.StamMax));
                    int manaPercent = (int) (m.Mana * 100 / (m.ManaMax == 0 ? (ushort) 1 : m.ManaMax));

                    // Limit to people who are on screen and check the previous value so we dont get spammed.
                    if (oldPercent != stamPercent && World.Player != null &&
                        Utility.Distance(World.Player.Position, m.Position) <= 12)
                    {
                        try
                        {
                            m.OverheadMessageFrom(0x63,
                                m.Name ?? string.Empty,
                                Config.GetString("PartyStatFmt"), manaPercent, stamPercent);
                        }
                        catch
                        {
                        }
                    }
                }
            }
        }

        private static void ManaUpdate(PacketReader p, PacketHandlerEventArgs args)
        {
            Mobile m = World.FindMobile(p.ReadUInt32());

            if (m != null)
            {
                int oldPercent = (int) (m.Mana * 100 / (m.ManaMax == 0 ? (ushort) 1 : m.ManaMax));

                m.ManaMax = p.ReadUInt16();
                m.Mana = p.ReadUInt16();

                if (m == World.Player)
                {
                    Client.Instance.RequestTitlebarUpdate();
                    UOAssist.PostManaUpdate();
                }

                if (m != World.Player && Client.Instance.AllowBit(FeatureBit.OverheadHealth) &&
                    Config.GetBool("ShowPartyStats"))
                {
                    int stamPercent = (int) (m.Stam * 100 / (m.StamMax == 0 ? (ushort) 1 : m.StamMax));
                    int manaPercent = (int) (m.Mana * 100 / (m.ManaMax == 0 ? (ushort) 1 : m.ManaMax));

                    // Limit to people who are on screen and check the previous value so we dont get spammed.
                    if (oldPercent != manaPercent && World.Player != null &&
                        Utility.Distance(World.Player.Position, m.Position) <= 12)
                    {
                        try
                        {
                            m.OverheadMessageFrom(0x63,
                                Language.Format(LocString.sStatsA1, m.Name),
                                Config.GetString("PartyStatFmt"), manaPercent, stamPercent);
                        }
                        catch
                        {
                        }
                    }
                }
            }
        }

        private static void MobileStatInfo(PacketReader pvSrc, PacketHandlerEventArgs args)
        {
            Mobile m = World.FindMobile(pvSrc.ReadUInt32());
            if (m == null)
                return;
            PlayerData p = World.Player;

            m.HitsMax = pvSrc.ReadUInt16();
            m.Hits = pvSrc.ReadUInt16();

            m.ManaMax = pvSrc.ReadUInt16();
            m.Mana = pvSrc.ReadUInt16();

            m.StamMax = pvSrc.ReadUInt16();
            m.Stam = pvSrc.ReadUInt16();

            if (m == World.Player)
            {
                Client.Instance.RequestTitlebarUpdate();
                UOAssist.PostHitsUpdate();
                UOAssist.PostStamUpdate();
                UOAssist.PostManaUpdate();
            }
        }

        public static bool UseNewStatus = false;

        private static void NewMobileStatus(PacketReader p, PacketHandlerEventArgs args)
        {
            Mobile m = World.FindMobile((Serial) p.ReadUInt32());

            if (m == null)
                return;

            UseNewStatus = true;

            // 00 01
            p.ReadUInt16();

            // 00 01 Poison
            // 00 02 Yellow Health Bar

            ushort id = p.ReadUInt16();

            // 00 Off
            // 01 On
            // For Poison: Poison Level + 1

            byte flag = p.ReadByte();

            if (id == 1)
            {
                bool wasPoisoned = m.Poisoned;
                m.Poisoned = (flag != 0);

                if (m == World.Player && wasPoisoned != m.Poisoned)
                    Client.Instance.RequestTitlebarUpdate();
            }
        }

        private static void Damage(PacketReader p, PacketHandlerEventArgs args)
        {
            uint serial = p.ReadUInt32();
            ushort damage = p.ReadUInt16();

            if (Config.GetBool("ShowDamageTaken") || Config.GetBool("ShowDamageDealt"))
            {
                if (serial == World.Player.Serial && Config.GetBool("ShowDamageTaken"))
                {
                    if (Config.GetBool("ShowDamageTakenOverhead"))
                    {
                        World.Player.OverheadMessage(37, $"[{damage}]", true);
                    }
                    else
                    {
                        World.Player.SendMessage(MsgLevel.Info, $"{World.Player.Name}: {damage} damage taken");
                    }
                }
                else if (Config.GetBool("ShowDamageDealt"))
                {
                    Mobile m = World.FindMobile(serial);

                    if (m == null)
                        return;

                    if (Config.GetBool("ShowDamageDealtOverhead"))
                    {
                        m.OverheadMessageFrom(37, m.Name, $"[{damage}]", true);
                    }
                    else
                    {
                        World.Player.SendMessage(MsgLevel.Info, $"{World.Player.Name}: {damage} damage on '{m.Name}'");
                    }
                }
            }

            if (DamageTracker.Running)
                DamageTracker.AddDamage(serial, damage);
        }

        private static void MobileStatus(PacketReader p, PacketHandlerEventArgs args)
        {
            Serial serial = p.ReadUInt32();
            Mobile m = World.FindMobile(serial);
            if (m == null)
                World.AddMobile(m = new Mobile(serial));

            m.Name = p.ReadString(30);

            m.Hits = p.ReadUInt16();
            m.HitsMax = p.ReadUInt16();

            //p.ReadBoolean();//CanBeRenamed
            if (p.ReadBoolean())
                m.CanRename = true;

            byte type = p.ReadByte();

            if (m == World.Player && type != 0x00)
            {
                PlayerData player = (PlayerData) m;

                player.Female = p.ReadBoolean();

                int oStr = player.Str, oDex = player.Dex, oInt = player.Int;

                player.Str = p.ReadUInt16();
                player.Dex = p.ReadUInt16();
                player.Int = p.ReadUInt16();

                //Your strength has changed by {0}{1}, it is now {2}.
                if (player.Str != oStr && oStr != 0 && Config.GetBool("DisplaySkillChanges"))
                {
                    if (Config.GetBool("DisplaySkillChangesOverhead"))
                    {
                        World.Player.OverheadMessage(LocString.StrChangeOverhead, player.Str - oStr > 0 ? "+" : "",
                            player.Str - oStr, player.Str);
                    }
                    else
                    {
                        World.Player.SendMessage(MsgLevel.Force, LocString.StrChanged, player.Str - oStr > 0 ? "+" : "",
                            player.Str - oStr, player.Str);
                    }
                }

                if (player.Dex != oDex && oDex != 0 && Config.GetBool("DisplaySkillChanges"))
                {
                    if (Config.GetBool("DisplaySkillChangesOverhead"))
                    {
                        World.Player.OverheadMessage(LocString.DexChangeOverhead, player.Dex - oDex > 0 ? "+" : "",
                            player.Dex - oDex, player.Dex);
                    }
                    else
                    {
                        World.Player.SendMessage(MsgLevel.Force, LocString.DexChanged, player.Dex - oDex > 0 ? "+" : "",
                            player.Dex - oDex, player.Dex);
                    }
                }

                if (player.Int != oInt && oInt != 0 && Config.GetBool("DisplaySkillChanges"))
                {
                    if (Config.GetBool("DisplaySkillChangesOverhead"))
                    {
                        World.Player.OverheadMessage(LocString.IntChangeOverhead, player.Int - oInt > 0 ? "+" : "",
                            player.Int - oInt, player.Int);
                    }
                    else
                    {
                        World.Player.SendMessage(MsgLevel.Force, LocString.IntChanged, player.Int - oInt > 0 ? "+" : "",
                            player.Int - oInt, player.Int);
                    }
                }

                player.Stam = p.ReadUInt16();
                player.StamMax = p.ReadUInt16();
                player.Mana = p.ReadUInt16();
                player.ManaMax = p.ReadUInt16();

                player.Gold = p.ReadUInt32();
                player.AR = p.ReadUInt16(); // ar / physical resist
                player.Weight = p.ReadUInt16();

                if (type >= 0x03)
                {
                    if (type > 0x04)
                    {
                        player.MaxWeight = p.ReadUInt16();

                        p.ReadByte(); // race?
                    }

                    player.StatCap = p.ReadUInt16();

                    player.Followers = p.ReadByte();
                    player.FollowersMax = p.ReadByte();

                    if (type > 0x03)
                    {
                        player.FireResistance = p.ReadInt16();
                        player.ColdResistance = p.ReadInt16();
                        player.PoisonResistance = p.ReadInt16();
                        player.EnergyResistance = p.ReadInt16();

                        player.Luck = p.ReadInt16();

                        player.DamageMin = p.ReadUInt16();
                        player.DamageMin = p.ReadUInt16();
                        player.DamageMax = p.ReadUInt16();

                        player.Tithe = p.ReadInt32();
                    }
                }

                Client.Instance.RequestTitlebarUpdate();

                UOAssist.PostHitsUpdate();
                UOAssist.PostStamUpdate();
                UOAssist.PostManaUpdate();

                Engine.MainWindow.SafeAction(s => s.UpdateTitle()); // update player name
            }
        }

        private static void MobileUpdate(Packet p, PacketHandlerEventArgs args)
        {
            if (World.Player == null)
                return;

            Serial serial = p.ReadUInt32();
            Mobile m = World.FindMobile(serial);
            if (m == null)
                World.AddMobile(m = new Mobile(serial));

            bool wasHidden = !m.Visible;

            m.Body = (ushort) (p.ReadUInt16() + p.ReadSByte());
            m.Hue = p.ReadUInt16();
            int ltHue = Config.GetInt("LTHilight");
            if (ltHue != 0 && Targeting.IsLastTarget(m))
            {
                p.Seek(-2, SeekOrigin.Current);
                p.Write((ushort) (ltHue | 0x8000));
            }

            bool wasPoisoned = m.Poisoned;
            m.ProcessPacketFlags(p.ReadByte());

            ushort x = p.ReadUInt16();
            ushort y = p.ReadUInt16();
            p.ReadUInt16(); //always 0?
            m.Direction = (Direction) p.ReadByte();
            m.Position = new Point3D(x, y, p.ReadSByte());

            if (m == World.Player)
            {
                Client.Instance.SetPosition((uint) m.Position.X, (uint) m.Position.Y, (uint) m.Position.Z,
                    (byte) m.Direction);

                if (!wasHidden && !m.Visible)
                {
                    if (Config.GetBool("CountStealthSteps"))
                        StealthSteps.Hide();
                }
                else if (wasHidden && m.Visible)
                {
                    StealthSteps.Unhide();
                }

                if (wasPoisoned != m.Poisoned)
                    Client.Instance.RequestTitlebarUpdate();
            }

            Item.UpdateContainers();
        }

        private static void MobileIncoming(Packet p, PacketHandlerEventArgs args)
        {
            if (World.Player == null)
                return;

            Serial serial = p.ReadUInt32();
            ushort body = p.ReadUInt16();

            Mobile m = World.FindMobile(serial);

            if (m == null)
            {
                World.AddMobile(m = new Mobile(serial));

                if (m != World.Player && Config.GetBool("ShowMobNames"))
                    Client.Instance.SendToServer(new SingleClick(m));

                if (Config.GetBool("LastTargTextFlags"))
                    Targeting.CheckTextFlags(m);
            }

            MobileFilter.Apply(p, body);

            Point3D position = new Point3D(p.ReadUInt16(), p.ReadUInt16(), p.ReadSByte());

            bool wasHidden = !m.Visible;

            int ltHue = Config.GetInt("LTHilight");
            bool isLT;
            if (ltHue != 0)
                isLT = Targeting.IsLastTarget(m);
            else
                isLT = false;

            m.Body = body;
            if (m != World.Player)
                m.Position = position;
            m.Direction = (Direction) p.ReadByte();
            m.Hue = p.ReadUInt16();
            if (isLT)
            {
                p.Seek(-2, SeekOrigin.Current);
                p.Write((short) (ltHue | 0x8000));
            }

            bool wasPoisoned = m.Poisoned;
            m.ProcessPacketFlags(p.ReadByte());
            byte oldNoto = m.Notoriety;
            m.Notoriety = p.ReadByte();

            if (m == World.Player)
            {
                if (!wasHidden && !m.Visible)
                {
                    if (Config.GetBool("CountStealthSteps"))
                        StealthSteps.Hide();
                }
                else if (wasHidden && m.Visible)
                {
                    StealthSteps.Unhide();
                }

                if (wasPoisoned != m.Poisoned || (oldNoto != m.Notoriety && Config.GetBool("ShowNotoHue")))
                    Client.Instance.RequestTitlebarUpdate();
            }

            while (true)
            {
                serial = p.ReadUInt32();
                if (!serial.IsItem)
                    break;

                Item item = World.FindItem(serial);
                bool isNew = false;
                if (item == null)
                {
                    isNew = true;
                    World.AddItem(item = new Item(serial));
                }

                if (!DragDropManager.EndHolding(serial))
                    continue;

                item.Container = m;

                ushort id = p.ReadUInt16();

                if (Engine.UseNewMobileIncoming)
                    item.ItemID = (ushort) (id & 0xFFFF);
                else if (Engine.UsePostSAChanges)
                    item.ItemID = (ushort) (id & 0x7FFF);
                else
                    item.ItemID = (ushort) (id & 0x3FFF);

                item.Layer = (Layer) p.ReadByte();

                if (Engine.UseNewMobileIncoming)
                {
                    item.Hue = p.ReadUInt16();
                    if (isLT)
                    {
                        p.Seek(-2, SeekOrigin.Current);
                        p.Write((short) (ltHue & 0x3FFF));
                    }
                }
                else
                {
                    if ((id & 0x8000) != 0)
                    {
                        item.Hue = p.ReadUInt16();
                        if (isLT)
                        {
                            p.Seek(-2, SeekOrigin.Current);
                            p.Write((short) (ltHue & 0x3FFF));
                        }
                    }
                    else
                    {
                        item.Hue = 0;
                        if (isLT)
                            Client.Instance.SendToClient(new EquipmentItem(item, (ushort) (ltHue & 0x3FFF), m.Serial));
                    }
                }

                if (item.Layer == Layer.Backpack && isNew && Config.GetBool("AutoSearch") && m == World.Player &&
                    m != null)
                {
                    _ignoreGumps.Add(item);
                    PlayerData.DoubleClick(item);
                }
            }

            Item.UpdateContainers();
        }

        private static void RemoveObject(PacketReader p, PacketHandlerEventArgs args)
        {
            Serial serial = p.ReadUInt32();

            if (serial.IsMobile)
            {
                Mobile m = World.FindMobile(serial);
                if (m != null && m != World.Player)
                    m.Remove();
            }
            else if (serial.IsItem)
            {
                Item i = World.FindItem(serial);
                if (i != null)
                {
                    if (DragDropManager.Holding == i)
                    {
                        Counter.SupressWarnings = true;
                        i.Container = null;
                        Counter.SupressWarnings = false;
                    }
                    else
                    {
                        i.RemoveRequest();
                    }
                }
            }
        }

        private static void ServerChange(PacketReader p, PacketHandlerEventArgs args)
        {
            if (World.Player != null)
                World.Player.Position = new Point3D(p.ReadUInt16(), p.ReadUInt16(), p.ReadInt16());
        }

        private static void WorldItem(PacketReader p, PacketHandlerEventArgs args)
        {
            Item item;
            uint serial = p.ReadUInt32();
            item = World.FindItem(serial & 0x7FFFFFFF);
            bool isNew = false;
            if (item == null)
            {
                World.AddItem(item = new Item(serial & 0x7FFFFFFF));
                isNew = true;
            }
            else
            {
                item.CancelRemove();
            }

            if (!DragDropManager.EndHolding(serial))
                return;

            item.Container = null;
            Counter.Uncount(item);

            ushort itemID = p.ReadUInt16();
            item.ItemID = (ushort) (itemID & 0x7FFF);

            if ((serial & 0x80000000) != 0)
                item.Amount = p.ReadUInt16();
            else
                item.Amount = 1;

            if ((itemID & 0x8000) != 0)
                item.ItemID = (ushort) (item.ItemID + p.ReadSByte());

            ushort x = p.ReadUInt16();
            ushort y = p.ReadUInt16();

            if ((x & 0x8000) != 0)
                item.Direction = p.ReadByte();
            else
                item.Direction = 0;

            short z = p.ReadSByte();

            item.Position = new Point3D(x & 0x7FFF, y & 0x3FFF, z);

            if ((y & 0x8000) != 0)
                item.Hue = p.ReadUInt16();
            else
                item.Hue = 0;

            byte flags = 0;
            if ((y & 0x4000) != 0)
                flags = p.ReadByte();

            item.ProcessPacketFlags(flags);

            if (isNew && World.Player != null)
            {
                if (item.ItemID == 0x2006) // corpse itemid = 0x2006
                {
                    if (Config.GetBool("ShowCorpseNames"))
                        Client.Instance.SendToServer(new SingleClick(item));

                    if (Config.GetBool("AutoOpenCorpses") &&
                        Utility.InRange(item.Position, World.Player.Position, Config.GetInt("CorpseRange")) &&
                        World.Player != null && World.Player.Visible)
                    {
                        if (Config.GetBool("BlockOpenCorpsesTwice"))
                        {
                            bool blockOpen = false;
                            foreach (uint openedCorse in World.Player.OpenedCorpses)
                            {
                                if (openedCorse == serial)
                                {
                                    blockOpen = true;
                                    break;
                                }
                            }

                            if (World.Player.OpenedCorpses.Count > 2000)
                            {
                                World.Player.OpenedCorpses.RemoveRange(0, 500);
                            }

                            if (!blockOpen)
                            {
                                PlayerData.DoubleClick(item);
                            }

                            if (!World.Player.OpenedCorpses.Contains(serial))
                            {
                                World.Player.OpenedCorpses.Add(serial);
                            }
                        }
                        else
                        {
                            PlayerData.DoubleClick(item);
                        }
                    }
                }
                else if (item.IsMulti)
                {
                    UOAssist.PostAddMulti(item.ItemID, item.Position);
                }
                else
                {
                    ScavengerAgent s = ScavengerAgent.Instance;
                    int dist = Utility.Distance(item.GetWorldPosition(), World.Player.Position);
                    if (!World.Player.IsGhost && World.Player.Visible && dist <= 2 && s.Enabled && item.Movable)
                        s.Scavenge(item);
                }
            }

            Item.UpdateContainers();

            if (Config.GetBool("ShowStaticWalls"))
                args.Block = WallStaticFilter.MakeWallStatic(item);
        }

        private static void SAWorldItem(PacketReader p, PacketHandlerEventArgs args)
        {
            /*
            New World Item Packet
            PacketID: 0xF3
            PacketLen: 24
            Format:

                 BYTE - 0xF3 packetId
                 WORD - 0x01
                 BYTE - ArtDataID: 0x00 if the item uses art from TileData table, 0x02 if the item uses art from MultiData table)
                 DWORD - item Serial
                 WORD - item ID
                 BYTE - item direction (same as old)
                 WORD - amount
                 WORD - amount
                 WORD - X
                 WORD - Y
                 SBYTE - Z
                 BYTE - item light
                 WORD - item Hue
                 BYTE - item flags (same as old packet)
            */

            // Post-7.0.9.0
            /*
            New World Item Packet
            PacketID: 0xF3
            PacketLen: 26
            Format:

                 BYTE - 0xF3 packetId
                 WORD - 0x01
                 BYTE - ArtDataID: 0x00 if the item uses art from TileData table, 0x02 if the item uses art from MultiData table)
                 DWORD - item Serial
                 WORD - item ID
                 BYTE - item direction (same as old)
                 WORD - amount
                 WORD - amount
                 WORD - X
                 WORD - Y
                 SBYTE - Z
                 BYTE - item light
                 WORD - item Hue
                 BYTE - item flags (same as old packet)
                 WORD ???
            */

            ushort _unk1 = p.ReadUInt16();

            byte _artDataID = p.ReadByte();

            Item item;
            uint serial = p.ReadUInt32();
            item = World.FindItem(serial);
            bool isNew = false;
            if (item == null)
            {
                World.AddItem(item = new Item(serial));
                isNew = true;
            }
            else
            {
                item.CancelRemove();
            }

            if (!DragDropManager.EndHolding(serial))
                return;

            item.Container = null;
            Counter.Uncount(item);

            ushort itemID = p.ReadUInt16();
            item.ItemID = (ushort) (_artDataID == 0x02 ? itemID | 0x4000 : itemID);

            item.Direction = p.ReadByte();

            ushort _amount = p.ReadUInt16();
            item.Amount = _amount = p.ReadUInt16();

            ushort x = p.ReadUInt16();
            ushort y = p.ReadUInt16();
            short z = p.ReadSByte();

            item.Position = new Point3D(x, y, z);

            byte _light = p.ReadByte();

            item.Hue = p.ReadUInt16();

            byte flags = p.ReadByte();

            item.ProcessPacketFlags(flags);

            if (Engine.UsePostHSChanges)
            {
                p.ReadUInt16();
            }

            if (isNew && World.Player != null)
            {
                if (item.ItemID == 0x2006) // corpse itemid = 0x2006
                {
                    if (Config.GetBool("ShowCorpseNames"))
                        Client.Instance.SendToServer(new SingleClick(item));
                    if (Config.GetBool("AutoOpenCorpses") &&
                        Utility.InRange(item.Position, World.Player.Position, Config.GetInt("CorpseRange")) &&
                        World.Player != null && World.Player.Visible)
                        PlayerData.DoubleClick(item);
                }
                else if (item.IsMulti)
                {
                    UOAssist.PostAddMulti(item.ItemID, item.Position);
                }
                else
                {
                    ScavengerAgent s = ScavengerAgent.Instance;
                    int dist = Utility.Distance(item.GetWorldPosition(), World.Player.Position);
                    if (!World.Player.IsGhost && World.Player.Visible && dist <= 2 && s.Enabled && item.Movable)
                        s.Scavenge(item);
                }
            }

            Item.UpdateContainers();

            if (Config.GetBool("ShowStaticWalls"))
                args.Block = WallStaticFilter.MakeWallStatic(item);
        }

        public static System.Text.StringBuilder SpellPowerwordsBuilder { get; set; } =
            new System.Text.StringBuilder(Config.GetString("SpellFormat"));

        private static void ResetSpellPowerwordsBuilder()
        {
            SpellPowerwordsBuilder.Remove(0, SpellPowerwordsBuilder.Length);
            SpellPowerwordsBuilder.Insert(0, Config.GetString("SpellFormat"));
        }

        public static void AsciiSpeech(Packet p, PacketHandlerEventArgs args)
        {
            // 0, 1, 2
            Serial serial = p.ReadUInt32(); // 3, 4, 5, 6
            ushort body = p.ReadUInt16(); // 7, 8
            MessageType type = (MessageType) p.ReadByte(); // 9
            ushort hue = p.ReadUInt16(); // 10, 11
            ushort font = p.ReadUInt16();
            string name = p.ReadStringSafe(30);
            string text = p.ReadStringSafe();

            if (World.Player != null && serial == Serial.Zero && body == 0 && type == MessageType.Regular &&
                hue == 0xFFFF && font == 0xFFFF && name == "SYSTEM")
            {
                args.Block = true;

                Client.Instance.SendToServer(new ACKTalk());
            }
            else
            {
                MessageManager.HandleMessage(p, args, serial, body, type, hue, font, "A", name, text);
            }
        }

        public static void UnicodeSpeech(Packet p, PacketHandlerEventArgs args)
        {
            // 0, 1, 2
            Serial serial = p.ReadUInt32(); // 3, 4, 5, 6
            ushort body = p.ReadUInt16(); // 7, 8
            MessageType type = (MessageType) p.ReadByte(); // 9
            ushort hue = p.ReadUInt16(); // 10, 11
            ushort font = p.ReadUInt16();
            string lang = p.ReadStringSafe(4);
            string name = p.ReadStringSafe(30);
            string text = p.ReadUnicodeStringSafe();

            MessageManager.HandleMessage(p, args, serial, body, type, hue, font, lang, name, text);
        }

        private static void OnLocalizedMessage(Packet p, PacketHandlerEventArgs args)
        {
            // 0, 1, 2
            Serial serial = p.ReadUInt32(); // 3, 4, 5, 6
            ushort body = p.ReadUInt16(); // 7, 8
            MessageType type = (MessageType) p.ReadByte(); // 9
            ushort hue = p.ReadUInt16(); // 10, 11
            ushort font = p.ReadUInt16();
            int num = p.ReadInt32();
            string name = p.ReadStringSafe(30);
            string ext_str = p.ReadUnicodeStringLESafe();

            if ((num >= 3002011 && num < 3002011 + 64) || // reg spells
                (num >= 1060509 && num < 1060509 + 16) || // necro
                (num >= 1060585 && num < 1060585 + 10) || // chiv
                (num >= 1060493 && num < 1060493 + 10) || // chiv
                (num >= 1060595 && num < 1060595 + 6) || // bush
                (num >= 1060610 && num < 1060610 + 8)) // ninj
            {
                type = MessageType.Spell;
            }
            
            try
            {
                string text = Language.ClilocFormat(num, ext_str);
                MessageManager.HandleMessage(p, args, serial, body, type, hue, font, Language.CliLocName.ToUpper(),
                    name, text);
            }
            catch (Exception e)
            {
                Engine.LogCrash(new Exception($"Exception in Ultima.dll cliloc: {num}, {ext_str}", e));
            }
        }

        private static void OnLocalizedMessageAffix(Packet p, PacketHandlerEventArgs phea)
        {
            // 0, 1, 2
            Serial serial = p.ReadUInt32(); // 3, 4, 5, 6
            ushort body = p.ReadUInt16(); // 7, 8
            MessageType type = (MessageType) p.ReadByte(); // 9
            ushort hue = p.ReadUInt16(); // 10, 11
            ushort font = p.ReadUInt16();
            int num = p.ReadInt32();
            byte affixType = p.ReadByte();
            string name = p.ReadStringSafe(30);
            string affix = p.ReadStringSafe();
            string args = p.ReadUnicodeStringSafe();

            if ((num >= 3002011 && num < 3002011 + 64) || // reg spells
                (num >= 1060509 && num < 1060509 + 16) || // necro
                (num >= 1060585 && num < 1060585 + 10) || // chiv
                (num >= 1060493 && num < 1060493 + 10) || // chiv
                (num >= 1060595 && num < 1060595 + 6) || // bush
                (num >= 1060610 && num < 1060610 + 8) // ninj
               )
            {
                type = MessageType.Spell;
            }

            string text;
            if ((affixType & 1) != 0) // prepend
            {
                text = $"{affix}{Language.ClilocFormat(num, args)}";
            }
            else // 0 == append, 2 = system
            {
                text = $"{Language.ClilocFormat(num, args)}{affix}";
            }

            MessageManager.HandleMessage(p, phea, serial, body, type, hue, font, Language.CliLocName.ToUpper(), name,
                text);
        }

        private static void SendGump(PacketReader p, PacketHandlerEventArgs args)
        {
            if (World.Player == null)
                return;

            World.Player.CurrentGumpS = p.ReadUInt32();
            World.Player.CurrentGumpI = p.ReadUInt32();
            World.Player.HasGump = true;

            if (!World.Player.GumpList.TryGetValue(World.Player.CurrentGumpI, out PlayerData.GumpInfo _))
            {
                World.Player.GumpList.Add(World.Player.CurrentGumpI, new PlayerData.GumpInfo(World.Player.CurrentGumpS, World.Player.CurrentGumpI));
            }

            if (Macros.MacroManager.AcceptActions &&
                MacroManager.Action(new WaitForGumpAction(World.Player.CurrentGumpI)))
                args.Block = true;

            ScriptManager.AddToScript($"waitforgump {World.Player.CurrentGumpI} 10000");
        }

        private static void ClientGumpResponse(PacketReader p, PacketHandlerEventArgs args)
        {
            if (World.Player == null)
                return;

            Serial ser = p.ReadUInt32();
            uint gumpId = p.ReadUInt32();
            int buttonId = p.ReadInt32();

            World.Player.GumpList.Remove(gumpId);

            World.Player.HasGump = false;
            World.Player.HasCompressedGump = false;

            int switchCount = p.ReadInt32();
            if (switchCount < 0 || switchCount > 2000)
                return;

            int[] switches = new int[switchCount];
            for (int i = 0; i < switchCount; i++)
                switches[i] = p.ReadInt32();

            int ec = p.ReadInt32();
            if (ec < 0 || ec > 2000)
                return;

            GumpTextEntry[] entries = new GumpTextEntry[ec];
            for (int i = 0; i < ec; i++)
            {
                ushort id = p.ReadUInt16();
                ushort len = p.ReadUInt16();
                if (len >= 240)
                    return;
                string text = p.ReadUnicodeStringSafe(len);
                entries[i] = new GumpTextEntry(id, text);
            }

            if (World.Player.InternalGumps.GetGump(gumpId, out Gump gump))
            {
                World.Player.InternalGumps.Remove(gumpId, buttonId, switches, entries);
            }

            if (Macros.MacroManager.AcceptActions)
                MacroManager.Action(new GumpResponseAction(buttonId, switches, entries));

            ScriptManager.AddToScript(buttonId == 0 ? "gumpclose" : $"gumpresponse {buttonId}");


            World.Player.LastGumpResponseAction = new GumpResponseAction(buttonId, switches, entries);
        }

        private static void ChangeSeason(PacketReader p, PacketHandlerEventArgs args)
        {
            if (World.Player != null)
            {
                byte season = p.ReadByte();
                World.Player.SetSeason(season);
            }
        }

        private static void OnAssistVersion(Packet p, PacketHandlerEventArgs args)
        {
            args.Block = true;

            Client.Instance.ForceSendToServer(new AssistVersion());
        }

        private static void ExtendedPacket(PacketReader p, PacketHandlerEventArgs args)
        {
            ushort type = p.ReadUInt16();

            switch (type)
            {
                case 0x04: // close gump
                {
                    // int serial, int tid
                    if (World.Player != null)
                    {
                        uint gumpId = p.ReadUInt32();

                        World.Player.GumpList.Remove(gumpId);
                        World.Player.HasGump = false;
                        World.Player.HasCompressedGump = false;
                    }

                    break;
                }

                case 0x06: // party messages
                {
                    OnPartyMessage(p, args);
                    break;
                }

                case 0x08: // map change
                {
                    if (World.Player != null)
                        World.Player.Map = p.ReadByte();
                    break;
                }

                case 0x14: // context menu
                {
                    p.ReadInt16(); // 0x01
                    UOEntity ent = null;
                    Serial ser = p.ReadUInt32();
                    if (ser.IsMobile)
                        ent = World.FindMobile(ser);
                    else if (ser.IsItem)
                        ent = World.FindItem(ser);

                    if (ent != null)
                    {
                        byte count = p.ReadByte();

                        try
                        {
                            ent.ContextMenu.Clear();

                            for (int i = 0; i < count; i++)
                            {
                                ushort idx = p.ReadUInt16();
                                ushort num = p.ReadUInt16();
                                ushort flags = p.ReadUInt16();
                                ushort color = 0;

                                if ((flags & 0x02) != 0)
                                    color = p.ReadUInt16();

                                ent.ContextMenu.Add(idx, num);
                            }
                        }
                        catch
                        {
                            // ignored
                        }
                    }

                    if (ScriptManager.BlockPopupMenu)
                    {
                        args.Block = true;
                        ScriptManager.BlockPopupMenu = false;
                    }

                    break;
                }

                case 0x18: // map patches
                {
                    if (World.Player != null)
                    {
                        int count = p.ReadInt32() * 2;
                        try
                        {
                            World.Player.MapPatches = new int[count];
                            for (int i = 0; i < count; i++)
                                World.Player.MapPatches[i] = p.ReadInt32();
                        }
                        catch
                        {
                        }
                    }

                    break;
                }

                case 0x19: //  stat locks
                {
                    if (p.ReadByte() == 0x02)
                    {
                        Mobile m = World.FindMobile(p.ReadUInt32());
                        if (World.Player == m && m != null)
                        {
                            p.ReadByte(); // 0?

                            byte locks = p.ReadByte();

                            World.Player.StrLock = (LockType) ((locks >> 4) & 3);
                            World.Player.DexLock = (LockType) ((locks >> 2) & 3);
                            World.Player.IntLock = (LockType) (locks & 3);
                        }
                    }

                    break;
                }

                case 0x1D: // Custom House "General Info"
                {
                    Item i = World.FindItem(p.ReadUInt32());
                    if (i != null)
                        i.HouseRevision = p.ReadInt32();
                    break;
                }
            }
        }

        public static int SpecialPartySent = 0;
        public static int SpecialPartyReceived = 0;

        private static void RunUOProtocolExtention(PacketReader p, PacketHandlerEventArgs args)
        {
            // Only block this packet if they are using the OSI client
            // since ClassicUO actually has support for it now
            args.Block = Client.IsOSI;

            switch (p.ReadByte())
            {
                case 1: // Custom Party information
                {
                    Serial serial;

                    PacketHandlers.SpecialPartyReceived++;

                    while ((serial = p.ReadUInt32()) > 0)
                    {
                        Mobile mobile = World.FindMobile(serial);

                        short x = p.ReadInt16();
                        short y = p.ReadInt16();
                        byte map = p.ReadByte();

                        if (mobile == null)
                        {
                            World.AddMobile(mobile = new Mobile(serial));
                            mobile.Visible = false;
                        }

                        if (mobile.Name == null || mobile.Name.Length <= 0)
                            mobile.Name = "(Not Seen)";

                        if (!_party.Contains(serial))
                            _party.Add(serial);

                        if (map == World.Player.Map)
                            mobile.Position = new Point3D(x, y, mobile.Position.Z);
                        else
                            mobile.Position = Point3D.Zero;
                    }

                    if (Engine.MainWindow.MapWindow != null)
                        Engine.MainWindow.SafeAction(s => s.MapWindow.UpdateMap());

                    break;
                }

                case 0xFE: // Begin Handshake/Features Negotiation
                {
                    ulong features = ((ulong) p.ReadUInt32() << 32) | (ulong) p.ReadUInt32();

                    Client.Instance.SetFeatures(features);
                    Client.Instance.SendToServer(new RazorNegotiateResponse());
                    Engine.MainWindow.SafeAction(s => s.UpdateControlLocks());

                    break;
                }
            }
        }

        private static List<Serial> _party = new List<Serial>();

        public static List<Serial> Party => _party;

        private static Timer _partyDeclineTimer = null;
        public static Serial PartyLeader = Serial.Zero;

        private static void OnPartyMessage(PacketReader p, PacketHandlerEventArgs args)
        {
            switch (p.ReadByte())
            {
                case 0x01: // List
                {
                    _party.Clear();

                    int count = p.ReadByte();
                    for (int i = 0; i < count; i++)
                    {
                        Serial s = p.ReadUInt32();
                        if (World.Player == null || s != World.Player.Serial)
                            _party.Add(s);
                    }

                    break;
                }

                case 0x02: // Remove Member/Re-list
                {
                    _party.Clear();
                    int count = p.ReadByte();
                    Serial remSerial = p.ReadUInt32(); // the serial of who was removed

                    if (World.Player != null)
                    {
                        Mobile rem = World.FindMobile(remSerial);
                        if (rem != null && !Utility.InRange(World.Player.Position, rem.Position, World.Player.VisRange))
                            rem.Remove();
                    }

                    for (int i = 0; i < count; i++)
                    {
                        Serial s = p.ReadUInt32();
                        if (World.Player == null || s != World.Player.Serial)
                            _party.Add(s);
                    }

                    break;
                }

                case 0x03: // text message

                case 0x04: // 3 = private, 4 = public
                {
                    //Serial from = p.ReadUInt32();
                    //string text = p.ReadUnicodeStringSafe();
                    break;
                }

                case 0x07: // party invite
                {
                    //Serial leader = p.ReadUInt32();
                    PartyLeader = p.ReadUInt32();

                    if (Config.GetBool("BlockPartyInvites"))
                    {
                        Client.Instance.SendToServer(new DeclineParty(PacketHandlers.PartyLeader));
                    }

                    if (Config.GetBool("AutoAcceptParty"))
                    {
                        Mobile leaderMobile = World.FindMobile(PartyLeader);
                        if (leaderMobile != null && FriendsManager.IsFriend(leaderMobile.Serial))
                        {
                            if (PartyLeader != Serial.Zero)
                            {
                                World.Player.SendMessage($"Auto accepted party invite from: {leaderMobile.Name}");

                                Client.Instance.SendToServer(new AcceptParty(PartyLeader));
                                PartyLeader = Serial.Zero;
                            }
                        }
                    }
                    else
                    {
                        if (_partyDeclineTimer == null)
                            _partyDeclineTimer = Timer.DelayedCallback(TimeSpan.FromSeconds(10.0),
                                new TimerCallback(PartyAutoDecline));
                        _partyDeclineTimer.Start();
                    }

                    break;
                }
            }


            if (Engine.MainWindow.MapWindow != null)
                Engine.MainWindow.SafeAction(s => s.MapWindow.UpdateMap());
        }

        private static void PartyAutoDecline()
        {
            PartyLeader = Serial.Zero;
        }

        private static void PingResponse(PacketReader p, PacketHandlerEventArgs args)
        {
            if (Ping.Response(p.ReadByte()))
                args.Block = true;
        }

        private static void ClientEncodedPacket(PacketReader p, PacketHandlerEventArgs args)
        {
            Serial serial = p.ReadUInt32();
            ushort packetID = p.ReadUInt16();
            switch (packetID)
            {
                case 0x19: // set ability
                {
                    int ability = 0;
                    if (p.ReadByte() == 0)
                        ability = p.ReadInt32();

                    if (ability >= 0 && ability < (int) AOSAbility.Invalid && Macros.MacroManager.AcceptActions)
                        MacroManager.Action(new SetAbilityAction((AOSAbility) ability));
                    else if (ability >= 0 && ability < (int) AOSAbility.Invalid)
                        ScriptManager.AddToScript($"setability '{ability}'");

                    break;
                }
            }
        }

        private static string _lastPassword = "";

        private static void ServerListLogin(Packet p, PacketHandlerEventArgs args)
        {
            _lastPassword = "";
            if (!Config.GetBool("RememberPwds"))
                return;

            World.AccountName = p.ReadStringSafe(30);
            string pass = p.ReadStringSafe(30);

            if (pass == "")
            {
                pass = PasswordMemory.Find(World.AccountName, Client.Instance.LastConnection);
                if (pass != null && pass != "")
                {
                    p.Seek(31, SeekOrigin.Begin);
                    p.WriteAsciiFixed(pass, 30);
                    _lastPassword = pass;
                }
            }
            else
            {
                PasswordMemory.Add(World.AccountName, pass, Client.Instance.LastConnection);
            }
        }

        private static void GameLogin(Packet p, PacketHandlerEventArgs args)
        {
            int authID = p.ReadInt32();

            World.AccountName = p.ReadString(30);
            string password = p.ReadString(30);

            if (password == "" && _lastPassword != "" && Config.GetBool("RememberPwds"))
            {
                p.Seek(35, SeekOrigin.Begin);
                p.WriteAsciiFixed(_lastPassword, 30);
                _lastPassword = "";
            }
        }

        private static void MenuResponse(PacketReader pvSrc, PacketHandlerEventArgs args)
        {
            if (World.Player == null)
                return;

            uint serial = pvSrc.ReadUInt32();
            ushort menuID = pvSrc.ReadUInt16();
            ushort index = pvSrc.ReadUInt16();
            ushort itemID = pvSrc.ReadUInt16();
            ushort hue = pvSrc.ReadUInt16();

            World.Player.HasMenu = false;
            if (MacroManager.AcceptActions)
                MacroManager.Action(new MenuResponseAction(index, itemID, hue));

            ScriptManager.AddToScript($"menuresponse {index} {itemID} {hue}");
        }

        private static void SendMenu(PacketReader p, PacketHandlerEventArgs args)
        {
            if (World.Player == null)
                return;

            World.Player.CurrentMenuS = p.ReadUInt32();
            World.Player.CurrentMenuI = p.ReadUInt16();
            World.Player.HasMenu = true;
            if (MacroManager.AcceptActions && MacroManager.Action(new WaitForMenuAction(World.Player.CurrentMenuI)))
                args.Block = true;

            if (ScriptManager.AddToScript($"waitformenu {World.Player.CurrentMenuI}"))
                args.Block = true;
        }

        private static void HueResponse(PacketReader p, PacketHandlerEventArgs args)
        {
            Serial serial = p.ReadUInt32();
            ushort iid = p.ReadUInt16();
            ushort hue = p.ReadUInt16();

            if (serial == Serial.MinusOne)
            {
                if (HueEntry.Callback != null)
                    HueEntry.Callback(hue);
                args.Block = true;
            }
        }

        private static void ServerAddress(Packet p, PacketHandlerEventArgs args)
        {
            int port = Config.GetInt("ForcePort");
            if (port != 0)
            {
                try
                {
                    string[] parts = Config.GetString("ForceIP").Split('.');
                    p.Write((byte) Convert.ToInt16(parts[0]));
                    p.Write((byte) Convert.ToInt16(parts[1]));
                    p.Write((byte) Convert.ToInt16(parts[2]));
                    p.Write((byte) Convert.ToInt16(parts[3]));

                    p.Write((ushort) port);
                }
                catch
                {
                    System.Windows.Forms.MessageBox.Show(Engine.MainWindow, "Error parsing Proxy Settings.",
                        "Force Proxy Error.");
                }
            }
        }

        private static void Features(PacketReader p, PacketHandlerEventArgs args)
        {
            if (World.Player != null)
            {
                if (p.Length > 3)
                    World.Player.Features = p.ReadUInt32();
                else
                    World.Player.Features = p.ReadUInt16();
            }
        }

        private static void PersonalLight(PacketReader p, PacketHandlerEventArgs args)
        {
            if (World.Player != null && !args.Block)
            {
                p.ReadUInt32(); // serial

                World.Player.LocalLightLevel = p.ReadSByte();

                if (EnforceLightLevels(World.Player.LocalLightLevel))
                    args.Block = true;
            }
        }

        private static void GlobalLight(PacketReader p, PacketHandlerEventArgs args)
        {
            if (World.Player != null && !args.Block)
            {
                World.Player.GlobalLightLevel = p.ReadByte();

                if (EnforceLightLevels(World.Player.GlobalLightLevel))
                    args.Block = true;
            }
        }

        private static bool EnforceLightLevels(int lightLevel)
        {
            if (Client.Instance.AllowBit(FeatureBit.LightFilter) && Config.GetBool("MinMaxLightLevelEnabled"))
            {
                // 0 bright, 30 is dark
                if (lightLevel == -1)
                {
                    lightLevel = Convert.ToByte(Config.GetInt("MinLightLevel"));
                }
                else if (lightLevel < Config.GetInt("MaxLightLevel"))
                {
                    lightLevel = Convert.ToByte(Config.GetInt("MaxLightLevel")); // light level is too light
                }
                else if (lightLevel > Config.GetInt("MinLightLevel")) // light level is too dark
                {
                    lightLevel = Convert.ToByte(Config.GetInt("MinLightLevel"));
                }
                else // No need to block or do anything special
                {
                    return false;
                }

                World.Player.LocalLightLevel = 0;
                World.Player.GlobalLightLevel = (byte) lightLevel;

                Client.Instance.SendToClient(new GlobalLightLevel(lightLevel));
                Client.Instance.SendToClient(new PersonalLightLevel(World.Player));

                return true;
            }

            return false;
        }

        private static void ServerSetWarMode(PacketReader p, PacketHandlerEventArgs args)
        {
            World.Player.Warmode = p.ReadBoolean();
        }

        private static void CustomHouseInfo(PacketReader p, PacketHandlerEventArgs args)
        {
            p.ReadByte(); // compression
            p.ReadByte(); // Unknown

            Item i = World.FindItem(p.ReadUInt32());
            if (i != null)
            {
                i.HouseRevision = p.ReadInt32();
                i.HousePacket = p.CopyBytes(0, p.Length);
            }
        }

        /*
        Packet Build
        1.  BYTE[1] Cmd
        2.  BYTE[2] len
        3.  BYTE[4] Player Serial
        4.  BYTE[4] Gump ID
        5.  BYTE[4] x
        6.  BYTE[4] y
        7.  BYTE[4] Compressed Gump Layout Length (CLen)
        8.  BYTE[4] Decompressed Gump Layout Length (DLen)
        9.  BYTE[CLen-4] Gump Data, zlib compressed
        10. BYTE[4] Number of text lines
        11. BYTE[4] Compressed Text Line Length (CTxtLen)
        12. BYTE[4] Decompressed Text Line Length (DTxtLen)
        13. BYTE[CTxtLen-4] Gump's Compressed Text data, zlib compressed
         */
        private static void CompressedGump(PacketReader p, PacketHandlerEventArgs args)
        {
            if (World.Player == null)
                return;

            World.Player.CurrentGumpS = p.ReadUInt32();
            World.Player.CurrentGumpI = p.ReadUInt32();
            World.Player.HasCompressedGump = true;

            if (Macros.MacroManager.AcceptActions &&
                MacroManager.Action(new WaitForGumpAction(World.Player.CurrentGumpI)))
                args.Block = true;

            ScriptManager.AddToScript($"waitforgump {World.Player.CurrentGumpI}");

            List<string> gumpStrings = new List<string>();

            try
            {
                int x = p.ReadInt32(), y = p.ReadInt32();

                string layout = p.GetCompressedReader().ReadString();

                int numStrings = p.ReadInt32();
                if (numStrings < 0 || numStrings > 256)
                    numStrings = 0;

                // Split on one or more non-digit characters.
                World.Player.CurrentGumpStrings.Clear();

                string[] numbers = Regex.Split(layout, @"\D+");

                foreach (string value in numbers)
                {
                    if (!string.IsNullOrEmpty(value))
                    {
                        int i = int.Parse(value);
                        if ((i >= 500000 && i <= 503405) || (i >= 1000000 && i <= 1155584) ||
                            (i >= 3000000 && i <= 3011032))
                            gumpStrings.Add(Language.GetString(i));
                    }
                }

                PacketReader pComp = p.GetCompressedReader();
                int len = 0;
                int x1 = 0;
                string[] stringlistparse = new string[numStrings];

                while (!pComp.AtEnd && (len = pComp.ReadInt16()) > 0)
                {
                    string tempString = pComp.ReadUnicodeString(len);
                    stringlistparse[x1] = tempString;
                    x1++;
                }

                if (TryParseGump(layout, out string[] gumpPieces))
                {
                    gumpStrings.AddRange(ParseGumpString(gumpPieces, stringlistparse));
                }

                if (Config.GetBool("CaptureMibs") && MessageInBottleCapture.IsMibGump(layout))
                {
                    switch (gumpStrings.Count)
                    {
                        //Classic, non-custom MIB
                        case 3:
                            MessageInBottleCapture.CaptureMibCoordinates(gumpStrings[2], false);
                            break;
                        case 4:
                            MessageInBottleCapture.CaptureMibCoordinates(gumpStrings[2], true);
                            break;
                    }
                }

                if (World.Player.GumpList.ContainsKey(World.Player.CurrentGumpI))
                {
                    World.Player.GumpList.Remove(World.Player.CurrentGumpI);
                }

                World.Player.GumpList.Add(World.Player.CurrentGumpI, new PlayerData.GumpInfo(World.Player.CurrentGumpS, World.Player.CurrentGumpI, gumpStrings));

                World.Player.CurrentGumpStrings.AddRange(gumpStrings);
                World.Player.CurrentGumpRawData = layout; // Get raw data of current gump
            }
            catch
            {
            }
        }

        private static bool TryParseGump(string gumpData, out string[] pieces)
        {
            List<string> i = new List<string>();
            int dataIndex = 0;
            while (dataIndex < gumpData.Length)
            {
                if (gumpData.Substring(dataIndex) == "\0")
                {
                    break;
                }
                else
                {
                    int begin = gumpData.IndexOf("{", dataIndex);
                    int end = gumpData.IndexOf("}", dataIndex + 1);
                    if ((begin != -1) && (end != -1))
                    {
                        string sub = gumpData.Substring(begin + 1, end - begin - 1).Trim();
                        i.Add(sub);
                        dataIndex = end;
                    }
                    else
                    {
                        break;
                    }
                }
            }

            pieces = i.ToArray();
            return (pieces.Length > 0);
        }

        private static List<string> ParseGumpString(string[] gumpPieces, string[] gumpLines)
        {
            List<string> gumpText = new List<string>();
            for (int i = 0; i < gumpPieces.Length; i++)
            {
                string[] gumpParams = Regex.Split(gumpPieces[i], @"\s+");
                switch (gumpParams[0].ToLower())
                {
                    case "croppedtext":
                        gumpText.Add(gumpLines[int.Parse(gumpParams[6])]);
                        // CroppedText [x] [y] [width] [height] [color] [text-id]
                        // Adds a text field to the gump. gump is similar to the text command, but the text is cropped to the defined area.
                        //gump.AddControl(new CroppedText(gump, gumpParams, gumpLines), currentGUMPPage);
                        //(gump.LastControl as CroppedText).Hue = 1;
                        break;

                    case "htmlgump":
                        gumpText.Add(gumpLines[int.Parse(gumpParams[5])]);
                        // HtmlGump [x] [y] [width] [height] [text-id] [background] [scrollbar]
                        // Defines a text-area where Html-commands are allowed.
                        // [background] and [scrollbar] can be 0 or 1 and define whether the background is transparent and a scrollbar is displayed.
                        //	gump.AddControl(new HtmlGumpling(gump, gumpParams, gumpLines), currentGUMPPage);
                        break;

                    case "text":
                        gumpText.Add(gumpLines[int.Parse(gumpParams[4])]);
                        // Text [x] [y] [color] [text-id]
                        // Defines the position and color of a text (data) entry.
                        //gump.AddControl(new TextLabel(gump, gumpParams, gumpLines), currentGUMPPage);
                        break;
                }
            }

            return gumpText;
        }

        private static DateTime _lastSelfDeathScreenshot = DateTime.MinValue;

        private static void ResurrectionGump(PacketReader p, PacketHandlerEventArgs args)
        {
            if (Config.GetBool("CaptureOwnDeath") &&
                _lastSelfDeathScreenshot + TimeSpan.FromMilliseconds(500) < DateTime.UtcNow)
            {
                ScreenCapManager.DeathCapture(Config.GetDouble("CaptureOwnDeathDelay"));
                _lastSelfDeathScreenshot = DateTime.UtcNow;
            }

            if (Config.GetBool("CreateWaypointOnDeath") && World.Player != null)
            {
                WaypointManager.Waypoint waypoint = new WaypointManager.Waypoint
                {
                    X = World.Player.Position.X,
                    Y = World.Player.Position.Y,
                    Name = "Your Body"
                };

                WaypointManager.AddWaypoint(waypoint);
                WaypointManager.ShowWaypoint(waypoint);
            }
        }
        
        private const ushort BUFF_ICON_START = 0x03E9;
        private const ushort BUFF_ICON_START_NEW = 0x466;

        private static void BuffDebuff(PacketReader p, PacketHandlerEventArgs args)
        {
            Serial serial = p.ReadUInt32();
            ushort icon = p.ReadUInt16();
            ushort action = p.ReadUInt16();

            if (Enum.IsDefined(typeof(BuffIconType), icon))
            {
                BuffIconType buffType = (BuffIconType) icon;
                
                ushort iconId = (ushort) buffType >= BUFF_ICON_START_NEW ? (ushort) (buffType - (BUFF_ICON_START_NEW - 125)) : (ushort) ((ushort) buffType - BUFF_ICON_START);
                
                switch (action)
                {
                    case 0x01: // show

                        p.ReadUInt32(); //0x000
                        p.ReadUInt16(); //icon # again..?
                        p.ReadUInt16(); //0x1 = show
                        p.ReadUInt32(); //0x000
                        ushort duration = p.ReadUInt16();
                        p.ReadUInt16(); //0x0000
                        p.ReadByte(); //0x0

                        BuffDebuff buffInfo = new BuffDebuff
                        {
                            IconId = BuffDebuffManager.BuffTable[iconId],
                            BuffIconType = (BuffIconType) icon,
                            ClilocMessage1 = Language.GetCliloc((int) p.ReadUInt32()),
                            ClilocMessage2 = Language.GetCliloc((int) p.ReadUInt32()),
                            Duration = duration,
                            Timestamp = DateTime.UtcNow
                        };

                        if (World.Player != null && World.Player.BuffsDebuffs.All(b => b.BuffIconType != buffType))
                        {
                            World.Player.BuffsDebuffs.Add(buffInfo);

                            BuffDebuffManager.DisplayOverheadBuff(buffInfo);
                        }

                        break;

                    case 0x0: // remove
                        if (World.Player != null)
                        {
                            BuffDebuffManager.DisplayOverheadDebuff(buffType);

                            World.Player.BuffsDebuffs.RemoveAll(b => b.BuffIconType == buffType);
                        }

                        break;
                }

                Client.Instance.RequestTitlebarUpdate();
            }

            if (World.Player != null && World.Player.BuffsDebuffs.Count > 0)
            {
                BuffDebuffManager.Start();
            }
            else
            {
                BuffDebuffManager.Stop();
            }
        }

        private static void AttackRequest(Packet p, PacketHandlerEventArgs args)
        {
            if (Config.GetBool("ShowAttackTargetOverhead"))
            {
                uint serial = p.ReadUInt32();

                Mobile m = World.FindMobile(serial);

                if (m == null) return;

                World.Player.OverheadMessage(FriendsManager.IsFriend(m.Serial) ? 63 : m.GetNotorietyColorInt(),
                    $"Attack: {m.Name}");
            }
        }

        private static void TradeRequest(PacketReader p, PacketHandlerEventArgs args)
        {
            if (Config.GetBool("BlockTradeRequests"))
            {
                args.Block = true;
            }
        }

        private static void UnicodePromptSend(Packet p, PacketHandlerEventArgs args)
        {
            if (World.Player == null)
                return;

            //uint serial = p.ReadUInt32();
            //uint id = p.ReadUInt32();
            //uint type = p.ReadUInt32();

            uint serial = p.ReadUInt32();
            uint id = p.ReadUInt32();
            uint type = p.ReadUInt32();

            string lang = p.ReadStringSafe(4);
            string text = p.ReadUnicodeStringLESafe();

            World.Player.HasPrompt = false;
            World.Player.PromptSenderSerial = serial;
            World.Player.PromptID = id;
            World.Player.PromptType = type;
            World.Player.PromptInputText = text;

            if (MacroManager.AcceptActions && !string.IsNullOrEmpty(World.Player.PromptInputText))
            {
                MacroManager.Action(new PromptAction(World.Player.PromptInputText));
            }

            if (!string.IsNullOrEmpty(World.Player.PromptInputText))
                ScriptManager.AddToScript($"promptresponse '{World.Player.PromptInputText}'");
        }

        private static void UnicodePromptReceived(Packet p, PacketHandlerEventArgs args)
        {
            if (World.Player == null)
                return;

            uint serial = p.ReadUInt32();
            uint id = p.ReadUInt32();
            uint type = p.ReadUInt32();

            World.Player.HasPrompt = true;
            World.Player.PromptSenderSerial = serial;
            World.Player.PromptID = id;
            World.Player.PromptType = type;

            if (MacroManager.AcceptActions)
            {
                MacroManager.Action(new WaitForPromptAction(id));
            }

            ScriptManager.AddToScript($"waitforprompt {id}");

            //args.Block = true;

            //string lang = p.ReadStringSafe(4);
            //string message = p.ReadUnicodeStringSafe();
        }

        private static void PlaySoundEffect(Packet p, PacketHandlerEventArgs args)
        {
            if (World.Player == null)
                return;

            byte type = p.ReadByte();
            ushort sound = p.ReadUInt16();

            if (Config.GetBool("SoundFilterEnabled"))
            {
                bool blockSound = SoundMusicManager.IsFilteredSound(sound, out string name);

                if (blockSound)
                {
                    args.Block = true;

                    if (Config.GetBool("ShowFilteredSound"))
                    {
                        World.Player.SendMessage(MsgLevel.Warning, $"Blocked Sound: '{name}' (0x{sound:X})");
                        return;
                    }
                }
            }

            if (Config.GetBool("ShowPlayingSoundInfo"))
            {
                World.Player.SendMessage(MsgLevel.Info,
                    $"Playing Sound: '{SoundMusicManager.GetSoundName(sound)}' (0x{sound:X})");
            }
        }

        private static void PlayMusic(Packet p, PacketHandlerEventArgs args)
        {
            if (World.Player == null)
                return;

            if (!Config.GetBool("ShowMusicInfo"))
                return;

            ushort musicId = p.ReadUInt16();

            World.Player.SendMessage(
                $"Playing Music: '{SoundMusicManager.GetMusicName(musicId, out bool loop)}' (id: '{musicId}' loop: '{loop}')");
        }
    }
}

================================================
FILE: Razor/Network/Loader.cs
================================================
using System;
using System.Diagnostics;
using System.Runtime.InteropServices;

namespace Assistant
{
	public class Loader
	{
		public enum ERROR_TYPE : int
		{
			SUCCESS = 0,
			NO_OPEN_EXE,
			NO_READ_EXE_DATA,

			NO_RUN_EXE,
			NO_ALLOC_MEM,

			NO_WRITE,
			NO_VPROTECT,
			NO_READ,
		};

		[DllImport( "Loader.dll" )]
		public static unsafe extern ERROR_TYPE Load( string exe, string dll, string funcName, ref DLLParameters data, int dataSize, out int pid );

		[Flags]
		public enum DLLFlags  : uint
		{
			None			= 0x00000000,

			OSICryptEnabled = 0x00000001,
			SmartCPU		= 0x00000002,
			Trees			= 0x00000004,
		};

		[StructLayout( LayoutKind.Sequential )]
		public struct DLLParameters
		{
			public DLLFlags Flags;
		}
	}
}

================================================
FILE: Razor/Network/Packet.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.IO;
using System.Text;

namespace Assistant
{
    public enum PacketPath
    {
        ClientToServer,
        RazorToServer,
        ServerToClient,
        RazorToClient
    }

    public class Packet
    {
        private static bool m_Logging = false;

        public static bool Logging
        {
            get { return m_Logging; }
            set
            {
                if (value != m_Logging)
                {
                    m_Logging = value;
                    if (m_Logging)
                        BeginLog();
                }
            }
        }

        public static string PacketsLogFile
        {
            get { return Path.Combine(Config.GetInstallDirectory(), "Razor_Packets.log"); }
        }

        private static void BeginLog()
        {
            using (StreamWriter sw = new StreamWriter(PacketsLogFile, true))
            {
                sw.AutoFlush = true;
                sw.WriteLine();
                sw.WriteLine();
                sw.WriteLine();
                sw.WriteLine(">>>>>>>>>> Logging started {0} <<<<<<<<<<", DateTime.UtcNow);
                sw.WriteLine();
                sw.WriteLine();
            }
        }

        private static byte[] m_Buffer = new byte[4]; // Internal format buffer.
        private MemoryStream m_Stream;
        private bool m_DynSize;
        private byte m_PacketID;

        public Packet()
        {
            m_Stream = new MemoryStream();
        }

        public Packet(byte packetID)
        {
            m_PacketID = packetID;
            m_DynSize = true;
        }

        public Packet(byte packetID, int capacity)
        {
            m_Stream = new MemoryStream(capacity);

            m_PacketID = packetID;
            m_DynSize = false;

            m_Stream.WriteByte(packetID);
        }

        public Packet(byte[] data, int len, bool dynLen)
        {
            m_Stream = new MemoryStream(len);
            m_PacketID = data[0];
            m_DynSize = dynLen;

            m_Stream.Position = 0;
            m_Stream.Write(data, 0, len);

            MoveToData();
        }


        public void EnsureCapacity(int capacity)
        {
            m_Stream = new MemoryStream(capacity);
            Write((byte) m_PacketID);
            if (m_DynSize)
                Write((short) 0);
        }

        public byte[] Compile()
        {
            if (m_DynSize)
            {
                m_Stream.Seek(1, SeekOrigin.Begin);
                Write((ushort) m_Stream.Length);
            }

            return ToArray();
        }

        public void MoveToData()
        {
            m_Stream.Position = m_DynSize ? 3 : 1;
        }

        public void Copy(Packet p)
        {
            m_Stream = new MemoryStream((int) p.Length);
            byte[] data = p.ToArray();
            m_Stream.Write(data, 0, data.Length);

            m_DynSize = p.m_DynSize;
            m_PacketID = p.m_PacketID;

            MoveToData();
        }

        /*public override int GetHashCode()
        {
             long oldPos = m_Stream.Position;

             int code = 0;

             m_Stream.Position = 0;

             while ( m_Stream.Length - m_Stream.Position >= 4 )
                  code ^= ReadInt32();
             
             code ^= ReadByte() | (ReadByte() << 8) | (ReadByte() << 16) | (ReadByte() << 24);

             m_Stream.Position = oldPos;

             return code;
        }*/

        public static void Log(string line, params object[] args)
        {
            Log(string.Format(line, args));
        }

        public static void Log(string line)
        {
            if (!m_Logging)
                return;

            try
            {
                using (StreamWriter sw = new StreamWriter(PacketsLogFile, true))
                {
                    sw.AutoFlush = true;
                    sw.WriteLine(line);
                    sw.WriteLine();
                }
            }
            catch
            {
            }
        }

        public static unsafe void Log(PacketPath path, byte* buff, int len, bool blocked = false)
        {
            if (!m_Logging)
                return;

            try
            {
                using (StreamWriter sw = new StreamWriter(PacketsLogFile, true))
                {
                    sw.AutoFlush = true;

                    string pathStr;
                    switch (path)
                    {
                        case PacketPath.ClientToServer:
                            pathStr = "Client -> Server";
                            break;
                        case PacketPath.RazorToServer:
                            pathStr = "Razor -> Server";
                            break;
                        case PacketPath.ServerToClient:
                            pathStr = "Server -> Client";
                            break;
                        case PacketPath.RazorToClient:
                            pathStr = "Razor -> Client";
                            break;
                        default:
                            pathStr = "Unknown -> Unknown";
                            break;
                    }

                    sw.WriteLine("{0:HH:mm:ss.ffff}: {1}{2}0x{3:X2} (Length: {4})", Engine.MistedDateTime,
                        pathStr, blocked ? " [BLOCKED] " : " ", buff[0], len);
                    
                    Utility.FormatBuffer(sw, buff, len);
                    
                    sw.WriteLine();
                    sw.WriteLine();
                }
            }
            catch
            {
                // ignored
            }
        }

        public long Seek(int offset, SeekOrigin origin)
        {
            return m_Stream.Seek(offset, origin);
        }

        public int ReadInt32()
        {
            if (m_Stream.Position + 4 > m_Stream.Length)
                return 0;

            return (ReadByte() << 24)
                   | (ReadByte() << 16)
                   | (ReadByte() << 8)
                   | ReadByte();
        }

        public short ReadInt16()
        {
            if (m_Stream.Position + 2 > m_Stream.Length)
                return 0;
            return (short) ((ReadByte() << 8) | ReadByte());
        }

        public byte ReadByte()
        {
            if (m_Stream.Position + 1 > m_Stream.Length)
                return 0;
            return (byte) m_Stream.ReadByte();
        }

        public uint ReadUInt32()
        {
            if (m_Stream.Position + 4 > m_Stream.Length)
                return 0;
            return (uint) ((ReadByte() << 24)
                           | (ReadByte() << 16)
                           | (ReadByte() << 8)
                           | ReadByte());
        }

        public ushort ReadUInt16()
        {
            if (m_Stream.Position + 2 > m_Stream.Length)
                return 0;
            return (ushort) ((ReadByte() << 8) | ReadByte());
        }

        public sbyte ReadSByte()
        {
            if (m_Stream.Position + 1 > m_Stream.Length)
                return 0;
            return (sbyte) m_Stream.ReadByte();
        }

        public bool ReadBoolean()
        {
            if (m_Stream.Position + 1 > m_Stream.Length)
                return false;
            return (m_Stream.ReadByte() != 0);
        }

        public string ReadUnicodeStringLE()
        {
            StringBuilder sb = new StringBuilder();

            int c;

            while (m_Stream.Position + 1 < m_Stream.Length && (c = ReadByte() | (ReadByte() << 8)) != 0)
                sb.Append((char) c);

            return sb.ToString();
        }

        public string ReadUnicodeStringLESafe()
        {
            StringBuilder sb = new StringBuilder();

            int c;

            while (m_Stream.Position + 1 < m_Stream.Length && (c = ReadByte() | (ReadByte() << 8)) != 0)
            {
                if (IsSafeChar(c))
                    sb.Append((char) c);
            }

            return sb.ToString();
        }

        public string ReadUnicodeStringSafe()
        {
            StringBuilder sb = new StringBuilder();

            int c;

            while (m_Stream.Position + 1 < m_Stream.Length && (c = ReadUInt16()) != 0)
            {
                if (IsSafeChar(c))
                    sb.Append((char) c);
            }

            return sb.ToString();
        }

        public string ReadUnicodeString()
        {
            StringBuilder sb = new StringBuilder();

            int c;

            while (m_Stream.Position + 1 < m_Stream.Length && (c = ReadUInt16()) != 0)
                sb.Append((char) c);

            return sb.ToString();
        }

        public bool IsSafeChar(int c)
        {
            return (c >= 0x20 && c < 0xFFFE);
        }

        public string ReadUTF8StringSafe(int fixedLength)
        {
            if (m_Stream.Position >= m_Stream.Length)
                return String.Empty;

            long bound = m_Stream.Position + fixedLength;
            long end = bound;

            if (bound > m_Stream.Length)
                bound = m_Stream.Length;

            int count = 0;
            long index = m_Stream.Position;
            long start = m_Stream.Position;

            while (index < bound && ReadByte() != 0)
                ++count;

            m_Stream.Seek(start, SeekOrigin.Begin);

            index = 0;

            byte[] buffer = new byte[count];
            int value = 0;

            while (m_Stream.Position < bound && (value = ReadByte()) != 0)
                buffer[index++] = (byte) value;

            string s = Encoding.UTF8.GetString(buffer);

            bool isSafe = true;

            for (int i = 0; isSafe && i < s.Length; ++i)
                isSafe = IsSafeChar((int) s[i]);

            m_Stream.Seek(start + fixedLength, SeekOrigin.Begin);

            if (isSafe)
                return s;

            StringBuilder sb = new StringBuilder(s.Length);

            for (int i = 0; i < s.Length; ++i)
            {
                if (IsSafeChar((int) s[i]))
                    sb.Append(s[i]);
            }

            return sb.ToString();
        }

        public string ReadUTF8StringSafe()
        {
            if (m_Stream.Position >= m_Stream.Length)
                return String.Empty;

            int count = 0;
            long index = m_Stream.Position;
            long start = index;

            while (index < m_Stream.Length && ReadByte() != 0)
                ++count;

            m_Stream.Seek(start, SeekOrigin.Begin);

            index = 0;

            byte[] buffer = new byte[count];
            int value = 0;

            while (m_Stream.Position < m_Stream.Length && (value = ReadByte()) != 0)
                buffer[index++] = (byte) value;

            string s = Encoding.UTF8.GetString(buffer);

            bool isSafe = true;

            for (int i = 0; isSafe && i < s.Length; ++i)
                isSafe = IsSafeChar((int) s[i]);

            if (isSafe)
                return s;

            StringBuilder sb = new StringBuilder(s.Length);

            for (int i = 0; i < s.Length; ++i)
            {
                if (IsSafeChar((int) s[i]))
                    sb.Append(s[i]);
            }

            return sb.ToString();
        }

        public string ReadUTF8String()
        {
            if (m_Stream.Position >= m_Stream.Length)
                return String.Empty;

            int count = 0;
            long index = m_Stream.Position;
            long start = index;

            while (index < m_Stream.Length && ReadByte() != 0)
                ++count;

            m_Stream.Seek(start, SeekOrigin.Begin);

            index = 0;

            byte[] buffer = new byte[count];
            int value = 0;

            while (m_Stream.Position < m_Stream.Length && (value = ReadByte()) != 0)
                buffer[index++] = (byte) value;

            return Encoding.UTF8.GetString(buffer);
        }

        public string ReadString()
        {
            return ReadStringSafe();
        }

        public string ReadStringSafe()
        {
            StringBuilder sb = new StringBuilder();

            int c;

            while (m_Stream.Position < m_Stream.Length && (c = ReadByte()) != 0)
                sb.Append((char) c);

            return sb.ToString();
        }

        public string ReadUnicodeStringSafe(int fixedLength)
        {
            return ReadUnicodeString(fixedLength);
        }

        public string ReadUnicodeString(int fixedLength)
        {
            long bound = m_Stream.Position + (fixedLength << 1);
            long end = bound;

            if (bound > m_Stream.Length)
                bound = m_Stream.Length;

            StringBuilder sb = new StringBuilder();

            int c;

            while ((m_Stream.Position + 1) < bound && (c = ReadUInt16()) != 0)
                if (IsSafeChar(c))
                    sb.Append((char) c);

            m_Stream.Seek(end, SeekOrigin.Begin);

            return sb.ToString();
        }

        public string ReadStringSafe(int fixedLength)
        {
            return ReadString(fixedLength);
        }

        public string ReadString(int fixedLength)
        {
            long bound = m_Stream.Position + fixedLength;

            if (bound > m_Stream.Length)
                bound = m_Stream.Length;

            long end = bound;

            StringBuilder sb = new StringBuilder();

            int c;

            while (m_Stream.Position < bound && (c = ReadByte()) != 0)
                sb.Append((char) c);

            m_Stream.Seek(end, SeekOrigin.Begin);

            return sb.ToString();
        }


/////////////////////////////////////////////
        ///Packet Writer/////////////////////////////
/////////////////////////////////////////////
        public void Write(bool value)
        {
            m_Stream.WriteByte((byte) (value ? 1 : 0));
        }

        public void Write(byte value)
        {
            m_Stream.WriteByte(value);
        }

        public void Write(sbyte value)
        {
            m_Stream.WriteByte((byte) value);
        }

        public void Write(short value)
        {
            m_Buffer[0] = (byte) (value >> 8);
            m_Buffer[1] = (byte) value;

            m_Stream.Write(m_Buffer, 0, 2);
        }

        public void Write(ushort value)
        {
            m_Buffer[0] = (byte) (value >> 8);
            m_Buffer[1] = (byte) value;

            m_Stream.Write(m_Buffer, 0, 2);
        }

        public void Write(int value)
        {
            m_Buffer[0] = (byte) (value >> 24);
            m_Buffer[1] = (byte) (value >> 16);
            m_Buffer[2] = (byte) (value >> 8);
            m_Buffer[3] = (byte) value;

            m_Stream.Write(m_Buffer, 0, 4);
        }

        public void Write(uint value)
        {
            m_Buffer[0] = (byte) (value >> 24);
            m_Buffer[1] = (byte) (value >> 16);
            m_Buffer[2] = (byte) (value >> 8);
            m_Buffer[3] = (byte) value;

            m_Stream.Write(m_Buffer, 0, 4);
        }

        public void Write(byte[] buffer, int offset, int size)
        {
            m_Stream.Write(buffer, offset, size);
        }

        public void WriteAsciiFixed(string value, int size)
        {
            if (value == null)
                value = String.Empty;

            byte[] buffer = Encoding.ASCII.GetBytes(value);

            if (buffer.Length >= size)
            {
                m_Stream.Write(buffer, 0, size);
            }
            else
            {
                m_Stream.Write(buffer, 0, buffer.Length);

                byte[] pad = new byte[size - buffer.Length];

                m_Stream.Write(pad, 0, pad.Length);
            }
        }

        public void WriteAsciiNull(string value)
        {
            if (value == null)
                value = String.Empty;

            byte[] buffer = Encoding.ASCII.GetBytes(value);

            m_Stream.Write(buffer, 0, buffer.Length);
            m_Stream.WriteByte(0);
        }

        public void WriteLittleUniNull(string value)
        {
            if (value == null)
                value = String.Empty;

            byte[] buffer = Encoding.Unicode.GetBytes(value);

            m_Stream.Write(buffer, 0, buffer.Length);

            m_Buffer[0] = 0;
            m_Buffer[1] = 0;
            m_Stream.Write(m_Buffer, 0, 2);
        }

        public void WriteLittleUniFixed(string value, int size)
        {
            if (value == null)
                value = String.Empty;

            size *= 2;

            byte[] buffer = Encoding.Unicode.GetBytes(value);

            if (buffer.Length >= size)
            {
                m_Stream.Write(buffer, 0, size);
            }
            else
            {
                m_Stream.Write(buffer, 0, buffer.Length);

                byte[] pad = new byte[size - buffer.Length];

                m_Stream.Write(pad, 0, pad.Length);
            }
        }

        public void WriteBigUniNull(string value)
        {
            if (value == null)
                value = String.Empty;

            byte[] buffer = Encoding.BigEndianUnicode.GetBytes(value);

            m_Stream.Write(buffer, 0, buffer.Length);

            m_Buffer[0] = 0;
            m_Buffer[1] = 0;
            m_Stream.Write(m_Buffer, 0, 2);
        }

        public void WriteBigUniFixed(string value, int size)
        {
            if (value == null)
                value = String.Empty;

            size *= 2;

            byte[] buffer = Encoding.BigEndianUnicode.GetBytes(value);

            if (buffer.Length >= size)
            {
                m_Stream.Write(buffer, 0, size);
            }
            else
            {
                m_Stream.Write(buffer, 0, buffer.Length);

                byte[] pad = new byte[size - buffer.Length];

                m_Stream.Write(pad, 0, pad.Length);
            }
        }

        public void WriteUTF8Fixed(string value, int size)
        {
            if (value == null)
                value = String.Empty;

            size *= 2;

            byte[] buffer = Encoding.UTF8.GetBytes(value);

            if (buffer.Length >= size)
            {
                m_Stream.Write(buffer, 0, size);
            }
            else
            {
                m_Stream.Write(buffer, 0, buffer.Length);

                byte[] pad = new byte[size - buffer.Length];

                m_Stream.Write(pad, 0, pad.Length);
            }
        }

        public void WriteUTF8Null(string value)
        {
            if (value == null)
                value = String.Empty;

            byte[] buffer = Encoding.UTF8.GetBytes(value);

            m_Stream.Write(buffer, 0, buffer.Length);
            m_Buffer[0] = 0;
            m_Buffer[1] = 0;
            m_Stream.Write(m_Buffer, 0, 2);
        }

        public void Fill()
        {
            byte[] buffer = new byte[m_Stream.Capacity - Position];
            m_Stream.Write(buffer, 0, buffer.Length);
        }

        public void Fill(int length)
        {
            m_Stream.Write(new byte[length], 0, length);
        }

        public int PacketID
        {
            get { return m_PacketID; }
        }

        public long Length
        {
            get { return m_Stream.Length; }
        }

        public long Position
        {
            get { return m_Stream.Position; }
            set { m_Stream.Position = value; }
        }

        public MemoryStream UnderlyingStream
        {
            get { return m_Stream; }
        }

        public long Seek(long offset, SeekOrigin origin)
        {
            return m_Stream.Seek(offset, origin);
        }

        public byte[] ToArray()
        {
            return m_Stream.ToArray();
        }
    }

    public unsafe sealed class PacketReader
    {
        private byte* m_Data;
        private int m_Pos;
        private int m_Length;
        private bool m_Dyn;

        public PacketReader(byte* buff, int len, bool dyn)
        {
            m_Data = buff;
            m_Length = len;
            m_Pos = 0;
            m_Dyn = dyn;
        }

        public PacketReader(byte[] buff, bool dyn)
        {
            fixed (byte* p = buff)
                m_Data = p;
            m_Length = buff.Length;
            m_Pos = 0;
            m_Dyn = dyn;
        }

        public void MoveToData()
        {
            m_Pos = m_Dyn ? 3 : 1;
        }

        public int Seek(int offset, SeekOrigin origin)
        {
            switch (origin)
            {
                case SeekOrigin.End:
                    m_Pos = m_Length - offset;
                    break;
                case SeekOrigin.Current:
                    m_Pos += offset;
                    break;
                case SeekOrigin.Begin:
                    m_Pos = offset;
                    break;
            }

            if (m_Pos < 0)
                m_Pos = 0;
            else if (m_Pos > m_Length)
                m_Pos = m_Length;
            return m_Pos;
        }

        public int Length
        {
            get { return m_Length; }
        }

        public bool DynamicLength
        {
            get { return m_Dyn; }
        }

        public byte[] CopyBytes(int offset, int count)
        {
            byte[] read = new byte[count];
            for (m_Pos = offset; m_Pos < offset + count && m_Pos < m_Length; m_Pos++)
                read[m_Pos - offset] = m_Data[m_Pos];
            return read;
        }

        public PacketReader GetCompressedReader()
        {
            int fullLen = ReadInt32();
            int destLen = 0;
            byte[] buff;

            if (fullLen >= 4)
            {
                int packLen = ReadInt32();
                destLen = packLen;

                if (destLen < 0)
                    destLen = 0;

                buff = new byte[destLen];

                if (fullLen > 4 && destLen > 0)
                {
                    if (ZLib.uncompress(buff, ref destLen, CopyBytes(this.Position, fullLen - 4), fullLen - 4) !=
                        ZLibError.Z_OK)
                    {
                        destLen = 0;
                        buff = new byte[1];
                    }
                }
                else
                {
                    destLen = 0;
                    buff = new byte[1];
                }
            }
            else
            {
                buff = new byte[1];
            }

            return new PacketReader(buff, false);
        }

        public byte ReadByte()
        {
            if (m_Pos + 1 > m_Length || m_Data == null)
                return 0;
            return m_Data[m_Pos++];
        }

        public int ReadInt32()
        {
            return (ReadByte() << 24)
                   | (ReadByte() << 16)
                   | (ReadByte() << 8)
                   | ReadByte();
        }

        public short ReadInt16()
        {
            return (short) ((ReadByte() << 8) | ReadByte());
        }

        public uint ReadUInt32()
        {
            return (uint) (
                (ReadByte() << 24)
                | (ReadByte() << 16)
                | (ReadByte() << 8)
                | ReadByte());
        }

        public ulong ReadRawUInt64()
        {
            return (ulong)
                (((ulong) ReadByte() << 0)
                 | ((ulong) ReadByte() << 8)
                 | ((ulong) ReadByte() << 16)
                 | ((ulong) ReadByte() << 24)
                 | ((ulong) ReadByte() << 32)
                 | ((ulong) ReadByte() << 40)
                 | ((ulong) ReadByte() << 48)
                 | ((ulong) ReadByte() << 56));
        }

        public ushort ReadUInt16()
        {
            return (ushort) ((ReadByte() << 8) | ReadByte());
        }

        public sbyte ReadSByte()
        {
            if (m_Pos + 1 > m_Length)
                return 0;
            return (sbyte) m_Data[m_Pos++];
        }

        public bool ReadBoolean()
        {
            return (ReadByte() != 0);
        }

        public string ReadUnicodeStringLE()
        {
            return ReadUnicodeString();
        }

        public string ReadUnicodeStringLESafe()
        {
            return ReadUnicodeStringSafe();
        }

        public string ReadUnicodeStringSafe()
        {
            StringBuilder sb = new StringBuilder();

            int c;

            while ((c = ReadUInt16()) != 0)
            {
                if (IsSafeChar(c))
                    sb.Append((char) c);
            }

            return sb.ToString();
        }

        public string ReadUnicodeString()
        {
            StringBuilder sb = new StringBuilder();

            int c;

            while ((c = ReadUInt16()) != 0)
                sb.Append((char) c);

            return sb.ToString();
        }

        public bool IsSafeChar(int c)
        {
            return (c >= 0x20 && c < 0xFFFE);
        }

        public string ReadUTF8StringSafe(int fixedLength)
        {
            if (m_Pos >= m_Length)
                return String.Empty;

            int bound = m_Pos + fixedLength;
            int end = bound;

            if (bound > m_Length)
                bound = m_Length;

            int count = 0;
            int index = m_Pos;
            int start = m_Pos;

            while (index < bound && ReadByte() != 0)
                ++count;

            Seek(start, SeekOrigin.Begin);

            index = 0;

            byte[] buffer = new byte[count];
            int value = 0;

            while (m_Pos < bound && (value = ReadByte()) != 0)
                buffer[index++] = (byte) value;

            string s = Encoding.UTF8.GetString(buffer);

            bool isSafe = true;

            for (int i = 0; isSafe && i < s.Length; ++i)
                isSafe = IsSafeChar((int) s[i]);

            Seek(start + fixedLength, SeekOrigin.Begin);

            if (isSafe)
                return s;

            StringBuilder sb = new StringBuilder(s.Length);

            for (int i = 0; i < s.Length; ++i)
            {
                if (IsSafeChar((int) s[i]))
                    sb.Append(s[i]);
            }

            return sb.ToString();
        }

        public string ReadUTF8StringSafe()
        {
            if (m_Pos >= m_Length)
                return String.Empty;

            int count = 0;
            int index = m_Pos;
            int start = index;

            while (index < m_Length && ReadByte() != 0)
                ++count;

            Seek(start, SeekOrigin.Begin);

            index = 0;

            byte[] buffer = new byte[count];
            int value = 0;

            while (m_Pos < m_Length && (value = ReadByte()) != 0)
                buffer[index++] = (byte) value;

            string s = Encoding.UTF8.GetString(buffer);

            bool isSafe = true;

            for (int i = 0; isSafe && i < s.Length; ++i)
                isSafe = IsSafeChar((int) s[i]);

            if (isSafe)
                return s;

            StringBuilder sb = new StringBuilder(s.Length);

            for (int i = 0; i < s.Length; ++i)
            {
                if (IsSafeChar((int) s[i]))
                    sb.Append(s[i]);
            }

            return sb.ToString();
        }

        public string ReadUTF8String()
        {
            if (m_Pos >= m_Length)
                return String.Empty;

            int count = 0;
            int index = m_Pos;
            int start = index;

            while (index < m_Length && ReadByte() != 0)
                ++count;

            Seek(start, SeekOrigin.Begin);

            index = 0;

            byte[] buffer = new byte[count];
            int value = 0;

            while (m_Pos < m_Length && (value = ReadByte()) != 0)
                buffer[index++] = (byte) value;

            return Encoding.UTF8.GetString(buffer);
        }

        public string ReadString()
        {
            return ReadStringSafe();
        }

        public string ReadStringSafe()
        {
            StringBuilder sb = new StringBuilder();

            int c;

            while (m_Pos < m_Length && (c = ReadByte()) != 0)
                sb.Append((char) c);

            return sb.ToString();
        }

        public string ReadUnicodeStringSafe(int fixedLength)
        {
            return ReadUnicodeString(fixedLength);
        }

        public string ReadUnicodeString(int fixedLength)
        {
            int bound = m_Pos + (fixedLength << 1);
            int end = bound;

            if (bound > m_Length)
                bound = m_Length;

            StringBuilder sb = new StringBuilder();

            int c;

            while ((m_Pos + 1) < bound && (c = ReadUInt16()) != 0)
                if (IsSafeChar(c))
                    sb.Append((char) c);

            Seek(end, SeekOrigin.Begin);

            return sb.ToString();
        }

        public string ReadUnicodeStringBE(int fixedLength)
        {
            int bound = m_Pos + (fixedLength << 1);
            int end = bound;

            if (bound > m_Length)
                bound = m_Length;

            StringBuilder sb = new StringBuilder();

            int c;

            while ((m_Pos + 1) < bound)
            {
                c = (ushort) (ReadByte() | (ReadByte() << 8));
                sb.Append((char) c);
            }

            Seek(end, SeekOrigin.Begin);

            return sb.ToString();
        }

        public string ReadStringSafe(int fixedLength)
        {
            return ReadString(fixedLength);
        }

        public string ReadString(int fixedLength)
        {
            int bound = m_Pos + fixedLength;
            int end = bound;

            if (bound > m_Length)
                bound = m_Length;

            StringBuilder sb = new StringBuilder();

            int c;

            while (m_Pos < bound && (c = ReadByte()) != 0)
                sb.Append((char) c);

            Seek(end, SeekOrigin.Begin);

            return sb.ToString();
        }

        public byte PacketID
        {
            get { return *m_Data; }
        }

        public int Position
        {
            get { return m_Pos; }
            set { m_Pos = value; }
        }

        public bool AtEnd
        {
            get { return m_Pos >= m_Length; }
        }
    }
}

================================================
FILE: Razor/Network/PacketHandler.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;

namespace Assistant
{
    public delegate void PacketViewerCallback(PacketReader p, PacketHandlerEventArgs args);

    public delegate void PacketFilterCallback(Packet p, PacketHandlerEventArgs args);

    public class PacketHandlerEventArgs
    {
        private bool m_Block;

        public bool Block
        {
            get { return m_Block; }
            set { m_Block = value; }
        }

        public PacketHandlerEventArgs()
        {
            Reinit();
        }

        public void Reinit()
        {
            m_Block = false;
        }
    }

    public class PacketHandler
    {
        private static Dictionary<int, List<PacketViewerCallback>> m_ClientViewers;
        private static Dictionary<int, List<PacketViewerCallback>> m_ServerViewers;

        private static Dictionary<int, List<PacketFilterCallback>> m_ClientFilters;
        private static Dictionary<int, List<PacketFilterCallback>> m_ServerFilters;

        static PacketHandler()
        {
            m_ClientViewers = new Dictionary<int, List<PacketViewerCallback>>();
            m_ServerViewers = new Dictionary<int, List<PacketViewerCallback>>();

            m_ClientFilters = new Dictionary<int, List<PacketFilterCallback>>();
            m_ServerFilters = new Dictionary<int, List<PacketFilterCallback>>();
        }

        internal static void RegisterClientToServerViewer(int packetID, PacketViewerCallback callback)
        {
            List<PacketViewerCallback> list;
            if (!m_ClientViewers.TryGetValue(packetID, out list) || list == null)
                m_ClientViewers[packetID] = list = new List<PacketViewerCallback>();
            list.Add(callback);
        }

        internal static void RegisterServerToClientViewer(int packetID, PacketViewerCallback callback)
        {
            List<PacketViewerCallback> list;
            if (!m_ServerViewers.TryGetValue(packetID, out list) || list == null)
                m_ServerViewers[packetID] = list = new List<PacketViewerCallback>();
            list.Add(callback);
        }

        internal static void RemoveClientToServerViewer(int packetID, PacketViewerCallback callback)
        {
            List<PacketViewerCallback> list;
            if (m_ClientViewers.TryGetValue(packetID, out list) && list != null)
                list.Remove(callback);
        }

        internal static void RemoveServerToClientViewer(int packetID, PacketViewerCallback callback)
        {
            List<PacketViewerCallback> list;
            if (m_ServerViewers.TryGetValue(packetID, out list) && list != null)
                list.Remove(callback);
        }

        internal static void RegisterClientToServerFilter(int packetID, PacketFilterCallback callback)
        {
            List<PacketFilterCallback> list;
            if (!m_ClientFilters.TryGetValue(packetID, out list) || list == null)
                m_ClientFilters[packetID] = list = new List<PacketFilterCallback>();
            list.Add(callback);
        }

        internal static void RegisterServerToClientFilter(int packetID, PacketFilterCallback callback)
        {
            List<PacketFilterCallback> list;
            if (!m_ServerFilters.TryGetValue(packetID, out list) || list == null)
                m_ServerFilters[packetID] = list = new List<PacketFilterCallback>();
            list.Add(callback);
        }

        internal static void RemoveClientToServerFilter(int packetID, PacketFilterCallback callback)
        {
            List<PacketFilterCallback> list;
            if (m_ClientFilters.TryGetValue(packetID, out list) && list != null)
                list.Remove(callback);
        }

        internal static void RemoveServerToClientFilter(int packetID, PacketFilterCallback callback)
        {
            List<PacketFilterCallback> list;
            if (m_ServerFilters.TryGetValue(packetID, out list) && list != null)
                list.Remove(callback);
        }

        public static bool OnServerPacket(int id, PacketReader pr, Packet p)
        {
            bool result = false;
            if (pr != null)
            {
                List<PacketViewerCallback> list;
                if (m_ServerViewers.TryGetValue(id, out list) && list != null && list.Count > 0)
                    result = ProcessViewers(list, pr);
            }

            if (p != null)
            {
                List<PacketFilterCallback> list;
                if (m_ServerFilters.TryGetValue(id, out list) && list != null && list.Count > 0)
                    result |= ProcessFilters(list, p);
            }

            return result;
        }


        public static bool OnClientPacket(int id, PacketReader pr, Packet p)
        {
            bool result = false;
            if (pr != null)
            {
                List<PacketViewerCallback> list;
                if (m_ClientViewers.TryGetValue(id, out list) && list != null && list.Count > 0)
                    result = ProcessViewers(list, pr);
            }

            if (p != null)
            {
                List<PacketFilterCallback> list;
                if (m_ClientFilters.TryGetValue(id, out list) && list != null && list.Count > 0)
                    result |= ProcessFilters(list, p);
            }

            return result;
        }

        public static bool HasClientViewer(int packetID)
        {
            List<PacketViewerCallback> list;
            return m_ClientViewers.TryGetValue(packetID, out list) && list != null && list.Count > 0;
        }

        public static bool HasServerViewer(int packetID)
        {
            List<PacketViewerCallback> list;
            return m_ServerViewers.TryGetValue(packetID, out list) && list != null && list.Count > 0;
        }

        public static bool HasClientFilter(int packetID)
        {
            List<PacketFilterCallback> list;
            return (m_ClientFilters.TryGetValue(packetID, out list) && list != null && list.Count > 0);
        }

        public static bool HasServerFilter(int packetID)
        {
            List<PacketFilterCallback> list;
            return (m_ServerFilters.TryGetValue(packetID, out list) && list != null && list.Count > 0);
        }

        private static PacketHandlerEventArgs m_Args = new PacketHandlerEventArgs();

        private static bool ProcessViewers(List<PacketViewerCallback> list, PacketReader p)
        {
            m_Args.Reinit();

            if (list != null)
            {
                int count = list.Count;
                for (int i = 0; i < count; i++)
                {
                    p.MoveToData();

                    try
                    {
                        list[i](p, m_Args);
                    }
                    catch (Exception e)
                    {
                        Engine.LogCrash(e);
                        new MessageDialog("WARNING: Packet viewer exception!", true, e.ToString()).Show();
                    }
                }
            }

            return m_Args.Block;
        }

        private static bool ProcessFilters(List<PacketFilterCallback> list, Packet p)
        {
            m_Args.Reinit();

            if (list != null)
            {
                for (int i = 0; i < list.Count; i++)
                {
                    p.MoveToData();

                    try
                    {
                        list[i](p, m_Args);
                    }
                    catch (Exception e)
                    {
                        Engine.LogCrash(e);
                        new MessageDialog("WARNING: Packet filter exception!", true, e.ToString()).Show();
                    }
                }
            }

            return m_Args.Block;
        }
    }
}

================================================
FILE: Razor/Network/PacketTable.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;

namespace Assistant
{
    public static class PacketsTable
    {
        private static readonly short[] _packetsTable = new short[255]
        {
            0x0068, // 0x00
            0x0005, // 0x01
            0x0007, // 0x02
            -1, // 0x03
            0x0002, // 0x04
            0x0005, // 0x05
            0x0005, // 0x06
            0x0007, // 0x07
            0x000E, // 0x08
            0x0005, // 0x09
            0x000B, // 0x0A
            0x010A, // 0x0B
            -1, // 0x0C
            0x0003, // 0x0D
            -1, // 0x0E
            0x003D, // 0x0F
            0x00D7, // 0x10
            -1, // 0x11
            -1, // 0x12
            0x000A, // 0x13
            0x0006, // 0x14
            0x0009, // 0x15
            0x0001, // 0x16
            -1, // 0x17
            -1, // 0x18
            -1, // 0x19
            -1, // 0x1A
            0x0025, // 0x1B
            -1, // 0x1C
            0x0005, // 0x1D
            0x0004, // 0x1E
            0x0008, // 0x1F
            0x0013, // 0x20
            0x0008, // 0x21
            0x0003, // 0x22
            0x001A, // 0x23
            0x0007, // 0x24
            0x0014, // 0x25
            0x0005, // 0x26
            0x0002, // 0x27
            0x0005, // 0x28
            0x0001, // 0x29
            0x0005, // 0x2A
            0x0002, // 0x2B
            0x0002, // 0x2C
            0x0011, // 0x2D
            0x000F, // 0x2E
            0x000A, // 0x2F
            0x0005, // 0x30
            0x0001, // 0x31
            0x0002, // 0x32
            0x0002, // 0x33
            0x000A, // 0x34
            0x028D, // 0x35
            -1, // 0x36
            0x0008, // 0x37
            0x0007, // 0x38
            0x0009, // 0x39
            -1, // 0x3A
            -1, // 0x3B
            -1, // 0x3C
            0x0002, // 0x3D
            0x0025, // 0x3E
            -1, // 0x3F
            0x00C9, // 0x40
            -1, // 0x41
            -1, // 0x42
            0x0229, // 0x43
            0x02C9, // 0x44
            0x0005, // 0x45
            -1, // 0x46
            0x000B, // 0x47
            0x0049, // 0x48
            0x005D, // 0x49
            0x0005, // 0x4A
            0x0009, // 0x4B
            -1, // 0x4C
            -1, // 0x4D
            0x0006, // 0x4E
            0x0002, // 0x4F
            -1, // 0x50
            -1, // 0x51
            -1, // 0x52
            0x0002, // 0x53
            0x000C, // 0x54
            0x0001, // 0x55
            0x000B, // 0x56
            0x006E, // 0x57
            0x006A, // 0x58
            -1, // 0x59
            -1, // 0x5A
            0x0004, // 0x5B
            0x0002, // 0x5C
            0x0049, // 0x5D
            -1, // 0x5E
            0x0031, // 0x5F
            0x0005, // 0x60
            0x0009, // 0x61
            0x000F, // 0x62
            0x000D, // 0x63
            0x0001, // 0x64
            0x0004, // 0x65
            -1, // 0x66
            0x0015, // 0x67
            -1, // 0x68
            -1, // 0x69
            0x0003, // 0x6A
            0x0009, // 0x6B
            0x0013, // 0x6C
            0x0003, // 0x6D
            0x000E, // 0x6E
            -1, // 0x6F
            0x001C, // 0x70
            -1, // 0x71
            0x0005, // 0x72
            0x0002, // 0x73
            -1, // 0x74
            0x0023, // 0x75
            0x0010, // 0x76
            0x0011, // 0x77
            -1, // 0x78
            0x0009, // 0x79
            -1, // 0x7A
            0x0002, // 0x7B
            -1, // 0x7C
            0x000D, // 0x7D
            0x0002, // 0x7E
            -1, // 0x7F
            0x003E, // 0x80
            -1, // 0x81
            0x0002, // 0x82
            0x0027, // 0x83
            0x0045, // 0x84
            0x0002, // 0x85
            -1, // 0x86
            -1, // 0x87
            0x0042, // 0x88
            -1, // 0x89
            -1, // 0x8A
            -1, // 0x8B
            0x000B, // 0x8C
            -1, // 0x8D
            -1, // 0x8E
            -1, // 0x8F
            0x0013, // 0x90
            0x0041, // 0x91
            -1, // 0x92
            0x0063, // 0x93
            -1, // 0x94
            0x0009, // 0x95
            -1, // 0x96
            0x0002, // 0x97
            -1, // 0x98
            0x001A, // 0x99
            -1, // 0x9A
            0x0102, // 0x9B
            0x0135, // 0x9C
            0x0033, // 0x9D
            -1, // 0x9E
            -1, // 0x9F
            0x0003, // 0xA0
            0x0009, // 0xA1
            0x0009, // 0xA2
            0x0009, // 0xA3
            0x0095, // 0xA4
            -1, // 0xA5
            -1, // 0xA6
            0x0004, // 0xA7
            -1, // 0xA8
            -1, // 0xA9
            0x0005, // 0xAA
            -1, // 0xAB
            -1, // 0xAC
            -1, // 0xAD
            -1, // 0xAE
            0x000D, // 0xAF
            -1, // 0xB0
            -1, // 0xB1
            -1, // 0xB2
            -1, // 0xB3
            -1, // 0xB4
            0x0040, // 0xB5
            0x0009, // 0xB6
            -1, // 0xB7
            -1, // 0xB8
            0x0003, // 0xB9 //aggiornato da 3 a 5
            0x0006, // 0xBA
            0x0009, // 0xBB
            0x0003, // 0xBC
            -1, // 0xBD
            -1, // 0xBE
            -1, // 0xBF
            0x0024, // 0xC0
            -1, // 0xC1
            -1, // 0xC2
            -1, // 0xC3
            0x0006, // 0xC4
            0x00CB, // 0xC5
            0x0001, // 0xC6
            0x0031, // 0xC7
            0x0002, // 0xC8
            0x0006, // 0xC9
            0x0006, // 0xCA
            0x0007, // 0xCB
            -1, // 0xCC
            0x0001, // 0xCD
            -1, // 0xCE
            0x004E, // 0xCF
            -1, // 0xD0
            0x0002, // 0xD1
            0x0019, // 0xD2
            -1, // 0xD3
            -1, // 0xD4
            -1, // 0xD5
            -1, // 0xD6
            -1, // 0xD7
            -1, // 0xD8
            0x010C, // 0xD9
            -1, // 0xDA
            -1, // 0xDB
            0x09, // dc
            -1, // dd
            -1, // de
            -1, // df
            -1, // e0
            -1, // e1
            0x0A, // e2
            -1, // e3
            -1, // e4
            -1, // e5
            0x05, // e6
            0x0C, // e7
            0x0D, // e8
            0x4B, // e9
            0x03, // ea
            -1, // eb
            -1, // ec
            -1, // ed
            0x0A, // ee
            0x0015, // ef -> mortacci tua
            -1, // f0
            0x09, // f1
            0x19, // f2
            0x1A, // f3 -> altro mortacci tua
            -1, // f4
            0x15, // f5
            -1, // f6
            -1, // f7
            0x6A, // f8
            -1, // f9
            0x01, // fa
            0x02, // fb
            -1, // fc
            -1, // fd
            -1 // ff
        };

        public static unsafe short GetPacketLength(byte* buff, int length)
        {
            if (length <= 0)
            {
                return 0;
            }

            short len = _packetsTable[buff[0]];

            if (len >= 0)
                return len;

            if (length >= 3)
            {
                return (short) (buff[1] << 8 | buff[2]);
            }

            return 0;
        }

        public static bool IsDynLength(byte id)
        {
            return (_packetsTable[id] == -1);
        }

        public static void AdjustPacketSizeByVersion(Version version)
        {
            /* TODO: This should really be 5.0.0.a */
            if (version >= new Version(5, 0, 0, 0))
            {
                _packetsTable[0x0B] = 0x07;
                _packetsTable[0x16] = -1;
                _packetsTable[0x31] = -1;
            }
            else
            {
                _packetsTable[0x0B] = 0x10A;
                _packetsTable[0x16] = 0x01;
                _packetsTable[0x31] = 0x01;
            }

            if (version >= new Version(5, 0, 9, 0))
                _packetsTable[0xE1] = -1;
            else
                _packetsTable[0xE1] = 0x09;

            if (version >= new Version(6, 0, 13, 0))
            {
                _packetsTable[0xE3] = -1;
                _packetsTable[0xE6] = 0x05;
                _packetsTable[0xE7] = 0x0C;
                _packetsTable[0xE8] = 0x0D;
                _packetsTable[0xE9] = 0x4B;
                _packetsTable[0xEA] = 0x03;
            }
            else
            {
                _packetsTable[0xE3] = 0x4D;
                _packetsTable[0xE6] = -1;
                _packetsTable[0xE7] = -1;
                _packetsTable[0xE8] = -1;
                _packetsTable[0xE9] = -1;
                _packetsTable[0xEA] = -1;
            }

            if (version >= new Version(6, 0, 17, 0))
            {
                _packetsTable[0x08] = 0x0F;
                _packetsTable[0x25] = 0x15;
            }
            else
            {
                _packetsTable[0x08] = 0x0E;
                _packetsTable[0x25] = 0x14;
            }

            if (version >= new Version(6, 0, 6, 0))
            {
                _packetsTable[0xEE] = 0x2000;
                _packetsTable[0xEF] = 0x2000;
                _packetsTable[0xF1] = 0x09;
            }
            else
            {
                _packetsTable[0xEE] = -1;
                _packetsTable[0xEF] = 0x15;
                _packetsTable[0xF1] = -1;
            }

            if (version >= new Version(6, 0, 14, 2))
                _packetsTable[0xB9] = 0x05;
            else
                _packetsTable[0xB9] = 0x03;

            if (version >= new Version(7, 0, 0, 0))
            {
                _packetsTable[0xEE] = 0x0A; //0x2000;
                _packetsTable[0xEF] = 0x15; //0x2000;
            }
            else
            {
                _packetsTable[0xEE] = -1;
                _packetsTable[0xEF] = 0x15;
            }

            if (version >= new Version(7, 0, 9, 0))
            {
                _packetsTable[0x24] = 0x09;
                _packetsTable[0x99] = 0x1E;
                _packetsTable[0xBA] = 0x0A;
                _packetsTable[0xF3] = 0x1A;
                _packetsTable[0xF1] = 0x09;
                _packetsTable[0xF2] = 0x19;
            }
            else
            {
                _packetsTable[0x24] = 0x07;
                _packetsTable[0x99] = 0x1A;
                _packetsTable[0xBA] = 0x06;
                _packetsTable[0xF3] = 0x18;
                _packetsTable[0xF1] = -1;
                _packetsTable[0xF2] = -1;
            }

            if (version >= new Version(7, 0, 18, 0))
                _packetsTable[0x00] = 0x6A;
            else
                _packetsTable[0x00] = 0x68;
        }
    }
}

================================================
FILE: Razor/Network/PacketWriter.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

/***************************************************************************
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 ***************************************************************************/

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;

namespace Assistant.Network
{
    /// <summary>
    ///     Provides functionality for writing primitive binary data.
    /// </summary>
    public class PacketWriter : IDisposable
    {
        private static readonly Stack<PacketWriter> Pool = new Stack<PacketWriter>();

        /// <summary>
        ///     Internal format buffer.
        /// </summary>
        private readonly byte[] _buffer = new byte[4];

        /// <summary>
        ///     Internal stream which holds the entire packet.
        /// </summary>
        private readonly MemoryStream _stream;

        private int m_Capacity;

        /// <summary>
        ///     Instantiates a new PacketWriter instance with the default capacity of 4 bytes.
        /// </summary>
        public PacketWriter() : this( 32 )
        {
        }

        /// <summary>
        ///     Instantiates a new PacketWriter instance with a given capacity.
        /// </summary>
        /// <param name="capacity">Initial capacity for the internal stream.</param>
        public PacketWriter( int capacity )
        {
            _stream = new MemoryStream( capacity );
            m_Capacity = capacity;
        }

        /// <summary>
        ///     Gets the total stream length.
        /// </summary>
        public long Length => _stream.Length;

        /// <summary>
        ///     Gets or sets the current stream position.
        /// </summary>
        public long Position
        {
            get => _stream.Position;
            set => _stream.Position = value;
        }

        /// <summary>
        ///     The internal stream used by this PacketWriter instance.
        /// </summary>
        public MemoryStream UnderlyingStream => _stream;

        public void Dispose()
        {
            Dispose( true );
            GC.SuppressFinalize( this );
        }

        public static PacketWriter CreateInstance()
        {
            return CreateInstance( 32 );
        }

        public static PacketWriter CreateInstance( int capacity )
        {
            PacketWriter pw = null;

            lock ( Pool )
            {
                if ( Pool.Count > 0 )
                {
                    pw = Pool.Pop();

                    if ( pw != null )
                    {
                        pw.m_Capacity = capacity;
                        pw._stream.SetLength( 0 );
                    }
                }
            }

            return pw ?? new PacketWriter( capacity );
        }

        public static void ReleaseInstance( PacketWriter pw )
        {
            lock ( Pool )
            {
                if ( !Pool.Contains( pw ) )
                {
                    Pool.Push( pw );
                }
                else
                {
                    try
                    {
                        using ( StreamWriter op = new StreamWriter( "neterr.log" ) )
                        {
                            op.WriteLine( "{0}\tInstance pool contains writer", DateTime.UtcNow );
                        }
                    }
                    catch
                    {
                        Console.WriteLine( @"net error" );
                    }
                }
            }
        }

        /// <summary>
        ///     Writes a 1-byte boolean value to the underlying stream. False is represented by 0, true by 1.
        /// </summary>
        public void Write( bool value )
        {
            _stream.WriteByte( (byte) ( value ? 1 : 0 ) );
        }

        /// <summary>
        ///     Writes a 1-byte unsigned integer value to the underlying stream.
        /// </summary>
        public void Write( byte value )
        {
            _stream.WriteByte( value );
        }

        /// <summary>
        ///     Writes a 1-byte signed integer value to the underlying stream.
        /// </summary>
        public void Write( sbyte value )
        {
            _stream.WriteByte( (byte) value );
        }

        /// <summary>
        ///     Writes a 2-byte signed integer value to the underlying stream.
        /// </summary>
        public void Write( short value )
        {
            _buffer[0] = (byte) ( value >> 8 );
            _buffer[1] = (byte) value;

            _stream.Write( _buffer, 0, 2 );
        }

        /// <summary>
        ///     Writes a 2-byte unsigned integer value to the underlying stream.
        /// </summary>
        public void Write( ushort value )
        {
            _buffer[0] = (byte) ( value >> 8 );
            _buffer[1] = (byte) value;

            _stream.Write( _buffer, 0, 2 );
        }

        /// <summary>
        ///     Writes a 4-byte signed integer value to the underlying stream.
        /// </summary>
        public void Write( int value )
        {
            _buffer[0] = (byte) ( value >> 24 );
            _buffer[1] = (byte) ( value >> 16 );
            _buffer[2] = (byte) ( value >> 8 );
            _buffer[3] = (byte) value;

            _stream.Write( _buffer, 0, 4 );
        }

        /// <summary>
        ///     Writes a 4-byte unsigned integer value to the underlying stream.
        /// </summary>
        public void Write( uint value )
        {
            _buffer[0] = (byte) ( value >> 24 );
            _buffer[1] = (byte) ( value >> 16 );
            _buffer[2] = (byte) ( value >> 8 );
            _buffer[3] = (byte) value;

            _stream.Write( _buffer, 0, 4 );
        }

        /// <summary>
        ///     Writes a sequence of bytes to the underlying stream
        /// </summary>
        public void Write( byte[] buffer, int offset, int size )
        {
            _stream.Write( buffer, offset, size );
        }

        /// <summary>
        ///     Writes a fixed-length ASCII-encoded string value to the underlying stream. To fit (size), the string content is
        ///     either truncated or padded with null characters.
        /// </summary>
        public void WriteAsciiFixed( string value, int size )
        {
            if ( value == null )
            {
                Console.WriteLine( @"Network: Attempted to WriteAsciiFixed() with null value" );
                value = string.Empty;
            }

            int length = value.Length;

            _stream.SetLength( _stream.Length + size );

            if ( length >= size )
            {
                _stream.Position +=
                    Encoding.ASCII.GetBytes( value, 0, size, _stream.GetBuffer(), (int) _stream.Position );
            }
            else
            {
                Encoding.ASCII.GetBytes( value, 0, length, _stream.GetBuffer(), (int) _stream.Position );
                _stream.Position += size;
            }

            /*byte[] buffer = Encoding.ASCII.GetBytes( value );

			if ( buffer.Length >= size )
			{
				m_Stream.Write( buffer, 0, size );
			}
			else
			{
				m_Stream.Write( buffer, 0, buffer.Length );
				Fill( size - buffer.Length );
			}*/
        }

        /// <summary>
        ///     Writes a dynamic-length ASCII-encoded string value to the underlying stream, followed by a 1-byte null character.
        /// </summary>
        public void WriteAsciiNull( string value )
        {
            if ( value == null )
            {
                Console.WriteLine( @"Network: Attempted to WriteAsciiNull() with null value" );
                value = string.Empty;
            }

            int length = value.Length;

            _stream.SetLength( _stream.Length + length + 1 );

            Encoding.ASCII.GetBytes( value, 0, length, _stream.GetBuffer(), (int) _stream.Position );
            _stream.Position += length + 1;

            /*byte[] buffer = Encoding.ASCII.GetBytes( value );

			m_Stream.Write( buffer, 0, buffer.Length );
			m_Stream.WriteByte( 0 );*/
        }

        /// <summary>
        ///     Writes a dynamic-length little-endian unicode string value to the underlying stream, followed by a 2-byte null
        ///     character.
        /// </summary>
        public void WriteLittleUniNull( string value )
        {
            if ( value == null )
            {
                Console.WriteLine( @"Network: Attempted to WriteLittleUniNull() with null value" );
                value = string.Empty;
            }

            int length = value.Length;

            _stream.SetLength( _stream.Length + ( length + 1 ) * 2 );

            _stream.Position +=
                Encoding.Unicode.GetBytes( value, 0, length, _stream.GetBuffer(), (int) _stream.Position );
            _stream.Position += 2;

            /*byte[] buffer = Encoding.Unicode.GetBytes( value );

			m_Stream.Write( buffer, 0, buffer.Length );

			m_Buffer[0] = 0;
			m_Buffer[1] = 0;
			m_Stream.Write( m_Buffer, 0, 2 );*/
        }

        /// <summary>
        ///     Writes a fixed-length little-endian unicode string value to the underlying stream. To fit (size), the string
        ///     content is either truncated or padded with null characters.
        /// </summary>
        public void WriteLittleUniFixed( string value, int size )
        {
            if ( value == null )
            {
                Console.WriteLine( @"Network: Attempted to WriteLittleUniFixed() with null value" );
                value = string.Empty;
            }

            size *= 2;

            int length = value.Length;

            _stream.SetLength( _stream.Length + size );

            if ( length * 2 >= size )
            {
                _stream.Position +=
                    Encoding.Unicode.GetBytes( value, 0, length, _stream.GetBuffer(), (int) _stream.Position );
            }
            else
            {
                Encoding.Unicode.GetBytes( value, 0, length, _stream.GetBuffer(), (int) _stream.Position );
                _stream.Position += size;
            }

            /*size *= 2;

			byte[] buffer = Encoding.Unicode.GetBytes( value );

			if ( buffer.Length >= size )
			{
				m_Stream.Write( buffer, 0, size );
			}
			else
			{
				m_Stream.Write( buffer, 0, buffer.Length );
				Fill( size - buffer.Length );
			}*/
        }

        /// <summary>
        ///     Writes a dynamic-length big-endian unicode string value to the underlying stream, followed by a 2-byte null
        ///     character.
        /// </summary>
        public void WriteBigUniNull( string value )
        {
            if ( value == null )
            {
                Console.WriteLine( @"Network: Attempted to WriteBigUniNull() with null value" );
                value = string.Empty;
            }

            int length = value.Length;

            _stream.SetLength( _stream.Length + ( length + 1 ) * 2 );

            _stream.Position +=
                Encoding.BigEndianUnicode.GetBytes( value, 0, length, _stream.GetBuffer(), (int) _stream.Position );
            _stream.Position += 2;

            /*byte[] buffer = Encoding.BigEndianUnicode.GetBytes( value );

			m_Stream.Write( buffer, 0, buffer.Length );

			m_Buffer[0] = 0;
			m_Buffer[1] = 0;
			m_Stream.Write( m_Buffer, 0, 2 );*/
        }

        /// <summary>
        ///     Writes a fixed-length big-endian unicode string value to the underlying stream. To fit (size), the string content
        ///     is either truncated or padded with null characters.
        /// </summary>
        public void WriteBigUniFixed( string value, int size )
        {
            if ( value == null )
            {
                Console.WriteLine( @"Network: Attempted to WriteBigUniFixed() with null value" );
                value = string.Empty;
            }

            size *= 2;

            int length = value.Length;

            _stream.SetLength( _stream.Length + size );

            if ( length * 2 >= size )
            {
                _stream.Position +=
                    Encoding.BigEndianUnicode.GetBytes( value, 0, length, _stream.GetBuffer(), (int) _stream.Position );
            }
            else
            {
                Encoding.BigEndianUnicode.GetBytes( value, 0, length, _stream.GetBuffer(), (int) _stream.Position );
                _stream.Position += size;
            }

            /*size *= 2;

			byte[] buffer = Encoding.BigEndianUnicode.GetBytes( value );

			if ( buffer.Length >= size )
			{
				m_Stream.Write( buffer, 0, size );
			}
			else
			{
				m_Stream.Write( buffer, 0, buffer.Length );
				Fill( size - buffer.Length );
			}*/
        }

        /// <summary>
        ///     Fills the stream from the current position up to (capacity) with 0x00's
        /// </summary>
        public void Fill()
        {
            Fill( (int) ( m_Capacity - _stream.Length ) );
        }

        /// <summary>
        ///     Writes a number of 0x00 byte values to the underlying stream.
        /// </summary>
        public void Fill( int length )
        {
            if ( _stream.Position == _stream.Length )
            {
                _stream.SetLength( _stream.Length + length );
                _stream.Seek( 0, SeekOrigin.End );
            }
            else
            {
                _stream.Write( new byte[length], 0, length );
            }
        }

        /// <summary>
        ///     Offsets the current position from an origin.
        /// </summary>
        public long Seek( long offset, SeekOrigin origin )
        {
            return _stream.Seek( offset, origin );
        }

        /// <summary>
        ///     Gets the entire stream content as a byte array.
        /// </summary>
        public byte[] ToArray()
        {
            return _stream.ToArray();
        }

        protected virtual void Dispose( bool isDisposing )
        {
            if ( isDisposing )
            {
                _stream.Dispose();
            }

            GC.SuppressFinalize( this );
        }
    }
}

================================================
FILE: Razor/Network/Packets.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections;
using System.Collections.Generic;
using Assistant.Agents;
using Ultima;

namespace Assistant
{
    public enum MessageType
    {
        Regular = 0x00,
        System = 0x01,
        Emote = 0x02,
        Label = 0x06,
        Focus = 0x07,
        Whisper = 0x08,
        Yell = 0x09,
        Spell = 0x0A,
        Guild = 0x0D,
        Alliance = 0x0E,
        Encoded = 0xC0,

        Special = 0x20
    }

    public sealed class QueryPartyLocs : Packet
    {
        public QueryPartyLocs() : base(0xF0)
        {
            EnsureCapacity(4);
            Write((byte) 0x00);
        }
    }

    public sealed class SendPartyMessage : Packet
    {
        public SendPartyMessage(string message) : base(0xBF)
        {
            EnsureCapacity(1 + 2 + 2 + 1 + 4);

            Write((ushort) 0x06); // party command
            Write((byte) 0x04); // tell party
            WriteBigUniNull(message);
        }
    }

    public sealed class AcceptParty : Packet
    {
        public AcceptParty(Serial leader) : base(0xBF)
        {
            EnsureCapacity(1 + 2 + 2 + 1 + 4);

            Write((ushort) 0x06); // party command
            Write((byte) 0x08); // accept
            Write((uint) leader);
        }
    }

    public sealed class DeclineParty : Packet
    {
        public DeclineParty(Serial leader) : base(0xBF)
        {
            EnsureCapacity(1 + 2 + 2 + 1 + 4);

            Write((ushort) 0x06); // party command
            Write((byte) 0x09); // decline
            Write((uint) leader);
        }
    }

    public sealed class AddParty : Packet
    {
        public AddParty() : base(0xBF)
        {
            EnsureCapacity(1 + 2 + 2 + 1 + 4);

            Write((ushort)0x06); // party command
            Write((byte)0x01); // add party
            Write(0);
        }
    }

    public sealed class SendMessageParty : Packet
    {
        public SendMessageParty(string message) : base(0xBF)
        {
            EnsureCapacity(1 + 2 + 2 + 1 + 4);

            Write((ushort) 0x06); // party command
            Write((byte) 0x04); // tell party
            WriteBigUniNull(message);
        }
    }

    public sealed class ContainerContent : Packet
    {
        public ContainerContent(List<Item> items) : this(items, Engine.UsePostKRPackets)
        {
        }

        public ContainerContent(List<Item> items, bool useKR) : base(0x3C)
        {
            Write((ushort) items.Count);

            foreach (Item item in items)
            {
                Write((uint) item.Serial);
                Write((ushort) item.ItemID);
                Write((sbyte) 0);
                Write((ushort) item.Amount);
                Write((ushort) item.Position.X);
                Write((ushort) item.Position.Y);

                if (useKR)
                    Write((byte) item.GridNum);

                if (item.Container is Item)
                    Write((uint) ((Item) item.Container).Serial);
                else
                    Write((uint) 0);
                Write((ushort) item.Hue);
            }
        }
    }

    public sealed class ContainerItem : Packet
    {
        public ContainerItem(Item item) : this(item, Engine.UsePostKRPackets)
        {
        }

        public ContainerItem(Item item, bool isKR) : base(0x25, 20)
        {
            if (isKR)
                EnsureCapacity(21);

            Write(item.Serial);

            Write(item.ItemID);
            Write((byte) 0);
            Write(item.Amount);
            Write((ushort) item.Position.X);
            Write((ushort) item.Position.Y);

            if (isKR)
                Write(item.GridNum);

            object cont = item.Container;
            if (cont is UOEntity)
                Write((uint) ((UOEntity) item.Container).Serial);
            else if (cont is uint)
                Write((uint) cont);
            else if (cont is Serial)
                Write((Serial) item.Container);
            else
                Write((uint) 0x7FFFFFFF);

            if (SearchExemptionAgent.Contains(item))
                Write((ushort) Config.GetInt("ExemptColor"));
            else
                Write(item.Hue);
        }
    }

    public sealed class SingleClick : Packet
    {
        public SingleClick(object clicked) : base(0x09, 5)
        {
            if (clicked is Mobile)
                Write(((Mobile) clicked).Serial);
            else if (clicked is Item)
                Write(((Item) clicked).Serial);
            else if (clicked is Serial)
                Write(((Serial) clicked).Value);
            else
                Write((uint) 0);
        }
    }

    public sealed class DoubleClick : Packet
    {
        public DoubleClick(Serial clicked) : base(0x06, 5)
        {
            Write((uint) clicked.Value);
        }
    }

    public sealed class Target : Packet
    {
        public Target(uint tid) : this(tid, false, 0)
        {
        }

        public Target(uint tid, byte flags) : this(tid, false, flags)
        {
        }

        public Target(uint tid, bool ground) : this(tid, ground, 0)
        {
        }

        public Target(uint tid, bool ground, byte flags) : base(0x6C, 19)
        {
            Write(ground);
            Write(tid);
            Write(flags);
            Fill();
        }
    }

    public sealed class TargetResponse : Packet
    {
        public TargetResponse(TargetInfo info) : base(0x6C, 19)
        {
            Write((byte) info.Type);
            Write((uint) info.TargID);
            Write((byte) info.Flags);
            Write((uint) info.Serial);
            Write((ushort) info.X);
            Write((ushort) info.Y);
            Write((short) info.Z);
            Write((ushort) info.Gfx);
        }

        public TargetResponse(uint id, Mobile m) : base(0x6C, 19)
        {
            Write((byte) 0x00); // target object
            Write((uint) id);
            Write((byte) 0); // flags
            Write((uint) m.Serial);
            Write((ushort) m.Position.X);
            Write((ushort) m.Position.Y);
            Write((short) m.Position.Z);
            Write((ushort) m.Body);
        }

        public TargetResponse(uint id, Item item) : base(0x6C, 19)
        {
            Write((byte) 0x00); // target object
            Write((uint) id);
            Write((byte) 0); // flags
            Write((uint) item.Serial);
            Write((ushort) item.Position.X);
            Write((ushort) item.Position.Y);
            Write((short) item.Position.Z);
            Write((ushort) item.ItemID);
        }
        
    }

    public sealed class TargetCancelResponse : Packet
    {
        public TargetCancelResponse(uint id) : base(0x6C, 19)
        {
            Write((byte) 0);
            Write((uint) id);
            Write((byte) 0);
            Write((uint) 0);
            Write((ushort) 0xFFFF);
            Write((ushort) 0xFFFF);
            Write((short) 0);
            Write((ushort) 0);
        }
    }

    public sealed class AttackReq : Packet
    {
        public AttackReq(Serial serial) : base(0x05, 5)
        {
            Write((uint) serial);
        }
    }

    public sealed class SetWeather : Packet
    {
        public SetWeather(int type, int num) : base(0x65, 4)
        {
            Write((byte) type); //types: 0x00 - "It starts to rain", 0x01 - "A fierce storm approaches.", 0x02 - "It begins to snow", 0x03 - "A storm is brewing.", 0xFF - None (turns off sound effects), 0xFE (no effect?? Set temperature?)
            Write((byte) num); //number of weather effects on screen
            Write((byte) 0xFE);
        }
    }

    public sealed class PlayMusic : Packet
    {
        public PlayMusic(ushort num) : base(0x6D, 3)
        {
            Write(num);
        }
    }

    public sealed class CancelTarget : Packet
    {
        public CancelTarget(uint id) : base(0x6C, 19)
        {
            Write((byte) 0);
            Write((uint) id);
            Write((byte) 3);
            Fill();
        }
    }

    public sealed class SkillsQuery : Packet
    {
        public SkillsQuery(Mobile m) : base(0x34, 10)
        {
            Write((uint) 0xEDEDEDED); // que el fuck, osi
            Write((byte) 0x05);
            Write(m.Serial);
        }
    }

    public sealed class StatusQuery : Packet
    {
        public StatusQuery(Mobile m) : base(0x34, 10)
        {
            Write((uint) 0xEDEDEDED);
            Write((byte) 0x04);
            Write(m.Serial);
        }
    }

    public sealed class StatLockInfo : Packet
    {
        public StatLockInfo(PlayerData m) : base(0xBF)
        {
            this.EnsureCapacity(12);

            Write((short) 0x19);
            Write((byte) 2);
            Write((int) m.Serial);
            Write((byte) 0);

            int lockBits = 0;

            lockBits |= (int) m.StrLock << 4;
            lockBits |= (int) m.DexLock << 2;
            lockBits |= (int) m.IntLock;

            Write((byte) lockBits);
        }
    }

    public sealed class SkillsList : Packet
    {
        public SkillsList() : base(0x3A)
        {
            EnsureCapacity(3 + 1 + Skills.TotalSkills() * 9 + 2);

            Write((byte) 0x02);
            for (int i = 0; i < Skills.TotalSkills(); i++)
            {
                Write((short) (i + 1));
                Write(World.Player.Skills[i].FixedValue);
                Write(World.Player.Skills[i].FixedBase);
                Write((byte) World.Player.Skills[i].Lock);
                Write(World.Player.Skills[i].FixedCap);
            }

            Write((short) 0);
        }
    }

    public sealed class SkillUpdate : Packet
    {
        public SkillUpdate(Skill s) : base(0x3A)
        {
            EnsureCapacity(3 + 1 + 9);

            Write((byte) 0xDF);

            Write((short) s.Index);
            Write((ushort) s.FixedValue);
            Write((ushort) s.FixedBase);
            Write((byte) s.Lock);
            Write((ushort) s.FixedCap);
        }
    }

    public sealed class SetSkillLock : Packet
    {
        public SetSkillLock(int skill, LockType type) : base(0x3A)
        {
            EnsureCapacity(6);
            Write((short) skill);
            Write((byte) type);
        }
    }

    public sealed class AsciiMessage : Packet
    {
        public AsciiMessage(Serial serial, int graphic, MessageType type, int hue, int font, string name,
            string text) : base(0x1C)
        {
            if (name == null) name = "";
            if (text == null) text = "";

            if (hue == 0)
                hue = 0x3B2;

            this.EnsureCapacity(45 + text.Length);

            Write((uint) serial);
            Write((short) graphic);
            Write((byte) type);
            Write((short) hue);
            Write((short) font);
            WriteAsciiFixed(name, 30);
            WriteAsciiNull(text);
        }
    }

    public sealed class ClientAsciiMessage : Packet
    {
        public ClientAsciiMessage(MessageType type, int hue, int font, string str) : base(0x03)
        {
            EnsureCapacity(1 + 2 + 1 + 2 + 2 + str.Length + 1);

            Write((byte) type);
            Write((short) hue);
            Write((short) font);
            WriteAsciiNull(str);
        }
    }

    public sealed class UnicodeMessage : Packet
    {
        public UnicodeMessage(Serial serial, int graphic, MessageType type, int hue, int font, string lang, string name,
            string text) : base(0xAE)
        {
            if (lang == null || lang == "") lang = "ENU";
            if (name == null) name = "";
            if (text == null) text = "";

            if (hue == 0)
                hue = 0x3B2;

            this.EnsureCapacity(50 + (text.Length * 2));

            Write((uint) serial);
            Write((ushort) graphic);
            Write((byte) type);
            Write((ushort) hue);
            Write((ushort) font);
            WriteAsciiFixed(lang.ToUpper(), 4);
            WriteAsciiFixed(name, 30);
            WriteBigUniNull(text);
        }
    }

    public sealed class ClientUniMessage : Packet
    {
        public ClientUniMessage(MessageType type, int hue, int font, string lang, ArrayList keys, string text) :
            base(0xAD)
        {
            if (lang == null || lang == "") lang = "ENU";
            if (text == null) text = "";

            this.EnsureCapacity(50 + (text.Length * 2) + (keys == null ? 0 : keys.Count + 1));
            if (keys == null || keys.Count <= 1)
                Write((byte) type);
            else
                Write((byte) (type | MessageType.Encoded));
            Write((short) hue);
            Write((short) font);
            WriteAsciiFixed(lang, 4);
            if (keys != null && keys.Count > 1)
            {
                Write((ushort) keys[0]);
                for (int i = 1; i < keys.Count; i++)
                    Write((byte) keys[i]);
                WriteUTF8Null(text);
            }
            else
            {
                WriteBigUniNull(text);
            }
        }
    }

    public sealed class ClientUniEncodedCommandMessage : Packet
    {
        public ClientUniEncodedCommandMessage(MessageType type, int hue, int font, string lang, List<ushort> keys,
            string text) : base(0xAD)
        {
            if (lang == null || lang == "") lang = "ENU";
            if (text == null) text = "";

            this.EnsureCapacity(50 + (text.Length * 2) + (keys == null ? 0 : keys.Count + 1));
            if (keys == null || keys.Count <= 1)
                Write((byte) type);
            else
                Write((byte) (type | MessageType.Encoded));
            Write((short) hue);
            Write((short) font);
            WriteAsciiFixed(lang, 4);
            if (keys != null && keys.Count > 1)
            {
                Write(keys[0]);
                for (int i = 1; i < keys.Count; i++)
                    Write((byte) keys[i]);
                WriteUTF8Null(text);
            }
            else
            {
                WriteBigUniNull(text);
            }
        }
    }

    public sealed class LiftRequest : Packet
    {
        public LiftRequest(Serial ser, int amount) : base(0x07, 7)
        {
            this.Write(ser.Value);
            this.Write((ushort) amount);
        }

        public LiftRequest(Item i, int amount) : this(i.Serial, amount)
        {
        }

        public LiftRequest(Item i) : this(i.Serial, i.Amount)
        {
        }
    }

    public sealed class LiftRej : Packet
    {
        public LiftRej() : this(5) // reason = Inspecific
        {
        }

        public LiftRej(byte reason) : base(0x27, 2)
        {
            Write(reason);
        }
    }

    public sealed class EquipRequest : Packet
    {
        public EquipRequest(Serial item, Mobile to, Layer layer) : base(0x13, 10)
        {
            Write(item);
            Write((byte) layer);
            Write(to.Serial);
        }

        public EquipRequest(Serial item, Serial to, Layer layer) : base(0x13, 10)
        {
            Write(item);
            Write((byte) layer);
            Write(to);
        }
    }

    public sealed class DropRequest : Packet
    {
        public DropRequest(Item item, Serial destSer) : base(0x08, 14)
        {
            if (Engine.UsePostKRPackets)
                EnsureCapacity(15);

            Write(item.Serial);
            Write((short) (-1));
            Write((short) (-1));
            Write((sbyte) 0);
            if (Engine.UsePostKRPackets)
                Write((byte) 0);
            Write(destSer);
        }

        public DropRequest(Item item, Item to) : this(item, to.Serial)
        {
        }

        public DropRequest(Serial item, Point3D pt, Serial dest) : base(0x08, 14)
        {
            if (Engine.UsePostKRPackets)
                EnsureCapacity(15);

            Write(item);
            Write((ushort) pt.X);
            Write((ushort) pt.Y);
            Write((sbyte) pt.Z);
            if (Engine.UsePostKRPackets)
                Write((byte) 0);
            Write(dest);
        }

        public DropRequest(Item item, Point3D pt, Serial destSer) : this(item.Serial, pt, destSer)
        {
        }
    }

    public class SellListItem
    {
        public Serial Serial;
        public ushort Amount;

        public SellListItem(Serial s, ushort a)
        {
            Serial = s;
            Amount = a;
        }
    }

    public sealed class VendorSellResponse : Packet
    {
        public VendorSellResponse(Mobile vendor, List<SellListItem> list) : base(0x9F)
        {
            EnsureCapacity(1 + 2 + 4 + 2 + list.Count * 6);

            Write((uint) vendor.Serial);
            Write((ushort) list.Count);

            for (int i = 0; i < list.Count; i++)
            {
                SellListItem sli = list[i];
                Write((uint) sli.Serial);
                Write((ushort) sli.Amount);
            }
        }
    }

    public sealed class MobileStatusExtended : Packet
    {
        public MobileStatusExtended(PlayerData m) : base(0x11)
        {
            string name = m.Name;
            if (name == null) name = "";

            this.EnsureCapacity(88);

            Write((uint) m.Serial);
            WriteAsciiFixed(name, 30);

            Write((short) m.Hits);
            Write((short) m.HitsMax);

            Write(false); // cannot edit name

            Write((byte) 0x03); // no aos info

            Write(m.Female);

            Write((short) m.Str);
            Write((short) m.Dex);
            Write((short) m.Int);

            Write((short) m.Stam);
            Write((short) m.StamMax);

            Write((short) m.Mana);
            Write((short) m.ManaMax);

            Write((int) m.Gold);
            Write((short) m.AR);
            Write((short) m.Weight);
            Write((short) m.StatCap);
            Write((byte) m.Followers);
            Write((byte) m.FollowersMax);
        }
    }

    public sealed class MobileStatusCompact : Packet
    {
        public MobileStatusCompact(Mobile m) : base(0x11)
        {
            string name = m.Name;
            if (name == null) name = "";

            this.EnsureCapacity(88);

            Write((uint) m.Serial);
            WriteAsciiFixed(name, 30);

            Write((short) m.Hits);
            Write((short) m.HitsMax);

            Write(false); // cannot edit name

            Write((byte) 0x00); // no aos info
        }
    }

    public sealed class GumpTextEntry
    {
        public GumpTextEntry(ushort id, string s)
        {
            EntryID = id;
            Text = s;
        }

        public ushort EntryID;
        public string Text;
    }

    public sealed class GumpResponse : Packet
    {
        public GumpResponse(uint serial, uint tid, int bid, int[] switches, GumpTextEntry[] entries) : base(0xB1)
        {
            EnsureCapacity(3 + 4 + 4 + 4 + 4 + switches.Length * 4 + 4 + entries.Length * 4);

            Write((uint) serial);
            Write((uint) tid);

            Write((int) bid);

            Write((int) switches.Length);
            for (int i = 0; i < switches.Length; i++)
                Write((int) switches[i]);
            Write((int) entries.Length);
            for (int i = 0; i < entries.Length; i++)
            {
                GumpTextEntry gte = (GumpTextEntry) entries[i];
                Write((ushort) gte.EntryID);
                Write((ushort) (gte.Text.Length * 2));
                WriteBigUniFixed(gte.Text, gte.Text.Length);
            }
        }
    }

    public sealed class CompressedGump : Packet
    {
        public CompressedGump(uint serial, uint tid, int bid, int[] switches, GumpTextEntry[] entries) : base(0xDD)
        {
            EnsureCapacity(3 + 4 + 4 + 4 + 4 + switches.Length * 4 + 4 + entries.Length * 4);

            Write((uint) serial);
            Write((uint) tid);

            Write((int) bid);

            Write((int) switches.Length);
            for (int i = 0; i < switches.Length; i++)
                Write((int) switches[i]);
            Write((int) entries.Length);
            for (int i = 0; i < entries.Length; i++)
            {
                GumpTextEntry gte = (GumpTextEntry) entries[i];
                Write((ushort) gte.EntryID);
                Write((ushort) (gte.Text.Length * 2));
                WriteBigUniFixed(gte.Text, gte.Text.Length);
            }
        }
    }

    public sealed class UseSkill : Packet
    {
        public UseSkill(int sk) : base(0x12)
        {
            string cmd = $"{sk} 0";
            EnsureCapacity(4 + cmd.Length + 1);
            Write((byte) 0x24);
            WriteAsciiNull(cmd);
        }
    }

    public sealed class ExtCastSpell : Packet
    {
        public ExtCastSpell(Serial book, ushort spell) : base(0xBF)
        {
            EnsureCapacity(1 + 2 + 2 + 2 + 4 + 2);
            Write((short) 0x1C);
            Write((short) (book.IsItem ? 1 : 2));
            if (book.IsItem)
                Write((uint) book);
            Write((short) spell);
        }
    }

    public sealed class CastSpellFromBook : Packet
    {
        public CastSpellFromBook(Serial book, ushort spell) : base(0x12)
        {
            string cmd;
            if (book.IsItem)
                cmd = $"{spell} {book.Value}";
            else
                cmd = $"{spell}";
            EnsureCapacity(3 + 1 + cmd.Length + 1);
            Write((byte) 0x27);
            WriteAsciiNull(cmd);
        }
    }

    public sealed class CastSpellFromMacro : Packet
    {
        public CastSpellFromMacro(ushort spell) : base(0x12)
        {
            string cmd = spell.ToString();
            EnsureCapacity(3 + 1 + cmd.Length + 1);
            Write((byte) 0x56);
            WriteAsciiNull(cmd);
        }
    }

    public sealed class DisarmRequest : Packet
    {
        public DisarmRequest() : base(0xBF)
        {
            EnsureCapacity(3);
            Write((ushort) 0x09);
        }
    }

    public sealed class StunRequest : Packet
    {
        public StunRequest() : base(0xBF)
        {
            EnsureCapacity(3);
            Write((ushort) 0x0A);
        }
    }

    public sealed class CloseGump : Packet
    {
        public CloseGump(uint typeID, uint buttonID) : base(0xBF)
        {
            EnsureCapacity(13);

            Write((short) 0x04);
            Write((int) typeID);
            Write((int) buttonID);
        }

        public CloseGump(uint typeID) : base(0xBF)
        {
            EnsureCapacity(13);

            Write((short) 0x04);
            Write((int) typeID);
            Write((int) 0);
        }
    }

    public sealed class ChangeCombatant : Packet
    {
        public ChangeCombatant(Serial ser) : base(0xAA, 5)
        {
            Write((uint) ser);
        }

        public ChangeCombatant(Mobile m) : this(m.Serial)
        {
        }
    }

    public sealed class UseAbility : Packet
    {
        // ints are 'encoded' with a leading bool, if true then the number is 0, if flase then followed by all 4 bytes (lame :-)
        public UseAbility(AOSAbility a) : base(0xD7)
        {
            EnsureCapacity(1 + 2 + 4 + 2 + 4);

            Write((uint) World.Player.Serial);
            Write((ushort) 0x19);
            if (a == AOSAbility.Clear)
            {
                Write(true);
            }
            else
            {
                Write(false);
                Write((int) a);
            }
        }
    }

    public sealed class ClearAbility : Packet
    {
        public static readonly Packet Instance = new ClearAbility();

        public ClearAbility() : base(0xBF)
        {
            EnsureCapacity(5);

            Write((short) 0x21);
        }
    }

    public sealed class PingPacket : Packet
    {
        public PingPacket(byte seq) : base(0x73, 2)
        {
            Write(seq);
        }
    }

    public sealed class MobileUpdate : Packet
    {
        public MobileUpdate(Mobile m) : base(0x20, 19)
        {
            Write((int) m.Serial);
            Write((short) m.Body);
            Write((byte) 0);
            int ltHue = Config.GetInt("LTHilight");
            if (ltHue != 0 && Targeting.IsLastTarget(m))
                Write((short) (ltHue | 0x8000));
            else
                Write((short) m.Hue);
            Write((byte) m.GetPacketFlags());
            Write((short) m.Position.X);
            Write((short) m.Position.Y);
            Write((short) 0);
            Write((byte) m.Direction);
            Write((sbyte) m.Position.Z);
        }
    }

    public sealed class MobileIncoming : Packet
    {
        public MobileIncoming(Mobile m) : base(0x78)
        {
            int count = m.Contains.Count;
            int ltHue = Config.GetInt("LTHilight");
            bool isLT;
            if (ltHue != 0)
                isLT = Targeting.IsLastTarget(m);
            else
                isLT = false;

            EnsureCapacity(3 + 4 + 2 + 2 + 2 + 1 + 1 + 2 + 1 + 1 + 4 + count * (4 + 2 + 1 + 2));
            Write((uint) m.Serial);
            Write((ushort) m.Body);
            Write((ushort) m.Position.X);
            Write((ushort) m.Position.Y);
            Write((sbyte) m.Position.Z);
            Write((byte) m.Direction);
            Write((ushort) (isLT ? ltHue | 0x8000 : m.Hue));
            Write((byte) m.GetPacketFlags());
            Write((byte) m.Notoriety);

            for (int i = 0; i < count; ++i)
            {
                Item item = (Item) m.Contains[i];

                int itemID = item.ItemID & 0x3FFF;
                bool writeHue = (item.Hue != 0);
                if (writeHue || isLT)
                    itemID |= 0x8000;

                Write((uint) item.Serial);
                Write((ushort) itemID);
                Write((byte) item.Layer);
                if (isLT)
                    Write((ushort) (ltHue & 0x3FFF));
                else if (writeHue)
                    Write((ushort) item.Hue);
            }

            Write((uint) 0); // terminate
        }
    }

    public class VendorBuyItem
    {
        public VendorBuyItem(Serial ser, int amount, int price)
        {
            Serial = ser;
            Amount = amount;
            Price = price;
        }

        public readonly Serial Serial;
        public int Amount;
        public int Price;

        public int TotalCost
        {
            get { return Amount * Price; }
        }
    }

    public sealed class VendorBuyResponse : Packet
    {
        public VendorBuyResponse(Serial vendor, IList<VendorBuyItem> list) : base(0x3B)
        {
            EnsureCapacity(1 + 2 + 4 + 1 + list.Count * 7);

            Write(vendor);
            Write((byte) 0x02); // flag

            for (int i = 0; i < list.Count; i++)
            {
                VendorBuyItem vbi = list[i];
                Write((byte) 0x1A); // layer?
                Write(vbi.Serial);
                Write((ushort) vbi.Amount);
            }
        }
    }

    public sealed class MenuResponse : Packet
    {
        public MenuResponse(uint serial, ushort menuid, ushort index, ushort itemid, ushort hue) : base(0x7D, 13)
        {
            Write((uint) serial);
            Write(menuid);
            Write(index);
            Write(itemid);
            Write(hue);
        }
    }

    public sealed class HuePicker : Packet
    {
        public HuePicker() : this(Serial.MinusOne, 0x0FAB)
        {
        }

        public HuePicker(ItemID itemid) : this(Serial.MinusOne, itemid)
        {
        }

        public HuePicker(Serial serial, ItemID itemid) : base(0x95, 9)
        {
            Write((uint) serial);
            Write((ushort) 0);
            Write((ushort) itemid);
        }
    }

    public sealed class WalkRequest : Packet
    {
        public WalkRequest(Direction dir, byte seq) : base(0x02, 7)
        {
            Write((byte) dir);
            Write(seq);
            Write((int) -1); // key
        }
    }

    public sealed class ResyncReq : Packet
    {
        public ResyncReq() : base(0x22, 3)
        {
            Write((ushort) 0);
        }
    }

    public sealed class ACKTalk : Packet
    {
        public ACKTalk() : base(0x03)
        {
            EnsureCapacity(40);
            Write((byte) 0x20);
            Write((byte) 0x00);
            Write((byte) 0x34);
            Write((byte) 0x00);
            Write((byte) 0x03);
            Write((byte) 0xdb);
            Write((byte) 0x13);
            Write((byte) 0x14);
            Write((byte) 0x3f);
            Write((byte) 0x45);
            Write((byte) 0x2c);
            Write((byte) 0x58);
            Write((byte) 0x0f);
            Write((byte) 0x5d);
            Write((byte) 0x44);
            Write((byte) 0x2e);
            Write((byte) 0x50);
            Write((byte) 0x11);
            Write((byte) 0xdf);
            Write((byte) 0x75);
            Write((byte) 0x5c);
            Write((byte) 0xe0);
            Write((byte) 0x3e);
            Write((byte) 0x71);
            Write((byte) 0x4f);
            Write((byte) 0x31);
            Write((byte) 0x34);
            Write((byte) 0x05);
            Write((byte) 0x4e);
            Write((byte) 0x18);
            Write((byte) 0x1e);
            Write((byte) 0x72);
            Write((byte) 0x0f);
            Write((byte) 0x59);
            Write((byte) 0xad);
            Write((byte) 0xf5);
            Write((byte) 0x00);
        }
    }

    public sealed class WorldItem : Packet
    {
        public WorldItem(Item item) : base(0x1A)
        {
            this.EnsureCapacity(20);

            // 14 base length
            // +2 - Amount
            // +2 - Hue
            // +1 - Flags

            uint serial = (uint) item.Serial;
            ushort itemID = item.ItemID;
            ushort amount = item.Amount;
            int x = item.Position.X;
            int y = item.Position.Y;
            ushort hue = item.Hue;
            byte flags = item.GetPacketFlags();
            byte direction = item.Direction;

            if (amount != 0)
                serial |= 0x80000000;
            else
                serial &= 0x7FFFFFFF;
            Write((uint) serial);
            Write((ushort) (itemID & 0x7FFF));
            if (amount != 0)
                Write((ushort) amount);

            x &= 0x7FFF;
            if (direction != 0)
                x |= 0x8000;
            Write((ushort) x);

            y &= 0x3FFF;
            if (hue != 0)
                y |= 0x8000;
            if (flags != 0)
                y |= 0x4000;

            Write((ushort) y);
            if (direction != 0)
                Write((byte) direction);
            Write((sbyte) item.Position.Z);
            if (hue != 0)
                Write((ushort) hue);
            if (flags != 0)
                Write((byte) flags);
        }
    }

    public sealed class EquipmentItem : Packet
    {
        public EquipmentItem(Item item, Serial owner) : this(item, item.Hue, owner)
        {
        }

        public EquipmentItem(Item item, ushort hue, Serial owner) : base(0x2E, 15)
        {
            Write((uint) item.Serial);
            Write((ushort) item.ItemID);
            Write((sbyte) 0);
            Write((byte) item.Layer);
            Write((uint) owner);
            Write((ushort) hue);
        }
    }

    public sealed class ForceWalk : Packet
    {
        public ForceWalk(Direction d) : base(0x97, 2)
        {
            Write((byte) d);
        }
    }

    public sealed class PathFindTo : Packet
    {
        public PathFindTo(Point3D loc) : base(0x38, 7 * 20)
        {
            for (int i = 0; i < 20; i++)
            {
                if (i != 0)
                    Write((byte) 0x38);
                Write((ushort) loc.X);
                Write((ushort) loc.Y);
                Write((short) loc.Z);
            }
        }
    }

    public sealed class LoginConfirm : Packet
    {
        public LoginConfirm(Mobile m) : base(0x1B, 37)
        {
            Write((int) m.Serial);
            Write((int) 0);
            Write((short) m.Body);
            Write((short) m.Position.X);
            Write((short) m.Position.Y);
            Write((short) m.Position.Z);
            Write((byte) m.Direction);
            Write((byte) 0);
            Write((int) -1);

            Write((short) 0);
            Write((short) 0);
            Write((short) 6144);
            Write((short) 4096);
        }
    }

    public sealed class LoginComplete : Packet
    {
        public LoginComplete() : base(0x55, 1)
        {
        }
    }

    public sealed class DeathStatus : Packet
    {
        public DeathStatus(bool dead) : base(0x2C, 2)
        {
            Write((byte) (dead ? 0 : 2));
        }
    }

    public sealed class CurrentTime : Packet
    {
        public CurrentTime() : base(0x5B, 4)
        {
            DateTime now = DateTime.UtcNow;

            Write((byte) now.Hour);
            Write((byte) now.Minute);
            Write((byte) now.Second);
        }
    }

    public sealed class MapChange : Packet
    {
        public MapChange(byte map) : base(0xBF)
        {
            this.EnsureCapacity(6);

            Write((short) 0x08);
            Write((byte) map);
        }
    }

    public sealed class SeasonChange : Packet
    {
        public SeasonChange(int season, bool playSound) : base(0xBC, 3)
        {
            Write((byte) season);
            Write((bool) playSound);
        }
    }

    public sealed class SupportedFeatures : Packet
    {
        //private static int m_Value = 0x801F;
        public SupportedFeatures(ushort val) : base(0xB9, 3)
        {
            Write((ushort) val); // 0x01 = T2A, 0x02 = LBR
        }
    }

    public sealed class MapPatches : Packet
    {
        public MapPatches(int[] patches) : base(0xBF)
        {
            EnsureCapacity(9 + (4 * patches.Length));

            Write((short) 0x0018);

            Write((int) (patches.Length / 2));

            for (int i = 0; i < patches.Length; i++)
                Write((int) patches[i]);
            /*Write( (int) Ultima.Map.Felucca.Tiles.Patch.StaticBlocks );
            Write( (int) Ultima.Map.Felucca.Tiles.Patch.LandBlocks );

            Write( (int) Ultima.Map.Trammel.Tiles.Patch.StaticBlocks );
            Write( (int) Ultima.Map.Trammel.Tiles.Patch.LandBlocks );

            Write( (int) Ultima.Map.Ilshenar.Tiles.Patch.StaticBlocks );
            Write( (int) Ultima.Map.Ilshenar.Tiles.Patch.LandBlocks );

            Write( (int) Ultima.Map.Malas.Tiles.Patch.StaticBlocks );
            Write( (int) Ultima.Map.Malas.Tiles.Patch.LandBlocks );*/
        }
    }

    public sealed class MobileAttributes : Packet
    {
        public MobileAttributes(PlayerData m) : base(0x2D, 17)
        {
            Write(m.Serial);

            Write((short) m.HitsMax);
            Write((short) m.Hits);

            Write((short) m.ManaMax);
            Write((short) m.Mana);

            Write((short) m.StamMax);
            Write((short) m.Stam);
        }
    }

    public sealed class SetWarMode : Packet
    {
        public SetWarMode(bool mode) : base(0x72, 5)
        {
            Write(mode);
            Write((byte) 0x00);
            Write((byte) 0x32);
            Write((byte) 0x00);
            //Fill();
        }
    }

    public sealed class OpenDoorMacro : Packet
    {
        public OpenDoorMacro() : base(0x12)
        {
            EnsureCapacity(5);
            Write((byte) 0x58);
            Write((byte) 0);
        }
    }

    public sealed class PersonalLightLevel : Packet
    {
        public PersonalLightLevel(PlayerData m) : base(0x4E, 6)
        {
            Write((int) m.Serial);
            Write((sbyte) m.LocalLightLevel);
        }
    }

    public sealed class GlobalLightLevel : Packet
    {
        public GlobalLightLevel(int level) : base(0x4F, 2)
        {
            Write((sbyte) level);
        }
    }

    public sealed class DisplayPaperdoll : Packet
    {
        public DisplayPaperdoll(Mobile m, string text) : base(0x88, 66)
        {
            Write((int) m.Serial);
            WriteAsciiFixed(text, 60);
            Write((byte) (m.Warmode ? 1 : 0));
        }
    }

    public sealed class RemoveObject : Packet
    {
        public RemoveObject(UOEntity ent) : base(0x1D, 5)
        {
            Write((uint) ent.Serial);
        }

        public RemoveObject(Serial s) : base(0x1D, 5)
        {
            Write((uint) s);
        }
    }

    public sealed class ContextMenuRequest : Packet
    {
        public ContextMenuRequest(Serial entity) : base(0xBF)
        {
            EnsureCapacity(1 + 2 + 2 + 4);
            Write((ushort) 0x13);
            Write((uint) entity);
        }
    }

    public sealed class ContextMenuResponse : Packet
    {
        public ContextMenuResponse(Serial entity, ushort idx) : base(0xBF)
        {
            EnsureCapacity(1 + 2 + 2 + 4 + 2);

            Write((ushort) 0x15);
            Write((uint) entity);
            Write((ushort) idx);
        }
    }

    public sealed class SetUpdateRange : Packet
    {
        public SetUpdateRange(int range) : base(0xC8, 2)
        {
            Write((byte) range);
        }
    }

    public sealed class PlaySound : Packet
    {
        public PlaySound(int sound) : base(0x54, 12)
        {
            Write((byte) 0x01); //(0x00=quiet, repeating, 0x01=single normally played sound effect)
            Write((ushort) sound);
            Write((ushort) 0);
            Write((ushort) World.Player.Position.X);
            Write((ushort) World.Player.Position.Y);
            Write((ushort) World.Player.Position.Z);
        }
    }

    public sealed class RazorNegotiateResponse : Packet
    {
        public RazorNegotiateResponse() : base(0xF0)
        {
            EnsureCapacity(1 + 2 + 1);

            Write((byte) 0xFF);
        }
    }

    public sealed class DesignStateGeneral : Packet
    {
        public DesignStateGeneral(Item house) : base(0xBF)
        {
            EnsureCapacity(13);

            Write((ushort) 0x1D);
            Write((uint) house.Serial);
            Write((int) house.HouseRevision);
        }
    }

    public sealed class StringQueryResponse : Packet
    {
        public StringQueryResponse(int serial, byte type, byte index, bool ok, string resp) : base(0xAC)
        {
            if (resp == null)
                resp = String.Empty;

            this.EnsureCapacity(1 + 2 + 4 + 1 + 1 + 1 + 2 + resp.Length + 1);

            Write((int) serial);
            Write((byte) type);
            Write((byte) index);
            Write((bool) ok);
            Write((short) (resp.Length + 1));
            WriteAsciiNull(resp);
        }
    }

    public class DesignStateDetailed : Packet
    {
        public const int MaxItemsPerStairBuffer = 750;

        private static byte[][] m_PlaneBuffers;
        private static bool[] m_PlaneUsed;

        private static byte[][] m_StairBuffers;

        private static byte[] m_InflatedBuffer = new byte[0x2000];
        private static byte[] m_DeflatedBuffer = new byte[0x2000];

        /*private static byte[] m_PrimBuffer = new byte[4];

        public override void Write( int value )
        {
             m_PrimBuffer[0] = (byte)(value >> 24);
             m_PrimBuffer[1] = (byte)(value >> 16);
             m_PrimBuffer[2] = (byte)(value >>  8);
             m_PrimBuffer[3] = (byte) value;

             UnderlyingStream.Write( m_PrimBuffer, 0, 4 );
        }

        public override void Write( short value )
        {
             m_PrimBuffer[0] = (byte)(value >> 8);
             m_PrimBuffer[1] = (byte) value;

             UnderlyingStream.Write( m_PrimBuffer, 0, 2 );
        }

        public override void Write( byte value )
        {
             UnderlyingStream.WriteByte( value );
        }

        public void Write( byte[] buffer, int offset, int size )
        {
             UnderlyingStream.Write( buffer, offset, size );
        }*/

        public static void Clear(byte[] buffer, int size)
        {
            for (int i = 0; i < size; ++i)
                buffer[i] = 0;
        }

        public DesignStateDetailed(Serial serial, int revision, int xMin, int yMin, int xMax, int yMax,
            MultiTileEntry[] tiles) : base(0xD8)
        {
            EnsureCapacity(17 + (tiles.Length * 5));

            Write((byte) 0x03); // Compression Type
            Write((byte) 0x00); // Unknown
            Write((uint) serial);
            Write((int) revision);
            Write((short) tiles.Length);
            Write((short) 0); // Buffer length : reserved
            Write((byte) 0); // Plane count : reserved

            int totalLength = 1; // includes plane count

            int width = (xMax - xMin) + 1;
            int height = (yMax - yMin) + 1;

            if (m_PlaneBuffers == null)
            {
                m_PlaneBuffers = new byte[9][];
                m_PlaneUsed = new bool[9];

                for (int i = 0; i < m_PlaneBuffers.Length; ++i)
                    m_PlaneBuffers[i] = new byte[0x400];

                m_StairBuffers = new byte[6][];

                for (int i = 0; i < m_StairBuffers.Length; ++i)
                    m_StairBuffers[i] = new byte[MaxItemsPerStairBuffer * 5];
            }
            else
            {
                for (int i = 0; i < m_PlaneUsed.Length; ++i)
                    m_PlaneUsed[i] = false;

                Clear(m_PlaneBuffers[0], width * height * 2);

                for (int i = 0; i < 4; ++i)
                {
                    Clear(m_PlaneBuffers[1 + i], (width - 1) * (height - 2) * 2);
                    Clear(m_PlaneBuffers[5 + i], width * (height - 1) * 2);
                }
            }

            int totalStairsUsed = 0;

            for (int i = 0; i < tiles.Length; ++i)
            {
                MultiTileEntry mte = tiles[i];
                int x = mte.m_OffsetX - xMin;
                int y = mte.m_OffsetY - yMin;
                int z = mte.m_OffsetZ;
                int plane, size;
                bool floor = false;
                try
                {
                    floor = (Ultima.TileData.ItemTable[mte.m_ItemID & 0x3FFF].Height <= 0);
                }
                catch
                {
                }

                switch (z)
                {
                    case 0:
                        plane = 0;
                        break;
                    case 7:
                        plane = 1;
                        break;
                    case 27:
                        plane = 2;
                        break;
                    case 47:
                        plane = 3;
                        break;
                    case 67:
                        plane = 4;
                        break;
                    default:
                    {
                        int stairBufferIndex = (totalStairsUsed / MaxItemsPerStairBuffer);
                        byte[] stairBuffer = m_StairBuffers[stairBufferIndex];

                        int byteIndex = (totalStairsUsed % MaxItemsPerStairBuffer) * 5;

                        stairBuffer[byteIndex++] = (byte) ((mte.m_ItemID >> 8) & 0x3F);
                        stairBuffer[byteIndex++] = (byte) mte.m_ItemID;

                        stairBuffer[byteIndex++] = (byte) mte.m_OffsetX;
                        stairBuffer[byteIndex++] = (byte) mte.m_OffsetY;
                        stairBuffer[byteIndex++] = (byte) mte.m_OffsetZ;

                        ++totalStairsUsed;

                        continue;
                    }
                }

                if (plane == 0)
                {
                    size = height;
                }
                else if (floor)
                {
                    size = height - 2;
                    x -= 1;
                    y -= 1;
                }
                else
                {
                    size = height - 1;
                    plane += 4;
                }

                int index = ((x * size) + y) * 2;

                m_PlaneUsed[plane] = true;
                m_PlaneBuffers[plane][index] = (byte) ((mte.m_ItemID >> 8) & 0x3F);
                m_PlaneBuffers[plane][index + 1] = (byte) mte.m_ItemID;
            }

            int planeCount = 0;

            for (int i = 0; i < m_PlaneBuffers.Length; ++i)
            {
                if (!m_PlaneUsed[i])
                    continue;

                ++planeCount;

                int size = 0;

                if (i == 0)
                    size = width * height * 2;
                else if (i < 5)
                    size = (width - 1) * (height - 2) * 2;
                else
                    size = width * (height - 1) * 2;

                byte[] inflatedBuffer = m_PlaneBuffers[i];

                int deflatedLength = m_DeflatedBuffer.Length;
                ZLibError ce = ZLib.compress2(m_DeflatedBuffer, ref deflatedLength, inflatedBuffer, size,
                    ZLibCompressionLevel.Z_DEFAULT_COMPRESSION);

                if (ce != ZLibError.Z_OK)
                {
                    Console.WriteLine("ZLib error: {0} (#{1})", ce, (int) ce);
                    deflatedLength = 0;
                    size = 0;
                }

                Write((byte) (0x20 | i));
                Write((byte) size);
                Write((byte) deflatedLength);
                Write((byte) (((size >> 4) & 0xF0) | ((deflatedLength >> 8) & 0xF)));
                Write(m_DeflatedBuffer, 0, deflatedLength);

                totalLength += 4 + deflatedLength;
            }

            int totalStairBuffersUsed = (totalStairsUsed + (MaxItemsPerStairBuffer - 1)) / MaxItemsPerStairBuffer;

            for (int i = 0; i < totalStairBuffersUsed; ++i)
            {
                ++planeCount;

                int count = (totalStairsUsed - (i * MaxItemsPerStairBuffer));

                if (count > MaxItemsPerStairBuffer)
                    count = MaxItemsPerStairBuffer;

                int size = count * 5;

                byte[] inflatedBuffer = m_StairBuffers[i];

                int deflatedLength = m_DeflatedBuffer.Length;
                ZLibError ce = ZLib.compress2(m_DeflatedBuffer, ref deflatedLength, inflatedBuffer, size,
                    ZLibCompressionLevel.Z_DEFAULT_COMPRESSION);

                if (ce != ZLibError.Z_OK)
                {
                    Console.WriteLine("ZLib error: {0} (#{1})", ce, (int) ce);
                    deflatedLength = 0;
                    size = 0;
                }

                Write((byte) (9 + i));
                Write((byte) size);
                Write((byte) deflatedLength);
                Write((byte) (((size >> 4) & 0xF0) | ((deflatedLength >> 8) & 0xF)));
                Write(m_DeflatedBuffer, 0, deflatedLength);

                totalLength += 4 + deflatedLength;
            }

            Seek(15, System.IO.SeekOrigin.Begin);

            Write((short) totalLength); // Buffer length
            Write((byte) planeCount); // Plane count

            /*int planes = (tiles.Length + (MaxItemsPerPlane - 1)) / MaxItemsPerPlane;

            if ( planes > 255 )
                 planes = 255;

            int totalLength = 0;

            Write( (byte) planes );
            ++totalLength;

            int itemIndex = 0;

            for ( int i = 0; i < planes; ++i )
            {
                 int byteIndex = 0;

                 for ( int j = 0; j < MaxItemsPerPlane && itemIndex < tiles.Length; ++j, ++itemIndex )
                 {
                      MultiTileEntry e = tiles[itemIndex];

                      m_InflatedBuffer[byteIndex++] = (byte)((e.m_ItemID >> 8) & 0x3F);
                      m_InflatedBuffer[byteIndex++] = (byte)e.m_ItemID;
                      m_InflatedBuffer[byteIndex++] = (byte)e.m_OffsetX;
                      m_InflatedBuffer[byteIndex++] = (byte)e.m_OffsetY;
                      m_InflatedBuffer[byteIndex++] = (byte)e.m_OffsetZ;
                 }

                 int deflatedLength = m_DeflatedBuffer.Length;
                 ZLibError ce = ZLib.compress2( m_DeflatedBuffer, ref deflatedLength, m_InflatedBuffer, byteIndex, ZLibCompressionLevel.Z_DEFAULT_COMPRESSION );

                 if ( ce != ZLibError.Z_OK )
                 {
                      Console.WriteLine( "ZLib error: {0} (#{1})", ce, (int)ce );
                      deflatedLength = 0;
                      byteIndex = 0;
                 }

                 Write( (byte) 0x00 );
                 Write( (byte) byteIndex );
                 Write( (byte) deflatedLength );
                 Write( (byte) (((byteIndex >> 4) & 0xF0) | ((deflatedLength >> 8) & 0xF)) );
                 Write( m_DeflatedBuffer, 0, deflatedLength );

                 totalLength += 4 + deflatedLength;
            }

            Seek( 15, System.IO.SeekOrigin.Begin );
            Write( (short) totalLength ); // Buffer length*/
        }
    }

    internal sealed class PromptResponse : Packet
    {
        internal PromptResponse(uint serial, uint promptid, uint operation, string lang, string text)
            : base(0xC2)
        {
            if (text != "")
                EnsureCapacity(2 + 4 + 4 + 4 + 4 + (text.Length * 2));
            else
            {
                EnsureCapacity(18);
            }

            Write((uint) serial);
            Write((uint) promptid);
            Write((uint) operation);

            if (string.IsNullOrEmpty(lang))
                lang = "ENU";

            WriteAsciiFixed(lang.ToUpper(), 4);

            if (text != "")
                WriteLittleUniNull(text);
        }
    }

    internal sealed class AssistVersion : Packet
    {
        internal AssistVersion()
            : base(0xBE)
        {
            var assistVersion = $"Razor {(typeof(AssistVersion).Assembly.GetName().Version)}";

            EnsureCapacity(3 + assistVersion.Length);

            WriteAsciiNull(assistVersion);
        }
    }

    internal sealed class QuestArrow : Packet
    {
        internal QuestArrow(bool active, int x, int y)
            : base(0xBA, 10)
        {
            Write((byte) (active ? 1 : 0));
            Write((ushort) x);
            Write((ushort) y);
        }
    }

    internal sealed class VirtueRequest : Packet
    {
        internal VirtueRequest(byte id) : base(0x12)
        {
            EnsureCapacity(1 + id.ToString().Length + 1);

            Write((byte)0xF4);
            WriteAsciiNull(id.ToString());
        }
    }
    
    public sealed class RenamePacket : Packet
    {
        public RenamePacket(uint serial, string newName) : base(0x75, 35)
        {
            Write(serial);
            WriteAsciiFixed(newName, 30);
        }
    }
}


================================================
FILE: Razor/Platform.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Text;

namespace Assistant
{
    internal static unsafe class Win32Platform
    {
        static Dictionary<int, int> m_KeyMap = new Dictionary<int, int>()
        {
            {1073741979, 3},
            {8, 8},
            {9, 9},
            {1073741980, 12},
            {13, 13},
            {1073741942, 165},
            {1073741896, 19},
            {1073741881, 20},
            {27, 27},
            {1073742081, 31},
            {32, 32},
            {1073741899, 33},
            {1073741902, 34},
            {1073741901, 35},
            {1073741898, 36},
            {1073741904, 37},
            {1073741906, 38},
            {1073741903, 39},
            {1073741905, 40},
            {1073741943, 41},
            {1073741940, 43},
            {1073741897, 45},
            {127, 46},
            {1073741941, 47},
            {97, 65},
            {98, 66},
            {99, 67},
            {100, 68},
            {101, 69},
            {102, 70},
            {103, 71},
            {104, 72},
            {105, 73},
            {106, 74},
            {107, 75},
            {108, 76},
            {109, 77},
            {110, 78},
            {111, 79},
            {112, 80},
            {113, 81},
            {114, 82},
            {115, 83},
            {116, 84},
            {117, 85},
            {118, 86},
            {119, 87},
            {120, 88},
            {121, 89},
            {122, 90},
            {1073742051, 91},
            {1073742055, 92},
            {1073741925, 93},
            {1073742106, 95},
            {1073741922, 96},
            {1073741913, 97},
            {1073741914, 98},
            {1073741915, 99},
            {1073741916, 100},
            {1073741917, 101},
            {1073741918, 102},
            {1073741919, 103},
            {1073741920, 104},
            {1073741921, 105},
            {1073741909, 106},
            {1073741911, 107},
            {1073741910, 109},
            {1073741923, 110},
            {1073741908, 111},
            {1073741882, 112},
            {1073741883, 113},
            {1073741884, 114},
            {1073741885, 115},
            {1073741886, 116},
            {1073741887, 117},
            {1073741888, 118},
            {1073741889, 119},
            {1073741890, 120},
            {1073741891, 121},
            {1073741892, 122},
            {1073741893, 123},
            {1073741928, 124},
            {1073741929, 125},
            {1073741930, 126},
            {1073741931, 127},
            {1073741932, 128},
            {1073741933, 129},
            {1073741934, 130},
            {1073741935, 131},
            {1073741936, 132},
            {1073741937, 133},
            {1073741938, 134},
            {1073741939, 135},
            {1073741907, 144},
            {1073741895, 145},
            {1073742086, 173},
            {1073741953, 174},
            {1073741952, 175},
            {1073742082, 176},
            {1073742083, 177},
            {1073742084, 178},
            {1073742085, 179},
            {1073742089, 180},
            {1073742087, 181},
            {48, 48},
            {49, 49},
            {50, 50},
            {51, 51},
            {52, 52},
            {53, 53},
            {54, 54},
            {55, 55},
            {56, 56},
            {57, 57},
        };

        internal static int MapKey(int key)
        {
            int keycode;

            if (!m_KeyMap.TryGetValue(key, out keycode))
            {
                keycode = 0;
            }

            return keycode;
        }

        static Dictionary<int, int> m_KeyModMap = new Dictionary<int, int>()
        {
            {3, 512},
            {192, 1024},
            {195, 1536},
            {768, 2048},
            {771, 2560},
            {960, 3072},
            {963, 3584},
        };

        internal static int MapKeyMod(int key)
        {
            int keycode;

            if (!m_KeyModMap.TryGetValue(key, out keycode))
            {
                keycode = 0;
            }

            return keycode;
        }

        [DllImport("Platform.dll")]
        internal static unsafe extern IntPtr CaptureScreen(IntPtr handle, bool isFullScreen, string msgStr);

        [DllImport("Platform.dll")]
        internal static unsafe extern void BringToFront(IntPtr hWnd);

        [DllImport("user32.dll")]
        internal static extern ushort GetAsyncKeyState(int key);

        [DllImport("user32.dll")]
        internal static extern bool SetForegroundWindow(IntPtr hWnd);
    }

    internal static unsafe class LinuxPlatform
    {
        [DllImport("libX11")]
        private static extern IntPtr XOpenDisplay(IntPtr display);

        [DllImport("libX11")]
        private static extern IntPtr XCloseDisplay(IntPtr display);

        [DllImport("libX11")]
        private static extern int XRaiseWindow(IntPtr display, IntPtr window);

        [DllImport("libX11")]
        private static extern int XGetInputFocus(IntPtr display, IntPtr window, IntPtr focus_return);

        [DllImport("libX11")]
        private static extern int XQueryKeymap(IntPtr display, byte[] keys);

        [DllImport("libX11")]
        private static extern int XKeysymToKeycode(IntPtr display, int key);

        private static IntPtr m_Display;

        private static IntPtr Display
        {
            get
            {
                if (m_Display == IntPtr.Zero)
                    m_Display = XOpenDisplay(IntPtr.Zero);
                return m_Display;
            }
        }

        internal static void BringToFront(IntPtr window)
        {
            XRaiseWindow(Display, window);
        }
        
        /* List of mappings between:
         * Windows 'Virtual Key Codes' (https://docs.microsoft.com/en-us/windows/win32/inputdev/virtual-key-codes)
         * and
         * Unix X11 Keysyms (https://cgit.freedesktop.org/xorg/proto/x11proto/tree/keysymdef.h)
         *
         * Testing was done on Gentoo Linux with an Unicomp New Model M, standard ANSI 104-key layout. (https://www.pckeyboard.com/page/product/NEW_M)
         * The keyboard used may affect the results for some of the more ambiguous keysyms and keycodes. Hopefully this works for most folks.
         */
        static Dictionary<int, int> m_MapX11Key = new Dictionary<int, int>()
        {
            // Utility keys.
            // For many of these, Windows lists one keycode while unix has a separate keysym for each symbol on the key.
            // In such cases, the primary symbol is used for the mapping.
            {0x08, 0xFF08}, // Backspace
            {0x09, 0xFF09}, // Tab
            {0x0C, 0xFF0B}, // Clear
            {0x0D, 0xFF0D}, // Return
            {0x20, 0x0020}, // Space
            {0xDE, 0x0027}, // Single/Double quote key
            {0xDB, 0x005B}, // Bracket left
            {0xDD, 0x005D}, // Bracket right
            {0xBC, 0x002C}, // Comma / Less than (<)
            {0xBE, 0x002E}, // Period / Greater than (>)
            {0xDC, 0x005C}, // Backslash
            {0xBB, 0x003D}, // Addition / Equals
            {0xBF, 0x002F}, // Forward slash
            {0xBD, 0x002D}, // Dash / Minus
            {0xC0, 0x0060}, // Grave / Tilde
            {0xBA, 0x003B}, // Semi-Colon / Colon
            {0x13, 0xFF13}, // Pause
            {0x1B, 0xFF1B}, // Escape
            {0x26, 0xFF52}, // Up arrow
            {0x28, 0xFF54}, // Down arrow
            {0x25, 0xFF51}, // Left arrow
            {0x27, 0xFF53}, // Right arrow
            {0x2D, 0xFF63}, // Insert
            {0x2E, 0xFFFF}, // Delete
            {0x24, 0xFF50}, // Home
            {0x23, 0xFF57}, // End
            {0x21, 0xFF55}, // Page Up
            {0x22, 0xFF56}, // Page Down
            {0x14, 0xFFE5}, // Caps Lock
            {0x91, 0xFF14}, // Scroll Lock
            // Same physical key as scroll lock, unlikely to be needed for UO
            //{0x91, 0xFF15}, // SysRq

            // Modifier keys
            // Unix has no combined keysym for these, handled separately in GetAsyncKeyState() below.
            //{0x10, 0xFF??}, // Shift
            //{0x11, 0xFF??}, // Control
            //{0x12, 0xFF??}, // Alt
            {0xA0, 0xFFE1}, // LSHIFT
            {0xA1, 0xFFE2}, // RSHIFT
            {0xA2, 0xFFE3}, // LCONTROL
            {0xA3, 0xFFE4}, // RCONTROL
            {0xA4, 0xFFE9}, // LALT
            {0xA5, 0xFFEA}, // RALT
            // These are pretty ambiguous and I don't have a windows machine handy to verify them.
            //{0x5B, 0x00EB}, // Super L / Windows key L
            //{0x5C, 0x00EC}, // Super R / Windows key R
            //{0x5D, 0x0067}, // Menu

            // Numeric Keypad
            {0x90, 0xFFBE}, // Num lock
            {0x60, 0xFFB0}, // Numpad0
            {0x61, 0xFFB1},
            {0x62, 0xFFB2},
            {0x63, 0xFFB3},
            {0x64, 0xFFB4},
            {0x65, 0xFFB5},
            {0x66, 0xFFB6},
            {0x67, 0xFFB7},
            {0x68, 0xFFB8},
            {0x69, 0xFFB0}, // Numpad9
            {0x6F, 0xFFAF}, // Divide
            {0x6A, 0xFFAA}, // Multiply
            {0x6D, 0xFFAD}, // Subtract
            {0x6B, 0xFFAB}, // Add
            {0x6C, 0xFFAE}, // Decimal
            // Windows has no separate keycode for these, so ignore them for now.
            // Should probably be handled similar to how Shift/Control/Alt are, below.
            //{0x, 0xFF95}, // KP_Home
            //{0x, 0xFF97}, // KP_Up
            //{0x, 0xFF9A}, // KP_PageUp
            //{0x, 0xFF96}, // KP_Left
            //{0x, 0xFF98}, // KP_Right
            //{0x, 0xFF9C}, // KP_End
            //{0x, 0xFF99}, // KP_Down
            //{0x, 0xFF9B}, // KP_PageDown
            //{0x, 0xFF8D}, // KP_Enter

            // F1-F24
            {0x70, 0xFFBE},
            {0x71, 0xFFBF},
            {0x72, 0xFFC0},
            {0x73, 0xFFC1},
            {0x74, 0xFFC2},
            {0x75, 0xFFC3},
            {0x76, 0xFFC4},
            {0x77, 0xFFC5},
            {0x78, 0xFFC6},
            {0x79, 0xFFC7},
            {0x7A, 0xFFC8},
            {0x7B, 0xFFC9},
            {0x7C, 0xFFCA},
            {0x7D, 0xFFCB},
            {0x7E, 0xFFCC},
            {0x7F, 0xFFCD},
            {0x80, 0xFFCE},
            {0x81, 0xFFCF},
            {0x82, 0xFFD0},
            {0x83, 0xFFD1},
            {0x84, 0xFFD2},
            {0x85, 0xFFD3},
            {0x86, 0xFFD4},
            {0x87, 0xFFD5},

            // 0-9 map directly
            {0x30, 0x0030},
            {0x31, 0x0031},
            {0x32, 0x0032},
            {0x33, 0x0033},
            {0x34, 0x0034},
            {0x35, 0x0035},
            {0x36, 0x0036},
            {0x37, 0x0037},
            {0x38, 0x0038},
            {0x39, 0x0039},

            // Captial A-Z map directly.
            {0x41, 0x0041},
            {0x42, 0x0042},
            {0x43, 0x0043},
            {0x44, 0x0044},
            {0x45, 0x0045},
            {0x46, 0x0046},
            {0x47, 0x0047},
            {0x48, 0x0048},
            {0x49, 0x0049},
            {0x4A, 0x004A},
            {0x4B, 0x004B},
            {0x4C, 0x004C},
            {0x4D, 0x004D},
            {0x4E, 0x004E},
            {0x4F, 0x004F},
            {0x50, 0x0050},
            {0x51, 0x0051},
            {0x52, 0x0052},
            {0x53, 0x0053},
            {0x54, 0x0054},
            {0x55, 0x0055},
            {0x56, 0x0056},
            {0x57, 0x0057},
            {0x58, 0x0058},
            {0x59, 0x0059},
            {0x5A, 0x005A},

            // Windows doesn't have lowercase A-Z keycodes.
        };
        
        internal static int MapX11Key(int key)
        {
            int keycode;

            // If no mapping is found, pass the unmapped code back out.
            // Can't be any worse than the way it used to work.
            if (!m_MapX11Key.TryGetValue(key, out keycode))
                keycode = key;

            return keycode;
        }

        // A linux-version of WinUser.dll's GetAsyncKeyState()
        // Take the (Windows) Virtual Key Code, convert it to an X11 KeySym, then back to the X11 Keycode, then check if it's pressed.
        internal static ushort GetAsyncKeyState(int winkey)
        {
            try
            {
                int key = 0; int key2 = 0;
                bool pressed = false; bool pressed2 = false;

                // Convert Windows Virtual Key Code to an X11 Keysym.
                // Code elsewhere distills Left/Right modifier keys to Window's single keycode. Un-distill them here
                if (winkey == 0x10)      { key = 0xFFE1; key2 = 0xFFE2; }               // Any shift key
                else if (winkey == 0x11) { key = 0xFFE3; key2 = 0xFFE4; }               // Any ctrl key
                else if (winkey == 0x12) { key = 0xFFE9; key2 = 0xFFEA; }               // Any alt key
                else                     { key = LinuxPlatform.MapX11Key (winkey); }    // Any other key, map the keycode to a keysym

                // Get physical keyboard state - every key being pressed is listed in the byte array
                var szKey = new byte[32];
                int res = XQueryKeymap(Display, szKey);

                // Convert X11 Keysym to X11 Keycode
                int code = XKeysymToKeycode(Display, (int) key);

                // Check if keycode is included in the keyboard state.
                var r = szKey[code / 8];
                var s = (1 << (code % 8));
                pressed = Convert.ToBoolean(r & s);

                // Check the second modifier key if required
                if (key2 > 0)
                {
                    int code2 = XKeysymToKeycode(Display, (int) key2);
                    var r2 = szKey[code2 / 8];
                    var s2 = (1 << (code2 % 8));
                    pressed2 = Convert.ToBoolean(r2 & s2);
                }

                if (pressed || pressed2)
                    return (ushort) 0xFF00;
                else
                    return (ushort) 0;
            }
            catch
            {
                return (ushort) 0;
            }
        }

        internal static bool SetForegroundWindow(IntPtr hWnd)
        {
            XRaiseWindow(Display, hWnd);
            return true;
        }
    }

    internal static unsafe class Platform
    {
        internal static ushort GetAsyncKeyState(int key)
        {
            if (Environment.OSVersion.Platform == PlatformID.Win32NT)
                return Win32Platform.GetAsyncKeyState(key);
            else if (Environment.OSVersion.Platform == PlatformID.Unix)
                return LinuxPlatform.GetAsyncKeyState(key);
            else
                return 0;
        }

        internal static IntPtr CaptureScreen(IntPtr handle, bool isFullScreen, string msgStr)
        {
            if (Environment.OSVersion.Platform == PlatformID.Win32NT)
                return Win32Platform.CaptureScreen(handle, isFullScreen, msgStr);
            else
                return IntPtr.Zero;
        }

        internal static void BringToFront(IntPtr window)
        {
            try
            {
                if (Environment.OSVersion.Platform == PlatformID.Win32NT)
                    Win32Platform.BringToFront(window);
                else
                    LinuxPlatform.BringToFront(window);
            }
            catch
            {
            }
        }

        internal static bool SetForegroundWindow(IntPtr hWnd)
        {
            if (Environment.OSVersion.Platform == PlatformID.Win32NT)
                return Win32Platform.SetForegroundWindow(hWnd);
            else if (Environment.OSVersion.Platform == PlatformID.Unix)
                return LinuxPlatform.SetForegroundWindow(hWnd);
            else
                return false;
        }

        [DllImport("User32.dll")]
        private static extern IntPtr GetSystemMenu(IntPtr wnd, bool reset);

        [DllImport("User32.dll")]
        private static extern IntPtr EnableMenuItem(IntPtr menu, uint item, uint options);


        [DllImport("msvcrt.dll")]
        internal static unsafe extern void memcpy(void* to, void* from, int len);

        [DllImport("user32.dll")]
        internal static extern uint PostMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);


        [DllImport("kernel32.dll")]
        internal static extern uint GlobalGetAtomName(ushort atom, StringBuilder buff, int bufLen);

        [DllImport("Advapi32.dll")]
        internal static extern int GetUserNameA(StringBuilder buff, int* len);

        [DllImport("user32.dll")]
        internal static extern IntPtr SendMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);


        public static string GetWindowsUserName()
        {
            int len = 1024;
            StringBuilder sb = new StringBuilder(len);
            if (GetUserNameA(sb, &len) != 0)
                return sb.ToString();
            else
                return "";
        }

        internal static void DisableCloseButton(IntPtr handle)
        {
            if (Environment.OSVersion.Platform == PlatformID.Win32NT)
            {
                IntPtr menu = GetSystemMenu(handle, false);
                EnableMenuItem(menu, 0xF060, 0x00000002); //menu, SC_CLOSE, MF_BYCOMMAND|MF_GRAYED
            }
        }
    }
}


================================================
FILE: Razor/Properties/AssemblyInfo.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System.Reflection;
using System.Runtime.InteropServices;

//
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
//
[assembly: AssemblyTitle("Razor")]
[assembly: AssemblyDescription("Ultima Online Assistant Tool")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("https://github.com/markdwags/Razor")]
[assembly: AssemblyProduct("Razor")]
[assembly: AssemblyCopyright("")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]

//
// Version information for an assembly consists of the following four values:
//
//      Major Version
//      Minor Version
//      Build Number
//      Revision
//
// You can specify all the values or you can default the Revision and Build Numbers
// by using the '*' as shown below:

[assembly: AssemblyVersion("1.10.0.0")]
[assembly: AssemblyFileVersion("1.10.0.0")]
[assembly: AssemblyInformationalVersion("1.10.0.0")]

//
// In order to sign your assembly you must specify a key to use. Refer to the
// Microsoft .NET Framework documentation for more information on assembly signing.
//
// Use the attributes below to control which key is used for signing.
//
// Notes:
//   (*) If no key is specified, the assembly is not signed.
//   (*) KeyName refers to a key that has been installed in the Crypto Service
//       Provider (CSP) on your machine. KeyFile refers to a file which contains
//       a key.
//   (*) If the KeyFile and the KeyName values are both specified, the
//       following processing occurs:
//       (1) If the KeyName can be found in the CSP, that key is used.
//       (2) If the KeyName does not exist and the KeyFile does exist, the key
//           in the KeyFile is installed into the CSP and used.
//   (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility.
//       When specifying the KeyFile, the location of the KeyFile should be
//       relative to the project output directory which is
//       %Project Directory%\obj\<configuration>. For example, if your KeyFile is
//       located in the project directory, you would specify the AssemblyKeyFile
//       attribute as [assembly: AssemblyKeyFile("..\\..\\mykey.snk")]
//   (*) Delay Signing is an advanced option - see the Microsoft .NET Framework
//       documentation for more information on this.
//
[assembly: AssemblyDelaySign(false)]
//[assembly: AssemblyKeyFile("")]
//[assembly: AssemblyKeyName("")]
[assembly: ComVisibleAttribute(false)]

================================================
FILE: Razor/Properties/Resources.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.42000
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace Assistant.Properties {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class Resources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal Resources() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Assistant.Properties.Resources", typeof(Resources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
    }
}


================================================
FILE: Razor/Properties/Resources.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
</root>

================================================
FILE: Razor/Razor.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="12.0">
  <PropertyGroup>
    <ProjectType>Local</ProjectType>
    <ProductVersion>8.0.50727</ProductVersion>
    <SchemaVersion>2.0</SchemaVersion>
    <ProjectGuid>{B24E4FB1-4936-4544-9E88-F3FF9B04FDBA}</ProjectGuid>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
    <ApplicationIcon>UI\App.ico</ApplicationIcon>
    <AssemblyName>Razor</AssemblyName>
    <DefaultClientScript>JScript</DefaultClientScript>
    <DefaultHTMLPageLayout>Grid</DefaultHTMLPageLayout>
    <DefaultTargetSchema>IE50</DefaultTargetSchema>
    <DelaySign>false</DelaySign>
    <OutputType>WinExe</OutputType>
    <RootNamespace>Assistant</RootNamespace>
    <RunPostBuildEvent>OnOutputUpdated</RunPostBuildEvent>
    <StartupObject>Assistant.Engine</StartupObject>
    <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
    <OldToolsVersion>2.0</OldToolsVersion>
    <TargetFrameworkProfile>
    </TargetFrameworkProfile>
    <PublishUrl>E:\Programming\razor-markdwags\Build\</PublishUrl>
    <Install>true</Install>
    <InstallFrom>Disk</InstallFrom>
    <UpdateEnabled>false</UpdateEnabled>
    <UpdateMode>Foreground</UpdateMode>
    <UpdateInterval>7</UpdateInterval>
    <UpdateIntervalUnits>Days</UpdateIntervalUnits>
    <UpdatePeriodically>false</UpdatePeriodically>
    <UpdateRequired>false</UpdateRequired>
    <MapFileExtensions>true</MapFileExtensions>
    <AutorunEnabled>true</AutorunEnabled>
    <ApplicationRevision>0</ApplicationRevision>
    <ApplicationVersion>1.5.1.%2a</ApplicationVersion>
    <UseApplicationTrust>false</UseApplicationTrust>
    <PublishWizardCompleted>true</PublishWizardCompleted>
    <BootstrapperEnabled>true</BootstrapperEnabled>
  </PropertyGroup>
  <PropertyGroup />
  <PropertyGroup>
    <SignAssembly>false</SignAssembly>
  </PropertyGroup>
  <PropertyGroup />
  <PropertyGroup />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
    <DebugSymbols>true</DebugSymbols>
    <OutputPath>..\bin\Win32\Debug\</OutputPath>
    <DefineConstants>DEBUG;TRACE</DefineConstants>
    <BaseAddress>285212672</BaseAddress>
    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
    <FileAlignment>4096</FileAlignment>
    <DebugType>full</DebugType>
    <PlatformTarget>x64</PlatformTarget>
    <UseVSHostingProcess>false</UseVSHostingProcess>
    <ErrorReport>prompt</ErrorReport>
    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
    <CodeAnalysisIgnoreBuiltInRuleSets>false</CodeAnalysisIgnoreBuiltInRuleSets>
    <CodeAnalysisIgnoreBuiltInRules>false</CodeAnalysisIgnoreBuiltInRules>
    <Prefer32Bit>false</Prefer32Bit>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">
    <OutputPath>..\bin\Win32\Release\</OutputPath>
    <DefineConstants>TRACE</DefineConstants>
    <BaseAddress>285212672</BaseAddress>
    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
    <Optimize>true</Optimize>
    <FileAlignment>4096</FileAlignment>
    <PlatformTarget>x86</PlatformTarget>
    <ErrorReport>prompt</ErrorReport>
    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
    <CodeAnalysisIgnoreBuiltInRules>false</CodeAnalysisIgnoreBuiltInRules>
    <Prefer32Bit>false</Prefer32Bit>
  </PropertyGroup>
  <PropertyGroup />
  <PropertyGroup>
    <ApplicationManifest>Razor.manifest</ApplicationManifest>
  </PropertyGroup>
  <PropertyGroup>
    <ManifestCertificateThumbprint>0212178022788294553B69C3C9C642E8834CB0DB</ManifestCertificateThumbprint>
  </PropertyGroup>
  <PropertyGroup>
    <ManifestKeyFile>Razor_TemporaryKey.pfx</ManifestKeyFile>
  </PropertyGroup>
  <PropertyGroup>
    <GenerateManifests>false</GenerateManifests>
  </PropertyGroup>
  <PropertyGroup>
    <SignManifests>false</SignManifests>
  </PropertyGroup>
  <PropertyGroup>
    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|AnyCPU'">
    <DebugSymbols>true</DebugSymbols>
    <OutputPath>bin\Debug\</OutputPath>
    <DefineConstants>DEBUG;TRACE</DefineConstants>
    <BaseAddress>285212672</BaseAddress>
    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
    <FileAlignment>4096</FileAlignment>
    <DebugType>full</DebugType>
    <PlatformTarget>AnyCPU</PlatformTarget>
    <UseVSHostingProcess>false</UseVSHostingProcess>
    <ErrorReport>prompt</ErrorReport>
    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
    <CodeAnalysisIgnoreBuiltInRuleSets>false</CodeAnalysisIgnoreBuiltInRuleSets>
    <CodeAnalysisIgnoreBuiltInRules>false</CodeAnalysisIgnoreBuiltInRules>
    <Prefer32Bit>false</Prefer32Bit>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|AnyCPU'">
    <OutputPath>bin\Release\</OutputPath>
    <DefineConstants>TRACE</DefineConstants>
    <BaseAddress>285212672</BaseAddress>
    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
    <Optimize>true</Optimize>
    <FileAlignment>4096</FileAlignment>
    <PlatformTarget>AnyCPU</PlatformTarget>
    <ErrorReport>prompt</ErrorReport>
    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
    <CodeAnalysisIgnoreBuiltInRules>false</CodeAnalysisIgnoreBuiltInRules>
    <Prefer32Bit>false</Prefer32Bit>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
    <DebugSymbols>true</DebugSymbols>
    <OutputPath>..\bin\x64\Debug\</OutputPath>
    <DefineConstants>DEBUG;TRACE</DefineConstants>
    <BaseAddress>285212672</BaseAddress>
    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
    <FileAlignment>4096</FileAlignment>
    <DebugType>full</DebugType>
    <PlatformTarget>x64</PlatformTarget>
    <UseVSHostingProcess>false</UseVSHostingProcess>
    <LangVersion>7.3</LangVersion>
    <ErrorReport>prompt</ErrorReport>
    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
    <CodeAnalysisIgnoreBuiltInRuleSets>false</CodeAnalysisIgnoreBuiltInRuleSets>
    <CodeAnalysisIgnoreBuiltInRules>false</CodeAnalysisIgnoreBuiltInRules>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
    <OutputPath>..\bin\x64\Release\</OutputPath>
    <DefineConstants>TRACE</DefineConstants>
    <BaseAddress>285212672</BaseAddress>
    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
    <Optimize>true</Optimize>
    <FileAlignment>4096</FileAlignment>
    <PlatformTarget>x64</PlatformTarget>
    <LangVersion>7.3</LangVersion>
    <ErrorReport>prompt</ErrorReport>
    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
    <CodeAnalysisIgnoreBuiltInRules>false</CodeAnalysisIgnoreBuiltInRules>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="cuoapi, Version=1.3.0.0, Culture=neutral, processorArchitecture=AMD64">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>.\cuoapi.dll</HintPath>
    </Reference>
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="mscorlib" />
    <Reference Include="System">
      <Name>System</Name>
    </Reference>
    <Reference Include="System.Buffers, Version=4.0.3.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
      <HintPath>..\packages\System.Buffers.4.5.1\lib\net461\System.Buffers.dll</HintPath>
    </Reference>
    <Reference Include="System.Configuration" />
    <Reference Include="System.Data">
      <Name>System.Data</Name>
    </Reference>
    <Reference Include="System.Drawing">
      <Name>System.Drawing</Name>
    </Reference>
    <Reference Include="System.Memory, Version=4.0.1.2, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
      <HintPath>..\packages\System.Memory.4.5.5\lib\net461\System.Memory.dll</HintPath>
    </Reference>
    <Reference Include="System.Numerics" />
    <Reference Include="System.Numerics.Vectors, Version=4.1.4.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
      <HintPath>..\packages\System.Numerics.Vectors.4.5.0\lib\net46\System.Numerics.Vectors.dll</HintPath>
    </Reference>
    <Reference Include="System.Runtime.CompilerServices.Unsafe, Version=4.0.4.1, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
      <HintPath>..\packages\System.Runtime.CompilerServices.Unsafe.4.5.3\lib\net461\System.Runtime.CompilerServices.Unsafe.dll</HintPath>
    </Reference>
    <Reference Include="System.Windows.Forms">
      <Name>System.Windows.Forms</Name>
    </Reference>
    <Reference Include="System.Xml">
      <Name>System.XML</Name>
    </Reference>
  </ItemGroup>
  <ItemGroup>
    <Compile Include="Agents\BuyAgent.cs" />
    <Compile Include="Agents\IgnoreAgent.cs" />
    <Compile Include="Agents\OrganizerAgent.cs" />
    <Compile Include="Agents\RestockAgent.cs" />
    <Compile Include="Agents\SearchExemptionAgent.cs" />
    <Compile Include="Agents\SellAgent.cs" />
    <Compile Include="Agents\UseOnceAgent.cs" />
    <Compile Include="Boat\BoatWindow.cs">
      <SubType>Form</SubType>
    </Compile>
    <Compile Include="Boat\BoatWindow.Designer.cs">
      <DependentUpon>BoatWindow.cs</DependentUpon>
    </Compile>
    <Compile Include="Client\ClassicUO.cs" />
    <Compile Include="Client\OSI.cs" />
    <Compile Include="Core\ActionQueue.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Agents\Agents.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Core\BuffDebuffManager.cs" />
    <Compile Include="Core\BodCapture.cs" />
    <Compile Include="Core\ClassicUOManager.cs" />
    <Compile Include="Core\CooldownManager.cs" />
    <Compile Include="Core\Dress.cs" />
    <Compile Include="Core\EncodedSpeech.cs" />
    <Compile Include="Core\DamageTracker.cs" />
    <Compile Include="Core\StaffToolsManager.cs" />
    <Compile Include="Core\MessageManager.cs" />
    <Compile Include="Core\Overrides.cs" />
    <Compile Include="Core\SystemMessages.cs" />
    <Compile Include="Core\TextFilterManager.cs" />
    <Compile Include="Gumps\Gump.cs" />
    <Compile Include="Gumps\GumpButtonType.cs" />
    <Compile Include="Gumps\GumpCollection.cs" />
    <Compile Include="Gumps\GumpElement.cs" />
    <Compile Include="Gumps\GumpPage.cs" />
    <Compile Include="Gumps\GumpType.cs" />
    <Compile Include="Core\OverheadManager.cs" />
    <Compile Include="Core\WaypointManager.cs" />
    <Compile Include="Filters\SoundMusicManager.cs" />
    <Compile Include="Filters\TargetFilterManager.cs" />
    <Compile Include="Core\FriendsManager.cs" />
    <Compile Include="Core\MessageInBottleCapture.cs" />
    <Compile Include="Core\ContainerLabels.cs" />
    <Compile Include="Core\GoldPerHourTimer.cs" />
    <Compile Include="Core\GateTimer.cs" />
    <Compile Include="Core\SkillTimer.cs" />
    <Compile Include="Core\BandageTimer.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Core\Commands.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Core\Counters.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Core\DressList.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Core\TargetingClosest.cs" />
    <Compile Include="Core\TargetingNextPrevious.cs" />
    <Compile Include="Filters\Death.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Filters\Filter.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Filters\Light.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Filters\MessageFilter.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Filters\MobileFilter.cs" />
    <Compile Include="Filters\SoundFilters.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Filters\StaffItems.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Filters\VetRewardGump.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Filters\WallStaticFilter.cs" />
    <Compile Include="Filters\Weather.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Core\Geometry.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Gumps\Internal\BuffGump.cs" />
    <Compile Include="Gumps\Internal\CooldownGump.cs" />
    <Compile Include="Gumps\Internal\DamageTrackerListGump.cs" />
    <Compile Include="Gumps\Internal\InputDialogGump.cs" />
    <Compile Include="Gumps\Internal\MobileInfoGump.cs" />
    <Compile Include="Gumps\Internal\ItemInfoGump.cs" />
    <Compile Include="Gumps\Internal\DamageTrackerGump.cs" />
    <Compile Include="Gumps\Internal\HotKeyGump.cs" />
    <Compile Include="Gumps\Internal\BoatControlGump.cs" />
    <Compile Include="Gumps\Internal\SystemMessagesGump.cs" />
    <Compile Include="Gumps\Internal\AgentsGump.cs" />
    <Compile Include="Gumps\Internal\TestMessageGump.cs" />
    <Compile Include="HotKeys\Counters.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="HotKeys\HotKeys.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="HotKeys\Misc.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="HotKeys\SkillHotKeys.cs" />
    <Compile Include="HotKeys\SpecialMoves.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="HotKeys\Undress.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Core\Item.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Core\ItemID.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Agents\ScavengerAgent.cs" />
    <Compile Include="Network\PacketWriter.cs" />
    <Compile Include="Scripts\AgentCommands.cs" />
    <Compile Include="Scripts\Engine\Interpreter.cs" />
    <Compile Include="Scripts\Engine\Lexer.cs" />
    <Compile Include="Macros\MacroVariables.cs" />
    <Compile Include="Macros\Actions.cs">
      <SubType>Component</SubType>
    </Compile>
    <Compile Include="Macros\Macro.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Macros\MacroManager.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Core\Main.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Core\Map.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Scripts\Aliases.cs" />
    <Compile Include="Scripts\Commands.cs" />
    <Compile Include="Scripts\Engine\TextParser.cs" />
    <Compile Include="Scripts\Expressions.cs" />
    <Compile Include="Scripts\Helpers\CommandHelper.cs" />
    <Compile Include="Scripts\RazorScript.cs" />
    <Compile Include="Scripts\ScriptVariables.cs" />
    <Compile Include="Scripts\ScriptManager.cs" />
    <Compile Include="Map\MapWindow.cs">
      <SubType>Form</SubType>
    </Compile>
    <Compile Include="Map\Region.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Map\UOMapControl.cs">
      <SubType>Component</SubType>
    </Compile>
    <Compile Include="Map\UOMapRuneButton.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Core\MemHelper.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Core\Mobile.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Core\MsgQueue.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Platform.cs" />
    <Compile Include="Client\Client.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Network\Handlers.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Network\Packet.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Network\PacketHandler.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Network\Packets.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Core\ObjectPropertyList.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Core\PasswordMemory.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Core\Ping.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Core\Player.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Network\PacketTable.cs" />
    <Compile Include="Client\UOAssist.cs" />
    <Compile Include="Properties\Resources.Designer.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>Resources.resx</DependentUpon>
    </Compile>
    <Compile Include="Core\ScreenCapture.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Core\Serial.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Core\Spells.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Core\StealthSteps.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Core\Targeting.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Core\Timer.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Core\TargetingRandom.cs" />
    <Compile Include="Scripts\TargetCommands.cs" />
    <Compile Include="Scripts\SpeechCommands.cs" />
    <Compile Include="UI\AddCounter.cs">
      <SubType>Form</SubType>
    </Compile>
    <Compile Include="Properties\AssemblyInfo.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="UI\ArtViewer.cs">
      <SubType>UserControl</SubType>
    </Compile>
    <Compile Include="UI\ArtViewer.Designer.cs">
      <DependentUpon>ArtViewer.cs</DependentUpon>
    </Compile>
    <Compile Include="UI\BuffDebuffOptions.cs">
      <SubType>Form</SubType>
    </Compile>
    <Compile Include="UI\BuffDebuffOptions.Designer.cs">
      <DependentUpon>BuffDebuffOptions.cs</DependentUpon>
    </Compile>
    <Compile Include="UI\Config.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="UI\Ext.cs" />
    <Compile Include="UI\SoundEntry.cs">
      <SubType>Form</SubType>
    </Compile>
    <Compile Include="UI\HueEntry.cs">
      <SubType>Form</SubType>
    </Compile>
    <Compile Include="UI\InputDropdown.cs">
      <SubType>Form</SubType>
    </Compile>
    <Compile Include="UI\InputBox.cs">
      <SubType>Form</SubType>
    </Compile>
    <Compile Include="UI\Languages.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="UI\MacroInsertDoWhile.cs">
      <SubType>Form</SubType>
    </Compile>
    <Compile Include="UI\MacroInsertWhile.cs">
      <SubType>Form</SubType>
    </Compile>
    <Compile Include="UI\MacroInsertIf.cs">
      <SubType>Form</SubType>
    </Compile>
    <Compile Include="UI\MacroInsertWait.cs">
      <SubType>Form</SubType>
    </Compile>
    <Compile Include="UI\MessageDialog.cs">
      <SubType>Form</SubType>
    </Compile>
    <Compile Include="UI\ContainerLabels.cs">
      <SubType>Form</SubType>
    </Compile>
    <Compile Include="UI\ContainerLabels.Designer.cs">
      <DependentUpon>ContainerLabels.cs</DependentUpon>
    </Compile>
    <Compile Include="UI\Razor.cs">
      <SubType>Form</SubType>
    </Compile>
    <Compile Include="UI\Razor.Designer.cs">
      <DependentUpon>Razor.cs</DependentUpon>
    </Compile>
    <Compile Include="UI\SplashScreen.cs">
      <SubType>Form</SubType>
    </Compile>
    <Compile Include="UI\WelcomeForm.cs">
      <SubType>Form</SubType>
    </Compile>
    <Compile Include="Core\UOEntity.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Core\Utility.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Core\World.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Core\ZLib.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="UltimaSDK\AnimationEdit.cs" />
    <Compile Include="UltimaSDK\Animations.cs" />
    <Compile Include="UltimaSDK\Animdata.cs" />
    <Compile Include="UltimaSDK\Art.cs" />
    <Compile Include="UltimaSDK\ASCIIFont.cs" />
    <Compile Include="UltimaSDK\BwtDecompress.cs" />
    <Compile Include="UltimaSDK\CalibrationInfo.cs" />
    <Compile Include="UltimaSDK\Client.cs" />
    <Compile Include="UltimaSDK\ClientHandles.cs" />
    <Compile Include="UltimaSDK\FileIndex.cs" />
    <Compile Include="UltimaSDK\Files.cs" />
    <Compile Include="UltimaSDK\Gumps.cs" />
    <Compile Include="UltimaSDK\Hues.cs" />
    <Compile Include="UltimaSDK\Light.cs" />
    <Compile Include="UltimaSDK\LocationPointer.cs" />
    <Compile Include="UltimaSDK\Map.cs" />
    <Compile Include="UltimaSDK\MultiMap.cs" />
    <Compile Include="UltimaSDK\Multis.cs" />
    <Compile Include="UltimaSDK\NativeMethods.cs" />
    <Compile Include="UltimaSDK\ProcessStream.cs" />
    <Compile Include="UltimaSDK\RadarCol.cs" />
    <Compile Include="UltimaSDK\SkillGroups.cs" />
    <Compile Include="UltimaSDK\Skills.cs" />
    <Compile Include="UltimaSDK\Sound.cs" />
    <Compile Include="UltimaSDK\SpeechList.cs" />
    <Compile Include="UltimaSDK\StackDataReader.cs" />
    <Compile Include="UltimaSDK\StringEntry.cs" />
    <Compile Include="UltimaSDK\StringHelper.cs" />
    <Compile Include="UltimaSDK\StringList.cs" />
    <Compile Include="UltimaSDK\Textures.cs" />
    <Compile Include="UltimaSDK\TileData.cs" />
    <Compile Include="UltimaSDK\TileList.cs" />
    <Compile Include="UltimaSDK\TileMatrix.cs" />
    <Compile Include="UltimaSDK\TileMatrixPatch.cs" />
    <Compile Include="UltimaSDK\UnicodeFont.cs" />
    <Compile Include="UltimaSDK\ValueStringBuilder.cs" />
    <Compile Include="UltimaSDK\Verdata.cs" />
    <Compile Include="UltimaSDK\WindowProcessStream.cs" />
    <EmbeddedResource Include="Boat\BoatWindow.resx">
      <DependentUpon>BoatWindow.cs</DependentUpon>
      <SubType>Designer</SubType>
    </EmbeddedResource>
    <EmbeddedResource Include="Macros\Actions.resx">
      <DependentUpon>Actions.cs</DependentUpon>
    </EmbeddedResource>
    <EmbeddedResource Include="Map\MapWindow.resx">
      <DependentUpon>MapWindow.cs</DependentUpon>
    </EmbeddedResource>
    <EmbeddedResource Include="Map\UOMapControl.resx">
      <DependentUpon>UOMapControl.cs</DependentUpon>
    </EmbeddedResource>
    <EmbeddedResource Include="Properties\Resources.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
    <EmbeddedResource Include="UI\AddCounter.resx">
      <DependentUpon>AddCounter.cs</DependentUpon>
    </EmbeddedResource>
    <EmbeddedResource Include="UI\App.ico" />
    <EmbeddedResource Include="UI\BuffDebuffOptions.resx">
      <DependentUpon>BuffDebuffOptions.cs</DependentUpon>
    </EmbeddedResource>
    <EmbeddedResource Include="UI\SoundEntry.resx">
      <DependentUpon>SoundEntry.cs</DependentUpon>
    </EmbeddedResource>
    <EmbeddedResource Include="UI\HueEntry.resx">
      <DependentUpon>HueEntry.cs</DependentUpon>
    </EmbeddedResource>
    <EmbeddedResource Include="UI\InputDropdown.resx">
      <DependentUpon>InputDropdown.cs</DependentUpon>
    </EmbeddedResource>
    <EmbeddedResource Include="UI\InputBox.resx">
      <DependentUpon>InputBox.cs</DependentUpon>
    </EmbeddedResource>
    <EmbeddedResource Include="UI\MacroInsertDoWhile.resx">
      <DependentUpon>MacroInsertDoWhile.cs</DependentUpon>
    </EmbeddedResource>
    <EmbeddedResource Include="UI\MacroInsertWhile.resx">
      <DependentUpon>MacroInsertWhile.cs</DependentUpon>
    </EmbeddedResource>
    <EmbeddedResource Include="UI\MacroInsertIf.resx">
      <DependentUpon>MacroInsertIf.cs</DependentUpon>
    </EmbeddedResource>
    <EmbeddedResource Include="UI\MacroInsertWait.resx">
      <DependentUpon>MacroInsertWait.cs</DependentUpon>
    </EmbeddedResource>
    <EmbeddedResource Include="UI\MessageDialog.resx">
      <DependentUpon>MessageDialog.cs</DependentUpon>
    </EmbeddedResource>
    <EmbeddedResource Include="UI\ContainerLabels.resx">
      <DependentUpon>ContainerLabels.cs</DependentUpon>
    </EmbeddedResource>
    <EmbeddedResource Include="UI\Razor.resx">
      <DependentUpon>Razor.cs</DependentUpon>
      <SubType>Designer</SubType>
    </EmbeddedResource>
    <EmbeddedResource Include="UI\SplashScreen.resx">
      <DependentUpon>SplashScreen.cs</DependentUpon>
      <SubType>Designer</SubType>
    </EmbeddedResource>
    <EmbeddedResource Include="UI\WelcomeForm.resx">
      <DependentUpon>WelcomeForm.cs</DependentUpon>
    </EmbeddedResource>
    <Content Include="Boat\Images\anchor-left.png" />
    <Content Include="Boat\Images\anchor-right.png" />
    <Content Include="Boat\Images\boateast.png" />
    <Content Include="Boat\Images\boatnorth.png" />
    <Content Include="Boat\Images\boatsouth.png" />
    <Content Include="Boat\Images\boatwest.png" />
    <Content Include="Boat\Images\east.png" />
    <Content Include="Boat\Images\north.png" />
    <Content Include="Boat\Images\northeast.png" />
    <Content Include="Boat\Images\northwest.png" />
    <Content Include="Boat\Images\serpentspillar.png" />
    <Content Include="Boat\Images\south.png" />
    <Content Include="Boat\Images\southeast.png" />
    <Content Include="Boat\Images\southwest.png" />
    <Content Include="Boat\Images\west.png" />
    <Content Include="cuoapi.dll">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </Content>
    <Content Include="UI\Lock.ico" />
    <Content Include="UI\UOPS.ico" />
  </ItemGroup>
  <ItemGroup>
    <BootstrapperPackage Include="Microsoft.Net.Client.3.5">
      <Visible>False</Visible>
      <ProductName>.NET Framework 3.5 SP1 Client Profile</ProductName>
      <Install>false</Install>
    </BootstrapperPackage>
    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
      <Visible>False</Visible>
      <ProductName>.NET Framework 3.5 SP1</ProductName>
      <Install>true</Install>
    </BootstrapperPackage>
    <BootstrapperPackage Include="Microsoft.Windows.Installer.3.1">
      <Visible>False</Visible>
      <ProductName>Windows Installer 3.1</ProductName>
      <Install>true</Install>
    </BootstrapperPackage>
  </ItemGroup>
  <ItemGroup>
    <None Include="app.config" />
    <None Include="packages.config" />
    <None Include="Razor.manifest" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\FastColoredTextBox\FastColoredTextBox.csproj">
      <Project>{6DD14A85-CCFC-4774-BD26-0F5772512319}</Project>
      <Name>FastColoredTextBox</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup />
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
  <PropertyGroup>
    <PreBuildEvent>
    </PreBuildEvent>
    <PostBuildEvent>xcopy /S /Q /Y "$(SolutionDir)etc\*" "$(SolutionDir)bin\Win32\$(Configuration)\"
xcopy /S /Q /Y "$(SolutionDir)etc\*" "$(SolutionDir)bin\x64\$(Configuration)\"</PostBuildEvent>
  </PropertyGroup>
</Project>

================================================
FILE: Razor/Razor.manifest
================================================
<?xml version="1.0" encoding="utf-8"?>
<asmv1:assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1" xmlns:asmv1="urn:schemas-microsoft-com:asm.v1" xmlns:asmv2="urn:schemas-microsoft-com:asm.v2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <assemblyIdentity version="1.0.0.0" name="Razor" />
  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
    <security>
      <requestedPrivileges xmlns="urn:schemas-microsoft-com:asm.v3">
        <requestedExecutionLevel level="requireAdministrator" uiAccess="false" />
      </requestedPrivileges>
      <applicationRequestMinimum>
        <PermissionSet Unrestricted="true" ID="Custom" SameSite="site" />
        <defaultAssemblyRequest permissionSetReference="Custom" />
      </applicationRequestMinimum>
    </security>
  </trustInfo>
</asmv1:assembly>

================================================
FILE: Razor/Scripts/AgentCommands.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using Assistant.Agents;
using Assistant.Scripts.Engine;

namespace Assistant.Scripts
{
    public static class AgentCommands
    {
        public static void Register()
        {
            // "useonce", "organizer", "org", "restock", "scav", "scavenger"
            Interpreter.RegisterCommandHandler("useonce", UseOnceCommand);
            Interpreter.RegisterCommandHandler("organizer", OrganizerAgentCommand);
            Interpreter.RegisterCommandHandler("organize", OrganizerAgentCommand);
            Interpreter.RegisterCommandHandler("org", OrganizerAgentCommand);
            Interpreter.RegisterCommandHandler("restock", RestockAgentCommand);
            Interpreter.RegisterCommandHandler("scav", ScavAgentCommand);
            Interpreter.RegisterCommandHandler("scavenger", ScavAgentCommand);
            Interpreter.RegisterCommandHandler("sell", SellAgentCommand);
        }

        private static bool RestockAgentCommand(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length < 1)
            {
                throw new RunTimeError( "Usage: restock (number) ['set']");
            }
            
            bool setBag = false;

            if (vars.Length == 2)
            {
                if (vars[1].AsString().IndexOf("set", StringComparison.OrdinalIgnoreCase) != -1)
                {
                    setBag = true;
                }
            }

            if (!int.TryParse(vars[0].AsString(), out var agentNum))
            {
                string alias = vars[0].AsString();

                foreach (RestockAgent agent in RestockAgent.Agents)
                {
                    if (agent.Alias.IndexOf(alias, StringComparison.OrdinalIgnoreCase) != -1)
                    {
                        agentNum = agent.Number;
                        break;
                    }
                }
            }

            if (setBag)
            {
                RestockAgent.Agents[agentNum - 1].SetHB();
            }
            else
            {
                RestockAgent.Agents[agentNum - 1].OnHotKey();
            }

            return true;
        }

        private static bool UseOnceCommand(string command, Variable[] vars, bool quiet, bool force)
        {
            bool add = false;
            bool container = false;

            if (vars.Length == 1)
            {
                if (vars[0].AsString().IndexOf("add", StringComparison.OrdinalIgnoreCase) != -1)
                {
                    add = true;
                }
                else if (vars[0].AsString().IndexOf("addcontainer", StringComparison.OrdinalIgnoreCase) != -1)
                {
                    container = true;
                }
            }

            if (add)
            {
                UseOnceAgent.Instance.OnAdd();
            }
            else if (container)
            {
                UseOnceAgent.Instance.OnAddContainer();
            }
            else
            {
                UseOnceAgent.Instance.OnHotKey();
            }

            return true;
        }

        private static bool OrganizerAgentCommand(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length < 1)
            {
                throw new RunTimeError("Usage: organizer (number) ['set']");
            }

            bool setBag = false;

            if (vars.Length == 2)
            {
                if (vars[1].AsString().IndexOf("set", StringComparison.OrdinalIgnoreCase) != -1)
                {
                    setBag = true;
                }
            }

            if (!int.TryParse(vars[0].AsString(), out var agentNum))
            {
                string alias = vars[0].AsString();

                foreach (OrganizerAgent agent in OrganizerAgent.Agents)
                {
                    if (agent.Alias.IndexOf(alias, StringComparison.OrdinalIgnoreCase) != -1)
                    {
                        agentNum = agent.Number;
                        break;
                    }
                }
            }

            if (setBag)
            {
                OrganizerAgent.Agents[agentNum - 1].SetHotBag();
            }
            else
            {
                OrganizerAgent.Agents[agentNum - 1].Organize();
            }

            return true;
        }

        private static bool ScavAgentCommand(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length < 1)
            {
                throw new RunTimeError("Usage: scavenger ['clear'/'add'/'on'/'off'/'set']");
            }

            bool clear = false;
            bool add = false;
            bool set = false;

            bool status = false;
            bool enabled = true;

            if (vars.Length == 1)
            {
                if (vars[0].AsString().IndexOf("clear", StringComparison.OrdinalIgnoreCase) != -1)
                {
                    clear = true;
                }
                else if (vars[0].AsString().IndexOf("add", StringComparison.OrdinalIgnoreCase) != -1)
                {
                    add = true;
                }
                else if (vars[0].AsString().IndexOf("on", StringComparison.OrdinalIgnoreCase) != -1)
                {
                    status = true;
                }
                else if (vars[0].AsString().IndexOf("off", StringComparison.OrdinalIgnoreCase) != -1)
                {
                    status = true;
                    enabled = false;
                }
                else if (vars[0].AsString().IndexOf("set", StringComparison.OrdinalIgnoreCase) != -1)
                {
                    set = true;
                }
            }

            if (clear)
            {
                ScavengerAgent.Instance.ClearCache();
            }
            else if (add)
            {
                ScavengerAgent.Instance.OnAddToHotBag();
            }
            else if (status)
            {
                if (enabled)
                {
                    ScavengerAgent.Instance.Enable();
                }
                else
                {
                    ScavengerAgent.Instance.Disable();
                }
            }
            else if (set)
            {
                ScavengerAgent.Instance.OnSetHotBag();
            }

            return true;
        }

        private static bool SellAgentCommand(string command, Variable[] vars, bool quiet, bool force)
        {
            SellAgent.Instance.SetHotBag();

            return true;
        }
    }
}

================================================
FILE: Razor/Scripts/Aliases.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using Assistant.Scripts.Engine;

namespace Assistant.Scripts
{
    public static class Aliases
    {
        public static void Register()
        {
            Interpreter.RegisterAliasHandler("backpack", Backpack);
            Interpreter.RegisterAliasHandler("last", Last);
            Interpreter.RegisterAliasHandler("lasttarget", Last);
            Interpreter.RegisterAliasHandler("lastobject", LastObject);
            Interpreter.RegisterAliasHandler("self", Self);
            Interpreter.RegisterAliasHandler("righthand", RightHand);
            Interpreter.RegisterAliasHandler("lefthand", LeftHand);
            Interpreter.RegisterAliasHandler("hand", Hand);
        }

        private static uint RightHand(string alias)
        {
            Item item = World.Player.GetItemOnLayer(Layer.RightHand);

            return World.Player != null && item != null
                ? (uint) item.Serial
                : 0;
        }

        private static uint LeftHand(string alias)
        {
            Item item = World.Player.GetItemOnLayer(Layer.LeftHand);

            return World.Player != null && item != null
                ? (uint)item.Serial
                : 0;
        }

        private static uint Hand(string alias)
        {
            Item item = World.Player.GetItemOnLayer(Layer.RightHand) ?? World.Player.GetItemOnLayer(Layer.LeftHand);

            return World.Player != null && item != null
                ? (uint)item.Serial
                : 0;
        }

        private static uint Backpack(string alias)
        {
            if (World.Player == null || World.Player.Backpack == null)
                return 0;

            return World.Player.Backpack.Serial;
        }

        private static uint Last(string alias)
        {
            if (Targeting.LastTargetInfo != null)
                return Targeting.LastTargetInfo.Serial;

            return 0;
        }

        private static uint LastObject(string alias)
        {
            if (World.Player.LastObject != null)
                return World.Player.LastObject;

            return 0;
        }

        private static uint Self(string alias)
        {
            if (World.Player == null)
                return 0;

            return World.Player.Serial;
        }
    }
}

================================================
FILE: Razor/Scripts/Commands.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using Assistant.Core;
using Assistant.HotKeys;
using Assistant.Scripts.Engine;
using Assistant.Scripts.Helpers;
using Ultima;

namespace Assistant.Scripts
{
    public static class Commands
    {
        public static void Register()
        {
            // Commands based on Actions.cs
            Interpreter.RegisterCommandHandler("attack", Attack); //Attack by serial
            Interpreter.RegisterCommandHandler("cast", Cast); //BookcastAction, etc

            // Dress
            Interpreter.RegisterCommandHandler("dress", DressCommand); //DressAction
            Interpreter.RegisterCommandHandler("undress", UnDressCommand); //UndressAction

            // Using stuff
            Interpreter.RegisterCommandHandler("dclicktype", DClickType); // DoubleClickTypeAction
            Interpreter.RegisterCommandHandler("dclick", DClick); //DoubleClickAction

            Interpreter.RegisterCommandHandler("usetype", DClickType); // DoubleClickTypeAction
            Interpreter.RegisterCommandHandler("useobject", DClick); //DoubleClickAction

            // Moving stuff
            Interpreter.RegisterCommandHandler("drop", DropItem); //DropAction
            Interpreter.RegisterCommandHandler("droprelloc", DropRelLoc); //DropAction
            Interpreter.RegisterCommandHandler("lift", LiftItem); //LiftAction
            Interpreter.RegisterCommandHandler("lifttype", LiftType); //LiftTypeAction

            // Gump
            Interpreter.RegisterCommandHandler("waitforgump", WaitForGump); // WaitForGumpAction
            Interpreter.RegisterCommandHandler("gumpresponse", GumpResponse); // GumpResponseAction
            Interpreter.RegisterCommandHandler("gumpclose", GumpClose); // GumpResponseAction

            // Menu
            Interpreter.RegisterCommandHandler("menu", ContextMenu); //ContextMenuAction
            Interpreter.RegisterCommandHandler("menuresponse", MenuResponse); //MenuResponseAction
            Interpreter.RegisterCommandHandler("waitformenu", WaitForMenu); //WaitForMenuAction

            // Prompt
            Interpreter.RegisterCommandHandler("promptresponse", PromptResponse); //PromptAction
            Interpreter.RegisterCommandHandler("waitforprompt", WaitForPrompt); //WaitForPromptAction

            // Hotkey execution
            Interpreter.RegisterCommandHandler("hotkey", Hotkey); //HotKeyAction

            

            Interpreter.RegisterCommandHandler("overhead", OverheadMessage); //OverheadMessageAction
            Interpreter.RegisterCommandHandler("headmsg", OverheadMessage); //OverheadMessageAction
            Interpreter.RegisterCommandHandler("sysmsg", SystemMessage); //SystemMessageAction
            Interpreter.RegisterCommandHandler("clearsysmsg", ClearSysMsg); //SystemMessageAction
            Interpreter.RegisterCommandHandler("clearjournal", ClearSysMsg); //SystemMessageAction

            // General Waits/Pauses
            Interpreter.RegisterCommandHandler("wait", Pause); //PauseAction
            Interpreter.RegisterCommandHandler("pause", Pause); //PauseAction
            Interpreter.RegisterCommandHandler("waitforsysmsg", WaitForSysMsg);
            Interpreter.RegisterCommandHandler("wfsysmsg", WaitForSysMsg);

            // Misc
            Interpreter.RegisterCommandHandler("setability", SetAbility); //SetAbilityAction
            Interpreter.RegisterCommandHandler("setlasttarget", SetLastTarget); //SetLastTargetAction
            Interpreter.RegisterCommandHandler("lasttarget", LastTarget); //LastTargetAction
            Interpreter.RegisterCommandHandler("skill", UseSkill); //SkillAction
            Interpreter.RegisterCommandHandler("useskill", UseSkill); //SkillAction
            Interpreter.RegisterCommandHandler("walk", Walk); //Move/WalkAction
            Interpreter.RegisterCommandHandler("potion", Potion);

            // Script related
            Interpreter.RegisterCommandHandler("script", PlayScript);
            Interpreter.RegisterCommandHandler("setvar", SetVar);
            Interpreter.RegisterCommandHandler("setvariable", SetVar);
            Interpreter.RegisterCommandHandler("unsetvar", UnsetVar);
            Interpreter.RegisterCommandHandler("unsetvariable", UnsetVar);

            Interpreter.RegisterCommandHandler("stop", Stop);

            Interpreter.RegisterCommandHandler("clearall", ClearAll);

            Interpreter.RegisterCommandHandler("clearhands", ClearHands);

            Interpreter.RegisterCommandHandler("virtue", Virtue);

            Interpreter.RegisterCommandHandler("random", Random);

            Interpreter.RegisterCommandHandler("cleardragdrop", ClearDragDrop);
            Interpreter.RegisterCommandHandler("interrupt", Interrupt);

            Interpreter.RegisterCommandHandler("sound", Sound);
            Interpreter.RegisterCommandHandler("music", Music);

            Interpreter.RegisterCommandHandler("classicuo", ClassicUOProfile);
            Interpreter.RegisterCommandHandler("cuo", ClassicUOProfile);
            
            Interpreter.RegisterCommandHandler("rename", Rename);
            
            Interpreter.RegisterCommandHandler("getlabel", GetLabel);
            
            Interpreter.RegisterCommandHandler("ignore", AddIgnore);
            Interpreter.RegisterCommandHandler("unignore", RemoveIgnore);
            Interpreter.RegisterCommandHandler("clearignore", ClearIgnore);
            
            Interpreter.RegisterCommandHandler("cooldown", Cooldown);
            
            Interpreter.RegisterCommandHandler("poplist", PopList);
            Interpreter.RegisterCommandHandler("pushlist", PushList);
            Interpreter.RegisterCommandHandler("removelist", RemoveList);
            Interpreter.RegisterCommandHandler("createlist", CreateList);
            Interpreter.RegisterCommandHandler("clearlist", ClearList);
            
            Interpreter.RegisterCommandHandler("settimer", SetTimer);
            Interpreter.RegisterCommandHandler("removetimer", RemoveTimer);
            Interpreter.RegisterCommandHandler("createtimer", CreateTimer);
        }
        
        private static bool PopList(string command, Variable[] args, bool quiet, bool force)
        {
            if (args.Length != 2)
                throw new RunTimeError("Usage: poplist ('list name') ('element value'/'front'/'back')");

            if (args[1].AsString() == "front")
            {
                if (force)
                    while (Interpreter.PopList(args[0].AsString(), true, out _)) { }
                else
                    Interpreter.PopList(args[0].AsString(), true, out _);
            }
            else if (args[1].AsString() == "back")
            {
                if (force)
                    while (Interpreter.PopList(args[0].AsString(), false, out _)) { }
                else
                    Interpreter.PopList(args[0].AsString(), false, out _);
            }
            else
            {
                var evaluatedVar = new Variable(args[1].AsString());
                if (force)
                {
                    while (Interpreter.PopList(args[0].AsString(), evaluatedVar)) { }
                }
                else
                    Interpreter.PopList(args[0].AsString(), evaluatedVar);
            }

            return true;
        }

        private static bool PushList(string command, Variable[] args, bool quiet, bool force)
        {
            if (args.Length < 2 || args.Length > 3)
                throw new RunTimeError("Usage: pushlist ('list name') ('element value') ['front'/'back']");

            bool front = false;
            if (args.Length == 3)
            {
                if (args[2].AsString() == "front")
                    front = true;
            }

            Interpreter.PushList(args[0].AsString(), new Variable(args[1].AsString()), front, force);

            return true;
        }

        private static bool RemoveList(string command, Variable[] args, bool quiet, bool force)
        {
            if (args.Length != 1)
                throw new RunTimeError("Usage: removelist ('list name')");

            Interpreter.DestroyList(args[0].AsString());

            return true;
        }

        private static bool CreateList(string command, Variable[] args, bool quiet, bool force)
        {
            if (args.Length != 1)
                throw new RunTimeError("Usage: createlist ('list name')");

            Interpreter.CreateList(args[0].AsString());

            return true;
        }

        private static bool ClearList(string command, Variable[] args, bool quiet, bool force)
        {
            if (args.Length != 1)
                throw new RunTimeError("Usage: clearlist ('list name')");

            Interpreter.ClearList(args[0].AsString());

            return true;
        }

        private static bool SetTimer(string command, Variable[] args, bool quiet, bool force)
        {
            if (args.Length != 2)
                throw new RunTimeError("Usage: settimer (timer name) (value)");


            Interpreter.SetTimer(args[0].AsString(), args[1].AsInt());
            return true;
        }

        private static bool RemoveTimer(string command, Variable[] args, bool quiet, bool force)
        {
            if (args.Length != 1)
                throw new RunTimeError("Usage: removetimer (timer name)");

            Interpreter.RemoveTimer(args[0].AsString());
            return true;
        }

        private static bool CreateTimer(string command, Variable[] args, bool quiet, bool force)
        {
            if (args.Length != 1)
                throw new RunTimeError("Usage: createtimer (timer name)");

            Interpreter.CreateTimer(args[0].AsString());
            return true;
        }

        private static bool Cooldown(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length < 2)
            {
                throw new RunTimeError("Usage: cooldown ('name') ('seconds') ['hue'] ['icon'] ['sound'] ['stay visible'] ['foreground color'] ['background color']");
            }

            string name = vars[0].AsString();
            int seconds = vars[1].AsInt();
            
            int hue = 0, sound = 0;
            string icon = "none";
            bool stay = false;
            
            Color foreColor = Color.Empty;
            Color backColor = Color.Empty;
            
            switch (vars.Length)
            {
                case 3:
                    hue = vars[2].AsInt();

                    break;
                case 4:
                    hue = vars[2].AsInt();
                    icon = vars[3].AsString();

                    break;
                case 5:
                    hue = vars[2].AsInt();
                    icon = vars[3].AsString();
                    sound = vars[4].AsInt();

                    break;
                case 6:
                    hue = vars[2].AsInt();
                    icon = vars[3].AsString();
                    sound = vars[4].AsInt();
                    stay = vars[5].AsBool();

                    break;
                case 7:
                    hue = vars[2].AsInt();
                    icon = vars[3].AsString();
                    sound = vars[4].AsInt();
                    stay = vars[5].AsBool();

                    foreColor = Color.FromName(vars[6].AsString());

                    break;
                case 8:
                    hue = vars[2].AsInt();
                    icon = vars[3].AsString();
                    sound = vars[4].AsInt();
                    stay = vars[5].AsBool();

                    foreColor = Color.FromName(vars[6].AsString());
                    backColor = Color.FromName(vars[7].AsString());

                    break;
            }
            
            CooldownManager.AddCooldown(new Cooldown
            {
                Name = name,
                EndTime = DateTime.UtcNow.AddSeconds(seconds),
                Hue = hue,
                Icon = icon.Equals("0") ? 0 : BuffDebuffManager.GetGraphicId(icon),
                Seconds = seconds,
                SoundId = sound,
                StayVisible = stay,
                ForegroundColor = foreColor,
                BackgroundColor = backColor
            });

            return true;
        }
        
        private enum GetLabelState
        {
            None,
            WaitingForFirstLabel,
            WaitingForRemainingLabels
        };
        
        private static GetLabelState _getLabelState = GetLabelState.None;
        private static Action<Packet, PacketHandlerEventArgs, Serial, ushort, MessageType, ushort, ushort, string, string, string> _onLabelMessage;
        private static Action _onStop;
        
        private static bool GetLabel(string command, Variable[] args, bool quiet, bool force)
        {
            if (args.Length != 2)
                throw new RunTimeError("Usage: getlabel (serial) (name)");

            var serial = args[0].AsSerial();
            var name = args[1].AsString(false);

            var mobile = World.FindMobile(serial);
            if (mobile != null)
            {
                if (mobile.IsHuman)
                {
                    return false;
                }
            }

            switch (_getLabelState)
            {
                case GetLabelState.None:
                    _getLabelState = GetLabelState.WaitingForFirstLabel;
                    Interpreter.Timeout(2000, () =>
                    {
                        MessageManager.OnLabelMessage -= _onLabelMessage;
                        _onLabelMessage = null;
                        Interpreter.OnStop -= _onStop;
                        _getLabelState = GetLabelState.None;
                        MessageManager.GetLabelCommand = false;
                        return true;
                    });

                    // Single click the object
                    Client.Instance.SendToServer(new SingleClick((Serial)args[0].AsSerial()));

                    // Capture all message responses
                    StringBuilder label = new StringBuilder();
                    
                    // Some messages from Outlands server are send in sequence of LabelType and RegularType
                    // so we want to invoke that _onLabelMessage in both cases with delays
                    MessageManager.GetLabelCommand = true;

                    // Reset the state when script is stopped
                    _onStop = () =>
                    {
                        if (_onLabelMessage != null)
                        {
                            MessageManager.OnLabelMessage -= _onLabelMessage;
                            _onLabelMessage = null;
                        }
                        _getLabelState = GetLabelState.None;
                        
                        Interpreter.OnStop -= _onStop;
                        MessageManager.GetLabelCommand = false;
                    };

                    _onLabelMessage = (p, a, source, graphic, type, hue, font, lang, sourceName, text) =>
                    {
                        if (source != serial)
                            return;

                        a.Block = true;

                        if (_getLabelState == GetLabelState.WaitingForFirstLabel)
                        {
                            // After the first message, switch to a pause instead of a timeout.
                            _getLabelState = GetLabelState.WaitingForRemainingLabels;
                            Interpreter.Pause(500);
                        }

                        label.Append(" " + text);

                        Interpreter.SetVariable(name, label.ToString().Trim());
                    };

                    Interpreter.OnStop += _onStop;
                    MessageManager.OnLabelMessage += _onLabelMessage;
                    
                    break;
                case GetLabelState.WaitingForFirstLabel:
                    break;
                case GetLabelState.WaitingForRemainingLabels:
                    // We get here after the pause has expired.
                    Interpreter.OnStop -= _onStop;
                    MessageManager.OnLabelMessage -= _onLabelMessage;
                    
                    _onLabelMessage = null;
                    _getLabelState = GetLabelState.None;
                    
                    MessageManager.GetLabelCommand = false;
                    
                    return true;
            }

            return false;
        }

        private static bool Rename(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length < 2)
            {
                throw new RunTimeError("Usage: rename (serial) (new_name)");
            }

            string newName = vars[1].AsString();
            
            if (newName.Length < 1)
            {
                throw new RunTimeError("Mobile name must be longer than one character");
            }

            if (World.Mobiles.TryGetValue(vars[0].AsSerial(), out var follower))
            {
                if (follower.CanRename)
                {
                    PlayerData.RenameMobile(follower.Serial, newName);
                }
                else
                {
                    CommandHelper.SendMessage("Unable to rename mobile", quiet);
                }
            }
            
            return true;
        }

        private static bool ClassicUOProfile(string commands, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length != 2)
            {
                throw new RunTimeError("Usage: cuo (setting) (value)");
            }

            string property = ClassicUOManager.IsValidProperty(vars[0].AsString());

            if (string.IsNullOrEmpty(property))
            {
                throw new RunTimeError("Unknown ClassicUO setting/property. Type `>cuo list` for a list of valid settings.");
            }

            bool isNumeric = int.TryParse(vars[0].AsString(), out var value);

            if (isNumeric)
            {
                ClassicUOManager.ProfilePropertySet(property, value);
            }
            else
            {
                switch (vars[1].AsString())
                {
                    case "true":
                        ClassicUOManager.ProfilePropertySet(property, true);
                        break;
                    case "false":
                        ClassicUOManager.ProfilePropertySet(property, false);
                        break;
                    default:
                        ClassicUOManager.ProfilePropertySet(property, vars[1].AsString());
                        break;
                }
            }

            CommandHelper.SendMessage($"ClassicUO Setting: '{property}' set to '{vars[1].AsString()}'", quiet);

            return true;
        }

        private static bool Sound(string commands, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length != 1)
            {
                throw new RunTimeError("Usage: sound (serial)");
            }

            Client.Instance.SendToClient(new PlaySound(vars[0].AsInt()));

            return true;
        }

        private static bool Music(string commands, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length != 1)
            {
                throw new RunTimeError("Usage: music (id)");
            }

            Client.Instance.SendToClient(new PlayMusic(vars[0].AsUShort()));

            return true;
        }

        private static bool AddIgnore(string commands, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length != 1)
                throw new RunTimeError("Usage: ignore (serial)");

            Variable toIgnore = vars[0];
            string ignoreListName = vars[0].AsString();
            
            if (Interpreter.ListExists(ignoreListName))
            {
                List<Serial> list = Interpreter.GetList(ignoreListName).Select(v => (Serial)v.AsSerial()).ToList();
                Interpreter.AddIgnoreRange(list);
                CommandHelper.SendMessage($"Added {list.Count} entries to ignore list", quiet);
            }
            else
            {
                uint serial = toIgnore.AsSerial();
                Interpreter.AddIgnore(serial);
                CommandHelper.SendMessage($"Added {serial} to ignore list", quiet);
            }
            
            return true;
        }
        
        private static bool RemoveIgnore(string commands, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length != 1)
                throw new RunTimeError("Usage: unignore (serial or list)");
            
            Variable toIgnore = vars[0];
            string ignoreListName = toIgnore.AsString();
            
            if (Interpreter.ListExists(ignoreListName))
            {
                List<Serial> list = Interpreter.GetList(ignoreListName).Select(v => (Serial)v.AsSerial()).ToList();
                Interpreter.RemoveIgnoreRange(list);
                CommandHelper.SendMessage($"Removed {list.Count} entries from ignore list", quiet);
            }
            else
            {
                uint serial = toIgnore.AsSerial();
                Interpreter.RemoveIgnore(serial);
                CommandHelper.SendMessage($"Removed {serial} from ignore list", quiet);
            }
            
            return true;
        }

        private static bool ClearIgnore(string commands, Variable[] vars, bool quiet, bool force)
        {
            Interpreter.ClearIgnore();

            CommandHelper.SendMessage("Ignore List cleared", quiet);

            return true;
        }

        private static readonly string[] Virtues = { "honor", "sacrifice", "valor" };

        private static bool Virtue(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length == 0 || !Virtues.Contains(vars[0].AsString()))
            {
                throw new RunTimeError("Usage: virtue ('honor'/'sacrifice'/'valor')");
            }

            switch (vars[0].AsString())
            {
                case "honor":
                    PlayerData.InvokeVirtue(PlayerData.InvokeVirtues.Honor);
                    break;
                case "sacrifice":
                    PlayerData.InvokeVirtue(PlayerData.InvokeVirtues.Sacrifice);
                    break;
                case "valor":
                    PlayerData.InvokeVirtue(PlayerData.InvokeVirtues.Valor);
                    break;
            }

            return true;
        }

        private static bool ClearAll(string command, Variable[] vars, bool quiet, bool force)
        {

            DragDropManager.GracefulStop(); // clear drag/drop queue
            Targeting.CancelTarget(); // clear target queue & cancel current target
            DragDropManager.DropCurrent(); // drop what you are currently holding

            return true;
        }

        private static bool SetLastTarget(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length == 0)
            {
                throw new RunTimeError("Usage: setlasttarget ('serial')");
            }
            
            Serial serial = vars[0].AsSerial();

            if (serial != Serial.Zero)
            {
                Mobile mobile = World.FindMobile(serial);

                if (mobile != null)
                {
                    Targeting.SetLastTarget(mobile);
                    return true;
                }
                    
                Item item = World.FindItem(serial);

                if (item != null)
                {
                    Targeting.SetLastTarget(item);
                    return true;
                }

                Targeting.SetLastTarget(serial);
            }

            return true;
        }
        
        private enum SetVarState
        {
            INITIAL_PROMPT,
            WAIT_FOR_TARGET,
            COMPLETE,
        };

        private static SetVarState _setVarState = SetVarState.INITIAL_PROMPT;

        private static bool SetVar(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length < 1 || vars.Length > 2)
            {
                throw new RunTimeError("Usage: setvar ('variable') [serial] [timeout]");
            }

            string name = vars[0].AsString(false);

            if (vars.Length == 2)
            {
                // No need to target anything. We have the serial.
                var serial = vars[1].AsSerial();

                if (force)
                {
                    Interpreter.SetVariable(name, serial.ToString(), true);
                    return true;
                }

                if (ScriptVariables.GetVariable(name) == Serial.MinusOne && !quiet)
                {
                    CommandHelper.SendMessage($"'{name}' not found, creating new variable", quiet);
                }

                ScriptVariables.RegisterVariable(name, serial);
                CommandHelper.SendMessage($"'{name}' script variable updated to '{serial}'", quiet);

                Assistant.Engine.MainWindow.SaveScriptVariables();

                return true;
            }

            Interpreter.Timeout(vars.Length == 2 ? vars[1].AsUInt() : 30000, () => { _setVarState = SetVarState.INITIAL_PROMPT; return true; } );

            switch (_setVarState)
            {
                case SetVarState.INITIAL_PROMPT:
                    if (ScriptVariables.GetVariable(name) == Serial.MinusOne)
                    {
                        CommandHelper.SendMessage($"'{name}' not found, creating new variable", quiet);
                    }
                    World.Player.SendMessage(MsgLevel.Force, $"Select target for variable '{name}'");

                    _setVarState = SetVarState.WAIT_FOR_TARGET;

                    Targeting.OneTimeTarget((ground, serial, pt, gfx) =>
                    {
                        ScriptVariables.RegisterVariable(name, serial);
                        CommandHelper.SendMessage($"'{name}' script variable updated to '{serial}'", quiet);

                        Assistant.Engine.MainWindow.SaveScriptVariables();
                        _setVarState = SetVarState.COMPLETE;
                    },
                    () =>
                    {
                        _setVarState = SetVarState.COMPLETE;
                    });
                    break;
                case SetVarState.WAIT_FOR_TARGET:
                    break;
                case SetVarState.COMPLETE:
                    _setVarState = SetVarState.INITIAL_PROMPT;
                    return true;
            }

            return false;
        }
        
        private static bool UnsetVar(string expression, Variable[] args, bool quiet, bool force)
        {
            if (args.Length != 1)
                throw new RunTimeError("Usage: unsetvar ('name')");

            var name = args[0].AsString(false);

            if (force)
            {
                if (quiet)
                {
                    Interpreter.ClearVariable(name);
                }
                else
                {
                    Interpreter.ClearAlias(name);
                }
            }
            else
            {
                ScriptVariables.UnregisterVariable(name);
                ScriptManager.RedrawScripts();
            }

            return true;
        }


        private static bool Stop(string command, Variable[] vars, bool quiet, bool force)
        {
            ScriptManager.StopScript();

            return true;
        }

        private static bool Hotkey(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length < 1)
            {
                throw new RunTimeError("Usage: hotkey ('name of hotkey') OR (hotkeyId)");
            }

            string query = vars[0].AsString();

            KeyData hk = HotKey.GetByNameOrId(query);

            if (hk == null)
            {
                throw new RunTimeError($"{command} - Hotkey '{query}' not found");
            }

            hk.Callback();

            return true;
        }

        private static bool WaitForGump(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length < 1)
            {
                throw new RunTimeError("Usage: waitforgump (gumpId/'any') [timeout]");
            }

            uint gumpId = 0;
            bool strict = false;

            if (vars[0].AsString().IndexOf("any", StringComparison.OrdinalIgnoreCase) != -1)
            {
                strict = false;
            }
            else
            {
                gumpId = Utility.ToUInt32(vars[0].AsString(), 0);

                if (gumpId > 0)
                {
                    strict = true;
                }
            }

            Interpreter.Timeout(vars.Length == 2 ? vars[1].AsUInt() : 30000, () => { return true; });

            if ((World.Player.HasGump || World.Player.HasCompressedGump) &&
                (World.Player.CurrentGumpI == gumpId || !strict || gumpId == 0))
            {
                Interpreter.ClearTimeout();
                return true;
            }

            return false;
        }

        private static bool WaitForMenu(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length < 1)
            {
                throw new RunTimeError("Usage: waitformenu (menuId/'any') [timeout]");
            }

            uint menuId = 0;

            // Look for a specific menu
            menuId = vars[0].AsString().IndexOf("any", StringComparison.OrdinalIgnoreCase) != -1
                ? 0
                : Utility.ToUInt32(vars[0].AsString(), 0);

            Interpreter.Timeout(vars.Length == 2 ? vars[1].AsUInt() : 30000, () => { return true; });

            if (World.Player.HasMenu && (World.Player.CurrentGumpI == menuId || menuId == 0))
            {
                Interpreter.ClearTimeout();
                return true;
            }

            return false;
        }

        private static bool WaitForPrompt(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length < 1)
            {
                throw new RunTimeError("Usage: waitforprompt (promptId/'any') [timeout]");
            }

            uint promptId = 0;
            bool strict = false;

            // Look for a specific prompt
            if (vars[0].AsString().IndexOf("any", StringComparison.OrdinalIgnoreCase) != -1)
            {
                strict = false;
            }
            else
            {
                promptId = Utility.ToUInt32(vars[0].AsString(), 0);

                if (promptId > 0)
                {
                    strict = true;
                }
            }

            Interpreter.Timeout(vars.Length == 2 ? vars[1].AsUInt() : 30000, () => { return true; });

            if (World.Player.HasPrompt && (World.Player.PromptID == promptId || !strict || promptId == 0))
            {
                Interpreter.ClearTimeout();
                return true;
            }

            return false;
        }

        private static readonly string[] Abilities = {"primary", "secondary", "stun", "disarm"};

        private static bool SetAbility(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length < 1 || !Abilities.Contains(vars[0].AsString()))
            {
                throw new RunTimeError("Usage: setability ('primary'/'secondary'/'stun'/'disarm') ['on'/'off']");
            }

            if (vars.Length == 2 && vars[1].AsString() == "on" || vars.Length == 1)
            {
                switch (vars[0].AsString())
                {
                    case "primary":
                        SpecialMoves.SetPrimaryAbility();
                        break;
                    case "secondary":
                        SpecialMoves.SetSecondaryAbility();
                        break;
                    case "stun":
                        Client.Instance.SendToServer(new StunRequest());
                        break;
                    case "disarm":
                        Client.Instance.SendToServer(new DisarmRequest());
                        break;
                }
            }
            else if (vars.Length == 2 && vars[1].AsString() == "off")
            {
                Client.Instance.SendToServer(new UseAbility(AOSAbility.Clear));
                Client.Instance.SendToClient(ClearAbility.Instance);
            }

            return true;
        }

        private static readonly string[] Hands = {"left", "right", "both", "hands"};

        private static bool ClearHands(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length == 0 || !Hands.Contains(vars[0].AsString()))
            {
                throw new RunTimeError("Usage: clearhands ('left'/'right'/'both')");
            }

            switch (vars[0].AsString())
            {
                case "left":
                    Dress.Unequip(Layer.LeftHand);
                    break;
                case "right":
                    Dress.Unequip(Layer.RightHand);
                    break;
                default:
                    Dress.Unequip(Layer.LeftHand);
                    Dress.Unequip(Layer.RightHand);
                    break;
            }

            return true;
        }

        private static bool DClickType(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length == 0)
            {
                throw new RunTimeError("Usage: dclicktype ('name of item'/'graphicID') [inrangecheck (true/false)/backpack] [hue]");
            }

            string gfxStr = vars[0].AsString();
            Serial gfx = Utility.ToUInt16(gfxStr, 0);
            List<Item> items;
            List<Mobile> mobiles = new List<Mobile>();

            bool inRangeCheck = false;
            bool backpack = false;
            int hue = -1;

            if (vars.Length > 1)
            {
                if (vars.Length == 3)
                {
                    hue = vars[2].AsInt();
                }

                if (vars[1].AsString().IndexOf("pack", StringComparison.OrdinalIgnoreCase) > 0)
                {
                    backpack = true;
                }
                else
                {
                    inRangeCheck = vars[1].AsBool();
                }
            }

            // No graphic id, maybe searching by name?
            if (gfx == 0)
            {
                items = CommandHelper.GetItemsByName(gfxStr, backpack, inRangeCheck, hue);

                if (items.Count == 0) // no item found, search mobile by name
                {
                    mobiles = CommandHelper.GetMobilesByName(gfxStr, inRangeCheck);
                }
            }
            else // Provided graphic id for type, check backpack first (same behavior as DoubleClickAction in macros
            {
                ushort id = Utility.ToUInt16(gfxStr, 0);

                items = CommandHelper.GetItemsById(id, backpack, inRangeCheck, hue);
                
                // Still no item? Mobile check!
                if (items.Count == 0)
                {
                    mobiles = CommandHelper.GetMobilesById(id, inRangeCheck);
                }
            }

            if (items.Count > 0)
            {
                PlayerData.DoubleClick(items[Utility.Random(items.Count)].Serial);
            }
            else if (mobiles.Count > 0)
            {
                PlayerData.DoubleClick(mobiles[Utility.Random(mobiles.Count)].Serial);
            }
            else
            {
                CommandHelper.SendWarning(command, $"Item or mobile type '{gfxStr}' not found", quiet);
            }

            return true;
        }

        private static bool DClick(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length == 0)
            {
                throw new RunTimeError("Usage: dclick (serial) or dclick ('left'/'right'/'hands')");
            }

            if (Hands.Contains(vars[0].AsString()))
            {
                Item item;

                switch (vars[0].AsString())
                {
                    case "left":
                        item = World.Player.GetItemOnLayer(Layer.LeftHand);
                        break;
                    case "right":
                        item = World.Player.GetItemOnLayer(Layer.RightHand);
                        break;
                    default:
                        item = World.Player.GetItemOnLayer(Layer.RightHand) ?? World.Player.GetItemOnLayer(Layer.LeftHand);
                        break;
                }

                if (item != null)
                {
                    PlayerData.DoubleClick(item);
                }
                else
                {
                    CommandHelper.SendWarning(command, $"Item not found in '{vars[0].AsString()}'", quiet);
                }
            }
            else
            {
                Serial serial = vars[0].AsSerial();

                if (!serial.IsValid)
                {
                    throw new RunTimeError("dclick - invalid serial");
                }

                PlayerData.DoubleClick(serial);
            }

            return true;
        }

        private static bool DropItem(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length < 1)
            {
                throw new RunTimeError("Usage: drop (serial) (x y z/layername)");
            }

            Serial serial = vars[0].AsString().IndexOf("ground", StringComparison.OrdinalIgnoreCase) > 0
                ? uint.MaxValue
                : vars[0].AsSerial();

            Point3D to = new Point3D(0, 0, 0);
            Layer layer = Layer.Invalid;

            switch (vars.Length)
            {
                case 1: // drop at feet if only serial is provided
                    to = new Point3D(World.Player.Position.X, World.Player.Position.Y, World.Player.Position.Z);
                    break;
                case 2: // dropping on a layer
                    layer = (Layer) Enum.Parse(typeof(Layer), vars[1].AsString(), true);
                    break;
                case 3: // x y
                    to = new Point3D(Utility.ToInt32(vars[1].AsString(), 0), Utility.ToInt32(vars[2].AsString(), 0), 0);
                    break;
                case 4: // x y z
                    to = new Point3D(Utility.ToInt32(vars[1].AsString(), 0), Utility.ToInt32(vars[2].AsString(), 0),
                        Utility.ToInt32(vars[3].AsString(), 0));
                    break;
            }

            if (DragDropManager.Holding != null)
            {
                if (layer > Layer.Invalid && layer <= Layer.LastUserValid)
                {
                    Mobile m = World.FindMobile(serial);
                    if (m != null)
                        DragDropManager.Drop(DragDropManager.Holding, m, layer);
                }
                else
                {
                    DragDropManager.Drop(DragDropManager.Holding, serial, to);
                }
            }
            else
            {
                CommandHelper.SendWarning(command, "Not holding anything", quiet);
            }

            return true;
        }

        private static bool DropRelLoc(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length < 2)
            {
                throw new RunTimeError("Usage: droprelloc (x) (y)");
            }

            int x = vars[0].AsInt();
            int y = vars[1].AsInt();

            if (DragDropManager.Holding != null)
            {
                DragDropManager.Drop(DragDropManager.Holding, null,
                    new Point3D((ushort) (World.Player.Position.X + x),
                        (ushort) (World.Player.Position.Y + y), World.Player.Position.Z));
            }
            else
            {
                CommandHelper.SendWarning(command, "Not holding anything", quiet);
            }

            return true;
        }

        private static int _lastLiftId;

        private static bool LiftItem(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length < 1)
            {
                throw new RunTimeError("Usage: lift (serial) [amount] [timeout]");
            }

            Serial serial = vars[0].AsSerial();

            if (!serial.IsValid)
            {
                throw new RunTimeError($"{command} - Invalid serial");
            }

            ushort amount = 1;

            if (vars.Length == 2)
            {
                amount = Utility.ToUInt16(vars[1].AsString(), 1);
            }

            long timeout = 30000;
            
            if (vars.Length == 3)
            {
                timeout = Utility.ToLong(vars[2].AsString(), 30000);
            }

            if (_lastLiftId > 0)
            {
                if (DragDropManager.LastIDLifted == _lastLiftId)
                {
                    _lastLiftId = 0;
                    Interpreter.ClearTimeout();
                    return true;
                }

                Interpreter.Timeout(timeout, () =>
                {
                    _lastLiftId = 0;
                    return true;
                });
            }
            else
            {
                Item item = World.FindItem(serial);

                if (item != null)
                {
                    _lastLiftId = DragDropManager.Drag(item, amount <= item.Amount ? amount : item.Amount);
                }
                else
                {
                    CommandHelper.SendWarning(command, "Item not found or out of range", quiet);
                    return true;
                }
            }

            return false;
        }

        private static int _lastLiftTypeId;

        private static bool LiftType(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length < 1)
            {
                throw new RunTimeError("Usage: lifttype (gfx/'name of item') [amount] [hue]");
            }

            string gfxStr = vars[0].AsString();
            ushort gfx = Utility.ToUInt16(gfxStr, 0);
            ushort amount = 1;
            int hue = -1;

            if (vars.Length > 1)
            {
                if (vars.Length >= 2)
                {
                    amount = Utility.ToUInt16(vars[1].AsString(), 1);
                }

                if (vars.Length == 3)
                {
                    hue = Utility.ToUInt16(vars[2].AsString(), 0);
                }
            }

            if (_lastLiftTypeId > 0)
            {
                if (DragDropManager.LastIDLifted == _lastLiftTypeId)
                {
                    _lastLiftTypeId = 0;
                    Interpreter.ClearTimeout();
                    return true;
                }

                Interpreter.Timeout(30000, () =>
                {
                    _lastLiftTypeId = 0;
                    return true;
                });
            }
            else
            {
                List<Item> items = new List<Item>();

                // No graphic id, maybe searching by name?
                if (gfx == 0)
                {
                    items = World.Player.Backpack.FindItemsByName(gfxStr, true);

                    if (items.Count == 0)
                    {
                        CommandHelper.SendWarning(command, $"Item '{gfxStr}' not found", quiet);
                        return true;
                    }
                }
                else
                {
                    items = World.Player.Backpack.FindItemsById(gfx);
                }

                if (hue > -1)
                {
                    items.RemoveAll(item => item.Hue != hue);
                }

                if (items.Count > 0)
                {
                    Item item = items[Utility.Random(items.Count)];

                    if (item.Amount < amount)
                        amount = item.Amount;

                    _lastLiftTypeId = DragDropManager.Drag(item, amount);
                }
                else
                {
                    CommandHelper.SendWarning(command, Language.Format(LocString.NoItemOfType, (ItemID)gfx), quiet);
                    return true;
                }
            }

            return false;
        }

        private static bool Walk(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length < 1)
            {
                throw new RunTimeError("Usage: walk ('direction')");
            }

            if (ScriptManager.LastWalk + TimeSpan.FromSeconds(0.4) >= DateTime.UtcNow)
            {
                return false;
            }

            ScriptManager.LastWalk = DateTime.UtcNow;

            Direction dir = (Direction) Enum.Parse(typeof(Direction), vars[0].AsString(), true);
            Client.Instance.RequestMove(dir);

            return true;
        }

        private static bool UseSkill(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length == 0)
            {
                throw new RunTimeError("Usage: skill ('skill name'/'last')");
            }

            int skillId = 0;

            if (World.Player.LastSkill != -1)
            {
                skillId = World.Player.LastSkill;
            }

            if (vars[0].AsString() == "last")
            {
                Client.Instance.SendToServer(new UseSkill(World.Player.LastSkill));
            }
            else if (Skills.SkillsByName.TryGetValue(vars[0].AsString(), out SkillInfo skill))
            {
                if (skill.IsAction)
                {
                    Client.Instance.SendToServer(new UseSkill(skill.Index));

                    World.Player.LastSkill = skill.Index;
                }
                else
                {
                    CommandHelper.SendWarning(command, $"Skill '{vars[0].AsString()}' is not usable. Available usable skills: {string.Join(", ", Skills.GetUsableSkillNames())}", quiet);
                }
            }
            else
            {
                CommandHelper.SendWarning(command, $"Skill '{vars[0].AsString()}' not found. Available usable skills: {string.Join(", ", Skills.GetUsableSkillNames())}", quiet);
            }

            if (skillId == Skills.StealthIndex && !World.Player.Visible)
            {
                StealthSteps.Hide();
            }

            return true;
        }
        
        private static bool Pause(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length == 0)
                throw new RunTimeError("Usage: wait (timeout) [shorthand]");

            uint timeout = vars[0].AsUInt();

            if (vars.Length == 2)
            {
                switch (vars[1].AsString())
                {
                    case "s":
                    case "sec":
                    case "secs":
                    case "second":
                    case "seconds":
                        timeout *= 1000;
                        break;
                    case "m":
                    case "min":
                    case "mins":
                    case "minute":
                    case "minutes":
                        timeout *= 60000;
                        break;
                }
            }

            Interpreter.Pause(timeout);

            return true;
        }

        private static bool Attack(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length == 0)
            {
                throw new RunTimeError("Usage: attack (serial)");
            }

            Serial serial = vars[0].AsSerial();

            if (!serial.IsValid)
            {
                throw new RunTimeError($"{command} - Invalid serial");
            }

            if (serial == Targeting.LastTargetInfo.Serial)
            {
                Targeting.AttackLastTarg();
            }
            else
            {
                if (serial.IsMobile)
                    Client.Instance.SendToServer(new AttackReq(serial));
            }

            return true;
        }

        private static bool Cast(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length < 1)
            {
                throw new RunTimeError("Usage: cast 'name of spell'");
            }

            Spell spell = int.TryParse(vars[0].AsString(), out int spellnum)
                ? Spell.Get(spellnum)
                : Spell.GetByName(vars[0].AsString());

            if (spell != null)
            {
                spell.OnCast(new CastSpellFromMacro((ushort) spell.GetID()));
            }
            else
            {
                throw new RunTimeError($"{command} - Spell name or number not valid");
            }

            return true;
        }

        private static bool OverheadMessage(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length == 0)
            {
                throw new RunTimeError("Usage: overhead ('text') [color] [serial]");
            }
            
            string overheadMessage = vars[0].AsString();
            overheadMessage = CommandHelper.ReplaceStringInterpolations(overheadMessage);

            if (vars.Length == 1)
            {
                World.Player.OverheadMessage(Config.GetInt("SysColor"), overheadMessage);
            }
            else if (vars.Length == 2)
            {
                int hue = Utility.ToInt32(vars[1].AsString(), 0);

                if (vars.Length == 3)
                {
                    uint serial = vars[2].AsSerial();

                    Mobile m = World.FindMobile(serial);
                    m?.OverheadMessage(hue, overheadMessage);
                }
                else
                {
                    World.Player.OverheadMessage(hue, overheadMessage);
                }
            }

            return true;
        }

        private static bool SystemMessage(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length == 0)
            {
                throw new RunTimeError("Usage: sysmsg ('text') [color]");
            }
            
            var sysMessage = vars[0].AsString();
            sysMessage = CommandHelper.ReplaceStringInterpolations(sysMessage);

            if (vars.Length == 1)
            {
                World.Player.SendMessage(Config.GetInt("SysColor"), sysMessage);
            }
            else if (vars.Length == 2)
            {
                World.Player.SendMessage(Utility.ToInt32(vars[1].AsString(), 0), sysMessage);
            }

            return true;
        }

        private static bool ClearSysMsg(string command, Variable[] vars, bool quiet, bool force)
        {
            SystemMessages.Messages.Clear();

            return true;
        }

        private static DressList _lastDressList;

        private static bool DressCommand(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length == 0)
            {
                throw new RunTimeError("Usage: dress ('name of dress list')");
            }

            if (_lastDressList == null)
            {
                _lastDressList = DressList.Find(vars[0].AsString());
                
                if (_lastDressList != null)
                {
                    _lastDressList.Dress();
                }
                else
                {
                    Serial serial = vars[0].AsSerial();
                    Item item = World.FindItem(serial);

                    if (item != null)
                    {
                        DressList dressList = new DressList("temp");
                        dressList.Items.Add(serial);
                        dressList.Dress();

                        _lastDressList = dressList;
                    }
                    else
                    {
                        CommandHelper.SendWarning(command, $"'{vars[0].AsString()}' not found", quiet);
                        return true;
                    }
                }
            }
            else if (ActionQueue.Empty)
            {
                _lastDressList = null;
                return true;
            }

            return false;
        }

        private static DressList _lastUndressList;
        private static bool _undressAll;
        private static bool _undressLayer;

        private static bool UnDressCommand(string command, Variable[] vars, bool quiet, bool force)
        {

            if (vars.Length == 0 && !_undressAll) // full naked!
            {
                _undressAll = true;
                UndressHotKeys.OnUndressAll();
            }
            else if (vars.Length == 1 && _lastUndressList == null && !_undressLayer) // either a dress list item or a layer
            {
                _lastUndressList = DressList.Find(vars[0].AsString());

                if (_lastUndressList != null)
                {
                    _lastUndressList.Undress();
                }
                else // lets find the layer
                {
                    if (Enum.TryParse(vars[0].AsString(), true, out Layer layer))
                    {
                        Dress.Unequip(layer);
                        _undressLayer = true;
                    }
                    else
                    {
                        Serial serial = vars[0].AsSerial();
                        Item item = World.FindItem(serial);

                        if (item != null)
                        {
                            DressList undressList = new DressList("temp");
                            undressList.Items.Add(serial);
                            undressList.Undress();

                            _lastUndressList = undressList;
                        }
                        else
                        {
                            CommandHelper.SendWarning(command, $"'{vars[0].AsString()}' not found", quiet);
                            return true;
                        }
                    }
                }
            }
            else if (ActionQueue.Empty)
            {
                _undressAll = false;
                _undressLayer = false;
                _lastUndressList = null;
                return true;
            }

            return false;
        }

        private static bool GumpResponse(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length < 1)
            {
                throw new RunTimeError("Usage: gumpresponse (buttondId)");
                //throw new RunTimeError("Usage: gumpresponse (buttondId) [option] ['text1'|fieldId] ['text2'|fieldId]");
            }

            int buttonId = vars[0].AsInt();

            /*private int m_ButtonID;
                    private int[] m_Switches;
                    private GumpTextEntry[] m_TextEntries;*/

            //Assistant.Macros.GumpResponseAction|9|0|0
            //Assistant.Macros.GumpResponseAction|1|0|1|0&Hello How are you?
            //Assistant.Macros.GumpResponseAction|501|0|2|1&box2|0&box1

            Client.Instance.SendToClient(new CloseGump(World.Player.CurrentGumpI));
            Client.Instance.SendToServer(new GumpResponse(World.Player.CurrentGumpS, World.Player.CurrentGumpI,
                buttonId, new int[] { }, new GumpTextEntry[] { }));

            World.Player.HasGump = false;
            World.Player.HasCompressedGump = false;

            return true;
        }

        private static bool GumpClose(string command, Variable[] vars, bool quiet, bool force)
        {
            uint gumpI = World.Player.CurrentGumpI;

            if (vars.Length > 0)
            {
                gumpI = vars[0].AsUInt();
            }

            if (!World.Player.GumpList.ContainsKey(gumpI))
            {
                CommandHelper.SendWarning(command, $"'{gumpI}' unknown gump id", quiet);
                return true;
            }

            uint gumpS = World.Player.GumpList[gumpI].GumpSerial;

            Client.Instance.SendToClient(new CloseGump(gumpI));
            Client.Instance.SendToServer(new GumpResponse(gumpS, gumpI, 0, new int[] { }, new GumpTextEntry[] { }));

            World.Player.HasGump = false;
            World.Player.HasCompressedGump = false;

            return true;
        }

        private static bool ContextMenu(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length < 2)
            {
                throw new RunTimeError("Usage: menu (serial) (index)");
            }

            Serial s = vars[0].AsSerial();
            ushort index = vars[1].AsUShort();
            bool blockPopup = true;

            if (vars.Length > 2)
            {
                blockPopup = vars[2].AsBool();
            }

            if (s == Serial.Zero && World.Player != null)
                s = World.Player.Serial;
            
            ScriptManager.BlockPopupMenu = blockPopup;

            Client.Instance.SendToServer(new ContextMenuRequest(s));
            Client.Instance.SendToServer(new ContextMenuResponse(s, index));
            return true;
        }

        private static bool MenuResponse(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length < 2)
            {
                throw new RunTimeError("Usage: menuresponse (index) (menuId) [hue]");
            }

            ushort index = vars[0].AsUShort();
            ushort menuId = vars[1].AsUShort();
            ushort hue = 0;

            if (vars.Length == 3)
                hue = vars[2].AsUShort();

            Client.Instance.SendToServer(new MenuResponse(World.Player.CurrentMenuS, World.Player.CurrentMenuI, index,
                menuId, hue));
            World.Player.HasMenu = false;
            return true;
        }

        private static bool PromptResponse(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length < 1)
            {
                throw new RunTimeError("Usage: promptresponse ('response to the prompt')");
            }

            World.Player.ResponsePrompt(vars[0].AsString());
            return true;
        }

        private static bool LastTarget(string command, Variable[] vars, bool quiet, bool force)
        {
            if (!Targeting.DoLastTarget())
                Targeting.ResendTarget();

            return true;
        }

        private static bool PlayScript(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length < 1)
            {
                throw new RunTimeError("Usage: script 'name of script'");
            }

            ScriptManager.PlayScript(vars[0].AsString());

            return true;
        }

        private static readonly Dictionary<string, ushort> PotionList = new Dictionary<string, ushort>()
        {
            {"heal", 3852},
            {"cure", 3847},
            {"refresh", 3851},
            {"nightsight", 3846},
            {"ns", 3846},
            {"explosion", 3853},
            {"strength", 3849},
            {"str", 3849},
            {"agility", 3848}
        };

        private static bool Potion(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length == 0)
            {
                throw new RunTimeError("Usage: potion ('type')");
            }

            Item pack = World.Player.Backpack;
            if (pack == null)
                return true;

            if (PotionList.TryGetValue(vars[0].AsString().ToLower(), out ushort potionId))
            {
                if (potionId == 3852 && World.Player.Poisoned && Config.GetBool("BlockHealPoison") &&
                    Client.Instance.AllowBit(FeatureBit.BlockHealPoisoned))
                {
                    World.Player.SendMessage(MsgLevel.Force, LocString.HealPoisonBlocked);
                    return true;
                }

                if (!World.Player.UseItem(pack, potionId))
                {
                    CommandHelper.SendWarning(command, Language.Format(LocString.NoItemOfType, (ItemID)potionId), quiet);
                }
            }
            else
            {
                throw new RunTimeError($"{command} - Unknown potion type");
            }

            return true;
        }

        private static bool WaitForSysMsg(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length < 1)
            {
                throw new RunTimeError("Usage: waitforsysmsg 'message to wait for' [timeout]");
            }
            
            if (SystemMessages.Exists(vars[0].AsString()))
            {
                Interpreter.ClearTimeout();
                return true;
            }

            Interpreter.Timeout(vars.Length > 1 ? vars[1].AsUInt() : 30000, () => { return true; });

            return false;
        }

        private static bool Random(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length < 1)
            {
                throw new RunTimeError("Usage: random 'max value'");
            }

            int max = vars[0].AsInt();

            World.Player.SendMessage(MsgLevel.Info, $"Random: {Utility.Random(1, max)}");

            return true;
        }

        private static bool ClearDragDrop(string command, Variable[] vars, bool quiet, bool force)
        {
            DragDropManager.GracefulStop();

            return true;
        }
        
        private static bool Interrupt(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length == 1)
            {
                Layer layer = (Layer) Enum.Parse(typeof(Layer), vars[0].AsString(), true);

                if (layer > Layer.Invalid && layer <= Layer.LastUserValid)
                {
                    Spell.Interrupt(layer);
                }
                else
                {
                    throw new RunTimeError($"{command} - Invalid layer");
                }
            }
            else
            {
                Spell.Interrupt();    
            }

            return true;
        }
    }
}

================================================
FILE: Razor/Scripts/Engine/Interpreter.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.Globalization;

namespace Assistant.Scripts.Engine
{
    public class RunTimeError : Exception
    {
        public RunTimeError(string error) : base(error)
        {
        }
    }

    internal static class TypeConverter
    {
        public static int ToInt(string token)
        {
            int val;

            if (token.StartsWith("0x"))
            {
                if (int.TryParse(token.Substring(2), NumberStyles.HexNumber, Interpreter.Culture, out val))
                    return val;
            }
            else if (int.TryParse(token, out val))
                return val;

            throw new RunTimeError("Cannot convert argument to int");
        }

        public static uint ToUInt(string token)
        {
            uint val;

            if (token.StartsWith("0x"))
            {
                if (uint.TryParse(token.Substring(2), NumberStyles.HexNumber, Interpreter.Culture, out val))
                    return val;
            }
            else if (uint.TryParse(token, out val))
                return val;

            throw new RunTimeError("Cannot convert argument to uint");
        }

        public static ushort ToUShort(string token)
        {
            ushort val;

            if (token.StartsWith("0x"))
            {
                if (ushort.TryParse(token.Substring(2), NumberStyles.HexNumber, Interpreter.Culture, out val))
                    return val;
            }
            else if (ushort.TryParse(token, out val))
                return val;

            throw new RunTimeError("Cannot convert argument to ushort");
        }

        public static double ToDouble(string token)
        {
            double val;

            if (double.TryParse(token, out val))
                return val;

            throw new RunTimeError("Cannot convert argument to double");
        }

        public static bool ToBool(string token)
        {
            bool val;

            if (bool.TryParse(token, out val))
                return val;

            throw new RunTimeError("Cannot convert argument to bool");
        }
    }

    internal class Scope
    {
        private Dictionary<string, Variable> _namespace = new Dictionary<string, Variable>();
        private readonly HashSet<Serial> _ignoreList = new HashSet<Serial>();

        public readonly ASTNode StartNode;
        public readonly Scope Parent;

        public Scope(Scope parent, ASTNode start)
        {
            Parent = parent;
            StartNode = start;
        }

        public Variable GetVariable(string name)
        {
            Variable arg;

            if (_namespace.TryGetValue(name, out arg))
                return arg;

            return null;
        }

        public void SetVariable(string name, Variable val)
        {
            _namespace[name] = val;
        }

        public void ClearVariable(string name)
        {
            _namespace.Remove(name);
        }

        public bool ExistVariable(string name)
        {
            return _namespace.ContainsKey(name);
        }

        public void AddIgnore(Serial serial)
        {
            _ignoreList.Add(serial);
        }

        public void AddIgnoreRange(List<Serial> serials)
        {
            serials.ForEach(AddIgnore);
        }
        public void RemoveIgnore(Serial serial)
        {
            if (_ignoreList.Contains(serial))
                _ignoreList.Remove(serial);
        }

        public void RemoveIgnoreRange(List<Serial> serials)
        {
            _ignoreList.RemoveWhere(serials.Contains);
        }

        public void ClearIgnore()
        {
            _ignoreList.Clear();
        }

        public bool CheckIgnored(Serial serial)
        {
            return _ignoreList.Contains(serial);
        }

    }

    public class Variable
    {
        private string _value;

        public Variable(string value)
        {
            _value = value;
        }

        // Treat the argument as an integer
        public int AsInt()
        {
            if (_value == null)
                throw new RunTimeError("Cannot convert argument to int");

            // Try to resolve it as a scoped variable first
            var arg = Interpreter.GetVariable(_value);
            if (arg != null)
                return arg.AsInt();

            return TypeConverter.ToInt(_value);
        }

        // Treat the argument as an unsigned integer
        public uint AsUInt()
        {
            if (_value == null)
                throw new RunTimeError("Cannot convert argument to uint");

            // Try to resolve it as a scoped variable first
            var arg = Interpreter.GetVariable(_value);
            if (arg != null)
                return arg.AsUInt();

            return TypeConverter.ToUInt(_value);
        }

        public ushort AsUShort()
        {
            if (_value == null)
                throw new RunTimeError("Cannot convert argument to ushort");

            // Try to resolve it as a scoped variable first
            var arg = Interpreter.GetVariable(_value);
            if (arg != null)
                return arg.AsUShort();

            return TypeConverter.ToUShort(_value);
        }

        // Treat the argument as a serial or an alias. Aliases will
        // be automatically resolved to serial numbers.
        public uint AsSerial()
        {
            if (_value == null)
                throw new RunTimeError("Cannot convert argument to serial");

            // Try to resolve it as a scoped variable first
            var arg = Interpreter.GetVariable(_value);
            if (arg != null)
                return arg.AsSerial();

            // Resolve it as a global alias next
            uint serial = Interpreter.GetAlias(_value);
            if (serial != uint.MaxValue)
                return serial;

            try
            {
                return AsUInt();
            }
            catch (RunTimeError)
            { }

            return Serial.MinusOne;
        }

        // Treat the argument as a string
        public string AsString(bool resolve = true)
        {
            if (_value == null)
                throw new RunTimeError("Cannot convert argument to string");

            if (resolve)
            {
                // Try to resolve it as a scoped variable first
                var arg = Interpreter.GetVariable(_value);
                if (arg != null)
                    return arg.AsString();
            }

            return _value;
        }

        public bool AsBool()
        {
            if (_value == null)
                throw new RunTimeError("Cannot convert argument to bool");

            return TypeConverter.ToBool(_value);
        }

        public override bool Equals(object obj)
        {
            if (obj == null)
                return false;

            Variable arg = obj as Variable;

            if (arg == null)
                return false;

            return Equals(arg);
        }

        public bool Equals(Variable other)
        {
            if (other == null)
                return false;

            return (other._value == _value);
        }
    }

    public class Script
    {
        private ASTNode _statement;

        public int CurrentLine
        {
            get
            {
                return _statement == null ? 0 : _statement.LineNumber;
            }
        }

        private Variable[] ConstructArguments(ref ASTNode node)
        {
            List<Variable> args = new List<Variable>();

            node = node.Next();

            while (node != null)
            {
                switch (node.Type)
                {
                    case ASTNodeType.AND:
                    case ASTNodeType.OR:
                    case ASTNodeType.EQUAL:
                    case ASTNodeType.NOT_EQUAL:
                    case ASTNodeType.LESS_THAN:
                    case ASTNodeType.LESS_THAN_OR_EQUAL:
                    case ASTNodeType.GREATER_THAN:
                    case ASTNodeType.GREATER_THAN_OR_EQUAL:
                    case ASTNodeType.IN:
                    case ASTNodeType.AS:
                        return args.ToArray();
                }

                args.Add(new Variable(node.Lexeme));

                node = node.Next();
            }

            return args.ToArray();
        }

        // For now, the scripts execute directly from the
        // abstract syntax tree. This is relatively simple.
        // A more robust approach would be to "compile" the
        // scripts to a bytecode. That would allow more errors
        // to be caught with better error messages, as well as
        // make the scripts execute more quickly.
        public Script(ASTNode root)
        {
            // Set current to the first statement
            _statement = root.FirstChild();
        }

        public void Initialize()
        {
            Interpreter.PushScope(_statement);
        }

        public bool ExecuteNext()
        {
            if (_statement == null)
                return false;

            if (_statement.Type != ASTNodeType.STATEMENT)
                throw new RunTimeError("Invalid script");

            var node = _statement.FirstChild();

            if (node == null)
                throw new RunTimeError("Invalid statement");

            int depth = 0;

            switch (node.Type)
            {
                case ASTNodeType.IF:
                    {
                        Interpreter.PushScope(node);

                        var expr = node.FirstChild();
                        var result = EvaluateExpression(ref expr);

                        // Advance to next statement
                        Advance();

                        // Evaluated true. Jump right into execution.
                        if (result)
                            break;

                        // The expression evaluated false, so keep advancing until
                        // we hit an elseif, else, or endif statement that matches
                        // and try again.
                        depth = 0;

                        while (_statement != null)
                        {
                            node = _statement.FirstChild();

                            if (node.Type == ASTNodeType.IF)
                            {
                                depth++;
                            }
                            else if (node.Type == ASTNodeType.ELSEIF)
                            {
                                if (depth == 0)
                                {
                                    expr = node.FirstChild();
                                    result = EvaluateExpression(ref expr);

                                    // Evaluated true. Jump right into execution
                                    if (result)
                                    {
                                        Advance();
                                        break;
                                    }
                                }
                            }
                            else if (node.Type == ASTNodeType.ELSE)
                            {
                                if (depth == 0)
                                {
                                    // Jump into the else clause
                                    Advance();
                                    break;
                                }
                            }
                            else if (node.Type == ASTNodeType.ENDIF)
                            {
                                if (depth == 0)
                                    break;

                                depth--;
                            }

                            Advance();
                        }

                        if (_statement == null)
                            throw new RunTimeError("If with no matching endif");

                        break;
                    }
                case ASTNodeType.ELSEIF:
                    // If we hit the elseif statement during normal advancing, skip over it. The only way
                    // to execute an elseif clause is to jump directly in from an if statement.
                    depth = 0;

                    while (_statement != null)
                    {
                        node = _statement.FirstChild();

                        if (node.Type == ASTNodeType.IF)
                        {
                            depth++;
                        }
                        else if (node.Type == ASTNodeType.ENDIF)
                        {
                            if (depth == 0)
                                break;

                            depth--;
                        }

                        Advance();
                    }

                    if (_statement == null)
                        throw new RunTimeError("If with no matching endif");

                    break;
                case ASTNodeType.ENDIF:
                    Interpreter.PopScope();
                    Advance();
                    break;
                case ASTNodeType.ELSE:
                    // If we hit the else statement during normal advancing, skip over it. The only way
                    // to execute an else clause is to jump directly in from an if statement.
                    depth = 0;

                    while (_statement != null)
                    {
                        node = _statement.FirstChild();

                        if (node.Type == ASTNodeType.IF)
                        {
                            depth++;
                        }
                        else if (node.Type == ASTNodeType.ENDIF)
                        {
                            if (depth == 0)
                                break;

                            depth--;
                        }

                        Advance();
                    }

                    if (_statement == null)
                        throw new RunTimeError("If with no matching endif");

                    break;
                case ASTNodeType.WHILE:
                    {
                        // The iterator variable's name is the hash code of the for loop's ASTNode.
                        var iterName = node.GetHashCode().ToString();

                        // When we first enter the loop, push a new scope
                        if (Interpreter.CurrentScope.StartNode != node)
                        {
                            Interpreter.PushScope(node);
                            Interpreter.SetVariable(iterName, "0");
                            Interpreter.SetVariable("index", "0");
                        }
                        else
                        {
                            // Increment the iterator argument
                            var arg = Interpreter.GetVariable(iterName);
                            var index = arg.AsUInt() + 1;
                            Interpreter.SetVariable(iterName, index.ToString());
                            Interpreter.SetVariable("index", index.ToString());
                        }

                        var expr = node.FirstChild();
                        var result = EvaluateExpression(ref expr);

                        // Advance to next statement
                        Advance();

                        // The expression evaluated false, so keep advancing until
                        // we hit an endwhile statement.
                        if (!result)
                        {
                            depth = 0;

                            while (_statement != null)
                            {
                                node = _statement.FirstChild();

                                if (node.Type == ASTNodeType.WHILE)
                                {
                                    depth++;
                                }
                                else if (node.Type == ASTNodeType.ENDWHILE)
                                {
                                    if (depth == 0)
                                    {
                                        Interpreter.PopScope();
                                        // Go one past the endwhile so the loop doesn't repeat
                                        Advance();
                                        break;
                                    }

                                    depth--;
                                }

                                Advance();
                            }
                        }
                        break;
                    }
                case ASTNodeType.ENDWHILE:
                    // Walk backward to the while statement
                    _statement = _statement.Prev();

                    depth = 0;

                    while (_statement != null)
                    {
                        node = _statement.FirstChild();

                        if (node.Type == ASTNodeType.ENDWHILE)
                        {
                            depth++;
                        }
                        else if (node.Type == ASTNodeType.WHILE)
                        {
                            if (depth == 0)
                                break;

                            depth--;
                        }

                        _statement = _statement.Prev();
                    }

                    if (_statement == null)
                        throw new RunTimeError("Unexpected endwhile");

                    break;
                case ASTNodeType.FOR:
                    {
                        // The iterator variable's name is the hash code of the for loop's ASTNode.
                        var iterName = node.GetHashCode().ToString();

                        // When we first enter the loop, push a new scope
                        if (Interpreter.CurrentScope.StartNode != node)
                        {
                            Interpreter.PushScope(node);

                            // Grab the arguments
                            var max = node.FirstChild();

                            if (max.Type != ASTNodeType.INTEGER)
                                throw new RunTimeError("Invalid for loop syntax");

                            // Create a dummy argument that acts as our loop variable
                            Interpreter.SetVariable(iterName, "0");
                            Interpreter.SetVariable("index", "0");
                        }
                        else
                        {
                            // Increment the iterator argument
                            var arg = Interpreter.GetVariable(iterName);
                            var index = arg.AsUInt() + 1;
                            Interpreter.SetVariable(iterName, index.ToString());
                            Interpreter.SetVariable("index", index.ToString());
                        }

                        // Check loop condition
                        var i = Interpreter.GetVariable(iterName);

                        // Grab the max value to iterate to
                        node = node.FirstChild();
                        var end = new Variable(node.Lexeme);

                        if (i.AsUInt() < end.AsUInt())
                        {
                            // enter the loop
                            Advance();
                        }
                        else
                        {
                            // Walk until the end of the loop
                            Advance();

                            depth = 0;

                            while (_statement != null)
                            {
                                node = _statement.FirstChild();

                                if (node.Type == ASTNodeType.FOR || node.Type == ASTNodeType.FOREACH)
                                {
                                    depth++;
                                }
                                else if (node.Type == ASTNodeType.ENDFOR)
                                {
                                    if (depth == 0)
                                    {
                                        Interpreter.PopScope();
                                        // Go one past the end so the loop doesn't repeat
                                        Advance();
                                        break;
                                    }

                                    depth--;
                                }

                                Advance();
                            }
                        }
                    }
                    break;
                case ASTNodeType.FOREACH:
                    {
                        // foreach VAR in LIST
                        // The iterator's name is the hash code of the for loop's ASTNode.
                        var varName = node.FirstChild().Lexeme;
                        var listName = node.FirstChild().Next().Lexeme;
                        var iterName = node.GetHashCode().ToString();

                        // When we first enter the loop, push a new scope
                        if (Interpreter.CurrentScope.StartNode != node)
                        {
                            Interpreter.PushScope(node);

                            // Create a dummy argument that acts as our iterator object
                            Interpreter.SetVariable(iterName, "0");
                            Interpreter.SetVariable("index", "0");

                            // Make the user-chosen variable have the value for the front of the list
                            var arg = Interpreter.GetListValue(listName, 0);

                            if (arg != null)
                                Interpreter.SetVariable(varName, arg.AsString());
                            else
                                Interpreter.ClearVariable(varName);
                        }
                        else
                        {
                            // Increment the iterator argument
                            var idx = Interpreter.GetVariable(iterName).AsInt() + 1;
                            Interpreter.SetVariable(iterName, idx.ToString()); ;
                            Interpreter.SetVariable("index", idx.ToString());

                            // Update the user-chosen variable
                            var arg = Interpreter.GetListValue(listName, idx);

                            if (arg != null)
                                Interpreter.SetVariable(varName, arg.AsString());
                            else
                                Interpreter.ClearVariable(varName);
                        }

                        // Check loop condition
                        var i = Interpreter.GetVariable(varName);

                        if (i != null)
                        {
                            // enter the loop
                            Advance();
                        }
                        else
                        {
                            // Walk until the end of the loop
                            Advance();

                            depth = 0;

                            while (_statement != null)
                            {
                                node = _statement.FirstChild();

                                if (node.Type == ASTNodeType.FOR ||
                                    node.Type == ASTNodeType.FOREACH)
                                {
                                    depth++;
                                }
                                else if (node.Type == ASTNodeType.ENDFOR)
                                {
                                    if (depth == 0)
                                    {
                                        Interpreter.PopScope();
                                        // Go one past the end so the loop doesn't repeat
                                        Advance();
                                        break;
                                    }

                                    depth--;
                                }

                                Advance();
                            }
                        }
                        break;
                    }
                case ASTNodeType.ENDFOR:
                    // Walk backward to the for statement
                    _statement = _statement.Prev();

                    // track depth in case there is a nested for
                    depth = 0;

                    while (_statement != null)
                    {
                        node = _statement.FirstChild();

                        if (node.Type == ASTNodeType.ENDFOR)
                        {
                            depth++;
                        }
                        else if (node.Type == ASTNodeType.FOR ||
                                 node.Type == ASTNodeType.FOREACH)
                        {
                            if (depth == 0)
                            {
                                break;
                            }
                            depth--;
                        }

                        _statement = _statement.Prev();
                    }

                    if (_statement == null)
                        throw new RunTimeError("Unexpected endfor");

                    break;
                case ASTNodeType.BREAK:
                    // Walk until the end of the loop
                    Advance();

                    depth = 0;

                    while (_statement != null)
                    {
                        node = _statement.FirstChild();

                        if (node.Type == ASTNodeType.WHILE ||
                            node.Type == ASTNodeType.FOR ||
                            node.Type == ASTNodeType.FOREACH)
                        {
                            depth++;
                        }
                        else if (node.Type == ASTNodeType.ENDWHILE ||
                            node.Type == ASTNodeType.ENDFOR)
                        {
                            if (depth == 0)
                            {
                                // Go one past the end so the loop doesn't repeat
                                Advance();
                                break;
                            }

                            depth--;
                        }

                        Advance();
                    }

                    Interpreter.PopScope();
                    break;
                case ASTNodeType.CONTINUE:
                    // Walk backward to the loop statement
                    _statement = _statement.Prev();

                    depth = 0;

                    while (_statement != null)
                    {
                        node = _statement.FirstChild();

                        if (node.Type == ASTNodeType.ENDWHILE ||
                            node.Type == ASTNodeType.ENDFOR)
                        {
                            depth++;
                        }
                        else if (node.Type == ASTNodeType.WHILE ||
                                 node.Type == ASTNodeType.FOR ||
                                 node.Type == ASTNodeType.FOREACH)
                        {
                            if (depth == 0)
                                break;

                            depth--;
                        }

                        _statement = _statement.Prev();
                    }

                    if (_statement == null)
                        throw new RunTimeError("Unexpected continue");
                    break;
                case ASTNodeType.STOP:
                    _statement = null;
                    break;
                case ASTNodeType.REPLAY:
                    _statement = _statement.Parent.FirstChild();
                    break;
                case ASTNodeType.QUIET:
                case ASTNodeType.FORCE:
                case ASTNodeType.COMMAND:
                    if (ExecuteCommand(node))
                        Advance();

                    break;
            }

            return (_statement != null) ? true : false;
        }

        public void Advance()
        {
            Interpreter.ClearTimeout();
            _statement = _statement.Next();
        }

        private ASTNode EvaluateModifiers(ASTNode node, out bool quiet, out bool force, out bool not)
        {
            quiet = false;
            force = false;
            not = false;

            while (true)
            {
                switch (node.Type)
                {
                    case ASTNodeType.QUIET:
                        quiet = true;
                        break;
                    case ASTNodeType.FORCE:
                        force = true;
                        break;
                    case ASTNodeType.NOT:
                        not = true;
                        break;
                    default:
                        return node;
                }

                node = node.Next();
            }
        }

        private bool ExecuteCommand(ASTNode node)
        {
            node = EvaluateModifiers(node, out bool quiet, out bool force, out _);

            var handler = Interpreter.GetCommandHandler(node.Lexeme);

            if (handler == null)
                throw new RunTimeError("Unknown command");

            var cont = handler(node.Lexeme, ConstructArguments(ref node), quiet, force);

            if (node != null)
                throw new RunTimeError("Command did not consume all available arguments");

            return cont;
        }

        private bool EvaluateExpression(ref ASTNode expr)
        {
            if (expr == null || (expr.Type != ASTNodeType.UNARY_EXPRESSION && expr.Type != ASTNodeType.BINARY_EXPRESSION && expr.Type != ASTNodeType.LOGICAL_EXPRESSION))
                throw new RunTimeError("No expression following control statement");

            var node = expr.FirstChild();

            if (node == null)
                throw new RunTimeError("Empty expression following control statement");

            switch (expr.Type)
            {
                case ASTNodeType.UNARY_EXPRESSION:
                    return EvaluateUnaryExpression(ref node);
                case ASTNodeType.BINARY_EXPRESSION:
                    return EvaluateBinaryExpression(ref node);
            }

            bool lhs = EvaluateExpression(ref node);

            node = node.Next();

            while (node != null)
            {
                // Capture the operator
                var op = node.Type;
                node = node.Next();

                if (node == null)
                    throw new RunTimeError("Invalid logical expression");

                bool rhs;

                var e = node.FirstChild();

                switch (node.Type)
                {
                    case ASTNodeType.UNARY_EXPRESSION:
                        rhs = EvaluateUnaryExpression(ref e);
                        break;
                    case ASTNodeType.BINARY_EXPRESSION:
                        rhs = EvaluateBinaryExpression(ref e);
                        break;
                    default:
                        throw new RunTimeError("Nested logical expressions are not possible");
                }

                switch (op)
                {
                    case ASTNodeType.AND:
                        lhs = lhs && rhs;
                        break;
                    case ASTNodeType.OR:
                        lhs = lhs || rhs;
                        break;
                    default:
                        throw new RunTimeError("Invalid logical operator");
                }

                node = node.Next();
            }

            return lhs;
        }

        private bool CompareOperands(ASTNodeType op, IComparable lhs, IComparable rhs)
        {
            if (op == ASTNodeType.IN)
            {
                if (lhs.GetType() != typeof(string) || rhs.GetType() != typeof(string))
                {
                    throw new RunTimeError("The 'in' operator only works on string operands.");
                }
            }
            else if (op == ASTNodeType.AS)
            {
                if (lhs.GetType() != typeof(uint))
                {
                    throw new RunTimeError("The left hand side of an 'as' expression must evaluate to a serial");
                }

                if (rhs.GetType() != typeof(string))
                {
                    throw new RunTimeError("The right hand side of an 'as' expression must evaluate to a string");
                }
            }
            else if (lhs.GetType() != rhs.GetType())
            {
                // Different types. Try to convert one to match the other.

                if (rhs is double)
                {
                    // Special case for rhs doubles because we don't want to lose precision.
                    lhs = (double)lhs;
                }
                else if (rhs is bool)
                {
                    // Special case for rhs bools because we want to down-convert the lhs.
                    var tmp = Convert.ChangeType(lhs, typeof(bool));
                    lhs = (IComparable)tmp;
                }
                else
                {
                    var tmp = Convert.ChangeType(rhs, lhs.GetType());
                    rhs = (IComparable)tmp;
                }
            }

            try
            {
                // Evaluate the whole expression
                switch (op)
                {
                    case ASTNodeType.EQUAL:
                        return lhs.CompareTo(rhs) == 0;
                    case ASTNodeType.NOT_EQUAL:
                        return lhs.CompareTo(rhs) != 0;
                    case ASTNodeType.LESS_THAN:
                        return lhs.CompareTo(rhs) < 0;
                    case ASTNodeType.LESS_THAN_OR_EQUAL:
                        return lhs.CompareTo(rhs) <= 0;
                    case ASTNodeType.GREATER_THAN:
                        return lhs.CompareTo(rhs) > 0;
                    case ASTNodeType.GREATER_THAN_OR_EQUAL:
                        return lhs.CompareTo(rhs) >= 0;
                    case ASTNodeType.IN:
                        return ((string)rhs).Contains((string)lhs);
                    case ASTNodeType.AS:

                        if ((uint) lhs > 0)
                        {
                            Interpreter.SetVariable(rhs.ToString(), lhs.ToString());
                        }

                        return CompareOperands(ASTNodeType.EQUAL, lhs, true);
                }
            }
            catch (ArgumentException e)
            {
                throw new RunTimeError(e.Message);
            }

            throw new RunTimeError("Unknown operator in expression");

        }

        private bool EvaluateUnaryExpression(ref ASTNode node)
        {
            node = EvaluateModifiers(node, out bool quiet, out bool force, out bool not);

            var handler = Interpreter.GetExpressionHandler(node.Lexeme);

            if (handler == null)
                throw new RunTimeError("Unknown expression");

            var result = handler(node.Lexeme, ConstructArguments(ref node), quiet, force);

            if (not)
                return CompareOperands(ASTNodeType.EQUAL, result, false);
            else
                return CompareOperands(ASTNodeType.EQUAL, result, true);
        }

        private bool EvaluateBinaryExpression(ref ASTNode node)
        {
            // Evaluate the left hand side
            var lhs = EvaluateBinaryOperand(ref node);

            // Capture the operator
            var op = node.Type;
            node = node.Next();

            // Evaluate the right hand side
            var rhs = EvaluateBinaryOperand(ref node);

            return CompareOperands(op, lhs, rhs);
        }

        private IComparable EvaluateBinaryOperand(ref ASTNode node)
        {
            IComparable val;

            node = EvaluateModifiers(node, out bool quiet, out bool force, out _);
            switch (node.Type)
            {
                case ASTNodeType.INTEGER:
                    val = TypeConverter.ToInt(node.Lexeme);
                    node = node.Next();
                    break;
                case ASTNodeType.SERIAL:
                    val = TypeConverter.ToUInt(node.Lexeme);
                    node = node.Next();
                    break;
                case ASTNodeType.STRING:
                    val = node.Lexeme;
                    node = node.Next();
                    break;
                case ASTNodeType.DOUBLE:
                    val = TypeConverter.ToDouble(node.Lexeme);
                    node = node.Next();
                    break;
                case ASTNodeType.OPERAND:
                    {
                        // This might be a registered keyword, so do a lookup
                        var handler = Interpreter.GetExpressionHandler(node.Lexeme);

                        if (handler != null)
                        {
                            val = handler(node.Lexeme, ConstructArguments(ref node), quiet, force);
                            break;
                        }

                        // It could be a variable
                        var arg = Interpreter.GetVariable(node.Lexeme);
                        if (arg != null)
                        {
                            // TODO: Should really look at the type of arg here
                            val = arg.AsString();
                            node = node.Next();
                            break;
                        }

                        // It's just a string
                        val = node.Lexeme;
                        node = node.Next();
                        break;
                    }
                default:
                    throw new RunTimeError("Invalid type found in expression");
            }

            return val;
        }
    }

    public static class Interpreter
    {
        public static Action OnStop;

        // The "global" scope
        private readonly static Scope _scope = new Scope(null, null);

        // The current scope
        private static Scope _currentScope = _scope;
        
        // Lists
        private static Dictionary<string, List<Variable>> _lists = new Dictionary<string, List<Variable>>();

        // Timers
        private static Dictionary<string, DateTime> _timers = new Dictionary<string, DateTime>();

        // Expressions
        public delegate IComparable ExpressionHandler(string expression, Variable[] args, bool quiet, bool force);
        public delegate T ExpressionHandler<T>(string expression, Variable[] args, bool quiet, bool force) where T : IComparable;

        private static Dictionary<string, ExpressionHandler> _exprHandlers = new Dictionary<string, ExpressionHandler>();

        public delegate bool CommandHandler(string command, Variable[] args, bool quiet, bool force);

        private static Dictionary<string, CommandHandler> _commandHandlers = new Dictionary<string, CommandHandler>();

        public delegate uint AliasHandler(string alias);

        private static Dictionary<string, AliasHandler> _aliasHandlers = new Dictionary<string, AliasHandler>();

        private static Script _activeScript = null;

        public static int CurrentLine
        {
            get
            {
                return _activeScript == null ? 0 : _activeScript.CurrentLine;
            }
        }

        private enum ExecutionState
        {
            RUNNING,
            PAUSED,
            TIMING_OUT
        };

        public delegate bool TimeoutCallback();

        private static ExecutionState _executionState = ExecutionState.RUNNING;
        private static long _pauseTimeout = long.MaxValue;
        private static TimeoutCallback _timeoutCallback = null;

        internal static CultureInfo Culture;

        static Interpreter()
        {
            Culture = new CultureInfo(CultureInfo.CurrentCulture.LCID, false);
            Culture.NumberFormat.NumberDecimalSeparator = ".";
            Culture.NumberFormat.NumberGroupSeparator = ",";
        }

        public static void RegisterExpressionHandler<T>(string keyword, ExpressionHandler<T> handler) where T : IComparable
        {
            _exprHandlers[keyword] = (expression, args, quiet, force) => handler(expression, args, quiet, force);
        }

        public static ExpressionHandler GetExpressionHandler(string keyword)
        {
            _exprHandlers.TryGetValue(keyword, out var expression);

            return expression;
        }

        public static void RegisterCommandHandler(string keyword, CommandHandler handler)
        {
            _commandHandlers[keyword] = handler;
        }

        public static CommandHandler GetCommandHandler(string keyword)
        {
            _commandHandlers.TryGetValue(keyword, out CommandHandler handler);

            return handler;
        }

        public static void RegisterAliasHandler(string keyword, AliasHandler handler)
        {
            _aliasHandlers[keyword] = handler;
        }

        public static void UnregisterAliasHandler(string keyword)
        {
            _aliasHandlers.Remove(keyword);
        }
        
        public static bool AliasHandlerExist(string alias)
        {
            return _aliasHandlers.TryGetValue(alias, out _);
        }

        public static void PushScope(ASTNode node)
        {
            _currentScope = new Scope(_currentScope, node);
        }

        public static void PopScope()
        {
            if (_currentScope == _scope)
                throw new RunTimeError("Attempted to remove global scope");

            _currentScope = _currentScope.Parent;
        }

        internal static Scope CurrentScope => _currentScope;

        public static void SetVariable(string name, string value, bool global = false)
        {
            Scope scope = global ? _scope : _currentScope;

            scope.SetVariable(name, new Variable(value));
        }

        public static void AddIgnore(Serial serial, bool global = true)
        {
            Scope scope = global ? _scope : _currentScope;
            scope.AddIgnore(serial);
        }

        public static void ClearIgnore(bool global = true)
        {
            Scope scope = global ? _scope : _currentScope;
            scope.ClearIgnore();
        }
        
        public static void AddIgnoreRange(List<Serial> serials, bool global = true)
        {
            Scope scope = global ? _scope : _currentScope;
            scope.AddIgnoreRange(serials);
        }

        public static void RemoveIgnore(Serial serial, bool global = true)
        {
            Scope scope = global ? _scope : _currentScope;
            scope.RemoveIgnore(serial);
        }

        public static void RemoveIgnoreRange(List<Serial> serials, bool global = true)
        {
            Scope scope = global ? _scope : _currentScope;
            scope.RemoveIgnoreRange(serials);
        }
        
        public static bool CheckIgnored(Serial serial, bool global = true)
        {
            Scope scope = global ? _scope : _currentScope;
            return scope.CheckIgnored(serial);
        }

        public static Variable GetVariable(string name)
        {
            var scope = _currentScope;
            Variable result = null;

            while (scope != null)
            {
                result = scope.GetVariable(name);
                if (result != null)
                    return result;

                scope = scope.Parent;
            }

            return result;
        }

        public static void ClearVariable(string name)
        {
            _currentScope.ClearVariable(name);
        }

        public static bool ExistVariable(string name)
        {
            return _currentScope.ExistVariable(name);
        }

        public static uint GetAlias(string alias)
        {
            // If a handler is explicitly registered, call that.
            if (_aliasHandlers.TryGetValue(alias, out AliasHandler handler))
                return handler(alias);

            var arg = GetVariable(alias);

            return arg?.AsUInt() ?? uint.MaxValue;
        }

        public static void SetAlias(string alias, uint serial)
        {
            SetVariable(alias, serial.ToString(), true);
        }

        public static void ClearAlias(string alias)
        {
            _scope.ClearVariable(alias);
        }

        public static bool ExistAlias(string alias)
        {
            return _scope.ExistVariable(alias);
        }
        
        public static void CreateList(string name)
        {
            if (_lists.ContainsKey(name))
                return;

            _lists[name] = new List<Variable>();
        }

        public static void DestroyList(string name)
        {
            _lists.Remove(name);
        }

        public static void ClearList(string name)
        {
            if (!_lists.ContainsKey(name))
                return;

            _lists[name].Clear();
        }

        public static bool ListExists(string name)
        {
            return _lists.ContainsKey(name);
        }

        public static List<Variable> GetList(string name)
        {
            return _lists.ContainsKey(name) ? _lists[name] : null;
        }
        public static bool ListContains(string name, Variable arg)
        {
            if (!_lists.ContainsKey(name))
                throw new RunTimeError("List does not exist");

            var list = _lists[name];
            var a = arg.AsString();

            foreach (var v in list)
            {
                if (v.AsString().Equals(a, StringComparison.OrdinalIgnoreCase))
                {
                    return true;
                }
            }

            return false;
        }

        public static int ListLength(string name)
        {
            if (!_lists.ContainsKey(name))
                throw new RunTimeError("List does not exist");

            return _lists[name].Count;
        }

        public static void PushList(string name, Variable arg, bool front, bool unique)
        {
            if (!_lists.ContainsKey(name))
                throw new RunTimeError("List does not exist");

            if (unique && _lists[name].Contains(arg))
                return;

            if (front)
                _lists[name].Insert(0, arg);
            else
                _lists[name].Add(arg);
        }

        public static bool PopList(string name, Variable arg)
        {
            if (!_lists.ContainsKey(name))
                throw new RunTimeError("List does not exist");

            return _lists[name].Remove(arg);
        }

        public static bool PopList(string name, bool front, out Variable removedVar)
        {
            if (!_lists.ContainsKey(name))
                throw new RunTimeError("List does not exist");

            var list = _lists[name];
            var idx = front ? 0 : _lists[name].Count - 1;

            removedVar = list[idx];
            list.RemoveAt(idx);

            return list.Count > 0;
        }

        public static Variable GetListValue(string name, int idx)
        {
            if (!_lists.ContainsKey(name))
                throw new RunTimeError("List does not exist");

            var list = _lists[name];

            if (idx < list.Count)
                return list[idx];

            return null;
        }

        public static void CreateTimer(string name)
        {
            _timers[name] = DateTime.UtcNow;
        }

        public static TimeSpan GetTimer(string name)
        {
            if (!_timers.TryGetValue(name, out DateTime timestamp))
                throw new RunTimeError("Timer does not exist");

            TimeSpan elapsed = DateTime.UtcNow - timestamp;

            return elapsed;
        }

        public static void SetTimer(string name, int elapsed)
        {
            // Setting a timer to start at a given value is equivalent to
            // starting the timer that number of milliseconds in the past.
            _timers[name] = DateTime.UtcNow.AddMilliseconds(-elapsed);
        }

        public static void RemoveTimer(string name)
        {
            _timers.Remove(name);
        }

        public static bool TimerExists(string name)
        {
            return _timers.ContainsKey(name);
        }

        public static bool StartScript(Script script)
        {
            if (_activeScript != null)
                return false;

            _currentScope = _scope;
            _activeScript = script;
            _activeScript.Initialize();
            _executionState = ExecutionState.RUNNING;

            ExecuteScript();

            return true;
        }

        public static void StopScript()
        {
            _activeScript = null;
            _currentScope = _scope;
            _executionState = ExecutionState.RUNNING;
            
            if (_timeoutCallback != null)
            {
                if (_timeoutCallback())
                {
                    ClearTimeout();
                }

                _timeoutCallback = null;
            }
            
            OnStop?.Invoke();
        }
        
        public static void PauseScript()
        {
            _pauseTimeout = DateTime.MaxValue.Ticks;
            _executionState = ExecutionState.PAUSED;
        }
        public static void ResumeScript()
        {
            _executionState = ExecutionState.RUNNING;
        }

        public static bool ExecuteScript()
        {
            if (_activeScript == null)
                return false;

            if (_executionState == ExecutionState.PAUSED)
            {
                if (_pauseTimeout < DateTime.UtcNow.Ticks)
                    _executionState = ExecutionState.RUNNING;
                else
                    return true;
            }
            else if (_executionState == ExecutionState.TIMING_OUT)
            {
                if (_pauseTimeout < DateTime.UtcNow.Ticks)
                {
                    if (_timeoutCallback != null)
                    {
                        if (_timeoutCallback())
                        {
                            _activeScript.Advance();
                            ClearTimeout();
                        }

                        _timeoutCallback = null;
                    }

                    /* If the callback changed the state to running, continue
                     * on. Otherwise, exit.
                     */
                    if (_executionState != ExecutionState.RUNNING)
                    {
                        _activeScript = null;
                        return false;
                    }
                }
            }

            if (!_activeScript.ExecuteNext())
            {
                _activeScript = null;
                return false;
            }

            return true;
        }

        // Pause execution for the given number of milliseconds
        public static void Pause(long duration)
        {
            // Already paused or timing out
            if (_executionState != ExecutionState.RUNNING)
                return;

            _pauseTimeout = DateTime.UtcNow.Ticks + (duration * 10000);
            _executionState = ExecutionState.PAUSED;
        }

        // Unpause execution
        public static void Unpause()
        {
            if (_executionState != ExecutionState.PAUSED)
                return;

            _pauseTimeout = 0;
            _executionState = ExecutionState.RUNNING;
        }

        // If forward progress on the script isn't made within this
        // amount of time (milliseconds), bail
        public static void Timeout(long duration, TimeoutCallback callback)
        {
            // Don't change an existing timeout
            if (_executionState != ExecutionState.RUNNING)
                return;

            _pauseTimeout = DateTime.UtcNow.Ticks + (duration * 10000);
            _executionState = ExecutionState.TIMING_OUT;
            _timeoutCallback = callback;
        }

        // Clears any previously set timeout. Automatically
        // called any time the script advances a statement.
        public static void ClearTimeout()
        {
            if (_executionState != ExecutionState.TIMING_OUT)
                return;

            _pauseTimeout = 0;
            _executionState = ExecutionState.RUNNING;
        }
    }
}

================================================
FILE: Razor/Scripts/Engine/Lexer.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

namespace Assistant.Scripts.Engine
{
    public class SyntaxError : Exception
    {
        public ASTNode Node;
        public string Line;
        public int LineNumber;

        public SyntaxError(ASTNode node, string error) : base(error)
        {
            Node = node;
            Line = null;
            LineNumber = 0;
        }

        public SyntaxError(string line, int lineNumber, ASTNode node, string error) : base(error)
        {
            Line = line;
            LineNumber = lineNumber;
            Node = node;
        }
    }

    public enum ASTNodeType
    {
        // Keywords
        IF,
        ELSEIF,
        ELSE,
        ENDIF,
        WHILE,
        ENDWHILE,
        FOR,
        FOREACH,
        ENDFOR,
        BREAK,
        CONTINUE,
        STOP,
        REPLAY,

        // Operators
        EQUAL,
        NOT_EQUAL,
        LESS_THAN,
        LESS_THAN_OR_EQUAL,
        GREATER_THAN,
        GREATER_THAN_OR_EQUAL,
        IN,
        AS,

        // Logical Operators
        NOT,
        AND,
        OR,

        // Value types
        STRING,
        SERIAL,
        INTEGER,
        DOUBLE,
        LIST,

        // Modifiers
        QUIET, // @ symbol
        FORCE, // ! symbol

        // Everything else
        SCRIPT,
        STATEMENT,
        COMMAND,
        OPERAND,
        LOGICAL_EXPRESSION,
        UNARY_EXPRESSION,
        BINARY_EXPRESSION,
    }

    // Abstract Syntax Tree Node
    public class ASTNode
    {
        public readonly ASTNodeType Type;
        public readonly string Lexeme;
        public readonly ASTNode Parent;
        public readonly int LineNumber;

        internal LinkedListNode<ASTNode> _node;
        private LinkedList<ASTNode> _children;

        public ASTNode(ASTNodeType type, string lexeme, ASTNode parent, int lineNumber)
        {
            Type = type;
            if (lexeme != null)
                Lexeme = lexeme;
            else
                Lexeme = "";
            Parent = parent;
            LineNumber = lineNumber;
        }

        public ASTNode Push(ASTNodeType type, string lexeme, int lineNumber)
        {
            var node = new ASTNode(type, lexeme, this, lineNumber);

            if (_children == null)
                _children = new LinkedList<ASTNode>();

            node._node = _children.AddLast(node);

            return node;
        }

        public ASTNode FirstChild()
        {
            if (_children == null || _children.First == null)
                return null;

            return _children.First.Value;
        }

        public ASTNode Next()
        {
            if (_node == null || _node.Next == null)
                return null;

            return _node.Next.Value;
        }

        public ASTNode Prev()
        {
            if (_node == null || _node.Previous == null)
                return null;

            return _node.Previous.Value;
        }
    }

    public static class Lexer
    {
        private static int _curLine = 0;
        
        public static bool AllowLoop { get; set; } = true;

        public static T[] Slice<T>(this T[] src, int start, int end)
        {
            if (end < start)
                return new T[0];

            int len = end - start + 1;

            T[] slice = new T[len];
            for (int i = 0; i < len; i++)
            {
                slice[i] = src[i + start];
            }

            return slice;
        }

        public static ASTNode Lex(string[] lines)
        {
            ASTNode node = new ASTNode(ASTNodeType.SCRIPT, null, null, 0);

            try
            {
                for (_curLine = 0; _curLine < lines.Length; _curLine++)
                {
                    foreach (var l in lines[_curLine].Split(';'))
                    {
                        ParseLine(node, l);
                    }
                }
            }
            catch (SyntaxError e)
            {
                throw new SyntaxError(lines[_curLine], _curLine, e.Node, e.Message);
            }
            catch (Exception e)
            {
                throw new SyntaxError(lines[_curLine], _curLine, null, e.Message);
            }

            return node;
        }

        public static ASTNode Lex(string fname)
        {
            ASTNode node = new ASTNode(ASTNodeType.SCRIPT, null, null, 0);

            using (var file = new StreamReader(fname))
            {
                _curLine = 0;
                string line = null;

                try
                {
                    while (true)
                    {
                        // Each line in the file is a statement. Statements starting
                        // with a control flow keyword contain an expression.

                        line = file.ReadLine();

                        // End of file
                        if (line == null)
                            break;

                        foreach (var l in line.Split(';'))
                            ParseLine(node, line);

                        _curLine++;
                    }
                }
                catch (SyntaxError e)
                {
                    throw new SyntaxError(line, _curLine, e.Node, e.Message);
                }
                catch (Exception e)
                {
                    throw new SyntaxError(line, _curLine, null, e.Message);
                }
            }

            return node;
        }

        private static TextParser _tfp = new TextParser("", new char[] { ' ' }, new char[] { }, new char[] { '\'', '\'', '"', '"' });
        private static void ParseLine(ASTNode node, string line)
        {
            line = line.Trim();

            if (line.StartsWith("//") || line.StartsWith("#"))
                return;

            // Split the line by spaces (unless the space is in quotes)
            var lexemes = _tfp.GetTokens(line, false);

            if (lexemes.Length == 0)
                return;

            ParseStatement(node, lexemes);
        }

        private static void ParseValue(ASTNode node, string lexeme, ASTNodeType typeDefault)
        {
            if (lexeme.StartsWith("0x"))
                node.Push(ASTNodeType.SERIAL, lexeme, _curLine);
            else if (int.TryParse(lexeme, out _))
                node.Push(ASTNodeType.INTEGER, lexeme, _curLine);
            else if (double.TryParse(lexeme, out _))
                node.Push(ASTNodeType.DOUBLE, lexeme, _curLine);
            else
                node.Push(typeDefault, lexeme, _curLine);
        }

        private static void ParseCommand(ASTNode node, string lexeme)
        {
            // A command may start with an '@' symbol. Pick that
            // off.
            if (lexeme[0] == '@')
            {
                node.Push(ASTNodeType.QUIET, null, _curLine);
                lexeme = lexeme.Substring(1, lexeme.Length - 1);
            }

            // A command may end with a '!' symbol. Pick that
            // off.
            if (lexeme.EndsWith("!"))
            {
                node.Push(ASTNodeType.FORCE, null, _curLine);
                lexeme = lexeme.Substring(0, lexeme.Length - 1);
            }

            node.Push(ASTNodeType.COMMAND, lexeme, _curLine);
        }

        private static void ParseOperand(ASTNode node, string lexeme)
        {
            bool modifier = false;

            // An operand may start with an '@' symbol. Pick that
            // off.
            if (lexeme[0] == '@')
            {
                node.Push(ASTNodeType.QUIET, null, _curLine);
                lexeme = lexeme.Substring(1, lexeme.Length - 1);
                modifier = true;
            }

            // An operand may end with a '!' symbol. Pick that
            // off.
            if (lexeme.EndsWith("!"))
            {
                node.Push(ASTNodeType.FORCE, null, _curLine);
                lexeme = lexeme.Substring(0, lexeme.Length - 1);
                modifier = true;
            }

            if (!modifier)
                ParseValue(node, lexeme, ASTNodeType.OPERAND);
            else
                node.Push(ASTNodeType.OPERAND, lexeme, _curLine);
        }

        private static ASTNodeType ParseOperator(ASTNode node, string lexeme)
        {
            ASTNodeType type;

            switch (lexeme)
            {
                case "==":
                case "=":
                    type = ASTNodeType.EQUAL;
                    break;
                case "!=":
                    type = ASTNodeType.NOT_EQUAL;
                    break;
                case "<":
                    type = ASTNodeType.LESS_THAN;
                    break;
                case "<=":
                    type = ASTNodeType.LESS_THAN_OR_EQUAL;
                    break;
                case ">":
                    type = ASTNodeType.GREATER_THAN;
                    break;
                case ">=":
                    type = ASTNodeType.GREATER_THAN_OR_EQUAL;
                    break;
                case "in":
                    type = ASTNodeType.IN;
                    break;
                case "as":
                    type = ASTNodeType.AS;
                    break;
                default:
                    throw new SyntaxError(node, "Invalid operator in binary expression");
            }

            node.Push(type, null, _curLine);

            return type;
        }

        private static void ParseStatement(ASTNode node, string[] lexemes)
        {
            var statement = node.Push(ASTNodeType.STATEMENT, null, _curLine);

            // Examine the first word on the line
            switch (lexemes[0])
            {
                // Ignore comments
                case "#":
                case "//":
                    return;

                // Control flow statements are special
                case "if":
                    {
                        if (lexemes.Length <= 1)
                            throw new SyntaxError(node, "Script compilation error");

                        var t = statement.Push(ASTNodeType.IF, null, _curLine);
                        ParseLogicalExpression(t, lexemes.Slice(1, lexemes.Length - 1));
                        break;
                    }
                case "elseif":
                    {
                        if (lexemes.Length <= 1)
                            throw new SyntaxError(node, "Script compilation error");

                        var t = statement.Push(ASTNodeType.ELSEIF, null, _curLine);
                        ParseLogicalExpression(t, lexemes.Slice(1, lexemes.Length - 1));
                        break;
                    }
                case "else":
                    if (lexemes.Length > 1)
                        throw new SyntaxError(node, "Script compilation error");

                    statement.Push(ASTNodeType.ELSE, null, _curLine);
                    break;
                case "endif":
                    if (lexemes.Length > 1)
                        throw new SyntaxError(node, "Script compilation error");

                    statement.Push(ASTNodeType.ENDIF, null, _curLine);
                    break;
                case "while":
                    {
                        if (lexemes.Length <= 1)
                            throw new SyntaxError(node, "Script compilation error");

                        var t = statement.Push(ASTNodeType.WHILE, null, _curLine);
                        ParseLogicalExpression(t, lexemes.Slice(1, lexemes.Length - 1));
                        break;
                    }
                case "endwhile":
                    if (lexemes.Length > 1)
                        throw new SyntaxError(node, "Script compilation error");

                    statement.Push(ASTNodeType.ENDWHILE, null, _curLine);
                    break;
                case "for":
                    {
                        if (lexemes.Length <= 1)
                            throw new SyntaxError(node, "Script compilation error");

                        ParseForLoop(statement, lexemes.Slice(1, lexemes.Length - 1));
                        break;
                    }
                case "endfor":
                    if (lexemes.Length > 1)
                        throw new SyntaxError(node, "Script compilation error");

                    statement.Push(ASTNodeType.ENDFOR, null, _curLine);
                    break;
                case "foreach":
                {
                    if (lexemes.Length != 4)
                        throw new SyntaxError(node, "Script compilation error");

                    ParseForEachLoop(statement, lexemes.Slice(1, lexemes.Length - 1));
                    break;
                }
                case "break":
                    if (lexemes.Length > 1)
                        throw new SyntaxError(node, "Script compilation error");

                    statement.Push(ASTNodeType.BREAK, null, _curLine);
                    break;
                case "continue":
                    if (lexemes.Length > 1)
                        throw new SyntaxError(node, "Script compilation error");

                    statement.Push(ASTNodeType.CONTINUE, null, _curLine);
                    break;
                case "stop":
                    if (lexemes.Length > 1)
                        throw new SyntaxError(node, "Script compilation error");

                    statement.Push(ASTNodeType.STOP, null, _curLine);
                    break;
                case "replay":
                case "loop":
                    if (lexemes.Length > 1)
                        throw new SyntaxError(node, "Script compilation error");

                    statement.Push(AllowLoop ? ASTNodeType.REPLAY : ASTNodeType.STOP, null, _curLine);
                    break;
                default:
                    // It's a regular statement.
                    ParseCommand(statement, lexemes[0]);

                    foreach (var lexeme in lexemes.Slice(1, lexemes.Length - 1))
                    {
                        ParseValue(statement, lexeme, ASTNodeType.STRING);
                    }
                    break;
            }

        }

        private static bool IsOperator(string lexeme)
        {
            switch (lexeme)
            {
                case "==":
                case "=":
                case "!=":
                case "<":
                case "<=":
                case ">":
                case ">=":
                case "in":
                case "as":
                    return true;
            }

            return false;
        }

        private static void ParseLogicalExpression(ASTNode node, string[] lexemes)
        {
            // The steam language supports logical operators 'and' and 'or'.
            // Catch those and split the expression into pieces first.
            // Fortunately, it does not support parenthesis.
            var expr = node;
            bool logical = false;
            int start = 0;

            for (int i = start; i < lexemes.Length; i++)
            {
                if (lexemes[i] == "and" || lexemes[i] == "or")
                {
                    if (!logical)
                    {
                        expr = node.Push(ASTNodeType.LOGICAL_EXPRESSION, null, _curLine);
                        logical = true;
                    }

                    ParseExpression(expr, lexemes.Slice(start, i - 1));
                    start = i + 1;
                    expr.Push(lexemes[i] == "and" ? ASTNodeType.AND : ASTNodeType.OR, null, _curLine);

                }
            }

            ParseExpression(expr, lexemes.Slice(start, lexemes.Length - 1));
        }

        private static void ParseExpression(ASTNode node, string[] lexemes)
        {

            // The steam language supports both unary and
            // binary expressions. First determine what type
            // we have here.

            bool unary = false;
            bool binary = false;

            foreach (var lexeme in lexemes)
            {
                if (lexeme == "not")
                {
                    // The not lexeme only appears in unary expressions.
                    // Binary expressions would use "!=".
                    unary = true;
                }
                else if (IsOperator(lexeme))
                {
                    // Operators mean it is a binary expression.
                    binary = true;
                }
            }

            // If no operators appeared, it's a unary expression
            if (!unary && !binary)
                unary = true;

            if (unary && binary)
                throw new SyntaxError(node, "Invalid expression");

            if (unary)
                ParseUnaryExpression(node, lexemes);
            else
                ParseBinaryExpression(node, lexemes);
        }

        private static void ParseUnaryExpression(ASTNode node, string[] lexemes)
        {
            var expr = node.Push(ASTNodeType.UNARY_EXPRESSION, null, _curLine);

            int i = 0;

            if (lexemes[i] == "not")
            {
                expr.Push(ASTNodeType.NOT, null, _curLine);
                i++;
            }

            ParseOperand(expr, lexemes[i++]);

            for (; i < lexemes.Length; i++)
            {
                ParseValue(expr, lexemes[i], ASTNodeType.STRING);
            }
        }

        private static void ParseBinaryExpression(ASTNode node, string[] lexemes)
        {
            var expr = node.Push(ASTNodeType.BINARY_EXPRESSION, null, _curLine);

            int i = 0;

            // The expressions on either side of the operator can be values
            // or operands that need to be evaluated.
            ParseOperand(expr, lexemes[i++]);

            for (; i < lexemes.Length; i++)
            {
                if (IsOperator(lexemes[i]))
                    break;

                ParseValue(expr, lexemes[i], ASTNodeType.STRING);
            }

            var op = ParseOperator(expr, lexemes[i++]);

            if (op == ASTNodeType.AS)
            {
                expr.Push(ASTNodeType.STRING, lexemes[i++], _curLine);
            }
            else
            {
                ParseOperand(expr, lexemes[i++]);
            }

            for (; i < lexemes.Length; i++)
            {
                if (IsOperator(lexemes[i]))
                    break;

                ParseValue(expr, lexemes[i], ASTNodeType.STRING);
            }
        }

        private static void ParseForLoop(ASTNode statement, string[] lexemes)
        {
            // There are 4 variants of for loops in steam. The simplest two just
            // iterate a fixed number of times. The other two iterate
            // parts of lists. We call those second two FOREACH.

            // We're intentionally deprecating two of the variants here.
            // The for X to Y variant, where both X and Y are integers,
            // is useless. It can be just written as for X.
            // The for X to Y in LIST variant may have some niche uses, but
            // is annoying to implement.

            // The for X loop remains supported as is, while the
            // for X in LIST form is actually transformed into a foreach
            // statement.

            if (lexemes.Length == 1)
            {
                // for X
                var loop = statement.Push(ASTNodeType.FOR, null, _curLine);

                ParseValue(loop, lexemes[0], ASTNodeType.STRING);

            }
            else if (lexemes.Length == 3 && lexemes[1] == "to")
            {
                // for X to LIST
                var loop = statement.Push(ASTNodeType.FOREACH, null, _curLine);

                loop.Push(ASTNodeType.STRING, lexemes[2], _curLine);
                loop.Push(ASTNodeType.LIST, lexemes[2].Substring(0, lexemes[2].Length - 2), _curLine);
            }
            else
            {
                throw new SyntaxError(statement, "Invalid for loop");
            }
        }
        
        private static void ParseForEachLoop(ASTNode statement, string[] lexemes)
        {
            // foreach X in LIST
            var loop = statement.Push(ASTNodeType.FOREACH, null, _curLine);

            if (lexemes[1] != "in")
                throw new SyntaxError(statement, "Invalid foreach loop");

            // This is the iterator name
            ParseValue(loop, lexemes[0], ASTNodeType.STRING);
            loop.Push(ASTNodeType.LIST, lexemes[2], _curLine);
        }
    }
}


================================================
FILE: Razor/Scripts/Engine/TextParser.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System.Collections.Generic;
using System.Text;

namespace Assistant.Scripts.Engine
{
    internal class TextParser
    {
        private readonly char[] _delimiters, _comments, _quotes;
        private int _eol;
        private int _pos;
        private int _Size;
        private string _string;
        private bool _trim;

        public TextParser(string str, char[] delimiters, char[] comments, char[] quotes)
        {
            _delimiters = delimiters;
            _comments = comments;
            _quotes = quotes;
            _Size = str.Length;
            _string = str;
        }

        internal bool IsDelimiter()
        {
            bool result = false;

            for (int i = 0; i < _delimiters.Length && !result; i++)
                result = _string[_pos] == _delimiters[i];

            return result;
        }

        private void SkipToData()
        {
            while (_pos < _eol && IsDelimiter())
                _pos++;
        }

        private bool IsComment()
        {
            bool result = _string[_pos] == '\n';

            for (int i = 0; i < _comments.Length && !result; i++)
            {
                result = _string[_pos] == _comments[i];

                if (result && i + 1 < _comments.Length && _comments[i] == _comments[i + 1] && _pos + 1 < _eol)
                {
                    result = _string[_pos] == _string[_pos + 1];
                    i++;
                }
            }

            return result;
        }

        private string ObtainData()
        {
            StringBuilder result = new StringBuilder();

            while (_pos < _Size && _string[_pos] != '\n')
            {
                if (IsDelimiter())
                    break;

                if (IsComment())
                {
                    _pos = _eol;

                    break;
                }

                if (_string[_pos] != '\r' && (!_trim || _string[_pos] != ' ' && _string[_pos] != '\t'))
                    result.Append(_string[_pos]);

                _pos++;
            }

            return result.ToString();
        }

        private string ObtainQuotedData()
        {
            bool exit = false;
            string result = "";

            for (int i = 0; i < _quotes.Length; i += 2)
            {
                if (_string[_pos] == _quotes[i])
                {
                    char endQuote = _quotes[i + 1];
                    exit = true;

                    int pos = _pos + 1;
                    int start = pos;

                    while (pos < _eol && _string[pos] != '\n' && _string[pos] != endQuote)
                    {
                        if (_string[pos] == _quotes[i]) // another {
                        {
                            _pos = pos;
                            ObtainQuotedData(); // skip
                            pos = _pos;
                        }

                        pos++;
                    }

                    _pos++;
                    int size = pos - start;

                    if (size > 0)
                    {
                        result = _string.Substring(start, size).TrimEnd('\r', '\n');
                        _pos = pos;

                        if (_pos < _eol && _string[_pos] == endQuote)
                            _pos++;
                    }

                    break;
                }
            }

            if (!exit)
                result = ObtainData();

            return result;
        }

        internal string[] GetTokens(string str, bool trim = true)
        {
            _trim = trim;
            List<string> result = new List<string>();

            _pos = 0;
            _string = str;
            _Size = str.Length;
            _eol = _Size - 1;

            while (_pos < _eol)
            {
                SkipToData();

                if (IsComment())
                    break;

                string buf = ObtainQuotedData();

                if (buf.Length > 0)
                    result.Add(buf);
            }

            return result.ToArray();
        }
    }
}

================================================
FILE: Razor/Scripts/Expressions.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using Assistant.Core;
using Assistant.Scripts.Engine;
using Assistant.Scripts.Helpers;
using Ultima;

namespace Assistant.Scripts
{
    public static class Expressions
    {
        public static void Register()
        {
            Interpreter.RegisterExpressionHandler("stam", Stam);
            Interpreter.RegisterExpressionHandler("maxstam", MaxStam);
            Interpreter.RegisterExpressionHandler("hp", Hp);
            Interpreter.RegisterExpressionHandler("hits", Hp);
            Interpreter.RegisterExpressionHandler("maxhp", MaxHp);
            Interpreter.RegisterExpressionHandler("maxhits", MaxHp);
            Interpreter.RegisterExpressionHandler("mana", Mana);
            Interpreter.RegisterExpressionHandler("maxmana", MaxMana);
            Interpreter.RegisterExpressionHandler("poisoned", Poisoned);
            Interpreter.RegisterExpressionHandler("hidden", Hidden);

            Interpreter.RegisterExpressionHandler("mounted", Mounted);
            Interpreter.RegisterExpressionHandler("rhandempty", RHandEmpty);
            Interpreter.RegisterExpressionHandler("lhandempty", LHandEmpty);

            Interpreter.RegisterExpressionHandler("dead", Dead);

            Interpreter.RegisterExpressionHandler("str", Str);
            Interpreter.RegisterExpressionHandler("int", Int);
            Interpreter.RegisterExpressionHandler("dex", Dex);

            Interpreter.RegisterExpressionHandler("weight", Weight);
            Interpreter.RegisterExpressionHandler("maxweight", MaxWeight);

            Interpreter.RegisterExpressionHandler("skill", SkillExpression);
            Interpreter.RegisterExpressionHandler("count", CountExpression);
            Interpreter.RegisterExpressionHandler("counter", CountExpression);

            Interpreter.RegisterExpressionHandler("insysmsg", InSysMessage);
            Interpreter.RegisterExpressionHandler("insysmessage", InSysMessage);

            Interpreter.RegisterExpressionHandler("findtype", FindType);

            Interpreter.RegisterExpressionHandler("findbuff", FindBuffDebuff);
            Interpreter.RegisterExpressionHandler("finddebuff", FindBuffDebuff);

            Interpreter.RegisterExpressionHandler("position", Position);

            Interpreter.RegisterExpressionHandler("queued", Queued);

            Interpreter.RegisterExpressionHandler("varexist", VarExist);
            Interpreter.RegisterExpressionHandler("varexists", VarExist);

            Interpreter.RegisterExpressionHandler("followers", Followers);
            Interpreter.RegisterExpressionHandler("maxfollowers", MaxFollowers);

            Interpreter.RegisterExpressionHandler("targetexists", TargetExists);

            Interpreter.RegisterExpressionHandler("diffweight", DiffWeight);
            Interpreter.RegisterExpressionHandler("diffhits", DiffHits);
            Interpreter.RegisterExpressionHandler("diffhp", DiffHits);
            Interpreter.RegisterExpressionHandler("diffstam", DiffStam);
            Interpreter.RegisterExpressionHandler("diffmana", DiffMana);

            Interpreter.RegisterExpressionHandler("name", Name);
            Interpreter.RegisterExpressionHandler("paralyzed", Paralyzed);
            Interpreter.RegisterExpressionHandler("invuln", Invulnerable);
            Interpreter.RegisterExpressionHandler("invul", Invulnerable);
            Interpreter.RegisterExpressionHandler("blessed", Invulnerable);
            Interpreter.RegisterExpressionHandler("warmode", Warmode);
            
            Interpreter.RegisterExpressionHandler("itemcount", ItemCount);
            
            Interpreter.RegisterExpressionHandler("poplist", PopListExp);
            Interpreter.RegisterExpressionHandler("listexists", ListExists);
            Interpreter.RegisterExpressionHandler("list", ListLength);
            Interpreter.RegisterExpressionHandler("inlist", InList);
            
            Interpreter.RegisterExpressionHandler("timer", TimerValue);
            Interpreter.RegisterExpressionHandler("timerexists", TimerExists);
        }
        
        private static int TimerValue(string expression, Variable[] args, bool quiet, bool force)
        {
            if (args.Length != 1)
                throw new RunTimeError("Usage: timer ('timer name')");

            var ts = Interpreter.GetTimer(args[0].AsString());

            return (int)ts.TotalMilliseconds;
        }

        private static bool TimerExists(string expression, Variable[] args, bool quiet, bool force)
        {
            if (args.Length != 1)
                throw new RunTimeError("Usage: timerexists ('timer name')");

            return Interpreter.TimerExists(args[0].AsString());
        }
        
        private static bool ListExists(string expression, Variable[] args, bool quiet, bool force)
        {
            if (args.Length != 1)
                throw new RunTimeError("Usage: listexists ('list name')");

            if (Interpreter.ListExists(args[0].AsString()))
                return true;

            return false;
        }

        private static int ListLength(string expression, Variable[] args, bool quiet, bool force)
        {
            if (args.Length != 1)
                throw new RunTimeError("Usage: list (list name) (operator) (value)");

            return Interpreter.ListLength(args[0].AsString());
        }

        private static bool InList(string expression, Variable[] args, bool quiet, bool force)
        {
            if (args.Length != 2)
                throw new RunTimeError("Usage: inlist (list name) (element)");

            if (Interpreter.ListContains(args[0].AsString(), args[1]))
                return true;

            return false;
        }
        
        private static uint PopListExp(string command, Variable[] args, bool quiet, bool force)
        {
            if (args.Length != 2)
                throw new RunTimeError("Usage: poplist ('list name') ('element value'/'front'/'back')");

            var listName = args[0].AsString();
            var frontBackOrElementVar = args[1];
            var isFrontOrBack = frontBackOrElementVar.AsString() == "front" || frontBackOrElementVar.AsString() == "back";

            if (isFrontOrBack)
            {
                var isFront = frontBackOrElementVar.AsString() == "front";
                if (force)
                {
                    while (Interpreter.PopList(listName, isFront, out _)) { }
                    return Serial.Zero;
                }

                Interpreter.PopList(listName, isFront, out var popped);
                return popped.AsSerial();
            }

            var evaluatedVar = new Variable(frontBackOrElementVar.AsString());

            if (force)
            {
                while (Interpreter.PopList(listName, evaluatedVar)) { }
                return Serial.Zero;
            }

            Interpreter.PopList(listName, evaluatedVar);
            return evaluatedVar.AsSerial();
        }
        
        private static int ItemCount(string expression, Variable[] args, bool quiet, bool force)
        {
            return World.Player == null ? 0 : World.Player.Backpack.GetTotalCount();
        }
        
        private static string Name(string expression, Variable[] args, bool quiet, bool force)
        {
            return World.Player == null ? string.Empty : World.Player.Name;
        }

        private static bool Paralyzed(string expression, Variable[] args, bool quiet, bool force)
        {
            return World.Player != null && World.Player.Paralyzed;
        }

        private static bool Invulnerable(string expression, Variable[] args, bool quiet, bool force)
        {
            return World.Player != null && World.Player.Blessed;
        }

        private static bool Warmode(string expression, Variable[] args, bool quiet, bool force)
        {
            return World.Player != null && World.Player.Warmode;
        }

        private static int MaxFollowers(string expression, Variable[] args, bool quiet, bool force)
        {
            return World.Player == null ? 0 : World.Player.FollowersMax;
        }

        private static int Followers(string expression, Variable[] args, bool quiet, bool force)
        {
            return World.Player == null ? 0 : World.Player.Followers;
        }

        private static bool VarExist(string expression, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length != 1)
            {
                throw new RunTimeError("Usage: varexist ('name')");
            }

            string varName = vars[0].AsString(false);

            return quiet ? Interpreter.ExistVariable(varName) : Interpreter.ExistAlias(varName);
        }

        private static bool Queued(string expression, Variable[] vars, bool quiet, bool force)
        {
            return !ActionQueue.Empty;
        }

        private static bool FindBuffDebuff(string expression, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length == 0)
            {
                throw new RunTimeError("Usage: findbuff/finddebuff ('name of buff')");
            }

            string name = vars[0].AsString();

            foreach (BuffDebuff buff in World.Player.BuffsDebuffs)
            {
                if (buff.ClilocMessage1.IndexOf(name, StringComparison.OrdinalIgnoreCase) != -1)
                {
                    return true;
                }
            }

            return false;
        }

        private static uint FindType(string expression, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length == 0)
            {
                throw new RunTimeError("Usage: findtype ('name of item'/'graphicID) [inrangecheck (true/false)/backpack] [hue]");
            }

            string gfxStr = vars[0].AsString();
            Serial gfx = Utility.ToUInt16(gfxStr, 0);
            List<Item> items;
            List<Mobile> mobiles;

            bool inRangeCheck = false;
            bool backpack = false;
            int hue = -1;

            if (vars.Length > 1)
            {
                if (vars.Length == 3)
                {
                    hue = vars[2].AsInt();
                }

                if (vars[1].AsString().IndexOf("pack", StringComparison.OrdinalIgnoreCase) > 0)
                {
                    backpack = true;
                }
                else
                {
                    inRangeCheck = vars[1].AsBool();
                }
            }

            // No graphic id, maybe searching by name?
            if (gfx == 0)
            {
                items = CommandHelper.GetItemsByName(gfxStr, backpack, inRangeCheck, hue);

                if (items.Count == 0) // no item found, search mobile by name
                {
                    mobiles = CommandHelper.GetMobilesByName(gfxStr, inRangeCheck);

                    if (mobiles.Count > 0)
                    {
                        return mobiles[Utility.Random(mobiles.Count)].Serial;
                    }
                }
                else
                {
                    return items[Utility.Random(items.Count)].Serial;
                }
            }
            else // Provided graphic id for type, check backpack first (same behavior as DoubleClickAction in macros
            {
                ushort id = Utility.ToUInt16(gfxStr, 0);

                items = CommandHelper.GetItemsById(id, backpack, inRangeCheck, hue);

                // Still no item? Mobile check!
                if (items.Count == 0)
                {
                    mobiles = CommandHelper.GetMobilesById(id, inRangeCheck);

                    if (mobiles.Count > 0)
                    {
                        return mobiles[Utility.Random(mobiles.Count)].Serial;
                    }
                }
                else
                {
                    return items[Utility.Random(items.Count)].Serial;
                }
            }

            return Serial.Zero;
        }

        private static bool Mounted(string expression, Variable[] vars, bool quiet, bool force)
        {
            return World.Player != null && World.Player.GetItemOnLayer(Layer.Mount) != null;
        }

        private static bool RHandEmpty(string expression, Variable[] vars, bool quiet, bool force)
        {
            return World.Player != null && World.Player.GetItemOnLayer(Layer.RightHand) == null;
        }

        private static bool LHandEmpty(string expression, Variable[] vars, bool quiet, bool force)
        {
            return World.Player != null && World.Player.GetItemOnLayer(Layer.LeftHand) == null;
        }

        private static bool Dead(string expression, Variable[] vars, bool quiet, bool force)
        {
            return World.Player != null && World.Player.IsGhost;
        }

        private static bool InSysMessage(string expression, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length == 0)
            {
                throw new RunTimeError("Usage: insysmsg ('text')");
            }

            string text = vars[0].AsString();

            return SystemMessages.Exists(text);
        }

        private static int Mana(string expression, Variable[] vars, bool quiet, bool force)
        {
            if (World.Player == null)
                return 0;

            return World.Player.Mana;
        }

        private static int MaxMana(string expression, Variable[] vars, bool quiet, bool force)
        {
            if (World.Player == null)
                return 0;

            return World.Player.ManaMax;
        }

        private static bool Poisoned(string expression, Variable[] vars, bool quiet, bool force)
        {
            return World.Player != null && Client.Instance.AllowBit(FeatureBit.BlockHealPoisoned) &&
                   World.Player.Poisoned;
        }

        private static bool Hidden(string expression, Variable[] vars, bool quiet, bool force)
        {
            return World.Player != null && !World.Player.Visible;
        }

        private static int Hp(string expression, Variable[] vars, bool quiet, bool force)
        {
            if (World.Player == null)
                return 0;

            return World.Player.Hits;
        }

        private static int MaxHp(string expression, Variable[] vars, bool quiet, bool force)
        {
            if (World.Player == null)
                return 0;

            return World.Player.HitsMax;
        }

        private static int Stam(string expression, Variable[] vars, bool quiet, bool force)
        {
            if (World.Player == null)
                return 0;

            return World.Player.Stam;
        }

        private static int MaxStam(string expression, Variable[] vars, bool quiet, bool force)
        {
            if (World.Player == null)
                return 0;

            return World.Player.StamMax;
        }

        private static int Str(string expression, Variable[] vars, bool quiet, bool force)
        {
            if (World.Player == null)
                return 0;

            return World.Player.Str;
        }

        private static int Dex(string expression, Variable[] vars, bool quiet, bool force)
        {
            if (World.Player == null)
                return 0;

            return World.Player.Dex;
        }

        private static int Int(string expression, Variable[] vars, bool quiet, bool force)
        {
            if (World.Player == null)
                return 0;

            return World.Player.Int;
        }

        private static int Weight(string expression, Variable[] vars, bool quiet, bool force)
        {
            if (World.Player == null)
                return 0;

            return World.Player.Weight;
        }

        private static int MaxWeight(string expression, Variable[] vars, bool quiet, bool force)
        {
            if (World.Player == null)
                return 0;

            return World.Player.MaxWeight;
        }

        private static double SkillExpression(string expression, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length < 1)
                throw new RunTimeError("Usage: skill ('name of skill')");

            if (World.Player == null)
                return 0;

            if (Skills.SkillsByName.TryGetValue(vars[0].AsString(), out var skill))
            {
                return force ? World.Player.Skills[skill.Index].Base : World.Player.Skills[skill.Index].Value;
            }

            CommandHelper.SendWarning(expression, $"Skill '{vars[0].AsString()}' not found", quiet);

            return 0;
        }

        private static int CountExpression(string expression, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length < 1)
                throw new RunTimeError("Usage: count ('name of counter') OR count ('name of item' OR graphicID) [hue]");

            if (World.Player == null)
                return 0;

            var counter = Counter.FindCounter(vars[0].AsString());
            if (counter != null)
            {
                return counter.Amount;
            }

            string gfxStr = vars[0].AsString();
            Serial gfx = Utility.ToUInt16(gfxStr, 0);
            ushort hue = 0xFFFF;

            if (vars.Length == 2)
            {
                hue = Utility.ToUInt16(vars[1].AsString(), 0xFFFF);
            }

            // No graphic id, maybe searching by name?
            if (gfx == 0)
            {
                var items = CommandHelper.GetItemsByName(gfxStr, true, false, -1);
                
                return items.Count == 0 ? 0 : Counter.GetCount(items[0].ItemID, hue);
            }

            return Counter.GetCount(new ItemID((ushort)gfx.Value), hue);
        }

        private static bool Position(string expression, Variable[] vars, bool quiet, bool force)
        {
            if (World.Player == null)
                return false;

            if (vars.Length < 2)
            {
                throw new RunTimeError("Usage: position (x, y) or position (x, y, z)");
            } 

            int x = vars[0].AsInt();
            int y = vars[1].AsInt();
            int z = (vars.Length > 2) 
                ? vars[2].AsInt() 
                : World.Player.Position.Z;

            return World.Player.Position.X == x
                && World.Player.Position.Y == y
                && World.Player.Position.Z == z;
        }

        private static readonly Dictionary<string, byte> TargetMap = new Dictionary<string, byte>
        {
            {"neutral", 0},
            {"harmful", 1},
            {"beneficial", 2},
            {"any", 3}
        };

        private static bool TargetExists(string expression, Variable[] args, bool quiet, bool force)
        {
            byte type = 3;

            if (args.Length > 0)
            {
                if (!TargetMap.TryGetValue(args[0].AsString().ToLower(), out type))
                {
                    throw new RunTimeError("Invalid target type: 0 = neutral, 1 = harmful, 2 = beneficial, any = 3");
                }
            }

            if (!Targeting.HasTarget)
                return false;

            if (type == 3)
                return true;

            return Targeting.CursorType == type;
        }

        private static int DiffWeight(string expression, Variable[] args, bool quiet, bool force)
        {
            if (World.Player == null)
                return 0;

            return World.Player.MaxWeight - World.Player.Weight;
        }

        private static int DiffHits(string expression, Variable[] args, bool quiet, bool force)
        {
            if (World.Player == null)
                return 0;

            return World.Player.HitsMax - World.Player.Hits;
        }

        private static int DiffStam(string expression, Variable[] args, bool quiet, bool force)
        {
            if (World.Player == null)
                return 0;

            return World.Player.StamMax - World.Player.Stam;
        }

        private static int DiffMana(string expression, Variable[] args, bool quiet, bool force)
        {
            if (World.Player == null)
                return 0;

            return World.Player.ManaMax - World.Player.Mana;
        }
    }
}

================================================
FILE: Razor/Scripts/Helpers/CommandHelper.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using Assistant.Filters;
using Assistant.Scripts.Engine;

namespace Assistant.Scripts.Helpers
{
    public static class CommandHelper
    {
        /// <summary>
        /// Common logic for dclicktype and targettype to find items by name
        /// </summary>
        /// <param name="name"></param>
        /// <param name="backpack"></param>
        /// <param name="inRange"></param>
        /// <param name="hue"></param>
        /// <returns></returns>
        public static List<Item> GetItemsByName(string name, bool backpack, bool inRange, int hue)
        {
            List<Item> items = new List<Item>();

            if (backpack && World.Player.Backpack != null) // search backpack only
            {
                items.AddRange(World.Player.Backpack.FindItemsByName(name, true).Where(item => !Interpreter.CheckIgnored(item.Serial)));
            }
            else if (inRange) // inrange includes both backpack and within 2 tiles
            {
                items.AddRange(World.FindItemsByName(name).Where(item =>
                    !item.IsInBank && !Interpreter.CheckIgnored(item.Serial) && (Utility.InRange(World.Player.Position, item.Position, 2) ||
                                       item.RootContainer == World.Player)));
            }
            else
            {
                items.AddRange(World.FindItemsByName(name).Where(item => !item.IsInBank && !Interpreter.CheckIgnored(item.Serial)));
            }

            if (hue > -1)
            {
                items.RemoveAll(item => item.Hue != hue);
            }

            return items;
        }

        /// <summary>
        /// Common logic for dclicktype and targettype to find items by id
        /// </summary>
        /// <param name="id"></param>
        /// <param name="backpack"></param>
        /// <param name="inRange"></param>
        /// <param name="hue"></param>
        /// <returns></returns>
        public static List<Item> GetItemsById(ushort id, bool backpack, bool inRange, int hue)
        {
            List<Item> items = new List<Item>();

            if (backpack && World.Player.Backpack != null)
            {
                items.AddRange(World.Player.Backpack.FindItemsById(id, true).Where(item => !Interpreter.CheckIgnored(item.Serial)));
            } 
            else if (inRange)
            {
                items.AddRange(World.FindItemsById(id).Where(item =>
                    !item.IsInBank && !Interpreter.CheckIgnored(item.Serial) && (Utility.InRange(World.Player.Position, item.Position, 2) ||
                                                                              item.RootContainer == World.Player)));
            }
            else
            {
                items.AddRange(World.FindItemsById(id).Where(item => !item.IsInBank && !Interpreter.CheckIgnored(item.Serial)));
            }

            if (hue > -1)
            {
                items.RemoveAll(item => item.Hue != hue);
            }

            return items;
        }

        /// <summary>
        /// Common logic for dclicktype and targettype to find mobiles by name
        /// </summary>
        /// <param name="name"></param>
        /// <param name="inRange"></param>
        /// <returns></returns>
        public static List<Mobile> GetMobilesByName(string name, bool inRange)
        {
            List<Mobile> mobiles = new List<Mobile>();

            mobiles.AddRange(inRange
                ? World.FindMobilesByName(name).Where(m => !Interpreter.CheckIgnored(m.Serial) && Utility.InRange(World.Player.Position, m.Position, 2))
                : World.FindMobilesByName(name).Where(m => !Interpreter.CheckIgnored(m.Serial)));

            return mobiles;
        }

        /// <summary>
        /// Common logic for dclicktype and targettype to find mobiles by id
        /// </summary>
        /// <param name="id"></param>
        /// <param name="inRange"></param>
        /// <returns></returns>
        public static List<Mobile> GetMobilesById(ushort id, bool inRange)
        {
            List<Mobile> mobiles = new List<Mobile>();

            mobiles.AddRange(inRange
                ? World.MobilesInRange().Where(m =>
                    Utility.InRange(World.Player.Position, m.Position, 2) && m.Body == id &&
                    !Interpreter.CheckIgnored(m.Serial))
                : World.MobilesInRange().Where(m => m.Body == id && !Interpreter.CheckIgnored(m.Serial)));

            return mobiles;
        }

        public static void SendWarning(string command, string message, bool quiet)
        {
            if (!quiet)
            {
                World.Player.SendMessage(MsgLevel.Warning, $"{command} - {message}");
            }
        }

        public static void SendMessage(string message, bool quiet)
        {
            if (!quiet)
            {
                World.Player.SendMessage(MsgLevel.Force, message);
            }
        }

        public static void SendInfo(string message, bool quiet)
        {
            if (!quiet)
            {
                World.Player.SendMessage(MsgLevel.Info, message);
            }
        }

        /// <summary>
        /// Parse the script input to target the correct mobile
        /// </summary>
        /// <param name="args"></param>
        /// <param name="closest"></param>
        /// <param name="random"></param>
        /// <param name="next"></param>
        /// <param name="prev"></param>
        public static void FindTarget(Variable[] args, bool closest, bool random = false, bool next = false, bool prev = false)
        {
            ScriptManager.TargetFound = false;

            // Do a basic t
            if (args.Length == 1)
            {
                if (closest)
                {
                    Targeting.TargetClosest();
                }
                else if (random)
                {
                    Targeting.TargetRandAnyone();
                }
                else if (next)
                {
                    Targeting.NextTarget();
                }
                else
                {
                    Targeting.PrevTarget();
                }
            }
            else if ((next || prev) && args.Length == 2)
            {
                switch (args[1].AsString())
                {
                    case "human":
                    case "humanoid":

                        if (next)
                        {
                            Targeting.NextTargetHumanoid();
                        }
                        else
                        {
                            Targeting.PrevTargetHumanoid();
                        }

                        break;
                    case "monster":
                        if (next)
                        {
                            Targeting.NextTargetMonster();
                        }
                        else
                        {
                            Targeting.PrevTargetMonster();
                        }

                        break;
                    case "friend":
                        if (next)
                        {
                            Targeting.NextTargetFriend();
                        }
                        else
                        {
                            Targeting.PrevTargetFriend();
                        }

                        break;
                    case "friendly":
                        if (next)
                        {
                            Targeting.NextTargetFriendly();
                        }
                        else
                        {
                            Targeting.PrevTargetFriendly();
                        }

                        break;
                    case "nonfriendly":
                        if (next)
                        {
                            Targeting.NextTargetNonFriend();
                        }
                        else
                        {
                            Targeting.PrevTargetNonFriend();
                        }

                        break;
                    default:
                        throw new RunTimeError($"Unknown target type: '{args[1].AsString()}' - Missing type? (human/monster)");
                }
            }
            else if (args.Length > 1)
            {
                string list = args[1].AsString();

                if (list.IndexOf('!') != -1)
                {
                    FindTargetPriority(args, closest, random, next);
                }
                else if (list.IndexOf(',') != -1)
                {
                    FindTargetNotoriety(args, closest, random, next);
                }
                else
                {
                    FindTargetPriority(args, closest, random, next);
                }
            }
        }

        /// <summary>
        /// Find targets based on notoriety
        /// </summary>
        /// <param name="args"></param>
        /// <param name="closest"></param>
        /// <param name="random"></param>
        /// <param name="next"></param>
        private static void FindTargetNotoriety(Variable[] args, bool closest, bool random, bool next)
        {
            string[] notoList = args[1].AsString().Split(',');

            List<int> notoTypes = new List<int>();

            foreach (string noto in notoList)
            {
                Targeting.TargetType type = (Targeting.TargetType)Enum.Parse(typeof(Targeting.TargetType), noto, true);

                /*NonFriendly, //Attackable, Criminal, Enemy, Murderer
                Friendly, //Innocent, Guild/Ally 
                Red, //Murderer
                Blue, //Innocent
                Gray, //Attackable, Criminal
                Grey, //Attackable, Criminal
                Green, //GuildAlly
                Guild, //GuildAlly*/

                switch (type)
                {
                    case Targeting.TargetType.Friendly:
                        notoTypes.Add((int) Targeting.TargetType.Innocent);
                        notoTypes.Add((int) Targeting.TargetType.GuildAlly);
                        break;
                    case Targeting.TargetType.NonFriendly:
                        notoTypes.Add((int)Targeting.TargetType.Attackable);
                        notoTypes.Add((int)Targeting.TargetType.Criminal);
                        notoTypes.Add((int)Targeting.TargetType.Enemy);
                        notoTypes.Add((int)Targeting.TargetType.Murderer);
                        break;
                    case Targeting.TargetType.Red:
                        notoTypes.Add((int)Targeting.TargetType.Murderer);
                        break;
                    case Targeting.TargetType.Blue:
                        notoTypes.Add((int)Targeting.TargetType.Innocent);
                        break;
                    case Targeting.TargetType.Gray:
                    case Targeting.TargetType.Grey:
                        notoTypes.Add((int)Targeting.TargetType.Attackable);
                        notoTypes.Add((int)Targeting.TargetType.Criminal);
                        break;
                    case Targeting.TargetType.Green:
                    case Targeting.TargetType.Guild:
                        notoTypes.Add((int)Targeting.TargetType.GuildAlly);
                        break;
                    default:
                        notoTypes.Add((int)type);
                        break;
                }
            }

            if (args.Length == 3)
            {
                if (args[2].AsString().IndexOf("human", StringComparison.OrdinalIgnoreCase) != -1)
                {
                    if (closest)
                    {
                        Targeting.ClosestHumanoidTarget(notoTypes.ToArray());
                    }
                    else if (random)
                    {
                        Targeting.RandomHumanoidTarget(notoTypes.ToArray());
                    } 
                    else if (next)
                    {
                        Targeting.NextPrevTargetNotorietyHumanoid(true, notoTypes.ToArray());
                    }
                    else
                    {
                        Targeting.NextPrevTargetNotorietyHumanoid(false, notoTypes.ToArray());
                    }
                }
                else if (args[2].AsString().IndexOf("monster", StringComparison.OrdinalIgnoreCase) != -1)
                {
                    if (closest)
                    {
                        Targeting.ClosestMonsterTarget(notoTypes.ToArray());
                    }
                    else if (random)
                    {
                        Targeting.RandomMonsterTarget(notoTypes.ToArray());
                    }
                    else if (next)
                    {
                        Targeting.NextPrevTargetNotorietyMonster(true, notoTypes.ToArray());
                    }
                    else
                    {
                        Targeting.NextPrevTargetNotorietyMonster(false, notoTypes.ToArray());
                    }
                }
            }
            else
            {
                if (closest)
                {
                    Targeting.ClosestTarget(notoTypes.ToArray());
                }
                else if (random)
                {
                    Targeting.RandomTarget(notoTypes.ToArray());
                }
                else if (next)
                {
                    Targeting.NextPrevTargetNotoriety(true, notoTypes.ToArray());
                }
                else
                {
                    Targeting.NextPrevTargetNotoriety(false, notoTypes.ToArray());
                }
            }
        }

        /// <summary>
        /// Find a target based on a priority list of notorieties 
        /// </summary>
        /// <param name="args"></param>
        /// <param name="closest"></param>
        /// <param name="random"></param>
        /// <param name="next"></param>
        private static void FindTargetPriority(Variable[] args, bool closest, bool random, bool next)
        {
            string[] notoList = args[1].AsString().Split('!');

            foreach (string noto in notoList)
            {
                if (ScriptManager.TargetFound)
                {
                    break;
                }

                switch (noto)
                {
                    case "enemy":
                        if (args.Length == 3)
                        {
                            if (args[2].AsString().IndexOf("human", StringComparison.OrdinalIgnoreCase) != -1)
                            {
                                if (closest)
                                {
                                    Targeting.TargetCloseEnemyHumanoid();
                                }
                                else if (random)
                                {
                                    Targeting.TargetRandEnemyHumanoid();
                                }
                                else if (next)
                                {
                                    Targeting.NextTargetEnemyHumanoid();
                                }
                                else
                                {
                                    Targeting.PrevTargetEnemyHumanoid();
                                }
                            }
                            else if (args[2].AsString()
                                .IndexOf("monster", StringComparison.OrdinalIgnoreCase) != -1)
                            {
                                if (closest)
                                {
                                    Targeting.TargetCloseEnemyMonster();
                                }
                                else if (random)
                                {
                                    Targeting.TargetRandEnemyMonster();
                                }
                                else if (next)
                                {
                                    Targeting.NextTargetEnemyMonster();
                                }
                                else
                                {
                                    Targeting.PrevTargetEnemyMonster();
                                }
                            }
                        }
                        else
                        {
                            if (closest)
                            {
                                Targeting.TargetCloseEnemy();
                            }
                            else if (random)
                            {
                                Targeting.TargetRandEnemy();
                            }
                        }

                        break;
                    case "friend":
                        if (closest)
                        {
                            Targeting.TargetClosestFriend();
                        }
                        else if (random)
                        {
                            Targeting.TargetRandFriend();
                        }
                        else if (next)
                        {
                            Targeting.NextTargetFriend();
                        }
                        else
                        {
                            Targeting.PrevTargetFriend();
                        }

                        break;
                    case "friendly":
                        if (args.Length == 3)
                        {
                            if (args[2].AsString().IndexOf("human", StringComparison.OrdinalIgnoreCase) != -1)
                            {
                                if (closest)
                                {
                                    Targeting.TargetCloseFriendlyHumanoid();
                                }
                                else if (random)
                                {
                                    Targeting.TargetRandFriendlyHumanoid();
                                }
                                else if (next)
                                {
                                    Targeting.NextTargetFriendlyHumanoid();
                                }
                                else
                                {
                                    Targeting.PrevTargetFriendlyHumanoid();
                                }
                            }
                            else if (args[2].AsString()
                                .IndexOf("monster", StringComparison.OrdinalIgnoreCase) != -1)
                            {
                                if (closest)
                                {
                                    Targeting.TargetCloseFriendlyMonster();
                                }
                                else if (random)
                                {
                                    Targeting.TargetRandFriendlyMonster();
                                }
                                else if (next)
                                {
                                    Targeting.NextTargetFriendlyMonster();
                                }
                                else
                                {
                                    Targeting.PrevTargetFriendlyMonster();
                                }
                            }
                        }
                        else
                        {
                            if (closest)
                            {
                                Targeting.TargetCloseFriendly();
                            }
                            else if (random)
                            {
                                Targeting.TargetRandFriendly();
                            }
                        }

                        break;
                    case "gray":
                    case "grey":
                        if (args.Length == 3)
                        {
                            if (args[2].AsString().IndexOf("human", StringComparison.OrdinalIgnoreCase) != -1)
                            {
                                if (closest)
                                {
                                    Targeting.TargetCloseGreyHumanoid();
                                }
                                else if (random)
                                {
                                    Targeting.TargetRandGreyHumanoid();
                                }
                                else if (next)
                                {
                                    Targeting.NextTargetGreyHumanoid();
                                }
                                else
                                {
                                    Targeting.PrevTargetGreyHumanoid();
                                }
                            }
                            else if (args[2].AsString()
                                .IndexOf("monster", StringComparison.OrdinalIgnoreCase) != -1)
                            {
                                if (closest)
                                {
                                    Targeting.TargetCloseGreyMonster();
                                }
                                else if (random)
                                {
                                    Targeting.TargetRandGreyMonster();
                                }
                                else if (next)
                                {
                                    Targeting.NextTargetGreyMonster();
                                }
                                else
                                {
                                    Targeting.PrevTargetGreyMonster();
                                }
                            }
                        }
                        else
                        {
                            if (closest)
                            {
                                Targeting.TargetCloseGrey();
                            }
                            else if (random)
                            {
                                Targeting.TargetRandGrey();
                            }
                        }

                        break;
                    case "criminal":
                        if (args.Length == 3)
                        {
                            if (args[2].AsString().IndexOf("human", StringComparison.OrdinalIgnoreCase) != -1)
                            {
                                if (closest)
                                {
                                    Targeting.TargetCloseCriminalHumanoid();
                                }
                                else if (random)
                                {
                                    Targeting.TargetRandCriminalHumanoid();
                                }
                                else if (next)
                                {
                                    Targeting.NextTargetCriminalHumanoid();
                                }
                                else
                                {
                                    Targeting.PrevTargetCriminalHumanoid();
                                }
                            }
                            else if (args[2].AsString()
                                .IndexOf("monster", StringComparison.OrdinalIgnoreCase) != -1)
                            {
                                if (closest)
                                {
                                    Targeting.TargetCloseCriminalMonster();
                                }
                                else if (random)
                                {
                                    Targeting.TargetRandCriminalMonster();
                                }
                                else if (next)
                                {
                                    Targeting.NextTargetCriminalMonster();
                                }
                                else
                                {
                                    Targeting.PrevTargetCriminalMonster();
                                }
                            }
                        }
                        else
                        {
                            if (closest)
                            {
                                Targeting.TargetCloseCriminal();
                            }
                            else if (random)
                            {
                                Targeting.TargetRandCriminal();
                            }
                        }

                        break;
                    case "blue":
                    case "innocent":
                        if (args.Length == 3)
                        {
                            if (args[2].AsString().IndexOf("human", StringComparison.OrdinalIgnoreCase) != -1)
                            {
                                if (closest)
                                {
                                    Targeting.TargetCloseInnocentHumanoid();
                                }
                                else if (random)
                                {
                                    Targeting.TargetRandInnocentHumanoid();
                                }
                                else if (next)
                                {
                                    Targeting.NextTargetInnocentHumanoid();
                                }
                                else
                                {
                                    Targeting.PrevTargetInnocentHumanoid();
                                }
                            }
                            else if (args[2].AsString()
                                .IndexOf("monster", StringComparison.OrdinalIgnoreCase) != -1)
                            {
                                if (closest)
                                {
                                    Targeting.TargetCloseInnocentMonster();
                                }
                                else if (random)
                                {
                                    Targeting.TargetRandInnocentMonster();
                                }
                                else if (next)
                                {
                                    Targeting.NextTargetInnocentMonster();
                                }
                                else
                                {
                                    Targeting.PrevTargetInnocentMonster();
                                }
                            }
                        }
                        else
                        {
                            if (closest)
                            {
                                Targeting.TargetCloseInnocent();
                            }
                            else if (random)
                            {
                                Targeting.TargetRandInnocent();
                            }
                        }

                        break;
                    case "red":
                    case "murderer":
                        if (args.Length == 3)
                        {
                            if (args[2].AsString().IndexOf("human", StringComparison.OrdinalIgnoreCase) != -1)
                            {
                                if (closest)
                                {
                                    Targeting.TargetCloseRedHumanoid();
                                }
                                else if (random)
                                {
                                    Targeting.TargetRandRedHumanoid();
                                }
                                else if (next)
                                {
                                    Targeting.NextTargetMurdererHumanoid();
                                }
                                else
                                {
                                    Targeting.PrevTargetMurdererHumanoid();
                                }
                            }
                            else if (args[2].AsString()
                                .IndexOf("monster", StringComparison.OrdinalIgnoreCase) != -1)
                            {
                                if (closest)
                                {
                                    Targeting.TargetCloseRedMonster();
                                }
                                else if (random)
                                {
                                    Targeting.TargetRandRedMonster();
                                }
                                else if (next)
                                {
                                    Targeting.NextTargetMurdererMonster();
                                }
                                else
                                {
                                    Targeting.PrevTargetMurdererMonster();
                                }
                            }
                        }
                        else
                        {
                            if (closest)
                            {
                                Targeting.TargetCloseRed();
                            }
                            else if (random)
                            {
                                Targeting.TargetRandRed();
                            }
                        }

                        break;
                    case "nonfriendly":
                        if (args.Length == 3)
                        {
                            if (args[2].AsString().IndexOf("human", StringComparison.OrdinalIgnoreCase) != -1)
                            {
                                if (closest)
                                {
                                    Targeting.TargetCloseNonFriendlyHumanoid();
                                }
                                else if (random)
                                {
                                    Targeting.TargetRandNonFriendlyHumanoid();
                                }
                                else if (next)
                                {
                                    Targeting.NextTargetNonFriendlyHumanoid();
                                }
                                else
                                {
                                    Targeting.PrevTargetNonFriendlyHumanoid();
                                }
                            }
                            else if (args[2].AsString()
                                .IndexOf("monster", StringComparison.OrdinalIgnoreCase) != -1)
                            {
                                if (closest)
                                {
                                    Targeting.TargetCloseNonFriendlyMonster();
                                }
                                else if (random)
                                {
                                    Targeting.TargetRandNonFriendlyMonster();
                                }
                                else if (next)
                                {
                                    Targeting.NextTargetNonFriendlyMonster();
                                }
                                else
                                {
                                    Targeting.PrevTargetNonFriendlyMonster();
                                }
                            }
                        }
                        else
                        {
                            if (closest)
                            {
                                Targeting.TargetCloseNonFriendly();
                            }
                            else if (random)
                            {
                                Targeting.TargetRandNonFriendly();
                            }
                        }

                        break;
                    default:
                        throw new RunTimeError($"Unknown target type: '{args[1].AsString()}'");
                }
            }
        }
        
        public static string ReplaceStringInterpolations(string stringWithPossibleInterpolation)
        {
            Regex regex = new Regex(@"\{{(.*?)\}}");
            return regex.Replace(stringWithPossibleInterpolation, match =>
            {
                string varName = match.Groups[1].Value;
                Variable varContent = Interpreter.GetVariable(varName);

                return varContent?.AsString() ?? "<not found>";
            });
        }
    }
}


================================================
FILE: Razor/Scripts/RazorScript.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

namespace Assistant.Scripts
{
    public sealed class RazorScript
    {
        public string Path { get; set; }
        public string[] Lines { get; set; }
        public string Name { get; set; }
        public string Category { get; set; }

        public override string ToString()
        {
            return string.IsNullOrEmpty(Category) ? Name : $"{Category}\\{Name}";
        }
    }
}


================================================
FILE: Razor/Scripts/ScriptManager.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Windows.Forms;
using Assistant.Gumps.Internal;
using Assistant.Macros;
using Assistant.Scripts.Engine;
using Assistant.UI;
using FastColoredTextBoxNS;

namespace Assistant.Scripts
{
    public static class ScriptManager
    {
        public static bool Recording { get; set; }

        public static bool Paused => ScriptPaused;

        private static bool ScriptPaused { get; set; }

        public static bool Running => ScriptRunning;

        private static bool ScriptRunning { get; set; }

        public static DateTime LastWalk { get; set; }

        public static bool SetVariableActive { get; set; }
        
        public static bool TargetFound { get; set; }

        public static string ScriptPath => Config.GetUserDirectory("Scripts");

        private static FastColoredTextBox ScriptEditor { get; set; }

        private static TreeView ScriptTree { get; set; }

        private static ListBox ScriptVariableList { get; set; }

        private static Script _queuedScript;

        private static string _queuedScriptName;

        public static bool BlockPopupMenu { get; set; }

        private static bool EnableHighlight { get; set; }

        public enum HighlightType
        {
            Error,
            Execution
        }

        private static Dictionary<HighlightType, List<int>> HighlightLines { get; } = new Dictionary<HighlightType, List<int>>();

        private static Dictionary<HighlightType, Brush> HighlightLineColors { get; } = new Dictionary<HighlightType, Brush>()
        {
            { HighlightType.Error, new SolidBrush(Color.Red) },
            { HighlightType.Execution, new SolidBrush(Color.Blue) }
        };

        private static HighlightType[] GetHighlightTypes()
        {
            return (HighlightType[])Enum.GetValues(typeof(HighlightType));
        }

        public static RazorScript SelectedScript { get; set; }

        private static Stopwatch Stopwatch { get; } = new Stopwatch();
        
        private class ScriptTimer : Timer
        {
            // Only run scripts once every 25ms to avoid spamming.
            public ScriptTimer(int delay) : base(TimeSpan.FromMilliseconds(delay), TimeSpan.FromMilliseconds(delay))
            {
            }

            protected override void OnTick()
            {
                try
                {
                    if (!Client.Instance.ClientRunning)
                    {
                        if (ScriptRunning)
                        {
                            ScriptRunning = false;
                            Interpreter.StopScript();
                        }

                        return;
                    }

                    bool running;

                    if (_queuedScript != null)
                    {
                        // Starting a new script. This relies on the atomicity for references in CLR
                        Script script = _queuedScript;

                        running = Interpreter.StartScript(script);
                        UpdateLineNumber(Interpreter.CurrentLine);

                        _queuedScript = null;
                    }
                    else
                    {
                        running = Interpreter.ExecuteScript();

                        if (running)
                        {
                            UpdateLineNumber(Interpreter.CurrentLine);
                        }
                    }


                    if (running)
                    {
                        if (ScriptManager.Running == false)
                        {
                            if (!Config.GetBool("ScriptDisablePlayFinish"))
                            {
                                if (!Config.GetBool("DisableScriptStopwatch"))
                                {
                                    Stopwatch.Start();    
                                }
                                
                                World.Player?.SendMessage(LocString.ScriptPlaying, _queuedScriptName);
                            }

                            Assistant.Engine.MainWindow.LockScriptUI(true);
                            ScriptRunning = true;
                        }
                    }
                    else
                    {
                        if (ScriptManager.Running)
                        {
                            if (!Config.GetBool("ScriptDisablePlayFinish"))
                            {
                                if (!Config.GetBool("DisableScriptStopwatch"))
                                {
                                    Stopwatch.Stop();
                                    TimeSpan elapsed = Stopwatch.Elapsed;
                                    Stopwatch.Reset();
                                
                                    World.Player?.SendMessage(LocString.ScriptFinishedStopwatch, _queuedScriptName, elapsed.TotalMilliseconds);    
                                }
                                else
                                {
                                    World.Player?.SendMessage(LocString.ScriptFinished, _queuedScriptName);
                                }
                                
                            }

                            Assistant.Engine.MainWindow.LockScriptUI(false);
                            ScriptRunning = false;

                            ClearHighlightLine(HighlightType.Execution);
                        }
                    }
                }
                catch (Exception ex)
                {
                    World.Player?.SendMessage(MsgLevel.Error, $"Script Error: {ex.Message} (Line: {Interpreter.CurrentLine + 1})");

                    if (EnableHighlight)
                    {
                        SetHighlightLine(Interpreter.CurrentLine, HighlightType.Error);
                    }

                    StopScript();
                }
            }
        }

        /// <summary>
        /// This is called via reflection when the application starts up
        /// </summary>
        public static void Initialize()
        {
            HotKey.Add(HKCategory.Scripts, HKSubCat.None, LocString.StopScript, HotkeyStopScript);
            HotKey.Add(HKCategory.Scripts, HKSubCat.None, LocString.PauseScript, HotkeyPauseScript);
            HotKey.Add(HKCategory.Scripts, HKSubCat.None, LocString.ScriptDClickType, HotkeyDClickTypeScript);
            HotKey.Add(HKCategory.Scripts, HKSubCat.None, LocString.ScriptTargetType, HotkeyTargetTypeScript);


            _scriptList = new List<RazorScript>();

            Recurse(null, Config.GetUserDirectory("Scripts"));
            
            foreach (HighlightType type in GetHighlightTypes())
            {
                HighlightLines[type] = new List<int>();
            }

            Lexer.AllowLoop = Client.Instance.AllowBit(FeatureBit.LoopingMacros);
        }

        private static void HotkeyTargetTypeScript()
        {
            if (World.Player != null)
            {
                World.Player.SendMessage(MsgLevel.Force, LocString.ScriptTargetType);
                Targeting.OneTimeTarget(OnTargetTypeScript);
            }
        }

        private static void OnTargetTypeScript(bool loc, Serial serial, Point3D pt, ushort itemId)
        {
            Item item = World.FindItem(serial);

            if (item != null && item.Serial.IsItem && item.Movable && item.Visible)
            {
                string cmd = $"targettype '{item.ItemID.ItemData.Name}'";

                Clipboard.SetDataObject(cmd);
                World.Player.SendMessage(MsgLevel.Force, Language.Format(LocString.ScriptCopied, cmd), false);
            }
            else
            {
                Mobile m = World.FindMobile(serial);

                if (m != null)
                {
                    string cmd = $"targettype '{m.Body}'";

                    Clipboard.SetDataObject(cmd);
                    World.Player.SendMessage(MsgLevel.Force, Language.Format(LocString.ScriptCopied, cmd), false);
                }
            }
        }

        private static void HotkeyDClickTypeScript()
        {
            if (World.Player != null)
            {
                World.Player.SendMessage(MsgLevel.Force, LocString.ScriptTargetType);
                Targeting.OneTimeTarget(OnDClickTypeScript);
            }
        }

        private static void OnDClickTypeScript(bool loc, Serial serial, Point3D pt, ushort itemId)
        {
            Item item = World.FindItem(serial);

            if (item != null && item.Serial.IsItem && item.Movable && item.Visible)
            {
                string cmd = $"dclicktype '{item.ItemID.ItemData.Name}'";

                Clipboard.SetDataObject(cmd);
                World.Player.SendMessage(MsgLevel.Force, Language.Format(LocString.ScriptCopied, cmd), false);
            }
            else
            {
                Mobile m = World.FindMobile(serial);

                if (m != null)
                {
                    string cmd = $"dclicktype '{m.Body}'";

                    Clipboard.SetDataObject(cmd);
                    World.Player.SendMessage(MsgLevel.Force, Language.Format(LocString.ScriptCopied, cmd), false);
                }
            }
        }

        private static void HotkeyStopScript()
        {
            StopScript();
        }

        private static void HotkeyPauseScript()
        {
            if (!ScriptRunning)
            {
                return;
            }

            if (ScriptPaused)
            {
                ResumeScript();
                World.Player.SendMessage(MsgLevel.Force, Language.Format(LocString.ResumeScriptMessage, Interpreter.CurrentLine), false);
            }
            else
            {
                World.Player.SendMessage(MsgLevel.Force, Language.Format(LocString.PauseScriptMessage, Interpreter.CurrentLine), false);
                PauseScript();
            }
        }

        private static void AddHotkey(RazorScript script)
        {
            HotKey.Add(HKCategory.Scripts, HKSubCat.None, Language.Format(LocString.PlayScript, script), OnHotKey,
                script);
        }

        private static void RemoveHotkey(RazorScript script)
        {
            HotKey.Remove(Language.Format(LocString.PlayScript, script.ToString()));
        }

        public static void OnHotKey(ref object state)
        {
            RazorScript script = (RazorScript) state;
            
            PlayScript(script.Lines, script.Name);
        }

        public static void StopScript()
        {
            _queuedScript = null;
            ScriptPaused = false;

            Interpreter.StopScript();
        }

        public static void PauseScript()
        {
            ScriptPaused = true;
            Interpreter.PauseScript();
        }

        public static void ResumeScript()
        {
            ScriptPaused = false;
            Interpreter.ResumeScript();
        }

        public static RazorScript AddScript(string file)
        {
            RazorScript script = new RazorScript
            {
                Lines = File.ReadAllLines(file),
                Name = Path.GetFileNameWithoutExtension(file),
                Path = file
            };

            if (Path.GetDirectoryName(script.Path).Equals(Config.GetUserDirectory("Scripts")))
            {
                script.Category = string.Empty;
            }
            else
            {
                string cat = file.Replace(Config.GetUserDirectory("Scripts"), "").Substring(1);
                script.Category = Path.GetDirectoryName(cat).Replace("/", "\\");
            }

            AddHotkey(script);

            _scriptList.Add(script);

            return script;
        }

        public static void RemoveScript(RazorScript script)
        {
            RemoveHotkey(script);

            _scriptList.Remove(script);
        }
        
        public static void PlayScript(string scriptName)
        {
            foreach (RazorScript razorScript in _scriptList)
            {
                if (razorScript.ToString().IndexOf(scriptName, StringComparison.OrdinalIgnoreCase) != -1)
                {
                    PlayScript(razorScript.Lines, scriptName);
                    break;
                }
            }
        }

        public static void PlayScript(string[] lines, string name)
        {
            if (World.Player == null || lines == null)
                return;

            if (MacroManager.Playing || MacroManager.StepThrough)
                MacroManager.Stop();

            StopScript();
            
            EnableHighlight = false;
            
            SetVariableActive = false;

            if (_queuedScript != null)
                return;

            if (!Client.Instance.ClientRunning)
                return;

            try
            {
                Script script = new Script(Lexer.Lex(lines));
                
                _queuedScript = script;
                _queuedScriptName = name;
            }
            catch (SyntaxError syntaxError)
            {
                World.Player.SendMessage(MsgLevel.Error, $"{syntaxError.Message}: '{syntaxError.Line}' (Line #{syntaxError.LineNumber + 1})");
            }
        }
        
        public static void PlayScriptFromUI(string[] lines, string name, bool highlight)
        {
            if (World.Player == null || ScriptEditor == null || lines == null)
                return;

            EnableHighlight = highlight;

            if (EnableHighlight)
            {
                ClearAllHighlightLines();
            }

            if (MacroManager.Playing || MacroManager.StepThrough)
                MacroManager.Stop();

            StopScript(); // be sure nothing is running
            
            SetVariableActive = false;

            if (_queuedScript != null)
                return;

            if (!Client.Instance.ClientRunning)
                return;

            try
            {
                Script script = new Script(Lexer.Lex(lines));
                
                _queuedScript = script;
                _queuedScriptName = name;
            }
            catch (SyntaxError syntaxError)
            {
                World.Player.SendMessage(MsgLevel.Error, $"{syntaxError.Message}: '{syntaxError.Line}' (Line #{syntaxError.LineNumber + 1})");

                if (EnableHighlight)
                {
                    SetHighlightLine(syntaxError.LineNumber, HighlightType.Error);
                }
            }
        }

        /*private static void ActiveScriptStatementExecuted(ASTNode statement)
        {
            if (EnableHighlight && statement != null)
            {
                var lineNum = statement.LineNumber;

                SetHighlightLine(lineNum, HighlightType.Execution);
                // Scrolls to relevant line, per this suggestion: https://github.com/PavelTorgashov/FastColoredTextBox/issues/115
                ScriptEditor.Selection.Start = new Place(0, lineNum);
                ScriptEditor.DoSelectionVisible();
            }
        }*/

        private static ScriptTimer Timer { get; set; }

        static ScriptManager()
        {
            Timer = new ScriptTimer(Config.GetBool("DefaultScriptDelay") ? 25 : 0);
        }

        public static void ResetTimer()
        {
            Timer.Stop();
            Timer = new ScriptTimer(Config.GetBool("DefaultScriptDelay") ? 25 : 0);
            Timer.Start();
        }

        private static void UpdateLineNumber(int lineNum)
        {
            if (EnableHighlight)
            {
                SetHighlightLine(lineNum, HighlightType.Execution);
                // Scrolls to relevant line, per this suggestion: https://github.com/PavelTorgashov/FastColoredTextBox/issues/115
                ScriptEditor.Selection.Start = new Place(0, lineNum);
                ScriptEditor.DoSelectionVisible();
            }
        }

        public static void SetEditor(FastColoredTextBox scriptEditor)
        {
            ScriptEditor = scriptEditor;

            InitScriptEditor();

            if (SelectedScript != null)
            {
                SetEditorText(SelectedScript);
            }
        }

        public static void SetEditorText(RazorScript selectedScript)
        {
            SelectedScript = selectedScript;

            ScriptEditor.Text = string.Join("\n", SelectedScript.Lines);
        }

        public static void SetControls(FastColoredTextBox scriptEditor, TreeView scriptTree, ListBox scriptVariables)
        {
            ScriptEditor = scriptEditor;
            ScriptTree = scriptTree;
            ScriptVariableList = scriptVariables;
        }

        public static void OnLogin()
        {
            Commands.Register();
            AgentCommands.Register();
            SpeechCommands.Register();
            TargetCommands.Register();

            Aliases.Register();
            Expressions.Register();

            Timer.Start();
        }

        public static void OnLogout()
        {
            StopScript();
            Timer.Stop();
            Assistant.Engine.MainWindow.LockScriptUI(false);
        }

        public static void StartEngine()
        {
            Timer.Start();
        }

        private static List<RazorScript> _scriptList { get; set; }

        public static void RedrawScriptVariables()
        {
            ScriptVariableList?.SafeAction(s =>
            {
                s.BeginUpdate();
                s.Items.Clear();

                foreach (KeyValuePair<string, Serial> variable in ScriptVariables.Variables)
                {
                    s.Items.Add($"{variable.Key} ({variable.Value})");
                }

                s.EndUpdate();
                s.Refresh();
                s.Update();
            });
        }

        public static bool AddToScript(string command)
        {
            if (Recording)
            {
                ScriptEditor?.AppendText(command + Environment.NewLine);

                return true;
            }

            return false;
        }

        private static int GetScriptIndex(string script)
        {
            for (int i = 0; i < _scriptList.Count; i++)
            {
                if (_scriptList[i].Name.Equals(script, StringComparison.OrdinalIgnoreCase))
                    return i;
            }

            return -1;
        }

        public static void Error(bool quiet, string statement, string message, bool throwError = false)
        {
            if (quiet)
                return;

            World.Player?.SendMessage(MsgLevel.Error, $"{statement}: {message}");
        }

        public static List<ASTNode> ParseArguments(ref ASTNode node)
        {
            List<ASTNode> args = new List<ASTNode>();
            while (node != null)
            {
                args.Add(node);
                node = node.Next();
            }

            return args;
        }

        private delegate void SetHighlightLineDelegate(int iline, Color color);

        /// <summary>
        /// Adds a new highlight of specified type
        /// </summary>
        /// <param name="iline">Line number to highlight</param>
        /// <param name="type">Type of highlight to set</param>
        private static void AddHighlightLine(int iline, HighlightType type)
        {
            HighlightLines[type].Add(iline);
            RefreshHighlightLines();
        }

        /// <summary>
        /// Clears existing highlight lines of this type, and adds a new one at specified line number
        /// </summary>
        /// <param name="iline">Line number to highlight</param>
        /// <param name="type">Type of highlight to set</param>
        private static void SetHighlightLine(int iline, HighlightType type)
        {
            ClearHighlightLine(type);
            AddHighlightLine(iline, type);
        }

        public static void ClearHighlightLine(HighlightType type)
        {
            HighlightLines[type].Clear();
            RefreshHighlightLines();
        }

        public static void ClearAllHighlightLines()
        {
            foreach (HighlightType type in GetHighlightTypes())
            {
                HighlightLines[type].Clear();
            }

            RefreshHighlightLines();
        }

        private static void RefreshHighlightLines()
        {
            for (int i = 0; i < ScriptEditor.LinesCount; i++)
            {
                ScriptEditor[i].BackgroundBrush = ScriptEditor.BackBrush;
            }

            foreach (HighlightType type in GetHighlightTypes())
            {
                foreach (int lineNum in HighlightLines[type])
                {
                    ScriptEditor[lineNum].BackgroundBrush = HighlightLineColors[type];
                }
            }

            ScriptEditor.Invalidate();
        }

        private static FastColoredTextBoxNS.AutocompleteMenu _autoCompleteMenu;

        public static void InitScriptEditor()
        {
            _autoCompleteMenu = new AutocompleteMenu(ScriptEditor)
            {
                SearchPattern = @"[\w\.:=!<>]",
                AllowTabKey = true,
                ToolTipDuration = 5000,
                AppearInterval = 100
            };

            #region Keywords

            string[] keywords =
            {
                    "if", "elseif", "else", "endif", "while", "endwhile", "for", "endfor", "break", "continue", "stop",
                    "replay", "not", "and", "or"
                };

            #endregion

            #region Commands auto-complete

            string[] commands =
            {
                "alliance", "clearall", "cleardragdrop", "clearhands", "emote", "guild", "attack", "interrupt", "virtue", "yell",
                "cast", "dclick", "dclicktype",
                "dress", "drop", "droprelloc", "gumpresponse", "gumpclose", "hotkey", "lasttarget", "lift", "lifttype",
                "menu", "menuresponse", "organizer", "overhead", "potion", "promptresponse", "restock", "say",
                "whisper", "yell", "emote", "script", "scavenger", "sell", "setability", "setlasttarget", "setvar",
                "skill", "sysmsg", "target", "targettype", "targetrelloc", "undress", "useonce", "walk", "wait",
                "pause", "waitforgump", "waitformenu", "waitforprompt", "waitfortarget", "waitforsysmsg", "clearsysmsg", "clearjournal",
                "waitforsysmsg", "random"
            };

            #endregion

            Dictionary<string, ToolTipDescriptions> descriptionCommands = new Dictionary<string, ToolTipDescriptions>();

            #region CommandToolTips

            var tooltip = new ToolTipDescriptions("attack", new[] { "attack (serial) or attack ('variablename')" },
                "N/A", "Attack a specific serial or variable tied to a serial.", "attack 0x2AB4\n\tattack 'attackdummy'");
            descriptionCommands.Add("attack", tooltip);

            tooltip = new ToolTipDescriptions("clearall", new[] { "clearall" }, "N/A", "Clear target, clear queues, drop anything you're holding",
                "clearall");
            descriptionCommands.Add("clearall", tooltip);

            tooltip = new ToolTipDescriptions("clearhands", new[] { "clearhands ('right'/'left'/'hands')" }, "N/A", "Use the item in your hands",
                "clearhands");
            descriptionCommands.Add("clearhands", tooltip);

            tooltip = new ToolTipDescriptions("virtue", new[] { "virtue ('honor'/'sacrifice'/'valor')" }, "N/A", "Invoke a specific virtue",
                "virtue 'honor'");
            descriptionCommands.Add("virtue", tooltip);

            tooltip = new ToolTipDescriptions("cast", new[] { "cast ('name of spell')" }, "N/A", "Cast a spell by name",
                "cast 'blade spirits'");
            descriptionCommands.Add("cast", tooltip);

            tooltip = new ToolTipDescriptions("dclick", new[] { "dclick (serial) or useobject (serial)" }, "N/A",
                "This command will use (double-click) a specific item or mobile.", "dclick 0x34AB");
            descriptionCommands.Add("dclick", tooltip);

            tooltip = new ToolTipDescriptions("dclicktype",
                new[]
                {
                        "dclicktype ('name of item') OR (graphicID) [inrange] or usetype ('name of item') OR (graphicID) [inrange/backpack] [hue]"
                }, "N/A",
                "This command will use (double-click) an item type either provided by the name or the graphic ID.\n\t\tIf you include the optional true parameter, items within range (2 tiles) will only be considered.",
                "dclicktype 'dagger'\n\t\twaitfortarget\n\t\ttargettype 'robe'");
            descriptionCommands.Add("dclicktype", tooltip);

            tooltip = new ToolTipDescriptions("dress", new[] { "dress ('name of dress list')" }, "N/A",
                "This command will execute a spec dress list you have defined in Razor.", "dress 'My Sunday Best'");
            descriptionCommands.Add("dress", tooltip);

            tooltip = new ToolTipDescriptions("drop", new[] { "drop (serial) (x/y/z/layername)" }, "N/A",
                "This command will drop the item you are holding either at your feet,\n\t\ton a specific layer or at a specific X / Y / Z location.",
                "lift 0x400D54A7 1\n\t\tdrop 0x6311 InnerTorso");
            descriptionCommands.Add("drop", tooltip);

            tooltip = new ToolTipDescriptions("", new[] { "" }, "N/A", "",
                "lift 0x400D54A7 1\n\twait 5000\n\tdrop 0xFFFFFFFF 5926 1148 0");
            descriptionCommands.Add("", tooltip);

            tooltip = new ToolTipDescriptions("droprelloc", new[] { "droprelloc (x) (y)" }, "N/A",
                "This command will drop the item you're holding to a location relative to your position.",
                "lift 0x400EED2A 1\n\twait 1000\n\tdroprelloc 1 1");
            descriptionCommands.Add("droprelloc", tooltip);

            tooltip = new ToolTipDescriptions("gumpresponse", new[] { "gumpresponse (buttonID)" }, "N/A",
                "Responds to a specific gump button", "gumpresponse 4");
            descriptionCommands.Add("gumpresponse", tooltip);

            tooltip = new ToolTipDescriptions("gumpclose", new[] { "gumpclose" }, "N/A",
                "This command will close the last gump that opened.", "gumpclose");
            descriptionCommands.Add("gumpclose", tooltip);

            tooltip = new ToolTipDescriptions("hotkey", new[] { "hotkey ('name of hotkey')" }, "N/A",
                "This command will execute any Razor hotkey by name.",
                "skill 'detect hidden'\n\twaitfortarget\n\thotkey 'target self'");
            descriptionCommands.Add("hotkey", tooltip);

            tooltip = new ToolTipDescriptions("lasttarget", new[] { "lasttarget" }, "N/A",
                "This command will target your last target set in Razor.",
                "cast 'magic arrow'\n\twaitfortarget\n\tlasttarget");
            descriptionCommands.Add("lasttarget", tooltip);

            tooltip = new ToolTipDescriptions("lift", new[] { "lift (serial) [amount]" }, "N/A",
                "This command will lift a specific item and amount. If no amount is provided, 1 is defaulted.",
                "lift 0x400EED2A 1\n\twait 1000\n\tdroprelloc 1 1 0");
            descriptionCommands.Add("lift", tooltip);

            tooltip = new ToolTipDescriptions("lifttype",
                new[] { "lifttype (gfx) [amount] or lifttype ('name of item') [amount] [hue]" }, "N/A",
                "This command will lift a specific item by type either by the graphic id or by the name.\n\tIf no amount is provided, 1 is defaulted.",
                "lifttype 'robe'\n\twait 1000\n\tdroprelloc 1 1 0\n\tlifttype 0x1FCD\n\twait 1000\n\tdroprelloc 1 1");
            descriptionCommands.Add("lifttype", tooltip);

            tooltip = new ToolTipDescriptions("menu", new[] { "menu (serial) (index) [false]" }, "N/A",
                "Selects a specific index within a context menu", "# open backpack\n\tmenu 0 1");
            descriptionCommands.Add("menu", tooltip);

            tooltip = new ToolTipDescriptions("menuresponse", new[] { "menuresponse (index) (menuId) [hue]" }, "N/A",
                "Responds to a specific menu and menu ID (not a context menu)", "menuresponse 3 4");
            descriptionCommands.Add("menuresponse", tooltip);

            tooltip = new ToolTipDescriptions("organizer", new[] { "organizer (number) ['set']" }, "N/A",
                "This command will execute a specific organizer agent. If the set parameter is included,\n\tyou will instead be prompted to set the organizer agent's hotbag.",
                "organizer 1\n\torganizer 4 'set'");
            descriptionCommands.Add("organizer", tooltip);

            tooltip = new ToolTipDescriptions("overhead", new[] { "overhead ('text') [color] [serial]" }, "N/A",
                "This command will display a message over your head. Only you can see this.",
                "if stam = 100\n\t    overhead 'ready to go!'\n\tendif");
            descriptionCommands.Add("overhead", tooltip);

            tooltip = new ToolTipDescriptions("potion", new[] { "potion ('potion type')" }, "N/A",
                "This command will use a specific potion based on the type.", "potion 'agility'\n\tpotion 'heal'");
            descriptionCommands.Add("potion", tooltip);

            tooltip = new ToolTipDescriptions("promptresponse", new[] { "promptresponse ('prompt response')" }, "N/A",
                "This command will respond to a prompt triggered from actions such as renaming runes or giving a guild title.",
                "dclicktype 'rune'\n\twaitforprompt\n\tpromptresponse 'to home'");
            descriptionCommands.Add("promptresponse", tooltip);

            tooltip = new ToolTipDescriptions("restock", new[] { "restock (number) ['set']" }, "N/A",
                "This command will execute a specific restock agent.\n\tIf the set parameter is included, you will instead be prompted to set the restock agent's hotbag.",
                "restock 1\n\trestock 4 'set'");
            descriptionCommands.Add("restock", tooltip);

            tooltip = new ToolTipDescriptions("say",
                new[] { "say ('message to send') [hue] or msg ('message to send') [hue]" }, "N/A",
                "This command will force your character to say the message passed as the parameter.",
                "say 'Hello world!'\n\tsay 'Hello world!' 454");
            descriptionCommands.Add("say", tooltip);

            tooltip = new ToolTipDescriptions("whisper",
                new[] { "whisper ('message to send') [hue]" }, "N/A",
                "This command will force your character to whisper the message passed as the parameter.",
                "whisper 'Hello world!'\n\twhisper 'Hello world!' 454");
            descriptionCommands.Add("whisper", tooltip);

            tooltip = new ToolTipDescriptions("yell",
                new[] { "yell ('message to send') [hue]" }, "N/A",
                "This command will force your character to yell the message passed as the parameter.",
                "yell 'Hello world!'\n\tyell 'Hello world!' 454");
            descriptionCommands.Add("yell", tooltip);

            tooltip = new ToolTipDescriptions("emote",
                new[] { "emote ('message to send') [hue]" }, "N/A",
                "This command will force your character to emote the message passed as the parameter.",
                "emote 'Hello world!'\n\temote 'Hello world!' 454");
            descriptionCommands.Add("emote", tooltip);

            tooltip = new ToolTipDescriptions("script", new[] { "script 'name'" }, "N/A",
                "This command will call another script.", "if hp = 40\n\t   script 'healself'\n\tendif");
            descriptionCommands.Add("script", tooltip);

            tooltip = new ToolTipDescriptions("scavenger", new[] { "scavenger ['clear'/'add'/'on'/'off'/'set']" },
                "N/A", "This command will control the scavenger agent.", "scavenger 'off'");
            descriptionCommands.Add("scavenger", tooltip);

            tooltip = new ToolTipDescriptions("sell", new[] { "sell" }, "N/A",
                "This command will set the Sell agent's hotbag.", "sell");
            descriptionCommands.Add("sell", tooltip);

            tooltip = new ToolTipDescriptions("setability",
                new[] { "setability ('primary'/'secondary'/'stun'/'disarm') ['on'/'off']" }, "N/A",
                "This will set a specific ability on or off. If on or off is missing, on is defaulted.",
                "setability stun");
            descriptionCommands.Add("setability", tooltip);

            tooltip = new ToolTipDescriptions("setlasttarget", new[] { "setlasttarget" }, "N/A",
                "This command will pause the script until you select a target to be set as Last Target.",
                "overhead 'set last target'\n\tsetlasttarget\n\toverhead 'set!'\n\tcast 'magic arrow'\n\twaitfortarget\n\ttarget 'last'");
            descriptionCommands.Add("setlasttarget", tooltip);

            tooltip = new ToolTipDescriptions("setvar", new[] { "setvar ('variable') or setvariable ('variable')" },
                "N/A",
                "This command will pause the script until you select a target to be assigned a variable.\n\tPlease note, the variable must exist before you can assign values to it.",
                "setvar 'dummy'\n\tcast 'magic arrow'\n\twaitfortarget\n\ttarget 'dummy'");
            descriptionCommands.Add("setvar", tooltip);

            tooltip = new ToolTipDescriptions("skill", new[] { "skill 'name of skill' or skill last" }, "N/A",
                "This command will use a specific skill (assuming it's a usable skill).",
                "while mana < maxmana\n\t    say 'mediation!'\n\t    skill 'meditation'\n\t    wait 11000\n\tendwhile");
            descriptionCommands.Add("skill", tooltip);

            tooltip = new ToolTipDescriptions("sysmsg", new[] { "sysmsg ('message to display in system message')" },
                "N/A", "This command will display a message in the lower-left of the client.",
                "if stam = 100\n\t    sysmsg 'ready to go!'\n\tendif");
            descriptionCommands.Add("sysmsg", tooltip);

            tooltip = new ToolTipDescriptions("target", new[] { "target (serial) or target (x) (y) (z)" }, "N/A",
                "This command will target a specific mobile or item or target a specific location based on X/Y/Z coordinates.",
                "cast 'lightning'\n\twaitfortarget\n\ttarget 0xBB3\n\tcast 'fire field'\n\twaitfortarget\n\ttarget 5923 1145 0");
            descriptionCommands.Add("target", tooltip);

            tooltip = new ToolTipDescriptions("targettype",
                new[] { "targettype (graphic) or targettype ('name of item or mobile type') [inrangecheck/backpack] [hue]" }, "N/A",
                "This command will target a specific type of mobile or item based on the graphic id or based on\n\tthe name of the item or mobile. If the optional parameter is passed\n\tin as true only items within the range of 2 tiles will be considered.",
                "usetype 'dagger'\n\twaitfortarget\n\ttargettype 'robe'\n\tuseobject 0x4005ECAF\n\twaitfortarget\n\ttargettype 0x1f03\n\tuseobject 0x4005ECAF\n\twaitfortarget\n\ttargettype 0x1f03 true");
            descriptionCommands.Add("targettype", tooltip);

            tooltip = new ToolTipDescriptions("targetrelloc", new[] { "targetrelloc (x-offset) (y-offset)" }, "N/A",
                "This command will target a specific location on the map relative to your position.",
                "cast 'fire field'\n\twaitfortarget\n\ttargetrelloc 1 1");
            descriptionCommands.Add("targetrelloc", tooltip);

            tooltip = new ToolTipDescriptions("undress",
                new[] { "undress ['name of dress list']' or undress 'LayerName'" }, "N/A",
                "This command will either undress you completely if no dress list is provided.\n\tIf you provide a dress list, only those specific items will be undressed. Lastly, you can define a layer name to undress.",
                "undress\n\tundress 'My Sunday Best'\n\tundress 'Shirt'\n\tundrsss 'Pants'");
            descriptionCommands.Add("undress", tooltip);

            tooltip = new ToolTipDescriptions("useonce", new[] { "useonce ['add'/'addcontainer']" }, "N/A",
                "This command will execute the UseOnce agent. If the add parameter is included, you can add items to your UseOnce list.\n\tIf the addcontainer parameter is included, you can add all items in a container to your UseOnce list.",
                "useonce\n\tuseonce 'add'\n\tuseonce 'addcontainer'");
            descriptionCommands.Add("useonce", tooltip);

            tooltip = new ToolTipDescriptions("walk", new[] { "walk ('direction')" }, "N/A",
                "This command will turn and/or walk your player in a certain direction.",
                "walk 'North'\n\twalk 'Up'\n\twalk 'West'\n\twalk 'Left'\n\twalk 'South'\n\twalk 'Down'\n\twalk 'East'\n\twalk 'Right'");
            descriptionCommands.Add("walk", tooltip);

            tooltip = new ToolTipDescriptions("wait",
                new[] { "wait [time in milliseconds or pause [time in milliseconds]" }, "N/A",
                "This command will pause the execution of a script for a given time.",
                "while stam < 100\n\t    wait 5000\n\tendwhile");
            descriptionCommands.Add("wait", tooltip);

            tooltip = new ToolTipDescriptions("pause",
                new[] { "pause [time in milliseconds or pause [time in milliseconds]" }, "N/A",
                "This command will pause the execution of a script for a given time.",
                "while stam < 100\n\t    wait 5000\n\tendwhile");
            descriptionCommands.Add("pause", tooltip);

            tooltip = new ToolTipDescriptions("waitforgump", new[] { "waitforgump [gump id]" }, "N/A",
                "This command will wait for a gump. If no gump id is provided, it will wait for **any * *gump.",
                "waitforgump\n\twaitforgump 4");
            descriptionCommands.Add("waitforgump", tooltip);

            tooltip = new ToolTipDescriptions("waitformenu", new[] { "waitformenu [menu id]" }, "N/A",
                "This command will wait for menu (not a context menu). If no menu id is provided, it will wait for **any * *menu.",
                "waitformenu\n\twaitformenu 4");
            descriptionCommands.Add("waitformenu", tooltip);

            tooltip = new ToolTipDescriptions("waitforprompt", new[] { "waitforprompt" }, "N/A",
                "This command will wait for a prompt before continuing.",
                "dclicktype 'rune'\n\twaitforprompt\n\tpromptresponse 'to home'");
            descriptionCommands.Add("waitforprompt", tooltip);

            tooltip = new ToolTipDescriptions("waitfortarget",
                new[] { "waitfortarget [pause in milliseconds] or wft [pause in milliseconds]" }, "N/A",
                "This command will cause the script to pause until you have a target cursor.\n\tBy default it will wait 30 seconds but you can define a specific wait time if you prefer.",
                "cast 'energy bolt'\n\twaitfortarget\n\thotkey 'Target Closest Enemy'");
            descriptionCommands.Add("waitfortarget", tooltip);

            tooltip = new ToolTipDescriptions("clearsysmsg",
                new[] { "clearsysmsg" }, "N/A",
                "This command will clear the internal system message queue used with insysmsg.",
                "clearsysmsg\n");
            descriptionCommands.Add("clearsysmsg", tooltip);

            tooltip = new ToolTipDescriptions("clearjournal",
                new[] { "clearjournal" }, "N/A",
                "This command (same as clearjournal) will clear the internal system message queue used with insysmsg.",
                "clearjournal\n");
            descriptionCommands.Add("clearjournal", tooltip);

            tooltip = new ToolTipDescriptions("waitforsysmsg",
                new[] { "waitforsysmsg" }, "N/A",
                "This command will pause the script until the message defined is in the system message queue.",
                "waitforsysmsg 'message here'\n");
            descriptionCommands.Add("waitforsysmsg", tooltip);

            tooltip = new ToolTipDescriptions("random",
                new[] { "random [max number]" }, "N/A",
                "This command output a random number between 1 and the max number provided.",
                "random '15'\n");
            descriptionCommands.Add("random", tooltip);

            #endregion

            if (!Config.GetBool("DisableScriptTooltips"))
            {
                List<AutocompleteItem> items = new List<AutocompleteItem>();

                foreach (var item in keywords)
                {
                    items.Add(new AutocompleteItem(item));
                }

                foreach (var item in commands)
                {
                    descriptionCommands.TryGetValue(item, out ToolTipDescriptions element);

                    if (element != null)
                    {
                        items.Add(new MethodAutocompleteItemAdvance(item)
                        {
                            ImageIndex = 2,
                            ToolTipTitle = element.Title,
                            ToolTipText = element.ToolTipDescription()
                        });
                    }
                    else
                    {
                        items.Add(new MethodAutocompleteItemAdvance(item)
                        {
                            ImageIndex = 2
                        });
                    }
                }

                _autoCompleteMenu.Items.SetAutocompleteItems(items);
                _autoCompleteMenu.Items.MaximumSize =
                    new Size(_autoCompleteMenu.Items.Width + 20, _autoCompleteMenu.Items.Height);
                _autoCompleteMenu.Items.Width = _autoCompleteMenu.Items.Width + 20;
            }
            else
            {
                _autoCompleteMenu.Items.SetAutocompleteItems(new List<AutocompleteItem>());
            }

            ScriptEditor.Language = FastColoredTextBoxNS.Language.Razor;
        }

        public class ToolTipDescriptions
        {
            public string Title;
            public string[] Parameters;
            public string Returns;
            public string Description;
            public string Example;

            public ToolTipDescriptions(string title, string[] parameter, string returns, string description,
                string example)
            {
                Title = title;
                Parameters = parameter;
                Returns = returns;
                Description = description;
                Example = example;
            }

            public string ToolTipDescription()
            {
                string complete_description = string.Empty;

                complete_description += "Parameter(s): ";

                foreach (string parameter in Parameters)
                    complete_description += "\n\t" + parameter;

                complete_description += "\nDescription:";

                complete_description += "\n\t" + Description;

                complete_description += "\nExample(s):";

                complete_description += "\n\t" + Example;

                return complete_description;
            }
        }

        public class MethodAutocompleteItemAdvance : MethodAutocompleteItem
        {
            string firstPart;
            string lastPart;

            public MethodAutocompleteItemAdvance(string text)
                : base(text)
            {
                var i = text.LastIndexOf(' ');
                if (i < 0)
                    firstPart = text;
                else
                {
                    firstPart = text.Substring(0, i);
                    lastPart = text.Substring(i + 1);
                }
            }

            public override CompareResult Compare(string fragmentText)
            {
                int i = fragmentText.LastIndexOf(' ');

                if (i < 0)
                {
                    if (firstPart.StartsWith(fragmentText) && string.IsNullOrEmpty(lastPart))
                        return CompareResult.VisibleAndSelected;
                    //if (firstPart.ToLower().Contains(fragmentText.ToLower()))
                    //  return CompareResult.Visible;
                }
                else
                {
                    var fragmentFirstPart = fragmentText.Substring(0, i);
                    var fragmentLastPart = fragmentText.Substring(i + 1);


                    if (firstPart != fragmentFirstPart)
                        return CompareResult.Hidden;

                    if (lastPart != null && lastPart.StartsWith(fragmentLastPart))
                        return CompareResult.VisibleAndSelected;

                    if (lastPart != null && lastPart.ToLower().Contains(fragmentLastPart.ToLower()))
                        return CompareResult.Visible;
                }

                return CompareResult.Hidden;
            }

            public override string GetTextForReplace()
            {
                if (lastPart == null)
                    return firstPart;

                return firstPart + " " + lastPart;
            }

            public override string ToString()
            {
                if (lastPart == null)
                    return firstPart;

                return lastPart;
            }
        }

        public static void RedrawScripts()
        {
            ScriptTree.SafeAction(s =>
            {
                s.BeginUpdate();
                s.Nodes.Clear();
                Recurse(s.Nodes, Config.GetUserDirectory("Scripts"));
                s.EndUpdate();
                s.Refresh();
                s.Update();
            });

            RedrawScriptVariables();
        }

        public static TreeNode GetScriptDirNode()
        {
            if (ScriptTree.SelectedNode == null)
            {
                return null;
            }

            if (ScriptTree.SelectedNode.Tag is string)
                return ScriptTree.SelectedNode;
                
            if (!(ScriptTree.SelectedNode.Parent?.Tag is string))
                return null;
                
            return ScriptTree.SelectedNode.Parent;
        }

        public static void AddScriptNode(TreeNode node)
        {
            if (node == null)
            {
                ScriptTree.Nodes.Add(node);
            }
            else
            {
                node.Nodes.Add(node);
            }

            ScriptTree.SelectedNode = node;
        }

        private static void Recurse(TreeNodeCollection nodes, string path)
        {
            try
            {
                var razorFiles = Directory.GetFiles(path, "*.razor");
                razorFiles = razorFiles.OrderBy(fileName => fileName).ToArray();

                foreach (var file in razorFiles)
                {
                    RazorScript script = null;

                    foreach (RazorScript razorScript in _scriptList)
                    {
                        if (razorScript.Path.Equals(file))
                        {
                            script = razorScript;
                            script.Lines = File.ReadAllLines(script.Path);
                        }
                    }

                    if (script == null)
                    {
                        script = AddScript(file);
                    }

                    if (nodes != null)
                    {
                        TreeNode node = new TreeNode(script.Name)
                        {
                            Tag = script
                        };

                        nodes.Add(node);
                    }
                }
            }
            catch
            {
                // ignored
            }

            try
            {

                foreach (string directory in Directory.GetDirectories(path))
                {
                    if (!string.IsNullOrEmpty(directory) && !directory.Equals(".") && !directory.Equals(".."))
                    {
                        if (nodes != null)
                        {
                            TreeNode node = new TreeNode($"[{Path.GetFileName(directory)}]")
                            {
                                Tag = directory
                            };

                            nodes.Add(node);

                            Recurse(node.Nodes, directory);
                        }
                        else
                        {
                            Recurse(null, directory);
                        }
                    }
                }
            }
            catch
            {
                // ignored
            }
        }

        public static void GetGumpInfo(string[] param)
        {
            Targeting.OneTimeTarget(OnGetItemInfoTarget);
            Client.Instance.SendToClient(new UnicodeMessage(0xFFFFFFFF, -1, MessageType.Regular, 0x3B2, 3,
                Language.CliLocName, "System", "Select an item or mobile to view/inspect"));
        }

        private static void OnGetItemInfoTarget(bool ground, Serial serial, Point3D pt, ushort gfx)
        {
            Item item = World.FindItem(serial);

            if (item == null)
            {
                Mobile mobile = World.FindMobile(serial);

                if (mobile == null)
                    return;

                MobileInfoGump gump = new MobileInfoGump(mobile);
                gump.SendGump();
            }
            else
            {
                ItemInfoGump gump = new ItemInfoGump(item);
                gump.SendGump();
            }
        }
    }
}

================================================
FILE: Razor/Scripts/ScriptVariables.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.Xml;
using Assistant.Scripts.Engine;

namespace Assistant.Scripts
{
    public class ScriptVariables
    {
        private static Dictionary<string, Serial> _variables = new Dictionary<string, Serial>();
        public static IEnumerable<KeyValuePair<string, Serial>> Variables => _variables;

        public static void Save(XmlTextWriter xml)
        {
            foreach (KeyValuePair<string, Serial> kv in _variables)
            {
                xml.WriteStartElement("scriptvariable");
                xml.WriteAttributeString("serial", kv.Value.ToString());
                xml.WriteAttributeString("name", kv.Key);
                xml.WriteEndElement();
            }
        }

        public static void Load(XmlElement node)
        {
            ClearAll();

            try
            {
                foreach (XmlElement el in node.GetElementsByTagName("scriptvariable"))
                {
                    string name = el.GetAttribute("name");
                    Serial serial = Serial.Parse(el.GetAttribute("serial"));

                    RegisterVariable(name, serial);
                }
            }
            catch
            {
                // ignored
            }
        }

        public static void RegisterVariable(string name, Serial serial)
        {
            name = name.Trim();

            _variables[name] = serial;
            Interpreter.SetAlias(name, serial);
        }

        public static void UnregisterVariable(string name)
        {
            name = name.Trim();
            Interpreter.ClearAlias(name);
            _variables.Remove(name);
        }

        public static void ClearAll()
        {
            foreach (string key in new List<string>(_variables.Keys))
            {
                UnregisterVariable(key);
            }

            _variables.Clear();
        }

        public static Serial GetVariable(string name)
        {
            name = name.Trim();

            if (_variables.TryGetValue(name, out var val))
            {
                return val;
            }

            return Serial.MinusOne;
        }
    }
}

================================================
FILE: Razor/Scripts/SpeechCommands.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using Assistant.Scripts.Engine;

namespace Assistant.Scripts
{
    public static class SpeechCommands
    {
        public static void Register()
        {
            // Messages
            Interpreter.RegisterCommandHandler("say", Say);
            Interpreter.RegisterCommandHandler("msg", Say);
            Interpreter.RegisterCommandHandler("yell", Yell);
            Interpreter.RegisterCommandHandler("whisper", Whisper);
            Interpreter.RegisterCommandHandler("emote", Emote);
            Interpreter.RegisterCommandHandler("guild", Guild);
            Interpreter.RegisterCommandHandler("alliance", Alliance);
        }

        private static bool Say(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length == 0)
            {
                throw new RunTimeError("Usage: say ('text') [color]");
            }

            if (vars.Length == 1)
                World.Player.Say(Config.GetInt("SysColor"), vars[0].AsString());
            else
                World.Player.Say(Utility.ToInt32(vars[1].AsString(), 0), vars[0].AsString());

            return true;
        }

        private static bool Whisper(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length == 0)
            {
                throw new RunTimeError("Usage: whisper ('text') [color]");
            }

            MessageType type = MessageType.Whisper & ~MessageType.Encoded;

            if (vars.Length == 1)
                World.Player.Whisper(vars[0].AsString(), World.Player.SpeechHue);
            else
                World.Player.Whisper(vars[0].AsString(), Utility.ToInt32(vars[1].AsString(), 0));

            return true;
        }

        private static bool Yell(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length == 0)
            {
                throw new RunTimeError("Usage: yell ('text') [color]");
            }

            if (vars.Length == 1)
                World.Player.Yell(vars[0].AsString(), World.Player.SpeechHue);
            else
                World.Player.Yell(vars[0].AsString(), Utility.ToInt32(vars[1].AsString(), 0));

            return true;
        }

        private static bool Emote(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length == 0)
            {
                throw new RunTimeError("Usage: emote ('text') [color]");
            }

            if (vars.Length == 1)
                World.Player.Emote(vars[0].AsString(), World.Player.SpeechHue);
            else
                World.Player.Emote(vars[0].AsString(), Utility.ToInt32(vars[1].AsString(), 0));

            return true;
        }

        private static bool Guild(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length == 0)
            {
                throw new RunTimeError("Usage: guild ('text')");
            }

            if (vars.Length == 1)
                World.Player.Guild(vars[0].AsString(), World.Player.SpeechHue);
            else
                World.Player.Guild(vars[0].AsString(), Utility.ToInt32(vars[1].AsString(), 0));

            return true;
        }

        private static bool Alliance(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length == 0)
            {
                throw new RunTimeError("Usage: alliance ('text')");
            }

            if (vars.Length == 1)
                World.Player.Alliance(vars[0].AsString(), World.Player.SpeechHue);
            else
                World.Player.Alliance(vars[0].AsString(), Utility.ToInt32(vars[1].AsString(), 0));

            return true;
        }
    }
}


================================================
FILE: Razor/Scripts/TargetCommands.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using Assistant.Scripts.Engine;
using Assistant.Scripts.Helpers;

namespace Assistant.Scripts
{
    public static class TargetCommands
    {
        public static void Register()
        {
            // Targets
            Interpreter.RegisterCommandHandler("target", Target); //Absolute Target

            Interpreter.RegisterCommandHandler("targettype", TargetType); //TargetTypeAction
            Interpreter.RegisterCommandHandler("targetrelloc", TargetRelLoc); //TargetRelLocAction
            Interpreter.RegisterCommandHandler("targetloc", TargetLocation);

            Interpreter.RegisterCommandHandler("waitfortarget", WaitForTarget); //WaitForTargetAction
            Interpreter.RegisterCommandHandler("wft", WaitForTarget); //WaitForTargetAction
        }

        private static bool Target(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length < 1)
            {
                throw new RunTimeError("Usage: target (serial) OR target (closest/random/next/prev [noto] [type]");
            }

            switch (vars[0].AsString())
            {
                case "close":
                case "closest":
                    CommandHelper.FindTarget(vars, true);

                    break;

                case "rand":
                case "random":
                    CommandHelper.FindTarget(vars, false, true);

                    break;

                case "next":
                    CommandHelper.FindTarget(vars, false, false, true);

                    break;

                case "prev":
                case "previous":
                    CommandHelper.FindTarget(vars, false, false, false, true);

                    break;

                case "cancel":
                    Targeting.CancelTarget();

                    break;

                case "clear":
                    Targeting.OnClearQueue();

                    break;

                default:
                    Serial serial = vars[0].AsSerial();

                    if (serial != Serial.Zero) // Target a specific item or mobile
                    {
                        Item item = World.FindItem(serial);

                        if (item != null)
                        {
                            Targeting.Target(item);
                            return true;
                        }

                        Mobile mobile = World.FindMobile(serial);

                        if (mobile != null)
                        {
                            Targeting.Target(mobile);
                        }
                    }

                    break;
            }

            return true;
        }

        private static bool TargetType(string command, Variable[] vars, bool quiet, bool force)
        {
            if (Targeting.FromGrabHotKey)
                return false;

            if (vars.Length < 1)
            {
                throw new RunTimeError("Usage: targettype ('name of item or mobile type'/'graphicId') [inrangecheck (true/false)/backpack] [hue]");
            }

            string gfxStr = vars[0].AsString();
            Serial gfx = Utility.ToUInt16(gfxStr, 0);
            List<Item> items;
            List<Mobile> mobiles = new List<Mobile>();

            bool inRangeCheck = false;
            bool backpack = false;
            int hue = -1;

            if (vars.Length > 1)
            {
                if (vars.Length == 3)
                {
                    hue = vars[2].AsInt();
                }

                if (vars[1].AsString().IndexOf("pack", StringComparison.OrdinalIgnoreCase) != -1)
                {
                    backpack = true;
                }
                else
                {
                    inRangeCheck = vars[1].AsBool();
                }
            }

            // No graphic id, maybe searching by name?
            if (gfx == 0)
            {
                items = CommandHelper.GetItemsByName(gfxStr, backpack, inRangeCheck, hue);

                if (items.Count == 0) // no item found, search mobile by name
                {
                    mobiles = CommandHelper.GetMobilesByName(gfxStr, inRangeCheck);
                }
            }
            else // Provided graphic id for type, check backpack first (same behavior as DoubleClickAction in macros
            {
                ushort id = Utility.ToUInt16(gfxStr, 0);

                items = CommandHelper.GetItemsById(id, backpack, inRangeCheck, hue);

                // Still no item? Mobile check!
                if (items.Count == 0)
                {
                    mobiles = CommandHelper.GetMobilesById(id, inRangeCheck);
                }
            }

            if (items.Count > 0)
            {
                Targeting.Target(items[Utility.Random(items.Count)]);
            }
            else if (mobiles.Count > 0)
            {
                Targeting.Target(mobiles[Utility.Random(mobiles.Count)]);
            }
            else
            {
                CommandHelper.SendWarning(command, $"Item or mobile type '{gfxStr}' not found", quiet);
            }

            return true;
        }

        private static bool TargetRelLoc(string command, Variable[] vars, bool quiet, bool force)
        {
            if (Targeting.FromGrabHotKey)
                return false;

            if (vars.Length < 2)
            {
                throw new RunTimeError("Usage: targetrelloc (x-offset) (y-offset)");
            }

            int xoffset = Utility.ToInt32(vars[0].AsString(), 0);
            int yoffset = Utility.ToInt32(vars[1].AsString(), 0);

            ushort x = (ushort) (World.Player.Position.X + xoffset);
            ushort y = (ushort) (World.Player.Position.Y + yoffset);
            short z = (short) World.Player.Position.Z;

            try
            {
                Ultima.HuedTile tile = Map.GetTileNear(World.Player.Map, x, y, z);
                Targeting.Target(new Point3D(x, y, tile.Z), tile.ID);
            }
            catch (Exception e)
            {
                throw new RunTimeError($"{command} - Error Executing: {e.Message}");
            }

            return true;
        }

        private static bool TargetLocation(string command, Variable[] vars, bool quiet, bool force)
        {
            if (vars.Length < 2)
            {
                throw new RunTimeError("Usage: targetloc (x) (y) (z)");
            }

            Targeting.Target(new TargetInfo
            {
                Type = 1,
                Flags = 0,
                Serial = Serial.Zero,
                X = vars[0].AsInt(),
                Y = vars[1].AsInt(),
                Z = vars.Length == 3 ? vars[2].AsInt() : 0,
                Gfx = 0
            });

            return true;
        }

        private static bool WaitForTarget(string command, Variable[] vars, bool quiet, bool force)
        {
            if (Targeting.HasTarget)
            {
                Interpreter.ClearTimeout();
                return true;
            }

            Interpreter.Timeout(vars.Length > 0 ? vars[0].AsUInt() : 30000, () => { return true; });

            return false;
        }
    }
}

================================================
FILE: Razor/UI/AddCounter.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Windows.Forms;
using Assistant.UI;

namespace Assistant
{
    /// <summary>
    /// Summary description for AddCounter.
    /// </summary>
    public class AddCounter : System.Windows.Forms.Form
    {
        private System.Windows.Forms.Label label1;
        private System.Windows.Forms.TextBox name;
        private System.Windows.Forms.Label label2;
        private System.Windows.Forms.TextBox format;
        private System.Windows.Forms.Label label3;
        private System.Windows.Forms.TextBox itemid;
        private System.Windows.Forms.Label label4;
        private System.Windows.Forms.TextBox hue;
        private System.Windows.Forms.Button Add;
        private System.Windows.Forms.Button cancel;
        private System.Windows.Forms.Button target;
        private System.Windows.Forms.Button delete;
        private System.Windows.Forms.CheckBox dispImg;

        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.Container components = null;

        public AddCounter()
        {
            //
            // Required for Windows Form Designer support
            //
            InitializeComponent();
        }

        public AddCounter(Counter c) : this()
        {
            name.Text = c.Name;
            format.Text = c.Format;
            itemid.Text = c.ItemID.ToString();
            hue.Text = c.Hue.ToString();
            dispImg.Checked = c.DisplayImage;

            delete.Visible = true;
            this.Text = "Edit Counter";
        }

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (components != null)
                {
                    components.Dispose();
                }
            }

            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.label1 = new System.Windows.Forms.Label();
            this.name = new System.Windows.Forms.TextBox();
            this.label2 = new System.Windows.Forms.Label();
            this.format = new System.Windows.Forms.TextBox();
            this.label3 = new System.Windows.Forms.Label();
            this.itemid = new System.Windows.Forms.TextBox();
            this.label4 = new System.Windows.Forms.Label();
            this.hue = new System.Windows.Forms.TextBox();
            this.Add = new System.Windows.Forms.Button();
            this.cancel = new System.Windows.Forms.Button();
            this.target = new System.Windows.Forms.Button();
            this.delete = new System.Windows.Forms.Button();
            this.dispImg = new System.Windows.Forms.CheckBox();
            this.SuspendLayout();
            // 
            // label1
            // 
            this.label1.AutoSize = true;
            this.label1.Location = new System.Drawing.Point(12, 9);
            this.label1.Name = "label1";
            this.label1.Size = new System.Drawing.Size(42, 15);
            this.label1.TabIndex = 0;
            this.label1.Text = "Name:";
            this.label1.TextAlign = System.Drawing.ContentAlignment.MiddleLeft;
            // 
            // name
            // 
            this.name.Location = new System.Drawing.Point(60, 6);
            this.name.Name = "name";
            this.name.Size = new System.Drawing.Size(85, 23);
            this.name.TabIndex = 1;
            // 
            // label2
            // 
            this.label2.AutoSize = true;
            this.label2.Location = new System.Drawing.Point(151, 9);
            this.label2.Name = "label2";
            this.label2.Size = new System.Drawing.Size(48, 15);
            this.label2.TabIndex = 2;
            this.label2.Text = "Format:";
            this.label2.TextAlign = System.Drawing.ContentAlignment.MiddleLeft;
            // 
            // format
            // 
            this.format.Location = new System.Drawing.Point(205, 6);
            this.format.Name = "format";
            this.format.Size = new System.Drawing.Size(94, 23);
            this.format.TabIndex = 3;
            // 
            // label3
            // 
            this.label3.AutoSize = true;
            this.label3.Location = new System.Drawing.Point(6, 38);
            this.label3.Name = "label3";
            this.label3.Size = new System.Drawing.Size(48, 15);
            this.label3.TabIndex = 4;
            this.label3.Text = "Item ID:";
            this.label3.TextAlign = System.Drawing.ContentAlignment.MiddleLeft;
            // 
            // itemid
            // 
            this.itemid.Location = new System.Drawing.Point(60, 35);
            this.itemid.Name = "itemid";
            this.itemid.Size = new System.Drawing.Size(85, 23);
            this.itemid.TabIndex = 5;
            // 
            // label4
            // 
            this.label4.AutoSize = true;
            this.label4.Location = new System.Drawing.Point(151, 38);
            this.label4.Name = "label4";
            this.label4.Size = new System.Drawing.Size(88, 15);
            this.label4.TabIndex = 6;
            this.label4.Text = "Color (Any: -1):";
            this.label4.TextAlign = System.Drawing.ContentAlignment.MiddleLeft;
            // 
            // hue
            // 
            this.hue.Location = new System.Drawing.Point(245, 35);
            this.hue.Name = "hue";
            this.hue.Size = new System.Drawing.Size(54, 23);
            this.hue.TabIndex = 7;
            // 
            // Add
            // 
            this.Add.DialogResult = System.Windows.Forms.DialogResult.OK;
            this.Add.Location = new System.Drawing.Point(9, 90);
            this.Add.Name = "Add";
            this.Add.Size = new System.Drawing.Size(68, 34);
            this.Add.TabIndex = 8;
            this.Add.Text = "&Okay";
            this.Add.Click += new System.EventHandler(this.Add_Click);
            // 
            // cancel
            // 
            this.cancel.DialogResult = System.Windows.Forms.DialogResult.Cancel;
            this.cancel.Location = new System.Drawing.Point(83, 90);
            this.cancel.Name = "cancel";
            this.cancel.Size = new System.Drawing.Size(68, 34);
            this.cancel.TabIndex = 9;
            this.cancel.Text = "Cancel";
            this.cancel.Click += new System.EventHandler(this.cancel_Click);
            // 
            // target
            // 
            this.target.Location = new System.Drawing.Point(231, 90);
            this.target.Name = "target";
            this.target.Size = new System.Drawing.Size(68, 34);
            this.target.TabIndex = 10;
            this.target.Text = "Target ";
            this.target.Click += new System.EventHandler(this.target_Click);
            // 
            // delete
            // 
            this.delete.Location = new System.Drawing.Point(157, 90);
            this.delete.Name = "delete";
            this.delete.Size = new System.Drawing.Size(68, 34);
            this.delete.TabIndex = 11;
            this.delete.Text = "Delete";
            this.delete.Visible = false;
            this.delete.Click += new System.EventHandler(this.delete_Click);
            // 
            // dispImg
            // 
            this.dispImg.Checked = true;
            this.dispImg.CheckState = System.Windows.Forms.CheckState.Checked;
            this.dispImg.Location = new System.Drawing.Point(9, 64);
            this.dispImg.Name = "dispImg";
            this.dispImg.Size = new System.Drawing.Size(160, 20);
            this.dispImg.TabIndex = 12;
            this.dispImg.Text = "Display image in titlebar";
            // 
            // AddCounter
            // 
            this.AcceptButton = this.Add;
            this.AutoScaleBaseSize = new System.Drawing.Size(6, 16);
            this.ClientSize = new System.Drawing.Size(308, 133);
            this.ControlBox = false;
            this.Controls.Add(this.dispImg);
            this.Controls.Add(this.hue);
            this.Controls.Add(this.itemid);
            this.Controls.Add(this.format);
            this.Controls.Add(this.name);
            this.Controls.Add(this.delete);
            this.Controls.Add(this.target);
            this.Controls.Add(this.cancel);
            this.Controls.Add(this.Add);
            this.Controls.Add(this.label4);
            this.Controls.Add(this.label3);
            this.Controls.Add(this.label2);
            this.Controls.Add(this.label1);
            this.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular,
                System.Drawing.GraphicsUnit.Point, ((byte) (0)));
            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog;
            this.Name = "AddCounter";
            this.ShowInTaskbar = false;
            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
            this.Text = "Add a Counter";
            this.Load += new System.EventHandler(this.AddCounter_Load);
            this.ResumeLayout(false);
            this.PerformLayout();
        }

        #endregion

        public string NameStr, FmtStr;
        public int ItemID, Hue;
        public bool DisplayImage;

        private void Add_Click(object sender, System.EventArgs e)
        {
            if (name.Text.Trim().Length > 0 && format.Text.Trim().Length > 0)
            {
                NameStr = name.Text.Trim();
                FmtStr = format.Text.Trim();
            }
            else
            {
                MessageBox.Show(this, Language.GetString(LocString.InvalidAbrev), "Error", MessageBoxButtons.OK,
                    MessageBoxIcon.Information);
                return;
            }

            try
            {
                if (itemid.Text.StartsWith("0x"))
                    ItemID = Convert.ToUInt16(itemid.Text.Substring(2).Trim(), 16);
                else
                    ItemID = Convert.ToUInt16(itemid.Text.Trim());
            }
            catch
            {
                ItemID = 0;
            }

            if (ItemID == 0)
            {
                MessageBox.Show(this, Language.GetString(LocString.InvalidIID), "Error", MessageBoxButtons.OK,
                    MessageBoxIcon.Information);
                return;
            }

            Hue = Utility.ToInt32(hue.Text, -1);

            if (Hue < -1 || Hue > 0xFFFF)
            {
                MessageBox.Show(this, Language.GetString(LocString.InvalidHue), "Error", MessageBoxButtons.OK,
                    MessageBoxIcon.Information);
                Hue = 0;
                return;
            }

            DisplayImage = dispImg.Checked;
        }

        private void cancel_Click(object sender, System.EventArgs e)
        {
            Targeting.CancelOneTimeTarget();
        }

        private void target_Click(object sender, System.EventArgs e)
        {
            if (World.Player != null)
            {
                Targeting.OneTimeTarget(new Targeting.TargetResponseCallback(OnTarget));
                World.Player.SendMessage(MsgLevel.Force, LocString.SelItem2Count);
            }
        }

        private void OnTarget(bool loc, Serial serial, Point3D p, ushort graphic)
        {
            Engine.MainWindow.SafeAction(s => s.ShowMe());
            this.BringToFront();
            this.Show();
            this.Focus();
            if (loc)
                return;

            Item item = World.FindItem(serial);
            if (item != null)
            {
                itemid.Text = item.ItemID.Value.ToString();
                hue.Text = item.Hue == 0 ? "-1" : item.Hue.ToString();
            }
            else
            {
                itemid.Text = graphic.ToString();
                hue.Text = "-1";
            }
        }

        private void AddCounter_Load(object sender, System.EventArgs e)
        {
            Language.LoadControlNames(this);
        }

        private void delete_Click(object sender, System.EventArgs e)
        {
            if (MessageBox.Show(this, "Are you sure you want to delete this counter?", "Delete Confirm",
                    MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
            {
                this.DialogResult = DialogResult.Abort;
                this.Close();
            }
        }
    }
}

================================================
FILE: Razor/UI/AddCounter.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
</root>

================================================
FILE: Razor/UI/ArtViewer.Designer.cs
================================================
using System.ComponentModel;

namespace Assistant.UI
{
    partial class ArtViewer
    {
        /// <summary> 
        /// Required designer variable.
        /// </summary>
        private IContainer components = null;

        /// <summary> 
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        /*protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }

            base.Dispose(disposing);
        }
        */

        #region Component Designer generated code

        /// <summary> 
        /// Required method for Designer support - do not modify 
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            components = new System.ComponentModel.Container();
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
        }

        #endregion
    }
}

================================================
FILE: Razor/UI/ArtViewer.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Windows.Forms;
using Ultima;

namespace Assistant.UI
{
	public enum Art
	{
		/// <summary>
		///     Static items
		/// </summary>
		Items = 0,

		/// <summary>
		///     Characters ( animated or not )
		/// </summary>
		NPCs = 1,

		/// <summary>
		///     Gumps
		/// </summary>
		Gumps = 2,

		/// <summary>
		///     Images
		/// </summary>
		Images = 3
	}
	
    public partial class ArtViewer : UserControl
    {
       
        
	    #region events
		/// <summary>
		///     Occurs when the index of the displayed art is changed
		/// </summary>
		public event EventHandler ArtIndexChanged;
		#endregion

		#region Variables
		/// <summary>
		///     The art type currently displayed
		/// </summary>
		private Art m_Art = Art.Items;

		/// <summary>
		///     The index of the art to display
		/// </summary>
		private int m_ArtIndex;

		/// <summary>
		///     Animate characters or not
		/// </summary>
		private bool m_Animate;

		/// <summary>
		///     The hue for the current item
		/// </summary>
		private int m_Hue;

		/// <summary>
		///     Resize images that are larger than the control area
		/// </summary>
		private bool m_ResizeTallItems;

		/// <summary>
		///     Display the axes when showing items
		/// </summary>
		private bool m_RoomView = true;

		/// <summary>
		///     The image currently displayed
		/// </summary>
		private Bitmap m_Image;

		/// <summary>
		///     Image is invalidated and needs to be redrawn
		/// </summary>
		private bool m_ImageInvalidated = true;

		/// <summary>
		///     The bitmaps used for the animation
		/// </summary>
		private Bitmap[] m_Animation;

		/// <summary>
		///     The timer for the animation
		/// </summary>
		private Timer m_Timer;

		/// <summary>
		///     Current animation index
		/// </summary>
		private int m_FrameIndex;

		/// <summary>
		///     Shows the ID in the lower right corner
		/// </summary>
		private bool m_ShowID = true;

		/// <summary>
		///     Shows the ID in hex format in the lower left corner
		/// </summary>
		private bool m_ShowHexID = true;
		#endregion

		#region Properties
		/// <summary>
		///     Sets the image that should be displayed by the viewer
		/// </summary>
		public Image DisplayedImage
		{
			set
			{
				if (value != null)
				{
					//StopAnimation();

					if (m_Image != null)
						m_Image.Dispose();

					m_Image = new Bitmap(value);

					m_Art = Art.Images;

					m_ImageInvalidated = false;
					Refresh();
				}
			}
		}

		/// <summary>
		///     Gets or sets the art type displayed by the control
		/// </summary>
		public Art Art
		{
			get { return m_Art; }
			set
			{
				if (m_Art != value)
				{
					if (value == Art.Images)
						return;

					m_Art = value;

					//StopAnimation();
					m_ImageInvalidated = true;
					Refresh();
				}
			}
		}

		/// <summary>
		///     Gets or sets the index of the currently displayed art
		/// </summary>
		public int ArtIndex
		{
			get { return m_ArtIndex; }
			set
			{
				if (value != m_ArtIndex)
				{
					m_ArtIndex = value;

					//StopAnimation();
					m_ImageInvalidated = true;
					Refresh();

					if (ArtIndexChanged != null)
					{
						ArtIndexChanged(this, new EventArgs());
					}
				}
			}
		}

		/// <summary>
		///     Gets or sets a value stating whether the character display is going to be animated
		/// </summary>
		public bool Animate
		{
			get { return m_Animate; }
			set
			{
				if (m_Animate != value)
				{
					m_Animate = value;

					if (m_Art == Art.NPCs)
					{
						//StopAnimation();
						m_ImageInvalidated = true;
						Refresh();
					}
				}
			}
		}

		/// <summary>
		///     Gets or sets the hue for the current image
		/// </summary>
		public int Hue
		{
			get { return m_Hue; }
			set
			{
				if (m_Hue == value)
					return;

				m_Hue = value;

				if (m_Hue < 0)
					m_Hue = 0;

				if (m_Hue > 2999)
					m_Hue = 2999;

				//StopAnimation();
				m_ImageInvalidated = true;
				Refresh();
			}
		}

		/// <summary>
		///     Gets or sets a value stating whether items larger than the display area should be resized
		/// </summary>
		public bool ResizeTallItems
		{
			get { return m_ResizeTallItems; }
			set
			{
				if (m_ResizeTallItems != value)
				{
					m_ResizeTallItems = value;

					Refresh();
				}
			}
		}

		/// <summary>
		///     Gets or sets a value stating whether the display of static items will show the
		/// </summary>
		public bool RoomView
		{
			get { return m_RoomView; }
			set
			{
				if (m_RoomView != value)
				{
					m_RoomView = value;

					Refresh();
				}
			}
		}

		public bool ShowID
		{
			get { return m_ShowID; }
			set
			{
				if (m_ShowID != value)
				{
					m_ShowID = value;

					Refresh();
				}
			}
		}

		public bool ShowHexID
		{
			get { return m_ShowHexID; }
			set
			{
				if (m_ShowHexID != value)
				{
					m_ShowHexID = value;
					Refresh();
				}
			}
		}
		#endregion
        
        public ArtViewer()
        {
            InitializeComponent();
        }
        
        /// <summary>
		///     Clean up any resources being used.
		/// </summary>
		protected override void Dispose(bool disposing)
		{
			base.Dispose(disposing);

			if (m_Image != null)
			{
				m_Image.Dispose();
				m_Image = null;
			}
		}

		protected override void OnPaint(PaintEventArgs e)
		{
			base.OnPaint(e);

			if (m_ImageInvalidated)
				CreateDisplay();

			if (m_Image != null)
			{
				// Position image
				var location = Point.Empty;
				var size = Size.Empty;

				if (m_Image.Width <= Width && m_Image.Height <= Height)
				{
					// Image fits
					size = m_Image.Size;
					location.X = (Width - m_Image.Width) / 2;
					location.Y = (Height - m_Image.Height) / 2;
				}
				else
				{
					if (m_ResizeTallItems)
					{
						size = m_Image.Size;

						var rate = m_Image.Width / (double)m_Image.Height;

						// Resize
						if (size.Width > Width)
						{
							size.Width = Width;
							size.Height = (int)(size.Width / rate);
						}

						if (size.Height > Height)
						{
							size.Height = Height;
							size.Width = (int)(size.Height * rate);
						}

						location.X = (Width - size.Width) / 2;
						location.Y = (Height - size.Height) / 2;
					}
					else
					{
						location.X = (Width - m_Image.Width) / 2;
						location.Y = (Height - m_Image.Height) / 2;
						size = m_Image.Size;
					}
				}

				var destRect = new Rectangle(location, size);

				if (m_Art == Art.Items && m_RoomView)
				{
					DrawRoomView(e.Graphics, destRect);
				}

				e.Graphics.DrawImage(m_Image, destRect, 0, 0, m_Image.Width, m_Image.Height, GraphicsUnit.Pixel);
			}
			else
			{
				if (m_Art == Art.Items && m_RoomView)
					DrawRoomView(e.Graphics, new Rectangle((Width - 44) / 2, (Height - 44) / 2, 44, 44));
			}

			// ID
			var black = new Pen(SystemColors.ControlDark);

			if ((m_ShowID || m_ShowHexID) && m_Art != Art.Images)
			{
				Brush back = new SolidBrush(SystemColors.Window);
				Brush text = new SolidBrush(SystemColors.WindowText);

				var font = new Font("Verdana", 8.0f);
				var id = m_ArtIndex.ToString();
				var hex = m_ArtIndex.ToString("X");

				if (m_ShowID)
				{
					var siz = e.Graphics.MeasureString(id, font);

					var s = siz.ToSize();
					s.Width += 4;
					siz.Height += 4;

					var x = Width - s.Width - 4;
					var y = Height - s.Height - 4;

					var r = new RectangleF(x + 2, y, siz.Width, siz.Height);

					e.Graphics.FillRectangle(back, x, y, s.Width, s.Height);
					e.Graphics.DrawRectangle(black, x, y, s.Width, s.Height);
					e.Graphics.DrawString(id, font, text, r);
				}

				if (m_ShowHexID)
				{
					var siz = e.Graphics.MeasureString(hex, font);

					var s = siz.ToSize();
					s.Width += 4;
					siz.Height += 4;

					var y = Height - s.Height - 4;

					var r = new RectangleF(6, y, siz.Width, siz.Height);

					e.Graphics.FillRectangle(back, 4, y, s.Width, s.Height);
					e.Graphics.DrawRectangle(black, 4, y, s.Width, s.Height);
					e.Graphics.DrawString(hex, font, text, r);
				}

				text.Dispose();
				back.Dispose();
				font.Dispose();
			}

			// Border

			e.Graphics.DrawRectangle(black, 0, 0, Width - 1, Height - 1);
			black.Dispose();
		}

		#region Room View
		/// <summary>
		///     Draws the room view
		/// </summary>
		/// <param name="g">The graphics used to draw the room view</param>
		/// <param name="imgRect">The rectangle the image will occupy on the display</param>
		private void DrawRoomView(Graphics g, Rectangle imgRect)
		{
			var bottom = Point.Empty;
			var top = Point.Empty;
			var left = Point.Empty;
			var right = Point.Empty;

			bottom.X = imgRect.X + (imgRect.Width / 2);
			bottom.Y = imgRect.Bottom;

			top.X = bottom.X;
			top.Y = bottom.Y - imgRect.Width;

			left.X = imgRect.X;
			left.Y = imgRect.Bottom - (imgRect.Width / 2);

			right.X = imgRect.Right;
			right.Y = left.Y;

			// top points
			var top1 = Point.Empty;
			var top2 = Point.Empty;
			var top3 = Point.Empty;

			top1.Y = top2.Y = top3.Y = 0;
			top1.X = left.X;
			top2.X = top.X;
			top3.X = right.X;

			var blackPen = new Pen(Color.Black);
			Brush whiteBrush = new LinearGradientBrush(top, right, Color.DarkSlateBlue, Color.SkyBlue);

			// Draw base block
			var baseBlock = new[] {top, right, bottom, left, top};
			g.FillPolygon(whiteBrush, baseBlock);

			// Fill
			var leftArea = new[] {left, top1, top2, top, left};
			var rightArea = new[] {top, top2, top3, right, top};

			Brush darkBrush = new LinearGradientBrush(left, top1, Color.MidnightBlue, Color.LightGray);
			Brush lightBrush = new LinearGradientBrush(right, top3, Color.SteelBlue, Color.White);

			g.FillPolygon(darkBrush, leftArea);
			g.FillPolygon(lightBrush, rightArea);

			// Draw base
			g.DrawLines(blackPen, baseBlock);

			// Draw vertical lines
			g.DrawLine(blackPen, left, top1);
			g.DrawLine(blackPen, top, top2);
			g.DrawLine(blackPen, right, top3);

			// Draw top line
			g.DrawLine(blackPen, top1, top3);

			// Draw axes
			g.DrawLine(blackPen, right, GetIntersection(bottom, right));
			g.DrawLine(blackPen, right, GetIntersection(top, right));
			g.DrawLine(blackPen, left, GetIntersection(bottom, left));
			g.DrawLine(blackPen, left, GetIntersection(top, left));

			blackPen.Dispose();
			whiteBrush.Dispose();
			darkBrush.Dispose();
			lightBrush.Dispose();
		}

		/// <summary>
		///     Gets the intersection point with the control bounds following a line from p2
		/// </summary>
		/// <param name="p1">the starting point of the line</param>
		/// <param name="p2">the middle point of the line, used to define it</param>
		/// <returns>A point on the bounds of the control</returns>
		private Point GetIntersection(Point p1, Point p2)
		{
			var a = ((p1.Y - p2.Y) / (double)(p1.X - p2.X));
			var b = p1.Y - (a * p1.X);

			if (p1.X < p2.X)
			{
				// Right side
				var pRight = Point.Empty;

				pRight.X = Width;
				pRight.Y = (int)(Width * a + b);

				if (pRight.Y < 0)
				{
					pRight.Y = 0;
					pRight.X = (int)-(b / a);
				}

				return pRight;
			}
			var pLeft = Point.Empty;

			if (b < 0)
			{
				pLeft.Y = 0;
				pLeft.X = (int)(-b / a);
			}
			else
			{
				pLeft.Y = (int)b;
				pLeft.X = 0;
			}

			return pLeft;
		}
		#endregion

		protected override void OnResize(EventArgs e)
		{
			base.OnResize(e);

			Refresh();
		}

		/// <summary>
		///     Calculates the image displayed by the control
		/// </summary>
		private void CreateDisplay()
		{
			if (m_Image != null)
			{
				m_Image.Dispose();
			}

			switch (m_Art)
			{
				case Art.Items:

					try
					{
						m_Image = new Bitmap(Ultima.Art.GetStatic(m_ArtIndex));
					}
					catch
					{
						m_Image = null;
					}

					break;

				/*case Art.Gumps:

					try
					{
						m_Image = new Bitmap(Gumps.GetGump(m_ArtIndex));
					}
					catch
					{
						m_Image = null;
					}

					break;*/

				case Art.NPCs:

					try
					{
						if (m_Animate)
						{
							//m_Image = DoAnimation();
						}
						else
						{
							var hue = m_Hue;

							var frames = Animations.GetAnimation(m_ArtIndex, 0, 1, ref hue, true, true);

							if (frames != null)
								m_Image = new Bitmap(frames[0].Bitmap);
							else
								m_Image = null;
						}
					}
					catch
					{
						m_Image = null;
					}

					break;
			}

			//
			// Hue
			//
			if (m_Hue > 0 && m_Image != null && m_Art != Art.Images)
			{
				if (m_Art != Art.NPCs || (m_Art == Art.NPCs && !m_Animate))
				{
					var hue = Hues.GetHue(m_Hue - 1);

					if (hue != null)
					{
						Hues.ApplyTo(m_Image, hue.Colors, m_Art == Art.Gumps);
					}
				}
			}
		}

		/// <summary>
		///     Sets up the animation
		/// </summary>
		/// <returns>The current image</returns>
		/*private Bitmap DoAnimation()
		{
			if (m_Timer == null)
			{
				// Create the animation
				var frames = Animations.GetAnimation(m_ArtIndex, 0, 1, ref m_Hue, true, false);

				if (frames == null)
					return null;

				var count = frames.Length;
				m_Animation = new Bitmap[count];

				for (var i = 0; i < count; i++)
				{
					m_Animation[i] = frames[i].Bitmap;
				}

				m_Timer = new Timer();
				m_Timer.Interval = 1000 / count;
				m_Timer.Tick += AnimTick;
				m_Timer.Start();

				m_FrameIndex = 0;
				return new Bitmap(m_Animation[0]);
			}
			return new Bitmap(m_Animation[m_FrameIndex]);
		}

		private void AnimTick(object sender, EventArgs e)
		{
			m_FrameIndex++;

			if (m_FrameIndex == m_Animation.Length)
				m_FrameIndex = 0;

			m_ImageInvalidated = true;
			Refresh();
		}

		/// <summary>
		///     Stops the current animation
		/// </summary>
		private void StopAnimation()
		{
			if (m_Timer != null)
			{
				if (m_Timer.Enabled)
					m_Timer.Stop();

				m_Timer.Dispose();
				m_Timer = null;
			}

			if (m_Animation != null)
			{
				for (var i = 0; i < m_Animation.Length; i++)
					if (m_Animation[i] != null)
						m_Animation[i].Dispose();
			}

			m_Animation = null;
			m_FrameIndex = 0;
		}*/
    }
}

================================================
FILE: Razor/UI/BuffDebuffOptions.Designer.cs
================================================
namespace Assistant.UI
{
    partial class BuffDebuffOptions
    {
        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(BuffDebuffOptions));
            this.grpFilter = new System.Windows.Forms.GroupBox();
            this.removeFilter = new System.Windows.Forms.Button();
            this.addFilter = new System.Windows.Forms.Button();
            this.buffDebuffFilters = new System.Windows.Forms.ListBox();
            this.lblSeconds = new System.Windows.Forms.Label();
            this.buffDebuffSeconds = new System.Windows.Forms.TextBox();
            this.displayBuffDebuffEvery = new System.Windows.Forms.CheckBox();
            this.buffDebuffFormat = new System.Windows.Forms.TextBox();
            this.setDebuffHue = new System.Windows.Forms.Button();
            this.lblDebuffHue = new System.Windows.Forms.Label();
            this.setBuffHue = new System.Windows.Forms.Button();
            this.lblBuffHue = new System.Windows.Forms.Label();
            this.buffFormatKey = new System.Windows.Forms.Button();
            this.okClose = new System.Windows.Forms.Button();
            this.overrideBuffDebuffFormat = new System.Windows.Forms.CheckBox();
            this.grpFilter.SuspendLayout();
            this.SuspendLayout();
            // 
            // grpFilter
            // 
            this.grpFilter.Controls.Add(this.removeFilter);
            this.grpFilter.Controls.Add(this.addFilter);
            this.grpFilter.Controls.Add(this.buffDebuffFilters);
            this.grpFilter.Location = new System.Drawing.Point(12, 12);
            this.grpFilter.Name = "grpFilter";
            this.grpFilter.Size = new System.Drawing.Size(319, 140);
            this.grpFilter.TabIndex = 65;
            this.grpFilter.TabStop = false;
            this.grpFilter.Text = "Filter:";
            // 
            // removeFilter
            // 
            this.removeFilter.Location = new System.Drawing.Point(230, 57);
            this.removeFilter.Name = "removeFilter";
            this.removeFilter.Size = new System.Drawing.Size(83, 29);
            this.removeFilter.TabIndex = 76;
            this.removeFilter.Text = "Remove";
            this.removeFilter.UseVisualStyleBackColor = true;
            this.removeFilter.Click += new System.EventHandler(this.RemoveFilter_Click);
            // 
            // addFilter
            // 
            this.addFilter.Location = new System.Drawing.Point(230, 22);
            this.addFilter.Name = "addFilter";
            this.addFilter.Size = new System.Drawing.Size(83, 29);
            this.addFilter.TabIndex = 75;
            this.addFilter.Text = "Add";
            this.addFilter.UseVisualStyleBackColor = true;
            this.addFilter.Click += new System.EventHandler(this.AddFilter_Click);
            // 
            // buffDebuffFilters
            // 
            this.buffDebuffFilters.FormattingEnabled = true;
            this.buffDebuffFilters.ItemHeight = 15;
            this.buffDebuffFilters.Location = new System.Drawing.Point(6, 22);
            this.buffDebuffFilters.Name = "buffDebuffFilters";
            this.buffDebuffFilters.Size = new System.Drawing.Size(218, 109);
            this.buffDebuffFilters.TabIndex = 74;
            // 
            // lblSeconds
            // 
            this.lblSeconds.AutoSize = true;
            this.lblSeconds.Location = new System.Drawing.Point(225, 213);
            this.lblSeconds.Name = "lblSeconds";
            this.lblSeconds.Size = new System.Drawing.Size(50, 15);
            this.lblSeconds.TabIndex = 82;
            this.lblSeconds.Text = "seconds";
            // 
            // buffDebuffSeconds
            // 
            this.buffDebuffSeconds.Location = new System.Drawing.Point(175, 210);
            this.buffDebuffSeconds.Name = "buffDebuffSeconds";
            this.buffDebuffSeconds.Size = new System.Drawing.Size(47, 23);
            this.buffDebuffSeconds.TabIndex = 81;
            this.buffDebuffSeconds.Text = "20";
            this.buffDebuffSeconds.TextAlign = System.Windows.Forms.HorizontalAlignment.Center;
            this.buffDebuffSeconds.TextChanged += new System.EventHandler(this.BuffDebuffSeconds_TextChanged);
            // 
            // displayBuffDebuffEvery
            // 
            this.displayBuffDebuffEvery.AutoSize = true;
            this.displayBuffDebuffEvery.Location = new System.Drawing.Point(18, 212);
            this.displayBuffDebuffEvery.Name = "displayBuffDebuffEvery";
            this.displayBuffDebuffEvery.Size = new System.Drawing.Size(160, 19);
            this.displayBuffDebuffEvery.TabIndex = 80;
            this.displayBuffDebuffEvery.Text = "Display buff/debuff every";
            this.displayBuffDebuffEvery.UseVisualStyleBackColor = true;
            this.displayBuffDebuffEvery.CheckedChanged += new System.EventHandler(this.DisplayBuffDebuffEvery_CheckedChanged);
            // 
            // buffDebuffFormat
            // 
            this.buffDebuffFormat.Location = new System.Drawing.Point(18, 183);
            this.buffDebuffFormat.Name = "buffDebuffFormat";
            this.buffDebuffFormat.Size = new System.Drawing.Size(224, 23);
            this.buffDebuffFormat.TabIndex = 79;
            this.buffDebuffFormat.Text = "[{action}{name} {duration}]";
            this.buffDebuffFormat.TextAlign = System.Windows.Forms.HorizontalAlignment.Center;
            this.buffDebuffFormat.TextChanged += new System.EventHandler(this.BuffDebuffFormat_TextChanged);
            // 
            // setDebuffHue
            // 
            this.setDebuffHue.Location = new System.Drawing.Point(175, 260);
            this.setDebuffHue.Name = "setDebuffHue";
            this.setDebuffHue.Size = new System.Drawing.Size(47, 20);
            this.setDebuffHue.TabIndex = 78;
            this.setDebuffHue.Text = "Set";
            this.setDebuffHue.Click += new System.EventHandler(this.SetDebuffHue_Click);
            // 
            // lblDebuffHue
            // 
            this.lblDebuffHue.Location = new System.Drawing.Point(15, 262);
            this.lblDebuffHue.Name = "lblDebuffHue";
            this.lblDebuffHue.Size = new System.Drawing.Size(207, 18);
            this.lblDebuffHue.TabIndex = 77;
            this.lblDebuffHue.Text = "Debuff Hue:";
            // 
            // setBuffHue
            // 
            this.setBuffHue.Location = new System.Drawing.Point(175, 237);
            this.setBuffHue.Name = "setBuffHue";
            this.setBuffHue.Size = new System.Drawing.Size(47, 20);
            this.setBuffHue.TabIndex = 76;
            this.setBuffHue.Text = "Set";
            this.setBuffHue.Click += new System.EventHandler(this.SetBuffHue_Click);
            // 
            // lblBuffHue
            // 
            this.lblBuffHue.Location = new System.Drawing.Point(15, 239);
            this.lblBuffHue.Name = "lblBuffHue";
            this.lblBuffHue.Size = new System.Drawing.Size(207, 18);
            this.lblBuffHue.TabIndex = 75;
            this.lblBuffHue.Text = "Buff Hue:";
            // 
            // buffFormatKey
            // 
            this.buffFormatKey.Location = new System.Drawing.Point(248, 183);
            this.buffFormatKey.Name = "buffFormatKey";
            this.buffFormatKey.Size = new System.Drawing.Size(16, 23);
            this.buffFormatKey.TabIndex = 84;
            this.buffFormatKey.Text = "?";
            this.buffFormatKey.UseVisualStyleBackColor = true;
            this.buffFormatKey.Click += new System.EventHandler(this.BuffFormatKey_Click);
            // 
            // okClose
            // 
            this.okClose.Location = new System.Drawing.Point(248, 251);
            this.okClose.Name = "okClose";
            this.okClose.Size = new System.Drawing.Size(83, 29);
            this.okClose.TabIndex = 85;
            this.okClose.Text = "OK";
            this.okClose.UseVisualStyleBackColor = true;
            this.okClose.Click += new System.EventHandler(this.OkClose_Click);
            // 
            // overrideBuffDebuffFormat
            // 
            this.overrideBuffDebuffFormat.AutoSize = true;
            this.overrideBuffDebuffFormat.Location = new System.Drawing.Point(18, 158);
            this.overrideBuffDebuffFormat.Name = "overrideBuffDebuffFormat";
            this.overrideBuffDebuffFormat.Size = new System.Drawing.Size(175, 19);
            this.overrideBuffDebuffFormat.TabIndex = 86;
            this.overrideBuffDebuffFormat.Text = "Override buff/debuff format";
            this.overrideBuffDebuffFormat.UseVisualStyleBackColor = true;
            this.overrideBuffDebuffFormat.CheckedChanged += new System.EventHandler(this.overrideBuffDebuffFormat_CheckedChanged);
            // 
            // BuffDebuff
            // 
            this.AutoScaleDimensions = new System.Drawing.SizeF(7F, 15F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.ClientSize = new System.Drawing.Size(341, 291);
            this.Controls.Add(this.overrideBuffDebuffFormat);
            this.Controls.Add(this.okClose);
            this.Controls.Add(this.buffFormatKey);
            this.Controls.Add(this.lblSeconds);
            this.Controls.Add(this.buffDebuffSeconds);
            this.Controls.Add(this.displayBuffDebuffEvery);
            this.Controls.Add(this.buffDebuffFormat);
            this.Controls.Add(this.setDebuffHue);
            this.Controls.Add(this.lblDebuffHue);
            this.Controls.Add(this.setBuffHue);
            this.Controls.Add(this.lblBuffHue);
            this.Controls.Add(this.grpFilter);
            this.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle;
            this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon")));
            this.MaximizeBox = false;
            this.Name = "BuffDebuff";
            this.ShowIcon = false;
            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
            this.Text = "Buff/Debuff Options";
            this.Closing += new System.ComponentModel.CancelEventHandler(this.BuffDebuff_Closing);
            this.Load += new System.EventHandler(this.BuffDebuff_Load);
            this.grpFilter.ResumeLayout(false);
            this.ResumeLayout(false);
            this.PerformLayout();

        }

        #endregion

        private System.Windows.Forms.GroupBox grpFilter;
        private System.Windows.Forms.Button removeFilter;
        private System.Windows.Forms.Button addFilter;
        private System.Windows.Forms.ListBox buffDebuffFilters;
        private System.Windows.Forms.Label lblSeconds;
        private System.Windows.Forms.TextBox buffDebuffSeconds;
        private System.Windows.Forms.CheckBox displayBuffDebuffEvery;
        private System.Windows.Forms.TextBox buffDebuffFormat;
        private System.Windows.Forms.Button setDebuffHue;
        private System.Windows.Forms.Label lblDebuffHue;
        private System.Windows.Forms.Button setBuffHue;
        private System.Windows.Forms.Label lblBuffHue;
        private System.Windows.Forms.Button buffFormatKey;
        private System.Windows.Forms.Button okClose;
        private System.Windows.Forms.CheckBox overrideBuffDebuffFormat;
    }
}

================================================
FILE: Razor/UI/BuffDebuffOptions.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.ComponentModel;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using Assistant.Core;

namespace Assistant.UI
{
    public partial class BuffDebuffOptions : Form
    {
        public BuffDebuffOptions()
        {
            InitializeComponent();
        }

        private void SetBuffHue_Click(object sender, EventArgs e)
        {
            lblBuffHue.SafeAction(s => { SetHue(s, "BuffHue"); });
        }

        private void SetDebuffHue_Click(object sender, EventArgs e)
        {
            lblDebuffHue.SafeAction(s => { SetHue(s, "DebuffHue"); });
        }

        private void SetHue(Control ctrl, string cfg)
        {
            HueEntry h = new HueEntry(Config.GetInt(cfg));

            if (h.ShowDialog(this) == DialogResult.OK)
            {
                int hueIdx = h.Hue;
                Config.SetProperty(cfg, hueIdx);
                if (hueIdx > 0 && hueIdx < 3000)
                    ctrl.BackColor = Ultima.Hues.GetHue(hueIdx - 1).GetColor(HueEntry.TextHueIDX);
                else
                    ctrl.BackColor = Color.White;
                ctrl.ForeColor = (ctrl.BackColor.GetBrightness() < 0.35 ? Color.White : Color.Black);
            }
        }

        private void InitPreviewHue(Control ctrl, string cfg)
        {
            int hueIdx = Config.GetInt(cfg);
            if (hueIdx > 0 && hueIdx < 3000)
                ctrl.BackColor = Ultima.Hues.GetHue(hueIdx - 1).GetColor(HueEntry.TextHueIDX);
            else
                ctrl.BackColor = SystemColors.Control;
            ctrl.ForeColor = (ctrl.BackColor.GetBrightness() < 0.35 ? Color.White : Color.Black);
        }

        private void BuffDebuffFormat_TextChanged(object sender, EventArgs e)
        {
            if (string.IsNullOrEmpty(buffDebuffFormat.Text))
            {
                Config.SetProperty("BuffDebuffFormat", "[{action}{name} {duration}]");
            }
            else
            {
                Config.SetProperty("BuffDebuffFormat", buffDebuffFormat.Text);
            }
        }

        private void BuffDebuffSeconds_TextChanged(object sender, EventArgs e)
        {
            Config.SetProperty("BuffDebuffSeconds", Utility.ToInt32(buffDebuffSeconds.Text.Trim(), 20));

            if (Config.GetInt("BuffDebuffSeconds") < 1)
                Config.SetProperty("BuffDebuffSeconds", 20);
        }

        private void DisplayBuffDebuffEvery_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("BuffDebuffEveryXSeconds", displayBuffDebuffEvery.Checked);
        }

        private void BtnOk_Click(object sender, EventArgs e)
        {
            Hide();
        }

        private void AddFilter_Click(object sender, EventArgs e)
        {
            if (InputBox.Show(this, "Filter Buff/Debuff",
                "Enter part or the whole name of the buff to filter it from showing overhead"))
            {
                string name = InputBox.GetString();

                if (!string.IsNullOrEmpty(name))
                {
                    buffDebuffFilters.Items.Add(name.Trim());
                }
            }

            SaveFilter();
        }

        private void BuffDebuff_Load(object sender, EventArgs e)
        {
            buffDebuffFilters.Items.Clear();

            foreach (string filter in Config.GetString("BuffDebuffFilter").Split(','))
            {
                if (string.IsNullOrEmpty(filter))
                    continue;

                buffDebuffFilters.Items.Add(filter);
            }

            buffDebuffFormat.SafeAction(s => s.Text = Config.GetString("BuffDebuffFormat"));
            buffDebuffSeconds.SafeAction(s => s.Text = Convert.ToString(Config.GetInt("BuffDebuffSeconds")));
            displayBuffDebuffEvery.SafeAction(s => s.Checked = Config.GetBool("BuffDebuffEveryXSeconds"));
            overrideBuffDebuffFormat.SafeAction(s => s.Checked = Config.GetBool("OverrideBuffDebuffFormat"));

            lblBuffHue.SafeAction(s => { InitPreviewHue(s, "BuffHue"); });
            lblDebuffHue.SafeAction(s => { InitPreviewHue(s, "DebuffHue"); });
        }

        private void RemoveFilter_Click(object sender, EventArgs e)
        {
            if (buffDebuffFilters.SelectedIndex < 0)
                return;

            buffDebuffFilters.Items.RemoveAt(buffDebuffFilters.SelectedIndex);

            SaveFilter();
        }

        private void BuffFormatKey_Click(object sender, EventArgs e)
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendLine("You can insert these variables into the buff/debuff format box.");
            sb.AppendLine(string.Empty);
            sb.AppendLine("{name} - The name of the buff/debuff");
            sb.AppendLine("{action} - + or - depending if you gain or lose the buff/debuff");
            sb.AppendLine("{duration} - Time in seconds left for the buff/debuff");

            MessageBox.Show(this, sb.ToString(), "Buff/Debuff Format", MessageBoxButtons.OK,
                MessageBoxIcon.Information);
        }

        private void SaveFilter()
        {
            StringBuilder sb = new StringBuilder();
            foreach (var item in buffDebuffFilters.Items)
            {
                sb.Append($"{item},");
            }

            Config.SetProperty("BuffDebuffFilter", sb.ToString());

            BuffDebuffManager.ReloadFilter();
        }

        private void OkClose_Click(object sender, EventArgs e)
        {
            this.SafeAction(s => s.Hide());
        }

        private void BuffDebuff_Closing(object sender, CancelEventArgs e)
        {
            this.SafeAction(s =>
            {
                e.Cancel = true;
                s.Hide();
            });
        }

        private void overrideBuffDebuffFormat_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("OverrideBuffDebuffFormat", displayBuffDebuffEvery.Checked);
        }
    }
}

================================================
FILE: Razor/UI/BuffDebuffOptions.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <assembly alias="System.Drawing" name="System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
  <data name="$this.Icon" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
    <value>
        AAABAAEAICAAAAAAAACoCAAAFgAAACgAAAAgAAAAQAAAAAEACAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAB
        AAAAAAAAAACAAACAAAAAgIAAgAAAAIAAgACAgAAAwMDAAMDcwADwyqYABAQEAAgICAAMDAwAERERABYW
        FgAcHBwAIiIiACkpKQBVVVUATU1NAEJCQgA5OTkAgHz/AFBQ/wCTANYA/+zMAMbW7wDW5+cAkKmtAAAA
        MwAAAGYAAACZAAAAzAAAMwAAADMzAAAzZgAAM5kAADPMAAAz/wAAZgAAAGYzAABmZgAAZpkAAGbMAABm
        /wAAmQAAAJkzAACZZgAAmZkAAJnMAACZ/wAAzAAAAMwzAADMZgAAzJkAAMzMAADM/wAA/2YAAP+ZAAD/
        zAAzAAAAMwAzADMAZgAzAJkAMwDMADMA/wAzMwAAMzMzADMzZgAzM5kAMzPMADMz/wAzZgAAM2YzADNm
        ZgAzZpkAM2bMADNm/wAzmQAAM5kzADOZZgAzmZkAM5nMADOZ/wAzzAAAM8wzADPMZgAzzJkAM8zMADPM
        /wAz/zMAM/9mADP/mQAz/8wAM///AGYAAABmADMAZgBmAGYAmQBmAMwAZgD/AGYzAABmMzMAZjNmAGYz
        mQBmM8wAZjP/AGZmAABmZjMAZmZmAGZmmQBmZswAZpkAAGaZMwBmmWYAZpmZAGaZzABmmf8AZswAAGbM
        MwBmzJkAZszMAGbM/wBm/wAAZv8zAGb/mQBm/8wAzAD/AP8AzACZmQAAmTOZAJkAmQCZAMwAmQAAAJkz
        MwCZAGYAmTPMAJkA/wCZZgAAmWYzAJkzZgCZZpkAmWbMAJkz/wCZmTMAmZlmAJmZmQCZmcwAmZn/AJnM
        AACZzDMAZsxmAJnMmQCZzMwAmcz/AJn/AACZ/zMAmcxmAJn/mQCZ/8wAmf//AMwAAACZADMAzABmAMwA
        mQDMAMwAmTMAAMwzMwDMM2YAzDOZAMwzzADMM/8AzGYAAMxmMwCZZmYAzGaZAMxmzACZZv8AzJkAAMyZ
        MwDMmWYAzJmZAMyZzADMmf8AzMwAAMzMMwDMzGYAzMyZAMzMzADMzP8AzP8AAMz/MwCZ/2YAzP+ZAMz/
        zADM//8AzAAzAP8AZgD/AJkAzDMAAP8zMwD/M2YA/zOZAP8zzAD/M/8A/2YAAP9mMwDMZmYA/2aZAP9m
        zADMZv8A/5kAAP+ZMwD/mWYA/5mZAP+ZzAD/mf8A/8wAAP/MMwD/zGYA/8yZAP/MzAD/zP8A//8zAMz/
        ZgD//5kA///MAGZm/wBm/2YAZv//AP9mZgD/Zv8A//9mACEApQBfX18Ad3d3AIaGhgCWlpYAy8vLALKy
        sgDX19cA3d3dAOPj4wDq6uoA8fHxAPj4+ADw+/8ApKCgAICAgAAAAP8AAP8AAAD//wD/AAAA/wD/AP//
        AAD///8ACgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoK
        CgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCrcKCgoKCgoKCgoKCgoK
        CgoKCgoKCgoKCgoKCgoKCgoK+QoKCgoKCgoKCgrSCgoKCgoKCgoKCgoKCgoKCgoKCgr5+QoKCgoKCgr5
        sQoKCgoKCgoKCgoKCgoKCgoKCgoKCvn5CgoKCgoKsbEKCgoKCgoKCgoKCgoKCgoKCgoKCgoK+ZQKCgoK
        CuPjCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgr5sQoKCgpHsQoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgpq
        Cgr5QbEKCgqxtwoKCgoKCgr5CgoK+QoKCgoKCgoKCuP5lPmUCgoKCrGxt7f5+fkKCvkK+fkKCgoKCgoK
        CgoKFkH5lAoK+QoK+bcKCgr5t7cK+fn5CgoKCgoKCgoKCrdB+fkKCgoK0rext7EKCvn5Crf5+QoKCgoK
        CgoKCgqx+UdBCgoKCgq3+fkKt5QK+fkK0vn5CgoKCgoKCgoKCgq3+UGUCgoKCvmxtwoKsbcK+QqUCvn5
        +QoKCgoKCgoKCgr5F0f5CgoKCmqxCgoKavn5+eP5arexagoKCgoKCgoKCgqU+Wrj+QoKt7cKRmlq+Qq3
        lJQXF+MWCgoKCgoKCgoKCvn5+flq4/kKCuvs7O0KCgoKCgoKCgoKCgoKCgoKCgoKCkfjCgoWRxaSku3s
        7OwKCgoKCgoKCgoKCgoKCgoKCgoK+fkKCgr5bpKS7e3t7eztCgoKCgoKCgoKCgoKCgoKCgr5+ZQKCgqS
        kpLt7e3t7e3tCgoKCgoKCgoKCgoKCgoKCgr54woK7++SkpLt7e3t7Ozs7fcKCgoKCgoKCgoKCrHjFkEX
        FhZpku/3kpLt7e3s7Ozs7JIKCgoKCgoKCgoKR/n5+fn5+fkg7e+SkpLt7Ozs7Ozs7ZIKCgoKCgoKCgpH
        QUFBQUcXahbt95KS7e3s7Ozs7Oztkvf3CgoKCgoKCgoKCgrs6+wKCpKS7e3t7Ozs7Ozt7ZL39+/vCgoK
        CgoKCgoKCuzr6uzs7ZLt7ezs7Ozs7ZKS9+/v7+/vCgoKCgoKCgrr7JLrbeyS7ezs7Ozs7ZKS9/fv7wcH
        BwcKCgoKCgoK7BLs7/fs7Ozs7Ozs7O2S9+/v7+8HBwcHBwoKCgoKCgoSbe8H7+zt7Ovs7O2Skvfv7+8H
        BwcHBwcHCgoKCgoK7ezv7++S7O3v9+zs9/fv7+8HBwcHBwcH8fAKCgoKCuwS6+ztkvfv7+8HB/f3B7y8
        vPDw8PDwvPP/8/////////////////f////3/v//8/n///Pz///z5///88////sc/u/4PAaf+GziP/Dw
        ZH/h8SR/8PGVH/h5wA/8GQgP/AYf//5gD//+cAP//jgB//8wAD/4AAAf+AAAD/gAAAP/jAAB/4AAAP8A
        AAD+AAAA/gAAAPwAAAD4AAAA
</value>
  </data>
</root>

================================================
FILE: Razor/UI/Config.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Xml;
using System.IO;
using System.Reflection;
using System.Text;
using System.Collections.Generic;
using System.ComponentModel;
using System.Configuration;
using System.Windows.Forms;
using Assistant.Agents;
using Assistant.Core;
using Assistant.Filters;
using Assistant.Macros;
using Assistant.Scripts;
using Assistant.UI;
using ContainerLabels = Assistant.Core.ContainerLabels;

namespace Assistant
{
    public class Profile
    {
        private string m_Name;
        private Dictionary<string, object> m_Props;
        private System.Threading.Mutex m_Mutex;

        public Profile(string name)
        {
            Name = name;
            m_Props = new Dictionary<string, object>(16, StringComparer.OrdinalIgnoreCase);

            MakeDefault();
        }

        public void MakeDefault()
        {
            m_Props.Clear();

            AddProperty("ShowMobNames", false);
            AddProperty("ShowCorpseNames", false);
            AddProperty("DisplaySkillChanges", false);

            if (Client.IsOSI)
                AddProperty("TitleBarText", @"UO - {char} {crimtime}- {mediumstatbar} {bp} {bm} {gl} {gs} {mr} {ns} {ss} {sa} {aids}");
            else
                AddProperty("TitleBarText", @"UO - {char}");

            AddProperty("TitleBarDisplay", true);
            AddProperty("AutoSearch", true);
            AddProperty("NoSearchPouches", true);
            AddProperty("CounterWarnAmount", (int) 5);
            AddProperty("CounterWarn", true);
            AddProperty("ObjectDelay", (int) 600);
            AddProperty("ObjectDelayEnabled", true);
            AddProperty("AlwaysOnTop", false);
            AddProperty("SortCounters", true);
            AddProperty("QueueActions", false);
            AddProperty("QueueTargets", false);
            AddProperty("WindowX", (int) 400);
            AddProperty("WindowY", (int) 400);
            AddProperty("CountStealthSteps", true);

            AddProperty("SysColor", (int) 0x0044);
            AddProperty("WarningColor", (int) 0x0025);
            AddProperty("ExemptColor", (int) 0x0480);
            AddProperty("SpeechHue", (int) 0x03B1);
            AddProperty("BeneficialSpellHue", (int) 0x0005);
            AddProperty("HarmfulSpellHue", (int) 0x0058);
            AddProperty("NeutralSpellHue", (int) 0x03B1);
            AddProperty("ForceSpeechHue", false);
            AddProperty("ForceSpellHue", true);
            AddProperty("SpellFormat", @"{power} [{spell}]");

            AddProperty("ShowNotoHue", true);
            AddProperty("Opacity", (int) 100);

            AddProperty("AutoOpenCorpses", false);
            AddProperty("CorpseRange", (int) 2);

            AddProperty("BlockDismount", false);

            AddProperty("CapFullScreen", false);
            AddProperty("CapPath",
                Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyPictures), "RazorScreenShots"));
            AddProperty("CapTimeStamp", true);
            AddProperty("ImageFormat", "jpg");

            AddProperty("UndressConflicts", true);
            AddProperty("HighlightReagents", true);
            AddProperty("Systray", false);
            AddProperty("TitlebarImages", true);

            AddProperty("SellAgentMax", (int) 99);
            AddProperty("SkillListCol", (int) -1);
            AddProperty("SkillListAsc", false);

            AddProperty("AutoStack", false);
            AddProperty("ActionStatusMsg", true);
            AddProperty("RememberPwds", false);

            AddProperty("SpellUnequip", true);
            AddProperty("RangeCheckLT", true);
            AddProperty("LTRange", (int) 12);

            AddProperty("FilterSnoopMsg", true);
            AddProperty("OldStatBar", false);

            AddProperty("SmartLastTarget", false);
            AddProperty("LastTargTextFlags", true);
            //AddProperty("SmartCPU", false);
            AddProperty("LTHilight", (int) 0);

            AddProperty("AutoFriend", false);

            AddProperty("AutoOpenDoors", true);

            AddProperty("MessageLevel", 0);

            AddProperty("ForceIP", "");
            AddProperty("ForcePort", 0);

            AddProperty("ForceSizeEnabled", false);
            AddProperty("ForceSizeX", 1000);
            AddProperty("ForceSizeY", 800);

            AddProperty("PotionEquip", false);
            AddProperty("BlockHealPoison", true);

            AddProperty("SmoothWalk", false);

            AddProperty("Negotiate", true);

            AddProperty("MapX", 200);
            AddProperty("MapY", 200);
            AddProperty("MapW", 200);
            AddProperty("MapH", 200);

            AddProperty("LogPacketsByDefault", false);

            AddProperty("ShowHealth", true);
            AddProperty("HealthFmt", "[{0}%]");
            AddProperty("ShowPartyStats", true);
            AddProperty("PartyStatFmt", "[{0}% / {1}%]");

            AddProperty("HotKeyStop", false);
            AddProperty("DiffTargetByType", false);
            AddProperty("StepThroughMacro", false);

            AddProperty("ShowTargetSelfLastClearOverhead", true);
            AddProperty("ShowOverheadMessages", false);
            AddProperty("CaptureMibs", false);

            //OverheadFormat
            AddProperty("OverheadFormat", "[{msg}]");
            AddProperty("OverheadStyle", 1);

            AddProperty("GoldPerDisplay", false);

            AddProperty("LightLevel", 31);
            AddProperty("LogSkillChanges", false);
            AddProperty("StealthOverhead", false);

            AddProperty("ShowBuffDebuffOverhead", true);
            AddProperty("BuffDebuffFormat", "[{action}{name} {duration}]");

            AddProperty("BlockOpenCorpsesTwice", false);

            AddProperty("ShowAttackTargetOverhead", true);

            AddProperty("RangeCheckTargetByType", false);
            AddProperty("RangeCheckDoubleClick", false);

            AddProperty("ShowContainerLabels", false);
            AddProperty("ContainerLabelFormat", "[{label}] ({type})");
            AddProperty("ContainerLabelColor", 88);
            AddProperty("ContainerLabelStyle", 1);

            AddProperty("Season", 5);

            AddProperty("BlockTradeRequests", false);
            AddProperty("BlockPartyInvites", false);
            AddProperty("AutoAcceptParty", false);

            AddProperty("MaxLightLevel", 31);
            AddProperty("MinLightLevel", 0);
            AddProperty("MinMaxLightLevelEnabled", false);
            AddProperty("ShowStaticWalls", false);
            AddProperty("ShowStaticWallLabels", false);

            AddProperty("ShowTextTargetIndicator", false);
            AddProperty("ShowAttackTargetNewOnly", true);

            AddProperty("FilterDragonGraphics", false);
            AddProperty("FilterDrakeGraphics", false);
            AddProperty("DragonGraphic", 0);
            AddProperty("DrakeGraphic", 0);

            AddProperty("ShowDamageDealt", false);
            AddProperty("ShowDamageDealtOverhead", false);
            AddProperty("ShowDamageTaken", false);
            AddProperty("ShowDamageTakenOverhead", false);

            AddProperty("ShowInRazorTitleBar", false);
            AddProperty("RazorTitleBarText", "{name} on {account} ({profile} - {shard}) - Razor v{version}");

            AddProperty("EnableUOAAPI", true);

            AddProperty("TargetIndicatorFormat", "* Target *");

            AddProperty("NextPrevTargetIgnoresFriends", false);

            AddProperty("StealthStepsFormat", "Steps: {step}");

            AddProperty("ShowFriendOverhead", false);

            AddProperty("DisplaySkillChangesOverhead", false);

            AddProperty("GrabHotBag", "0");

            // Enable it for OSI client by default, CUO turn it off
            AddProperty("MacroActionDelay", Client.IsOSI);

            AddProperty("AutoOpenDoorWhenHidden", false);

            AddProperty("DisableMacroPlayFinish", false);

            AddProperty("ShowBandageTimer", false);
            AddProperty("ShowBandageTimerFormat", "Bandage: {count}s");
            AddProperty("ShowBandageTimerLocation", 0);
            AddProperty("OnlyShowBandageTimerEvery", false);
            AddProperty("OnlyShowBandageTimerSeconds", 1);
            AddProperty("ShowBandageTimerHue", 88);

            AddProperty("TargetIndicatorHue", 10);

            AddProperty("FilterSystemMessages", false);
            AddProperty("FilterRazorMessages", false);
            AddProperty("FilterDelay", 3.5);
            AddProperty("FilterOverheadMessages", false);

            AddProperty("OnlyNextPrevBeneficial", false);
            AddProperty("FriendlyBeneficialOnly", false);
            AddProperty("NonFriendlyHarmfulOnly", false);

            AddProperty("ShowBandageStart", false);
            AddProperty("BandageStartMessage", "Bandage: Starting");
            AddProperty("ShowBandageEnd", false);
            AddProperty("BandageEndMessage", "Bandage: Ending");

            AddProperty("BuffDebuffSeconds", 20);
            AddProperty("BuffHue", 88);
            AddProperty("DebuffHue", 338);
            AddProperty("DisplayBuffDebuffEvery", false);
            AddProperty("BuffDebuffFilter", string.Empty);
            AddProperty("BuffDebuffEveryXSeconds", false);

            AddProperty("CaptureOthersDeathDelay", 0.5);
            AddProperty("CaptureOwnDeathDelay", 0.5);
            AddProperty("CaptureOthersDeath", false);
            AddProperty("CaptureOwnDeath", false);

            AddProperty("TargetFilterEnabled", false);

            AddProperty("FilterDaemonGraphics", false);
            AddProperty("DaemonGraphic", 0);

            AddProperty("SoundFilterEnabled", false);
            AddProperty("ShowFilteredSound", false);
            AddProperty("ShowPlayingSoundInfo", false);
            AddProperty("ShowMusicInfo", false);

            AddProperty("AutoSaveScript", false);
            AddProperty("AutoSaveScriptPlay", false);

            AddProperty("HighlightFriend", false);
            
            AddProperty("ScriptDisablePlayFinish", false);

            AddProperty("ShowWaypointOverhead", true);
            AddProperty("ShowWaypointDistance", true);
            AddProperty("ShowWaypointSeconds", 10);

            AddProperty("ClearWaypoint", false);
            AddProperty("HideWaypointDistance", 4);

            AddProperty("CreateWaypointOnDeath", false);

            AddProperty("ShowPartyFriendOverhead", false);

            AddProperty("OverrideSpellFormat", true);

            AddProperty("PotionReequip", true);

            AddProperty("EnableTextFilter", false);

            AddProperty("DisableScriptTooltips", false);

            AddProperty("BuyAgentsIgnoreGold", false);
            
            AddProperty("OverrideBuffDebuffFormat", false);

            AddProperty("NextPrevAlphabetical", false);

            AddProperty("FilterWyrmGraphics", false);
            AddProperty("WyrmGraphic", 0);

            AddProperty("WindowSizeX", 546);
            AddProperty("WindowSizeY", 411);

            AddProperty("PlayEmoteSound", false);

            AddProperty("ShowBuffDebuffGump", false);
            AddProperty("ShowBuffDebuffIcons", true);
            AddProperty("ShowBuffDebuffWidth", 100);
            AddProperty("ShowBuffDebuffHeight", 18);
            AddProperty("ShowBuffDebuffSort", 2);
            AddProperty("UseBlackBuffDebuffBg", false);
            AddProperty("ShowBuffDebuffTimeType", 0);
            
            AddProperty("DefaultScriptDelay", true);
            AddProperty("EnableHighlight", false);
            AddProperty("DisableScriptStopwatch", false);

            AddProperty("CooldownHeight", 28);
            AddProperty("CooldownWidth", 110);

            Counter.Default();
            Filter.DisableAll();
            DressList.ClearAll();
            HotKey.ClearAll();
            Agent.ClearAll();
            PasswordMemory.ClearAll();
            FriendsManager.ClearAll();
            WaypointManager.ClearAll();
            TextFilterManager.ClearAll();
            DressList.ClearAll();
            OverheadManager.ClearAll();
            ContainerLabels.ClearAll();
            MacroVariables.ClearAll();
            ScriptVariables.ClearAll();
        }

        public string Name
        {
            get { return m_Name; }
            set
            {
                if (value != null && value.Trim() != "")
                {
                    StringBuilder sb = new StringBuilder(value);
                    sb.Replace('\\', '_');
                    sb.Replace('/', '_');
                    sb.Replace('\"', '\'');
                    sb.Replace(':', '_');
                    sb.Replace('?', '_');
                    sb.Replace('*', '_');
                    sb.Replace('<', '(');
                    sb.Replace('>', ')');
                    sb.Replace('|', '_');
                    m_Name = sb.ToString();
                }
                else
                {
                    m_Name = "[No Name]";
                }
            }
        }

        private static bool m_Warned = false;

        public bool Load()
        {
            if (m_Name == null || m_Name.Trim() == "")
                return false;

            string path = Config.GetUserDirectory("Profiles");
            string file = Path.Combine(path, $"{m_Name}.xml");
            if (!File.Exists(file))
                return false;

            XmlDocument doc = new XmlDocument();
            try
            {
                doc.Load(file);
            }
            catch
            {
                MessageBox.Show(Engine.ActiveWindow, Language.Format(LocString.ProfileCorrupt, file),
                    "Profile Load Error", MessageBoxButtons.OK, MessageBoxIcon.Stop);
                return false;
            }

            XmlElement root = doc["profile"];
            if (root == null)
                return false;

            Assembly exe = Assembly.GetCallingAssembly();
            if (exe == null)
                return false;

            foreach (XmlElement el in root.GetElementsByTagName("property"))
            {
                try
                {
                    string name = el.GetAttribute("name");
                    string typeStr = el.GetAttribute("type");
                    string val = el.InnerText;

                    if (typeStr == "-null-" || name == "LimitSize" || name == "VisRange")
                    {
                        //m_Props[name] = null;
                        if (m_Props.ContainsKey(name))
                            m_Props.Remove(name);
                    }
                    else
                    {
                        Type type = Type.GetType(typeStr);
                        if (type == null)
                            type = exe.GetType(typeStr);

                        if (m_Props.ContainsKey(name) || name == "ForceSize")
                        {
                            if (type == null)
                                m_Props.Remove(name);
                            else
                                m_Props[name] = GetObjectFromString(val, type);
                        }
                    }
                }
                catch (Exception e)
                {
                    MessageBox.Show(Engine.ActiveWindow, Language.Format(LocString.ProfileLoadEx, e.ToString()),
                        "Profile Load Exception", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                }
            }

            Filter.Load(root["filters"]);
            Counter.LoadProfile(root["counters"]);
            Agent.LoadProfile(root["agents"]);
            DressList.Load(root["dresslists"]);
            TargetFilterManager.Load(root["targetfilters"]);
            SoundMusicManager.Load(root["soundfilters"]);
            WaypointManager.Load(root["waypoints"]);
            TextFilterManager.Load(root["textfilters"]);
            FriendsManager.Load(root["friends"]);
            HotKey.Load(root["hotkeys"]);
            PasswordMemory.Load(root["passwords"]);
            OverheadManager.Load(root["overheadmessages"]);
            ContainerLabels.Load(root["containerlabels"]);
            MacroVariables.Load(root["macrovariables"]);
            //imports previous absolutetargets and doubleclickvariables if present in profile
            if ((root.SelectSingleNode("absolutetargets") != null) ||
                (root.SelectSingleNode("doubleclickvariables") != null))
            {
                MacroVariables.Import(root);
            }

            ScriptVariables.Load(root["scriptvariables"]);

            GoldPerHourTimer.Stop();
            DamageTracker.Stop();

            if (m_Props.ContainsKey("ForceSize"))
            {
                try
                {
                    int x, y;
                    switch ((int) m_Props["ForceSize"])
                    {
                        case 1:
                            x = 960;
                            y = 600;
                            break;
                        case 2:
                            x = 1024;
                            y = 768;
                            break;
                        case 3:
                            x = 1152;
                            y = 864;
                            break;
                        case 4:
                            x = 1280;
                            y = 720;
                            break;
                        case 5:
                            x = 1280;
                            y = 768;
                            break;
                        case 6:
                            x = 1280;
                            y = 800;
                            break;
                        case 7:
                            x = 1280;
                            y = 960;
                            break;
                        case 8:
                            x = 1280;
                            y = 1024;
                            break;

                        case 0:
                        default:
                            x = 800;
                            y = 600;
                            break;
                    }

                    SetProperty("ForceSizeX", x);
                    SetProperty("ForceSizeY", y);

                    if (x != 800 || y != 600)
                        SetProperty("ForceSizeEnabled", true);

                    m_Props.Remove("ForceSize");
                }
                catch
                {
                }
            }

            //if ( !Language.Load( GetString( "Language" ) ) )
            //	MessageBox.Show( Engine.ActiveWindow, "Warning: Could not load language from profile, using current language instead.", "Language Error", MessageBoxButtons.OK, MessageBoxIcon.Warning );

            return true;
        }

        public void Unload()
        {
            try
            {
                if (m_Mutex != null)
                {
                    m_Mutex.ReleaseMutex();
                    m_Mutex.Close();
                    m_Mutex = null;
                }
            }
            catch
            {
            }
        }

        public void Save()
        {
            string profileDir = Config.GetUserDirectory("Profiles");
            string file = Path.Combine(profileDir, $"{m_Name}.xml");

            if (m_Name != "default" && !m_Warned)
            {
                try
                {
                    m_Mutex = new System.Threading.Mutex(true, $"Razor_Profile_{m_Name}");

                    if (!m_Mutex.WaitOne(10, false))
                        throw new Exception("Can't grab profile mutex, must be in use!");
                }
                catch
                {
                    //MessageBox.Show( Engine.ActiveWindow, Language.Format( LocString.ProfileInUse, m_Name ), "Profile In Use", MessageBoxButtons.OK, MessageBoxIcon.Warning );
                    //m_Warned = true;
                    return; // refuse to overwrite profiles that we don't own.
                }
            }

            XmlTextWriter xml;
            try
            {
                xml = new XmlTextWriter(file, Encoding.UTF8);
            }
            catch
            {
                return;
            }

            xml.Formatting = Formatting.Indented;
            xml.IndentChar = '\t';
            xml.Indentation = 1;

            xml.WriteStartDocument(true);
            xml.WriteStartElement("profile");

            foreach (KeyValuePair<string, object> de in m_Props)
            {
                xml.WriteStartElement("property");
                xml.WriteAttributeString("name", de.Key);
                if (de.Value == null)
                {
                    xml.WriteAttributeString("type", "-null-");
                }
                else
                {
                    xml.WriteAttributeString("type", de.Value.GetType().FullName);
                    xml.WriteString(de.Value.ToString());
                }

                xml.WriteEndElement();
            }

            xml.WriteStartElement("filters");
            Filter.Save(xml);
            xml.WriteEndElement();

            xml.WriteStartElement("counters");
            Counter.SaveProfile(xml);
            xml.WriteEndElement();

            xml.WriteStartElement("agents");
            Agent.SaveProfile(xml);
            xml.WriteEndElement();

            xml.WriteStartElement("dresslists");
            DressList.Save(xml);
            xml.WriteEndElement();

            xml.WriteStartElement("hotkeys");
            HotKey.Save(xml);
            xml.WriteEndElement();

            xml.WriteStartElement("passwords");
            PasswordMemory.Save(xml);
            xml.WriteEndElement();

            xml.WriteStartElement("overheadmessages");
            OverheadManager.Save(xml);
            xml.WriteEndElement();

            xml.WriteStartElement("containerlabels");
            ContainerLabels.Save(xml);
            xml.WriteEndElement();

            xml.WriteStartElement("macrovariables");
            MacroVariables.Save(xml);
            xml.WriteEndElement();

            xml.WriteStartElement("scriptvariables");
            ScriptVariables.Save(xml);
            xml.WriteEndElement();

            xml.WriteStartElement("friends");
            FriendsManager.Save(xml);
            xml.WriteEndElement();
            
            xml.WriteStartElement("textfilters");
            TextFilterManager.Save(xml);
            xml.WriteEndElement();

            xml.WriteStartElement("targetfilters");
            TargetFilterManager.Save(xml);
            xml.WriteEndElement();

            xml.WriteStartElement("soundfilters");
            SoundMusicManager.Save(xml);
            xml.WriteEndElement();

            xml.WriteStartElement("waypoints");
            WaypointManager.Save(xml);
            xml.WriteEndElement();

            xml.WriteEndElement(); // end profile section

            xml.Close();
        }

        private static Type[] ctorTypes = new Type[] {typeof(string)};

        private object GetObjectFromString(string val, Type type)
        {
            if (type == typeof(string))
            {
                return val;
            }
            else
            {
                try
                {
                    ConstructorInfo ctor = type.GetConstructor(ctorTypes);
                    if (ctor != null)
                        return ctor.Invoke(new object[] {val});
                }
                catch
                {
                }

                return Convert.ChangeType(val, type);
            }
        }

        public object GetProperty(string name)
        {
            if (!m_Props.ContainsKey(name))
                throw new Exception(Language.Format(LocString.NoProp, name));
            return m_Props[name];
        }

        public void SetProperty(string name, object val)
        {
            if (!m_Props.ContainsKey(name))
                throw new Exception(Language.Format(LocString.NoProp, name));
            m_Props[name] = val;
        }

        public void AddProperty(string name, object val)
        {
            m_Props[name] = val;
        }
    }

    public class Config
    {
        private static Profile m_Current;
        private static Dictionary<Serial, string> m_Chars;

        private static Dictionary<string, string> m_AppSettings = new Dictionary<string, string>();

        static Config()
        {
            var path = Path.Combine(Engine.RootPath, "settings.csv");

            // Set defaults
            m_AppSettings["UODataDir"] = @"D:\Games\UO";
            m_AppSettings["UOClient"] = @"D:\Games\UO\client.exe";
            m_AppSettings["LastPort"] = "2593";
            m_AppSettings["LastProfile"] = "default";
            m_AppSettings["LastServer"] = "127.0.0.1";
            m_AppSettings["LastServerId"] = "0";
            m_AppSettings["ClientEncrypted"] = "1";
            m_AppSettings["ServerEncrypted"] = "0";
            m_AppSettings["ShowWelcome"] = "1";
            m_AppSettings["UId"] = "";
            m_AppSettings["MaxOrganizerAgents"] = "20";
            m_AppSettings["MaxBuyAgents"] = "20";
            m_AppSettings["MaxRestockAgents"] = "20";
            m_AppSettings["ImportProfilesAndMacros"] = "true";
            m_AppSettings["BackupPath"] = @".\Backup";

            try
            {
                if (!File.Exists(path))
                {
                    File.Create(path);
                }
                else
                {
                    foreach (var line in File.ReadLines(path))
                    {
                        var strs = line.Split(',');

                        m_AppSettings[strs[0].Trim()] = strs[1].Trim();
                    }
                }
            }
            catch (Exception)
            { }
            finally
            {
            }
        }

        public static Profile CurrentProfile
        {
            get
            {
                if (m_Current == null)
                    LoadLastProfile();
                return m_Current;
            }
        }

        public static void Save()
        {
            if (m_Current != null)
                m_Current.Save();
            SaveCharList();
            SaveAppSettings();
        }

        public static bool LoadProfile(string name)
        {
            Profile p = new Profile(name);
            if (p.Load())
            {
                LastProfileName = p.Name;
                if (m_Current != null)
                    m_Current.Unload();
                m_Current = p;
                return true;
            }
            else
            {
                return false;
            }
        }

        public static void NewProfile(string name)
        {
            if (m_Current != null)
                m_Current.Unload();
            m_Current = new Profile(name);
        }

        public static void LoadCharList()
        {
            if (m_Chars == null)
                m_Chars = new Dictionary<Serial, string>();
            else
                m_Chars.Clear();

            string file = Path.Combine(Config.GetUserDirectory("Profiles"), "chars.lst");
            if (!File.Exists(file))
                return;

            using (StreamReader reader = new StreamReader(file))
            {
                string line;
                while ((line = reader.ReadLine()) != null)
                {
                    if (line.Length <= 0 || line[0] == ';' || line[0] == '#')
                        continue;
                    string[] split = line.Split('=');
                    try
                    {
                        m_Chars.Add(Serial.Parse(split[0]), split[1]);
                    }
                    catch
                    {
                    }
                }
            }
        }

        public static void SaveCharList()
        {
            if (m_Chars == null)
                m_Chars = new Dictionary<Serial, string>();

            try
            {
                using (StreamWriter writer =
                    new StreamWriter(Path.Combine(Config.GetUserDirectory("Profiles"), "chars.lst")))
                {
                    foreach (KeyValuePair<Serial, string> de in m_Chars)
                    {
                        writer.WriteLine("{0}={1}", de.Key, de.Value);
                    }
                }
            }
            catch
            {
            }
        }

        public static void LoadProfileFor(PlayerData player)
        {
            if (m_Chars == null)
                m_Chars = new Dictionary<Serial, string>();

            string prof;

            if (m_Chars.TryGetValue(player.Serial, out prof) && prof != null)
            {
                if (m_Current != null && (m_Current.Name == prof || m_Current.Name.Trim() == prof.Trim()))
                    return;

                Save();

                if (!LoadProfile(prof))
                {
                    if (prof != "default")
                    {
                        if (!LoadProfile("default"))
                            m_Current.MakeDefault();
                    }
                    else
                    {
                        m_Current.MakeDefault();
                    }
                }

                Engine.MainWindow.InitConfig();
            }
            else
            {
                m_Chars[player.Serial] = (m_Current != null ? m_Current.Name : "default");
            }

            Engine.MainWindow.SafeAction(s => s.SelectProfile(m_Current != null ? m_Current.Name : "default"));
        }

        public static void SetProfileFor(PlayerData player)
        {
            if (m_Current != null)
                m_Chars[player.Serial] = m_Current.Name;
        }

        public static bool LoadLastProfile()
        {
            string name = LastProfileName;
            Profile p;

            if (!string.IsNullOrWhiteSpace(name))
            {
                p = new Profile(name);
                if (p.Load())
                {
                    if (m_Current != null)
                        m_Current.Unload();
                    m_Current = p;
                    return true;
                }
            }

            LastProfileName = "default";
            p = new Profile("default");
            if (!p.Load())
            {
                p.MakeDefault();
                p.Save();
            }

            if (m_Current != null)
                m_Current.Unload();
            m_Current = p;

            return true;
        }

        public static void SetupProfilesList(ComboBox list, string selectName)
        {
            if (list == null || list.Items == null)
                return;

            string[] files = Directory.GetFiles(Config.GetUserDirectory("Profiles"), "*.xml");
            string compare = String.Empty;
            if (selectName != null)
                compare = selectName.ToLower();

            for (int i = 0; i < files.Length; i++)
            {
                string name = Path.GetFileNameWithoutExtension(files[i]);
                if (name == null || name.Length <= 0)
                    name = files[i];
                if (name == null)
                    continue;

                list.Items.Add(name);
                if (name.ToLower() == compare)
                    list.SelectedIndex = i;
            }
        }

        public static List<string> GetProfileList()
        {
            List<string> list = new List<string>();

            string[] files = Directory.GetFiles(GetUserDirectory("Profiles"), "*.xml");

            foreach (var file in files)
            {
                list.Add(Path.GetFileNameWithoutExtension(file));
            }

            return list;
        }

        private static void SaveAppSettings()
        {
            var path = Path.Combine(Engine.RootPath, "settings.csv");

            Engine.EnsureDirectory(Engine.RootPath);

            if (!File.Exists(path))
            {
                File.Create(path);
            }

            var data = "";
            foreach (var setting in m_AppSettings)
            {
                data += $"{setting.Key}, {setting.Value}\n";
            }

            File.WriteAllText(path, data);
        }

        public static T GetAppSetting<T>(string key)
        {
            try
            {
                var appSetting = m_AppSettings[key];

                if (!string.IsNullOrWhiteSpace(appSetting))
                {
                    var converter = TypeDescriptor.GetConverter(typeof(T));
                    return (T) (converter.ConvertFromInvariantString(appSetting));
                }

                return default(T);
            }
            catch
            {
                return default(T);
            }
        }

        public static object GetProperty(string name)
        {
            return CurrentProfile.GetProperty(name);
        }

        public static void SetProperty(string name, object val)
        {
            CurrentProfile.SetProperty(name, val);
        }

        public static void AddProperty(string name, object val)
        {
            CurrentProfile.AddProperty(name, val);
        }

        public static bool GetBool(string name)
        {
            return (bool) CurrentProfile.GetProperty(name);
        }

        public static string GetString(string name)
        {
            return (string) CurrentProfile.GetProperty(name);
        }

        public static int GetInt(string name)
        {
            return (int) CurrentProfile.GetProperty(name);
        }

        public static double GetDouble(string name)
        {
            return (double) CurrentProfile.GetProperty(name);
        }

        public static bool SetAppSetting(string key, string value)
        {
            try
            {
                m_AppSettings[key] = value;
                SaveAppSettings();

                return true;
            }
            catch
            {
                return false;
            }
        }

        public static void RecursiveCopy(string oldDir, string newDir, bool overWrite = false)
        {
            Engine.EnsureDirectory(newDir);

            if (!Directory.Exists(oldDir))
                return;

            string[] files = Directory.GetFiles(oldDir);
            foreach (string f in files)
                File.Copy(Path.Combine(oldDir, Path.GetFileName(f)), Path.Combine(newDir, Path.GetFileName(f)),
                    overWrite);

            string[] dirs = Directory.GetDirectories(oldDir);
            foreach (string d in dirs)
                RecursiveCopy(Path.Combine(oldDir, Path.GetDirectoryName(d)),
                    Path.Combine(newDir, Path.GetDirectoryName(d)), overWrite);
        }

        public static void CopyUserFiles(string appDir, string name)
        {
            RecursiveCopy(Path.Combine(GetInstallDirectory(), name), Path.Combine(appDir, name));
        }

        public static void ImportProfilesMacros(string appDataSource)
        {
            RecursiveCopy(Path.Combine(appDataSource, "Profiles"), Path.Combine(GetInstallDirectory(), "Profiles"),
                true);

            RecursiveCopy(Path.Combine(appDataSource, "Macros"), Path.Combine(GetInstallDirectory(), "Macros"), true);

            File.Copy(Path.Combine(appDataSource, "counters.xml"), Path.Combine(GetInstallDirectory(), "counters.xml"),
                true);
        }

        public static string GetUserDirectory(string name)
        {
            string appDir = GetInstallDirectory();

            if (!Directory.Exists(Path.Combine(appDir, "Macros")))
            {
                Directory.CreateDirectory(Path.Combine(appDir, "Macros"));
            }

            if (!Directory.Exists(Path.Combine(appDir, "Profiles")))
            {
                Directory.CreateDirectory(Path.Combine(appDir, "Profiles"));
            }

            if (!Directory.Exists(Path.Combine(appDir, "Scripts")))
            {
                Directory.CreateDirectory(Path.Combine(appDir, "Scripts"));
            }

            name = name.Length > 0 ? Path.Combine(appDir, name) : appDir;

            Engine.EnsureDirectory(name);

            return name;
        }

        public static string GetUserDirectory()
        {
            return GetUserDirectory("");
        }

        public static string GetInstallDirectory(string name)
        {
            string dir = Engine.RootPath;

            if (name.Length > 0)
            {
                dir = Path.Combine(dir, name);
            }

            Engine.EnsureDirectory(dir);

            return dir;
        }

        public static string GetInstallDirectory()
        {
            return GetInstallDirectory("");
        }

        public static string LastProfileName
        {
            get => GetAppSetting<string>("LastProfile");
            set => SetAppSetting("LastProfile", value);
        }
    }
}

================================================
FILE: Razor/UI/ContainerLabels.Designer.cs
================================================
namespace Assistant.UI
{
    partial class ContainerLabels
    {
        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.cancelContainerLabels = new System.Windows.Forms.Button();
            this.saveContainerLabels = new System.Windows.Forms.Button();
            this.lblFormat = new System.Windows.Forms.Label();
            this.containerLabelFormat = new System.Windows.Forms.TextBox();
            this.removeContainerLabel = new System.Windows.Forms.Button();
            this.addContainLabel = new System.Windows.Forms.Button();
            this.containerView = new System.Windows.Forms.ListView();
            this.containerId = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader()));
            this.containerType = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader()));
            this.containerLabel = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader()));
            this.containerAlias = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader()));
            this.setExHue = new System.Windows.Forms.Button();
            this.lblContainerHue = new System.Windows.Forms.Label();
            this.setColorHue = new System.Windows.Forms.Button();
            this.asciiStyle = new System.Windows.Forms.RadioButton();
            this.unicodeStyle = new System.Windows.Forms.RadioButton();
            this.lblStyle = new System.Windows.Forms.Label();
            this.setAlias = new System.Windows.Forms.Button();
            this.SuspendLayout();
            // 
            // cancelContainerLabels
            // 
            this.cancelContainerLabels.Location = new System.Drawing.Point(449, 240);
            this.cancelContainerLabels.Name = "cancelContainerLabels";
            this.cancelContainerLabels.Size = new System.Drawing.Size(54, 28);
            this.cancelContainerLabels.TabIndex = 20;
            this.cancelContainerLabels.Text = "Cancel";
            this.cancelContainerLabels.UseVisualStyleBackColor = true;
            this.cancelContainerLabels.Click += new System.EventHandler(this.cancelOverheadMessages_Click);
            // 
            // saveContainerLabels
            // 
            this.saveContainerLabels.Location = new System.Drawing.Point(507, 240);
            this.saveContainerLabels.Name = "saveContainerLabels";
            this.saveContainerLabels.Size = new System.Drawing.Size(50, 28);
            this.saveContainerLabels.TabIndex = 19;
            this.saveContainerLabels.Text = "OK";
            this.saveContainerLabels.UseVisualStyleBackColor = true;
            this.saveContainerLabels.Click += new System.EventHandler(this.saveContainerLabels_Click);
            // 
            // lblFormat
            // 
            this.lblFormat.AutoSize = true;
            this.lblFormat.Location = new System.Drawing.Point(12, 240);
            this.lblFormat.Name = "lblFormat";
            this.lblFormat.Size = new System.Drawing.Size(79, 15);
            this.lblFormat.TabIndex = 30;
            this.lblFormat.Text = "Label Format:";
            // 
            // containerLabelFormat
            // 
            this.containerLabelFormat.Location = new System.Drawing.Point(97, 237);
            this.containerLabelFormat.Name = "containerLabelFormat";
            this.containerLabelFormat.Size = new System.Drawing.Size(132, 23);
            this.containerLabelFormat.TabIndex = 29;
            this.containerLabelFormat.Text = "[{label}] ({name})";
            this.containerLabelFormat.TextAlign = System.Windows.Forms.HorizontalAlignment.Center;
            // 
            // removeContainerLabel
            // 
            this.removeContainerLabel.Location = new System.Drawing.Point(449, 150);
            this.removeContainerLabel.Name = "removeContainerLabel";
            this.removeContainerLabel.Size = new System.Drawing.Size(108, 40);
            this.removeContainerLabel.TabIndex = 28;
            this.removeContainerLabel.Text = "Remove Selected";
            this.removeContainerLabel.UseVisualStyleBackColor = true;
            this.removeContainerLabel.Click += new System.EventHandler(this.removeContainerLabel_Click);
            // 
            // addContainLabel
            // 
            this.addContainLabel.Location = new System.Drawing.Point(449, 12);
            this.addContainLabel.Name = "addContainLabel";
            this.addContainLabel.Size = new System.Drawing.Size(108, 40);
            this.addContainLabel.TabIndex = 27;
            this.addContainLabel.Text = "Add Container Label";
            this.addContainLabel.UseVisualStyleBackColor = true;
            this.addContainLabel.Click += new System.EventHandler(this.addContainLabel_Click);
            // 
            // containerView
            // 
            this.containerView.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] {
            this.containerId,
            this.containerType,
            this.containerLabel,
            this.containerAlias});
            this.containerView.FullRowSelect = true;
            this.containerView.Location = new System.Drawing.Point(12, 12);
            this.containerView.MultiSelect = false;
            this.containerView.Name = "containerView";
            this.containerView.Size = new System.Drawing.Size(431, 215);
            this.containerView.TabIndex = 22;
            this.containerView.UseCompatibleStateImageBehavior = false;
            this.containerView.View = System.Windows.Forms.View.Details;
            this.containerView.MouseDown += new System.Windows.Forms.MouseEventHandler(this.OnMouseDownContainerView);
            // 
            // containerId
            // 
            this.containerId.Text = "ID";
            this.containerId.Width = 88;
            // 
            // containerType
            // 
            this.containerType.Text = "Type";
            this.containerType.Width = 100;
            // 
            // containerLabel
            // 
            this.containerLabel.Text = "Label";
            this.containerLabel.Width = 132;
            // 
            // containerAlias
            // 
            this.containerAlias.Text = "Alias";
            this.containerAlias.Width = 106;
            // 
            // setExHue
            // 
            this.setExHue.Location = new System.Drawing.Point(182, 263);
            this.setExHue.Name = "setExHue";
            this.setExHue.Size = new System.Drawing.Size(47, 21);
            this.setExHue.TabIndex = 39;
            this.setExHue.Text = "Set";
            this.setExHue.Click += new System.EventHandler(this.setExHue_Click);
            // 
            // lblContainerHue
            // 
            this.lblContainerHue.Location = new System.Drawing.Point(12, 263);
            this.lblContainerHue.Name = "lblContainerHue";
            this.lblContainerHue.Size = new System.Drawing.Size(217, 21);
            this.lblContainerHue.TabIndex = 38;
            this.lblContainerHue.Text = "Default Label Hue:";
            this.lblContainerHue.TextAlign = System.Drawing.ContentAlignment.MiddleLeft;
            // 
            // setColorHue
            // 
            this.setColorHue.Location = new System.Drawing.Point(449, 58);
            this.setColorHue.Name = "setColorHue";
            this.setColorHue.Size = new System.Drawing.Size(108, 40);
            this.setColorHue.TabIndex = 40;
            this.setColorHue.Text = "Set Color/Hue";
            this.setColorHue.UseVisualStyleBackColor = true;
            this.setColorHue.Click += new System.EventHandler(this.setColorHue_Click);
            // 
            // asciiStyle
            // 
            this.asciiStyle.AutoSize = true;
            this.asciiStyle.Location = new System.Drawing.Point(309, 238);
            this.asciiStyle.Name = "asciiStyle";
            this.asciiStyle.Size = new System.Drawing.Size(53, 19);
            this.asciiStyle.TabIndex = 41;
            this.asciiStyle.TabStop = true;
            this.asciiStyle.Text = "ASCII";
            this.asciiStyle.UseVisualStyleBackColor = true;
            // 
            // unicodeStyle
            // 
            this.unicodeStyle.AutoSize = true;
            this.unicodeStyle.Location = new System.Drawing.Point(309, 263);
            this.unicodeStyle.Name = "unicodeStyle";
            this.unicodeStyle.Size = new System.Drawing.Size(69, 19);
            this.unicodeStyle.TabIndex = 42;
            this.unicodeStyle.TabStop = true;
            this.unicodeStyle.Text = "Unicode";
            this.unicodeStyle.UseVisualStyleBackColor = true;
            // 
            // lblStyle
            // 
            this.lblStyle.AutoSize = true;
            this.lblStyle.Location = new System.Drawing.Point(237, 240);
            this.lblStyle.Name = "lblStyle";
            this.lblStyle.Size = new System.Drawing.Size(66, 15);
            this.lblStyle.TabIndex = 43;
            this.lblStyle.Text = "Label Style:";
            // 
            // setAlias
            // 
            this.setAlias.Location = new System.Drawing.Point(449, 104);
            this.setAlias.Name = "setAlias";
            this.setAlias.Size = new System.Drawing.Size(108, 40);
            this.setAlias.TabIndex = 44;
            this.setAlias.Text = "Set Container Alias";
            this.setAlias.UseVisualStyleBackColor = true;
            this.setAlias.Click += new System.EventHandler(this.setAlias_Click);
            // 
            // ContainerLabels
            // 
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.None;
            this.ClientSize = new System.Drawing.Size(569, 291);
            this.Controls.Add(this.setAlias);
            this.Controls.Add(this.lblStyle);
            this.Controls.Add(this.unicodeStyle);
            this.Controls.Add(this.asciiStyle);
            this.Controls.Add(this.setColorHue);
            this.Controls.Add(this.setExHue);
            this.Controls.Add(this.lblContainerHue);
            this.Controls.Add(this.lblFormat);
            this.Controls.Add(this.containerLabelFormat);
            this.Controls.Add(this.removeContainerLabel);
            this.Controls.Add(this.addContainLabel);
            this.Controls.Add(this.containerView);
            this.Controls.Add(this.cancelContainerLabels);
            this.Controls.Add(this.saveContainerLabels);
            this.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog;
            this.MaximizeBox = false;
            this.Name = "ContainerLabels";
            this.Text = "Container Labels";
            this.Load += new System.EventHandler(this.ContainerLabels_Load);
            this.ResumeLayout(false);
            this.PerformLayout();
            this.Closing += new System.ComponentModel.CancelEventHandler(this.ContainerLabels_Closing);

        }

        #endregion
        private System.Windows.Forms.Button cancelContainerLabels;
        private System.Windows.Forms.Button saveContainerLabels;
        private System.Windows.Forms.Label lblFormat;
        private System.Windows.Forms.TextBox containerLabelFormat;
        private System.Windows.Forms.Button removeContainerLabel;
        private System.Windows.Forms.Button addContainLabel;
        private System.Windows.Forms.ListView containerView;
        private System.Windows.Forms.ColumnHeader containerId;
        private System.Windows.Forms.ColumnHeader containerType;
        private System.Windows.Forms.ColumnHeader containerLabel;
        private System.Windows.Forms.Button setExHue;
        private System.Windows.Forms.Label lblContainerHue;
        private System.Windows.Forms.Button setColorHue;
        private System.Windows.Forms.RadioButton asciiStyle;
        private System.Windows.Forms.RadioButton unicodeStyle;
        private System.Windows.Forms.Label lblStyle;
        private System.Windows.Forms.ColumnHeader containerAlias;
        private System.Windows.Forms.Button setAlias;
    }
}

================================================
FILE: Razor/UI/ContainerLabels.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using Assistant.Macros;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Windows.Forms;
using Ultima;

namespace Assistant.UI
{
    public partial class ContainerLabels : Form
    {
        // Used to track new entries in the form's life
        private List<Core.ContainerLabels.ContainerLabel> NewContainerEntries =
            new List<Core.ContainerLabels.ContainerLabel>();

        public ContainerLabels()
        {
            InitializeComponent();
        }

        private void ContainerLabels_Load(object sender, EventArgs e)
        {
            foreach (Core.ContainerLabels.ContainerLabel list in Core.ContainerLabels.ContainerLabelList)
            {
                ListViewItem item = new ListViewItem($"{list.Id}");
                item.SubItems.Add(new ListViewItem.ListViewSubItem(item, list.Type));
                item.SubItems.Add(new ListViewItem.ListViewSubItem(item, list.Label));
                item.SubItems.Add(new ListViewItem.ListViewSubItem(item, list.Alias));

                int hueIdx = list.Hue;

                if (hueIdx > 0 && hueIdx < 3000)
                    item.SubItems[2].BackColor = Ultima.Hues.GetHue(hueIdx - 1).GetColor(HueEntry.TextHueIDX);
                else
                    item.SubItems[2].BackColor = SystemColors.Control;

                item.SubItems[2].ForeColor =
                    (item.SubItems[2].BackColor.GetBrightness() < 0.35 ? Color.White : Color.Black);

                item.UseItemStyleForSubItems = false;

                containerView.SafeAction(s => s.Items.Add(item));
            }

            containerLabelFormat.SafeAction(s => s.Text = Config.GetString("ContainerLabelFormat"));
            InitPreviewHue(lblContainerHue, "ContainerLabelColor");

            if (Config.GetInt("ContainerLabelStyle") == 0)
            {
                asciiStyle.SafeAction(s => s.Checked = true);
            }
            else
            {
                unicodeStyle.SafeAction(s => s.Checked = true);
            }
        }

        private void InitPreviewHue(Control ctrl, string cfg)
        {
            int hueIdx = Config.GetInt(cfg);

            if (hueIdx > 0 && hueIdx < 3000)
                ctrl.BackColor = Ultima.Hues.GetHue(hueIdx - 1).GetColor(HueEntry.TextHueIDX);
            else
                ctrl.BackColor = SystemColors.Control;

            ctrl.ForeColor = (ctrl.BackColor.GetBrightness() < 0.35 ? Color.White : Color.Black);
        }

        private void saveContainerLabels_Click(object sender, EventArgs e)
        {
            List<Core.ContainerLabels.ContainerLabel> newContainerLabelList =
                new List<Core.ContainerLabels.ContainerLabel>();

            // Keep it simple, reset to default if it isn't what we like
            if (string.IsNullOrEmpty(containerLabelFormat.Text) || !containerLabelFormat.Text.Contains("{label}"))
            {
                containerLabelFormat.Text = @"[{label}] ({type})";
            }

            Config.SetProperty("ContainerLabelFormat", containerLabelFormat.Text);

            if (asciiStyle.Checked)
            {
                Config.SetProperty("ContainerLabelStyle", 0);
            }
            else
            {
                Config.SetProperty("ContainerLabelStyle", 1);
            }

            foreach (ListViewItem item in containerView.Items)
            {
                Core.ContainerLabels.ContainerLabel label = new Core.ContainerLabels.ContainerLabel
                {
                    Id = item.SubItems[0].Text,
                    Type = item.SubItems[1].Text,
                    Label = item.SubItems[2].Text,
                    Hue = GetHueFromListView(item.SubItems[0].Text),
                    Alias = item.SubItems[3].Text
                };

                newContainerLabelList.Add(label);
            }

            Core.ContainerLabels.ContainerLabelList =
                new List<Core.ContainerLabels.ContainerLabel>(newContainerLabelList);

            Config.Save();

            this.SafeAction(s => s.Hide());
        }

        private void removeContainerLabel_Click(object sender, EventArgs e)
        {
            if (containerView.SelectedItems.Count > 0)
            {
                containerView.SafeAction(s => s.Items.Remove(containerView.SelectedItems[0]));
            }
        }

        private void cancelOverheadMessages_Click(object sender, EventArgs e)
        {
            this.SafeAction(s => s.Hide());
        }

        private void addContainLabel_Click(object sender, EventArgs e)
        {
            if (MacroManager.Playing || MacroManager.Recording || World.Player == null)
                return;

            Targeting.OneTimeTarget(OnContainerLabelAddTarget);
            World.Player.SendMessage(MsgLevel.Force, LocString.SelTargAct);
        }

        private void OnContainerLabelAddTarget(bool ground, Serial serial, Point3D pt, ushort gfx)
        {
            TargetInfo t = new TargetInfo
            {
                Gfx = gfx,
                Serial = serial,
                Type = (byte) (ground ? 1 : 0),
                X = pt.X,
                Y = pt.Y,
                Z = pt.Z
            };

            if (t != null && t.Serial.IsItem)
            {
                Item item = World.FindItem(t.Serial);

                if (!item.IsContainer)
                {
                    // must be a container
                    World.Player.SendMessage(MsgLevel.Force, "You must select a container");
                }
                else
                {
                    // add it
                    World.Player.SendMessage(MsgLevel.Force, "Container selected, add label text in Razor");

                    if (InputBox.Show(this, Language.GetString(LocString.SetContainerLabel),
                        Language.GetString(LocString.EnterAName)))
                    {
                        string name = InputBox.GetString();

                        ListViewItem lvItem = new ListViewItem($"{t.Serial.Value}");
                        lvItem.SubItems.Add(new ListViewItem.ListViewSubItem(lvItem, item.Name));
                        lvItem.SubItems.Add(new ListViewItem.ListViewSubItem(lvItem, name));
                        lvItem.SubItems.Add(new ListViewItem.ListViewSubItem(lvItem, string.Empty));

                        int hueIdx = Config.GetInt("ContainerLabelColor");

                        if (hueIdx > 0 && hueIdx < 3000)
                            lvItem.SubItems[2].BackColor = Ultima.Hues.GetHue(hueIdx - 1).GetColor(HueEntry.TextHueIDX);
                        else
                            lvItem.SubItems[2].BackColor = SystemColors.Control;

                        lvItem.SubItems[2].ForeColor = (lvItem.SubItems[2].BackColor.GetBrightness() < 0.35
                            ? Color.White
                            : Color.Black);

                        lvItem.UseItemStyleForSubItems = false;

                        containerView.SafeAction(s => s.Items.Add(lvItem));

                        NewContainerEntries.Add(new Core.ContainerLabels.ContainerLabel
                        {
                            Hue = hueIdx,
                            Id = $"{t.Serial.Value}",
                            Label = name,
                            Type = item.Name
                        });

                        World.Player.SendMessage(MsgLevel.Force, $"Container {item} labeled as '{name}'");

                        Show();
                    }
                }
            }
            else if (t != null && t.Serial.IsMobile)
            {
                World.Player.SendMessage(MsgLevel.Force, "You shouldn't label other people");
            }
        }

        private void setExHue_Click(object sender, EventArgs e)
        {
            SetHue(lblContainerHue, "ContainerLabelColor");
        }

        private bool SetHue(Control ctrl, string cfg)
        {
            HueEntry h = new HueEntry(Config.GetInt(cfg));

            if (h.ShowDialog(this) == DialogResult.OK)
            {
                int hueIdx = h.Hue;
                Config.SetProperty(cfg, hueIdx);
                if (hueIdx > 0 && hueIdx < 3000)
                    ctrl.BackColor = Ultima.Hues.GetHue(hueIdx - 1).GetColor(HueEntry.TextHueIDX);
                else
                    ctrl.BackColor = Color.White;
                ctrl.ForeColor = (ctrl.BackColor.GetBrightness() < 0.35 ? Color.White : Color.Black);

                return true;
            }
            else
            {
                return false;
            }
        }

        private void setColorHue_Click(object sender, EventArgs e)
        {
            if (containerView.SelectedItems.Count > 0)
            {
                SetContainerLabelHue();
            }
        }

        private bool SetContainerLabelHue()
        {
            ListViewItem selectedItem = containerView.Items[containerView.SelectedIndices[0]];

            HueEntry h = new HueEntry(GetHueFromListView(selectedItem.SubItems[0].Text));

            // TODO: BREAKING DRY!
            if (h.ShowDialog(this) == DialogResult.OK)
            {
                int hueIdx = h.Hue;

                if (hueIdx > 0 && hueIdx < 3000)
                    selectedItem.SubItems[2].BackColor = Hues.GetHue(hueIdx - 1).GetColor(HueEntry.TextHueIDX);
                else
                    selectedItem.SubItems[2].BackColor = Color.White;

                selectedItem.SubItems[2].ForeColor = (selectedItem.SubItems[2].BackColor.GetBrightness() < 0.35
                    ? Color.White
                    : Color.Black);

                foreach (Core.ContainerLabels.ContainerLabel list in Core.ContainerLabels.ContainerLabelList)
                {
                    if (list.Id.Equals(selectedItem.Text))
                    {
                        list.Hue = hueIdx;
                        break;
                    }
                }

                foreach (Core.ContainerLabels.ContainerLabel list in NewContainerEntries)
                {
                    if (list.Id.Equals(selectedItem.Text))
                    {
                        list.Hue = hueIdx;
                        break;
                    }
                }

                return true;
            }
            else
            {
                return false;
            }
        }

        public int GetHueFromListView(string id)
        {
            int hue = 0;

            foreach (Core.ContainerLabels.ContainerLabel list in Core.ContainerLabels.ContainerLabelList)
            {
                if (list.Id.Equals(id))
                {
                    return list.Hue;
                }
            }

            foreach (Core.ContainerLabels.ContainerLabel list in NewContainerEntries)
            {
                if (list.Id.Equals(id))
                {
                    return list.Hue;
                }
            }

            return hue;
        }

        private void OnMouseDownContainerView(object sender, MouseEventArgs e)
        {
            if (containerView.SelectedItems.Count == 0)
                return;

            if (e.Button == MouseButtons.Right && e.Clicks == 1)
            {
                ContextMenuStrip menu = new ContextMenuStrip();
                menu.Items.Add("Open Container (if in range)", null, new EventHandler(OnContainerDoubleClick));

                menu.Show(containerView, new Point(e.X, e.Y));
            }
        }

        private void OnContainerDoubleClick(object sender, System.EventArgs e)
        {
            ListViewItem selectedItem = containerView.Items[containerView.SelectedIndices[0]];

            Item container = World.FindItem(Serial.Parse(selectedItem.SubItems[0].Text));

            if (!container.IsContainer)
                return;

            World.Player.SendMessage(MsgLevel.Force, "Opening container");

            Client.Instance.SendToServer(new DoubleClick(container.Serial));
        }

        private void setAlias_Click(object sender, EventArgs e)
        {
            if (containerView.SelectedItems.Count > 0)
            {
                ListViewItem selectedItem = containerView.Items[containerView.SelectedIndices[0]];

                if (InputBox.Show(this, Language.GetString(LocString.SetContainerLabel),
                    Language.GetString(LocString.EnterAName)))
                {
                    string name = InputBox.GetString();

                    selectedItem.SubItems[3].Text = name;

                    foreach (Core.ContainerLabels.ContainerLabel list in Core.ContainerLabels.ContainerLabelList)
                    {
                        if (list.Id.Equals(selectedItem.Text))
                        {
                            list.Alias = name;
                            break;
                        }
                    }

                    foreach (Core.ContainerLabels.ContainerLabel list in NewContainerEntries)
                    {
                        if (list.Id.Equals(selectedItem.Text))
                        {
                            list.Alias = name;
                            break;
                        }
                    }
                }
            }
        }

        private void ContainerLabels_Closing(object sender, CancelEventArgs e)
        {
            this.SafeAction(s =>
            {
                e.Cancel = true;
                s.Hide();
            });
        }
    }
}

================================================
FILE: Razor/UI/ContainerLabels.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
</root>

================================================
FILE: Razor/UI/Ext.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Windows.Forms;

namespace Assistant.UI
{
    static class Ext
    {
        public static void SafeAction<TControl>(this TControl control, Action<TControl> action) where TControl : Control
        {
            if (control.InvokeRequired)
            {
                control.Invoke(action, control);
            }
            else
                action(control);
        }
    }
}

================================================
FILE: Razor/UI/HueEntry.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System.Drawing;
using System.Windows.Forms;

namespace Assistant
{
    /// <summary>
    /// Summary description for HueEntry.
    /// </summary>
    public class HueEntry : System.Windows.Forms.Form
    {
        private System.Windows.Forms.Label label1;
        private System.Windows.Forms.TextBox hueNum;
        private System.Windows.Forms.Button inGame;
        private System.Windows.Forms.Label preview;
        private System.Windows.Forms.Button okay;
        private System.Windows.Forms.Button cancel;

        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.Container components = null;

        private int m_Hue;

        public delegate void HueEntryCallback(int hue);

        public static HueEntryCallback Callback = null;

        public int Hue
        {
            get { return m_Hue; }
        }

        public HueEntry() : this(0)
        {
        }

        public HueEntry(int hue)
        {
            m_Hue = hue;
            //
            // Required for Windows Form Designer support
            //
            InitializeComponent();

            //
            // TODO: Add any constructor code after InitializeComponent call
            //
        }

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (components != null)
                {
                    components.Dispose();
                }
            }

            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.label1 = new System.Windows.Forms.Label();
            this.hueNum = new System.Windows.Forms.TextBox();
            this.inGame = new System.Windows.Forms.Button();
            this.preview = new System.Windows.Forms.Label();
            this.okay = new System.Windows.Forms.Button();
            this.cancel = new System.Windows.Forms.Button();
            this.SuspendLayout();
            // 
            // label1
            // 
            this.label1.Location = new System.Drawing.Point(12, 9);
            this.label1.Name = "label1";
            this.label1.Size = new System.Drawing.Size(83, 18);
            this.label1.TabIndex = 0;
            this.label1.Text = "Hue Number:";
            // 
            // hueNum
            // 
            this.hueNum.Location = new System.Drawing.Point(101, 6);
            this.hueNum.Name = "hueNum";
            this.hueNum.Size = new System.Drawing.Size(61, 23);
            this.hueNum.TabIndex = 1;
            this.hueNum.TextChanged += new System.EventHandler(this.hueNum_TextChanged);
            // 
            // inGame
            // 
            this.inGame.Location = new System.Drawing.Point(15, 35);
            this.inGame.Name = "inGame";
            this.inGame.Size = new System.Drawing.Size(147, 35);
            this.inGame.TabIndex = 2;
            this.inGame.Text = "Select in Game";
            this.inGame.Click += new System.EventHandler(this.inGame_Click);
            // 
            // preview
            // 
            this.preview.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
            this.preview.Location = new System.Drawing.Point(15, 73);
            this.preview.Name = "preview";
            this.preview.Size = new System.Drawing.Size(147, 35);
            this.preview.TabIndex = 3;
            this.preview.Text = "Preview";
            this.preview.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
            // 
            // okay
            // 
            this.okay.Location = new System.Drawing.Point(110, 111);
            this.okay.Name = "okay";
            this.okay.Size = new System.Drawing.Size(52, 35);
            this.okay.TabIndex = 4;
            this.okay.Text = "&OK";
            this.okay.Click += new System.EventHandler(this.okay_Click);
            // 
            // cancel
            // 
            this.cancel.DialogResult = System.Windows.Forms.DialogResult.Cancel;
            this.cancel.Location = new System.Drawing.Point(15, 111);
            this.cancel.Name = "cancel";
            this.cancel.Size = new System.Drawing.Size(52, 35);
            this.cancel.TabIndex = 5;
            this.cancel.Text = "Cancel";
            this.cancel.Click += new System.EventHandler(this.cancel_Click);
            // 
            // HueEntry
            // 
            this.AcceptButton = this.okay;
            this.AutoScaleBaseSize = new System.Drawing.Size(6, 16);
            this.CancelButton = this.cancel;
            this.ClientSize = new System.Drawing.Size(177, 154);
            this.ControlBox = false;
            this.Controls.Add(this.hueNum);
            this.Controls.Add(this.cancel);
            this.Controls.Add(this.okay);
            this.Controls.Add(this.preview);
            this.Controls.Add(this.inGame);
            this.Controls.Add(this.label1);
            this.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular,
                System.Drawing.GraphicsUnit.Point, ((byte) (0)));
            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog;
            this.MaximizeBox = false;
            this.MinimizeBox = false;
            this.Name = "HueEntry";
            this.ShowInTaskbar = false;
            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
            this.Text = "Select a Hue";
            this.Load += new System.EventHandler(this.HueEntry_Load);
            this.ResumeLayout(false);
            this.PerformLayout();
        }

        #endregion

        private void hueNum_TextChanged(object sender, System.EventArgs e)
        {
            SetPreview(Utility.ToInt32(hueNum.Text, 0) & 0x3FFF);
        }

        public const int TextHueIDX = 30;

        private void SetPreview(int hue)
        {
            if (hue > 0 && hue < 3000)
                preview.BackColor = Ultima.Hues.GetHue(hue - 1).GetColor(TextHueIDX);
            else
                preview.BackColor = Color.Black;
            preview.ForeColor = (preview.BackColor.GetBrightness() < 0.35 ? Color.White : Color.Black);
        }

        private void HueResp(int hue)
        {
            hue &= 0x3FFF;
            SetPreview(hue);
            hueNum.Text = hue.ToString();
            Callback = null;

            //Engine.MainWindow.SafeAction(s => s.ShowMe());
            if (Client.IsOSI) // With CUO, this cancels the window not saving the result
                this.Hide();

            this.SendToBack();
            this.WindowState = FormWindowState.Normal;
            this.BringToFront();
            this.Show();
        }

        private void inGame_Click(object sender, System.EventArgs e)
        {
            if (World.Player == null)
                return;

            Callback = new HueEntryCallback(HueResp);
            Client.Instance.SendToClient(new HuePicker());
            World.Player.SendMessage(MsgLevel.Force, LocString.SelHue);
        }

        private void okay_Click(object sender, System.EventArgs e)
        {
            m_Hue = Utility.ToInt32(hueNum.Text, 0);
            this.DialogResult = DialogResult.OK;
            this.Close();
            Callback = null;
        }

        private void cancel_Click(object sender, System.EventArgs e)
        {
            this.DialogResult = DialogResult.Cancel;
            this.Close();
            Callback = null;
        }

        private void HueEntry_Load(object sender, System.EventArgs e)
        {
            Language.LoadControlNames(this);

            SetPreview(m_Hue);
            hueNum.Text = m_Hue.ToString();
        }
    }
}

================================================
FILE: Razor/UI/HueEntry.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
</root>

================================================
FILE: Razor/UI/InputBox.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Windows.Forms;

namespace Assistant
{
    /// <summary>
    /// Summary description for NewProfile.
    /// </summary>
    public class InputBox : System.Windows.Forms.Form
    {
        private static InputBox m_Instance;

        public static bool Show(string prompt)
        {
            return Show(null, prompt, Language.GetString(LocString.InputReq), "");
        }

        public static bool Show(string prompt, string title)
        {
            return Show(null, prompt, title, "");
        }

        public static bool Show(string prompt, string title, string def)
        {
            return Show(null, prompt, title, def);
        }

        public static bool Show(Form parent, string prompt)
        {
            return Show(parent, prompt, Language.GetString(LocString.InputReq), "");
        }

        public static bool Show(Form parent, string prompt, string title)
        {
            return Show(parent, prompt, title, "");
        }

        public static bool Show(Form parent, string prompt, string title, string def)
        {
            if (m_Instance == null)
                m_Instance = new InputBox();
            m_Instance.Prompt.Text = prompt;
            m_Instance.Text = title;
            m_Instance.m_String = "";
            m_Instance.EntryBox.Text = def;

            if (parent != null)
                return m_Instance.ShowDialog() == DialogResult.OK;
            else
                return m_Instance.ShowDialog(parent) == DialogResult.OK;
        }

        public static string GetString()
        {
            return m_Instance != null ? m_Instance.m_String : null;
        }

        public static int GetInt(int def)
        {
            try
            {
                string conv = m_Instance.m_String;
                int b = 10;
                if (conv[0] == '0' && conv[1] == 'x')
                {
                    b = 16;
                    conv = conv.Substring(2);
                }
                else if (conv[0] == 'x' || conv[0] == 'X')
                {
                    b = 16;
                    conv = conv.Substring(1);
                }

                return Convert.ToInt32(conv, b);
            }
            catch
            {
                return def;
            }
        }

        public static int GetInt()
        {
            return GetInt(0);
        }

        private string m_String;
        private System.Windows.Forms.Button ok;
        private System.Windows.Forms.Button cancel;
        private System.Windows.Forms.Label Prompt;
        private System.Windows.Forms.TextBox EntryBox;

        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.Container components = null;

        private InputBox()
        {
            //
            // Required for Windows Form Designer support
            //
            InitializeComponent();

            //
            // TODO: Add any constructor code after InitializeComponent call
            //
        }

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (components != null)
                {
                    components.Dispose();
                }
            }

            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.Prompt = new System.Windows.Forms.Label();
            this.EntryBox = new System.Windows.Forms.TextBox();
            this.ok = new System.Windows.Forms.Button();
            this.cancel = new System.Windows.Forms.Button();
            this.SuspendLayout();
            // 
            // Prompt
            // 
            this.Prompt.Location = new System.Drawing.Point(12, 9);
            this.Prompt.Name = "Prompt";
            this.Prompt.Size = new System.Drawing.Size(210, 16);
            this.Prompt.TabIndex = 0;
            this.Prompt.Text = ":";
            // 
            // EntryBox
            // 
            this.EntryBox.Location = new System.Drawing.Point(12, 28);
            this.EntryBox.Name = "EntryBox";
            this.EntryBox.Size = new System.Drawing.Size(243, 23);
            this.EntryBox.TabIndex = 1;
            // 
            // ok
            // 
            this.ok.Location = new System.Drawing.Point(186, 57);
            this.ok.Name = "ok";
            this.ok.Size = new System.Drawing.Size(69, 30);
            this.ok.TabIndex = 2;
            this.ok.Text = "Okay";
            this.ok.Click += new System.EventHandler(this.ok_Click);
            // 
            // cancel
            // 
            this.cancel.DialogResult = System.Windows.Forms.DialogResult.Cancel;
            this.cancel.Location = new System.Drawing.Point(15, 57);
            this.cancel.Name = "cancel";
            this.cancel.Size = new System.Drawing.Size(69, 30);
            this.cancel.TabIndex = 3;
            this.cancel.Text = "Cancel";
            this.cancel.Click += new System.EventHandler(this.cancel_Click);
            // 
            // InputBox
            // 
            this.AcceptButton = this.ok;
            this.AutoScaleBaseSize = new System.Drawing.Size(6, 16);
            this.CancelButton = this.cancel;
            this.ClientSize = new System.Drawing.Size(266, 94);
            this.ControlBox = false;
            this.Controls.Add(this.cancel);
            this.Controls.Add(this.ok);
            this.Controls.Add(this.EntryBox);
            this.Controls.Add(this.Prompt);
            this.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular,
                System.Drawing.GraphicsUnit.Point, ((byte) (0)));
            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog;
            this.Name = "InputBox";
            this.ShowInTaskbar = false;
            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
            this.Text = "Input";
            this.Load += new System.EventHandler(this.InputBox_Load);
            this.ResumeLayout(false);
            this.PerformLayout();
        }

        #endregion

        private void ok_Click(object sender, System.EventArgs e)
        {
            m_String = EntryBox.Text.Trim();
            this.DialogResult = DialogResult.OK;
            this.Close();
        }

        private void cancel_Click(object sender, System.EventArgs e)
        {
            this.DialogResult = DialogResult.Cancel;
            this.Close();
        }

        private void InputBox_Load(object sender, System.EventArgs e)
        {
            Language.LoadControlNames(this);

            if (this.Location.X <= 0 || this.Location.Y <= 0)
                this.Location = new System.Drawing.Point(Config.GetInt("WindowX"), Config.GetInt("WindowY"));

            this.WindowState = FormWindowState.Normal;
            this.BringToFront();
            this.TopMost = true;

            _ShowTimer = new System.Windows.Forms.Timer();
            _ShowTimer.Interval = 250;
            _ShowTimer.Enabled = true;
            _ShowTimer.Tick += new EventHandler(timer_Tick);
        }

        private System.Windows.Forms.Timer _ShowTimer;

        private void timer_Tick(object sender, EventArgs e)
        {
            this.TopMost = false;
            this.BringToFront();
            this.Activate();

            EntryBox.Focus();

            if (_ShowTimer != null)
                _ShowTimer.Stop();
        }
    }
}

================================================
FILE: Razor/UI/InputBox.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
</root>

================================================
FILE: Razor/UI/InputDropdown.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.ComponentModel;
using System.Windows.Forms;

namespace Assistant
{
    /// <summary>
    /// Summary description for NewProfile.
    /// </summary>
    public class InputDropdown : System.Windows.Forms.Form
    {
        private static InputDropdown m_Instance;


        public static bool Show(Form parent, string prompt, string[] dropDownItems)
        {
            return Show(parent, prompt, dropDownItems, Language.GetString(LocString.InputReq));
        }

        public static bool Show(Form parent, string prompt, string title)
        {
            return Show(parent, prompt, new string[] { }, title);
        }

        public static bool Show(Form parent, string prompt, string[] dropDownItems, string title)
        {
            if (m_Instance == null)
                m_Instance = new InputDropdown();
            m_Instance.Prompt.Text = prompt;
            m_Instance.Text = title;
            m_Instance.m_String = "";

            m_Instance.EntryCombo.Items.Clear();
            m_Instance.EntryCombo.Items.AddRange(dropDownItems);
            m_Instance.EntryCombo.SelectedIndex = 0;

            if (parent != null)
                return m_Instance.ShowDialog() == DialogResult.OK;
            else
                return m_Instance.ShowDialog(parent) == DialogResult.OK;
        }

        public static string GetString()
        {
            return m_Instance != null ? m_Instance.m_String : null;
        }

        public static int GetInt(int def)
        {
            try
            {
                string conv = m_Instance.m_String;
                int b = 10;
                if (conv[0] == '0' && conv[1] == 'x')
                {
                    b = 16;
                    conv = conv.Substring(2);
                }
                else if (conv[0] == 'x' || conv[0] == 'X')
                {
                    b = 16;
                    conv = conv.Substring(1);
                }

                return Convert.ToInt32(conv, b);
            }
            catch
            {
                return def;
            }
        }

        public static int GetInt()
        {
            return GetInt(0);
        }

        private string m_String;
        private System.Windows.Forms.Button ok;
        private System.Windows.Forms.Button cancel;
        private System.Windows.Forms.Label Prompt;
        private ComboBox EntryCombo;

        /// <summary>
        /// Required designer variable.
        /// </summary>
        private Container components = null;

        private InputDropdown()
        {
            //
            // Required for Windows Form Designer support
            //
            InitializeComponent();

            //
            // TODO: Add any constructor code after InitializeComponent call
            //
        }

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (components != null)
                {
                    components.Dispose();
                }
            }

            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.Prompt = new System.Windows.Forms.Label();
            this.ok = new System.Windows.Forms.Button();
            this.cancel = new System.Windows.Forms.Button();
            this.EntryCombo = new System.Windows.Forms.ComboBox();
            this.SuspendLayout();
            // 
            // Prompt
            // 
            this.Prompt.Location = new System.Drawing.Point(12, 9);
            this.Prompt.Name = "Prompt";
            this.Prompt.Size = new System.Drawing.Size(210, 16);
            this.Prompt.TabIndex = 0;
            this.Prompt.Text = ":";
            // 
            // ok
            // 
            this.ok.Location = new System.Drawing.Point(150, 57);
            this.ok.Name = "ok";
            this.ok.Size = new System.Drawing.Size(69, 30);
            this.ok.TabIndex = 2;
            this.ok.Text = "Okay";
            this.ok.Click += new System.EventHandler(this.ok_Click);
            // 
            // cancel
            // 
            this.cancel.DialogResult = System.Windows.Forms.DialogResult.Cancel;
            this.cancel.Location = new System.Drawing.Point(12, 57);
            this.cancel.Name = "cancel";
            this.cancel.Size = new System.Drawing.Size(69, 30);
            this.cancel.TabIndex = 3;
            this.cancel.Text = "Cancel";
            this.cancel.Click += new System.EventHandler(this.cancel_Click);
            // 
            // EntryCombo
            // 
            this.EntryCombo.FormattingEnabled = true;
            this.EntryCombo.Location = new System.Drawing.Point(12, 28);
            this.EntryCombo.Name = "EntryCombo";
            this.EntryCombo.Size = new System.Drawing.Size(207, 23);
            this.EntryCombo.TabIndex = 4;
            // 
            // InputDropdown
            // 
            this.AcceptButton = this.ok;
            this.AutoScaleBaseSize = new System.Drawing.Size(6, 16);
            this.CancelButton = this.cancel;
            this.ClientSize = new System.Drawing.Size(232, 94);
            this.ControlBox = false;
            this.Controls.Add(this.EntryCombo);
            this.Controls.Add(this.cancel);
            this.Controls.Add(this.ok);
            this.Controls.Add(this.Prompt);
            this.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular,
                System.Drawing.GraphicsUnit.Point, ((byte) (0)));
            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog;
            this.Name = "InputDropdown";
            this.ShowInTaskbar = false;
            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
            this.Text = "Input";
            this.Load += new System.EventHandler(this.InputDropdown_Load);
            this.ResumeLayout(false);
        }

        #endregion

        private void ok_Click(object sender, System.EventArgs e)
        {
            m_String = EntryCombo.Text.Trim();
            this.DialogResult = DialogResult.OK;
            this.Close();
        }

        private void cancel_Click(object sender, System.EventArgs e)
        {
            this.DialogResult = DialogResult.Cancel;
            this.Close();
        }

        private void InputDropdown_Load(object sender, System.EventArgs e)
        {
            Language.LoadControlNames(this);

            if (this.Location.X <= 0 || this.Location.Y <= 0)
                this.Location = new System.Drawing.Point(Config.GetInt("WindowX"), Config.GetInt("WindowY"));

            this.WindowState = FormWindowState.Normal;
            this.BringToFront();
            this.TopMost = true;

            _ShowTimer = new System.Windows.Forms.Timer();
            _ShowTimer.Interval = 250;
            _ShowTimer.Enabled = true;
            _ShowTimer.Tick += new EventHandler(timer_Tick);
        }

        private System.Windows.Forms.Timer _ShowTimer;

        private void timer_Tick(object sender, EventArgs e)
        {
            this.TopMost = false;
            this.BringToFront();
            this.Activate();

            EntryCombo.Focus();

            if (_ShowTimer != null)
                _ShowTimer.Stop();
        }
    }
}

================================================
FILE: Razor/UI/InputDropdown.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
</root>

================================================
FILE: Razor/UI/Languages.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

//#define LOG_CONTROL_TEXT

using System;
using System.Text;
using System.IO;
using System.Collections;
using System.Windows.Forms;
using Ultima;

namespace Assistant
{
    #region Localization enum

    //1044060 = Alchemy in UO cliloc
    public enum LocString : int
    {
        Null = 0,

        __Start = 1000,
        DeathStatus,
        BardMusic,
        DogSounds,
        CatSounds,
        HorseSounds,
        SheepSounds,
        SS_Sound,
        FizzleSound,
        Weather,
        DispCounters,
        RecountCounters,
        ClearAbility,
        SetPrimAb,
        SetSecAb,
        ToggleStun,
        ToggleDisarm,
        SettingAOSAb,
        AOSAbCleared,
        UndressAll,
        UndressHands,
        UndressLeft,
        UndressRight,
        UndressHat,
        UndressJewels,
        BandageSelf,
        BandageLT,
        UseBandage,
        DrinkHeal,
        DrinkCure,
        DrinkRef,
        DrinkNS,
        DrinkExp,
        DrinkStr,
        DrinkAg,
        NoBandages,
        NoItemOfType,
        DClickA1,
        ReTarget,
        Conv2DCT,
        SelTargAct,
        ProfileLoadEx,
        MacroItemOutRange,
        LiftA10,
        ConvLiftByType,
        MacroNoHold,
        EquipTo,
        DropA2,
        ConvRelLoc,
        DropRelA3,
        GumpRespB, //1050
        CloseGump,
        MenuRespA1,
        MacroNoTarg,
        AbsTarg,
        ConvLT,
        ConvTargType,
        TargRelLocA3,
        LastTarget,
        TargetSelf,
        SetLT,
        TargRandRed,
        TargRandGrey,
        TargRandBlue,
        TargRandEnemy,
        TargRandFriend,
        TargRandNFriend,
        SayQA1,
        UseSkillA1,
        CastSpellA1,
        SetAbilityA1,
        DressA1,
        UndressA1,
        UndressLayerA1,
        WaitAnyMenu,
        WaitMenuA1,
        Edit,
        WaitAnyGump,
        WaitGumpA1,
        WaitTarg,
        PauseA1,
        WaitA3,
        LoadingA1,
        StopCurrent,
        PlayA1,
        PlayingA1,
        MacroFinished,
        InitError,
        IE_1,
        IE_2,
        IE_3,
        IE_4,
        IE_5,
        IE_6, // InitError.NO_PATCH
        IE_7,
        NoMemCpy,
        SkillChanged,
        InvalidAbrev,
        InvalidIID,
        InvalidHue,
        SelItem2Count, // 1100
        ProfileCorrupt,
        NoProp,
        CounterFux,
        NoAutoCount,
        CountLow,
        SelHue,
        TakeSS,
        TitleBarTip,
        RazorStatus1,
        SetSLUp,
        SetSLDown,
        SetSLLocked,
        ConfirmDelCounter,
        ProfLoadQ,
        ProfLoadE,
        NoDelete,
        EnterProfileName,
        ProfExists,
        DressName,
        DelDressQ,
        OutOfRangeA1,
        DelDressItemQ,
        TargUndressBag,
        UB_Set,
        ItemNotFound,
        KeyUsed,
        SaveOK,
        PacketLogWarn,
        Conv2Type,
        NewMacro,
        InvalidChars,
        MacroExists,
        MacroConfRec,
        DelConf,
        InsWait,
        InsLT,
        MoveUp,
        MoveDown,
        RemAct,
        BeginRec,
        FileNotFoundA1,
        Confirm,
        FileDelError,
        NextRestart,
        PWWarn,
        NeedPort,
        QueueIgnore,
        ActQueued,
        QueueFinished,
        UseOnceAgent, // 1150
        AddTarg,
        AddContTarg,
        RemoveTarg,
        ClearList,
        TargItemAdd,
        TargCont,
        TargItemRem,
        ItemAdded,
        ItemRemoved,
        ItemsAdded,
        UseOnceEmpty,
        UseOnceStatus,
        UseOnceError,
        SellTotals,
        Remove,
        ContSet,
        Clear,
        PushDisable,
        PushEnable,
        SetHB,
        ClearHB,
        OrganizerAgent,
        Organizer,
        OrganizeNow,
        ContNotSet,
        NoBackpack,
        OrgQueued,
        OrgNoItems,
        ItemExists,
        AutoSearchEx,
        BuyTotals,
        BuyLowGold,
        EnterAmount,
        PrioSet,
        CurTime,
        CurLoc,
        UndressBagRange,
        UndressQueued,
        DressQueued,
        AlreadyDressed,
        ItemsNotFound,
        NoSpells,
        StealthSteps,
        StealthStart,
        ClearTargQueue,
        AttackLastComb,
        TQCleared,
        TargSetLT,
        LTSet,
        NewTargSet, // 1200
        TargNoOne,
        QueuedTS,
        QueuedLT,
        OTTCancel,
        TargByType,
        Scavenger,
        DeleteConfirm,
        SelSSFolder,
        HotKeys,

        // 1210 - 1248 reserved for hotkey categories
        HKSubOffset = 1249,
        // 1252 - 1300 reserved for hotkey sub-categories

        Sell = 1301,
        Buy,
        InputReq,
        CommandList,
        UseHand,
        MustDisarm,
        ArmDisarmRight,
        ArmDisarmLeft,
        DropCur,
        SpellWeaving,
        ToggleHKEnable,
        HKEnabledPress,
        HKDisabledPress,
        HKEnabled,
        HKDisabled,
        WalkA1,
        AddTargType,
        LTOutOfRange,
        SellAmount,
        SnoopFilter,
        PackSound,
        InsIF,
        InsELSE,
        InsENDIF,
        SetAmt,
        Restock,
        RestockNow,
        RestockAgent,
        RestockTarget,
        InvalidCont,
        RestockDone,
        CancelTarget,
        NewerVersion,
        Reload,
        Save,
        LTGround,
        Resync,
        DismountBlocked,
        RecStart,
        VidStop,
        RecError,
        WrongVer,
        VideoCorrupt,
        ReadError,
        CatName,
        CantDelDir,
        CanCreateDir,
        CantMoveMacro,
        Friends,

        // 1350 to 1359 reserved for PacketPlayer stop messages
        Reserved0 = 1350,
        Reserved1 = 1359,

        TargFriendAdd,
        TargFriendRem,
        FriendAdded,
        FriendRemoved,
        Constructs,
        InsFOR,
        InsENDFOR,
        NumIter,
        ClearScavCache,
        LastSpell,
        LastSkill,
        LastObj,
        AllNames,
        UseOnce,
        TargRandEnemyHuman,
        TargRandGreyHuman,
        TargRandInnocentHuman,
        TargRandCriminalHuman,
        TargRandCriminal,
        ForceEndHolding,
        RestartClient,
        ApplyOptionsRequired,
        LiftQueued,
        RestockQueued,
        StrChanged,
        DexChanged,
        IntChanged,
        LightFilter,
        HealPoisonBlocked,
        ClearDragDropQueue,
        StopNow,
        HealOrCureSelf,
        NextTarget,
        SetRestockHB,
        AddUseOnce,
        AttackLastTarg,
        EditTimeout,
        NoHold,
        NotAllowed,
        Allowed,

        // 1400 to 1465 reserved for negotiation features
        NegotiateTitle = 1400,
        AllFeaturesEnabled,
        FeatureDescBase,

        NextCliloc = 1466,
        FeatureDisabled = NextCliloc,
        FeatureDisabledText,
        InsComment,
        AddFriend,
        RemoveFriend,
        MiniHealOrCureSelf,
        NoPatchWarning,
        Dismount,
        ToggleMap,
        TooFar,
        DragDropQueueFull,
        ToggleWarPeace,
        VetRewardGump,
        ForceSizeBad,
        ScavengerHB,
        RestockHBA1,
        UseOnceHBA1,
        SellHB,
        OrganizerHBA1,
        BadServerAddr,
        PartyAccept,
        PartyDecline,
        HarmfulTarget,
        BeneficialTarget,
        RazorFriend,
        PlayFromHere,
        Initializing,
        LoadingLastProfile,
        LoadingClient,
        WaitingForClient,
        RememberDonate,
        Welcome,
        Auto2D,
        Auto3D,
        AutoDetect, // 1500
        OpacityA1,
        NewTimeout,
        NotAssigned,
        ChangeTimeout,
        EnterAName,
        Invalid,
        StaffOnlyItems,
        sStatsA1,
        DrinkApple,

        TargCloseRed,
        TargCloseGrey,
        TargCloseBlue,
        TargCloseEnemy,
        TargCloseFriend,
        TargCloseNFriend,
        TargCloseEnemyHuman,
        TargCloseGreyHuman,
        TargCloseInnocentHuman,
        TargCloseCriminalHuman,
        TargCloseCriminal,

        ProfileInUse,
        WaitingTimeout,
        NoCliLocMsg,
        NoCliLoc,
        BOD,
        LaunchBODAgent,

        NextTargetHumanoid,
        NewClipboardMacro = 1950,
        CopyClipboardMacro = 1951,
        DeerSounds,
        MacroRename,
        NewMacroVariable,

        TargCloseGreyMonster,
        TargCloseEnemyMonster,
        TargRandGreyMonster,
        TargRandEnemyMonster,
        CyclopTitanSounds,
        NextTargetEnemyHumanoid,
        UnableToOpenMacro,
        PauseCurrent,
        MacroPaused,
        MacroResuming,
        StunReady,
        StunSuccessful,
        StunDisabled,
        StunFailed,
        AllCorpses,
        AllMobiles,
        BullSounds,
        DragonSounds,
        SetSellAgentHotBag,
        AddUseOnceContainer,
        ChickenSounds,
        Reserved3,
        ScavengerEnableDisable,
        ScavengerSetHotBag,
        ScavengerAddTarget,
        GoldPerHotkey,
        EnterNewText,
        ImportFromPrevious,
        SetOrganizerHB,
        SetContainerLabel,
        AddToIgnore,
        RemoveFromIgnore,
        RazorIgnored,
        IgnoreAgent,
        PrevTarget,
        PrevTargetEnemyHumanoid,
        PrevTargetHumanoid,
        UseLastGumpResponse,
        SetContainerAlias,
        Interrupt,
        CaptureBod,
        DamageTracker,
        EnableHotkeys,
        DisableHotkeys,
        ClientDataMismatch,
        TargetRandom,
        TargCloseRedMonster,
        TargCloseRedHumanoid,
        TargClosest,
        TargRandomRedHuman,
        TargRandomRedMonster,
        TargRandomNFriendlyHuman,
        TargRandomNFriendlyMonster,
        TargRandomFriendlyHuman,
        TargRandomFriendlyMonster,
        TargRandomInnocentMonster,
        TargRandomCriminalMonster,
        TargClosestNFriendlyHuman,
        TargClosestNFriendlyMonster,
        TargClosestFriendlyHuman,
        TargClosestFriendlyMonster,
        TargClosestInnocentMonster,
        TargClosestCriminalMonster,
        NextTargetMonster,
        PrevTargetMonster,
        AddAllMobileFriends,
        AllCome,
        AllFollowMe,
        AllFollow,
        AllGuardMe,
        AllGuard,
        AllKill,
        AllStay,
        AllStop,
        PetCommands,
        Friend,
        StrChangeOverhead,
        DexChangeOverhead,
        IntChangeOverhead,
        SkillChangeOverhead,
        GrabItem,
        SetGrabItemHotBag,
        GrabItemTarget,
        GrabHB,
        NextTargetCriminalHumanoid,
        NextTargetMurdererHumanoid,
        NextTargetInnocentHumanoid,
        PrevTargetCriminalHumanoid,
        PrevTargetMurdererHumanoid,
        PrevTargetInnocentHumanoid,
        CriminalTargets,
        EnemyTargets,
        FriendlyTargets,
        GreyTargets,
        InnocentTargets,
        MurdererTargets,
        NonFriendlyTargets,
        NextTargetFriendlyHumanoid,
        NextTargetGreyHumanoid,
        NextTargetNonFriendlyHumanoid,
        PrevTargetFriendlyHumanoid,
        PrevTargetGreyHumanoid,
        PrevTargetNonFriendlyHumanoid,
        ToggleWar,
        TogglePeace,
        GHealOrCureSelf,
        SetLastBeneficial,
        SetLastHarmful,
        SetLTBene,
        SetLTHarm,
        TargClosestFriend,
        TargRandomFriend,
        NextTargetFriend,
        PrevTargetFriend,
        UseRightHand,
        UseLeftHand,
        InsertOverheadMessage,
        InsertWaitForTarget,
        AddAllHumanoidsAsFriends,
        NextTargetEnemyMonster,
        NextTargetCriminalMonster,
        NextTargetMurdererMonster,
        NextTargetInnocentMonster,
        PrevTargetCriminalMonster,
        PrevTargetMurdererMonster,
        PrevTargetInnocentMonster,
        NextTargetFriendlyMonster,
        NextTargetGreyMonster,
        NextTargetNonFriendlyMonster,
        PrevTargetEnemyMonster,
        PrevTargetFriendlyMonster,
        PrevTargetGreyMonster,
        PrevTargetNonFriendlyMonster,
        NewBeneficialTarget,
        NewHarmfulTarget,
        BirdSounds,
        AddAllMobilesTargetFilter,
        AddAllMobilesHumanoidTargetFilter,
        InsertWhile,
        InsertEndWhile,
        InsertDo,
        InsertDoWhile,
        PlayScript,
        NewScriptVariable,
        ScriptPlaying,
        ScriptFinished,
        StopScript,
        PartyAdd,
        Mysticism,
        Masteries,
        NextWaypoint,
        PrevWaypoint,
        HideWaypoint,
        InsertClearSysMsg,
        ClearSysMsg,
        NextTargetNonFriendly,
        PrevTargetNonFriendly,
        SetHue,
        ScriptDClickType,
        ScriptTargetType,
        ScriptCopied,
        GumpInfo,
        GumpSysMsg,
        GumpHotKeys,
        GumpBoatControl,
        BuyAgentAttempt,
        NextTargetFriendly,
        PrevTargetFriendly,
        PauseScript,
        ResumeScriptMessage,
        PauseScriptMessage,
        ScriptFinishedStopwatch,
        __End
    }

    #endregion

    public class Language
    {
        private static Hashtable m_Controls;
        private static Hashtable m_Strings;
        private static Ultima.StringList m_CliLoc = null;
        private static bool m_Loaded = false;
        private static string m_Current;
        private static string m_CliLocName = "ENU";

        public static bool Loaded
        {
            get { return m_Loaded; }
        }

        public static string Current
        {
            get { return m_Current; }
        }

        public static string CliLocName
        {
            get { return m_CliLocName; }
        }

        public static Ultima.StringList CliLoc
        {
            get { return m_CliLoc; }
        }


        public static string GetControlText(string name)
        {
            name = $"{name}::Text";
            if (m_Controls.ContainsKey(name))
                return m_Controls[name] as string;
            else
                return null;
        }

        static Language()
        {
            m_Controls = new Hashtable(32, 1.0f, StringComparer.OrdinalIgnoreCase);
            m_Strings = new Hashtable((int) (LocString.__End - LocString.__Start) + 1, 1.0f);
        }

        public static string GetString(LocString key)
        {
            string value = m_Strings[key] as string;
            if (value == null)
                value = $"LanguageString \"{key}\" not found!"; //throw new MissingFieldException( String.Format( "Razor requested Language Pack string '{0}', but it does not exist in the current language pack.", key ) );
            return value;
        }

        public static string GetString(int key)
        {
            string value = null;
            if (key > (uint) LocString.__Start && key < (uint) LocString.__End)
                value = m_Strings[(LocString) key] as string;
            else if (m_CliLoc != null)
                value = m_CliLoc.GetString(key);

            if (value == null)
                value = $"LanguageString \"{key}\" not found!";
            return value;
        }

        public static string Format(int key, params object[] args)
        {
            return string.Format(GetString(key), args);
        }

        public static string Format(LocString key, params object[] args)
        {
            return string.Format(GetString(key), args);
        }
        
        public static string GetSkillCliloc(int skill)
        {
            string value = null;
            
            if (m_CliLoc != null)
            {
                value = m_CliLoc.GetString(1044060 + skill);
            }

            if (value == null)
            {
                value = $"LanguageString \"{1044060 + skill}\" not found!";
            }

            return value;
        }

        public static string[] GetPackNames()
        {
            string path = Config.GetInstallDirectory("Language");
            string[] names = Directory.GetFiles(path, "Razor_lang.*");
            for (int i = 0; i < names.Length; i++)
                names[i] = Path.GetExtension(names[i]).ToUpper().Substring(1);
            return names;
        }

        public static bool Load(string lang)
        {
            lang = lang.ToUpper();
            if (m_Current != null && m_Current == lang)
                return true;

            m_CliLocName = "enu";
            string filename = Path.Combine(Config.GetInstallDirectory("Language"),
                $"Razor_lang.{lang.ToLower()}");
            if (!File.Exists(filename))
                return false;
            m_Current = lang;
            ArrayList errors = new ArrayList();
            Encoding encoding = Encoding.ASCII;

            using (StreamReader reader = new StreamReader(filename))
            {
                string line;
                while ((line = reader.ReadLine()) != null)
                {
                    line = line.Trim();
                    string lower = line.ToLower();

                    if (line == "" || line[0] == '#' || line[0] == ';' ||
                        (line.Length >= 2 && line[0] == '/' && line[1] == '/'))
                        continue;
                    else if (lower == "[controls]" || lower == "[strings]")
                        break;

                    if (lower.StartsWith("::encoding"))
                    {
                        try
                        {
                            int idx = lower.IndexOf('=') + 1;
                            if (idx > 0 && idx < lower.Length)
                                encoding = Encoding.GetEncoding(line.Substring(idx).Trim());
                        }
                        catch
                        {
                            encoding = null;
                        }

                        if (encoding == null)
                        {
                            MessageBox.Show(
                                "Error: The encoding specified in the language file was not valid.  Using ASCII.",
                                "Invalid Encoding", MessageBoxButtons.OK, MessageBoxIcon.Error);
                            encoding = Encoding.ASCII;
                        }

                        break;
                    }
                }
            }

            using (StreamReader reader = new StreamReader(filename, encoding))
            {
                //m_Dict.Clear(); // just overwrite the old lang, rather than erasing it (this way if this lang is missing something, it'll appear in the old one
                int lineNum = 0;
                string line;
                bool controls = true;
                int idx = 0;

                while ((line = reader.ReadLine()) != null)
                {
                    try
                    {
                        line = line.Trim();
                        lineNum++;
                        if (line == "" || line[0] == '#' || line[0] == ';' ||
                            (line.Length >= 2 && line[0] == '/' && line[1] == '/'))
                            continue;
                        string lower = line.ToLower();
                        if (lower == "[controls]")
                        {
                            controls = true;
                            continue;
                        }
                        else if (lower == "[strings]")
                        {
                            controls = false;
                            continue;
                        }
                        else if (lower.StartsWith("::cliloc"))
                        {
                            idx = lower.IndexOf('=') + 1;
                            if (idx > 0 && idx < lower.Length)
                                m_CliLocName = lower.Substring(idx).Trim().ToUpper();
                            continue;
                        }
                        else if (lower.StartsWith("::encoding"))
                        {
                            continue;
                        }

                        idx = line.IndexOf('=');
                        if (idx < 0)
                        {
                            errors.Add(lineNum);
                            continue;
                        }

                        string key = line.Substring(0, idx).Trim();
                        string value = line.Substring(idx + 1).Trim().Replace("\\n", "\n");

                        if (controls)
                            m_Controls[key] = value;
                        else
                            m_Strings[(LocString) Convert.ToInt32(key)] = value;
                    }
                    catch
                    {
                        errors.Add(lineNum);
                    }
                } //while
            } //using

            if (errors.Count > 0)
            {
                StringBuilder sb = new StringBuilder();

                sb.AppendFormat("Razor enountered errors on the following lines while loading the file '{0}'\r\n",
                    filename);
                for (int i = 0; i < errors.Count; i++)
                    sb.AppendFormat("Line {0}\r\n", errors[i]);

                new MessageDialog("Language Pack Load Errors", true, sb.ToString()).Show();
            }

            LoadCliLoc();

            m_Loaded = true;
            return true;
        }

        public static void LoadCliLoc()
        {
            if (m_CliLocName == null || m_CliLocName.Length <= 0)
                m_CliLocName = "enu";

            try
            {
                m_CliLoc = new Ultima.StringList(m_CliLocName.ToLower());
            }
            catch (Exception e)
            {
                string fileName = "[CliLoc]";
                try
                {
                    fileName = Ultima.Files.GetFilePath($"cliloc.{m_CliLocName}");
                }
                catch
                {
                }

                new MessageDialog("Error loading CliLoc", true,
                        "There was an exception while attempting to load '{0}':\n{1}", fileName, e)
                    .ShowDialog(Engine.ActiveWindow);
            }

            if (m_CliLoc == null || m_CliLoc.Entries == null || m_CliLoc.Entries.Count < 10)
            {
                m_CliLoc = null;
                if (m_CliLocName != "enu")
                {
                    m_CliLocName = "enu";
                    LoadCliLoc();
                    return;
                }
                else
                {
                    MessageBox.Show(Engine.ActiveWindow, Language.GetString(LocString.NoCliLocMsg),
                        Language.GetString(LocString.NoCliLoc), MessageBoxButtons.OK, MessageBoxIcon.Warning);
                }
            }
        }

        public static string GetCliloc(int num)
        {
            if (m_CliLoc == null)
                return String.Empty;

            StringEntry se = m_CliLoc.GetEntry(num);

            if (se != null)
                return se.Format();
            else
                return string.Empty;
        }

        public static string ClilocFormat(int num, string argstr)
        {
            if (m_CliLoc == null)
                return String.Empty;

            StringEntry se = m_CliLoc.GetEntry(num);

            if (se != null)
                return se.SplitFormat(argstr);
            else
                return string.Empty;
        }

        public static string ClilocFormat(int num, params object[] args)
        {
            if (m_CliLoc == null)
                return String.Empty;

            StringEntry se = m_CliLoc.GetEntry(num);

            if (se != null)
                return se.Format(args);
            else
                return string.Empty;
        }

        private static void LoadControls(string name, System.Windows.Forms.Control.ControlCollection controls)
        {
            if (controls == null)
                return;

            for (int i = 0; i < controls.Count; i++)
            {
                string find = $"{name}::{controls[i].Name}";
                string str = m_Controls[find] as string;
                if (str != null)
                    controls[i].Text = str;

                if (controls[i] is ListView)
                {
                    foreach (ColumnHeader ch in ((ListView) controls[i]).Columns)
                    {
                        find = $"{name}::{controls[i].Name}::{ch.Index}";
                        str = m_Controls[find] as string;
                        if (str != null)
                            ch.Text = str;
                    }
                }

                LoadControls(name, controls[i].Controls);
            }
        }

        public static void LoadControlNames(System.Windows.Forms.Form form)
        {
#if LOG_CONTROL_TEXT
			DumpControls( form );
#endif

            LoadControls(form.Name, form.Controls);
            string text = m_Controls[$"{form.Name}::Text"] as string;
            if (text != null)
                form.Text = text;

            if (form is MainForm)
                ((MainForm) form).UpdateTitle();
        }

#if LOG_CONTROL_TEXT
		public static void DumpControls( System.Windows.Forms.Form form )
		{
			using ( StreamWriter w = new StreamWriter( form.Name+".controls.txt" ) )
			{
				w.WriteLine( "{0}::Text={1}", form.Name, form.Text );
				Dump( form.Name, form.Controls, w );
			}
		}

		private static void Dump( string name, System.Windows.Forms.Control.ControlCollection ctrls, StreamWriter w )
		{
			for(int i = 0;ctrls != null && i<ctrls.Count;i++)
			{
				if ( !(ctrls[i] is System.Windows.Forms.TextBox) && !(ctrls[i] is System.Windows.Forms.ComboBox) )
				{
					if ( ctrls[i].Text.Length > 0 )
						w.WriteLine( "{0}::{1}={2}", name, ctrls[i].Name, ctrls[i].Text );
					if ( ctrls[i] is ListView )
					{
						foreach ( ColumnHeader ch in ((ListView)ctrls[i]).Columns )
							w.WriteLine( "{0}::{1}::{2}={3}", name, ctrls[i].Name, ch.Index, ch.Text );
					}
				}

				Dump( name, ctrls[i].Controls, w );
			}
		}
#endif
    }
}

================================================
FILE: Razor/UI/MacroInsertDoWhile.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Windows.Forms;
using Assistant.Macros;
using Ultima;

namespace Assistant
{
    /// <summary>
    /// Summary description for MacroInsertIf.
    /// </summary>
    public class MacroInsertDoWhile : System.Windows.Forms.Form
    {
        private Macro m_Macro;
        private int m_Idx;
        private MacroAction m_Action;

        private int m_SkillStart = -1;

        private System.Windows.Forms.Button insert;
        private System.Windows.Forms.TextBox txtAmount;
        private System.Windows.Forms.Button cancel;
        private System.Windows.Forms.ComboBox varList;
        private System.Windows.Forms.ComboBox opList;
        private System.Windows.Forms.Label label1;
        private ComboBox whileVariables;

        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.Container components = null;

        public MacroInsertDoWhile(Macro m, int idx)
        {
            m_Macro = m;
            m_Idx = idx;
            //
            // Required for Windows Form Designer support
            //
            InitializeComponent();

            foreach (Counter c in Counter.List)
                varList.Items.Add(c.Name);

            m_SkillStart = varList.Items.Count;

            if (World.Player != null && World.Player.SkillsSent)
            {
                foreach (Skill skill in World.Player.Skills)
                {
                    varList.Items.Add(Skills.GetSkillDisplayName(skill.Index));
                }
            }
        }

        public MacroInsertDoWhile(MacroAction a)
        {
            m_Action = a;
            //
            // Required for Windows Form Designer support
            //
            InitializeComponent();

            foreach (Counter c in Counter.List)
                varList.Items.Add(c.Name);

            m_SkillStart = varList.Items.Count;

            if (World.Player != null && World.Player.SkillsSent)
            {
                foreach (Skill skill in World.Player.Skills)
                {
                    varList.Items.Add(Skills.GetSkillDisplayName(skill.Index));
                }
            }
        }

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (components != null)
                {
                    components.Dispose();
                }
            }

            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.insert = new System.Windows.Forms.Button();
            this.txtAmount = new System.Windows.Forms.TextBox();
            this.varList = new System.Windows.Forms.ComboBox();
            this.cancel = new System.Windows.Forms.Button();
            this.opList = new System.Windows.Forms.ComboBox();
            this.label1 = new System.Windows.Forms.Label();
            this.whileVariables = new System.Windows.Forms.ComboBox();
            this.SuspendLayout();
            // 
            // insert
            // 
            this.insert.Location = new System.Drawing.Point(117, 38);
            this.insert.Name = "insert";
            this.insert.Size = new System.Drawing.Size(76, 33);
            this.insert.TabIndex = 0;
            this.insert.Text = "&Insert";
            this.insert.Click += new System.EventHandler(this.insert_Click);
            // 
            // txtAmount
            // 
            this.txtAmount.Location = new System.Drawing.Point(266, 9);
            this.txtAmount.Name = "txtAmount";
            this.txtAmount.Size = new System.Drawing.Size(126, 23);
            this.txtAmount.TabIndex = 7;
            // 
            // varList
            // 
            this.varList.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.varList.Items.AddRange(new object[]
            {
                "Hits",
                "Mana",
                "Stamina",
                "Poisoned",
                "SysMessage",
                "Weight",
                "Mounted",
                "R Hand Empty",
                "L Hand Empty"
            });
            this.varList.Location = new System.Drawing.Point(72, 9);
            this.varList.Name = "varList";
            this.varList.Size = new System.Drawing.Size(129, 23);
            this.varList.TabIndex = 8;
            this.varList.SelectedIndexChanged += new System.EventHandler(this.varList_SelectedIndexChanged);
            // 
            // cancel
            // 
            this.cancel.DialogResult = System.Windows.Forms.DialogResult.Cancel;
            this.cancel.Location = new System.Drawing.Point(199, 38);
            this.cancel.Name = "cancel";
            this.cancel.Size = new System.Drawing.Size(76, 33);
            this.cancel.TabIndex = 10;
            this.cancel.Text = "&Cancel";
            this.cancel.Click += new System.EventHandler(this.cancel_Click);
            // 
            // opList
            // 
            this.opList.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.opList.Items.AddRange(new object[]
            {
                "<=",
                ">=",
                "<",
                ">"
            });
            this.opList.Location = new System.Drawing.Point(207, 9);
            this.opList.Name = "opList";
            this.opList.Size = new System.Drawing.Size(53, 23);
            this.opList.TabIndex = 11;
            // 
            // label1
            // 
            this.label1.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Bold,
                System.Drawing.GraphicsUnit.Point, ((byte) (0)));
            this.label1.Location = new System.Drawing.Point(8, 12);
            this.label1.Name = "label1";
            this.label1.Size = new System.Drawing.Size(64, 20);
            this.label1.TabIndex = 12;
            this.label1.Text = "Do While:";
            // 
            // whileVariables
            // 
            this.whileVariables.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.whileVariables.FormattingEnabled = true;
            this.whileVariables.Items.AddRange(new object[]
            {
                "{maxhp}",
                "{maxstam}",
                "{maxmana}"
            });
            this.whileVariables.Location = new System.Drawing.Point(281, 44);
            this.whileVariables.Name = "whileVariables";
            this.whileVariables.Size = new System.Drawing.Size(104, 23);
            this.whileVariables.TabIndex = 14;
            this.whileVariables.SelectedIndexChanged += new System.EventHandler(this.ifVariables_SelectedIndexChanged);
            // 
            // MacroInsertDoWhile
            // 
            this.AutoScaleBaseSize = new System.Drawing.Size(6, 16);
            this.ClientSize = new System.Drawing.Size(404, 79);
            this.ControlBox = false;
            this.Controls.Add(this.whileVariables);
            this.Controls.Add(this.label1);
            this.Controls.Add(this.opList);
            this.Controls.Add(this.cancel);
            this.Controls.Add(this.varList);
            this.Controls.Add(this.txtAmount);
            this.Controls.Add(this.insert);
            this.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular,
                System.Drawing.GraphicsUnit.Point, ((byte) (0)));
            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog;
            this.Name = "MacroInsertDoWhile";
            this.ShowInTaskbar = false;
            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
            this.Text = "Insert Do While...";
            this.Load += new System.EventHandler(this.MacroInsertWhile_Load);
            this.ResumeLayout(false);
            this.PerformLayout();
        }

        #endregion

        private void cancel_Click(object sender, System.EventArgs e)
        {
            this.DialogResult = DialogResult.Cancel;
            this.Close();
        }

        private void insert_Click(object sender, System.EventArgs e)
        {
            MacroAction a = null;

            try
            {
                if (varList.SelectedIndex == (int) DoWhileAction.DoWhileVarType.SysMessage)
                {
                    a = new DoWhileAction((DoWhileAction.DoWhileVarType) varList.SelectedIndex, txtAmount.Text);
                }
                else if (varList.SelectedIndex >= m_SkillStart)
                {
                    int skillId = -1;

                    foreach (Skill skill in World.Player.Skills)
                    {
                        if (Skills.GetSkillDisplayName(skill.Index).Equals(varList.SelectedItem as string))
                        {
                            skillId = skill.Index;
                            break;
                        }
                    }

                    if (skillId != -1)
                        a = new DoWhileAction(DoWhileAction.DoWhileVarType.Skill, (sbyte) opList.SelectedIndex,
                            Utility.ToDouble(txtAmount.Text, 0.0), skillId);
                }
                else if (varList.SelectedIndex >= (int) DoWhileAction.DoWhileVarType.BeginCountersMarker)
                {
                    a = new DoWhileAction(DoWhileAction.DoWhileVarType.Counter, (sbyte) opList.SelectedIndex,
                        Utility.ToInt32(txtAmount.Text, 0), varList.SelectedItem as string);
                }
                else
                {
                    a = txtAmount.Text.Contains("{") // using an if variable
                        ? new DoWhileAction((DoWhileAction.DoWhileVarType) varList.SelectedIndex,
                            (sbyte) opList.SelectedIndex,
                            txtAmount.Text)
                        : new DoWhileAction((DoWhileAction.DoWhileVarType) varList.SelectedIndex,
                            (sbyte) opList.SelectedIndex,
                            Utility.ToInt32(txtAmount.Text, 0));
                }
            }
            catch
            {
                return;
            }

            if (m_Action == null)
                m_Macro.Insert(m_Idx + 1, a);
            else
                m_Action.Parent.Convert(m_Action, a);
            this.DialogResult = DialogResult.OK;
            this.Close();
        }

        private void MacroInsertWhile_Load(object sender, System.EventArgs e)
        {
            Language.LoadControlNames(this);

            if (m_Action is DoWhileAction)
            {
                try
                {
                    varList.SelectedIndex = (int) ((DoWhileAction) m_Action).Variable;
                }
                catch
                {
                }

                try
                {
                    opList.SelectedIndex = (int) ((DoWhileAction) m_Action).Op;
                }
                catch
                {
                }

                try
                {
                    if (varList.SelectedIndex != 3 && (varList.SelectedIndex <= 5 ||
                                                       varList.SelectedIndex >=
                                                       (int) DoWhileAction.DoWhileVarType.BeginCountersMarker))
                        txtAmount.Text = ((DoWhileAction) m_Action).Value.ToString();
                }
                catch
                {
                }

                if (((DoWhileAction) m_Action).Counter != null &&
                    ((DoWhileAction) m_Action).Variable == DoWhileAction.DoWhileVarType.Counter)
                    try
                    {
                        varList.SelectedItem = ((DoWhileAction) m_Action).Counter;
                    }
                    catch
                    {
                    }

                if (((DoWhileAction) m_Action).SkillId != -1 &&
                    ((DoWhileAction) m_Action).Variable == DoWhileAction.DoWhileVarType.Skill)
                    try
                    {
                        varList.SelectedItem = Skills.GetSkillDisplayName(((DoWhileAction) m_Action).SkillId);
                    }
                    catch
                    {
                    }
            }
        }

        private void varList_SelectedIndexChanged(object sender, System.EventArgs e)
        {
            try
            {
                opList.Visible = varList.SelectedIndex < 3 || varList.SelectedIndex == 5 ||
                                 varList.SelectedIndex >= (int) DoWhileAction.DoWhileVarType.BeginCountersMarker;
                txtAmount.Visible = varList.SelectedIndex != 3 &&
                                    (varList.SelectedIndex <= 5 || varList.SelectedIndex >=
                                     (int) DoWhileAction.DoWhileVarType.BeginCountersMarker);
            }
            catch
            {
            }

            /*if ( !opList.Visible )
            {
                if ( txtAmount.Visible )
                {
                    //varList.Size = new System.Drawing.Size(80, 21);

                    //txtAmount.Location = new System.Drawing.Point(104, 9);
                    //txtAmount.Size = new System.Drawing.Size(120, 20);
                }
                else
                {
                    //varList.Size = new System.Drawing.Size(200, 21);
                }
            }
            else
            {
                varList.Size = new System.Drawing.Size(80, 21);

                txtAmount.Location = new System.Drawing.Point(144, 9);
                txtAmount.Size = new System.Drawing.Size(80, 20);
            }*/
        }

        private void ifVariables_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (whileVariables.SelectedItem.ToString().Substring(0, 1).Equals("{") && whileVariables.Focused)
            {
                txtAmount.Text = $"{whileVariables.SelectedItem}";
            }
        }
    }
}

================================================
FILE: Razor/UI/MacroInsertDoWhile.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
</root>

================================================
FILE: Razor/UI/MacroInsertIf.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Windows.Forms;
using Assistant.Macros;
using Ultima;

namespace Assistant
{
    /// <summary>
    /// Summary description for MacroInsertIf.
    /// </summary>
    public class MacroInsertIf : System.Windows.Forms.Form
    {
        private Macro m_Macro;
        private int m_Idx;
        private MacroAction m_Action;

        private int m_SkillStart = -1;

        private System.Windows.Forms.Button insert;
        private System.Windows.Forms.TextBox txtAmount;
        private System.Windows.Forms.Button cancel;
        private System.Windows.Forms.ComboBox varList;
        private System.Windows.Forms.ComboBox opList;
        private System.Windows.Forms.Label label1;
        private ComboBox ifVariables;

        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.Container components = null;

        public MacroInsertIf(Macro m, int idx)
        {
            m_Macro = m;
            m_Idx = idx;
            //
            // Required for Windows Form Designer support
            //
            InitializeComponent();

            foreach (Counter c in Counter.List)
                varList.Items.Add(c.Name);

            m_SkillStart = varList.Items.Count;

            if (World.Player != null && World.Player.SkillsSent)
            {
                foreach (Skill skill in World.Player.Skills)
                {
                    varList.Items.Add(Skills.GetSkillDisplayName(skill.Index));
                }
            }
        }

        public MacroInsertIf(MacroAction a)
        {
            m_Action = a;
            //
            // Required for Windows Form Designer support
            //
            InitializeComponent();

            foreach (Counter c in Counter.List)
                varList.Items.Add(c.Name);

            m_SkillStart = varList.Items.Count;

            if (World.Player != null && World.Player.SkillsSent)
            {
                foreach (Skill skill in World.Player.Skills)
                {
                    varList.Items.Add(Skills.GetSkillDisplayName(skill.Index));
                }
            }
        }

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (components != null)
                {
                    components.Dispose();
                }
            }

            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.insert = new System.Windows.Forms.Button();
            this.txtAmount = new System.Windows.Forms.TextBox();
            this.varList = new System.Windows.Forms.ComboBox();
            this.cancel = new System.Windows.Forms.Button();
            this.opList = new System.Windows.Forms.ComboBox();
            this.label1 = new System.Windows.Forms.Label();
            this.ifVariables = new System.Windows.Forms.ComboBox();
            this.SuspendLayout();
            // 
            // insert
            // 
            this.insert.Location = new System.Drawing.Point(124, 38);
            this.insert.Name = "insert";
            this.insert.Size = new System.Drawing.Size(76, 33);
            this.insert.TabIndex = 0;
            this.insert.Text = "&Insert";
            this.insert.Click += new System.EventHandler(this.insert_Click);
            // 
            // txtAmount
            // 
            this.txtAmount.Location = new System.Drawing.Point(238, 9);
            this.txtAmount.Name = "txtAmount";
            this.txtAmount.Size = new System.Drawing.Size(156, 23);
            this.txtAmount.TabIndex = 7;
            // 
            // varList
            // 
            this.varList.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.varList.Items.AddRange(new object[]
            {
                "Hits",
                "Mana",
                "Stamina",
                "Poisoned",
                "SysMessage",
                "Weight",
                "Mounted",
                "R Hand Empty",
                "L Hand Empty"
            });
            this.varList.Location = new System.Drawing.Point(30, 9);
            this.varList.Name = "varList";
            this.varList.Size = new System.Drawing.Size(143, 23);
            this.varList.TabIndex = 8;
            this.varList.SelectedIndexChanged += new System.EventHandler(this.varList_SelectedIndexChanged);
            // 
            // cancel
            // 
            this.cancel.DialogResult = System.Windows.Forms.DialogResult.Cancel;
            this.cancel.Location = new System.Drawing.Point(206, 38);
            this.cancel.Name = "cancel";
            this.cancel.Size = new System.Drawing.Size(76, 33);
            this.cancel.TabIndex = 10;
            this.cancel.Text = "&Cancel";
            this.cancel.Click += new System.EventHandler(this.cancel_Click);
            // 
            // opList
            // 
            this.opList.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.opList.Items.AddRange(new object[]
            {
                "<=",
                ">=",
                "<",
                ">"
            });
            this.opList.Location = new System.Drawing.Point(179, 9);
            this.opList.Name = "opList";
            this.opList.Size = new System.Drawing.Size(53, 23);
            this.opList.TabIndex = 11;
            // 
            // label1
            // 
            this.label1.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Bold,
                System.Drawing.GraphicsUnit.Point, ((byte) (0)));
            this.label1.Location = new System.Drawing.Point(8, 12);
            this.label1.Name = "label1";
            this.label1.Size = new System.Drawing.Size(16, 20);
            this.label1.TabIndex = 12;
            this.label1.Text = "If:";
            // 
            // ifVariables
            // 
            this.ifVariables.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.ifVariables.FormattingEnabled = true;
            this.ifVariables.Items.AddRange(new object[]
            {
                "{maxhp}",
                "{maxstam}",
                "{maxmana}"
            });
            this.ifVariables.Location = new System.Drawing.Point(288, 44);
            this.ifVariables.Name = "ifVariables";
            this.ifVariables.Size = new System.Drawing.Size(104, 23);
            this.ifVariables.TabIndex = 14;
            this.ifVariables.SelectedIndexChanged += new System.EventHandler(this.ifVariables_SelectedIndexChanged);
            // 
            // MacroInsertIf
            // 
            this.AutoScaleBaseSize = new System.Drawing.Size(6, 16);
            this.ClientSize = new System.Drawing.Size(404, 77);
            this.ControlBox = false;
            this.Controls.Add(this.ifVariables);
            this.Controls.Add(this.label1);
            this.Controls.Add(this.opList);
            this.Controls.Add(this.cancel);
            this.Controls.Add(this.varList);
            this.Controls.Add(this.txtAmount);
            this.Controls.Add(this.insert);
            this.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular,
                System.Drawing.GraphicsUnit.Point, ((byte) (0)));
            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog;
            this.Name = "MacroInsertIf";
            this.ShowInTaskbar = false;
            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
            this.Text = "Insert If...";
            this.Load += new System.EventHandler(this.MacroInsertIf_Load);
            this.ResumeLayout(false);
            this.PerformLayout();
        }

        #endregion

        private void cancel_Click(object sender, System.EventArgs e)
        {
            this.DialogResult = DialogResult.Cancel;
            this.Close();
        }

        private void insert_Click(object sender, System.EventArgs e)
        {
            MacroAction a = null;

            try
            {
                if (varList.SelectedIndex == (int) IfAction.IfVarType.SysMessage)
                {
                    a = new IfAction((IfAction.IfVarType) varList.SelectedIndex, txtAmount.Text);
                }
                else if (varList.SelectedIndex >= m_SkillStart)
                {
                    int skillId = -1;

                    foreach (Skill skill in World.Player.Skills)
                    {
                        if (Skills.GetSkillDisplayName(skill.Index).Equals(varList.SelectedItem as string))
                        {
                            skillId = skill.Index;
                            break;
                        }
                    }

                    if (skillId != -1)
                        a = new IfAction(IfAction.IfVarType.Skill, (sbyte) opList.SelectedIndex,
                            Utility.ToDouble(txtAmount.Text, 0.0), skillId);
                }
                else if (varList.SelectedIndex >= (int) IfAction.IfVarType.BeginCountersMarker)
                {
                    a = new IfAction(IfAction.IfVarType.Counter, (sbyte) opList.SelectedIndex,
                        Utility.ToInt32(txtAmount.Text, 0), varList.SelectedItem as string);
                }
                else
                {
                    a = txtAmount.Text.Contains("{") // using an if variable
                        ? new IfAction((IfAction.IfVarType) varList.SelectedIndex, (sbyte) opList.SelectedIndex,
                            txtAmount.Text)
                        : new IfAction((IfAction.IfVarType) varList.SelectedIndex, (sbyte) opList.SelectedIndex,
                            Utility.ToInt32(txtAmount.Text, 0));
                }
            }
            catch
            {
                return;
            }

            if (m_Action == null)
                m_Macro.Insert(m_Idx + 1, a);
            else
                m_Action.Parent.Convert(m_Action, a);
            this.DialogResult = DialogResult.OK;
            this.Close();
        }

        private void MacroInsertIf_Load(object sender, System.EventArgs e)
        {
            Language.LoadControlNames(this);

            if (m_Action is IfAction)
            {
                try
                {
                    varList.SelectedIndex = (int) ((IfAction) m_Action).Variable;
                }
                catch
                {
                }

                try
                {
                    opList.SelectedIndex = (int) ((IfAction) m_Action).Op;
                }
                catch
                {
                }

                try
                {
                    if (varList.SelectedIndex != 3 && (varList.SelectedIndex <= 5 ||
                                                       varList.SelectedIndex >=
                                                       (int) IfAction.IfVarType.BeginCountersMarker))
                        txtAmount.Text = ((IfAction) m_Action).Value.ToString();
                }
                catch
                {
                }

                if (((IfAction) m_Action).Counter != null &&
                    ((IfAction) m_Action).Variable == IfAction.IfVarType.Counter)
                    try
                    {
                        varList.SelectedItem = ((IfAction) m_Action).Counter;
                    }
                    catch
                    {
                    }

                if (((IfAction) m_Action).SkillId != -1 &&
                    ((IfAction) m_Action).Variable == IfAction.IfVarType.Skill)
                    try
                    {
                        varList.SelectedItem = Skills.GetSkillDisplayName(((IfAction) m_Action).SkillId);
                    }
                    catch
                    {
                    }
            }
        }

        private void varList_SelectedIndexChanged(object sender, System.EventArgs e)
        {
            try
            {
                opList.Visible = varList.SelectedIndex < 3 || varList.SelectedIndex == 5 ||
                                 varList.SelectedIndex >= (int) IfAction.IfVarType.BeginCountersMarker;
                txtAmount.Visible = varList.SelectedIndex != 3 &&
                                    (varList.SelectedIndex <= 5 || varList.SelectedIndex >=
                                     (int) IfAction.IfVarType.BeginCountersMarker);
            }
            catch
            {
            }

            /*if ( !opList.Visible )
            {
                if ( txtAmount.Visible )
                {
                    //varList.Size = new System.Drawing.Size(80, 21);

                    //txtAmount.Location = new System.Drawing.Point(104, 9);
                    //txtAmount.Size = new System.Drawing.Size(120, 20);
                }
                else
                {
                    //varList.Size = new System.Drawing.Size(200, 21);
                }
            }
            else
            {
                varList.Size = new System.Drawing.Size(80, 21);

                txtAmount.Location = new System.Drawing.Point(144, 9);
                txtAmount.Size = new System.Drawing.Size(80, 20);
            }*/
        }

        private void ifVariables_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (ifVariables.SelectedItem.ToString().Substring(0, 1).Equals("{") && ifVariables.Focused)
            {
                txtAmount.Text = $"{ifVariables.SelectedItem}";
            }
        }
    }
}

================================================
FILE: Razor/UI/MacroInsertIf.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
</root>

================================================
FILE: Razor/UI/MacroInsertWait.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Windows.Forms;
using Assistant.Macros;

namespace Assistant
{
    /// <summary>
    /// Summary description for MacroInsertWait.
    /// </summary>
    public class MacroInsertWait : System.Windows.Forms.Form
    {
        private Macro m_Macro;
        private int m_Idx;
        private MacroAction m_Action;

        private System.Windows.Forms.Button insert;
        private System.Windows.Forms.RadioButton radioPause;
        private System.Windows.Forms.TextBox pause;
        private System.Windows.Forms.Label label1;
        private System.Windows.Forms.RadioButton radioGump;
        private System.Windows.Forms.RadioButton radioStat;
        private System.Windows.Forms.TextBox statAmount;
        private System.Windows.Forms.Button cancel;
        private System.Windows.Forms.RadioButton radioTarg;
        private System.Windows.Forms.ComboBox statList;
        private System.Windows.Forms.ComboBox statOpList;
        private System.Windows.Forms.RadioButton radioMenu;

        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.Container components = null;

        public MacroInsertWait(Macro m, int idx)
        {
            m_Macro = m;
            m_Idx = idx;
            //
            // Required for Windows Form Designer support
            //
            InitializeComponent();

            //
            // TODO: Add any constructor code after InitializeComponent call
            //
        }

        public MacroInsertWait(MacroAction a)
        {
            m_Action = a;
            //
            // Required for Windows Form Designer support
            //
            InitializeComponent();

            //
            // TODO: Add any constructor code after InitializeComponent call
            //
        }

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (components != null)
                {
                    components.Dispose();
                }
            }

            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.insert = new System.Windows.Forms.Button();
            this.radioPause = new System.Windows.Forms.RadioButton();
            this.pause = new System.Windows.Forms.TextBox();
            this.label1 = new System.Windows.Forms.Label();
            this.radioGump = new System.Windows.Forms.RadioButton();
            this.radioTarg = new System.Windows.Forms.RadioButton();
            this.radioStat = new System.Windows.Forms.RadioButton();
            this.statAmount = new System.Windows.Forms.TextBox();
            this.statList = new System.Windows.Forms.ComboBox();
            this.cancel = new System.Windows.Forms.Button();
            this.statOpList = new System.Windows.Forms.ComboBox();
            this.radioMenu = new System.Windows.Forms.RadioButton();
            this.SuspendLayout();
            // 
            // insert
            // 
            this.insert.Location = new System.Drawing.Point(67, 148);
            this.insert.Name = "insert";
            this.insert.Size = new System.Drawing.Size(64, 38);
            this.insert.TabIndex = 0;
            this.insert.Text = "&Insert";
            this.insert.Click += new System.EventHandler(this.insert_Click);
            // 
            // radioPause
            // 
            this.radioPause.Location = new System.Drawing.Point(12, 12);
            this.radioPause.Name = "radioPause";
            this.radioPause.Size = new System.Drawing.Size(101, 20);
            this.radioPause.TabIndex = 1;
            this.radioPause.Text = "Pause for:";
            this.radioPause.CheckedChanged += new System.EventHandler(this.radioPause_CheckedChanged);
            // 
            // pause
            // 
            this.pause.Enabled = false;
            this.pause.Location = new System.Drawing.Point(89, 12);
            this.pause.Name = "pause";
            this.pause.Size = new System.Drawing.Size(40, 23);
            this.pause.TabIndex = 2;
            // 
            // label1
            // 
            this.label1.Location = new System.Drawing.Point(135, 15);
            this.label1.Name = "label1";
            this.label1.Size = new System.Drawing.Size(91, 20);
            this.label1.TabIndex = 3;
            this.label1.Text = "milliseconds";
            // 
            // radioGump
            // 
            this.radioGump.Location = new System.Drawing.Point(12, 41);
            this.radioGump.Name = "radioGump";
            this.radioGump.Size = new System.Drawing.Size(176, 20);
            this.radioGump.TabIndex = 4;
            this.radioGump.Text = "Wait for Gump";
            // 
            // radioTarg
            // 
            this.radioTarg.Location = new System.Drawing.Point(12, 93);
            this.radioTarg.Name = "radioTarg";
            this.radioTarg.Size = new System.Drawing.Size(128, 20);
            this.radioTarg.TabIndex = 5;
            this.radioTarg.Text = "Wait for Target";
            // 
            // radioStat
            // 
            this.radioStat.Location = new System.Drawing.Point(12, 119);
            this.radioStat.Name = "radioStat";
            this.radioStat.Size = new System.Drawing.Size(67, 20);
            this.radioStat.TabIndex = 6;
            this.radioStat.Text = "Wait for ";
            this.radioStat.CheckedChanged += new System.EventHandler(this.radioStat_CheckedChanged);
            // 
            // statAmount
            // 
            this.statAmount.Enabled = false;
            this.statAmount.Location = new System.Drawing.Point(205, 119);
            this.statAmount.Name = "statAmount";
            this.statAmount.Size = new System.Drawing.Size(50, 23);
            this.statAmount.TabIndex = 7;
            // 
            // statList
            // 
            this.statList.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.statList.Enabled = false;
            this.statList.Items.AddRange(new object[]
            {
                "Hits",
                "Mana",
                "Stamina"
            });
            this.statList.Location = new System.Drawing.Point(85, 119);
            this.statList.Name = "statList";
            this.statList.Size = new System.Drawing.Size(64, 23);
            this.statList.TabIndex = 8;
            // 
            // cancel
            // 
            this.cancel.DialogResult = System.Windows.Forms.DialogResult.Cancel;
            this.cancel.Location = new System.Drawing.Point(137, 148);
            this.cancel.Name = "cancel";
            this.cancel.Size = new System.Drawing.Size(64, 38);
            this.cancel.TabIndex = 10;
            this.cancel.Text = "&Cancel";
            this.cancel.Click += new System.EventHandler(this.cancel_Click);
            // 
            // statOpList
            // 
            this.statOpList.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.statOpList.Enabled = false;
            this.statOpList.Items.AddRange(new object[]
            {
                "<=",
                ">="
            });
            this.statOpList.Location = new System.Drawing.Point(155, 119);
            this.statOpList.Name = "statOpList";
            this.statOpList.Size = new System.Drawing.Size(44, 23);
            this.statOpList.TabIndex = 11;
            // 
            // radioMenu
            // 
            this.radioMenu.Location = new System.Drawing.Point(12, 67);
            this.radioMenu.Name = "radioMenu";
            this.radioMenu.Size = new System.Drawing.Size(176, 20);
            this.radioMenu.TabIndex = 12;
            this.radioMenu.Text = "Wait for old-style Menu/Dialog";
            // 
            // MacroInsertWait
            // 
            this.AcceptButton = this.insert;
            this.AutoScaleBaseSize = new System.Drawing.Size(6, 16);
            this.CancelButton = this.cancel;
            this.ClientSize = new System.Drawing.Size(267, 192);
            this.ControlBox = false;
            this.Controls.Add(this.radioMenu);
            this.Controls.Add(this.statOpList);
            this.Controls.Add(this.cancel);
            this.Controls.Add(this.statList);
            this.Controls.Add(this.statAmount);
            this.Controls.Add(this.radioStat);
            this.Controls.Add(this.radioTarg);
            this.Controls.Add(this.label1);
            this.Controls.Add(this.pause);
            this.Controls.Add(this.radioPause);
            this.Controls.Add(this.insert);
            this.Controls.Add(this.radioGump);
            this.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular,
                System.Drawing.GraphicsUnit.Point, ((byte) (0)));
            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog;
            this.Name = "MacroInsertWait";
            this.ShowInTaskbar = false;
            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
            this.Text = "Insert Wait/Pause...";
            this.Load += new System.EventHandler(this.MacroInsertWait_Load);
            this.ResumeLayout(false);
            this.PerformLayout();
        }

        #endregion

        private void cancel_Click(object sender, System.EventArgs e)
        {
            this.DialogResult = DialogResult.Cancel;
            this.Close();
        }

        private void insert_Click(object sender, System.EventArgs e)
        {
            MacroAction a = null;

            if (radioPause.Checked)
                a = new PauseAction(TimeSpan.FromMilliseconds(Utility.ToInt32(pause.Text, 1000)));
            else if (radioGump.Checked)
                a = new WaitForGumpAction(0);
            else if (radioMenu.Checked)
                a = new WaitForMenuAction(0);
            else if (radioTarg.Checked)
                a = new WaitForTargetAction();
            else if (radioStat.Checked && statList.SelectedIndex >= 0 && statList.SelectedIndex < 3 &&
                     statOpList.SelectedIndex >= 0 && statOpList.SelectedIndex < statOpList.Items.Count)
                a = new WaitForStatAction((IfAction.IfVarType) statList.SelectedIndex, (byte) statOpList.SelectedIndex,
                    Utility.ToInt32(statAmount.Text, 0));

            if (a != null)
            {
                if (m_Action == null)
                    m_Macro.Insert(m_Idx + 1, a);
                else
                    m_Action.Parent.Convert(m_Action, a);
                this.DialogResult = DialogResult.OK;
                this.Close();
            }
        }

        private void radioStat_CheckedChanged(object sender, System.EventArgs e)
        {
            statList.Enabled = statAmount.Enabled = statOpList.Enabled = radioStat.Checked;
        }

        private void radioPause_CheckedChanged(object sender, System.EventArgs e)
        {
            pause.Enabled = radioPause.Checked;
        }

        private void MacroInsertWait_Load(object sender, System.EventArgs e)
        {
            Language.LoadControlNames(this);

            radioPause.Checked = m_Action is PauseAction;
            radioGump.Checked = m_Action is WaitForGumpAction;
            radioMenu.Checked = m_Action is WaitForMenuAction;
            radioTarg.Checked = m_Action is WaitForTargetAction;
            radioStat.Checked = m_Action is WaitForStatAction;

            if (radioPause.Checked)
            {
                pause.Text = ((int) ((PauseAction) m_Action).Timeout.TotalMilliseconds).ToString();
            }
            else if (radioStat.Checked)
            {
                statList.SelectedIndex = (int) ((WaitForStatAction) m_Action).Stat;
                statOpList.SelectedIndex = (int) ((WaitForStatAction) m_Action).Op;
                statAmount.Text = ((WaitForStatAction) m_Action).Amount.ToString();
            }
        }
    }
}

================================================
FILE: Razor/UI/MacroInsertWait.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
</root>

================================================
FILE: Razor/UI/MacroInsertWhile.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Windows.Forms;
using Assistant.Macros;
using Ultima;

namespace Assistant
{
    /// <summary>
    /// Summary description for MacroInsertIf.
    /// </summary>
    public class MacroInsertWhile : System.Windows.Forms.Form
    {
        private Macro m_Macro;
        private int m_Idx;
        private MacroAction m_Action;

        private int m_SkillStart = -1;

        private System.Windows.Forms.Button insert;
        private System.Windows.Forms.TextBox txtAmount;
        private System.Windows.Forms.Button cancel;
        private System.Windows.Forms.ComboBox varList;
        private System.Windows.Forms.ComboBox opList;
        private System.Windows.Forms.Label label1;
        private ComboBox whileVariables;

        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.Container components = null;

        public MacroInsertWhile(Macro m, int idx)
        {
            m_Macro = m;
            m_Idx = idx;
            //
            // Required for Windows Form Designer support
            //
            InitializeComponent();

            foreach (Counter c in Counter.List)
                varList.Items.Add(c.Name);

            m_SkillStart = varList.Items.Count;

            if (World.Player != null && World.Player.SkillsSent)
            {
                foreach (Skill skill in World.Player.Skills)
                {
                    varList.Items.Add(Skills.GetSkillDisplayName(skill.Index));
                }
            }
        }

        public MacroInsertWhile(MacroAction a)
        {
            m_Action = a;
            //
            // Required for Windows Form Designer support
            //
            InitializeComponent();

            foreach (Counter c in Counter.List)
                varList.Items.Add(c.Name);

            m_SkillStart = varList.Items.Count;

            if (World.Player != null && World.Player.SkillsSent)
            {
                foreach (Skill skill in World.Player.Skills)
                {
                    varList.Items.Add(Skills.GetSkillDisplayName(skill.Index));
                }
            }
        }

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (components != null)
                {
                    components.Dispose();
                }
            }

            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.insert = new System.Windows.Forms.Button();
            this.txtAmount = new System.Windows.Forms.TextBox();
            this.varList = new System.Windows.Forms.ComboBox();
            this.cancel = new System.Windows.Forms.Button();
            this.opList = new System.Windows.Forms.ComboBox();
            this.label1 = new System.Windows.Forms.Label();
            this.whileVariables = new System.Windows.Forms.ComboBox();
            this.SuspendLayout();
            // 
            // insert
            // 
            this.insert.Location = new System.Drawing.Point(117, 38);
            this.insert.Name = "insert";
            this.insert.Size = new System.Drawing.Size(76, 33);
            this.insert.TabIndex = 0;
            this.insert.Text = "&Insert";
            this.insert.Click += new System.EventHandler(this.insert_Click);
            // 
            // txtAmount
            // 
            this.txtAmount.Location = new System.Drawing.Point(266, 9);
            this.txtAmount.Name = "txtAmount";
            this.txtAmount.Size = new System.Drawing.Size(126, 23);
            this.txtAmount.TabIndex = 7;
            // 
            // varList
            // 
            this.varList.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.varList.Items.AddRange(new object[]
            {
                "Hits",
                "Mana",
                "Stamina",
                "Poisoned",
                "SysMessage",
                "Weight",
                "Mounted",
                "R Hand Empty",
                "L Hand Empty"
            });
            this.varList.Location = new System.Drawing.Point(58, 9);
            this.varList.Name = "varList";
            this.varList.Size = new System.Drawing.Size(143, 23);
            this.varList.TabIndex = 8;
            this.varList.SelectedIndexChanged += new System.EventHandler(this.varList_SelectedIndexChanged);
            // 
            // cancel
            // 
            this.cancel.DialogResult = System.Windows.Forms.DialogResult.Cancel;
            this.cancel.Location = new System.Drawing.Point(199, 38);
            this.cancel.Name = "cancel";
            this.cancel.Size = new System.Drawing.Size(76, 33);
            this.cancel.TabIndex = 10;
            this.cancel.Text = "&Cancel";
            this.cancel.Click += new System.EventHandler(this.cancel_Click);
            // 
            // opList
            // 
            this.opList.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.opList.Items.AddRange(new object[]
            {
                "<=",
                ">=",
                "<",
                ">"
            });
            this.opList.Location = new System.Drawing.Point(207, 9);
            this.opList.Name = "opList";
            this.opList.Size = new System.Drawing.Size(53, 23);
            this.opList.TabIndex = 11;
            // 
            // label1
            // 
            this.label1.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Bold,
                System.Drawing.GraphicsUnit.Point, ((byte) (0)));
            this.label1.Location = new System.Drawing.Point(8, 12);
            this.label1.Name = "label1";
            this.label1.Size = new System.Drawing.Size(44, 20);
            this.label1.TabIndex = 12;
            this.label1.Text = "While:";
            // 
            // whileVariables
            // 
            this.whileVariables.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.whileVariables.FormattingEnabled = true;
            this.whileVariables.Items.AddRange(new object[]
            {
                "{maxhp}",
                "{maxstam}",
                "{maxmana}"
            });
            this.whileVariables.Location = new System.Drawing.Point(281, 44);
            this.whileVariables.Name = "whileVariables";
            this.whileVariables.Size = new System.Drawing.Size(104, 23);
            this.whileVariables.TabIndex = 14;
            this.whileVariables.SelectedIndexChanged += new System.EventHandler(this.ifVariables_SelectedIndexChanged);
            // 
            // MacroInsertWhile
            // 
            this.AutoScaleBaseSize = new System.Drawing.Size(6, 16);
            this.ClientSize = new System.Drawing.Size(404, 79);
            this.ControlBox = false;
            this.Controls.Add(this.whileVariables);
            this.Controls.Add(this.label1);
            this.Controls.Add(this.opList);
            this.Controls.Add(this.cancel);
            this.Controls.Add(this.varList);
            this.Controls.Add(this.txtAmount);
            this.Controls.Add(this.insert);
            this.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular,
                System.Drawing.GraphicsUnit.Point, ((byte) (0)));
            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog;
            this.Name = "MacroInsertWhile";
            this.ShowInTaskbar = false;
            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
            this.Text = "Insert While...";
            this.Load += new System.EventHandler(this.MacroInsertWhile_Load);
            this.ResumeLayout(false);
            this.PerformLayout();
        }

        #endregion

        private void cancel_Click(object sender, System.EventArgs e)
        {
            this.DialogResult = DialogResult.Cancel;
            this.Close();
        }

        private void insert_Click(object sender, System.EventArgs e)
        {
            MacroAction a = null;

            try
            {
                if (varList.SelectedIndex == (int) WhileAction.WhileVarType.SysMessage)
                {
                    a = new WhileAction((WhileAction.WhileVarType) varList.SelectedIndex, txtAmount.Text);
                }
                else if (varList.SelectedIndex >= m_SkillStart)
                {
                    int skillId = -1;

                    foreach (Skill skill in World.Player.Skills)
                    {
                        if (Skills.GetSkillDisplayName(skill.Index).Equals(varList.SelectedItem as string))
                        {
                            skillId = skill.Index;
                            break;
                        }
                    }

                    if (skillId != -1)
                        a = new WhileAction(WhileAction.WhileVarType.Skill, (sbyte) opList.SelectedIndex,
                            Utility.ToDouble(txtAmount.Text, 0.0), skillId);
                }
                else if (varList.SelectedIndex >= (int) WhileAction.WhileVarType.BeginCountersMarker)
                {
                    a = new WhileAction(WhileAction.WhileVarType.Counter, (sbyte) opList.SelectedIndex,
                        Utility.ToInt32(txtAmount.Text, 0), varList.SelectedItem as string);
                }
                else
                {
                    a = txtAmount.Text.Contains("{") // using an if variable
                        ? new WhileAction((WhileAction.WhileVarType) varList.SelectedIndex,
                            (sbyte) opList.SelectedIndex,
                            txtAmount.Text)
                        : new WhileAction((WhileAction.WhileVarType) varList.SelectedIndex,
                            (sbyte) opList.SelectedIndex,
                            Utility.ToInt32(txtAmount.Text, 0));
                }
            }
            catch
            {
                return;
            }

            if (m_Action == null)
                m_Macro.Insert(m_Idx + 1, a);
            else
                m_Action.Parent.Convert(m_Action, a);
            this.DialogResult = DialogResult.OK;
            this.Close();
        }

        private void MacroInsertWhile_Load(object sender, System.EventArgs e)
        {
            Language.LoadControlNames(this);

            if (m_Action is WhileAction)
            {
                try
                {
                    varList.SelectedIndex = (int) ((WhileAction) m_Action).Variable;
                }
                catch
                {
                }

                try
                {
                    opList.SelectedIndex = (int) ((WhileAction) m_Action).Op;
                }
                catch
                {
                }

                try
                {
                    if (varList.SelectedIndex != 3 && (varList.SelectedIndex <= 5 ||
                                                       varList.SelectedIndex >=
                                                       (int) WhileAction.WhileVarType.BeginCountersMarker))
                        txtAmount.Text = ((WhileAction) m_Action).Value.ToString();
                }
                catch
                {
                }

                if (((WhileAction) m_Action).Counter != null &&
                    ((WhileAction) m_Action).Variable == WhileAction.WhileVarType.Counter)
                    try
                    {
                        varList.SelectedItem = ((WhileAction) m_Action).Counter;
                    }
                    catch
                    {
                    }

                if (((WhileAction) m_Action).SkillId != -1 &&
                    ((WhileAction) m_Action).Variable == WhileAction.WhileVarType.Skill)
                    try
                    {
                        varList.SelectedItem = Skills.GetSkillDisplayName(((WhileAction) m_Action).SkillId);
                    }
                    catch
                    {
                    }
            }
        }

        private void varList_SelectedIndexChanged(object sender, System.EventArgs e)
        {
            try
            {
                opList.Visible = varList.SelectedIndex < 3 || varList.SelectedIndex == 5 ||
                                 varList.SelectedIndex >= (int) WhileAction.WhileVarType.BeginCountersMarker;
                txtAmount.Visible = varList.SelectedIndex != 3 &&
                                    (varList.SelectedIndex <= 5 || varList.SelectedIndex >=
                                     (int) WhileAction.WhileVarType.BeginCountersMarker);
            }
            catch
            {
            }

            /*if ( !opList.Visible )
            {
                if ( txtAmount.Visible )
                {
                    //varList.Size = new System.Drawing.Size(80, 21);

                    //txtAmount.Location = new System.Drawing.Point(104, 9);
                    //txtAmount.Size = new System.Drawing.Size(120, 20);
                }
                else
                {
                    //varList.Size = new System.Drawing.Size(200, 21);
                }
            }
            else
            {
                varList.Size = new System.Drawing.Size(80, 21);

                txtAmount.Location = new System.Drawing.Point(144, 9);
                txtAmount.Size = new System.Drawing.Size(80, 20);
            }*/
        }

        private void ifVariables_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (whileVariables.SelectedItem.ToString().Substring(0, 1).Equals("{") && whileVariables.Focused)
            {
                txtAmount.Text = $"{whileVariables.SelectedItem}";
            }
        }
    }
}

================================================
FILE: Razor/UI/MacroInsertWhile.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
</root>

================================================
FILE: Razor/UI/MessageDialog.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Windows.Forms;

namespace Assistant
{
    /// <summary>
    /// Summary description for MessageDialog.
    /// </summary>
    public class MessageDialog : System.Windows.Forms.Form
    {
        private System.Windows.Forms.Button okay;

        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.Container components = null;

        private string m_Title;
        private string m_Message;
        private System.Windows.Forms.TextBox message;
        private bool m_CanIgnore;

        public MessageDialog(string title, string message) : this(title, false, message)
        {
        }

        public MessageDialog(string title, bool ignorable, string message, params object[] msgArgs) : this(title,
            ignorable, String.Format(message, msgArgs))
        {
        }

        public MessageDialog(string title, bool ignorable, string message)
        {
            m_Title = title;
            m_Message = message;
            m_CanIgnore = ignorable;
            //
            // Required for Windows Form Designer support
            //
            InitializeComponent();

            //
            // TODO: Add any constructor code after InitializeComponent call
            //
        }

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (components != null)
                {
                    components.Dispose();
                }
            }

            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.message = new System.Windows.Forms.TextBox();
            this.okay = new System.Windows.Forms.Button();
            this.SuspendLayout();
            // 
            // message
            // 
            this.message.Location = new System.Drawing.Point(8, 8);
            this.message.Multiline = true;
            this.message.Name = "message";
            this.message.ReadOnly = true;
            this.message.ScrollBars = System.Windows.Forms.ScrollBars.Both;
            this.message.Size = new System.Drawing.Size(552, 320);
            this.message.TabIndex = 0;
            // 
            // okay
            // 
            this.okay.DialogResult = System.Windows.Forms.DialogResult.OK;
            this.okay.Location = new System.Drawing.Point(8, 334);
            this.okay.Name = "okay";
            this.okay.Size = new System.Drawing.Size(88, 26);
            this.okay.TabIndex = 1;
            this.okay.Text = "&Okay";
            this.okay.Click += new System.EventHandler(this.okay_Click);
            // 
            // MessageDialog
            // 
            this.AcceptButton = this.okay;
            this.AutoScaleBaseSize = new System.Drawing.Size(6, 16);
            this.ClientSize = new System.Drawing.Size(567, 366);
            this.ControlBox = false;
            this.Controls.Add(this.okay);
            this.Controls.Add(this.message);
            this.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular,
                System.Drawing.GraphicsUnit.Point, ((byte) (0)));
            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog;
            this.Name = "MessageDialog";
            this.ShowInTaskbar = false;
            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
            this.Text = "Message";
            this.Load += new System.EventHandler(this.MessageDialog_Load);
            this.ResumeLayout(false);
            this.PerformLayout();
        }

        #endregion

        private void MessageDialog_Load(object sender, System.EventArgs e)
        {
            this.Text = m_Title;
            this.message.Text = m_Message;
            this.message.Select(0, 0);
            this.BringToFront();

            if (m_CanIgnore)
                this.okay.Text = "&Ignore";
        }

        private void okay_Click(object sender, System.EventArgs e)
        {
            this.DialogResult = DialogResult.OK;
            this.Close();
        }
    }
}

================================================
FILE: Razor/UI/MessageDialog.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
</root>

================================================
FILE: Razor/UI/Razor.Designer.cs
================================================
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace Assistant
{
    public partial class MainForm : System.Windows.Forms.Form
    {

        #region Class Variables

        private System.Windows.Forms.NotifyIcon m_NotifyIcon;
        private System.Windows.Forms.TabControl tabs;
        private System.Windows.Forms.ColumnHeader skillHDRName;
        private System.Windows.Forms.ColumnHeader skillHDRvalue;
        private System.Windows.Forms.ColumnHeader skillHDRbase;
        private System.Windows.Forms.ColumnHeader skillHDRdelta;
        private System.Windows.Forms.Button resetDelta;
        private System.Windows.Forms.Button setlocks;
        private System.Windows.Forms.ComboBox locks;
        private System.Windows.Forms.ListView skillList;
        private System.Windows.Forms.ColumnHeader skillHDRcap;
        private System.Windows.Forms.Label label1;
        private System.Windows.Forms.TextBox baseTotal;
        private System.Windows.Forms.TabPage dressTab;
        private System.Windows.Forms.Button skillCopySel;
        private System.Windows.Forms.Button skillCopyAll;
        private System.Windows.Forms.GroupBox groupBox5;
        private System.Windows.Forms.Button removeDress;
        private System.Windows.Forms.Button addDress;
        private System.Windows.Forms.ListBox dressList;
        private System.Windows.Forms.GroupBox groupBox6;
        private System.Windows.Forms.Button targItem;
        private System.Windows.Forms.ListBox dressItems;
        private System.Windows.Forms.Button dressUseCur;
        private System.Windows.Forms.TabPage generalTab;
        private System.Windows.Forms.TabPage displayTab;
        private System.Windows.Forms.TabPage skillsTab;
        private System.Windows.Forms.TabPage hotkeysTab;
        private System.Windows.Forms.CheckBox chkCtrl;
        private System.Windows.Forms.CheckBox chkAlt;
        private System.Windows.Forms.CheckBox chkShift;
        private System.Windows.Forms.GroupBox groupBox8;
        private System.Windows.Forms.TextBox hkKey;
        private System.Windows.Forms.Button setHK;
        private System.Windows.Forms.Button unsetHK;
        private System.Windows.Forms.Label label2;
        private System.Windows.Forms.CheckBox chkPass;
        private System.Windows.Forms.TabPage moreOptTab;
        private System.Windows.Forms.TabPage agentsTab;
        private System.Windows.Forms.GroupBox agentGroup;
        private System.Windows.Forms.ListBox agentSubList;
        private System.Windows.Forms.Button agentB1;
        private System.Windows.Forms.Button agentB2;
        private System.Windows.Forms.Button agentB3;
        private System.Windows.Forms.Button dohotkey;
        private System.Windows.Forms.Button agentB4;
        private System.Windows.Forms.CheckBox dispDelta;
        private System.Windows.Forms.ComboBox agentList;
        private System.Windows.Forms.TabPage macrosTab;
        private System.Windows.Forms.TreeView hotkeyTree;
        private System.Windows.Forms.TabPage screenshotTab;
        private System.Windows.Forms.TabPage aboutTab;
        private System.Windows.Forms.Button dressNow;
        private System.Windows.Forms.Button undressList;
        private System.Windows.Forms.PictureBox screenPrev;
        private System.Windows.Forms.ListBox screensList;
        private System.Windows.Forms.Button setScnPath;
        private System.Windows.Forms.RadioButton radioFull;
        private System.Windows.Forms.RadioButton radioUO;
        private System.Windows.Forms.CheckBox captureOthersDeath;
        private System.Windows.Forms.TextBox screenPath;
        private System.Windows.Forms.Button capNow;
        private System.Windows.Forms.CheckBox dispTime;
        private System.Windows.Forms.Button agentB5;
        private System.Windows.Forms.Button agentB6;
        private System.Windows.Forms.CheckBox undressConflicts;
        private System.Windows.Forms.ColumnHeader skillHDRlock;
        private System.ComponentModel.IContainer components;
        private System.Windows.Forms.Button undressBag;
        private System.Windows.Forms.Button dressDelSel;
        private System.Windows.Forms.Label hkStatus;
        private System.Windows.Forms.Button clearDress;
        private System.Windows.Forms.Label label12;
        private System.Windows.Forms.ComboBox imgFmt;
        private ToolTip m_Tip;

        #endregion

        private int m_LastKV = 0;
        private bool m_ProfileConfirmLoad;
        private LinkLabel linkMain;
        private Label label21;
        private Label aboutVer;
        private TextBox filterHotkeys;
        private Label label22;
        private bool m_CanClose = true;
        private TabPage advancedTab;
        private Label aboutSubInfo;
        private Label lblCredits1;
        private Label label20;
        private CheckBox logSkillChanges;
        private TreeView _hotkeyTreeViewCache = new TreeView();
        private LinkLabel linkHelp;
        private TabControl tabControl2;
        private TabPage subMacrosTab;
        private TabPage subMacrosOptionsTab;
        private CheckBox rangeCheckDoubleClick;
        private CheckBox rangeCheckTargetByType;
        private Button nextMacroAction;
        private CheckBox stepThroughMacro;
        private CheckBox targetByTypeDifferent;
        private System.Windows.Forms.GroupBox macroVariableGroup;
        private ComboBox macroVariableTypeList;
        private Button retargetMacroVariable;
        private Button insertMacroVariable;
        private Button removeMacroVariable;
        private Button addMacroVariable;
        private ListBox macroVariables;
        private TextBox filterMacros;
        private Label filterLabel;
        private TreeView macroTree;
        private Button delMacro;
        private Button newMacro;
        private GroupBox macroActGroup;
        private Button playMacro;
        private Label waitDisp;
        private CheckBox loopMacro;
        private Button recMacro;
        private ListBox actionList;
        private TabControl optionsTabCtrl;
        private System.Windows.Forms.TabPage subOptionsSpeechTab;
        private Button setLTHilight;
        private CheckBox lthilight;
        private Button setHarmHue;
        private Button setNeuHue;
        private Label lblHarmHue;
        private Label lblNeuHue;
        private Label lblBeneHue;
        private Button setBeneHue;
        private Button setSpeechHue;
        private Button setWarnHue;
        private Button setMsgHue;
        private Button setExHue;
        private Label lblWarnHue;
        private Label lblMsgHue;
        private Label lblExHue;
        private TextBox txtSpellFormat;
        private CheckBox chkForceSpellHue;
        private CheckBox chkForceSpeechHue;
        private Label label3;
        private TabPage subOptionsTargetTab;
        private CheckBox incomingMob;
        private CheckBox incomingCorpse;
        private CheckBox showAttackTargetNewOnly;
        private CheckBox showTextTargetIndicator;
        private CheckBox showAttackTarget;
        private CheckBox showTargetMessagesOverChar;
        private TextBox txtObjDelay;
        private CheckBox objectDelay;
        private TextBox ltRange;
        private CheckBox QueueActions;
        private CheckBox rangeCheckLT;
        private CheckBox actionStatusMsg;
        private Label label8;
        private Label label6;
        private CheckBox queueTargets;
        private CheckBox showtargtext;
        private Button containerLabels;
        private CheckBox showContainerLabels;
        private System.Windows.Forms.CheckBox showBuffDebuffOverhead;
        private TextBox healthFmt;
        private Label label10;
        private CheckBox showHealthOH;
        private CheckBox chkPartyOverhead;
        private TabPage subOptionsMiscTab;
        private Button setMinLightLevel;
        private Button setMaxLightLevel;
        private ComboBox seasonList;
        private Label lblSeason;
        private Label lightLevel;
        private TrackBar lightLevelBar;
        private CheckBox minMaxLightLevel;
        private CheckBox blockPartyInvites;
        private CheckBox blockTradeRequests;
        private CheckBox blockOpenCorpsesTwice;
        private CheckBox preAOSstatbar;
        private TextBox corpseRange;
        private CheckBox autoStackRes;
        private Label label4;
        private CheckBox openCorpses;
        private CheckBox blockDis;
        private CheckBox showStaticWalls;
        private CheckBox showStaticWallLabels;
        private CheckBox stealthOverhead;
        private TextBox forceSizeX;
        private TextBox forceSizeY;
        private CheckBox blockHealPoison;
        private CheckBox potionEquip;
        private CheckBox spellUnequip;
        private CheckBox autoOpenDoors;
        private CheckBox chkStealth;
        private Label label18;
        private CheckBox gameSize;
        private CheckBox damageTakenOverhead;
        private CheckBox showDamageTaken;
        private CheckBox damageDealtOverhead;
        private CheckBox showDamageDealt;
        private CheckBox rememberPwds;
        private System.Windows.Forms.TabControl displayCountersTabCtrl;
        private TabPage subDisplayTab;
        private GroupBox groupBox11;
        private Button razorTitleBarKey;
        private System.Windows.Forms.CheckBox showInRazorTitleBar;
        private TextBox razorTitleBar;
        private System.Windows.Forms.CheckBox trackDps;
        private System.Windows.Forms.CheckBox trackIncomingGold;
        private CheckBox showNotoHue;
        private CheckBox highlightSpellReags;
        private GroupBox groupBox3;
        private ComboBox titleBarParams;
        private TextBox titleStr;
        private CheckBox showInBar;
        private TabPage subCountersTab;
        private TextBox warnNum;
        private CheckBox warnCount;
        private CheckBox excludePouches;
        private CheckBox titlebarImages;
        private CheckBox checkNewConts;
        private System.Windows.Forms.GroupBox groupBox2;
        private System.Windows.Forms.ListView counters;
        private ColumnHeader cntName;
        private ColumnHeader cntCount;
        private System.Windows.Forms.Button delCounter;
        private System.Windows.Forms.Button addCounter;
        private System.Windows.Forms.Button recount;
        private TabControl subGeneralTab;
        private TabPage subGenTab;
        private RadioButton systray;
        private RadioButton taskbar;
        private ComboBox langSel;
        private Label label7;
        private Label label11;
        private CheckBox showWelcome;
        private TrackBar opacity;
        private CheckBox alwaysTop;
        private Label opacityLabel;
        private GroupBox groupBox4;
        private Button saveProfile;
        private Button cloneProfile;
        private Button delProfile;
        private Button newProfile;
        private ComboBox profiles;
        private TextBox targetIndicatorFormat;
        private Label lblTargetFormat;
        private Label lblStealthFormat;
        private TextBox stealthStepsFormat;
        private CheckBox dispDeltaOverhead;
        private Label lblCredits2;
        private LinkLabel linkGitHub;
        private Label lblCredits3;
        private GroupBox groupBox15;
        private Button btnMap;
        private Button boatControl;
        private CheckBox captureMibs;
        private CheckBox macroActionDelay;
        private CheckBox autoOpenDoorWhenHidden;
        private CheckBox disableMacroPlayFinish;
        private TabPage subBandageTimerTab;
        private CheckBox onlyShowBandageTimerSeconds;
        private TextBox bandageTimerFormat;
        private CheckBox showBandageTimer;
        private ComboBox bandageTimerLocation;
        private TextBox bandageTimerSeconds;
        private Label lblBandageCountFormat;
        private Button setBandageHue;
        private Button setTargetIndicatorHue;
        private GroupBox groupSmartTarget;
        private CheckBox nonFriendlyHarmfulOnly;
        private CheckBox friendBeneficialOnly;
        private CheckBox onlyNextPrevBeneficial;
        private CheckBox smartLT;
        private TextBox bandageEndMessage;
        private TextBox bandageStartMessage;
        private System.Windows.Forms.CheckBox showBandageEnd;
        private System.Windows.Forms.CheckBox showBandageStart;
        private System.Windows.Forms.Button buffDebuffOptions;
        private TextBox captureOthersDeathDelay;
        private Label lblCaptureOthersDeathMs;
        private TextBox captureOwnDeathDelay;
        private Label lblOwnDeathMs;
        private CheckBox captureOwnDeath;
        private Button setMacroHotKey;
        private TabPage subFilterSoundMusic;
        private CheckedListBox soundFilterList;
        private CheckBox soundFilterEnabled;
        private Button playSound;
        private CheckBox showFilteredSound;
        private CheckBox showPlayingSoundInfo;
        private CheckBox showPlayingMusic;
        private CheckBox playInClient;
        private Button playMusic;
        private ComboBox playableMusicList;
        private TreeView _macroTreeViewCache = new TreeView();
        private TreeView _scriptTreeViewCache = new TreeView();
        private TreeView _itemTreeCache = new TreeView();


        public Label WaitDisplay
        {
            get { return waitDisp; }
        }

        public MainForm()
        {
            m_ProfileConfirmLoad = true;
            m_Tip = new ToolTip();
            //
            // Required for Windows Form Designer support
            //
            InitializeComponent();

            m_NotifyIcon.ContextMenuStrip = new ContextMenuStrip();
            m_NotifyIcon.ContextMenuStrip.Items.Add("Show Razor", null, new EventHandler(DoShowMe));
            m_NotifyIcon.ContextMenuStrip.Items.Add("Hide Razor", null, new EventHandler(HideMe));
            m_NotifyIcon.ContextMenuStrip.Items.Add("-");
            m_NotifyIcon.ContextMenuStrip.Items.Add("Toggle Razor Visibility", null, new EventHandler(ToggleVisible));
            m_NotifyIcon.ContextMenuStrip.Items.Add("-");
            m_NotifyIcon.ContextMenuStrip.Items.Add("Close Razor && UO", null, new EventHandler(OnClose));

            m_NotifyIcon.ContextMenuStrip.Items[0].Select();
        }

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (components != null)
                {
                    components.Dispose();
                }
            }

            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.components = new System.ComponentModel.Container();
            System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(MainForm));
            this.m_NotifyIcon = new System.Windows.Forms.NotifyIcon(this.components);
            this.tabs = new System.Windows.Forms.TabControl();
            this.generalTab = new System.Windows.Forms.TabPage();
            this.subGeneralTab = new System.Windows.Forms.TabControl();
            this.subGenTab = new System.Windows.Forms.TabPage();
            this.groupBox15 = new System.Windows.Forms.GroupBox();
            this.boatControl = new System.Windows.Forms.Button();
            this.btnMap = new System.Windows.Forms.Button();
            this.systray = new System.Windows.Forms.RadioButton();
            this.taskbar = new System.Windows.Forms.RadioButton();
            this.langSel = new System.Windows.Forms.ComboBox();
            this.label7 = new System.Windows.Forms.Label();
            this.label11 = new System.Windows.Forms.Label();
            this.showWelcome = new System.Windows.Forms.CheckBox();
            this.opacity = new System.Windows.Forms.TrackBar();
            this.alwaysTop = new System.Windows.Forms.CheckBox();
            this.opacityLabel = new System.Windows.Forms.Label();
            this.groupBox4 = new System.Windows.Forms.GroupBox();
            this.saveProfile = new System.Windows.Forms.Button();
            this.cloneProfile = new System.Windows.Forms.Button();
            this.delProfile = new System.Windows.Forms.Button();
            this.newProfile = new System.Windows.Forms.Button();
            this.profiles = new System.Windows.Forms.ComboBox();
            this.moreOptTab = new System.Windows.Forms.TabPage();
            this.optionsTabCtrl = new System.Windows.Forms.TabControl();
            this.subOptionsSpeechTab = new System.Windows.Forms.TabPage();
            this.playEmoteSound = new System.Windows.Forms.CheckBox();
            this.overrideSpellFormat = new System.Windows.Forms.CheckBox();
            this.damageTakenOverhead = new System.Windows.Forms.CheckBox();
            this.showDamageTaken = new System.Windows.Forms.CheckBox();
            this.damageDealtOverhead = new System.Windows.Forms.CheckBox();
            this.showDamageDealt = new System.Windows.Forms.CheckBox();
            this.healthFmt = new System.Windows.Forms.TextBox();
            this.label10 = new System.Windows.Forms.Label();
            this.showHealthOH = new System.Windows.Forms.CheckBox();
            this.chkPartyOverhead = new System.Windows.Forms.CheckBox();
            this.containerLabels = new System.Windows.Forms.Button();
            this.showContainerLabels = new System.Windows.Forms.CheckBox();
            this.incomingMob = new System.Windows.Forms.CheckBox();
            this.incomingCorpse = new System.Windows.Forms.CheckBox();
            this.setLTHilight = new System.Windows.Forms.Button();
            this.lthilight = new System.Windows.Forms.CheckBox();
            this.setHarmHue = new System.Windows.Forms.Button();
            this.setNeuHue = new System.Windows.Forms.Button();
            this.lblHarmHue = new System.Windows.Forms.Label();
            this.lblNeuHue = new System.Windows.Forms.Label();
            this.lblBeneHue = new System.Windows.Forms.Label();
            this.setBeneHue = new System.Windows.Forms.Button();
            this.setSpeechHue = new System.Windows.Forms.Button();
            this.setWarnHue = new System.Windows.Forms.Button();
            this.setMsgHue = new System.Windows.Forms.Button();
            this.setExHue = new System.Windows.Forms.Button();
            this.lblWarnHue = new System.Windows.Forms.Label();
            this.lblMsgHue = new System.Windows.Forms.Label();
            this.lblExHue = new System.Windows.Forms.Label();
            this.txtSpellFormat = new System.Windows.Forms.TextBox();
            this.chkForceSpellHue = new System.Windows.Forms.CheckBox();
            this.chkForceSpeechHue = new System.Windows.Forms.CheckBox();
            this.label3 = new System.Windows.Forms.Label();
            this.subOptionsTargetTab = new System.Windows.Forms.TabPage();
            this.groupSmartTarget = new System.Windows.Forms.GroupBox();
            this.nextPrevAbcOrder = new System.Windows.Forms.CheckBox();
            this.nonFriendlyHarmfulOnly = new System.Windows.Forms.CheckBox();
            this.friendBeneficialOnly = new System.Windows.Forms.CheckBox();
            this.onlyNextPrevBeneficial = new System.Windows.Forms.CheckBox();
            this.smartLT = new System.Windows.Forms.CheckBox();
            this.setTargetIndicatorHue = new System.Windows.Forms.Button();
            this.targetIndicatorFormat = new System.Windows.Forms.TextBox();
            this.showtargtext = new System.Windows.Forms.CheckBox();
            this.showAttackTargetNewOnly = new System.Windows.Forms.CheckBox();
            this.showTextTargetIndicator = new System.Windows.Forms.CheckBox();
            this.showAttackTarget = new System.Windows.Forms.CheckBox();
            this.showTargetMessagesOverChar = new System.Windows.Forms.CheckBox();
            this.txtObjDelay = new System.Windows.Forms.TextBox();
            this.objectDelay = new System.Windows.Forms.CheckBox();
            this.ltRange = new System.Windows.Forms.TextBox();
            this.QueueActions = new System.Windows.Forms.CheckBox();
            this.rangeCheckLT = new System.Windows.Forms.CheckBox();
            this.actionStatusMsg = new System.Windows.Forms.CheckBox();
            this.label8 = new System.Windows.Forms.Label();
            this.label6 = new System.Windows.Forms.Label();
            this.queueTargets = new System.Windows.Forms.CheckBox();
            this.lblTargetFormat = new System.Windows.Forms.Label();
            this.subOptionsMiscTab = new System.Windows.Forms.TabPage();
            this.buyAgentIgnoreGold = new System.Windows.Forms.CheckBox();
            this.reequipHandsPotion = new System.Windows.Forms.CheckBox();
            this.autoOpenDoorWhenHidden = new System.Windows.Forms.CheckBox();
            this.lblStealthFormat = new System.Windows.Forms.Label();
            this.stealthStepsFormat = new System.Windows.Forms.TextBox();
            this.rememberPwds = new System.Windows.Forms.CheckBox();
            this.showStaticWalls = new System.Windows.Forms.CheckBox();
            this.showStaticWallLabels = new System.Windows.Forms.CheckBox();
            this.stealthOverhead = new System.Windows.Forms.CheckBox();
            this.forceSizeX = new System.Windows.Forms.TextBox();
            this.forceSizeY = new System.Windows.Forms.TextBox();
            this.blockHealPoison = new System.Windows.Forms.CheckBox();
            this.potionEquip = new System.Windows.Forms.CheckBox();
            this.spellUnequip = new System.Windows.Forms.CheckBox();
            this.autoOpenDoors = new System.Windows.Forms.CheckBox();
            this.chkStealth = new System.Windows.Forms.CheckBox();
            this.label18 = new System.Windows.Forms.Label();
            this.gameSize = new System.Windows.Forms.CheckBox();
            this.setMinLightLevel = new System.Windows.Forms.Button();
            this.setMaxLightLevel = new System.Windows.Forms.Button();
            this.seasonList = new System.Windows.Forms.ComboBox();
            this.lblSeason = new System.Windows.Forms.Label();
            this.lightLevel = new System.Windows.Forms.Label();
            this.lightLevelBar = new System.Windows.Forms.TrackBar();
            this.minMaxLightLevel = new System.Windows.Forms.CheckBox();
            this.blockPartyInvites = new System.Windows.Forms.CheckBox();
            this.blockTradeRequests = new System.Windows.Forms.CheckBox();
            this.blockOpenCorpsesTwice = new System.Windows.Forms.CheckBox();
            this.preAOSstatbar = new System.Windows.Forms.CheckBox();
            this.corpseRange = new System.Windows.Forms.TextBox();
            this.autoStackRes = new System.Windows.Forms.CheckBox();
            this.label4 = new System.Windows.Forms.Label();
            this.openCorpses = new System.Windows.Forms.CheckBox();
            this.blockDis = new System.Windows.Forms.CheckBox();
            this.displayTab = new System.Windows.Forms.TabPage();
            this.displayCountersTabCtrl = new System.Windows.Forms.TabControl();
            this.subDisplayTab = new System.Windows.Forms.TabPage();
            this.groupBox11 = new System.Windows.Forms.GroupBox();
            this.razorTitleBarKey = new System.Windows.Forms.Button();
            this.showInRazorTitleBar = new System.Windows.Forms.CheckBox();
            this.razorTitleBar = new System.Windows.Forms.TextBox();
            this.trackDps = new System.Windows.Forms.CheckBox();
            this.trackIncomingGold = new System.Windows.Forms.CheckBox();
            this.showNotoHue = new System.Windows.Forms.CheckBox();
            this.highlightSpellReags = new System.Windows.Forms.CheckBox();
            this.groupBox3 = new System.Windows.Forms.GroupBox();
            this.titleBarParams = new System.Windows.Forms.ComboBox();
            this.titleStr = new System.Windows.Forms.TextBox();
            this.showInBar = new System.Windows.Forms.CheckBox();
            this.subCountersTab = new System.Windows.Forms.TabPage();
            this.warnNum = new System.Windows.Forms.TextBox();
            this.warnCount = new System.Windows.Forms.CheckBox();
            this.excludePouches = new System.Windows.Forms.CheckBox();
            this.titlebarImages = new System.Windows.Forms.CheckBox();
            this.checkNewConts = new System.Windows.Forms.CheckBox();
            this.groupBox2 = new System.Windows.Forms.GroupBox();
            this.counters = new System.Windows.Forms.ListView();
            this.cntName = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader()));
            this.cntCount = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader()));
            this.delCounter = new System.Windows.Forms.Button();
            this.addCounter = new System.Windows.Forms.Button();
            this.recount = new System.Windows.Forms.Button();
            this.subBandageTimerTab = new System.Windows.Forms.TabPage();
            this.bandageEndMessage = new System.Windows.Forms.TextBox();
            this.bandageStartMessage = new System.Windows.Forms.TextBox();
            this.showBandageEnd = new System.Windows.Forms.CheckBox();
            this.showBandageStart = new System.Windows.Forms.CheckBox();
            this.setBandageHue = new System.Windows.Forms.Button();
            this.bandageTimerLocation = new System.Windows.Forms.ComboBox();
            this.bandageTimerSeconds = new System.Windows.Forms.TextBox();
            this.onlyShowBandageTimerSeconds = new System.Windows.Forms.CheckBox();
            this.bandageTimerFormat = new System.Windows.Forms.TextBox();
            this.showBandageTimer = new System.Windows.Forms.CheckBox();
            this.lblBandageCountFormat = new System.Windows.Forms.Label();
            this.subOverheadTab = new System.Windows.Forms.TabPage();
            this.setSound = new System.Windows.Forms.Button();
            this.label14 = new System.Windows.Forms.Label();
            this.unicodeStyle = new System.Windows.Forms.RadioButton();
            this.asciiStyle = new System.Windows.Forms.RadioButton();
            this.editOverheadMessage = new System.Windows.Forms.Button();
            this.setColorHue = new System.Windows.Forms.Button();
            this.removeOverheadMessage = new System.Windows.Forms.Button();
            this.label13 = new System.Windows.Forms.Label();
            this.overheadFormat = new System.Windows.Forms.TextBox();
            this.setOverheadMessage = new System.Windows.Forms.Button();
            this.cliLocOverheadView = new System.Windows.Forms.ListView();
            this.cliLocOriginal = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader()));
            this.cliLocOverheadMessage = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader()));
            this.cliLocSound = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader()));
            this.cliLocSearch = new System.Windows.Forms.Button();
            this.cliLocTextSearch = new System.Windows.Forms.TextBox();
            this.lblOhSearch = new System.Windows.Forms.Label();
            this.cliLocSearchView = new System.Windows.Forms.ListView();
            this.cliLocSearchNumber = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader()));
            this.cliLocSearchText = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader()));
            this.showOverheadMessages = new System.Windows.Forms.CheckBox();
            this.subWaypoints = new System.Windows.Forms.TabPage();
            this.waypointOnDeath = new System.Windows.Forms.CheckBox();
            this.lblWaypointTiles = new System.Windows.Forms.Label();
            this.hideWaypointDist = new System.Windows.Forms.TextBox();
            this.hideWaypointWithin = new System.Windows.Forms.CheckBox();
            this.txtWaypointDistanceSec = new System.Windows.Forms.TextBox();
            this.lblWaypointSeconds = new System.Windows.Forms.Label();
            this.showWaypointDistance = new System.Windows.Forms.CheckBox();
            this.showWaypointOverhead = new System.Windows.Forms.CheckBox();
            this.btnRemoveSelectedWaypoint = new System.Windows.Forms.Button();
            this.btnHideWaypoint = new System.Windows.Forms.Button();
            this.btnUseCurrentLoc = new System.Windows.Forms.Button();
            this.txtWaypointName = new System.Windows.Forms.TextBox();
            this.lblWaypointY = new System.Windows.Forms.Label();
            this.lblWaypointX = new System.Windows.Forms.Label();
            this.txtWaypointX = new System.Windows.Forms.TextBox();
            this.txtWaypointY = new System.Windows.Forms.TextBox();
            this.lblWaypoint = new System.Windows.Forms.Label();
            this.btnAddWaypoint = new System.Windows.Forms.Button();
            this.waypointList = new System.Windows.Forms.ListBox();
            this.subBuffsDebuffs = new System.Windows.Forms.TabPage();
            this.buffBarGroupBox = new System.Windows.Forms.GroupBox();
            this.showBuffDebuffTimeType = new System.Windows.Forms.ComboBox();
            this.lblShowBuffTime = new System.Windows.Forms.Label();
            this.useBlackBuffDebuffBg = new System.Windows.Forms.CheckBox();
            this.buffBarHeight = new System.Windows.Forms.TextBox();
            this.lblBuffBarHeight = new System.Windows.Forms.Label();
            this.buffBarSort = new System.Windows.Forms.ComboBox();
            this.lblBuffSortBy = new System.Windows.Forms.Label();
            this.buffBarWidth = new System.Windows.Forms.TextBox();
            this.lblBuffBarWidth = new System.Windows.Forms.Label();
            this.showBuffIcons = new System.Windows.Forms.CheckBox();
            this.showBuffDebuffGump = new System.Windows.Forms.CheckBox();
            this.buffDebuffOptions = new System.Windows.Forms.Button();
            this.showBuffDebuffOverhead = new System.Windows.Forms.CheckBox();
            this.dressTab = new System.Windows.Forms.TabPage();
            this.groupBox6 = new System.Windows.Forms.GroupBox();
            this.clearDress = new System.Windows.Forms.Button();
            this.dressDelSel = new System.Windows.Forms.Button();
            this.undressBag = new System.Windows.Forms.Button();
            this.undressList = new System.Windows.Forms.Button();
            this.dressUseCur = new System.Windows.Forms.Button();
            this.targItem = new System.Windows.Forms.Button();
            this.dressItems = new System.Windows.Forms.ListBox();
            this.dressNow = new System.Windows.Forms.Button();
            this.groupBox5 = new System.Windows.Forms.GroupBox();
            this.removeDress = new System.Windows.Forms.Button();
            this.addDress = new System.Windows.Forms.Button();
            this.dressList = new System.Windows.Forms.ListBox();
            this.undressConflicts = new System.Windows.Forms.CheckBox();
            this.skillsTab = new System.Windows.Forms.TabPage();
            this.captureMibs = new System.Windows.Forms.CheckBox();
            this.dispDeltaOverhead = new System.Windows.Forms.CheckBox();
            this.logSkillChanges = new System.Windows.Forms.CheckBox();
            this.dispDelta = new System.Windows.Forms.CheckBox();
            this.skillCopyAll = new System.Windows.Forms.Button();
            this.skillCopySel = new System.Windows.Forms.Button();
            this.baseTotal = new System.Windows.Forms.TextBox();
            this.label1 = new System.Windows.Forms.Label();
            this.locks = new System.Windows.Forms.ComboBox();
            this.setlocks = new System.Windows.Forms.Button();
            this.resetDelta = new System.Windows.Forms.Button();
            this.skillList = new System.Windows.Forms.ListView();
            this.skillHDRName = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader()));
            this.skillHDRvalue = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader()));
            this.skillHDRbase = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader()));
            this.skillHDRdelta = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader()));
            this.skillHDRcap = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader()));
            this.skillHDRlock = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader()));
            this.agentsTab = new System.Windows.Forms.TabPage();
            this.agentSetHotKey = new System.Windows.Forms.Button();
            this.agentB6 = new System.Windows.Forms.Button();
            this.agentB5 = new System.Windows.Forms.Button();
            this.agentList = new System.Windows.Forms.ComboBox();
            this.agentGroup = new System.Windows.Forms.GroupBox();
            this.agentSubList = new System.Windows.Forms.ListBox();
            this.agentB4 = new System.Windows.Forms.Button();
            this.agentB1 = new System.Windows.Forms.Button();
            this.agentB2 = new System.Windows.Forms.Button();
            this.agentB3 = new System.Windows.Forms.Button();
            this.filtersTab = new System.Windows.Forms.TabPage();
            this.filterTabs = new System.Windows.Forms.TabControl();
            this.subFilterTab = new System.Windows.Forms.TabPage();
            this.wyrmAnimationList = new System.Windows.Forms.ComboBox();
            this.filterWhiteWyrm = new System.Windows.Forms.CheckBox();
            this.daemonAnimationList = new System.Windows.Forms.ComboBox();
            this.filterDaemonGraphics = new System.Windows.Forms.CheckBox();
            this.drakeAnimationList = new System.Windows.Forms.ComboBox();
            this.filterDrakeGraphics = new System.Windows.Forms.CheckBox();
            this.dragonAnimationList = new System.Windows.Forms.ComboBox();
            this.filterDragonGraphics = new System.Windows.Forms.CheckBox();
            this.filters = new System.Windows.Forms.CheckedListBox();
            this.subFilterText = new System.Windows.Forms.TabPage();
            this.gbFilterText = new System.Windows.Forms.GroupBox();
            this.removeFilterText = new System.Windows.Forms.Button();
            this.addFilterText = new System.Windows.Forms.Button();
            this.textFilterList = new System.Windows.Forms.ListBox();
            this.enableTextFilter = new System.Windows.Forms.CheckBox();
            this.gbFilterMessages = new System.Windows.Forms.GroupBox();
            this.filterOverheadMessages = new System.Windows.Forms.CheckBox();
            this.lblFilterDelaySeconds = new System.Windows.Forms.Label();
            this.lblFilterDelay = new System.Windows.Forms.Label();
            this.filterDelaySeconds = new System.Windows.Forms.TextBox();
            this.filterRazorMessages = new System.Windows.Forms.CheckBox();
            this.filterSystemMessages = new System.Windows.Forms.CheckBox();
            this.filterSnoop = new System.Windows.Forms.CheckBox();
            this.subFilterSoundMusic = new System.Windows.Forms.TabPage();
            this.playableMusicList = new System.Windows.Forms.ComboBox();
            this.playMusic = new System.Windows.Forms.Button();
            this.showPlayingMusic = new System.Windows.Forms.CheckBox();
            this.showPlayingSoundInfo = new System.Windows.Forms.CheckBox();
            this.showFilteredSound = new System.Windows.Forms.CheckBox();
            this.playInClient = new System.Windows.Forms.CheckBox();
            this.playSound = new System.Windows.Forms.Button();
            this.soundFilterEnabled = new System.Windows.Forms.CheckBox();
            this.soundFilterList = new System.Windows.Forms.CheckedListBox();
            this.subFilterTargets = new System.Windows.Forms.TabPage();
            this.lblTargetFilter = new System.Windows.Forms.Label();
            this.targetFilterClear = new System.Windows.Forms.Button();
            this.targetFilterRemove = new System.Windows.Forms.Button();
            this.targetFilterAdd = new System.Windows.Forms.Button();
            this.targetFilter = new System.Windows.Forms.ListBox();
            this.targetFilterEnabled = new System.Windows.Forms.CheckBox();
            this.hotkeysTab = new System.Windows.Forms.TabPage();
            this.filterHotkeys = new System.Windows.Forms.TextBox();
            this.label22 = new System.Windows.Forms.Label();
            this.hkStatus = new System.Windows.Forms.Label();
            this.hotkeyTree = new System.Windows.Forms.TreeView();
            this.dohotkey = new System.Windows.Forms.Button();
            this.groupBox8 = new System.Windows.Forms.GroupBox();
            this.hkCommand = new System.Windows.Forms.TextBox();
            this.hkCmdLabel = new System.Windows.Forms.Label();
            this.chkAlt = new System.Windows.Forms.CheckBox();
            this.chkPass = new System.Windows.Forms.CheckBox();
            this.label2 = new System.Windows.Forms.Label();
            this.unsetHK = new System.Windows.Forms.Button();
            this.setHK = new System.Windows.Forms.Button();
            this.hkKey = new System.Windows.Forms.TextBox();
            this.chkCtrl = new System.Windows.Forms.CheckBox();
            this.chkShift = new System.Windows.Forms.CheckBox();
            this.macrosTab = new System.Windows.Forms.TabPage();
            this.tabControl2 = new System.Windows.Forms.TabControl();
            this.subMacrosTab = new System.Windows.Forms.TabPage();
            this.macroActGroup = new System.Windows.Forms.GroupBox();
            this.setMacroHotKey = new System.Windows.Forms.Button();
            this.playMacro = new System.Windows.Forms.Button();
            this.waitDisp = new System.Windows.Forms.Label();
            this.loopMacro = new System.Windows.Forms.CheckBox();
            this.recMacro = new System.Windows.Forms.Button();
            this.actionList = new System.Windows.Forms.ListBox();
            this.filterMacros = new System.Windows.Forms.TextBox();
            this.filterLabel = new System.Windows.Forms.Label();
            this.macroTree = new System.Windows.Forms.TreeView();
            this.delMacro = new System.Windows.Forms.Button();
            this.newMacro = new System.Windows.Forms.Button();
            this.subMacrosOptionsTab = new System.Windows.Forms.TabPage();
            this.disableMacroPlayFinish = new System.Windows.Forms.CheckBox();
            this.macroActionDelay = new System.Windows.Forms.CheckBox();
            this.rangeCheckDoubleClick = new System.Windows.Forms.CheckBox();
            this.rangeCheckTargetByType = new System.Windows.Forms.CheckBox();
            this.nextMacroAction = new System.Windows.Forms.Button();
            this.stepThroughMacro = new System.Windows.Forms.CheckBox();
            this.targetByTypeDifferent = new System.Windows.Forms.CheckBox();
            this.macroVariableGroup = new System.Windows.Forms.GroupBox();
            this.macroVariableTypeList = new System.Windows.Forms.ComboBox();
            this.retargetMacroVariable = new System.Windows.Forms.Button();
            this.insertMacroVariable = new System.Windows.Forms.Button();
            this.removeMacroVariable = new System.Windows.Forms.Button();
            this.addMacroVariable = new System.Windows.Forms.Button();
            this.macroVariables = new System.Windows.Forms.ListBox();
            this.scriptsTab = new System.Windows.Forms.TabPage();
            this.subTabScripts = new System.Windows.Forms.TabControl();
            this.subScripts = new System.Windows.Forms.TabPage();
            this.scriptHotkey = new System.Windows.Forms.Label();
            this.scriptSplitContainer = new System.Windows.Forms.SplitContainer();
            this.scriptTree = new System.Windows.Forms.TreeView();
            this.scriptFilter = new System.Windows.Forms.TextBox();
            this.scriptDocMap = new FastColoredTextBoxNS.DocumentMap();
            this.scriptEditor = new FastColoredTextBoxNS.FastColoredTextBox();
            this.scriptGuide = new System.Windows.Forms.Button();
            this.saveScript = new System.Windows.Forms.Button();
            this.newScript = new System.Windows.Forms.Button();
            this.setScriptHotkey = new System.Windows.Forms.Button();
            this.recordScript = new System.Windows.Forms.Button();
            this.playScript = new System.Windows.Forms.Button();
            this.subScriptOptions = new System.Windows.Forms.TabPage();
            this.disableScriptStopwatch = new System.Windows.Forms.CheckBox();
            this.enableHighlight = new System.Windows.Forms.CheckBox();
            this.defaultScriptDelay = new System.Windows.Forms.CheckBox();
            this.disableScriptTooltips = new System.Windows.Forms.CheckBox();
            this.scriptDisablePlayFinish = new System.Windows.Forms.CheckBox();
            this.autoSaveScriptPlay = new System.Windows.Forms.CheckBox();
            this.autoSaveScript = new System.Windows.Forms.CheckBox();
            this.scriptVariablesBox = new System.Windows.Forms.GroupBox();
            this.changeScriptVariable = new System.Windows.Forms.Button();
            this.removeScriptVariable = new System.Windows.Forms.Button();
            this.addScriptVariable = new System.Windows.Forms.Button();
            this.scriptVariables = new System.Windows.Forms.ListBox();
            this.friendsTab = new System.Windows.Forms.TabPage();
            this.showPartyFriendOverhead = new System.Windows.Forms.CheckBox();
            this.highlightFriend = new System.Windows.Forms.CheckBox();
            this.autoAcceptParty = new System.Windows.Forms.CheckBox();
            this.nextPrevIgnoresFriends = new System.Windows.Forms.CheckBox();
            this.autoFriend = new System.Windows.Forms.CheckBox();
            this.friendsGroupBox = new System.Windows.Forms.GroupBox();
            this.showFriendOverhead = new System.Windows.Forms.CheckBox();
            this.setFriendsFormatHue = new System.Windows.Forms.Button();
            this.friendOverheadFormat = new System.Windows.Forms.TextBox();
            this.friendFormat = new System.Windows.Forms.Label();
            this.friendsGroupRemove = new System.Windows.Forms.Button();
            this.friendsGroupAdd = new System.Windows.Forms.Button();
            this.friendClearList = new System.Windows.Forms.Button();
            this.friendRemoveSelected = new System.Windows.Forms.Button();
            this.friendAddTarget = new System.Windows.Forms.Button();
            this.friendsList = new System.Windows.Forms.ListBox();
            this.friendsGroup = new System.Windows.Forms.ComboBox();
            this.friendsListEnabled = new System.Windows.Forms.CheckBox();
            this.screenshotTab = new System.Windows.Forms.TabPage();
            this.openScreenshotFolder = new System.Windows.Forms.Button();
            this.captureOwnDeathDelay = new System.Windows.Forms.TextBox();
            this.lblOwnDeathMs = new System.Windows.Forms.Label();
            this.captureOwnDeath = new System.Windows.Forms.CheckBox();
            this.captureOthersDeathDelay = new System.Windows.Forms.TextBox();
            this.lblCaptureOthersDeathMs = new System.Windows.Forms.Label();
            this.imgFmt = new System.Windows.Forms.ComboBox();
            this.label12 = new System.Windows.Forms.Label();
            this.capNow = new System.Windows.Forms.Button();
            this.screenPath = new System.Windows.Forms.TextBox();
            this.radioUO = new System.Windows.Forms.RadioButton();
            this.radioFull = new System.Windows.Forms.RadioButton();
            this.captureOthersDeath = new System.Windows.Forms.CheckBox();
            this.setScnPath = new System.Windows.Forms.Button();
            this.screensList = new System.Windows.Forms.ListBox();
            this.screenPrev = new System.Windows.Forms.PictureBox();
            this.dispTime = new System.Windows.Forms.CheckBox();
            this.advancedTab = new System.Windows.Forms.TabPage();
            this.subAdvancedTab = new System.Windows.Forms.TabControl();
            this.advancedInfoTab = new System.Windows.Forms.TabPage();
            this.fontDecrease = new System.Windows.Forms.Button();
            this.fontIncrease = new System.Windows.Forms.Button();
            this.groupBox16 = new System.Windows.Forms.GroupBox();
            this.lastBackup = new System.Windows.Forms.Label();
            this.openBackupFolder = new System.Windows.Forms.Button();
            this.setBackupFolder = new System.Windows.Forms.Button();
            this.createBackup = new System.Windows.Forms.Button();
            this.enableUOAAPI = new System.Windows.Forms.CheckBox();
            this.disableSmartCPU = new System.Windows.Forms.Button();
            this.negotiate = new System.Windows.Forms.CheckBox();
            this.openRazorDataDir = new System.Windows.Forms.Button();
            this.msglvl = new System.Windows.Forms.ComboBox();
            this.label17 = new System.Windows.Forms.Label();
            this.logPackets = new System.Windows.Forms.CheckBox();
            this.statusBox = new System.Windows.Forms.TextBox();
            this.features = new System.Windows.Forms.TextBox();
            this.advancedStaffDeco = new System.Windows.Forms.TabPage();
            this.itemAppendM = new System.Windows.Forms.CheckBox();
            this.itemCopyToClipboard = new System.Windows.Forms.CheckBox();
            this.itemSearch = new System.Windows.Forms.TextBox();
            this.itemMovable = new System.Windows.Forms.CheckBox();
            this.itemRandomNumber = new System.Windows.Forms.NumericUpDown();
            this.itemRandom = new System.Windows.Forms.CheckBox();
            this.itemTileCount = new System.Windows.Forms.NumericUpDown();
            this.itemTile = new System.Windows.Forms.Button();
            this.itemAdd = new System.Windows.Forms.Button();
            this.itemTree = new System.Windows.Forms.TreeView();
            this.advancedStaffDoors = new System.Windows.Forms.TabPage();
            this.doorTree = new System.Windows.Forms.TreeView();
            this.doorSouthCW = new System.Windows.Forms.Button();
            this.doorSouthCCW = new System.Windows.Forms.Button();
            this.doorEastCW = new System.Windows.Forms.Button();
            this.doorEastCCW = new System.Windows.Forms.Button();
            this.doorNorthCCW = new System.Windows.Forms.Button();
            this.doorNorthCW = new System.Windows.Forms.Button();
            this.doorWestCCW = new System.Windows.Forms.Button();
            this.doorWestCW = new System.Windows.Forms.Button();
            this.aboutTab = new System.Windows.Forms.TabPage();
            this.linkGitHub = new System.Windows.Forms.LinkLabel();
            this.lblCredits3 = new System.Windows.Forms.Label();
            this.linkHelp = new System.Windows.Forms.LinkLabel();
            this.lblCredits2 = new System.Windows.Forms.Label();
            this.label20 = new System.Windows.Forms.Label();
            this.lblCredits1 = new System.Windows.Forms.Label();
            this.aboutSubInfo = new System.Windows.Forms.Label();
            this.linkMain = new System.Windows.Forms.LinkLabel();
            this.label21 = new System.Windows.Forms.Label();
            this.aboutVer = new System.Windows.Forms.Label();
            this.cooldownGumpBox = new System.Windows.Forms.GroupBox();
            this.cooldownHeight = new System.Windows.Forms.TextBox();
            this.lblCooldownHeight = new System.Windows.Forms.Label();
            this.cooldownWidth = new System.Windows.Forms.TextBox();
            this.lblCooldownWidth = new System.Windows.Forms.Label();
            this.artViewer = new Assistant.UI.ArtViewer();
            this.doorViewer = new Assistant.UI.ArtViewer();
            this.tabs.SuspendLayout();
            this.generalTab.SuspendLayout();
            this.subGeneralTab.SuspendLayout();
            this.subGenTab.SuspendLayout();
            this.groupBox15.SuspendLayout();
            ((System.ComponentModel.ISupportInitialize)(this.opacity)).BeginInit();
            this.groupBox4.SuspendLayout();
            this.moreOptTab.SuspendLayout();
            this.optionsTabCtrl.SuspendLayout();
            this.subOptionsSpeechTab.SuspendLayout();
            this.subOptionsTargetTab.SuspendLayout();
            this.groupSmartTarget.SuspendLayout();
            this.subOptionsMiscTab.SuspendLayout();
            ((System.ComponentModel.ISupportInitialize)(this.lightLevelBar)).BeginInit();
            this.displayTab.SuspendLayout();
            this.displayCountersTabCtrl.SuspendLayout();
            this.subDisplayTab.SuspendLayout();
            this.groupBox11.SuspendLayout();
            this.groupBox3.SuspendLayout();
            this.subCountersTab.SuspendLayout();
            this.groupBox2.SuspendLayout();
            this.subBandageTimerTab.SuspendLayout();
            this.subOverheadTab.SuspendLayout();
            this.subWaypoints.SuspendLayout();
            this.subBuffsDebuffs.SuspendLayout();
            this.buffBarGroupBox.SuspendLayout();
            this.dressTab.SuspendLayout();
            this.groupBox6.SuspendLayout();
            this.groupBox5.SuspendLayout();
            this.skillsTab.SuspendLayout();
            this.agentsTab.SuspendLayout();
            this.agentGroup.SuspendLayout();
            this.filtersTab.SuspendLayout();
            this.filterTabs.SuspendLayout();
            this.subFilterTab.SuspendLayout();
            this.subFilterText.SuspendLayout();
            this.gbFilterText.SuspendLayout();
            this.gbFilterMessages.SuspendLayout();
            this.subFilterSoundMusic.SuspendLayout();
            this.subFilterTargets.SuspendLayout();
            this.hotkeysTab.SuspendLayout();
            this.groupBox8.SuspendLayout();
            this.macrosTab.SuspendLayout();
            this.tabControl2.SuspendLayout();
            this.subMacrosTab.SuspendLayout();
            this.macroActGroup.SuspendLayout();
            this.subMacrosOptionsTab.SuspendLayout();
            this.macroVariableGroup.SuspendLayout();
            this.scriptsTab.SuspendLayout();
            this.subTabScripts.SuspendLayout();
            this.subScripts.SuspendLayout();
            ((System.ComponentModel.ISupportInitialize)(this.scriptSplitContainer)).BeginInit();
            this.scriptSplitContainer.Panel1.SuspendLayout();
            this.scriptSplitContainer.Panel2.SuspendLayout();
            this.scriptSplitContainer.SuspendLayout();
            ((System.ComponentModel.ISupportInitialize)(this.scriptEditor)).BeginInit();
            this.subScriptOptions.SuspendLayout();
            this.scriptVariablesBox.SuspendLayout();
            this.friendsTab.SuspendLayout();
            this.friendsGroupBox.SuspendLayout();
            this.screenshotTab.SuspendLayout();
            ((System.ComponentModel.ISupportInitialize)(this.screenPrev)).BeginInit();
            this.advancedTab.SuspendLayout();
            this.subAdvancedTab.SuspendLayout();
            this.advancedInfoTab.SuspendLayout();
            this.groupBox16.SuspendLayout();
            this.advancedStaffDeco.SuspendLayout();
            ((System.ComponentModel.ISupportInitialize)(this.itemRandomNumber)).BeginInit();
            ((System.ComponentModel.ISupportInitialize)(this.itemTileCount)).BeginInit();
            this.advancedStaffDoors.SuspendLayout();
            this.aboutTab.SuspendLayout();
            this.cooldownGumpBox.SuspendLayout();
            this.SuspendLayout();
            // 
            // m_NotifyIcon
            // 
            this.m_NotifyIcon.Icon = ((System.Drawing.Icon)(resources.GetObject("m_NotifyIcon.Icon")));
            this.m_NotifyIcon.Text = "Razor";
            this.m_NotifyIcon.DoubleClick += new System.EventHandler(this.NotifyIcon_DoubleClick);
            // 
            // tabs
            // 
            this.tabs.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.tabs.Controls.Add(this.generalTab);
            this.tabs.Controls.Add(this.moreOptTab);
            this.tabs.Controls.Add(this.displayTab);
            this.tabs.Controls.Add(this.dressTab);
            this.tabs.Controls.Add(this.skillsTab);
            this.tabs.Controls.Add(this.agentsTab);
            this.tabs.Controls.Add(this.filtersTab);
            this.tabs.Controls.Add(this.hotkeysTab);
            this.tabs.Controls.Add(this.macrosTab);
            this.tabs.Controls.Add(this.scriptsTab);
            this.tabs.Controls.Add(this.friendsTab);
            this.tabs.Controls.Add(this.screenshotTab);
            this.tabs.Controls.Add(this.advancedTab);
            this.tabs.Controls.Add(this.aboutTab);
            this.tabs.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.tabs.Location = new System.Drawing.Point(2, 0);
            this.tabs.Multiline = true;
            this.tabs.Name = "tabs";
            this.tabs.SelectedIndex = 0;
            this.tabs.Size = new System.Drawing.Size(527, 370);
            this.tabs.SizeMode = System.Windows.Forms.TabSizeMode.FillToRight;
            this.tabs.TabIndex = 0;
            this.tabs.SelectedIndexChanged += new System.EventHandler(this.tabs_IndexChanged);
            this.tabs.KeyDown += new System.Windows.Forms.KeyEventHandler(this.tabs_KeyDown);
            // 
            // generalTab
            // 
            this.generalTab.Controls.Add(this.subGeneralTab);
            this.generalTab.Location = new System.Drawing.Point(4, 44);
            this.generalTab.Name = "generalTab";
            this.generalTab.Size = new System.Drawing.Size(519, 322);
            this.generalTab.TabIndex = 0;
            this.generalTab.Text = "General";
            // 
            // subGeneralTab
            // 
            this.subGeneralTab.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.subGeneralTab.Controls.Add(this.subGenTab);
            this.subGeneralTab.Location = new System.Drawing.Point(6, 3);
            this.subGeneralTab.Name = "subGeneralTab";
            this.subGeneralTab.SelectedIndex = 0;
            this.subGeneralTab.Size = new System.Drawing.Size(510, 314);
            this.subGeneralTab.TabIndex = 63;
            this.subGeneralTab.SelectedIndexChanged += new System.EventHandler(this.subGeneralTab_IndexChanged);
            // 
            // subGenTab
            // 
            this.subGenTab.BackColor = System.Drawing.SystemColors.Control;
            this.subGenTab.Controls.Add(this.groupBox15);
            this.subGenTab.Controls.Add(this.systray);
            this.subGenTab.Controls.Add(this.taskbar);
            this.subGenTab.Controls.Add(this.langSel);
            this.subGenTab.Controls.Add(this.label7);
            this.subGenTab.Controls.Add(this.label11);
            this.subGenTab.Controls.Add(this.showWelcome);
            this.subGenTab.Controls.Add(this.opacity);
            this.subGenTab.Controls.Add(this.alwaysTop);
            this.subGenTab.Controls.Add(this.opacityLabel);
            this.subGenTab.Controls.Add(this.groupBox4);
            this.subGenTab.Location = new System.Drawing.Point(4, 24);
            this.subGenTab.Name = "subGenTab";
            this.subGenTab.Padding = new System.Windows.Forms.Padding(3);
            this.subGenTab.Size = new System.Drawing.Size(502, 286);
            this.subGenTab.TabIndex = 0;
            this.subGenTab.Text = "General";
            // 
            // groupBox15
            // 
            this.groupBox15.Controls.Add(this.boatControl);
            this.groupBox15.Controls.Add(this.btnMap);
            this.groupBox15.Location = new System.Drawing.Point(14, 232);
            this.groupBox15.Name = "groupBox15";
            this.groupBox15.Size = new System.Drawing.Size(223, 48);
            this.groupBox15.TabIndex = 77;
            this.groupBox15.TabStop = false;
            this.groupBox15.Text = "Map / Boat";
            // 
            // boatControl
            // 
            this.boatControl.Location = new System.Drawing.Point(119, 16);
            this.boatControl.Name = "boatControl";
            this.boatControl.Size = new System.Drawing.Size(96, 26);
            this.boatControl.TabIndex = 70;
            this.boatControl.Text = "Boat Control";
            this.boatControl.UseVisualStyleBackColor = true;
            this.boatControl.Click += new System.EventHandler(this.boatControl_Click);
            // 
            // btnMap
            // 
            this.btnMap.Location = new System.Drawing.Point(6, 16);
            this.btnMap.Name = "btnMap";
            this.btnMap.Size = new System.Drawing.Size(107, 26);
            this.btnMap.TabIndex = 67;
            this.btnMap.Text = "UOPS";
            this.btnMap.Click += new System.EventHandler(this.btnMap_Click);
            // 
            // systray
            // 
            this.systray.Location = new System.Drawing.Point(164, 118);
            this.systray.Name = "systray";
            this.systray.Size = new System.Drawing.Size(88, 23);
            this.systray.TabIndex = 69;
            this.systray.Text = "System Tray";
            this.systray.CheckedChanged += new System.EventHandler(this.systray_CheckedChanged);
            // 
            // taskbar
            // 
            this.taskbar.Location = new System.Drawing.Point(92, 118);
            this.taskbar.Name = "taskbar";
            this.taskbar.Size = new System.Drawing.Size(79, 23);
            this.taskbar.TabIndex = 68;
            this.taskbar.Text = "Taskbar";
            this.taskbar.CheckedChanged += new System.EventHandler(this.taskbar_CheckedChanged);
            // 
            // langSel
            // 
            this.langSel.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.langSel.Location = new System.Drawing.Point(341, 169);
            this.langSel.Name = "langSel";
            this.langSel.Size = new System.Drawing.Size(136, 23);
            this.langSel.TabIndex = 71;
            this.langSel.SelectedIndexChanged += new System.EventHandler(this.langSel_SelectedIndexChanged);
            // 
            // label7
            // 
            this.label7.Location = new System.Drawing.Point(267, 172);
            this.label7.Name = "label7";
            this.label7.Size = new System.Drawing.Size(68, 18);
            this.label7.TabIndex = 70;
            this.label7.Text = "Language:";
            // 
            // label11
            // 
            this.label11.Location = new System.Drawing.Point(11, 122);
            this.label11.Name = "label11";
            this.label11.Size = new System.Drawing.Size(54, 16);
            this.label11.TabIndex = 67;
            this.label11.Text = "Show in:";
            // 
            // showWelcome
            // 
            this.showWelcome.Location = new System.Drawing.Point(270, 107);
            this.showWelcome.Name = "showWelcome";
            this.showWelcome.Size = new System.Drawing.Size(152, 23);
            this.showWelcome.TabIndex = 66;
            this.showWelcome.Text = "Show Welcome Screen";
            this.showWelcome.CheckedChanged += new System.EventHandler(this.showWelcome_CheckedChanged);
            // 
            // opacity
            // 
            this.opacity.AutoSize = false;
            this.opacity.Cursor = System.Windows.Forms.Cursors.SizeWE;
            this.opacity.Location = new System.Drawing.Point(97, 150);
            this.opacity.Maximum = 100;
            this.opacity.Minimum = 10;
            this.opacity.Name = "opacity";
            this.opacity.Size = new System.Drawing.Size(155, 21);
            this.opacity.TabIndex = 64;
            this.opacity.TickFrequency = 0;
            this.opacity.TickStyle = System.Windows.Forms.TickStyle.None;
            this.opacity.Value = 100;
            this.opacity.Scroll += new System.EventHandler(this.opacity_Scroll);
            // 
            // alwaysTop
            // 
            this.alwaysTop.Location = new System.Drawing.Point(270, 136);
            this.alwaysTop.Name = "alwaysTop";
            this.alwaysTop.Size = new System.Drawing.Size(162, 23);
            this.alwaysTop.TabIndex = 63;
            this.alwaysTop.Text = "Use Smart Always on Top";
            this.alwaysTop.CheckedChanged += new System.EventHandler(this.alwaysTop_CheckedChanged);
            // 
            // opacityLabel
            // 
            this.opacityLabel.Location = new System.Drawing.Point(11, 152);
            this.opacityLabel.Name = "opacityLabel";
            this.opacityLabel.Size = new System.Drawing.Size(58, 19);
            this.opacityLabel.TabIndex = 65;
            this.opacityLabel.Text = "Opacity: 100%";
            // 
            // groupBox4
            // 
            this.groupBox4.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.groupBox4.Controls.Add(this.saveProfile);
            this.groupBox4.Controls.Add(this.cloneProfile);
            this.groupBox4.Controls.Add(this.delProfile);
            this.groupBox4.Controls.Add(this.newProfile);
            this.groupBox4.Controls.Add(this.profiles);
            this.groupBox4.Location = new System.Drawing.Point(6, 6);
            this.groupBox4.Name = "groupBox4";
            this.groupBox4.Size = new System.Drawing.Size(490, 95);
            this.groupBox4.TabIndex = 5;
            this.groupBox4.TabStop = false;
            this.groupBox4.Text = "Profiles";
            // 
            // saveProfile
            // 
            this.saveProfile.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.saveProfile.AutoSize = true;
            this.saveProfile.Location = new System.Drawing.Point(320, 56);
            this.saveProfile.Name = "saveProfile";
            this.saveProfile.Size = new System.Drawing.Size(50, 30);
            this.saveProfile.TabIndex = 4;
            this.saveProfile.Text = "Save";
            this.saveProfile.Click += new System.EventHandler(this.saveProfile_Click);
            // 
            // cloneProfile
            // 
            this.cloneProfile.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.cloneProfile.AutoSize = true;
            this.cloneProfile.Location = new System.Drawing.Point(376, 56);
            this.cloneProfile.Name = "cloneProfile";
            this.cloneProfile.Size = new System.Drawing.Size(50, 30);
            this.cloneProfile.TabIndex = 3;
            this.cloneProfile.Text = "Clone";
            this.cloneProfile.Click += new System.EventHandler(this.cloneProfile_Click);
            // 
            // delProfile
            // 
            this.delProfile.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.delProfile.AutoSize = true;
            this.delProfile.Location = new System.Drawing.Point(432, 56);
            this.delProfile.Name = "delProfile";
            this.delProfile.Size = new System.Drawing.Size(50, 30);
            this.delProfile.TabIndex = 2;
            this.delProfile.Text = "Delete";
            this.delProfile.Click += new System.EventHandler(this.delProfile_Click);
            // 
            // newProfile
            // 
            this.newProfile.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.newProfile.AutoSize = true;
            this.newProfile.Location = new System.Drawing.Point(264, 56);
            this.newProfile.Name = "newProfile";
            this.newProfile.Size = new System.Drawing.Size(50, 30);
            this.newProfile.TabIndex = 1;
            this.newProfile.Text = "New";
            this.newProfile.Click += new System.EventHandler(this.newProfile_Click);
            // 
            // profiles
            // 
            this.profiles.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.profiles.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.profiles.Font = new System.Drawing.Font("Segoe UI", 11.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.profiles.ItemHeight = 20;
            this.profiles.Location = new System.Drawing.Point(6, 22);
            this.profiles.MaxDropDownItems = 5;
            this.profiles.Name = "profiles";
            this.profiles.Size = new System.Drawing.Size(476, 28);
            this.profiles.TabIndex = 0;
            this.profiles.SelectedIndexChanged += new System.EventHandler(this.profiles_SelectedIndexChanged);
            // 
            // moreOptTab
            // 
            this.moreOptTab.Controls.Add(this.optionsTabCtrl);
            this.moreOptTab.Location = new System.Drawing.Point(4, 24);
            this.moreOptTab.Name = "moreOptTab";
            this.moreOptTab.Size = new System.Drawing.Size(519, 342);
            this.moreOptTab.TabIndex = 5;
            this.moreOptTab.Text = "Options";
            // 
            // optionsTabCtrl
            // 
            this.optionsTabCtrl.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.optionsTabCtrl.Controls.Add(this.subOptionsSpeechTab);
            this.optionsTabCtrl.Controls.Add(this.subOptionsTargetTab);
            this.optionsTabCtrl.Controls.Add(this.subOptionsMiscTab);
            this.optionsTabCtrl.Location = new System.Drawing.Point(6, 3);
            this.optionsTabCtrl.Name = "optionsTabCtrl";
            this.optionsTabCtrl.SelectedIndex = 0;
            this.optionsTabCtrl.Size = new System.Drawing.Size(510, 334);
            this.optionsTabCtrl.TabIndex = 93;
            // 
            // subOptionsSpeechTab
            // 
            this.subOptionsSpeechTab.BackColor = System.Drawing.SystemColors.Control;
            this.subOptionsSpeechTab.Controls.Add(this.playEmoteSound);
            this.subOptionsSpeechTab.Controls.Add(this.overrideSpellFormat);
            this.subOptionsSpeechTab.Controls.Add(this.damageTakenOverhead);
            this.subOptionsSpeechTab.Controls.Add(this.showDamageTaken);
            this.subOptionsSpeechTab.Controls.Add(this.damageDealtOverhead);
            this.subOptionsSpeechTab.Controls.Add(this.showDamageDealt);
            this.subOptionsSpeechTab.Controls.Add(this.healthFmt);
            this.subOptionsSpeechTab.Controls.Add(this.label10);
            this.subOptionsSpeechTab.Controls.Add(this.showHealthOH);
            this.subOptionsSpeechTab.Controls.Add(this.chkPartyOverhead);
            this.subOptionsSpeechTab.Controls.Add(this.containerLabels);
            this.subOptionsSpeechTab.Controls.Add(this.showContainerLabels);
            this.subOptionsSpeechTab.Controls.Add(this.incomingMob);
            this.subOptionsSpeechTab.Controls.Add(this.incomingCorpse);
            this.subOptionsSpeechTab.Controls.Add(this.setLTHilight);
            this.subOptionsSpeechTab.Controls.Add(this.lthilight);
            this.subOptionsSpeechTab.Controls.Add(this.setHarmHue);
            this.subOptionsSpeechTab.Controls.Add(this.setNeuHue);
            this.subOptionsSpeechTab.Controls.Add(this.lblHarmHue);
            this.subOptionsSpeechTab.Controls.Add(this.lblNeuHue);
            this.subOptionsSpeechTab.Controls.Add(this.lblBeneHue);
            this.subOptionsSpeechTab.Controls.Add(this.setBeneHue);
            this.subOptionsSpeechTab.Controls.Add(this.setSpeechHue);
            this.subOptionsSpeechTab.Controls.Add(this.setWarnHue);
            this.subOptionsSpeechTab.Controls.Add(this.setMsgHue);
            this.subOptionsSpeechTab.Controls.Add(this.setExHue);
            this.subOptionsSpeechTab.Controls.Add(this.lblWarnHue);
            this.subOptionsSpeechTab.Controls.Add(this.lblMsgHue);
            this.subOptionsSpeechTab.Controls.Add(this.lblExHue);
            this.subOptionsSpeechTab.Controls.Add(this.txtSpellFormat);
            this.subOptionsSpeechTab.Controls.Add(this.chkForceSpellHue);
            this.subOptionsSpeechTab.Controls.Add(this.chkForceSpeechHue);
            this.subOptionsSpeechTab.Controls.Add(this.label3);
            this.subOptionsSpeechTab.Location = new System.Drawing.Point(4, 24);
            this.subOptionsSpeechTab.Name = "subOptionsSpeechTab";
            this.subOptionsSpeechTab.Padding = new System.Windows.Forms.Padding(3);
            this.subOptionsSpeechTab.Size = new System.Drawing.Size(502, 306);
            this.subOptionsSpeechTab.TabIndex = 0;
            this.subOptionsSpeechTab.Text = "Speech & Messages  ";
            // 
            // playEmoteSound
            // 
            this.playEmoteSound.AutoSize = true;
            this.playEmoteSound.Location = new System.Drawing.Point(260, 210);
            this.playEmoteSound.Name = "playEmoteSound";
            this.playEmoteSound.Size = new System.Drawing.Size(136, 19);
            this.playEmoteSound.TabIndex = 131;
            this.playEmoteSound.Text = "Play *emote* sounds";
            this.playEmoteSound.UseVisualStyleBackColor = true;
            this.playEmoteSound.CheckedChanged += new System.EventHandler(this.playEmoteSound_CheckedChanged);
            // 
            // overrideSpellFormat
            // 
            this.overrideSpellFormat.Location = new System.Drawing.Point(9, 205);
            this.overrideSpellFormat.Name = "overrideSpellFormat";
            this.overrideSpellFormat.Size = new System.Drawing.Size(152, 20);
            this.overrideSpellFormat.TabIndex = 130;
            this.overrideSpellFormat.Text = "Override spell format";
            this.overrideSpellFormat.CheckedChanged += new System.EventHandler(this.overrideSpellFormat_CheckedChanged);
            // 
            // damageTakenOverhead
            // 
            this.damageTakenOverhead.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Italic, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.damageTakenOverhead.Location = new System.Drawing.Point(394, 185);
            this.damageTakenOverhead.Name = "damageTakenOverhead";
            this.damageTakenOverhead.Size = new System.Drawing.Size(77, 19);
            this.damageTakenOverhead.TabIndex = 128;
            this.damageTakenOverhead.Text = "Overhead";
            this.damageTakenOverhead.UseVisualStyleBackColor = true;
            this.damageTakenOverhead.CheckedChanged += new System.EventHandler(this.damageTakenOverhead_CheckedChanged);
            // 
            // showDamageTaken
            // 
            this.showDamageTaken.Font = new System.Drawing.Font("Segoe UI", 9F);
            this.showDamageTaken.Location = new System.Drawing.Point(260, 185);
            this.showDamageTaken.Name = "showDamageTaken";
            this.showDamageTaken.Size = new System.Drawing.Size(139, 19);
            this.showDamageTaken.TabIndex = 127;
            this.showDamageTaken.Text = "Show damage taken";
            this.showDamageTaken.UseVisualStyleBackColor = true;
            this.showDamageTaken.CheckedChanged += new System.EventHandler(this.showDamageTaken_CheckedChanged);
            // 
            // damageDealtOverhead
            // 
            this.damageDealtOverhead.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Italic, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.damageDealtOverhead.Location = new System.Drawing.Point(394, 160);
            this.damageDealtOverhead.Name = "damageDealtOverhead";
            this.damageDealtOverhead.Size = new System.Drawing.Size(77, 19);
            this.damageDealtOverhead.TabIndex = 126;
            this.damageDealtOverhead.Text = "Overhead";
            this.damageDealtOverhead.UseVisualStyleBackColor = true;
            this.damageDealtOverhead.CheckedChanged += new System.EventHandler(this.damageDealtOverhead_CheckedChanged);
            // 
            // showDamageDealt
            // 
            this.showDamageDealt.AutoSize = true;
            this.showDamageDealt.Location = new System.Drawing.Point(260, 160);
            this.showDamageDealt.Name = "showDamageDealt";
            this.showDamageDealt.Size = new System.Drawing.Size(130, 19);
            this.showDamageDealt.TabIndex = 125;
            this.showDamageDealt.Text = "Show damage dealt";
            this.showDamageDealt.UseVisualStyleBackColor = true;
            this.showDamageDealt.CheckedChanged += new System.EventHandler(this.showDamageDealt_CheckedChanged);
            // 
            // healthFmt
            // 
            this.healthFmt.Location = new System.Drawing.Point(377, 110);
            this.healthFmt.Name = "healthFmt";
            this.healthFmt.Size = new System.Drawing.Size(53, 23);
            this.healthFmt.TabIndex = 89;
            this.healthFmt.Text = "[{0}%]";
            this.healthFmt.TextAlign = System.Windows.Forms.HorizontalAlignment.Center;
            this.healthFmt.TextChanged += new System.EventHandler(this.healthFmt_TextChanged);
            // 
            // label10
            // 
            this.label10.Location = new System.Drawing.Point(283, 111);
            this.label10.Name = "label10";
            this.label10.Size = new System.Drawing.Size(115, 18);
            this.label10.TabIndex = 88;
            this.label10.Text = "Health Format:";
            this.label10.TextAlign = System.Drawing.ContentAlignment.MiddleLeft;
            // 
            // showHealthOH
            // 
            this.showHealthOH.Location = new System.Drawing.Point(260, 88);
            this.showHealthOH.Name = "showHealthOH";
            this.showHealthOH.Size = new System.Drawing.Size(231, 20);
            this.showHealthOH.TabIndex = 87;
            this.showHealthOH.Text = "Show health above people/creatures";
            this.showHealthOH.CheckedChanged += new System.EventHandler(this.showHealthOH_CheckedChanged);
            // 
            // chkPartyOverhead
            // 
            this.chkPartyOverhead.Location = new System.Drawing.Point(260, 134);
            this.chkPartyOverhead.Name = "chkPartyOverhead";
            this.chkPartyOverhead.Size = new System.Drawing.Size(238, 20);
            this.chkPartyOverhead.TabIndex = 90;
            this.chkPartyOverhead.Text = "Show mana/stam above party members";
            this.chkPartyOverhead.CheckedChanged += new System.EventHandler(this.chkPartyOverhead_CheckedChanged);
            // 
            // containerLabels
            // 
            this.containerLabels.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.containerLabels.Location = new System.Drawing.Point(438, 63);
            this.containerLabels.Name = "containerLabels";
            this.containerLabels.Size = new System.Drawing.Size(33, 19);
            this.containerLabels.TabIndex = 86;
            this.containerLabels.Text = "...";
            this.containerLabels.UseVisualStyleBackColor = true;
            this.containerLabels.Click += new System.EventHandler(this.containerLabels_Click);
            // 
            // showContainerLabels
            // 
            this.showContainerLabels.AutoSize = true;
            this.showContainerLabels.Location = new System.Drawing.Point(260, 63);
            this.showContainerLabels.Name = "showContainerLabels";
            this.showContainerLabels.Size = new System.Drawing.Size(141, 19);
            this.showContainerLabels.TabIndex = 85;
            this.showContainerLabels.Text = "Show container labels";
            this.showContainerLabels.UseVisualStyleBackColor = true;
            this.showContainerLabels.CheckedChanged += new System.EventHandler(this.showContainerLabels_CheckedChanged);
            // 
            // incomingMob
            // 
            this.incomingMob.Location = new System.Drawing.Point(260, 10);
            this.incomingMob.Name = "incomingMob";
            this.incomingMob.Size = new System.Drawing.Size(211, 20);
            this.incomingMob.TabIndex = 71;
            this.incomingMob.Text = "Show Names of Incoming People/Creatures";
            this.incomingMob.CheckedChanged += new System.EventHandler(this.incomingMob_CheckedChanged);
            // 
            // incomingCorpse
            // 
            this.incomingCorpse.Location = new System.Drawing.Point(260, 36);
            this.incomingCorpse.Name = "incomingCorpse";
            this.incomingCorpse.Size = new System.Drawing.Size(238, 20);
            this.incomingCorpse.TabIndex = 72;
            this.incomingCorpse.Text = "Show Names of New/Incoming Corpses";
            this.incomingCorpse.CheckedChanged += new System.EventHandler(this.incomingCorpse_CheckedChanged);
            // 
            // setLTHilight
            // 
            this.setLTHilight.Location = new System.Drawing.Point(168, 116);
            this.setLTHilight.Name = "setLTHilight";
            this.setLTHilight.Size = new System.Drawing.Size(47, 20);
            this.setLTHilight.TabIndex = 70;
            this.setLTHilight.Text = "Set";
            this.setLTHilight.Click += new System.EventHandler(this.setLTHilight_Click);
            // 
            // lthilight
            // 
            this.lthilight.Location = new System.Drawing.Point(9, 116);
            this.lthilight.Name = "lthilight";
            this.lthilight.Size = new System.Drawing.Size(206, 19);
            this.lthilight.TabIndex = 69;
            this.lthilight.Text = "Last Target Highlight:";
            this.lthilight.CheckedChanged += new System.EventHandler(this.lthilight_CheckedChanged);
            // 
            // setHarmHue
            // 
            this.setHarmHue.Enabled = false;
            this.setHarmHue.Location = new System.Drawing.Point(99, 179);
            this.setHarmHue.Name = "setHarmHue";
            this.setHarmHue.Size = new System.Drawing.Size(32, 20);
            this.setHarmHue.TabIndex = 64;
            this.setHarmHue.Text = "Set";
            this.setHarmHue.Click += new System.EventHandler(this.setHarmHue_Click);
            // 
            // setNeuHue
            // 
            this.setNeuHue.Enabled = false;
            this.setNeuHue.Location = new System.Drawing.Point(172, 179);
            this.setNeuHue.Name = "setNeuHue";
            this.setNeuHue.Size = new System.Drawing.Size(32, 20);
            this.setNeuHue.TabIndex = 65;
            this.setNeuHue.Text = "Set";
            this.setNeuHue.Click += new System.EventHandler(this.setNeuHue_Click);
            // 
            // lblHarmHue
            // 
            this.lblHarmHue.Location = new System.Drawing.Point(86, 165);
            this.lblHarmHue.Name = "lblHarmHue";
            this.lblHarmHue.Size = new System.Drawing.Size(59, 14);
            this.lblHarmHue.TabIndex = 68;
            this.lblHarmHue.Text = "Harmful";
            this.lblHarmHue.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
            // 
            // lblNeuHue
            // 
            this.lblNeuHue.Location = new System.Drawing.Point(163, 165);
            this.lblNeuHue.Name = "lblNeuHue";
            this.lblNeuHue.Size = new System.Drawing.Size(52, 14);
            this.lblNeuHue.TabIndex = 67;
            this.lblNeuHue.Text = "Neutral";
            this.lblNeuHue.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
            // 
            // lblBeneHue
            // 
            this.lblBeneHue.Location = new System.Drawing.Point(9, 165);
            this.lblBeneHue.Name = "lblBeneHue";
            this.lblBeneHue.Size = new System.Drawing.Size(66, 14);
            this.lblBeneHue.TabIndex = 66;
            this.lblBeneHue.Text = "Beneficial";
            this.lblBeneHue.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
            // 
            // setBeneHue
            // 
            this.setBeneHue.Enabled = false;
            this.setBeneHue.Location = new System.Drawing.Point(27, 179);
            this.setBeneHue.Name = "setBeneHue";
            this.setBeneHue.Size = new System.Drawing.Size(32, 20);
            this.setBeneHue.TabIndex = 63;
            this.setBeneHue.Text = "Set";
            this.setBeneHue.Click += new System.EventHandler(this.setBeneHue_Click);
            // 
            // setSpeechHue
            // 
            this.setSpeechHue.Location = new System.Drawing.Point(168, 90);
            this.setSpeechHue.Name = "setSpeechHue";
            this.setSpeechHue.Size = new System.Drawing.Size(47, 20);
            this.setSpeechHue.TabIndex = 62;
            this.setSpeechHue.Text = "Set";
            this.setSpeechHue.Click += new System.EventHandler(this.setSpeechHue_Click);
            // 
            // setWarnHue
            // 
            this.setWarnHue.Location = new System.Drawing.Point(168, 64);
            this.setWarnHue.Name = "setWarnHue";
            this.setWarnHue.Size = new System.Drawing.Size(47, 20);
            this.setWarnHue.TabIndex = 61;
            this.setWarnHue.Text = "Set";
            this.setWarnHue.Click += new System.EventHandler(this.setWarnHue_Click);
            // 
            // setMsgHue
            // 
            this.setMsgHue.Location = new System.Drawing.Point(168, 38);
            this.setMsgHue.Name = "setMsgHue";
            this.setMsgHue.Size = new System.Drawing.Size(47, 20);
            this.setMsgHue.TabIndex = 60;
            this.setMsgHue.Text = "Set";
            this.setMsgHue.Click += new System.EventHandler(this.setMsgHue_Click);
            // 
            // setExHue
            // 
            this.setExHue.Location = new System.Drawing.Point(168, 12);
            this.setExHue.Name = "setExHue";
            this.setExHue.Size = new System.Drawing.Size(47, 20);
            this.setExHue.TabIndex = 59;
            this.setExHue.Text = "Set";
            this.setExHue.Click += new System.EventHandler(this.setExHue_Click);
            // 
            // lblWarnHue
            // 
            this.lblWarnHue.Location = new System.Drawing.Point(9, 64);
            this.lblWarnHue.Name = "lblWarnHue";
            this.lblWarnHue.Size = new System.Drawing.Size(206, 18);
            this.lblWarnHue.TabIndex = 58;
            this.lblWarnHue.Text = "Warning Message Hue:";
            // 
            // lblMsgHue
            // 
            this.lblMsgHue.Location = new System.Drawing.Point(9, 38);
            this.lblMsgHue.Name = "lblMsgHue";
            this.lblMsgHue.Size = new System.Drawing.Size(206, 18);
            this.lblMsgHue.TabIndex = 57;
            this.lblMsgHue.Text = "Razor Message Hue:";
            // 
            // lblExHue
            // 
            this.lblExHue.Location = new System.Drawing.Point(9, 12);
            this.lblExHue.Name = "lblExHue";
            this.lblExHue.Size = new System.Drawing.Size(206, 18);
            this.lblExHue.TabIndex = 56;
            this.lblExHue.Text = "Search Exemption Hue:";
            // 
            // txtSpellFormat
            // 
            this.txtSpellFormat.Location = new System.Drawing.Point(89, 228);
            this.txtSpellFormat.Name = "txtSpellFormat";
            this.txtSpellFormat.Size = new System.Drawing.Size(126, 23);
            this.txtSpellFormat.TabIndex = 55;
            this.txtSpellFormat.TextChanged += new System.EventHandler(this.txtSpellFormat_TextChanged);
            // 
            // chkForceSpellHue
            // 
            this.chkForceSpellHue.Location = new System.Drawing.Point(9, 142);
            this.chkForceSpellHue.Name = "chkForceSpellHue";
            this.chkForceSpellHue.Size = new System.Drawing.Size(152, 20);
            this.chkForceSpellHue.TabIndex = 53;
            this.chkForceSpellHue.Text = "Override Spell Hues:";
            this.chkForceSpellHue.CheckedChanged += new System.EventHandler(this.chkForceSpellHue_CheckedChanged);
            // 
            // chkForceSpeechHue
            // 
            this.chkForceSpeechHue.Location = new System.Drawing.Point(9, 90);
            this.chkForceSpeechHue.Name = "chkForceSpeechHue";
            this.chkForceSpeechHue.Size = new System.Drawing.Size(206, 19);
            this.chkForceSpeechHue.TabIndex = 52;
            this.chkForceSpeechHue.Text = "Override Speech Hue:";
            this.chkForceSpeechHue.CheckedChanged += new System.EventHandler(this.chkForceSpeechHue_CheckedChanged);
            // 
            // label3
            // 
            this.label3.Location = new System.Drawing.Point(11, 228);
            this.label3.Name = "label3";
            this.label3.Size = new System.Drawing.Size(87, 20);
            this.label3.TabIndex = 54;
            this.label3.Text = "Spell Format:";
            this.label3.TextAlign = System.Drawing.ContentAlignment.MiddleLeft;
            // 
            // subOptionsTargetTab
            // 
            this.subOptionsTargetTab.BackColor = System.Drawing.SystemColors.Control;
            this.subOptionsTargetTab.Controls.Add(this.groupSmartTarget);
            this.subOptionsTargetTab.Controls.Add(this.setTargetIndicatorHue);
            this.subOptionsTargetTab.Controls.Add(this.targetIndicatorFormat);
            this.subOptionsTargetTab.Controls.Add(this.showtargtext);
            this.subOptionsTargetTab.Controls.Add(this.showAttackTargetNewOnly);
            this.subOptionsTargetTab.Controls.Add(this.showTextTargetIndicator);
            this.subOptionsTargetTab.Controls.Add(this.showAttackTarget);
            this.subOptionsTargetTab.Controls.Add(this.showTargetMessagesOverChar);
            this.subOptionsTargetTab.Controls.Add(this.txtObjDelay);
            this.subOptionsTargetTab.Controls.Add(this.objectDelay);
            this.subOptionsTargetTab.Controls.Add(this.ltRange);
            this.subOptionsTargetTab.Controls.Add(this.QueueActions);
            this.subOptionsTargetTab.Controls.Add(this.rangeCheckLT);
            this.subOptionsTargetTab.Controls.Add(this.actionStatusMsg);
            this.subOptionsTargetTab.Controls.Add(this.label8);
            this.subOptionsTargetTab.Controls.Add(this.label6);
            this.subOptionsTargetTab.Controls.Add(this.queueTargets);
            this.subOptionsTargetTab.Controls.Add(this.lblTargetFormat);
            this.subOptionsTargetTab.Location = new System.Drawing.Point(4, 22);
            this.subOptionsTargetTab.Name = "subOptionsTargetTab";
            this.subOptionsTargetTab.Padding = new System.Windows.Forms.Padding(3);
            this.subOptionsTargetTab.Size = new System.Drawing.Size(502, 308);
            this.subOptionsTargetTab.TabIndex = 1;
            this.subOptionsTargetTab.Text = "Targeting & Queues  ";
            // 
            // groupSmartTarget
            // 
            this.groupSmartTarget.Controls.Add(this.nextPrevAbcOrder);
            this.groupSmartTarget.Controls.Add(this.nonFriendlyHarmfulOnly);
            this.groupSmartTarget.Controls.Add(this.friendBeneficialOnly);
            this.groupSmartTarget.Controls.Add(this.onlyNextPrevBeneficial);
            this.groupSmartTarget.Controls.Add(this.smartLT);
            this.groupSmartTarget.Location = new System.Drawing.Point(243, 11);
            this.groupSmartTarget.Name = "groupSmartTarget";
            this.groupSmartTarget.Size = new System.Drawing.Size(253, 153);
            this.groupSmartTarget.TabIndex = 138;
            this.groupSmartTarget.TabStop = false;
            this.groupSmartTarget.Text = "Smart Targeting:";
            // 
            // nextPrevAbcOrder
            // 
            this.nextPrevAbcOrder.Location = new System.Drawing.Point(6, 123);
            this.nextPrevAbcOrder.Name = "nextPrevAbcOrder";
            this.nextPrevAbcOrder.Size = new System.Drawing.Size(232, 19);
            this.nextPrevAbcOrder.TabIndex = 142;
            this.nextPrevAbcOrder.Text = "\'Next/Prev\' by alphabetical order";
            this.nextPrevAbcOrder.UseVisualStyleBackColor = true;
            this.nextPrevAbcOrder.CheckedChanged += new System.EventHandler(this.nextPrevAbcOrder_CheckedChanged);
            // 
            // nonFriendlyHarmfulOnly
            // 
            this.nonFriendlyHarmfulOnly.Location = new System.Drawing.Point(6, 98);
            this.nonFriendlyHarmfulOnly.Name = "nonFriendlyHarmfulOnly";
            this.nonFriendlyHarmfulOnly.Size = new System.Drawing.Size(232, 19);
            this.nonFriendlyHarmfulOnly.TabIndex = 141;
            this.nonFriendlyHarmfulOnly.Text = "\'Next/Prev Non-Friendly\' harmful only";
            this.nonFriendlyHarmfulOnly.UseVisualStyleBackColor = true;
            this.nonFriendlyHarmfulOnly.CheckedChanged += new System.EventHandler(this.nonFriendlyHarmfulOnly_CheckedChanged);
            // 
            // friendBeneficialOnly
            // 
            this.friendBeneficialOnly.AutoSize = true;
            this.friendBeneficialOnly.Location = new System.Drawing.Point(6, 73);
            this.friendBeneficialOnly.Name = "friendBeneficialOnly";
            this.friendBeneficialOnly.Size = new System.Drawing.Size(233, 19);
            this.friendBeneficialOnly.TabIndex = 140;
            this.friendBeneficialOnly.Text = "\'Next/Prev Friendly\' sets beneficial only";
            this.friendBeneficialOnly.UseVisualStyleBackColor = true;
            this.friendBeneficialOnly.CheckedChanged += new System.EventHandler(this.friendBeneficialOnly_CheckedChanged);
            // 
            // onlyNextPrevBeneficial
            // 
            this.onlyNextPrevBeneficial.AutoSize = true;
            this.onlyNextPrevBeneficial.Location = new System.Drawing.Point(6, 48);
            this.onlyNextPrevBeneficial.Name = "onlyNextPrevBeneficial";
            this.onlyNextPrevBeneficial.Size = new System.Drawing.Size(224, 19);
            this.onlyNextPrevBeneficial.TabIndex = 139;
            this.onlyNextPrevBeneficial.Text = "\'Next/Prev Friend\' sets beneficial only";
            this.onlyNextPrevBeneficial.UseVisualStyleBackColor = true;
            this.onlyNextPrevBeneficial.CheckedChanged += new System.EventHandler(this.onlyNextPrevBeneficial_CheckedChanged);
            // 
            // smartLT
            // 
            this.smartLT.Location = new System.Drawing.Point(6, 22);
            this.smartLT.Name = "smartLT";
            this.smartLT.Size = new System.Drawing.Size(212, 20);
            this.smartLT.TabIndex = 138;
            this.smartLT.Text = "Use Smart Last Target";
            this.smartLT.CheckedChanged += new System.EventHandler(this.smartLT_CheckedChanged);
            // 
            // setTargetIndicatorHue
            // 
            this.setTargetIndicatorHue.Location = new System.Drawing.Point(177, 246);
            this.setTargetIndicatorHue.Name = "setTargetIndicatorHue";
            this.setTargetIndicatorHue.Size = new System.Drawing.Size(59, 23);
            this.setTargetIndicatorHue.TabIndex = 134;
            this.setTargetIndicatorHue.Text = "Set Hue";
            this.setTargetIndicatorHue.UseVisualStyleBackColor = true;
            this.setTargetIndicatorHue.Click += new System.EventHandler(this.setTargetIndicatorHue_Click);
            // 
            // targetIndicatorFormat
            // 
            this.targetIndicatorFormat.Location = new System.Drawing.Point(64, 246);
            this.targetIndicatorFormat.Name = "targetIndicatorFormat";
            this.targetIndicatorFormat.Size = new System.Drawing.Size(107, 23);
            this.targetIndicatorFormat.TabIndex = 93;
            this.targetIndicatorFormat.TextAlign = System.Windows.Forms.HorizontalAlignment.Center;
            this.targetIndicatorFormat.TextChanged += new System.EventHandler(this.targetIndicatorFormat_TextChanged);
            // 
            // showtargtext
            // 
            this.showtargtext.Location = new System.Drawing.Point(9, 170);
            this.showtargtext.Name = "showtargtext";
            this.showtargtext.Size = new System.Drawing.Size(212, 20);
            this.showtargtext.TabIndex = 91;
            this.showtargtext.Text = "Show target flag on single click";
            this.showtargtext.CheckedChanged += new System.EventHandler(this.showtargtext_CheckedChanged);
            // 
            // showAttackTargetNewOnly
            // 
            this.showAttackTargetNewOnly.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Italic, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.showAttackTargetNewOnly.Location = new System.Drawing.Point(195, 196);
            this.showAttackTargetNewOnly.Name = "showAttackTargetNewOnly";
            this.showAttackTargetNewOnly.Size = new System.Drawing.Size(121, 44);
            this.showAttackTargetNewOnly.TabIndex = 90;
            this.showAttackTargetNewOnly.Text = "New targets only";
            this.showAttackTargetNewOnly.UseVisualStyleBackColor = true;
            this.showAttackTargetNewOnly.CheckedChanged += new System.EventHandler(this.showAttackTargetNewOnly_CheckedChanged);
            // 
            // showTextTargetIndicator
            // 
            this.showTextTargetIndicator.Location = new System.Drawing.Point(9, 221);
            this.showTextTargetIndicator.Name = "showTextTargetIndicator";
            this.showTextTargetIndicator.Size = new System.Drawing.Size(232, 19);
            this.showTextTargetIndicator.TabIndex = 89;
            this.showTextTargetIndicator.Text = "Show text target indicator";
            this.showTextTargetIndicator.UseVisualStyleBackColor = true;
            this.showTextTargetIndicator.CheckedChanged += new System.EventHandler(this.showTextTargetIndicator_CheckedChanged);
            // 
            // showAttackTarget
            // 
            this.showAttackTarget.Location = new System.Drawing.Point(9, 196);
            this.showAttackTarget.Name = "showAttackTarget";
            this.showAttackTarget.Size = new System.Drawing.Size(232, 19);
            this.showAttackTarget.TabIndex = 88;
            this.showAttackTarget.Text = "Attack/target name overhead";
            this.showAttackTarget.UseVisualStyleBackColor = true;
            this.showAttackTarget.CheckedChanged += new System.EventHandler(this.showAttackTarget_CheckedChanged);
            // 
            // showTargetMessagesOverChar
            // 
            this.showTargetMessagesOverChar.AutoSize = true;
            this.showTargetMessagesOverChar.Location = new System.Drawing.Point(9, 118);
            this.showTargetMessagesOverChar.Name = "showTargetMessagesOverChar";
            this.showTargetMessagesOverChar.Size = new System.Drawing.Size(224, 19);
            this.showTargetMessagesOverChar.TabIndex = 74;
            this.showTargetMessagesOverChar.Text = "Show Target Self/Last/Clear Overhead";
            this.showTargetMessagesOverChar.UseVisualStyleBackColor = true;
            this.showTargetMessagesOverChar.CheckedChanged += new System.EventHandler(this.showTargetMessagesOverChar_CheckedChanged);
            // 
            // txtObjDelay
            // 
            this.txtObjDelay.Location = new System.Drawing.Point(109, 89);
            this.txtObjDelay.Name = "txtObjDelay";
            this.txtObjDelay.Size = new System.Drawing.Size(32, 23);
            this.txtObjDelay.TabIndex = 56;
            this.txtObjDelay.TextAlign = System.Windows.Forms.HorizontalAlignment.Center;
            this.txtObjDelay.TextChanged += new System.EventHandler(this.txtObjDelay_TextChanged);
            // 
            // objectDelay
            // 
            this.objectDelay.Location = new System.Drawing.Point(9, 88);
            this.objectDelay.Name = "objectDelay";
            this.objectDelay.Size = new System.Drawing.Size(104, 24);
            this.objectDelay.TabIndex = 53;
            this.objectDelay.Text = "Object Delay:";
            this.objectDelay.CheckedChanged += new System.EventHandler(this.objectDelay_CheckedChanged);
            // 
            // ltRange
            // 
            this.ltRange.Location = new System.Drawing.Point(165, 141);
            this.ltRange.Name = "ltRange";
            this.ltRange.Size = new System.Drawing.Size(30, 23);
            this.ltRange.TabIndex = 59;
            this.ltRange.TextChanged += new System.EventHandler(this.ltRange_TextChanged);
            // 
            // QueueActions
            // 
            this.QueueActions.Location = new System.Drawing.Point(9, 64);
            this.QueueActions.Name = "QueueActions";
            this.QueueActions.Size = new System.Drawing.Size(202, 20);
            this.QueueActions.TabIndex = 54;
            this.QueueActions.Text = "Auto-Queue Object Delay actions ";
            this.QueueActions.CheckedChanged += new System.EventHandler(this.QueueActions_CheckedChanged);
            // 
            // rangeCheckLT
            // 
            this.rangeCheckLT.Location = new System.Drawing.Point(9, 142);
            this.rangeCheckLT.Name = "rangeCheckLT";
            this.rangeCheckLT.Size = new System.Drawing.Size(162, 20);
            this.rangeCheckLT.TabIndex = 58;
            this.rangeCheckLT.Text = "Range check Last Target:";
            this.rangeCheckLT.CheckedChanged += new System.EventHandler(this.rangeCheckLT_CheckedChanged);
            // 
            // actionStatusMsg
            // 
            this.actionStatusMsg.Location = new System.Drawing.Point(9, 38);
            this.actionStatusMsg.Name = "actionStatusMsg";
            this.actionStatusMsg.Size = new System.Drawing.Size(212, 20);
            this.actionStatusMsg.TabIndex = 57;
            this.actionStatusMsg.Text = "Show Action-Queue status messages";
            this.actionStatusMsg.CheckedChanged += new System.EventHandler(this.actionStatusMsg_CheckedChanged);
            // 
            // label8
            // 
            this.label8.Location = new System.Drawing.Point(201, 144);
            this.label8.Name = "label8";
            this.label8.Size = new System.Drawing.Size(30, 18);
            this.label8.TabIndex = 60;
            this.label8.Text = "tiles";
            // 
            // label6
            // 
            this.label6.Location = new System.Drawing.Point(147, 93);
            this.label6.Name = "label6";
            this.label6.Size = new System.Drawing.Size(32, 18);
            this.label6.TabIndex = 55;
            this.label6.Text = "ms";
            // 
            // queueTargets
            // 
            this.queueTargets.Location = new System.Drawing.Point(9, 12);
            this.queueTargets.Name = "queueTargets";
            this.queueTargets.Size = new System.Drawing.Size(228, 20);
            this.queueTargets.TabIndex = 35;
            this.queueTargets.Text = "Queue LastTarget and TargetSelf";
            this.queueTargets.CheckedChanged += new System.EventHandler(this.queueTargets_CheckedChanged);
            // 
            // lblTargetFormat
            // 
            this.lblTargetFormat.Location = new System.Drawing.Point(10, 246);
            this.lblTargetFormat.Name = "lblTargetFormat";
            this.lblTargetFormat.Size = new System.Drawing.Size(140, 23);
            this.lblTargetFormat.TabIndex = 94;
            this.lblTargetFormat.Text = "Format:";
            this.lblTargetFormat.TextAlign = System.Drawing.ContentAlignment.MiddleLeft;
            // 
            // subOptionsMiscTab
            // 
            this.subOptionsMiscTab.BackColor = System.Drawing.SystemColors.Control;
            this.subOptionsMiscTab.Controls.Add(this.buyAgentIgnoreGold);
            this.subOptionsMiscTab.Controls.Add(this.reequipHandsPotion);
            this.subOptionsMiscTab.Controls.Add(this.autoOpenDoorWhenHidden);
            this.subOptionsMiscTab.Controls.Add(this.lblStealthFormat);
            this.subOptionsMiscTab.Controls.Add(this.stealthStepsFormat);
            this.subOptionsMiscTab.Controls.Add(this.rememberPwds);
            this.subOptionsMiscTab.Controls.Add(this.showStaticWalls);
            this.subOptionsMiscTab.Controls.Add(this.showStaticWallLabels);
            this.subOptionsMiscTab.Controls.Add(this.stealthOverhead);
            this.subOptionsMiscTab.Controls.Add(this.forceSizeX);
            this.subOptionsMiscTab.Controls.Add(this.forceSizeY);
            this.subOptionsMiscTab.Controls.Add(this.blockHealPoison);
            this.subOptionsMiscTab.Controls.Add(this.potionEquip);
            this.subOptionsMiscTab.Controls.Add(this.spellUnequip);
            this.subOptionsMiscTab.Controls.Add(this.autoOpenDoors);
            this.subOptionsMiscTab.Controls.Add(this.chkStealth);
            this.subOptionsMiscTab.Controls.Add(this.label18);
            this.subOptionsMiscTab.Controls.Add(this.gameSize);
            this.subOptionsMiscTab.Controls.Add(this.setMinLightLevel);
            this.subOptionsMiscTab.Controls.Add(this.setMaxLightLevel);
            this.subOptionsMiscTab.Controls.Add(this.seasonList);
            this.subOptionsMiscTab.Controls.Add(this.lblSeason);
            this.subOptionsMiscTab.Controls.Add(this.lightLevel);
            this.subOptionsMiscTab.Controls.Add(this.lightLevelBar);
            this.subOptionsMiscTab.Controls.Add(this.minMaxLightLevel);
            this.subOptionsMiscTab.Controls.Add(this.blockPartyInvites);
            this.subOptionsMiscTab.Controls.Add(this.blockTradeRequests);
            this.subOptionsMiscTab.Controls.Add(this.blockOpenCorpsesTwice);
            this.subOptionsMiscTab.Controls.Add(this.preAOSstatbar);
            this.subOptionsMiscTab.Controls.Add(this.corpseRange);
            this.subOptionsMiscTab.Controls.Add(this.autoStackRes);
            this.subOptionsMiscTab.Controls.Add(this.label4);
            this.subOptionsMiscTab.Controls.Add(this.openCorpses);
            this.subOptionsMiscTab.Controls.Add(this.blockDis);
            this.subOptionsMiscTab.Location = new System.Drawing.Point(4, 22);
            this.subOptionsMiscTab.Name = "subOptionsMiscTab";
            this.subOptionsMiscTab.Size = new System.Drawing.Size(502, 308);
            this.subOptionsMiscTab.TabIndex = 2;
            this.subOptionsMiscTab.Text = "Additional Options  ";
            // 
            // buyAgentIgnoreGold
            // 
            this.buyAgentIgnoreGold.AutoSize = true;
            this.buyAgentIgnoreGold.Location = new System.Drawing.Point(260, 244);
            this.buyAgentIgnoreGold.Name = "buyAgentIgnoreGold";
            this.buyAgentIgnoreGold.Size = new System.Drawing.Size(185, 19);
            this.buyAgentIgnoreGold.TabIndex = 126;
            this.buyAgentIgnoreGold.Text = "Buy Agents ignore player gold";
            this.buyAgentIgnoreGold.UseVisualStyleBackColor = true;
            this.buyAgentIgnoreGold.CheckedChanged += new System.EventHandler(this.buyAgentIgnoreGold_CheckedChanged);
            // 
            // reequipHandsPotion
            // 
            this.reequipHandsPotion.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Italic, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.reequipHandsPotion.Location = new System.Drawing.Point(423, 140);
            this.reequipHandsPotion.Name = "reequipHandsPotion";
            this.reequipHandsPotion.Size = new System.Drawing.Size(69, 20);
            this.reequipHandsPotion.TabIndex = 125;
            this.reequipHandsPotion.Text = "Re-equip";
            this.reequipHandsPotion.CheckedChanged += new System.EventHandler(this.reequipHandsPotion_CheckedChanged);
            // 
            // autoOpenDoorWhenHidden
            // 
            this.autoOpenDoorWhenHidden.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Italic, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.autoOpenDoorWhenHidden.Location = new System.Drawing.Point(393, 88);
            this.autoOpenDoorWhenHidden.Name = "autoOpenDoorWhenHidden";
            this.autoOpenDoorWhenHidden.Size = new System.Drawing.Size(95, 20);
            this.autoOpenDoorWhenHidden.TabIndex = 124;
            this.autoOpenDoorWhenHidden.Text = "When hidden";
            this.autoOpenDoorWhenHidden.CheckedChanged += new System.EventHandler(this.autoDoorWhenHidden_CheckedChanged);
            // 
            // lblStealthFormat
            // 
            this.lblStealthFormat.AutoSize = true;
            this.lblStealthFormat.Location = new System.Drawing.Point(280, 62);
            this.lblStealthFormat.Name = "lblStealthFormat";
            this.lblStealthFormat.Size = new System.Drawing.Size(48, 15);
            this.lblStealthFormat.TabIndex = 123;
            this.lblStealthFormat.Text = "Format:";
            // 
            // stealthStepsFormat
            // 
            this.stealthStepsFormat.Location = new System.Drawing.Point(334, 59);
            this.stealthStepsFormat.Name = "stealthStepsFormat";
            this.stealthStepsFormat.Size = new System.Drawing.Size(114, 23);
            this.stealthStepsFormat.TabIndex = 122;
            this.stealthStepsFormat.TextAlign = System.Windows.Forms.HorizontalAlignment.Center;
            this.stealthStepsFormat.TextChanged += new System.EventHandler(this.stealthStepsFormat_TextChanged);
            // 
            // rememberPwds
            // 
            this.rememberPwds.Location = new System.Drawing.Point(260, 12);
            this.rememberPwds.Name = "rememberPwds";
            this.rememberPwds.Size = new System.Drawing.Size(148, 20);
            this.rememberPwds.TabIndex = 121;
            this.rememberPwds.Text = "Remember passwords ";
            this.rememberPwds.CheckedChanged += new System.EventHandler(this.rememberPwds_CheckedChanged);
            // 
            // showStaticWalls
            // 
            this.showStaticWalls.AutoSize = true;
            this.showStaticWalls.Location = new System.Drawing.Point(260, 219);
            this.showStaticWalls.Name = "showStaticWalls";
            this.showStaticWalls.Size = new System.Drawing.Size(153, 19);
            this.showStaticWalls.TabIndex = 119;
            this.showStaticWalls.Text = "Static magic fields/walls";
            this.showStaticWalls.UseVisualStyleBackColor = true;
            this.showStaticWalls.CheckedChanged += new System.EventHandler(this.showStaticWalls_CheckedChanged);
            // 
            // showStaticWallLabels
            // 
            this.showStaticWallLabels.AutoSize = true;
            this.showStaticWallLabels.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Italic, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.showStaticWallLabels.Location = new System.Drawing.Point(421, 220);
            this.showStaticWallLabels.Name = "showStaticWallLabels";
            this.showStaticWallLabels.Size = new System.Drawing.Size(55, 17);
            this.showStaticWallLabels.TabIndex = 120;
            this.showStaticWallLabels.Text = "Labels";
            this.showStaticWallLabels.UseVisualStyleBackColor = true;
            this.showStaticWallLabels.CheckedChanged += new System.EventHandler(this.showStaticWallLabels_CheckedChanged);
            // 
            // stealthOverhead
            // 
            this.stealthOverhead.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Italic, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.stealthOverhead.Location = new System.Drawing.Point(393, 37);
            this.stealthOverhead.Name = "stealthOverhead";
            this.stealthOverhead.Size = new System.Drawing.Size(99, 20);
            this.stealthOverhead.TabIndex = 117;
            this.stealthOverhead.Text = "Overhead";
            this.stealthOverhead.UseVisualStyleBackColor = true;
            this.stealthOverhead.CheckedChanged += new System.EventHandler(this.stealthOverhead_CheckedChanged);
            // 
            // forceSizeX
            // 
            this.forceSizeX.Location = new System.Drawing.Point(387, 190);
            this.forceSizeX.Name = "forceSizeX";
            this.forceSizeX.Size = new System.Drawing.Size(34, 23);
            this.forceSizeX.TabIndex = 111;
            this.forceSizeX.TextChanged += new System.EventHandler(this.forceSizeX_TextChanged);
            // 
            // forceSizeY
            // 
            this.forceSizeY.Location = new System.Drawing.Point(443, 191);
            this.forceSizeY.Name = "forceSizeY";
            this.forceSizeY.Size = new System.Drawing.Size(33, 23);
            this.forceSizeY.TabIndex = 112;
            this.forceSizeY.TextChanged += new System.EventHandler(this.forceSizeY_TextChanged);
            // 
            // blockHealPoison
            // 
            this.blockHealPoison.Location = new System.Drawing.Point(260, 166);
            this.blockHealPoison.Name = "blockHealPoison";
            this.blockHealPoison.Size = new System.Drawing.Size(201, 20);
            this.blockHealPoison.TabIndex = 116;
            this.blockHealPoison.Text = "Block heal if target is poisoned";
            this.blockHealPoison.CheckedChanged += new System.EventHandler(this.blockHealPoison_CheckedChanged);
            // 
            // potionEquip
            // 
            this.potionEquip.Location = new System.Drawing.Point(260, 140);
            this.potionEquip.Name = "potionEquip";
            this.potionEquip.Size = new System.Drawing.Size(232, 20);
            this.potionEquip.TabIndex = 115;
            this.potionEquip.Text = "Auto Unequip for potions";
            this.potionEquip.CheckedChanged += new System.EventHandler(this.potionEquip_CheckedChanged);
            // 
            // spellUnequip
            // 
            this.spellUnequip.Location = new System.Drawing.Point(260, 114);
            this.spellUnequip.Name = "spellUnequip";
            this.spellUnequip.Size = new System.Drawing.Size(213, 20);
            this.spellUnequip.TabIndex = 108;
            this.spellUnequip.Text = "Auto Unequip hands before casting";
            this.spellUnequip.CheckedChanged += new System.EventHandler(this.spellUnequip_CheckedChanged);
            // 
            // autoOpenDoors
            // 
            this.autoOpenDoors.Location = new System.Drawing.Point(260, 88);
            this.autoOpenDoors.Name = "autoOpenDoors";
            this.autoOpenDoors.Size = new System.Drawing.Size(118, 20);
            this.autoOpenDoors.TabIndex = 110;
            this.autoOpenDoors.Text = "Auto-open doors";
            this.autoOpenDoors.CheckedChanged += new System.EventHandler(this.autoOpenDoors_CheckedChanged);
            // 
            // chkStealth
            // 
            this.chkStealth.Location = new System.Drawing.Point(260, 37);
            this.chkStealth.Name = "chkStealth";
            this.chkStealth.Size = new System.Drawing.Size(190, 20);
            this.chkStealth.TabIndex = 107;
            this.chkStealth.Text = "Count stealth steps";
            this.chkStealth.CheckedChanged += new System.EventHandler(this.chkStealth_CheckedChanged);
            // 
            // label18
            // 
            this.label18.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.label18.Location = new System.Drawing.Point(427, 193);
            this.label18.Name = "label18";
            this.label18.Size = new System.Drawing.Size(10, 18);
            this.label18.TabIndex = 114;
            this.label18.Text = "x";
            this.label18.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
            // 
            // gameSize
            // 
            this.gameSize.Location = new System.Drawing.Point(260, 192);
            this.gameSize.Name = "gameSize";
            this.gameSize.Size = new System.Drawing.Size(118, 18);
            this.gameSize.TabIndex = 113;
            this.gameSize.Text = "Force Game Size:";
            this.gameSize.CheckedChanged += new System.EventHandler(this.gameSize_CheckedChanged);
            // 
            // setMinLightLevel
            // 
            this.setMinLightLevel.Location = new System.Drawing.Point(117, 247);
            this.setMinLightLevel.Name = "setMinLightLevel";
            this.setMinLightLevel.Size = new System.Drawing.Size(58, 25);
            this.setMinLightLevel.TabIndex = 105;
            this.setMinLightLevel.Text = "Set Min";
            this.setMinLightLevel.Click += new System.EventHandler(this.setMinLightLevel_Click);
            // 
            // setMaxLightLevel
            // 
            this.setMaxLightLevel.Location = new System.Drawing.Point(181, 247);
            this.setMaxLightLevel.Name = "setMaxLightLevel";
            this.setMaxLightLevel.Size = new System.Drawing.Size(58, 25);
            this.setMaxLightLevel.TabIndex = 104;
            this.setMaxLightLevel.Text = "Set Max";
            this.setMaxLightLevel.Click += new System.EventHandler(this.setMaxLightLevel_Click);
            // 
            // seasonList
            // 
            this.seasonList.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.seasonList.FormattingEnabled = true;
            this.seasonList.Items.AddRange(new object[] {
            "Spring",
            "Summer",
            "Fall",
            "Winter",
            "Desolation",
            "(Server Default)"});
            this.seasonList.Location = new System.Drawing.Point(59, 195);
            this.seasonList.Name = "seasonList";
            this.seasonList.Size = new System.Drawing.Size(111, 23);
            this.seasonList.TabIndex = 102;
            this.seasonList.SelectedIndexChanged += new System.EventHandler(this.seasonList_SelectedIndexChanged);
            // 
            // lblSeason
            // 
            this.lblSeason.AutoSize = true;
            this.lblSeason.Location = new System.Drawing.Point(6, 198);
            this.lblSeason.Name = "lblSeason";
            this.lblSeason.Size = new System.Drawing.Size(47, 15);
            this.lblSeason.TabIndex = 101;
            this.lblSeason.Text = "Season:";
            // 
            // lightLevel
            // 
            this.lightLevel.AutoSize = true;
            this.lightLevel.Location = new System.Drawing.Point(6, 223);
            this.lightLevel.Name = "lightLevel";
            this.lightLevel.Size = new System.Drawing.Size(67, 15);
            this.lightLevel.TabIndex = 100;
            this.lightLevel.Text = "Light Level:";
            // 
            // lightLevelBar
            // 
            this.lightLevelBar.AutoSize = false;
            this.lightLevelBar.Location = new System.Drawing.Point(79, 223);
            this.lightLevelBar.Maximum = 31;
            this.lightLevelBar.Name = "lightLevelBar";
            this.lightLevelBar.Size = new System.Drawing.Size(161, 21);
            this.lightLevelBar.TabIndex = 99;
            this.lightLevelBar.TickStyle = System.Windows.Forms.TickStyle.None;
            this.lightLevelBar.Value = 15;
            this.lightLevelBar.Scroll += new System.EventHandler(this.lightLevelBar_Scroll);
            // 
            // minMaxLightLevel
            // 
            this.minMaxLightLevel.Location = new System.Drawing.Point(9, 250);
            this.minMaxLightLevel.Name = "minMaxLightLevel";
            this.minMaxLightLevel.Size = new System.Drawing.Size(114, 20);
            this.minMaxLightLevel.TabIndex = 106;
            this.minMaxLightLevel.Text = "Enable Min/Max";
            this.minMaxLightLevel.CheckedChanged += new System.EventHandler(this.minMaxLightLevel_CheckedChanged);
            // 
            // blockPartyInvites
            // 
            this.blockPartyInvites.Location = new System.Drawing.Point(9, 169);
            this.blockPartyInvites.Name = "blockPartyInvites";
            this.blockPartyInvites.Size = new System.Drawing.Size(184, 20);
            this.blockPartyInvites.TabIndex = 98;
            this.blockPartyInvites.Text = "Block party invites";
            this.blockPartyInvites.CheckedChanged += new System.EventHandler(this.blockPartyInvites_CheckedChanged);
            // 
            // blockTradeRequests
            // 
            this.blockTradeRequests.Location = new System.Drawing.Point(9, 143);
            this.blockTradeRequests.Name = "blockTradeRequests";
            this.blockTradeRequests.Size = new System.Drawing.Size(184, 20);
            this.blockTradeRequests.TabIndex = 97;
            this.blockTradeRequests.Text = "Block trade requests";
            this.blockTradeRequests.CheckedChanged += new System.EventHandler(this.blockTradeRequests_CheckedChanged);
            // 
            // blockOpenCorpsesTwice
            // 
            this.blockOpenCorpsesTwice.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.blockOpenCorpsesTwice.Location = new System.Drawing.Point(9, 91);
            this.blockOpenCorpsesTwice.Name = "blockOpenCorpsesTwice";
            this.blockOpenCorpsesTwice.Size = new System.Drawing.Size(209, 20);
            this.blockOpenCorpsesTwice.TabIndex = 96;
            this.blockOpenCorpsesTwice.Text = "Block opening corpses twice";
            this.blockOpenCorpsesTwice.CheckedChanged += new System.EventHandler(this.blockOpenCorpsesTwice_CheckedChanged);
            // 
            // preAOSstatbar
            // 
            this.preAOSstatbar.Location = new System.Drawing.Point(9, 12);
            this.preAOSstatbar.Name = "preAOSstatbar";
            this.preAOSstatbar.Size = new System.Drawing.Size(190, 20);
            this.preAOSstatbar.TabIndex = 95;
            this.preAOSstatbar.Text = "Use Pre-AOS status window";
            this.preAOSstatbar.CheckedChanged += new System.EventHandler(this.preAOSstatbar_CheckedChanged);
            // 
            // corpseRange
            // 
            this.corpseRange.Location = new System.Drawing.Point(169, 63);
            this.corpseRange.Name = "corpseRange";
            this.corpseRange.Size = new System.Drawing.Size(24, 23);
            this.corpseRange.TabIndex = 91;
            this.corpseRange.TextAlign = System.Windows.Forms.HorizontalAlignment.Center;
            this.corpseRange.TextChanged += new System.EventHandler(this.corpseRange_TextChanged);
            // 
            // autoStackRes
            // 
            this.autoStackRes.Location = new System.Drawing.Point(9, 37);
            this.autoStackRes.Name = "autoStackRes";
            this.autoStackRes.Size = new System.Drawing.Size(228, 20);
            this.autoStackRes.TabIndex = 93;
            this.autoStackRes.Text = "Auto-Stack Ore/Fish/Logs at Feet";
            this.autoStackRes.CheckedChanged += new System.EventHandler(this.autoStackRes_CheckedChanged);
            // 
            // label4
            // 
            this.label4.Location = new System.Drawing.Point(201, 67);
            this.label4.Name = "label4";
            this.label4.Size = new System.Drawing.Size(36, 16);
            this.label4.TabIndex = 92;
            this.label4.Text = "tiles";
            // 
            // openCorpses
            // 
            this.openCorpses.Location = new System.Drawing.Point(9, 65);
            this.openCorpses.Name = "openCorpses";
            this.openCorpses.Size = new System.Drawing.Size(165, 20);
            this.openCorpses.TabIndex = 90;
            this.openCorpses.Text = "Open new corpses within";
            this.openCorpses.CheckedChanged += new System.EventHandler(this.openCorpses_CheckedChanged);
            // 
            // blockDis
            // 
            this.blockDis.Location = new System.Drawing.Point(9, 117);
            this.blockDis.Name = "blockDis";
            this.blockDis.Size = new System.Drawing.Size(184, 20);
            this.blockDis.TabIndex = 94;
            this.blockDis.Text = "Block dismount in war mode";
            this.blockDis.CheckedChanged += new System.EventHandler(this.blockDis_CheckedChanged);
            // 
            // displayTab
            // 
            this.displayTab.Controls.Add(this.displayCountersTabCtrl);
            this.displayTab.Location = new System.Drawing.Point(4, 44);
            this.displayTab.Name = "displayTab";
            this.displayTab.Size = new System.Drawing.Size(519, 322);
            this.displayTab.TabIndex = 1;
            this.displayTab.Text = "Display/Counters";
            // 
            // displayCountersTabCtrl
            // 
            this.displayCountersTabCtrl.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.displayCountersTabCtrl.Controls.Add(this.subDisplayTab);
            this.displayCountersTabCtrl.Controls.Add(this.subCountersTab);
            this.displayCountersTabCtrl.Controls.Add(this.subBandageTimerTab);
            this.displayCountersTabCtrl.Controls.Add(this.subOverheadTab);
            this.displayCountersTabCtrl.Controls.Add(this.subWaypoints);
            this.displayCountersTabCtrl.Controls.Add(this.subBuffsDebuffs);
            this.displayCountersTabCtrl.Location = new System.Drawing.Point(6, 3);
            this.displayCountersTabCtrl.Name = "displayCountersTabCtrl";
            this.displayCountersTabCtrl.SelectedIndex = 0;
            this.displayCountersTabCtrl.Size = new System.Drawing.Size(510, 314);
            this.displayCountersTabCtrl.TabIndex = 51;
            this.displayCountersTabCtrl.SelectedIndexChanged += new System.EventHandler(this.displayCountersTabCtrl_SelectedIndexChanged);
            // 
            // subDisplayTab
            // 
            this.subDisplayTab.BackColor = System.Drawing.SystemColors.Control;
            this.subDisplayTab.Controls.Add(this.groupBox11);
            this.subDisplayTab.Controls.Add(this.trackDps);
            this.subDisplayTab.Controls.Add(this.trackIncomingGold);
            this.subDisplayTab.Controls.Add(this.showNotoHue);
            this.subDisplayTab.Controls.Add(this.highlightSpellReags);
            this.subDisplayTab.Controls.Add(this.groupBox3);
            this.subDisplayTab.Location = new System.Drawing.Point(4, 24);
            this.subDisplayTab.Name = "subDisplayTab";
            this.subDisplayTab.Padding = new System.Windows.Forms.Padding(3);
            this.subDisplayTab.Size = new System.Drawing.Size(502, 286);
            this.subDisplayTab.TabIndex = 0;
            this.subDisplayTab.Text = "Display";
            // 
            // groupBox11
            // 
            this.groupBox11.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.groupBox11.Controls.Add(this.razorTitleBarKey);
            this.groupBox11.Controls.Add(this.showInRazorTitleBar);
            this.groupBox11.Controls.Add(this.razorTitleBar);
            this.groupBox11.Location = new System.Drawing.Point(6, 175);
            this.groupBox11.Name = "groupBox11";
            this.groupBox11.Size = new System.Drawing.Size(490, 71);
            this.groupBox11.TabIndex = 51;
            this.groupBox11.TabStop = false;
            this.groupBox11.Text = "Razor Title Bar";
            // 
            // razorTitleBarKey
            // 
            this.razorTitleBarKey.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.razorTitleBarKey.Location = new System.Drawing.Point(468, 17);
            this.razorTitleBarKey.Name = "razorTitleBarKey";
            this.razorTitleBarKey.Size = new System.Drawing.Size(16, 20);
            this.razorTitleBarKey.TabIndex = 2;
            this.razorTitleBarKey.Text = "?";
            this.razorTitleBarKey.UseVisualStyleBackColor = true;
            this.razorTitleBarKey.Click += new System.EventHandler(this.razorTitleBarKey_Click);
            // 
            // showInRazorTitleBar
            // 
            this.showInRazorTitleBar.AutoSize = true;
            this.showInRazorTitleBar.Location = new System.Drawing.Point(6, 17);
            this.showInRazorTitleBar.Name = "showInRazorTitleBar";
            this.showInRazorTitleBar.Size = new System.Drawing.Size(146, 19);
            this.showInRazorTitleBar.TabIndex = 1;
            this.showInRazorTitleBar.Text = "Show in Razor title bar:";
            this.showInRazorTitleBar.UseVisualStyleBackColor = true;
            this.showInRazorTitleBar.CheckedChanged += new System.EventHandler(this.showInRazorTitleBar_CheckedChanged);
            // 
            // razorTitleBar
            // 
            this.razorTitleBar.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.razorTitleBar.Font = new System.Drawing.Font("Consolas", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.razorTitleBar.Location = new System.Drawing.Point(6, 42);
            this.razorTitleBar.Name = "razorTitleBar";
            this.razorTitleBar.Size = new System.Drawing.Size(478, 22);
            this.razorTitleBar.TabIndex = 0;
            this.razorTitleBar.Text = "{name} ({profile} - {shard}) - Razor v{version}";
            this.razorTitleBar.TextChanged += new System.EventHandler(this.razorTitleBar_TextChanged);
            // 
            // trackDps
            // 
            this.trackDps.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.trackDps.AutoSize = true;
            this.trackDps.Location = new System.Drawing.Point(273, 146);
            this.trackDps.Name = "trackDps";
            this.trackDps.Size = new System.Drawing.Size(146, 19);
            this.trackDps.TabIndex = 53;
            this.trackDps.Text = "Enable damage tracker";
            this.trackDps.UseVisualStyleBackColor = true;
            this.trackDps.CheckedChanged += new System.EventHandler(this.trackDps_CheckedChanged);
            // 
            // trackIncomingGold
            // 
            this.trackIncomingGold.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.trackIncomingGold.AutoSize = true;
            this.trackIncomingGold.Location = new System.Drawing.Point(273, 120);
            this.trackIncomingGold.Name = "trackIncomingGold";
            this.trackIncomingGold.Size = new System.Drawing.Size(223, 19);
            this.trackIncomingGold.TabIndex = 52;
            this.trackIncomingGold.Text = "Enable gold per sec/min/hour tracker";
            this.trackIncomingGold.UseVisualStyleBackColor = true;
            this.trackIncomingGold.CheckedChanged += new System.EventHandler(this.trackIncomingGold_CheckedChanged);
            // 
            // showNotoHue
            // 
            this.showNotoHue.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.showNotoHue.Location = new System.Drawing.Point(6, 145);
            this.showNotoHue.Name = "showNotoHue";
            this.showNotoHue.Size = new System.Drawing.Size(221, 20);
            this.showNotoHue.TabIndex = 51;
            this.showNotoHue.Text = "Show noto hue on {char} in TitleBar";
            this.showNotoHue.CheckedChanged += new System.EventHandler(this.showNotoHue_CheckedChanged);
            // 
            // highlightSpellReags
            // 
            this.highlightSpellReags.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.highlightSpellReags.Location = new System.Drawing.Point(6, 119);
            this.highlightSpellReags.Name = "highlightSpellReags";
            this.highlightSpellReags.Size = new System.Drawing.Size(205, 20);
            this.highlightSpellReags.TabIndex = 50;
            this.highlightSpellReags.Text = "Highlight Spell Reagents on Cast";
            this.highlightSpellReags.CheckedChanged += new System.EventHandler(this.highlightSpellReags_CheckedChanged);
            // 
            // groupBox3
            // 
            this.groupBox3.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.groupBox3.Controls.Add(this.titleBarParams);
            this.groupBox3.Controls.Add(this.titleStr);
            this.groupBox3.Controls.Add(this.showInBar);
            this.groupBox3.Location = new System.Drawing.Point(6, 6);
            this.groupBox3.Name = "groupBox3";
            this.groupBox3.Size = new System.Drawing.Size(490, 107);
            this.groupBox3.TabIndex = 4;
            this.groupBox3.TabStop = false;
            this.groupBox3.Text = "Title Bar Display";
            // 
            // titleBarParams
            // 
            this.titleBarParams.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.titleBarParams.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.titleBarParams.FormattingEnabled = true;
            this.titleBarParams.Items.AddRange(new object[] {
            "{ar}",
            "{bandage}",
            "{char}",
            "{crimtime}",
            "{buffsdebuffs}",
            "{damage}",
            "-",
            "{dps}",
            "{maxdps}",
            "{maxdamagedealt}",
            "{maxdamagetaken}",
            "{totaldamagedealt}",
            "{totaldamagetaken}",
            "-",
            "{dex}",
            "{followersmax}",
            "{followers}",
            "-",
            "{gold}",
            "{goldtotal}",
            "{goldtotalmin}",
            "{gpm}",
            "{gps}",
            "{gph}",
            "-",
            "{gate}",
            "{hpmax}",
            "{hp}",
            "{int}",
            "{largestatbar}",
            "{manamax}",
            "{mana}",
            "{maxweight}",
            "{mediumstatbar}",
            "{shard}",
            "{skill}",
            "{stammax}",
            "{stam}",
            "{statbar}",
            "{stealthsteps}",
            "{str}",
            "{uptime}",
            "{weight}",
            "-",
            "{coldresist}",
            "{energyresist}",
            "{fireresist}",
            "{luck}",
            "{physresist}",
            "{poisonresist}",
            "{tithe}"});
            this.titleBarParams.Location = new System.Drawing.Point(380, 19);
            this.titleBarParams.Name = "titleBarParams";
            this.titleBarParams.Size = new System.Drawing.Size(104, 23);
            this.titleBarParams.TabIndex = 5;
            this.titleBarParams.SelectedIndexChanged += new System.EventHandler(this.titleBarParams_SelectedIndexChanged);
            // 
            // titleStr
            // 
            this.titleStr.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.titleStr.Font = new System.Drawing.Font("Consolas", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.titleStr.Location = new System.Drawing.Point(6, 48);
            this.titleStr.Multiline = true;
            this.titleStr.Name = "titleStr";
            this.titleStr.ScrollBars = System.Windows.Forms.ScrollBars.Vertical;
            this.titleStr.Size = new System.Drawing.Size(478, 53);
            this.titleStr.TabIndex = 4;
            this.titleStr.TextChanged += new System.EventHandler(this.titleStr_TextChanged);
            // 
            // showInBar
            // 
            this.showInBar.Location = new System.Drawing.Point(11, 22);
            this.showInBar.Name = "showInBar";
            this.showInBar.Size = new System.Drawing.Size(141, 20);
            this.showInBar.TabIndex = 3;
            this.showInBar.Text = "Show in UO title bar:";
            this.showInBar.CheckedChanged += new System.EventHandler(this.showInBar_CheckedChanged);
            // 
            // subCountersTab
            // 
            this.subCountersTab.BackColor = System.Drawing.SystemColors.Control;
            this.subCountersTab.Controls.Add(this.warnNum);
            this.subCountersTab.Controls.Add(this.warnCount);
            this.subCountersTab.Controls.Add(this.excludePouches);
            this.subCountersTab.Controls.Add(this.titlebarImages);
            this.subCountersTab.Controls.Add(this.checkNewConts);
            this.subCountersTab.Controls.Add(this.groupBox2);
            this.subCountersTab.Location = new System.Drawing.Point(4, 22);
            this.subCountersTab.Name = "subCountersTab";
            this.subCountersTab.Padding = new System.Windows.Forms.Padding(3);
            this.subCountersTab.Size = new System.Drawing.Size(502, 288);
            this.subCountersTab.TabIndex = 1;
            this.subCountersTab.Text = "Counters";
            // 
            // warnNum
            // 
            this.warnNum.Location = new System.Drawing.Point(430, 99);
            this.warnNum.Name = "warnNum";
            this.warnNum.Size = new System.Drawing.Size(30, 23);
            this.warnNum.TabIndex = 51;
            this.warnNum.Text = "3";
            this.warnNum.TextAlign = System.Windows.Forms.HorizontalAlignment.Center;
            this.warnNum.TextChanged += new System.EventHandler(this.warnNum_TextChanged);
            // 
            // warnCount
            // 
            this.warnCount.Location = new System.Drawing.Point(299, 101);
            this.warnCount.Name = "warnCount";
            this.warnCount.Size = new System.Drawing.Size(192, 19);
            this.warnCount.TabIndex = 50;
            this.warnCount.Text = "Warn when below:";
            this.warnCount.CheckedChanged += new System.EventHandler(this.warnCount_CheckedChanged);
            // 
            // excludePouches
            // 
            this.excludePouches.Location = new System.Drawing.Point(299, 48);
            this.excludePouches.Name = "excludePouches";
            this.excludePouches.Size = new System.Drawing.Size(192, 21);
            this.excludePouches.TabIndex = 49;
            this.excludePouches.Text = "Never auto-search pouches";
            this.excludePouches.CheckedChanged += new System.EventHandler(this.excludePouches_CheckedChanged);
            // 
            // titlebarImages
            // 
            this.titlebarImages.Location = new System.Drawing.Point(299, 75);
            this.titlebarImages.Name = "titlebarImages";
            this.titlebarImages.Size = new System.Drawing.Size(180, 20);
            this.titlebarImages.TabIndex = 48;
            this.titlebarImages.Text = "Show Images with Counters";
            this.titlebarImages.CheckedChanged += new System.EventHandler(this.titlebarImages_CheckedChanged);
            // 
            // checkNewConts
            // 
            this.checkNewConts.Location = new System.Drawing.Point(299, 24);
            this.checkNewConts.Name = "checkNewConts";
            this.checkNewConts.Size = new System.Drawing.Size(200, 20);
            this.checkNewConts.TabIndex = 47;
            this.checkNewConts.Text = "Auto search new containers";
            this.checkNewConts.CheckedChanged += new System.EventHandler(this.checkNewConts_CheckedChanged);
            // 
            // groupBox2
            // 
            this.groupBox2.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left)));
            this.groupBox2.Controls.Add(this.counters);
            this.groupBox2.Controls.Add(this.delCounter);
            this.groupBox2.Controls.Add(this.addCounter);
            this.groupBox2.Controls.Add(this.recount);
            this.groupBox2.Location = new System.Drawing.Point(6, 6);
            this.groupBox2.Name = "groupBox2";
            this.groupBox2.Size = new System.Drawing.Size(284, 254);
            this.groupBox2.TabIndex = 2;
            this.groupBox2.TabStop = false;
            this.groupBox2.Text = "Counters";
            // 
            // counters
            // 
            this.counters.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left)));
            this.counters.CheckBoxes = true;
            this.counters.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] {
            this.cntName,
            this.cntCount});
            this.counters.GridLines = true;
            this.counters.HeaderStyle = System.Windows.Forms.ColumnHeaderStyle.Nonclickable;
            this.counters.HideSelection = false;
            this.counters.LabelWrap = false;
            this.counters.Location = new System.Drawing.Point(6, 18);
            this.counters.MultiSelect = false;
            this.counters.Name = "counters";
            this.counters.Size = new System.Drawing.Size(272, 187);
            this.counters.TabIndex = 11;
            this.counters.UseCompatibleStateImageBehavior = false;
            this.counters.View = System.Windows.Forms.View.Details;
            this.counters.ItemCheck += new System.Windows.Forms.ItemCheckEventHandler(this.counters_ItemCheck);
            // 
            // cntName
            // 
            this.cntName.Text = "Name (Format)";
            this.cntName.Width = 216;
            // 
            // cntCount
            // 
            this.cntCount.Text = "Count";
            this.cntCount.Width = 51;
            // 
            // delCounter
            // 
            this.delCounter.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.delCounter.Location = new System.Drawing.Point(108, 211);
            this.delCounter.Name = "delCounter";
            this.delCounter.Size = new System.Drawing.Size(71, 37);
            this.delCounter.TabIndex = 4;
            this.delCounter.Text = "Del/Edit";
            this.delCounter.Click += new System.EventHandler(this.delCounter_Click);
            // 
            // addCounter
            // 
            this.addCounter.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.addCounter.Location = new System.Drawing.Point(6, 211);
            this.addCounter.Name = "addCounter";
            this.addCounter.Size = new System.Drawing.Size(70, 37);
            this.addCounter.TabIndex = 3;
            this.addCounter.Text = "Add...";
            this.addCounter.Click += new System.EventHandler(this.addCounter_Click);
            // 
            // recount
            // 
            this.recount.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.recount.Location = new System.Drawing.Point(208, 211);
            this.recount.Name = "recount";
            this.recount.Size = new System.Drawing.Size(70, 37);
            this.recount.TabIndex = 2;
            this.recount.Text = "Recount";
            this.recount.Click += new System.EventHandler(this.recount_Click);
            // 
            // subBandageTimerTab
            // 
            this.subBandageTimerTab.BackColor = System.Drawing.SystemColors.Control;
            this.subBandageTimerTab.Controls.Add(this.bandageEndMessage);
            this.subBandageTimerTab.Controls.Add(this.bandageStartMessage);
            this.subBandageTimerTab.Controls.Add(this.showBandageEnd);
            this.subBandageTimerTab.Controls.Add(this.showBandageStart);
            this.subBandageTimerTab.Controls.Add(this.setBandageHue);
            this.subBandageTimerTab.Controls.Add(this.bandageTimerLocation);
            this.subBandageTimerTab.Controls.Add(this.bandageTimerSeconds);
            this.subBandageTimerTab.Controls.Add(this.onlyShowBandageTimerSeconds);
            this.subBandageTimerTab.Controls.Add(this.bandageTimerFormat);
            this.subBandageTimerTab.Controls.Add(this.showBandageTimer);
            this.subBandageTimerTab.Controls.Add(this.lblBandageCountFormat);
            this.subBandageTimerTab.Location = new System.Drawing.Point(4, 22);
            this.subBandageTimerTab.Name = "subBandageTimerTab";
            this.subBandageTimerTab.Size = new System.Drawing.Size(502, 288);
            this.subBandageTimerTab.TabIndex = 2;
            this.subBandageTimerTab.Text = "Bandage Timer";
            // 
            // bandageEndMessage
            // 
            this.bandageEndMessage.Location = new System.Drawing.Point(205, 123);
            this.bandageEndMessage.Name = "bandageEndMessage";
            this.bandageEndMessage.Size = new System.Drawing.Size(146, 23);
            this.bandageEndMessage.TabIndex = 62;
            this.bandageEndMessage.Text = "Bandage: Ending";
            this.bandageEndMessage.TextAlign = System.Windows.Forms.HorizontalAlignment.Center;
            this.bandageEndMessage.TextChanged += new System.EventHandler(this.BandageEndMessage_TextChanged);
            // 
            // bandageStartMessage
            // 
            this.bandageStartMessage.Location = new System.Drawing.Point(205, 98);
            this.bandageStartMessage.Name = "bandageStartMessage";
            this.bandageStartMessage.Size = new System.Drawing.Size(146, 23);
            this.bandageStartMessage.TabIndex = 61;
            this.bandageStartMessage.Text = "Bandage: Starting";
            this.bandageStartMessage.TextAlign = System.Windows.Forms.HorizontalAlignment.Center;
            this.bandageStartMessage.TextChanged += new System.EventHandler(this.BandageStartMessage_TextChanged);
            // 
            // showBandageEnd
            // 
            this.showBandageEnd.AutoSize = true;
            this.showBandageEnd.Location = new System.Drawing.Point(9, 125);
            this.showBandageEnd.Name = "showBandageEnd";
            this.showBandageEnd.Size = new System.Drawing.Size(187, 19);
            this.showBandageEnd.TabIndex = 60;
            this.showBandageEnd.Text = "Show bandaging end message";
            this.showBandageEnd.UseVisualStyleBackColor = true;
            this.showBandageEnd.CheckedChanged += new System.EventHandler(this.ShowBandageEnd_CheckedChanged);
            // 
            // showBandageStart
            // 
            this.showBandageStart.AutoSize = true;
            this.showBandageStart.Location = new System.Drawing.Point(9, 100);
            this.showBandageStart.Name = "showBandageStart";
            this.showBandageStart.Size = new System.Drawing.Size(190, 19);
            this.showBandageStart.TabIndex = 58;
            this.showBandageStart.Text = "Show bandaging start message";
            this.showBandageStart.UseVisualStyleBackColor = true;
            this.showBandageStart.CheckedChanged += new System.EventHandler(this.ShowBandageStart_CheckedChanged);
            // 
            // setBandageHue
            // 
            this.setBandageHue.Location = new System.Drawing.Point(269, 41);
            this.setBandageHue.Name = "setBandageHue";
            this.setBandageHue.Size = new System.Drawing.Size(67, 23);
            this.setBandageHue.TabIndex = 57;
            this.setBandageHue.Text = "Set Hue";
            this.setBandageHue.UseVisualStyleBackColor = true;
            this.setBandageHue.Click += new System.EventHandler(this.setBandageHue_Click);
            // 
            // bandageTimerLocation
            // 
            this.bandageTimerLocation.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.bandageTimerLocation.FormattingEnabled = true;
            this.bandageTimerLocation.Items.AddRange(new object[] {
            "Overhead",
            "System Messages"});
            this.bandageTimerLocation.Location = new System.Drawing.Point(145, 10);
            this.bandageTimerLocation.Name = "bandageTimerLocation";
            this.bandageTimerLocation.Size = new System.Drawing.Size(118, 23);
            this.bandageTimerLocation.TabIndex = 56;
            this.bandageTimerLocation.SelectedIndexChanged += new System.EventHandler(this.bandageTimerLocation_SelectedIndexChanged);
            // 
            // bandageTimerSeconds
            // 
            this.bandageTimerSeconds.Location = new System.Drawing.Point(180, 71);
            this.bandageTimerSeconds.Name = "bandageTimerSeconds";
            this.bandageTimerSeconds.Size = new System.Drawing.Size(48, 23);
            this.bandageTimerSeconds.TabIndex = 55;
            this.bandageTimerSeconds.TextAlign = System.Windows.Forms.HorizontalAlignment.Center;
            this.bandageTimerSeconds.TextChanged += new System.EventHandler(this.bandageTimerSeconds_TextChanged);
            // 
            // onlyShowBandageTimerSeconds
            // 
            this.onlyShowBandageTimerSeconds.Location = new System.Drawing.Point(9, 72);
            this.onlyShowBandageTimerSeconds.Name = "onlyShowBandageTimerSeconds";
            this.onlyShowBandageTimerSeconds.Size = new System.Drawing.Size(205, 20);
            this.onlyShowBandageTimerSeconds.TabIndex = 53;
            this.onlyShowBandageTimerSeconds.Text = "Only show every X seconds:";
            this.onlyShowBandageTimerSeconds.CheckedChanged += new System.EventHandler(this.onlyShowBandageTimerSeconds_CheckedChanged);
            // 
            // bandageTimerFormat
            // 
            this.bandageTimerFormat.Location = new System.Drawing.Point(113, 41);
            this.bandageTimerFormat.Name = "bandageTimerFormat";
            this.bandageTimerFormat.Size = new System.Drawing.Size(150, 23);
            this.bandageTimerFormat.TabIndex = 52;
            this.bandageTimerFormat.Text = "Bandage: {count}s";
            this.bandageTimerFormat.TextAlign = System.Windows.Forms.HorizontalAlignment.Center;
            this.bandageTimerFormat.TextChanged += new System.EventHandler(this.bandageTimerFormat_TextChanged);
            // 
            // showBandageTimer
            // 
            this.showBandageTimer.Location = new System.Drawing.Point(9, 11);
            this.showBandageTimer.Name = "showBandageTimer";
            this.showBandageTimer.Size = new System.Drawing.Size(205, 20);
            this.showBandageTimer.TabIndex = 51;
            this.showBandageTimer.Text = "Show bandage timer";
            this.showBandageTimer.CheckedChanged += new System.EventHandler(this.showBandageTimer_CheckedChanged);
            // 
            // lblBandageCountFormat
            // 
            this.lblBandageCountFormat.Location = new System.Drawing.Point(21, 41);
            this.lblBandageCountFormat.Name = "lblBandageCountFormat";
            this.lblBandageCountFormat.Size = new System.Drawing.Size(159, 23);
            this.lblBandageCountFormat.TabIndex = 54;
            this.lblBandageCountFormat.Text = "Format && Hue:";
            this.lblBandageCountFormat.TextAlign = System.Drawing.ContentAlignment.MiddleLeft;
            // 
            // subOverheadTab
            // 
            this.subOverheadTab.BackColor = System.Drawing.SystemColors.Control;
            this.subOverheadTab.Controls.Add(this.setSound);
            this.subOverheadTab.Controls.Add(this.label14);
            this.subOverheadTab.Controls.Add(this.unicodeStyle);
            this.subOverheadTab.Controls.Add(this.asciiStyle);
            this.subOverheadTab.Controls.Add(this.editOverheadMessage);
            this.subOverheadTab.Controls.Add(this.setColorHue);
            this.subOverheadTab.Controls.Add(this.removeOverheadMessage);
            this.subOverheadTab.Controls.Add(this.label13);
            this.subOverheadTab.Controls.Add(this.overheadFormat);
            this.subOverheadTab.Controls.Add(this.setOverheadMessage);
            this.subOverheadTab.Controls.Add(this.cliLocOverheadView);
            this.subOverheadTab.Controls.Add(this.cliLocSearch);
            this.subOverheadTab.Controls.Add(this.cliLocTextSearch);
            this.subOverheadTab.Controls.Add(this.lblOhSearch);
            this.subOverheadTab.Controls.Add(this.cliLocSearchView);
            this.subOverheadTab.Controls.Add(this.showOverheadMessages);
            this.subOverheadTab.Location = new System.Drawing.Point(4, 22);
            this.subOverheadTab.Name = "subOverheadTab";
            this.subOverheadTab.Size = new System.Drawing.Size(502, 288);
            this.subOverheadTab.TabIndex = 3;
            this.subOverheadTab.Text = "Overhead Messages";
            // 
            // setSound
            // 
            this.setSound.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.setSound.Location = new System.Drawing.Point(8, 237);
            this.setSound.Name = "setSound";
            this.setSound.Size = new System.Drawing.Size(84, 28);
            this.setSound.TabIndex = 103;
            this.setSound.Text = "Set Sound";
            this.setSound.UseVisualStyleBackColor = true;
            this.setSound.Click += new System.EventHandler(this.setSound_Click);
            // 
            // label14
            // 
            this.label14.AutoSize = true;
            this.label14.Location = new System.Drawing.Point(5, 83);
            this.label14.Name = "label14";
            this.label14.Size = new System.Drawing.Size(84, 15);
            this.label14.TabIndex = 102;
            this.label14.Text = "Message Style:";
            // 
            // unicodeStyle
            // 
            this.unicodeStyle.AutoSize = true;
            this.unicodeStyle.Location = new System.Drawing.Point(8, 101);
            this.unicodeStyle.Name = "unicodeStyle";
            this.unicodeStyle.Size = new System.Drawing.Size(69, 19);
            this.unicodeStyle.TabIndex = 101;
            this.unicodeStyle.TabStop = true;
            this.unicodeStyle.Text = "Unicode";
            this.unicodeStyle.UseVisualStyleBackColor = true;
            this.unicodeStyle.CheckedChanged += new System.EventHandler(this.unicodeStyle_CheckedChanged);
            // 
            // asciiStyle
            // 
            this.asciiStyle.AutoSize = true;
            this.asciiStyle.Location = new System.Drawing.Point(8, 126);
            this.asciiStyle.Name = "asciiStyle";
            this.asciiStyle.Size = new System.Drawing.Size(53, 19);
            this.asciiStyle.TabIndex = 100;
            this.asciiStyle.TabStop = true;
            this.asciiStyle.Text = "ASCII";
            this.asciiStyle.UseVisualStyleBackColor = true;
            this.asciiStyle.CheckedChanged += new System.EventHandler(this.asciiStyle_CheckedChanged);
            // 
            // editOverheadMessage
            // 
            this.editOverheadMessage.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.editOverheadMessage.Location = new System.Drawing.Point(8, 135);
            this.editOverheadMessage.Name = "editOverheadMessage";
            this.editOverheadMessage.Size = new System.Drawing.Size(84, 28);
            this.editOverheadMessage.TabIndex = 97;
            this.editOverheadMessage.Text = "Edit";
            this.editOverheadMessage.UseVisualStyleBackColor = true;
            this.editOverheadMessage.Click += new System.EventHandler(this.editOverheadMessage_Click);
            // 
            // setColorHue
            // 
            this.setColorHue.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.setColorHue.Location = new System.Drawing.Point(8, 203);
            this.setColorHue.Name = "setColorHue";
            this.setColorHue.Size = new System.Drawing.Size(84, 28);
            this.setColorHue.TabIndex = 96;
            this.setColorHue.Text = "Set Hue";
            this.setColorHue.UseVisualStyleBackColor = true;
            this.setColorHue.Click += new System.EventHandler(this.setColorHue_Click);
            // 
            // removeOverheadMessage
            // 
            this.removeOverheadMessage.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.removeOverheadMessage.Location = new System.Drawing.Point(8, 169);
            this.removeOverheadMessage.Name = "removeOverheadMessage";
            this.removeOverheadMessage.Size = new System.Drawing.Size(84, 28);
            this.removeOverheadMessage.TabIndex = 95;
            this.removeOverheadMessage.Text = "Remove";
            this.removeOverheadMessage.UseVisualStyleBackColor = true;
            this.removeOverheadMessage.Click += new System.EventHandler(this.removeOverheadMessage_Click);
            // 
            // label13
            // 
            this.label13.AutoSize = true;
            this.label13.Location = new System.Drawing.Point(5, 39);
            this.label13.Name = "label13";
            this.label13.Size = new System.Drawing.Size(48, 15);
            this.label13.TabIndex = 94;
            this.label13.Text = "Format:";
            // 
            // overheadFormat
            // 
            this.overheadFormat.Location = new System.Drawing.Point(8, 57);
            this.overheadFormat.Name = "overheadFormat";
            this.overheadFormat.Size = new System.Drawing.Size(84, 23);
            this.overheadFormat.TabIndex = 93;
            this.overheadFormat.Text = "[{msg}]";
            this.overheadFormat.TextAlign = System.Windows.Forms.HorizontalAlignment.Center;
            this.overheadFormat.TextChanged += new System.EventHandler(this.overheadFormat_TextChanged);
            // 
            // setOverheadMessage
            // 
            this.setOverheadMessage.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.setOverheadMessage.Location = new System.Drawing.Point(443, 9);
            this.setOverheadMessage.Name = "setOverheadMessage";
            this.setOverheadMessage.Size = new System.Drawing.Size(56, 24);
            this.setOverheadMessage.TabIndex = 92;
            this.setOverheadMessage.Text = "Add";
            this.setOverheadMessage.UseVisualStyleBackColor = true;
            this.setOverheadMessage.Click += new System.EventHandler(this.setOverheadMessage_Click);
            // 
            // cliLocOverheadView
            // 
            this.cliLocOverheadView.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.cliLocOverheadView.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] {
            this.cliLocOriginal,
            this.cliLocOverheadMessage,
            this.cliLocSound});
            this.cliLocOverheadView.HideSelection = false;
            this.cliLocOverheadView.Location = new System.Drawing.Point(98, 156);
            this.cliLocOverheadView.Name = "cliLocOverheadView";
            this.cliLocOverheadView.Size = new System.Drawing.Size(401, 109);
            this.cliLocOverheadView.TabIndex = 91;
            this.cliLocOverheadView.UseCompatibleStateImageBehavior = false;
            this.cliLocOverheadView.View = System.Windows.Forms.View.Details;
            // 
            // cliLocOriginal
            // 
            this.cliLocOriginal.Text = "Original Text";
            this.cliLocOriginal.Width = 168;
            // 
            // cliLocOverheadMessage
            // 
            this.cliLocOverheadMessage.Text = "Overhead Message";
            this.cliLocOverheadMessage.Width = 181;
            // 
            // cliLocSound
            // 
            this.cliLocSound.Text = "Sound";
            this.cliLocSound.Width = 48;
            // 
            // cliLocSearch
            // 
            this.cliLocSearch.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.cliLocSearch.Location = new System.Drawing.Point(377, 9);
            this.cliLocSearch.Name = "cliLocSearch";
            this.cliLocSearch.Size = new System.Drawing.Size(60, 24);
            this.cliLocSearch.TabIndex = 90;
            this.cliLocSearch.Text = "Search";
            this.cliLocSearch.UseVisualStyleBackColor = true;
            this.cliLocSearch.Click += new System.EventHandler(this.cliLocSearch_Click);
            // 
            // cliLocTextSearch
            // 
            this.cliLocTextSearch.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.cliLocTextSearch.Location = new System.Drawing.Point(146, 9);
            this.cliLocTextSearch.Name = "cliLocTextSearch";
            this.cliLocTextSearch.Size = new System.Drawing.Size(225, 23);
            this.cliLocTextSearch.TabIndex = 89;
            // 
            // lblOhSearch
            // 
            this.lblOhSearch.AutoSize = true;
            this.lblOhSearch.Location = new System.Drawing.Point(95, 12);
            this.lblOhSearch.Name = "lblOhSearch";
            this.lblOhSearch.Size = new System.Drawing.Size(45, 15);
            this.lblOhSearch.TabIndex = 88;
            this.lblOhSearch.Text = "Search:";
            // 
            // cliLocSearchView
            // 
            this.cliLocSearchView.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.cliLocSearchView.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] {
            this.cliLocSearchNumber,
            this.cliLocSearchText});
            this.cliLocSearchView.HideSelection = false;
            this.cliLocSearchView.Location = new System.Drawing.Point(98, 39);
            this.cliLocSearchView.Name = "cliLocSearchView";
            this.cliLocSearchView.Size = new System.Drawing.Size(401, 111);
            this.cliLocSearchView.TabIndex = 87;
            this.cliLocSearchView.UseCompatibleStateImageBehavior = false;
            this.cliLocSearchView.View = System.Windows.Forms.View.Details;
            // 
            // cliLocSearchNumber
            // 
            this.cliLocSearchNumber.Text = "Number";
            this.cliLocSearchNumber.Width = 75;
            // 
            // cliLocSearchText
            // 
            this.cliLocSearchText.Text = "Text";
            this.cliLocSearchText.Width = 313;
            // 
            // showOverheadMessages
            // 
            this.showOverheadMessages.Location = new System.Drawing.Point(8, 9);
            this.showOverheadMessages.Name = "showOverheadMessages";
            this.showOverheadMessages.Size = new System.Drawing.Size(71, 24);
            this.showOverheadMessages.TabIndex = 85;
            this.showOverheadMessages.Text = "Enabled";
            this.showOverheadMessages.UseVisualStyleBackColor = true;
            this.showOverheadMessages.CheckedChanged += new System.EventHandler(this.showOverheadMessages_CheckedChanged);
            // 
            // subWaypoints
            // 
            this.subWaypoints.BackColor = System.Drawing.SystemColors.Control;
            this.subWaypoints.Controls.Add(this.waypointOnDeath);
            this.subWaypoints.Controls.Add(this.lblWaypointTiles);
            this.subWaypoints.Controls.Add(this.hideWaypointDist);
            this.subWaypoints.Controls.Add(this.hideWaypointWithin);
            this.subWaypoints.Controls.Add(this.txtWaypointDistanceSec);
            this.subWaypoints.Controls.Add(this.lblWaypointSeconds);
            this.subWaypoints.Controls.Add(this.showWaypointDistance);
            this.subWaypoints.Controls.Add(this.showWaypointOverhead);
            this.subWaypoints.Controls.Add(this.btnRemoveSelectedWaypoint);
            this.subWaypoints.Controls.Add(this.btnHideWaypoint);
            this.subWaypoints.Controls.Add(this.btnUseCurrentLoc);
            this.subWaypoints.Controls.Add(this.txtWaypointName);
            this.subWaypoints.Controls.Add(this.lblWaypointY);
            this.subWaypoints.Controls.Add(this.lblWaypointX);
            this.subWaypoints.Controls.Add(this.txtWaypointX);
            this.subWaypoints.Controls.Add(this.txtWaypointY);
            this.subWaypoints.Controls.Add(this.lblWaypoint);
            this.subWaypoints.Controls.Add(this.btnAddWaypoint);
            this.subWaypoints.Controls.Add(this.waypointList);
            this.subWaypoints.Location = new System.Drawing.Point(4, 22);
            this.subWaypoints.Name = "subWaypoints";
            this.subWaypoints.Size = new System.Drawing.Size(502, 288);
            this.subWaypoints.TabIndex = 4;
            this.subWaypoints.Text = "Waypoints";
            // 
            // waypointOnDeath
            // 
            this.waypointOnDeath.AutoSize = true;
            this.waypointOnDeath.Location = new System.Drawing.Point(184, 87);
            this.waypointOnDeath.Name = "waypointOnDeath";
            this.waypointOnDeath.Size = new System.Drawing.Size(162, 19);
            this.waypointOnDeath.TabIndex = 66;
            this.waypointOnDeath.Text = "Create waypoint on death";
            this.waypointOnDeath.UseVisualStyleBackColor = true;
            this.waypointOnDeath.CheckedChanged += new System.EventHandler(this.waypointOnDeath_CheckedChanged);
            // 
            // lblWaypointTiles
            // 
            this.lblWaypointTiles.Location = new System.Drawing.Point(374, 63);
            this.lblWaypointTiles.Name = "lblWaypointTiles";
            this.lblWaypointTiles.Size = new System.Drawing.Size(58, 18);
            this.lblWaypointTiles.TabIndex = 65;
            this.lblWaypointTiles.Text = "tiles";
            // 
            // hideWaypointDist
            // 
            this.hideWaypointDist.Location = new System.Drawing.Point(336, 60);
            this.hideWaypointDist.Name = "hideWaypointDist";
            this.hideWaypointDist.Size = new System.Drawing.Size(32, 23);
            this.hideWaypointDist.TabIndex = 64;
            this.hideWaypointDist.TextAlign = System.Windows.Forms.HorizontalAlignment.Center;
            this.hideWaypointDist.TextChanged += new System.EventHandler(this.hideWaypointDist_TextChanged);
            // 
            // hideWaypointWithin
            // 
            this.hideWaypointWithin.AutoSize = true;
            this.hideWaypointWithin.Location = new System.Drawing.Point(184, 62);
            this.hideWaypointWithin.Name = "hideWaypointWithin";
            this.hideWaypointWithin.Size = new System.Drawing.Size(139, 19);
            this.hideWaypointWithin.TabIndex = 63;
            this.hideWaypointWithin.Text = "Hide waypoint within";
            this.hideWaypointWithin.UseVisualStyleBackColor = true;
            this.hideWaypointWithin.CheckedChanged += new System.EventHandler(this.hideWaypointWithin_CheckedChanged);
            // 
            // txtWaypointDistanceSec
            // 
            this.txtWaypointDistanceSec.Location = new System.Drawing.Point(336, 35);
            this.txtWaypointDistanceSec.Name = "txtWaypointDistanceSec";
            this.txtWaypointDistanceSec.Size = new System.Drawing.Size(32, 23);
            this.txtWaypointDistanceSec.TabIndex = 62;
            this.txtWaypointDistanceSec.TextAlign = System.Windows.Forms.HorizontalAlignment.Center;
            this.txtWaypointDistanceSec.TextChanged += new System.EventHandler(this.txtWaypointDistanceSec_TextChanged);
            // 
            // lblWaypointSeconds
            // 
            this.lblWaypointSeconds.Location = new System.Drawing.Point(374, 37);
            this.lblWaypointSeconds.Name = "lblWaypointSeconds";
            this.lblWaypointSeconds.Size = new System.Drawing.Size(58, 18);
            this.lblWaypointSeconds.TabIndex = 61;
            this.lblWaypointSeconds.Text = "secs";
            // 
            // showWaypointDistance
            // 
            this.showWaypointDistance.AutoSize = true;
            this.showWaypointDistance.Location = new System.Drawing.Point(184, 37);
            this.showWaypointDistance.Name = "showWaypointDistance";
            this.showWaypointDistance.Size = new System.Drawing.Size(152, 19);
            this.showWaypointDistance.TabIndex = 60;
            this.showWaypointDistance.Text = "Show tile distance every";
            this.showWaypointDistance.UseVisualStyleBackColor = true;
            this.showWaypointDistance.CheckedChanged += new System.EventHandler(this.showWaypointDistance_CheckedChanged);
            // 
            // showWaypointOverhead
            // 
            this.showWaypointOverhead.AutoSize = true;
            this.showWaypointOverhead.Location = new System.Drawing.Point(184, 12);
            this.showWaypointOverhead.Name = "showWaypointOverhead";
            this.showWaypointOverhead.Size = new System.Drawing.Size(213, 19);
            this.showWaypointOverhead.TabIndex = 59;
            this.showWaypointOverhead.Text = "Show waypoint messages overhead";
            this.showWaypointOverhead.UseVisualStyleBackColor = true;
            this.showWaypointOverhead.CheckedChanged += new System.EventHandler(this.showWaypointOverhead_CheckedChanged);
            // 
            // btnRemoveSelectedWaypoint
            // 
            this.btnRemoveSelectedWaypoint.Location = new System.Drawing.Point(184, 242);
            this.btnRemoveSelectedWaypoint.Name = "btnRemoveSelectedWaypoint";
            this.btnRemoveSelectedWaypoint.Size = new System.Drawing.Size(135, 29);
            this.btnRemoveSelectedWaypoint.TabIndex = 10;
            this.btnRemoveSelectedWaypoint.Text = "Remove Selected";
            this.btnRemoveSelectedWaypoint.UseVisualStyleBackColor = true;
            this.btnRemoveSelectedWaypoint.Click += new System.EventHandler(this.btnRemoveSelectedWaypoint_Click);
            // 
            // btnHideWaypoint
            // 
            this.btnHideWaypoint.Location = new System.Drawing.Point(364, 242);
            this.btnHideWaypoint.Name = "btnHideWaypoint";
            this.btnHideWaypoint.Size = new System.Drawing.Size(129, 29);
            this.btnHideWaypoint.TabIndex = 9;
            this.btnHideWaypoint.Text = "Clear Waypoint";
            this.btnHideWaypoint.UseVisualStyleBackColor = true;
            this.btnHideWaypoint.Click += new System.EventHandler(this.btnHideWaypoint_Click);
            // 
            // btnUseCurrentLoc
            // 
            this.btnUseCurrentLoc.Location = new System.Drawing.Point(364, 151);
            this.btnUseCurrentLoc.Name = "btnUseCurrentLoc";
            this.btnUseCurrentLoc.Size = new System.Drawing.Size(129, 23);
            this.btnUseCurrentLoc.TabIndex = 8;
            this.btnUseCurrentLoc.Text = "Use Current Position";
            this.btnUseCurrentLoc.UseVisualStyleBackColor = true;
            this.btnUseCurrentLoc.Click += new System.EventHandler(this.btnUseCurrentLoc_Click);
            // 
            // txtWaypointName
            // 
            this.txtWaypointName.Location = new System.Drawing.Point(229, 121);
            this.txtWaypointName.Name = "txtWaypointName";
            this.txtWaypointName.Size = new System.Drawing.Size(129, 23);
            this.txtWaypointName.TabIndex = 7;
            // 
            // lblWaypointY
            // 
            this.lblWaypointY.AutoSize = true;
            this.lblWaypointY.Location = new System.Drawing.Point(285, 154);
            this.lblWaypointY.Name = "lblWaypointY";
            this.lblWaypointY.Size = new System.Drawing.Size(17, 15);
            this.lblWaypointY.TabIndex = 6;
            this.lblWaypointY.Text = "Y:";
            // 
            // lblWaypointX
            // 
            this.lblWaypointX.AutoSize = true;
            this.lblWaypointX.Location = new System.Drawing.Point(206, 154);
            this.lblWaypointX.Name = "lblWaypointX";
            this.lblWaypointX.Size = new System.Drawing.Size(17, 15);
            this.lblWaypointX.TabIndex = 5;
            this.lblWaypointX.Text = "X:";
            // 
            // txtWaypointX
            // 
            this.txtWaypointX.Location = new System.Drawing.Point(229, 151);
            this.txtWaypointX.Name = "txtWaypointX";
            this.txtWaypointX.Size = new System.Drawing.Size(50, 23);
            this.txtWaypointX.TabIndex = 4;
            // 
            // txtWaypointY
            // 
            this.txtWaypointY.Location = new System.Drawing.Point(308, 151);
            this.txtWaypointY.Name = "txtWaypointY";
            this.txtWaypointY.Size = new System.Drawing.Size(50, 23);
            this.txtWaypointY.TabIndex = 3;
            // 
            // lblWaypoint
            // 
            this.lblWaypoint.AutoSize = true;
            this.lblWaypoint.Location = new System.Drawing.Point(181, 124);
            this.lblWaypoint.Name = "lblWaypoint";
            this.lblWaypoint.Size = new System.Drawing.Size(42, 15);
            this.lblWaypoint.TabIndex = 2;
            this.lblWaypoint.Text = "Name:";
            // 
            // btnAddWaypoint
            // 
            this.btnAddWaypoint.Location = new System.Drawing.Point(364, 121);
            this.btnAddWaypoint.Name = "btnAddWaypoint";
            this.btnAddWaypoint.Size = new System.Drawing.Size(129, 24);
            this.btnAddWaypoint.TabIndex = 1;
            this.btnAddWaypoint.Text = "Add Waypoint";
            this.btnAddWaypoint.UseVisualStyleBackColor = true;
            this.btnAddWaypoint.Click += new System.EventHandler(this.btnAddWaypoint_Click);
            // 
            // waypointList
            // 
            this.waypointList.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left)));
            this.waypointList.FormattingEnabled = true;
            this.waypointList.ItemHeight = 15;
            this.waypointList.Location = new System.Drawing.Point(11, 12);
            this.waypointList.Name = "waypointList";
            this.waypointList.Size = new System.Drawing.Size(164, 154);
            this.waypointList.TabIndex = 0;
            this.waypointList.MouseDoubleClick += new System.Windows.Forms.MouseEventHandler(this.listWaypoints_MouseDoubleClick);
            this.waypointList.MouseDown += new System.Windows.Forms.MouseEventHandler(this.listWaypoints_MouseDown);
            // 
            // subBuffsDebuffs
            // 
            this.subBuffsDebuffs.BackColor = System.Drawing.SystemColors.Control;
            this.subBuffsDebuffs.Controls.Add(this.cooldownGumpBox);
            this.subBuffsDebuffs.Controls.Add(this.buffBarGroupBox);
            this.subBuffsDebuffs.Controls.Add(this.buffDebuffOptions);
            this.subBuffsDebuffs.Controls.Add(this.showBuffDebuffOverhead);
            this.subBuffsDebuffs.Location = new System.Drawing.Point(4, 24);
            this.subBuffsDebuffs.Name = "subBuffsDebuffs";
            this.subBuffsDebuffs.Size = new System.Drawing.Size(502, 286);
            this.subBuffsDebuffs.TabIndex = 5;
            this.subBuffsDebuffs.Text = "Buffs / Cooldowns";
            // 
            // buffBarGroupBox
            // 
            this.buffBarGroupBox.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.buffBarGroupBox.Controls.Add(this.showBuffDebuffTimeType);
            this.buffBarGroupBox.Controls.Add(this.lblShowBuffTime);
            this.buffBarGroupBox.Controls.Add(this.useBlackBuffDebuffBg);
            this.buffBarGroupBox.Controls.Add(this.buffBarHeight);
            this.buffBarGroupBox.Controls.Add(this.lblBuffBarHeight);
            this.buffBarGroupBox.Controls.Add(this.buffBarSort);
            this.buffBarGroupBox.Controls.Add(this.lblBuffSortBy);
            this.buffBarGroupBox.Controls.Add(this.buffBarWidth);
            this.buffBarGroupBox.Controls.Add(this.lblBuffBarWidth);
            this.buffBarGroupBox.Controls.Add(this.showBuffIcons);
            this.buffBarGroupBox.Controls.Add(this.showBuffDebuffGump);
            this.buffBarGroupBox.Location = new System.Drawing.Point(252, 12);
            this.buffBarGroupBox.Name = "buffBarGroupBox";
            this.buffBarGroupBox.Size = new System.Drawing.Size(235, 263);
            this.buffBarGroupBox.TabIndex = 132;
            this.buffBarGroupBox.TabStop = false;
            this.buffBarGroupBox.Text = "Buff/Debuff Gump:";
            // 
            // showBuffDebuffTimeType
            // 
            this.showBuffDebuffTimeType.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.showBuffDebuffTimeType.FormattingEnabled = true;
            this.showBuffDebuffTimeType.Items.AddRange(new object[] {
            "Next to name",
            "Outside of bar",
            "Right side of bar",
            "Under Icon",
            "None"});
            this.showBuffDebuffTimeType.Location = new System.Drawing.Point(84, 112);
            this.showBuffDebuffTimeType.Name = "showBuffDebuffTimeType";
            this.showBuffDebuffTimeType.Size = new System.Drawing.Size(126, 23);
            this.showBuffDebuffTimeType.TabIndex = 12;
            this.showBuffDebuffTimeType.SelectedIndexChanged += new System.EventHandler(this.showBuffDebuffTimeType_SelectedIndexChanged);
            // 
            // lblShowBuffTime
            // 
            this.lblShowBuffTime.AutoSize = true;
            this.lblShowBuffTime.Location = new System.Drawing.Point(12, 115);
            this.lblShowBuffTime.Name = "lblShowBuffTime";
            this.lblShowBuffTime.Size = new System.Drawing.Size(66, 15);
            this.lblShowBuffTime.TabIndex = 11;
            this.lblShowBuffTime.Text = "Show time:";
            // 
            // useBlackBuffDebuffBg
            // 
            this.useBlackBuffDebuffBg.AutoSize = true;
            this.useBlackBuffDebuffBg.Location = new System.Drawing.Point(15, 87);
            this.useBlackBuffDebuffBg.Name = "useBlackBuffDebuffBg";
            this.useBlackBuffDebuffBg.Size = new System.Drawing.Size(143, 19);
            this.useBlackBuffDebuffBg.TabIndex = 9;
            this.useBlackBuffDebuffBg.Text = "Use black background";
            this.useBlackBuffDebuffBg.UseVisualStyleBackColor = true;
            this.useBlackBuffDebuffBg.CheckedChanged += new System.EventHandler(this.useBlackBuffDebuffBg_CheckedChanged);
            // 
            // buffBarHeight
            // 
            this.buffBarHeight.Location = new System.Drawing.Point(78, 159);
            this.buffBarHeight.Name = "buffBarHeight";
            this.buffBarHeight.Size = new System.Drawing.Size(36, 23);
            this.buffBarHeight.TabIndex = 8;
            this.buffBarHeight.TextChanged += new System.EventHandler(this.buffBarHeight_TextChanged);
            // 
            // lblBuffBarHeight
            // 
            this.lblBuffBarHeight.AutoSize = true;
            this.lblBuffBarHeight.Location = new System.Drawing.Point(12, 162);
            this.lblBuffBarHeight.Name = "lblBuffBarHeight";
            this.lblBuffBarHeight.Size = new System.Drawing.Size(64, 15);
            this.lblBuffBarHeight.TabIndex = 7;
            this.lblBuffBarHeight.Text = "Bar height:";
            // 
            // buffBarSort
            // 
            this.buffBarSort.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.buffBarSort.FormattingEnabled = true;
            this.buffBarSort.Items.AddRange(new object[] {
            "Alphabetical (A-Z)",
            "Ascending by time",
            "Descending by time"});
            this.buffBarSort.Location = new System.Drawing.Point(65, 223);
            this.buffBarSort.Name = "buffBarSort";
            this.buffBarSort.Size = new System.Drawing.Size(145, 23);
            this.buffBarSort.TabIndex = 6;
            this.buffBarSort.SelectedIndexChanged += new System.EventHandler(this.buffBarSort_SelectedIndexChanged);
            // 
            // lblBuffSortBy
            // 
            this.lblBuffSortBy.AutoSize = true;
            this.lblBuffSortBy.Location = new System.Drawing.Point(12, 226);
            this.lblBuffSortBy.Name = "lblBuffSortBy";
            this.lblBuffSortBy.Size = new System.Drawing.Size(47, 15);
            this.lblBuffSortBy.TabIndex = 5;
            this.lblBuffSortBy.Text = "Sort by:";
            // 
            // buffBarWidth
            // 
            this.buffBarWidth.Location = new System.Drawing.Point(78, 187);
            this.buffBarWidth.Name = "buffBarWidth";
            this.buffBarWidth.Size = new System.Drawing.Size(36, 23);
            this.buffBarWidth.TabIndex = 4;
            this.buffBarWidth.TextChanged += new System.EventHandler(this.buffBarWidth_TextChanged);
            // 
            // lblBuffBarWidth
            // 
            this.lblBuffBarWidth.AutoSize = true;
            this.lblBuffBarWidth.Location = new System.Drawing.Point(12, 190);
            this.lblBuffBarWidth.Name = "lblBuffBarWidth";
            this.lblBuffBarWidth.Size = new System.Drawing.Size(60, 15);
            this.lblBuffBarWidth.TabIndex = 3;
            this.lblBuffBarWidth.Text = "Bar width:";
            // 
            // showBuffIcons
            // 
            this.showBuffIcons.AutoSize = true;
            this.showBuffIcons.Location = new System.Drawing.Point(15, 62);
            this.showBuffIcons.Name = "showBuffIcons";
            this.showBuffIcons.Size = new System.Drawing.Size(151, 19);
            this.showBuffIcons.TabIndex = 1;
            this.showBuffIcons.Text = "Show buff/debuff icons";
            this.showBuffIcons.UseVisualStyleBackColor = true;
            this.showBuffIcons.CheckedChanged += new System.EventHandler(this.showBuffIcons_CheckedChanged);
            // 
            // showBuffDebuffGump
            // 
            this.showBuffDebuffGump.AutoSize = true;
            this.showBuffDebuffGump.Location = new System.Drawing.Point(15, 22);
            this.showBuffDebuffGump.Name = "showBuffDebuffGump";
            this.showBuffDebuffGump.Size = new System.Drawing.Size(155, 19);
            this.showBuffDebuffGump.TabIndex = 0;
            this.showBuffDebuffGump.Text = "Show buff/debuff gump";
            this.showBuffDebuffGump.UseVisualStyleBackColor = true;
            this.showBuffDebuffGump.CheckedChanged += new System.EventHandler(this.showBuffDebuffGump_CheckedChanged);
            // 
            // buffDebuffOptions
            // 
            this.buffDebuffOptions.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.buffDebuffOptions.Location = new System.Drawing.Point(26, 37);
            this.buffDebuffOptions.Name = "buffDebuffOptions";
            this.buffDebuffOptions.Size = new System.Drawing.Size(140, 30);
            this.buffDebuffOptions.TabIndex = 131;
            this.buffDebuffOptions.Text = "Buff / Debuff Options";
            this.buffDebuffOptions.UseVisualStyleBackColor = true;
            this.buffDebuffOptions.Click += new System.EventHandler(this.buffDebuffOptions_Click);
            // 
            // showBuffDebuffOverhead
            // 
            this.showBuffDebuffOverhead.AutoSize = true;
            this.showBuffDebuffOverhead.Location = new System.Drawing.Point(14, 12);
            this.showBuffDebuffOverhead.Name = "showBuffDebuffOverhead";
            this.showBuffDebuffOverhead.Size = new System.Drawing.Size(172, 19);
            this.showBuffDebuffOverhead.TabIndex = 130;
            this.showBuffDebuffOverhead.Text = "Show buff/debuff overhead";
            this.showBuffDebuffOverhead.UseVisualStyleBackColor = true;
            this.showBuffDebuffOverhead.CheckedChanged += new System.EventHandler(this.showBuffDebuffOverhead_CheckedChanged);
            // 
            // dressTab
            // 
            this.dressTab.Controls.Add(this.groupBox6);
            this.dressTab.Controls.Add(this.groupBox5);
            this.dressTab.Location = new System.Drawing.Point(4, 24);
            this.dressTab.Name = "dressTab";
            this.dressTab.Size = new System.Drawing.Size(519, 342);
            this.dressTab.TabIndex = 3;
            this.dressTab.Text = "Arm/Dress";
            // 
            // groupBox6
            // 
            this.groupBox6.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.groupBox6.Controls.Add(this.clearDress);
            this.groupBox6.Controls.Add(this.dressDelSel);
            this.groupBox6.Controls.Add(this.undressBag);
            this.groupBox6.Controls.Add(this.undressList);
            this.groupBox6.Controls.Add(this.dressUseCur);
            this.groupBox6.Controls.Add(this.targItem);
            this.groupBox6.Controls.Add(this.dressItems);
            this.groupBox6.Controls.Add(this.dressNow);
            this.groupBox6.Location = new System.Drawing.Point(201, 3);
            this.groupBox6.Name = "groupBox6";
            this.groupBox6.Size = new System.Drawing.Size(311, 329);
            this.groupBox6.TabIndex = 7;
            this.groupBox6.TabStop = false;
            this.groupBox6.Text = "Arm/Dress Items";
            // 
            // clearDress
            // 
            this.clearDress.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.clearDress.Location = new System.Drawing.Point(209, 257);
            this.clearDress.Name = "clearDress";
            this.clearDress.Size = new System.Drawing.Size(96, 32);
            this.clearDress.TabIndex = 13;
            this.clearDress.Text = "Clear List";
            this.clearDress.Click += new System.EventHandler(this.clearDress_Click);
            // 
            // dressDelSel
            // 
            this.dressDelSel.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.dressDelSel.Location = new System.Drawing.Point(209, 170);
            this.dressDelSel.Name = "dressDelSel";
            this.dressDelSel.Size = new System.Drawing.Size(96, 32);
            this.dressDelSel.TabIndex = 12;
            this.dressDelSel.Text = "Remove";
            this.dressDelSel.Click += new System.EventHandler(this.dressDelSel_Click);
            // 
            // undressBag
            // 
            this.undressBag.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.undressBag.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.undressBag.Location = new System.Drawing.Point(209, 208);
            this.undressBag.Name = "undressBag";
            this.undressBag.Size = new System.Drawing.Size(96, 40);
            this.undressBag.TabIndex = 11;
            this.undressBag.Text = "Change Undress Bag";
            this.undressBag.Click += new System.EventHandler(this.undressBag_Click);
            // 
            // undressList
            // 
            this.undressList.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.undressList.Location = new System.Drawing.Point(209, 56);
            this.undressList.Name = "undressList";
            this.undressList.Size = new System.Drawing.Size(96, 32);
            this.undressList.TabIndex = 10;
            this.undressList.Text = "Undress";
            this.undressList.Click += new System.EventHandler(this.undressList_Click);
            // 
            // dressUseCur
            // 
            this.dressUseCur.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.dressUseCur.Location = new System.Drawing.Point(209, 132);
            this.dressUseCur.Name = "dressUseCur";
            this.dressUseCur.Size = new System.Drawing.Size(96, 32);
            this.dressUseCur.TabIndex = 9;
            this.dressUseCur.Text = "Add Current";
            this.dressUseCur.Click += new System.EventHandler(this.dressUseCur_Click);
            // 
            // targItem
            // 
            this.targItem.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.targItem.Location = new System.Drawing.Point(209, 94);
            this.targItem.Name = "targItem";
            this.targItem.Size = new System.Drawing.Size(96, 32);
            this.targItem.TabIndex = 7;
            this.targItem.Text = "Add (Target)";
            this.targItem.Click += new System.EventHandler(this.targItem_Click);
            // 
            // dressItems
            // 
            this.dressItems.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.dressItems.IntegralHeight = false;
            this.dressItems.ItemHeight = 15;
            this.dressItems.Location = new System.Drawing.Point(6, 18);
            this.dressItems.Name = "dressItems";
            this.dressItems.Size = new System.Drawing.Size(197, 305);
            this.dressItems.TabIndex = 6;
            this.dressItems.KeyDown += new System.Windows.Forms.KeyEventHandler(this.dressItems_KeyDown);
            this.dressItems.MouseDown += new System.Windows.Forms.MouseEventHandler(this.dressItems_MouseDown);
            // 
            // dressNow
            // 
            this.dressNow.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.dressNow.Location = new System.Drawing.Point(209, 18);
            this.dressNow.Name = "dressNow";
            this.dressNow.Size = new System.Drawing.Size(96, 32);
            this.dressNow.TabIndex = 6;
            this.dressNow.Text = "Dress";
            this.dressNow.Click += new System.EventHandler(this.dressNow_Click);
            // 
            // groupBox5
            // 
            this.groupBox5.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left)));
            this.groupBox5.Controls.Add(this.removeDress);
            this.groupBox5.Controls.Add(this.addDress);
            this.groupBox5.Controls.Add(this.dressList);
            this.groupBox5.Controls.Add(this.undressConflicts);
            this.groupBox5.Location = new System.Drawing.Point(8, 3);
            this.groupBox5.Name = "groupBox5";
            this.groupBox5.Size = new System.Drawing.Size(187, 329);
            this.groupBox5.TabIndex = 6;
            this.groupBox5.TabStop = false;
            this.groupBox5.Text = "Arm/Dress Selection";
            // 
            // removeDress
            // 
            this.removeDress.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.removeDress.Location = new System.Drawing.Point(121, 274);
            this.removeDress.Name = "removeDress";
            this.removeDress.Size = new System.Drawing.Size(60, 25);
            this.removeDress.TabIndex = 5;
            this.removeDress.Text = "Remove";
            this.removeDress.Click += new System.EventHandler(this.removeDress_Click);
            // 
            // addDress
            // 
            this.addDress.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.addDress.Location = new System.Drawing.Point(6, 274);
            this.addDress.Name = "addDress";
            this.addDress.Size = new System.Drawing.Size(60, 25);
            this.addDress.TabIndex = 4;
            this.addDress.Text = "Add...";
            this.addDress.Click += new System.EventHandler(this.addDress_Click);
            // 
            // dressList
            // 
            this.dressList.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.dressList.IntegralHeight = false;
            this.dressList.ItemHeight = 15;
            this.dressList.Location = new System.Drawing.Point(6, 18);
            this.dressList.Name = "dressList";
            this.dressList.Size = new System.Drawing.Size(175, 250);
            this.dressList.TabIndex = 3;
            this.dressList.SelectedIndexChanged += new System.EventHandler(this.dressList_SelectedIndexChanged);
            // 
            // undressConflicts
            // 
            this.undressConflicts.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.undressConflicts.Location = new System.Drawing.Point(6, 305);
            this.undressConflicts.Name = "undressConflicts";
            this.undressConflicts.Size = new System.Drawing.Size(137, 18);
            this.undressConflicts.TabIndex = 6;
            this.undressConflicts.Text = "Auto-move conflicts";
            this.undressConflicts.CheckedChanged += new System.EventHandler(this.undressConflicts_CheckedChanged);
            // 
            // skillsTab
            // 
            this.skillsTab.Controls.Add(this.captureMibs);
            this.skillsTab.Controls.Add(this.dispDeltaOverhead);
            this.skillsTab.Controls.Add(this.logSkillChanges);
            this.skillsTab.Controls.Add(this.dispDelta);
            this.skillsTab.Controls.Add(this.skillCopyAll);
            this.skillsTab.Controls.Add(this.skillCopySel);
            this.skillsTab.Controls.Add(this.baseTotal);
            this.skillsTab.Controls.Add(this.label1);
            this.skillsTab.Controls.Add(this.locks);
            this.skillsTab.Controls.Add(this.setlocks);
            this.skillsTab.Controls.Add(this.resetDelta);
            this.skillsTab.Controls.Add(this.skillList);
            this.skillsTab.Location = new System.Drawing.Point(4, 24);
            this.skillsTab.Name = "skillsTab";
            this.skillsTab.Size = new System.Drawing.Size(519, 342);
            this.skillsTab.TabIndex = 2;
            this.skillsTab.Text = "Skills";
            // 
            // captureMibs
            // 
            this.captureMibs.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.captureMibs.Location = new System.Drawing.Point(356, 230);
            this.captureMibs.Name = "captureMibs";
            this.captureMibs.Size = new System.Drawing.Size(153, 19);
            this.captureMibs.TabIndex = 70;
            this.captureMibs.Text = "Capture MIBs to file";
            this.captureMibs.UseVisualStyleBackColor = true;
            this.captureMibs.CheckedChanged += new System.EventHandler(this.captureMibs_CheckedChanged);
            // 
            // dispDeltaOverhead
            // 
            this.dispDeltaOverhead.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.dispDeltaOverhead.AutoSize = true;
            this.dispDeltaOverhead.Font = new System.Drawing.Font("Segoe UI", 8.25F, System.Drawing.FontStyle.Italic, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.dispDeltaOverhead.Location = new System.Drawing.Point(441, 207);
            this.dispDeltaOverhead.Name = "dispDeltaOverhead";
            this.dispDeltaOverhead.Size = new System.Drawing.Size(71, 17);
            this.dispDeltaOverhead.TabIndex = 14;
            this.dispDeltaOverhead.Text = "Overhead";
            this.dispDeltaOverhead.UseVisualStyleBackColor = true;
            this.dispDeltaOverhead.CheckedChanged += new System.EventHandler(this.dispDeltaOverhead_CheckedChanged);
            // 
            // logSkillChanges
            // 
            this.logSkillChanges.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.logSkillChanges.Location = new System.Drawing.Point(356, 157);
            this.logSkillChanges.Name = "logSkillChanges";
            this.logSkillChanges.Size = new System.Drawing.Size(156, 19);
            this.logSkillChanges.TabIndex = 13;
            this.logSkillChanges.Text = "Log skill changes";
            this.logSkillChanges.UseVisualStyleBackColor = true;
            this.logSkillChanges.CheckedChanged += new System.EventHandler(this.logSkillChanges_CheckedChanged);
            // 
            // dispDelta
            // 
            this.dispDelta.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.dispDelta.Location = new System.Drawing.Point(356, 182);
            this.dispDelta.Name = "dispDelta";
            this.dispDelta.Size = new System.Drawing.Size(156, 19);
            this.dispDelta.TabIndex = 11;
            this.dispDelta.Text = "Show skill/stat changes";
            this.dispDelta.CheckedChanged += new System.EventHandler(this.dispDelta_CheckedChanged);
            // 
            // skillCopyAll
            // 
            this.skillCopyAll.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.skillCopyAll.Location = new System.Drawing.Point(356, 119);
            this.skillCopyAll.Name = "skillCopyAll";
            this.skillCopyAll.Size = new System.Drawing.Size(156, 32);
            this.skillCopyAll.TabIndex = 9;
            this.skillCopyAll.Text = "Copy All";
            this.skillCopyAll.Click += new System.EventHandler(this.skillCopyAll_Click);
            // 
            // skillCopySel
            // 
            this.skillCopySel.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.skillCopySel.Location = new System.Drawing.Point(356, 81);
            this.skillCopySel.Name = "skillCopySel";
            this.skillCopySel.Size = new System.Drawing.Size(156, 32);
            this.skillCopySel.TabIndex = 8;
            this.skillCopySel.Text = "Copy Selected";
            this.skillCopySel.Click += new System.EventHandler(this.skillCopySel_Click);
            // 
            // baseTotal
            // 
            this.baseTotal.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
            this.baseTotal.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.baseTotal.Location = new System.Drawing.Point(428, 310);
            this.baseTotal.Name = "baseTotal";
            this.baseTotal.ReadOnly = true;
            this.baseTotal.Size = new System.Drawing.Size(84, 23);
            this.baseTotal.TabIndex = 7;
            this.baseTotal.TextAlign = System.Windows.Forms.HorizontalAlignment.Center;
            // 
            // label1
            // 
            this.label1.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
            this.label1.Location = new System.Drawing.Point(356, 309);
            this.label1.Name = "label1";
            this.label1.Size = new System.Drawing.Size(75, 23);
            this.label1.TabIndex = 6;
            this.label1.Text = "Base Total:";
            this.label1.TextAlign = System.Drawing.ContentAlignment.MiddleLeft;
            // 
            // locks
            // 
            this.locks.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.locks.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.locks.Items.AddRange(new object[] {
            "Up",
            "Down",
            "Locked"});
            this.locks.Location = new System.Drawing.Point(468, 49);
            this.locks.Name = "locks";
            this.locks.Size = new System.Drawing.Size(44, 23);
            this.locks.TabIndex = 5;
            // 
            // setlocks
            // 
            this.setlocks.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.setlocks.Location = new System.Drawing.Point(356, 43);
            this.setlocks.Name = "setlocks";
            this.setlocks.Size = new System.Drawing.Size(106, 32);
            this.setlocks.TabIndex = 4;
            this.setlocks.Text = "Set all locks:";
            this.setlocks.Click += new System.EventHandler(this.OnSetSkillLocks);
            // 
            // resetDelta
            // 
            this.resetDelta.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.resetDelta.Location = new System.Drawing.Point(356, 5);
            this.resetDelta.Name = "resetDelta";
            this.resetDelta.Size = new System.Drawing.Size(156, 32);
            this.resetDelta.TabIndex = 3;
            this.resetDelta.Text = "Reset  +/-";
            this.resetDelta.Click += new System.EventHandler(this.OnResetSkillDelta);
            // 
            // skillList
            // 
            this.skillList.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.skillList.AutoArrange = false;
            this.skillList.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] {
            this.skillHDRName,
            this.skillHDRvalue,
            this.skillHDRbase,
            this.skillHDRdelta,
            this.skillHDRcap,
            this.skillHDRlock});
            this.skillList.FullRowSelect = true;
            this.skillList.HideSelection = false;
            this.skillList.Location = new System.Drawing.Point(8, 5);
            this.skillList.Name = "skillList";
            this.skillList.Size = new System.Drawing.Size(342, 327);
            this.skillList.TabIndex = 1;
            this.skillList.UseCompatibleStateImageBehavior = false;
            this.skillList.View = System.Windows.Forms.View.Details;
            this.skillList.ColumnClick += new System.Windows.Forms.ColumnClickEventHandler(this.OnSkillColClick);
            this.skillList.MouseDown += new System.Windows.Forms.MouseEventHandler(this.skillList_MouseDown);
            // 
            // skillHDRName
            // 
            this.skillHDRName.Text = "Skill Name";
            this.skillHDRName.Width = 112;
            // 
            // skillHDRvalue
            // 
            this.skillHDRvalue.Text = "Value";
            this.skillHDRvalue.Width = 46;
            // 
            // skillHDRbase
            // 
            this.skillHDRbase.Text = "Base";
            this.skillHDRbase.Width = 43;
            // 
            // skillHDRdelta
            // 
            this.skillHDRdelta.Text = "+/-";
            this.skillHDRdelta.Width = 40;
            // 
            // skillHDRcap
            // 
            this.skillHDRcap.Text = "Cap";
            this.skillHDRcap.Width = 40;
            // 
            // skillHDRlock
            // 
            this.skillHDRlock.Text = "Lock";
            this.skillHDRlock.Width = 40;
            // 
            // agentsTab
            // 
            this.agentsTab.Controls.Add(this.agentSetHotKey);
            this.agentsTab.Controls.Add(this.agentB6);
            this.agentsTab.Controls.Add(this.agentB5);
            this.agentsTab.Controls.Add(this.agentList);
            this.agentsTab.Controls.Add(this.agentGroup);
            this.agentsTab.Controls.Add(this.agentB4);
            this.agentsTab.Controls.Add(this.agentB1);
            this.agentsTab.Controls.Add(this.agentB2);
            this.agentsTab.Controls.Add(this.agentB3);
            this.agentsTab.Location = new System.Drawing.Point(4, 24);
            this.agentsTab.Name = "agentsTab";
            this.agentsTab.Size = new System.Drawing.Size(519, 342);
            this.agentsTab.TabIndex = 6;
            this.agentsTab.Text = "Agents";
            // 
            // agentSetHotKey
            // 
            this.agentSetHotKey.Location = new System.Drawing.Point(8, 274);
            this.agentSetHotKey.Name = "agentSetHotKey";
            this.agentSetHotKey.Size = new System.Drawing.Size(130, 32);
            this.agentSetHotKey.TabIndex = 7;
            this.agentSetHotKey.Text = "Set Hot Key";
            this.agentSetHotKey.Visible = false;
            this.agentSetHotKey.Click += new System.EventHandler(this.agentSetHotKey_Click);
            // 
            // agentB6
            // 
            this.agentB6.Location = new System.Drawing.Point(8, 231);
            this.agentB6.Name = "agentB6";
            this.agentB6.Size = new System.Drawing.Size(130, 32);
            this.agentB6.TabIndex = 6;
            this.agentB6.Click += new System.EventHandler(this.agentB6_Click);
            // 
            // agentB5
            // 
            this.agentB5.Location = new System.Drawing.Point(8, 193);
            this.agentB5.Name = "agentB5";
            this.agentB5.Size = new System.Drawing.Size(130, 32);
            this.agentB5.TabIndex = 5;
            this.agentB5.Click += new System.EventHandler(this.agentB5_Click);
            // 
            // agentList
            // 
            this.agentList.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.agentList.Location = new System.Drawing.Point(8, 14);
            this.agentList.Name = "agentList";
            this.agentList.Size = new System.Drawing.Size(130, 23);
            this.agentList.TabIndex = 2;
            this.agentList.SelectedIndexChanged += new System.EventHandler(this.agentList_SelectedIndexChanged);
            this.agentList.MouseDown += new System.Windows.Forms.MouseEventHandler(this.agentList_MouseDown);
            // 
            // agentGroup
            // 
            this.agentGroup.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.agentGroup.Controls.Add(this.agentSubList);
            this.agentGroup.Location = new System.Drawing.Point(144, 3);
            this.agentGroup.Name = "agentGroup";
            this.agentGroup.Size = new System.Drawing.Size(368, 329);
            this.agentGroup.TabIndex = 1;
            this.agentGroup.TabStop = false;
            // 
            // agentSubList
            // 
            this.agentSubList.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.agentSubList.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.agentSubList.IntegralHeight = false;
            this.agentSubList.ItemHeight = 15;
            this.agentSubList.Location = new System.Drawing.Point(6, 22);
            this.agentSubList.Name = "agentSubList";
            this.agentSubList.Size = new System.Drawing.Size(356, 301);
            this.agentSubList.TabIndex = 0;
            this.agentSubList.MouseDown += new System.Windows.Forms.MouseEventHandler(this.agentSubList_MouseDown);
            // 
            // agentB4
            // 
            this.agentB4.Location = new System.Drawing.Point(8, 155);
            this.agentB4.Name = "agentB4";
            this.agentB4.Size = new System.Drawing.Size(130, 32);
            this.agentB4.TabIndex = 4;
            this.agentB4.Click += new System.EventHandler(this.agentB4_Click);
            // 
            // agentB1
            // 
            this.agentB1.Location = new System.Drawing.Point(8, 41);
            this.agentB1.Name = "agentB1";
            this.agentB1.Size = new System.Drawing.Size(130, 32);
            this.agentB1.TabIndex = 1;
            this.agentB1.Click += new System.EventHandler(this.agentB1_Click);
            // 
            // agentB2
            // 
            this.agentB2.Location = new System.Drawing.Point(8, 79);
            this.agentB2.Name = "agentB2";
            this.agentB2.Size = new System.Drawing.Size(130, 32);
            this.agentB2.TabIndex = 2;
            this.agentB2.Click += new System.EventHandler(this.agentB2_Click);
            // 
            // agentB3
            // 
            this.agentB3.Location = new System.Drawing.Point(8, 117);
            this.agentB3.Name = "agentB3";
            this.agentB3.Size = new System.Drawing.Size(130, 32);
            this.agentB3.TabIndex = 3;
            this.agentB3.Click += new System.EventHandler(this.agentB3_Click);
            // 
            // filtersTab
            // 
            this.filtersTab.BackColor = System.Drawing.SystemColors.Control;
            this.filtersTab.Controls.Add(this.filterTabs);
            this.filtersTab.Location = new System.Drawing.Point(4, 24);
            this.filtersTab.Name = "filtersTab";
            this.filtersTab.Size = new System.Drawing.Size(519, 342);
            this.filtersTab.TabIndex = 15;
            this.filtersTab.Text = "Filters";
            // 
            // filterTabs
            // 
            this.filterTabs.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.filterTabs.Controls.Add(this.subFilterTab);
            this.filterTabs.Controls.Add(this.subFilterText);
            this.filterTabs.Controls.Add(this.subFilterSoundMusic);
            this.filterTabs.Controls.Add(this.subFilterTargets);
            this.filterTabs.Location = new System.Drawing.Point(6, 3);
            this.filterTabs.Name = "filterTabs";
            this.filterTabs.SelectedIndex = 0;
            this.filterTabs.Size = new System.Drawing.Size(506, 333);
            this.filterTabs.TabIndex = 1;
            this.filterTabs.SelectedIndexChanged += new System.EventHandler(this.filterTabs_IndexChanged);
            // 
            // subFilterTab
            // 
            this.subFilterTab.BackColor = System.Drawing.SystemColors.Control;
            this.subFilterTab.Controls.Add(this.wyrmAnimationList);
            this.subFilterTab.Controls.Add(this.filterWhiteWyrm);
            this.subFilterTab.Controls.Add(this.daemonAnimationList);
            this.subFilterTab.Controls.Add(this.filterDaemonGraphics);
            this.subFilterTab.Controls.Add(this.drakeAnimationList);
            this.subFilterTab.Controls.Add(this.filterDrakeGraphics);
            this.subFilterTab.Controls.Add(this.dragonAnimationList);
            this.subFilterTab.Controls.Add(this.filterDragonGraphics);
            this.subFilterTab.Controls.Add(this.filters);
            this.subFilterTab.Location = new System.Drawing.Point(4, 24);
            this.subFilterTab.Name = "subFilterTab";
            this.subFilterTab.Padding = new System.Windows.Forms.Padding(3);
            this.subFilterTab.Size = new System.Drawing.Size(498, 305);
            this.subFilterTab.TabIndex = 0;
            this.subFilterTab.Text = "General";
            // 
            // wyrmAnimationList
            // 
            this.wyrmAnimationList.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.wyrmAnimationList.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.wyrmAnimationList.DropDownWidth = 250;
            this.wyrmAnimationList.FormattingEnabled = true;
            this.wyrmAnimationList.Location = new System.Drawing.Point(313, 93);
            this.wyrmAnimationList.Name = "wyrmAnimationList";
            this.wyrmAnimationList.Size = new System.Drawing.Size(163, 23);
            this.wyrmAnimationList.TabIndex = 129;
            this.wyrmAnimationList.SelectedIndexChanged += new System.EventHandler(this.wyrmAnimationList_SelectedIndexChanged);
            // 
            // filterWhiteWyrm
            // 
            this.filterWhiteWyrm.AutoSize = true;
            this.filterWhiteWyrm.Location = new System.Drawing.Point(209, 95);
            this.filterWhiteWyrm.Name = "filterWhiteWyrm";
            this.filterWhiteWyrm.Size = new System.Drawing.Size(90, 19);
            this.filterWhiteWyrm.TabIndex = 128;
            this.filterWhiteWyrm.Text = "Filter wyrms";
            this.filterWhiteWyrm.UseVisualStyleBackColor = true;
            this.filterWhiteWyrm.CheckedChanged += new System.EventHandler(this.filterWhiteWyrm_CheckedChanged);
            // 
            // daemonAnimationList
            // 
            this.daemonAnimationList.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.daemonAnimationList.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.daemonAnimationList.DropDownWidth = 250;
            this.daemonAnimationList.FormattingEnabled = true;
            this.daemonAnimationList.Location = new System.Drawing.Point(313, 64);
            this.daemonAnimationList.Name = "daemonAnimationList";
            this.daemonAnimationList.Size = new System.Drawing.Size(163, 23);
            this.daemonAnimationList.TabIndex = 127;
            this.daemonAnimationList.SelectedIndexChanged += new System.EventHandler(this.daemonAnimationList_SelectedIndexChanged);
            // 
            // filterDaemonGraphics
            // 
            this.filterDaemonGraphics.AutoSize = true;
            this.filterDaemonGraphics.Location = new System.Drawing.Point(209, 66);
            this.filterDaemonGraphics.Name = "filterDaemonGraphics";
            this.filterDaemonGraphics.Size = new System.Drawing.Size(104, 19);
            this.filterDaemonGraphics.TabIndex = 126;
            this.filterDaemonGraphics.Text = "Filter daemons";
            this.filterDaemonGraphics.UseVisualStyleBackColor = true;
            this.filterDaemonGraphics.CheckedChanged += new System.EventHandler(this.filterDaemonGraphics_CheckedChanged);
            // 
            // drakeAnimationList
            // 
            this.drakeAnimationList.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.drakeAnimationList.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.drakeAnimationList.DropDownWidth = 250;
            this.drakeAnimationList.FormattingEnabled = true;
            this.drakeAnimationList.Location = new System.Drawing.Point(313, 35);
            this.drakeAnimationList.Name = "drakeAnimationList";
            this.drakeAnimationList.Size = new System.Drawing.Size(163, 23);
            this.drakeAnimationList.TabIndex = 118;
            this.drakeAnimationList.SelectedIndexChanged += new System.EventHandler(this.drakeAnimationList_SelectedIndexChanged);
            // 
            // filterDrakeGraphics
            // 
            this.filterDrakeGraphics.AutoSize = true;
            this.filterDrakeGraphics.Location = new System.Drawing.Point(209, 37);
            this.filterDrakeGraphics.Name = "filterDrakeGraphics";
            this.filterDrakeGraphics.Size = new System.Drawing.Size(89, 19);
            this.filterDrakeGraphics.TabIndex = 117;
            this.filterDrakeGraphics.Text = "Filter drakes";
            this.filterDrakeGraphics.UseVisualStyleBackColor = true;
            this.filterDrakeGraphics.CheckedChanged += new System.EventHandler(this.filterDrakeGraphics_CheckedChanged);
            // 
            // dragonAnimationList
            // 
            this.dragonAnimationList.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.dragonAnimationList.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.dragonAnimationList.DropDownWidth = 250;
            this.dragonAnimationList.FormattingEnabled = true;
            this.dragonAnimationList.Location = new System.Drawing.Point(313, 6);
            this.dragonAnimationList.Name = "dragonAnimationList";
            this.dragonAnimationList.Size = new System.Drawing.Size(163, 23);
            this.dragonAnimationList.TabIndex = 116;
            this.dragonAnimationList.SelectedIndexChanged += new System.EventHandler(this.dragonAnimationList_SelectedIndexChanged);
            // 
            // filterDragonGraphics
            // 
            this.filterDragonGraphics.AutoSize = true;
            this.filterDragonGraphics.Location = new System.Drawing.Point(209, 8);
            this.filterDragonGraphics.Name = "filterDragonGraphics";
            this.filterDragonGraphics.Size = new System.Drawing.Size(98, 19);
            this.filterDragonGraphics.TabIndex = 115;
            this.filterDragonGraphics.Text = "Filter dragons";
            this.filterDragonGraphics.UseVisualStyleBackColor = true;
            this.filterDragonGraphics.CheckedChanged += new System.EventHandler(this.filterDragonGraphics_CheckedChanged);
            // 
            // filters
            // 
            this.filters.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left)));
            this.filters.CheckOnClick = true;
            this.filters.IntegralHeight = false;
            this.filters.Location = new System.Drawing.Point(6, 6);
            this.filters.Name = "filters";
            this.filters.Size = new System.Drawing.Size(197, 261);
            this.filters.TabIndex = 114;
            this.filters.ItemCheck += new System.Windows.Forms.ItemCheckEventHandler(this.OnFilterCheck);
            // 
            // subFilterText
            // 
            this.subFilterText.BackColor = System.Drawing.SystemColors.Control;
            this.subFilterText.Controls.Add(this.gbFilterText);
            this.subFilterText.Controls.Add(this.gbFilterMessages);
            this.subFilterText.Location = new System.Drawing.Point(4, 22);
            this.subFilterText.Name = "subFilterText";
            this.subFilterText.Size = new System.Drawing.Size(498, 307);
            this.subFilterText.TabIndex = 4;
            this.subFilterText.Text = "Text && Messages  ";
            // 
            // gbFilterText
            // 
            this.gbFilterText.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left)));
            this.gbFilterText.Controls.Add(this.removeFilterText);
            this.gbFilterText.Controls.Add(this.addFilterText);
            this.gbFilterText.Controls.Add(this.textFilterList);
            this.gbFilterText.Controls.Add(this.enableTextFilter);
            this.gbFilterText.Location = new System.Drawing.Point(3, 3);
            this.gbFilterText.Name = "gbFilterText";
            this.gbFilterText.Size = new System.Drawing.Size(229, 241);
            this.gbFilterText.TabIndex = 134;
            this.gbFilterText.TabStop = false;
            this.gbFilterText.Text = "Text Filter";
            // 
            // removeFilterText
            // 
            this.removeFilterText.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.removeFilterText.Location = new System.Drawing.Point(148, 206);
            this.removeFilterText.Name = "removeFilterText";
            this.removeFilterText.Size = new System.Drawing.Size(75, 29);
            this.removeFilterText.TabIndex = 2;
            this.removeFilterText.Text = "Remove";
            this.removeFilterText.UseVisualStyleBackColor = true;
            this.removeFilterText.Click += new System.EventHandler(this.removeFilterText_Click);
            // 
            // addFilterText
            // 
            this.addFilterText.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.addFilterText.Location = new System.Drawing.Point(67, 206);
            this.addFilterText.Name = "addFilterText";
            this.addFilterText.Size = new System.Drawing.Size(75, 29);
            this.addFilterText.TabIndex = 1;
            this.addFilterText.Text = "Add";
            this.addFilterText.UseVisualStyleBackColor = true;
            this.addFilterText.Click += new System.EventHandler(this.addFilterText_Click);
            // 
            // textFilterList
            // 
            this.textFilterList.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left)));
            this.textFilterList.FormattingEnabled = true;
            this.textFilterList.ItemHeight = 15;
            this.textFilterList.Location = new System.Drawing.Point(6, 48);
            this.textFilterList.Name = "textFilterList";
            this.textFilterList.Size = new System.Drawing.Size(217, 64);
            this.textFilterList.TabIndex = 0;
            // 
            // enableTextFilter
            // 
            this.enableTextFilter.AutoSize = true;
            this.enableTextFilter.Location = new System.Drawing.Point(6, 22);
            this.enableTextFilter.Name = "enableTextFilter";
            this.enableTextFilter.Size = new System.Drawing.Size(111, 19);
            this.enableTextFilter.TabIndex = 3;
            this.enableTextFilter.Text = "Enable text filter";
            this.enableTextFilter.UseVisualStyleBackColor = true;
            this.enableTextFilter.CheckedChanged += new System.EventHandler(this.enableTextFilter_CheckedChanged);
            // 
            // gbFilterMessages
            // 
            this.gbFilterMessages.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.gbFilterMessages.Controls.Add(this.filterOverheadMessages);
            this.gbFilterMessages.Controls.Add(this.lblFilterDelaySeconds);
            this.gbFilterMessages.Controls.Add(this.lblFilterDelay);
            this.gbFilterMessages.Controls.Add(this.filterDelaySeconds);
            this.gbFilterMessages.Controls.Add(this.filterRazorMessages);
            this.gbFilterMessages.Controls.Add(this.filterSystemMessages);
            this.gbFilterMessages.Controls.Add(this.filterSnoop);
            this.gbFilterMessages.Location = new System.Drawing.Point(238, 3);
            this.gbFilterMessages.Name = "gbFilterMessages";
            this.gbFilterMessages.Size = new System.Drawing.Size(257, 241);
            this.gbFilterMessages.TabIndex = 133;
            this.gbFilterMessages.TabStop = false;
            this.gbFilterMessages.Text = "Filter Messages";
            // 
            // filterOverheadMessages
            // 
            this.filterOverheadMessages.Location = new System.Drawing.Point(6, 100);
            this.filterOverheadMessages.Name = "filterOverheadMessages";
            this.filterOverheadMessages.Size = new System.Drawing.Size(220, 20);
            this.filterOverheadMessages.TabIndex = 139;
            this.filterOverheadMessages.Text = "Filter repeating overhead messages";
            this.filterOverheadMessages.CheckedChanged += new System.EventHandler(this.filterOverheadMessages_CheckedChanged);
            // 
            // lblFilterDelaySeconds
            // 
            this.lblFilterDelaySeconds.Location = new System.Drawing.Point(143, 130);
            this.lblFilterDelaySeconds.Name = "lblFilterDelaySeconds";
            this.lblFilterDelaySeconds.Size = new System.Drawing.Size(59, 18);
            this.lblFilterDelaySeconds.TabIndex = 138;
            this.lblFilterDelaySeconds.Text = "seconds";
            // 
            // lblFilterDelay
            // 
            this.lblFilterDelay.AutoSize = true;
            this.lblFilterDelay.Location = new System.Drawing.Point(27, 130);
            this.lblFilterDelay.Name = "lblFilterDelay";
            this.lblFilterDelay.Size = new System.Drawing.Size(68, 15);
            this.lblFilterDelay.TabIndex = 137;
            this.lblFilterDelay.Text = "Filter Delay:";
            // 
            // filterDelaySeconds
            // 
            this.filterDelaySeconds.Location = new System.Drawing.Point(101, 127);
            this.filterDelaySeconds.Name = "filterDelaySeconds";
            this.filterDelaySeconds.Size = new System.Drawing.Size(36, 23);
            this.filterDelaySeconds.TabIndex = 136;
            this.filterDelaySeconds.Text = "3.5";
            this.filterDelaySeconds.TextAlign = System.Windows.Forms.HorizontalAlignment.Center;
            this.filterDelaySeconds.TextChanged += new System.EventHandler(this.filterDelaySeconds_TextChanged);
            // 
            // filterRazorMessages
            // 
            this.filterRazorMessages.Location = new System.Drawing.Point(6, 74);
            this.filterRazorMessages.Name = "filterRazorMessages";
            this.filterRazorMessages.Size = new System.Drawing.Size(220, 20);
            this.filterRazorMessages.TabIndex = 135;
            this.filterRazorMessages.Text = "Filter repeating Razor messages";
            this.filterRazorMessages.CheckedChanged += new System.EventHandler(this.filterRazorMessages_CheckedChanged);
            // 
            // filterSystemMessages
            // 
            this.filterSystemMessages.Location = new System.Drawing.Point(6, 48);
            this.filterSystemMessages.Name = "filterSystemMessages";
            this.filterSystemMessages.Size = new System.Drawing.Size(220, 20);
            this.filterSystemMessages.TabIndex = 134;
            this.filterSystemMessages.Text = "Filter repeating system messages";
            this.filterSystemMessages.CheckedChanged += new System.EventHandler(this.filterSystemMessages_CheckedChanged);
            // 
            // filterSnoop
            // 
            this.filterSnoop.Location = new System.Drawing.Point(6, 22);
            this.filterSnoop.Name = "filterSnoop";
            this.filterSnoop.Size = new System.Drawing.Size(220, 20);
            this.filterSnoop.TabIndex = 133;
            this.filterSnoop.Text = "Filter snooping messages";
            this.filterSnoop.CheckedChanged += new System.EventHandler(this.filterSnoop_CheckedChanged);
            // 
            // subFilterSoundMusic
            // 
            this.subFilterSoundMusic.BackColor = System.Drawing.SystemColors.Control;
            this.subFilterSoundMusic.Controls.Add(this.playableMusicList);
            this.subFilterSoundMusic.Controls.Add(this.playMusic);
            this.subFilterSoundMusic.Controls.Add(this.showPlayingMusic);
            this.subFilterSoundMusic.Controls.Add(this.showPlayingSoundInfo);
            this.subFilterSoundMusic.Controls.Add(this.showFilteredSound);
            this.subFilterSoundMusic.Controls.Add(this.playInClient);
            this.subFilterSoundMusic.Controls.Add(this.playSound);
            this.subFilterSoundMusic.Controls.Add(this.soundFilterEnabled);
            this.subFilterSoundMusic.Controls.Add(this.soundFilterList);
            this.subFilterSoundMusic.Location = new System.Drawing.Point(4, 22);
            this.subFilterSoundMusic.Name = "subFilterSoundMusic";
            this.subFilterSoundMusic.Size = new System.Drawing.Size(498, 307);
            this.subFilterSoundMusic.TabIndex = 3;
            this.subFilterSoundMusic.Text = "Sound & Music  ";
            // 
            // playableMusicList
            // 
            this.playableMusicList.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.playableMusicList.FormattingEnabled = true;
            this.playableMusicList.Location = new System.Drawing.Point(215, 151);
            this.playableMusicList.Name = "playableMusicList";
            this.playableMusicList.Size = new System.Drawing.Size(145, 23);
            this.playableMusicList.TabIndex = 8;
            // 
            // playMusic
            // 
            this.playMusic.Location = new System.Drawing.Point(215, 180);
            this.playMusic.Name = "playMusic";
            this.playMusic.Size = new System.Drawing.Size(132, 23);
            this.playMusic.TabIndex = 7;
            this.playMusic.Text = "Play Music In Client";
            this.playMusic.UseVisualStyleBackColor = true;
            this.playMusic.Click += new System.EventHandler(this.playMusic_Click);
            // 
            // showPlayingMusic
            // 
            this.showPlayingMusic.AutoSize = true;
            this.showPlayingMusic.Location = new System.Drawing.Point(215, 215);
            this.showPlayingMusic.Name = "showPlayingMusic";
            this.showPlayingMusic.Size = new System.Drawing.Size(156, 19);
            this.showPlayingMusic.TabIndex = 6;
            this.showPlayingMusic.Text = "Show playing music info";
            this.showPlayingMusic.UseVisualStyleBackColor = true;
            this.showPlayingMusic.CheckedChanged += new System.EventHandler(this.showPlayingMusic_CheckedChanged);
            // 
            // showPlayingSoundInfo
            // 
            this.showPlayingSoundInfo.AutoSize = true;
            this.showPlayingSoundInfo.Location = new System.Drawing.Point(215, 106);
            this.showPlayingSoundInfo.Name = "showPlayingSoundInfo";
            this.showPlayingSoundInfo.Size = new System.Drawing.Size(181, 19);
            this.showPlayingSoundInfo.TabIndex = 5;
            this.showPlayingSoundInfo.Text = "Show non-filtered sound info";
            this.showPlayingSoundInfo.UseVisualStyleBackColor = true;
            this.showPlayingSoundInfo.CheckedChanged += new System.EventHandler(this.showPlayingSoundInfo_CheckedChanged);
            // 
            // showFilteredSound
            // 
            this.showFilteredSound.AutoSize = true;
            this.showFilteredSound.Location = new System.Drawing.Point(215, 81);
            this.showFilteredSound.Name = "showFilteredSound";
            this.showFilteredSound.Size = new System.Drawing.Size(155, 19);
            this.showFilteredSound.TabIndex = 4;
            this.showFilteredSound.Text = "Show filtered sound info";
            this.showFilteredSound.UseVisualStyleBackColor = true;
            this.showFilteredSound.CheckedChanged += new System.EventHandler(this.showFilteredSound_CheckedChanged);
            // 
            // playInClient
            // 
            this.playInClient.AutoSize = true;
            this.playInClient.Location = new System.Drawing.Point(348, 42);
            this.playInClient.Name = "playInClient";
            this.playInClient.Size = new System.Drawing.Size(93, 19);
            this.playInClient.TabIndex = 3;
            this.playInClient.Text = "Play in client";
            this.playInClient.UseVisualStyleBackColor = true;
            // 
            // playSound
            // 
            this.playSound.Location = new System.Drawing.Point(215, 39);
            this.playSound.Name = "playSound";
            this.playSound.Size = new System.Drawing.Size(127, 23);
            this.playSound.TabIndex = 2;
            this.playSound.Text = "Play Selected Sound";
            this.playSound.UseVisualStyleBackColor = true;
            this.playSound.Click += new System.EventHandler(this.playSound_Click);
            // 
            // soundFilterEnabled
            // 
            this.soundFilterEnabled.AutoSize = true;
            this.soundFilterEnabled.Location = new System.Drawing.Point(215, 14);
            this.soundFilterEnabled.Name = "soundFilterEnabled";
            this.soundFilterEnabled.Size = new System.Drawing.Size(127, 19);
            this.soundFilterEnabled.TabIndex = 1;
            this.soundFilterEnabled.Text = "Enable Sound Filter";
            this.soundFilterEnabled.UseVisualStyleBackColor = true;
            this.soundFilterEnabled.CheckedChanged += new System.EventHandler(this.soundFilterEnabled_CheckedChanged);
            // 
            // soundFilterList
            // 
            this.soundFilterList.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left)));
            this.soundFilterList.FormattingEnabled = true;
            this.soundFilterList.Location = new System.Drawing.Point(8, 14);
            this.soundFilterList.Name = "soundFilterList";
            this.soundFilterList.Size = new System.Drawing.Size(201, 130);
            this.soundFilterList.TabIndex = 0;
            this.soundFilterList.SelectedIndexChanged += new System.EventHandler(this.soundFilterList_SelectedIndexChanged);
            // 
            // subFilterTargets
            // 
            this.subFilterTargets.BackColor = System.Drawing.SystemColors.Control;
            this.subFilterTargets.Controls.Add(this.lblTargetFilter);
            this.subFilterTargets.Controls.Add(this.targetFilterClear);
            this.subFilterTargets.Controls.Add(this.targetFilterRemove);
            this.subFilterTargets.Controls.Add(this.targetFilterAdd);
            this.subFilterTargets.Controls.Add(this.targetFilter);
            this.subFilterTargets.Controls.Add(this.targetFilterEnabled);
            this.subFilterTargets.Location = new System.Drawing.Point(4, 22);
            this.subFilterTargets.Name = "subFilterTargets";
            this.subFilterTargets.Padding = new System.Windows.Forms.Padding(3);
            this.subFilterTargets.Size = new System.Drawing.Size(498, 307);
            this.subFilterTargets.TabIndex = 1;
            this.subFilterTargets.Text = "Target Filter";
            // 
            // lblTargetFilter
            // 
            this.lblTargetFilter.Location = new System.Drawing.Point(6, 84);
            this.lblTargetFilter.Name = "lblTargetFilter";
            this.lblTargetFilter.Size = new System.Drawing.Size(217, 52);
            this.lblTargetFilter.TabIndex = 18;
            this.lblTargetFilter.Text = "Targets added to this list will be ignored by Razor completely when using any tar" +
    "get hotkeys.";
            // 
            // targetFilterClear
            // 
            this.targetFilterClear.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
            this.targetFilterClear.Location = new System.Drawing.Point(415, 203);
            this.targetFilterClear.Name = "targetFilterClear";
            this.targetFilterClear.Size = new System.Drawing.Size(77, 29);
            this.targetFilterClear.TabIndex = 17;
            this.targetFilterClear.Text = "Clear List";
            this.targetFilterClear.UseVisualStyleBackColor = true;
            this.targetFilterClear.Click += new System.EventHandler(this.TargetFilterClear_Click);
            // 
            // targetFilterRemove
            // 
            this.targetFilterRemove.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
            this.targetFilterRemove.Location = new System.Drawing.Point(335, 203);
            this.targetFilterRemove.Name = "targetFilterRemove";
            this.targetFilterRemove.Size = new System.Drawing.Size(74, 29);
            this.targetFilterRemove.TabIndex = 16;
            this.targetFilterRemove.Text = "Remove";
            this.targetFilterRemove.UseVisualStyleBackColor = true;
            this.targetFilterRemove.Click += new System.EventHandler(this.TargetFilterRemove_Click);
            // 
            // targetFilterAdd
            // 
            this.targetFilterAdd.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
            this.targetFilterAdd.Location = new System.Drawing.Point(247, 203);
            this.targetFilterAdd.Name = "targetFilterAdd";
            this.targetFilterAdd.Size = new System.Drawing.Size(82, 29);
            this.targetFilterAdd.TabIndex = 15;
            this.targetFilterAdd.Text = "Add (Target)";
            this.targetFilterAdd.UseVisualStyleBackColor = true;
            this.targetFilterAdd.Click += new System.EventHandler(this.TargetFilterAdd_Click);
            // 
            // targetFilter
            // 
            this.targetFilter.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.targetFilter.FormattingEnabled = true;
            this.targetFilter.ItemHeight = 15;
            this.targetFilter.Location = new System.Drawing.Point(247, 6);
            this.targetFilter.Name = "targetFilter";
            this.targetFilter.Size = new System.Drawing.Size(245, 124);
            this.targetFilter.TabIndex = 14;
            // 
            // targetFilterEnabled
            // 
            this.targetFilterEnabled.AutoSize = true;
            this.targetFilterEnabled.Location = new System.Drawing.Point(6, 6);
            this.targetFilterEnabled.Name = "targetFilterEnabled";
            this.targetFilterEnabled.Size = new System.Drawing.Size(132, 19);
            this.targetFilterEnabled.TabIndex = 13;
            this.targetFilterEnabled.Text = "Target Filter Enabled";
            this.targetFilterEnabled.UseVisualStyleBackColor = true;
            this.targetFilterEnabled.CheckedChanged += new System.EventHandler(this.TargetFilterEnabled_CheckedChanged);
            // 
            // hotkeysTab
            // 
            this.hotkeysTab.Controls.Add(this.filterHotkeys);
            this.hotkeysTab.Controls.Add(this.label22);
            this.hotkeysTab.Controls.Add(this.hkStatus);
            this.hotkeysTab.Controls.Add(this.hotkeyTree);
            this.hotkeysTab.Controls.Add(this.dohotkey);
            this.hotkeysTab.Controls.Add(this.groupBox8);
            this.hotkeysTab.Location = new System.Drawing.Point(4, 24);
            this.hotkeysTab.Name = "hotkeysTab";
            this.hotkeysTab.Size = new System.Drawing.Size(519, 342);
            this.hotkeysTab.TabIndex = 4;
            this.hotkeysTab.Text = "Hot Keys";
            // 
            // filterHotkeys
            // 
            this.filterHotkeys.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.filterHotkeys.Location = new System.Drawing.Point(50, 8);
            this.filterHotkeys.Name = "filterHotkeys";
            this.filterHotkeys.Size = new System.Drawing.Size(281, 23);
            this.filterHotkeys.TabIndex = 9;
            this.filterHotkeys.TextChanged += new System.EventHandler(this.filterHotkeys_TextChanged);
            // 
            // label22
            // 
            this.label22.AutoSize = true;
            this.label22.Location = new System.Drawing.Point(8, 11);
            this.label22.Name = "label22";
            this.label22.Size = new System.Drawing.Size(36, 15);
            this.label22.TabIndex = 8;
            this.label22.Text = "Filter:";
            // 
            // hkStatus
            // 
            this.hkStatus.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.hkStatus.Font = new System.Drawing.Font("Segoe UI", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.hkStatus.Location = new System.Drawing.Point(337, 226);
            this.hkStatus.Name = "hkStatus";
            this.hkStatus.Size = new System.Drawing.Size(175, 64);
            this.hkStatus.TabIndex = 7;
            this.hkStatus.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
            // 
            // hotkeyTree
            // 
            this.hotkeyTree.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.hotkeyTree.HideSelection = false;
            this.hotkeyTree.Location = new System.Drawing.Point(8, 37);
            this.hotkeyTree.Name = "hotkeyTree";
            this.hotkeyTree.Size = new System.Drawing.Size(323, 295);
            this.hotkeyTree.Sorted = true;
            this.hotkeyTree.TabIndex = 6;
            this.hotkeyTree.AfterSelect += new System.Windows.Forms.TreeViewEventHandler(this.hotkeyTree_AfterSelect);
            // 
            // dohotkey
            // 
            this.dohotkey.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.dohotkey.Location = new System.Drawing.Point(337, 170);
            this.dohotkey.Name = "dohotkey";
            this.dohotkey.Size = new System.Drawing.Size(175, 29);
            this.dohotkey.TabIndex = 5;
            this.dohotkey.Text = "Execute Selected Hot Key";
            this.dohotkey.Click += new System.EventHandler(this.dohotkey_Click);
            // 
            // groupBox8
            // 
            this.groupBox8.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.groupBox8.Controls.Add(this.hkCommand);
            this.groupBox8.Controls.Add(this.hkCmdLabel);
            this.groupBox8.Controls.Add(this.chkAlt);
            this.groupBox8.Controls.Add(this.chkPass);
            this.groupBox8.Controls.Add(this.label2);
            this.groupBox8.Controls.Add(this.unsetHK);
            this.groupBox8.Controls.Add(this.setHK);
            this.groupBox8.Controls.Add(this.hkKey);
            this.groupBox8.Controls.Add(this.chkCtrl);
            this.groupBox8.Controls.Add(this.chkShift);
            this.groupBox8.Location = new System.Drawing.Point(337, 8);
            this.groupBox8.Name = "groupBox8";
            this.groupBox8.Size = new System.Drawing.Size(175, 156);
            this.groupBox8.TabIndex = 4;
            this.groupBox8.TabStop = false;
            this.groupBox8.Text = "Hot Key";
            // 
            // hkCommand
            // 
            this.hkCommand.Location = new System.Drawing.Point(73, 73);
            this.hkCommand.Name = "hkCommand";
            this.hkCommand.Size = new System.Drawing.Size(96, 23);
            this.hkCommand.TabIndex = 11;
            // 
            // hkCmdLabel
            // 
            this.hkCmdLabel.Location = new System.Drawing.Point(8, 76);
            this.hkCmdLabel.Name = "hkCmdLabel";
            this.hkCmdLabel.Size = new System.Drawing.Size(68, 20);
            this.hkCmdLabel.TabIndex = 10;
            this.hkCmdLabel.Text = "Command";
            // 
            // chkAlt
            // 
            this.chkAlt.Location = new System.Drawing.Point(58, 20);
            this.chkAlt.Name = "chkAlt";
            this.chkAlt.Size = new System.Drawing.Size(49, 16);
            this.chkAlt.TabIndex = 2;
            this.chkAlt.Text = "Alt";
            // 
            // chkPass
            // 
            this.chkPass.Location = new System.Drawing.Point(11, 102);
            this.chkPass.Name = "chkPass";
            this.chkPass.Size = new System.Drawing.Size(113, 16);
            this.chkPass.TabIndex = 9;
            this.chkPass.Text = "Pass to UO";
            // 
            // label2
            // 
            this.label2.Location = new System.Drawing.Point(8, 44);
            this.label2.Name = "label2";
            this.label2.Size = new System.Drawing.Size(28, 20);
            this.label2.TabIndex = 8;
            this.label2.Text = "Key:";
            // 
            // unsetHK
            // 
            this.unsetHK.Location = new System.Drawing.Point(11, 124);
            this.unsetHK.Name = "unsetHK";
            this.unsetHK.Size = new System.Drawing.Size(56, 26);
            this.unsetHK.TabIndex = 6;
            this.unsetHK.Text = "Unset";
            this.unsetHK.Click += new System.EventHandler(this.unsetHK_Click);
            // 
            // setHK
            // 
            this.setHK.Location = new System.Drawing.Point(113, 124);
            this.setHK.Name = "setHK";
            this.setHK.Size = new System.Drawing.Size(56, 26);
            this.setHK.TabIndex = 5;
            this.setHK.Text = "Set";
            this.setHK.Click += new System.EventHandler(this.setHK_Click);
            // 
            // hkKey
            // 
            this.hkKey.Location = new System.Drawing.Point(36, 40);
            this.hkKey.Name = "hkKey";
            this.hkKey.ReadOnly = true;
            this.hkKey.Size = new System.Drawing.Size(133, 23);
            this.hkKey.TabIndex = 4;
            this.hkKey.TextAlign = System.Windows.Forms.HorizontalAlignment.Center;
            this.hkKey.KeyUp += new System.Windows.Forms.KeyEventHandler(this.key_KeyUp);
            this.hkKey.MouseDown += new System.Windows.Forms.MouseEventHandler(this.key_MouseDown);
            this.hkKey.MouseWheel += new System.Windows.Forms.MouseEventHandler(this.key_MouseWheel);
            // 
            // chkCtrl
            // 
            this.chkCtrl.Location = new System.Drawing.Point(8, 20);
            this.chkCtrl.Name = "chkCtrl";
            this.chkCtrl.Size = new System.Drawing.Size(56, 16);
            this.chkCtrl.TabIndex = 1;
            this.chkCtrl.Text = "Ctrl";
            // 
            // chkShift
            // 
            this.chkShift.Location = new System.Drawing.Point(113, 20);
            this.chkShift.Name = "chkShift";
            this.chkShift.Size = new System.Drawing.Size(56, 16);
            this.chkShift.TabIndex = 3;
            this.chkShift.Text = "Shift";
            // 
            // macrosTab
            // 
            this.macrosTab.Controls.Add(this.tabControl2);
            this.macrosTab.Location = new System.Drawing.Point(4, 44);
            this.macrosTab.Name = "macrosTab";
            this.macrosTab.Size = new System.Drawing.Size(519, 322);
            this.macrosTab.TabIndex = 7;
            this.macrosTab.Text = "Macros";
            // 
            // tabControl2
            // 
            this.tabControl2.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.tabControl2.Controls.Add(this.subMacrosTab);
            this.tabControl2.Controls.Add(this.subMacrosOptionsTab);
            this.tabControl2.Location = new System.Drawing.Point(6, 3);
            this.tabControl2.Name = "tabControl2";
            this.tabControl2.SelectedIndex = 0;
            this.tabControl2.Size = new System.Drawing.Size(510, 314);
            this.tabControl2.TabIndex = 13;
            // 
            // subMacrosTab
            // 
            this.subMacrosTab.BackColor = System.Drawing.SystemColors.Control;
            this.subMacrosTab.Controls.Add(this.macroActGroup);
            this.subMacrosTab.Controls.Add(this.filterMacros);
            this.subMacrosTab.Controls.Add(this.filterLabel);
            this.subMacrosTab.Controls.Add(this.macroTree);
            this.subMacrosTab.Controls.Add(this.delMacro);
            this.subMacrosTab.Controls.Add(this.newMacro);
            this.subMacrosTab.Location = new System.Drawing.Point(4, 24);
            this.subMacrosTab.Name = "subMacrosTab";
            this.subMacrosTab.Padding = new System.Windows.Forms.Padding(3);
            this.subMacrosTab.Size = new System.Drawing.Size(502, 286);
            this.subMacrosTab.TabIndex = 0;
            this.subMacrosTab.Text = "Macros";
            // 
            // macroActGroup
            // 
            this.macroActGroup.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.macroActGroup.Controls.Add(this.setMacroHotKey);
            this.macroActGroup.Controls.Add(this.playMacro);
            this.macroActGroup.Controls.Add(this.waitDisp);
            this.macroActGroup.Controls.Add(this.loopMacro);
            this.macroActGroup.Controls.Add(this.recMacro);
            this.macroActGroup.Controls.Add(this.actionList);
            this.macroActGroup.Location = new System.Drawing.Point(200, 3);
            this.macroActGroup.Name = "macroActGroup";
            this.macroActGroup.Size = new System.Drawing.Size(296, 240);
            this.macroActGroup.TabIndex = 18;
            this.macroActGroup.TabStop = false;
            this.macroActGroup.Text = "Actions";
            this.macroActGroup.Visible = false;
            // 
            // setMacroHotKey
            // 
            this.setMacroHotKey.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.setMacroHotKey.Location = new System.Drawing.Point(230, 95);
            this.setMacroHotKey.Name = "setMacroHotKey";
            this.setMacroHotKey.Size = new System.Drawing.Size(60, 33);
            this.setMacroHotKey.TabIndex = 7;
            this.setMacroHotKey.Text = "Set HK";
            this.setMacroHotKey.Click += new System.EventHandler(this.SetMacroHotKey_Click);
            // 
            // playMacro
            // 
            this.playMacro.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.playMacro.Location = new System.Drawing.Point(230, 17);
            this.playMacro.Name = "playMacro";
            this.playMacro.Size = new System.Drawing.Size(60, 33);
            this.playMacro.TabIndex = 6;
            this.playMacro.Text = "Play";
            this.playMacro.Click += new System.EventHandler(this.playMacro_Click);
            // 
            // waitDisp
            // 
            this.waitDisp.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.waitDisp.Location = new System.Drawing.Point(230, 132);
            this.waitDisp.Name = "waitDisp";
            this.waitDisp.Size = new System.Drawing.Size(60, 89);
            this.waitDisp.TabIndex = 5;
            this.waitDisp.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
            // 
            // loopMacro
            // 
            this.loopMacro.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
            this.loopMacro.Location = new System.Drawing.Point(233, 210);
            this.loopMacro.Name = "loopMacro";
            this.loopMacro.Size = new System.Drawing.Size(57, 24);
            this.loopMacro.TabIndex = 4;
            this.loopMacro.Text = "Loop";
            this.loopMacro.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
            this.loopMacro.CheckedChanged += new System.EventHandler(this.loopMacro_CheckedChanged);
            // 
            // recMacro
            // 
            this.recMacro.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.recMacro.Location = new System.Drawing.Point(230, 56);
            this.recMacro.Name = "recMacro";
            this.recMacro.Size = new System.Drawing.Size(60, 33);
            this.recMacro.TabIndex = 3;
            this.recMacro.Text = "Record";
            this.recMacro.Click += new System.EventHandler(this.recMacro_Click);
            // 
            // actionList
            // 
            this.actionList.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.actionList.BackColor = System.Drawing.SystemColors.Window;
            this.actionList.HorizontalScrollbar = true;
            this.actionList.IntegralHeight = false;
            this.actionList.ItemHeight = 15;
            this.actionList.Location = new System.Drawing.Point(6, 17);
            this.actionList.Name = "actionList";
            this.actionList.Size = new System.Drawing.Size(218, 217);
            this.actionList.TabIndex = 0;
            this.actionList.KeyDown += new System.Windows.Forms.KeyEventHandler(this.actionList_KeyDown);
            this.actionList.MouseDown += new System.Windows.Forms.MouseEventHandler(this.actionList_MouseDown);
            // 
            // filterMacros
            // 
            this.filterMacros.Location = new System.Drawing.Point(47, 7);
            this.filterMacros.Name = "filterMacros";
            this.filterMacros.Size = new System.Drawing.Size(147, 23);
            this.filterMacros.TabIndex = 17;
            this.filterMacros.TextChanged += new System.EventHandler(this.filterMacros_TextChanged);
            // 
            // filterLabel
            // 
            this.filterLabel.AutoSize = true;
            this.filterLabel.Location = new System.Drawing.Point(5, 10);
            this.filterLabel.Name = "filterLabel";
            this.filterLabel.Size = new System.Drawing.Size(36, 15);
            this.filterLabel.TabIndex = 16;
            this.filterLabel.Text = "Filter:";
            // 
            // macroTree
            // 
            this.macroTree.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left)));
            this.macroTree.FullRowSelect = true;
            this.macroTree.HideSelection = false;
            this.macroTree.Location = new System.Drawing.Point(6, 36);
            this.macroTree.Name = "macroTree";
            this.macroTree.Size = new System.Drawing.Size(188, 171);
            this.macroTree.Sorted = true;
            this.macroTree.TabIndex = 15;
            this.macroTree.AfterSelect += new System.Windows.Forms.TreeViewEventHandler(this.macroTree_AfterSelect);
            this.macroTree.MouseDown += new System.Windows.Forms.MouseEventHandler(this.macroTree_MouseDown);
            // 
            // delMacro
            // 
            this.delMacro.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.delMacro.Location = new System.Drawing.Point(120, 213);
            this.delMacro.Name = "delMacro";
            this.delMacro.Size = new System.Drawing.Size(74, 30);
            this.delMacro.TabIndex = 14;
            this.delMacro.Text = "Remove";
            this.delMacro.Click += new System.EventHandler(this.delMacro_Click);
            // 
            // newMacro
            // 
            this.newMacro.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.newMacro.Location = new System.Drawing.Point(8, 213);
            this.newMacro.Name = "newMacro";
            this.newMacro.Size = new System.Drawing.Size(74, 30);
            this.newMacro.TabIndex = 13;
            this.newMacro.Text = "New...";
            this.newMacro.Click += new System.EventHandler(this.newMacro_Click);
            // 
            // subMacrosOptionsTab
            // 
            this.subMacrosOptionsTab.BackColor = System.Drawing.SystemColors.Control;
            this.subMacrosOptionsTab.Controls.Add(this.disableMacroPlayFinish);
            this.subMacrosOptionsTab.Controls.Add(this.macroActionDelay);
            this.subMacrosOptionsTab.Controls.Add(this.rangeCheckDoubleClick);
            this.subMacrosOptionsTab.Controls.Add(this.rangeCheckTargetByType);
            this.subMacrosOptionsTab.Controls.Add(this.nextMacroAction);
            this.subMacrosOptionsTab.Controls.Add(this.stepThroughMacro);
            this.subMacrosOptionsTab.Controls.Add(this.targetByTypeDifferent);
            this.subMacrosOptionsTab.Controls.Add(this.macroVariableGroup);
            this.subMacrosOptionsTab.Location = new System.Drawing.Point(4, 22);
            this.subMacrosOptionsTab.Name = "subMacrosOptionsTab";
            this.subMacrosOptionsTab.Padding = new System.Windows.Forms.Padding(3);
            this.subMacrosOptionsTab.Size = new System.Drawing.Size(502, 288);
            this.subMacrosOptionsTab.TabIndex = 1;
            this.subMacrosOptionsTab.Text = "Options";
            // 
            // disableMacroPlayFinish
            // 
            this.disableMacroPlayFinish.AutoSize = true;
            this.disableMacroPlayFinish.Location = new System.Drawing.Point(272, 183);
            this.disableMacroPlayFinish.Name = "disableMacroPlayFinish";
            this.disableMacroPlayFinish.Size = new System.Drawing.Size(204, 19);
            this.disableMacroPlayFinish.TabIndex = 17;
            this.disableMacroPlayFinish.Text = "Disable Playing/Finished Message";
            this.disableMacroPlayFinish.UseVisualStyleBackColor = true;
            this.disableMacroPlayFinish.CheckedChanged += new System.EventHandler(this.disableMacroPlayFinish_CheckedChanged);
            // 
            // macroActionDelay
            // 
            this.macroActionDelay.AutoSize = true;
            this.macroActionDelay.Location = new System.Drawing.Point(272, 158);
            this.macroActionDelay.Name = "macroActionDelay";
            this.macroActionDelay.Size = new System.Drawing.Size(207, 19);
            this.macroActionDelay.TabIndex = 16;
            this.macroActionDelay.Text = "Default macro action delay (50ms)";
            this.macroActionDelay.UseVisualStyleBackColor = true;
            this.macroActionDelay.CheckedChanged += new System.EventHandler(this.macroActionDelay_CheckedChanged);
            // 
            // rangeCheckDoubleClick
            // 
            this.rangeCheckDoubleClick.AutoSize = true;
            this.rangeCheckDoubleClick.Location = new System.Drawing.Point(272, 78);
            this.rangeCheckDoubleClick.Name = "rangeCheckDoubleClick";
            this.rangeCheckDoubleClick.Size = new System.Drawing.Size(207, 19);
            this.rangeCheckDoubleClick.TabIndex = 15;
            this.rangeCheckDoubleClick.Text = "Range check on \'DoubleClickType\'";
            this.rangeCheckDoubleClick.UseVisualStyleBackColor = true;
            this.rangeCheckDoubleClick.CheckedChanged += new System.EventHandler(this.rangeCheckDoubleClick_CheckedChanged);
            // 
            // rangeCheckTargetByType
            // 
            this.rangeCheckTargetByType.AutoSize = true;
            this.rangeCheckTargetByType.Location = new System.Drawing.Point(272, 53);
            this.rangeCheckTargetByType.Name = "rangeCheckTargetByType";
            this.rangeCheckTargetByType.Size = new System.Drawing.Size(188, 19);
            this.rangeCheckTargetByType.TabIndex = 14;
            this.rangeCheckTargetByType.Text = "Range check on \'TargetByType\'";
            this.rangeCheckTargetByType.UseVisualStyleBackColor = true;
            this.rangeCheckTargetByType.CheckedChanged += new System.EventHandler(this.rangeCheckTargetByType_CheckedChanged);
            // 
            // nextMacroAction
            // 
            this.nextMacroAction.Enabled = false;
            this.nextMacroAction.Location = new System.Drawing.Point(412, 115);
            this.nextMacroAction.Name = "nextMacroAction";
            this.nextMacroAction.Size = new System.Drawing.Size(60, 23);
            this.nextMacroAction.TabIndex = 13;
            this.nextMacroAction.Text = "Next";
            this.nextMacroAction.UseVisualStyleBackColor = true;
            this.nextMacroAction.Click += new System.EventHandler(this.nextMacroAction_Click);
            // 
            // stepThroughMacro
            // 
            this.stepThroughMacro.AutoSize = true;
            this.stepThroughMacro.Location = new System.Drawing.Point(272, 118);
            this.stepThroughMacro.Name = "stepThroughMacro";
            this.stepThroughMacro.Size = new System.Drawing.Size(134, 19);
            this.stepThroughMacro.TabIndex = 12;
            this.stepThroughMacro.Text = "Step Through Macro";
            this.stepThroughMacro.UseVisualStyleBackColor = true;
            this.stepThroughMacro.CheckedChanged += new System.EventHandler(this.stepThroughMacro_CheckedChanged);
            // 
            // targetByTypeDifferent
            // 
            this.targetByTypeDifferent.AutoSize = true;
            this.targetByTypeDifferent.Location = new System.Drawing.Point(272, 28);
            this.targetByTypeDifferent.Name = "targetByTypeDifferent";
            this.targetByTypeDifferent.Size = new System.Drawing.Size(181, 19);
            this.targetByTypeDifferent.TabIndex = 11;
            this.targetByTypeDifferent.Text = "Force different \'TargetByType\'";
            this.targetByTypeDifferent.UseVisualStyleBackColor = true;
            this.targetByTypeDifferent.CheckedChanged += new System.EventHandler(this.targetByTypeDifferent_CheckedChanged);
            // 
            // macroVariableGroup
            // 
            this.macroVariableGroup.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left)));
            this.macroVariableGroup.Controls.Add(this.macroVariableTypeList);
            this.macroVariableGroup.Controls.Add(this.retargetMacroVariable);
            this.macroVariableGroup.Controls.Add(this.insertMacroVariable);
            this.macroVariableGroup.Controls.Add(this.removeMacroVariable);
            this.macroVariableGroup.Controls.Add(this.addMacroVariable);
            this.macroVariableGroup.Controls.Add(this.macroVariables);
            this.macroVariableGroup.Location = new System.Drawing.Point(6, 6);
            this.macroVariableGroup.Name = "macroVariableGroup";
            this.macroVariableGroup.Size = new System.Drawing.Size(240, 271);
            this.macroVariableGroup.TabIndex = 6;
            this.macroVariableGroup.TabStop = false;
            this.macroVariableGroup.Text = "Macro Variables:";
            // 
            // macroVariableTypeList
            // 
            this.macroVariableTypeList.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.macroVariableTypeList.FormattingEnabled = true;
            this.macroVariableTypeList.Items.AddRange(new object[] {
            "Absolute Target",
            "DoubleClick Target",
            "Set Macro Variable Action"});
            this.macroVariableTypeList.Location = new System.Drawing.Point(79, 22);
            this.macroVariableTypeList.Name = "macroVariableTypeList";
            this.macroVariableTypeList.Size = new System.Drawing.Size(153, 23);
            this.macroVariableTypeList.TabIndex = 6;
            this.macroVariableTypeList.SelectedIndexChanged += new System.EventHandler(this.macroVariableTypeList_SelectedIndexChanged);
            // 
            // retargetMacroVariable
            // 
            this.retargetMacroVariable.Location = new System.Drawing.Point(6, 84);
            this.retargetMacroVariable.Name = "retargetMacroVariable";
            this.retargetMacroVariable.Size = new System.Drawing.Size(67, 25);
            this.retargetMacroVariable.TabIndex = 5;
            this.retargetMacroVariable.Text = "Retarget";
            this.retargetMacroVariable.UseVisualStyleBackColor = true;
            this.retargetMacroVariable.Click += new System.EventHandler(this.retargetMacroVariable_Click);
            // 
            // insertMacroVariable
            // 
            this.insertMacroVariable.Location = new System.Drawing.Point(6, 22);
            this.insertMacroVariable.Name = "insertMacroVariable";
            this.insertMacroVariable.Size = new System.Drawing.Size(67, 25);
            this.insertMacroVariable.TabIndex = 4;
            this.insertMacroVariable.Text = "Insert as...";
            this.insertMacroVariable.UseVisualStyleBackColor = true;
            this.insertMacroVariable.Click += new System.EventHandler(this.insertMacroVariable_Click);
            // 
            // removeMacroVariable
            // 
            this.removeMacroVariable.Location = new System.Drawing.Point(6, 115);
            this.removeMacroVariable.Name = "removeMacroVariable";
            this.removeMacroVariable.Size = new System.Drawing.Size(67, 25);
            this.removeMacroVariable.TabIndex = 3;
            this.removeMacroVariable.Text = "Remove";
            this.removeMacroVariable.UseVisualStyleBackColor = true;
            this.removeMacroVariable.Click += new System.EventHandler(this.removeMacroVariable_Click);
            // 
            // addMacroVariable
            // 
            this.addMacroVariable.Location = new System.Drawing.Point(6, 53);
            this.addMacroVariable.Name = "addMacroVariable";
            this.addMacroVariable.Size = new System.Drawing.Size(67, 25);
            this.addMacroVariable.TabIndex = 2;
            this.addMacroVariable.Text = "Add";
            this.addMacroVariable.UseVisualStyleBackColor = true;
            this.addMacroVariable.Click += new System.EventHandler(this.addMacroVariable_Click);
            // 
            // macroVariables
            // 
            this.macroVariables.FormattingEnabled = true;
            this.macroVariables.ItemHeight = 15;
            this.macroVariables.Location = new System.Drawing.Point(79, 53);
            this.macroVariables.Name = "macroVariables";
            this.macroVariables.Size = new System.Drawing.Size(153, 199);
            this.macroVariables.TabIndex = 1;
            // 
            // scriptsTab
            // 
            this.scriptsTab.BackColor = System.Drawing.SystemColors.Control;
            this.scriptsTab.Controls.Add(this.subTabScripts);
            this.scriptsTab.Location = new System.Drawing.Point(4, 44);
            this.scriptsTab.Name = "scriptsTab";
            this.scriptsTab.Size = new System.Drawing.Size(519, 322);
            this.scriptsTab.TabIndex = 13;
            this.scriptsTab.Text = "Scripts";
            // 
            // subTabScripts
            // 
            this.subTabScripts.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.subTabScripts.Controls.Add(this.subScripts);
            this.subTabScripts.Controls.Add(this.subScriptOptions);
            this.subTabScripts.Location = new System.Drawing.Point(6, 3);
            this.subTabScripts.Name = "subTabScripts";
            this.subTabScripts.SelectedIndex = 0;
            this.subTabScripts.Size = new System.Drawing.Size(506, 313);
            this.subTabScripts.TabIndex = 14;
            // 
            // subScripts
            // 
            this.subScripts.BackColor = System.Drawing.SystemColors.Control;
            this.subScripts.Controls.Add(this.scriptHotkey);
            this.subScripts.Controls.Add(this.scriptSplitContainer);
            this.subScripts.Controls.Add(this.scriptGuide);
            this.subScripts.Controls.Add(this.saveScript);
            this.subScripts.Controls.Add(this.newScript);
            this.subScripts.Controls.Add(this.setScriptHotkey);
            this.subScripts.Controls.Add(this.recordScript);
            this.subScripts.Controls.Add(this.playScript);
            this.subScripts.Location = new System.Drawing.Point(4, 24);
            this.subScripts.Name = "subScripts";
            this.subScripts.Padding = new System.Windows.Forms.Padding(3);
            this.subScripts.Size = new System.Drawing.Size(498, 285);
            this.subScripts.TabIndex = 0;
            this.subScripts.Text = "Scripts";
            // 
            // scriptHotkey
            // 
            this.scriptHotkey.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.scriptHotkey.ForeColor = System.Drawing.SystemColors.ControlText;
            this.scriptHotkey.Location = new System.Drawing.Point(432, 168);
            this.scriptHotkey.Name = "scriptHotkey";
            this.scriptHotkey.Size = new System.Drawing.Size(60, 35);
            this.scriptHotkey.TabIndex = 29;
            this.scriptHotkey.Text = "Not Set";
            this.scriptHotkey.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
            // 
            // scriptSplitContainer
            // 
            this.scriptSplitContainer.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.scriptSplitContainer.BackColor = System.Drawing.SystemColors.Control;
            this.scriptSplitContainer.Location = new System.Drawing.Point(7, 7);
            this.scriptSplitContainer.Name = "scriptSplitContainer";
            // 
            // scriptSplitContainer.Panel1
            // 
            this.scriptSplitContainer.Panel1.Controls.Add(this.scriptTree);
            this.scriptSplitContainer.Panel1.Controls.Add(this.scriptFilter);
            // 
            // scriptSplitContainer.Panel2
            // 
            this.scriptSplitContainer.Panel2.Controls.Add(this.scriptDocMap);
            this.scriptSplitContainer.Panel2.Controls.Add(this.scriptEditor);
            this.scriptSplitContainer.Size = new System.Drawing.Size(419, 262);
            this.scriptSplitContainer.SplitterDistance = 110;
            this.scriptSplitContainer.SplitterWidth = 10;
            this.scriptSplitContainer.TabIndex = 28;
            // 
            // scriptTree
            // 
            this.scriptTree.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.scriptTree.Location = new System.Drawing.Point(0, 31);
            this.scriptTree.Name = "scriptTree";
            this.scriptTree.Size = new System.Drawing.Size(110, 231);
            this.scriptTree.Sorted = true;
            this.scriptTree.TabIndex = 29;
            this.scriptTree.AfterSelect += new System.Windows.Forms.TreeViewEventHandler(this.scriptTree_AfterSelect);
            this.scriptTree.MouseDown += new System.Windows.Forms.MouseEventHandler(this.scriptTree_MouseDown);
            // 
            // scriptFilter
            // 
            this.scriptFilter.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.scriptFilter.Font = new System.Drawing.Font("Segoe UI", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.scriptFilter.Location = new System.Drawing.Point(0, 0);
            this.scriptFilter.Name = "scriptFilter";
            this.scriptFilter.Size = new System.Drawing.Size(110, 25);
            this.scriptFilter.TabIndex = 28;
            this.scriptFilter.TextChanged += new System.EventHandler(this.scriptFilter_TextChanged);
            // 
            // scriptDocMap
            // 
            this.scriptDocMap.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.scriptDocMap.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(38)))), ((int)(((byte)(37)))), ((int)(((byte)(56)))));
            this.scriptDocMap.ForeColor = System.Drawing.Color.Maroon;
            this.scriptDocMap.Location = new System.Drawing.Point(176, -4);
            this.scriptDocMap.Name = "scriptDocMap";
            this.scriptDocMap.Size = new System.Drawing.Size(120, 266);
            this.scriptDocMap.TabIndex = 22;
            this.scriptDocMap.Target = null;
            // 
            // scriptEditor
            // 
            this.scriptEditor.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.scriptEditor.AutoCompleteBracketsList = new char[] {
        '(',
        ')',
        '{',
        '}',
        '[',
        ']',
        '\"',
        '\"',
        '\'',
        '\''};
            this.scriptEditor.AutoScrollMinSize = new System.Drawing.Size(25, 15);
            this.scriptEditor.BackBrush = null;
            this.scriptEditor.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(38)))), ((int)(((byte)(37)))), ((int)(((byte)(56)))));
            this.scriptEditor.CaretColor = System.Drawing.Color.FromArgb(((int)(((byte)(150)))), ((int)(((byte)(150)))), ((int)(((byte)(150)))));
            this.scriptEditor.CharHeight = 15;
            this.scriptEditor.CharWidth = 7;
            this.scriptEditor.Cursor = System.Windows.Forms.Cursors.IBeam;
            this.scriptEditor.DisabledColor = System.Drawing.Color.FromArgb(((int)(((byte)(100)))), ((int)(((byte)(180)))), ((int)(((byte)(180)))), ((int)(((byte)(180)))));
            this.scriptEditor.Font = new System.Drawing.Font("Consolas", 9.75F);
            this.scriptEditor.ForeColor = System.Drawing.Color.White;
            this.scriptEditor.IsReplaceMode = false;
            this.scriptEditor.LeftBracket = '(';
            this.scriptEditor.LeftBracket2 = '[';
            this.scriptEditor.LineNumberColor = System.Drawing.Color.FromArgb(((int)(((byte)(43)))), ((int)(((byte)(144)))), ((int)(((byte)(175)))));
            this.scriptEditor.Location = new System.Drawing.Point(-4, 0);
            this.scriptEditor.Name = "scriptEditor";
            this.scriptEditor.Paddings = new System.Windows.Forms.Padding(0);
            this.scriptEditor.RightBracket = ')';
            this.scriptEditor.RightBracket2 = ']';
            this.scriptEditor.SelectionColor = System.Drawing.Color.FromArgb(((int)(((byte)(60)))), ((int)(((byte)(0)))), ((int)(((byte)(0)))), ((int)(((byte)(255)))));
            this.scriptEditor.ServiceColors = ((FastColoredTextBoxNS.ServiceColors)(resources.GetObject("scriptEditor.ServiceColors")));
            this.scriptEditor.ShowCaretWhenInactive = false;
            this.scriptEditor.Size = new System.Drawing.Size(174, 262);
            this.scriptEditor.TabIndex = 21;
            this.scriptEditor.Zoom = 100;
            this.scriptEditor.KeyDown += new System.Windows.Forms.KeyEventHandler(this.scriptEditor_KeyDown);
            this.scriptEditor.LostFocus += new System.EventHandler(this.scriptEditor_LostFocus);
            this.scriptEditor.MouseDown += new System.Windows.Forms.MouseEventHandler(this.scriptEditor_MouseDown);
            // 
            // scriptGuide
            // 
            this.scriptGuide.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
            this.scriptGuide.AutoSize = true;
            this.scriptGuide.Location = new System.Drawing.Point(432, 243);
            this.scriptGuide.Name = "scriptGuide";
            this.scriptGuide.Size = new System.Drawing.Size(60, 26);
            this.scriptGuide.TabIndex = 26;
            this.scriptGuide.Text = "Help";
            this.scriptGuide.UseVisualStyleBackColor = true;
            this.scriptGuide.Click += new System.EventHandler(this.scriptGuide_Click);
            // 
            // saveScript
            // 
            this.saveScript.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.saveScript.AutoSize = true;
            this.saveScript.Location = new System.Drawing.Point(432, 83);
            this.saveScript.Name = "saveScript";
            this.saveScript.Size = new System.Drawing.Size(60, 32);
            this.saveScript.TabIndex = 22;
            this.saveScript.Text = "Save";
            this.saveScript.UseVisualStyleBackColor = true;
            this.saveScript.Click += new System.EventHandler(this.saveScript_Click);
            // 
            // newScript
            // 
            this.newScript.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.newScript.AutoSize = true;
            this.newScript.Location = new System.Drawing.Point(432, 211);
            this.newScript.Name = "newScript";
            this.newScript.Size = new System.Drawing.Size(60, 26);
            this.newScript.TabIndex = 18;
            this.newScript.Text = "New";
            this.newScript.UseVisualStyleBackColor = true;
            this.newScript.Click += new System.EventHandler(this.newScript_Click);
            // 
            // setScriptHotkey
            // 
            this.setScriptHotkey.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.setScriptHotkey.AutoSize = true;
            this.setScriptHotkey.Location = new System.Drawing.Point(432, 133);
            this.setScriptHotkey.Name = "setScriptHotkey";
            this.setScriptHotkey.Size = new System.Drawing.Size(60, 32);
            this.setScriptHotkey.TabIndex = 16;
            this.setScriptHotkey.Text = "Set HK";
            this.setScriptHotkey.UseVisualStyleBackColor = true;
            this.setScriptHotkey.Click += new System.EventHandler(this.setScriptHotkey_Click);
            // 
            // recordScript
            // 
            this.recordScript.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.recordScript.AutoSize = true;
            this.recordScript.Location = new System.Drawing.Point(432, 45);
            this.recordScript.Name = "recordScript";
            this.recordScript.Size = new System.Drawing.Size(60, 32);
            this.recordScript.TabIndex = 15;
            this.recordScript.Text = "Record";
            this.recordScript.UseVisualStyleBackColor = true;
            this.recordScript.Click += new System.EventHandler(this.recordScript_Click);
            // 
            // playScript
            // 
            this.playScript.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.playScript.AutoSize = true;
            this.playScript.Location = new System.Drawing.Point(432, 7);
            this.playScript.Name = "playScript";
            this.playScript.Size = new System.Drawing.Size(60, 32);
            this.playScript.TabIndex = 14;
            this.playScript.Text = "Play";
            this.playScript.UseVisualStyleBackColor = true;
            this.playScript.Click += new System.EventHandler(this.playScript_Click);
            // 
            // subScriptOptions
            // 
            this.subScriptOptions.BackColor = System.Drawing.SystemColors.Control;
            this.subScriptOptions.Controls.Add(this.disableScriptStopwatch);
            this.subScriptOptions.Controls.Add(this.enableHighlight);
            this.subScriptOptions.Controls.Add(this.defaultScriptDelay);
            this.subScriptOptions.Controls.Add(this.disableScriptTooltips);
            this.subScriptOptions.Controls.Add(this.scriptDisablePlayFinish);
            this.subScriptOptions.Controls.Add(this.autoSaveScriptPlay);
            this.subScriptOptions.Controls.Add(this.autoSaveScript);
            this.subScriptOptions.Controls.Add(this.scriptVariablesBox);
            this.subScriptOptions.Location = new System.Drawing.Point(4, 22);
            this.subScriptOptions.Name = "subScriptOptions";
            this.subScriptOptions.Padding = new System.Windows.Forms.Padding(3);
            this.subScriptOptions.Size = new System.Drawing.Size(498, 287);
            this.subScriptOptions.TabIndex = 1;
            this.subScriptOptions.Text = "Options";
            // 
            // disableScriptStopwatch
            // 
            this.disableScriptStopwatch.AutoSize = true;
            this.disableScriptStopwatch.Location = new System.Drawing.Point(281, 115);
            this.disableScriptStopwatch.Name = "disableScriptStopwatch";
            this.disableScriptStopwatch.Size = new System.Drawing.Size(185, 19);
            this.disableScriptStopwatch.TabIndex = 23;
            this.disableScriptStopwatch.Text = "Disable execution time output";
            this.disableScriptStopwatch.UseVisualStyleBackColor = true;
            this.disableScriptStopwatch.CheckedChanged += new System.EventHandler(this.disableScriptStopwatch_CheckedChanged);
            // 
            // enableHighlight
            // 
            this.enableHighlight.AutoSize = true;
            this.enableHighlight.Location = new System.Drawing.Point(252, 190);
            this.enableHighlight.Name = "enableHighlight";
            this.enableHighlight.Size = new System.Drawing.Size(171, 19);
            this.enableHighlight.TabIndex = 22;
            this.enableHighlight.Text = "Enable highlighting per line";
            this.enableHighlight.UseVisualStyleBackColor = true;
            this.enableHighlight.CheckedChanged += new System.EventHandler(this.enableHighlight_CheckedChanged);
            // 
            // defaultScriptDelay
            // 
            this.defaultScriptDelay.AutoSize = true;
            this.defaultScriptDelay.Location = new System.Drawing.Point(252, 165);
            this.defaultScriptDelay.Name = "defaultScriptDelay";
            this.defaultScriptDelay.Size = new System.Drawing.Size(202, 19);
            this.defaultScriptDelay.TabIndex = 21;
            this.defaultScriptDelay.Text = "Default script action delay (25ms)";
            this.defaultScriptDelay.UseVisualStyleBackColor = true;
            this.defaultScriptDelay.CheckedChanged += new System.EventHandler(this.defaultScriptDelay_CheckedChanged);
            // 
            // disableScriptTooltips
            // 
            this.disableScriptTooltips.AutoSize = true;
            this.disableScriptTooltips.Location = new System.Drawing.Point(252, 140);
            this.disableScriptTooltips.Name = "disableScriptTooltips";
            this.disableScriptTooltips.Size = new System.Drawing.Size(107, 19);
            this.disableScriptTooltips.TabIndex = 20;
            this.disableScriptTooltips.Text = "Disable tooltips";
            this.disableScriptTooltips.UseVisualStyleBackColor = true;
            this.disableScriptTooltips.CheckedChanged += new System.EventHandler(this.disableScriptTooltips_CheckedChanged);
            // 
            // scriptDisablePlayFinish
            // 
            this.scriptDisablePlayFinish.AutoSize = true;
            this.scriptDisablePlayFinish.Location = new System.Drawing.Point(252, 90);
            this.scriptDisablePlayFinish.Name = "scriptDisablePlayFinish";
            this.scriptDisablePlayFinish.Size = new System.Drawing.Size(204, 19);
            this.scriptDisablePlayFinish.TabIndex = 19;
            this.scriptDisablePlayFinish.Text = "Disable Playing/Finished Message";
            this.scriptDisablePlayFinish.UseVisualStyleBackColor = true;
            this.scriptDisablePlayFinish.CheckedChanged += new System.EventHandler(this.disableScriptPlayFinish_CheckedChanged);
            // 
            // autoSaveScriptPlay
            // 
            this.autoSaveScriptPlay.AutoSize = true;
            this.autoSaveScriptPlay.Location = new System.Drawing.Point(252, 53);
            this.autoSaveScriptPlay.Name = "autoSaveScriptPlay";
            this.autoSaveScriptPlay.Size = new System.Drawing.Size(193, 19);
            this.autoSaveScriptPlay.TabIndex = 9;
            this.autoSaveScriptPlay.Text = "Auto-save when you click \'Play\'";
            this.autoSaveScriptPlay.UseVisualStyleBackColor = true;
            this.autoSaveScriptPlay.CheckedChanged += new System.EventHandler(this.autoSaveScriptPlay_CheckedChanged);
            // 
            // autoSaveScript
            // 
            this.autoSaveScript.AutoSize = true;
            this.autoSaveScript.Location = new System.Drawing.Point(252, 28);
            this.autoSaveScript.Name = "autoSaveScript";
            this.autoSaveScript.Size = new System.Drawing.Size(239, 19);
            this.autoSaveScript.TabIndex = 8;
            this.autoSaveScript.Text = "Auto-save when script editor loses focus";
            this.autoSaveScript.UseVisualStyleBackColor = true;
            this.autoSaveScript.CheckedChanged += new System.EventHandler(this.autoSaveScript_CheckedChanged);
            // 
            // scriptVariablesBox
            // 
            this.scriptVariablesBox.Controls.Add(this.changeScriptVariable);
            this.scriptVariablesBox.Controls.Add(this.removeScriptVariable);
            this.scriptVariablesBox.Controls.Add(this.addScriptVariable);
            this.scriptVariablesBox.Controls.Add(this.scriptVariables);
            this.scriptVariablesBox.Location = new System.Drawing.Point(6, 6);
            this.scriptVariablesBox.Name = "scriptVariablesBox";
            this.scriptVariablesBox.Size = new System.Drawing.Size(240, 269);
            this.scriptVariablesBox.TabIndex = 7;
            this.scriptVariablesBox.TabStop = false;
            this.scriptVariablesBox.Text = "Script Variables:";
            // 
            // changeScriptVariable
            // 
            this.changeScriptVariable.Location = new System.Drawing.Point(6, 53);
            this.changeScriptVariable.Name = "changeScriptVariable";
            this.changeScriptVariable.Size = new System.Drawing.Size(67, 25);
            this.changeScriptVariable.TabIndex = 5;
            this.changeScriptVariable.Text = "Retarget";
            this.changeScriptVariable.UseVisualStyleBackColor = true;
            this.changeScriptVariable.Click += new System.EventHandler(this.changeScriptVariable_Click);
            // 
            // removeScriptVariable
            // 
            this.removeScriptVariable.Location = new System.Drawing.Point(6, 84);
            this.removeScriptVariable.Name = "removeScriptVariable";
            this.removeScriptVariable.Size = new System.Drawing.Size(67, 25);
            this.removeScriptVariable.TabIndex = 3;
            this.removeScriptVariable.Text = "Remove";
            this.removeScriptVariable.UseVisualStyleBackColor = true;
            this.removeScriptVariable.Click += new System.EventHandler(this.removeScriptVariable_Click);
            // 
            // addScriptVariable
            // 
            this.addScriptVariable.Location = new System.Drawing.Point(6, 22);
            this.addScriptVariable.Name = "addScriptVariable";
            this.addScriptVariable.Size = new System.Drawing.Size(67, 25);
            this.addScriptVariable.TabIndex = 2;
            this.addScriptVariable.Text = "Add";
            this.addScriptVariable.UseVisualStyleBackColor = true;
            this.addScriptVariable.Click += new System.EventHandler(this.addScriptVariable_Click);
            // 
            // scriptVariables
            // 
            this.scriptVariables.FormattingEnabled = true;
            this.scriptVariables.ItemHeight = 15;
            this.scriptVariables.Location = new System.Drawing.Point(79, 22);
            this.scriptVariables.Name = "scriptVariables";
            this.scriptVariables.Size = new System.Drawing.Size(153, 229);
            this.scriptVariables.TabIndex = 1;
            // 
            // friendsTab
            // 
            this.friendsTab.BackColor = System.Drawing.SystemColors.Control;
            this.friendsTab.Controls.Add(this.showPartyFriendOverhead);
            this.friendsTab.Controls.Add(this.highlightFriend);
            this.friendsTab.Controls.Add(this.autoAcceptParty);
            this.friendsTab.Controls.Add(this.nextPrevIgnoresFriends);
            this.friendsTab.Controls.Add(this.autoFriend);
            this.friendsTab.Controls.Add(this.friendsGroupBox);
            this.friendsTab.Location = new System.Drawing.Point(4, 44);
            this.friendsTab.Name = "friendsTab";
            this.friendsTab.Size = new System.Drawing.Size(519, 322);
            this.friendsTab.TabIndex = 14;
            this.friendsTab.Text = "Friends";
            // 
            // showPartyFriendOverhead
            // 
            this.showPartyFriendOverhead.Location = new System.Drawing.Point(283, 40);
            this.showPartyFriendOverhead.Name = "showPartyFriendOverhead";
            this.showPartyFriendOverhead.Size = new System.Drawing.Size(217, 20);
            this.showPartyFriendOverhead.TabIndex = 144;
            this.showPartyFriendOverhead.Text = "Show [Party-Friend] overhead";
            this.showPartyFriendOverhead.CheckedChanged += new System.EventHandler(this.showPartyFriendOverhead_CheckedChanged);
            // 
            // highlightFriend
            // 
            this.highlightFriend.Location = new System.Drawing.Point(270, 117);
            this.highlightFriend.Name = "highlightFriend";
            this.highlightFriend.Size = new System.Drawing.Size(184, 23);
            this.highlightFriend.TabIndex = 143;
            this.highlightFriend.Text = "Next/Prev highlights \'Friends\'";
            this.highlightFriend.UseVisualStyleBackColor = true;
            this.highlightFriend.CheckedChanged += new System.EventHandler(this.highlightFriend_CheckedChanged);
            // 
            // autoAcceptParty
            // 
            this.autoAcceptParty.Location = new System.Drawing.Point(270, 91);
            this.autoAcceptParty.Name = "autoAcceptParty";
            this.autoAcceptParty.Size = new System.Drawing.Size(230, 20);
            this.autoAcceptParty.TabIndex = 138;
            this.autoAcceptParty.Text = "Auto-accept party invites from friends";
            this.autoAcceptParty.CheckedChanged += new System.EventHandler(this.autoAcceptParty_CheckedChanged);
            // 
            // nextPrevIgnoresFriends
            // 
            this.nextPrevIgnoresFriends.AutoSize = true;
            this.nextPrevIgnoresFriends.Location = new System.Drawing.Point(270, 66);
            this.nextPrevIgnoresFriends.Name = "nextPrevIgnoresFriends";
            this.nextPrevIgnoresFriends.Size = new System.Drawing.Size(203, 19);
            this.nextPrevIgnoresFriends.TabIndex = 137;
            this.nextPrevIgnoresFriends.Text = "Next/Prev Target ignores \'Friends\'";
            this.nextPrevIgnoresFriends.UseVisualStyleBackColor = true;
            this.nextPrevIgnoresFriends.CheckedChanged += new System.EventHandler(this.nextPrevIgnoresFriends_CheckedChanged);
            // 
            // autoFriend
            // 
            this.autoFriend.Location = new System.Drawing.Point(270, 14);
            this.autoFriend.Name = "autoFriend";
            this.autoFriend.Size = new System.Drawing.Size(217, 20);
            this.autoFriend.TabIndex = 136;
            this.autoFriend.Text = "Treat party members as \'Friends\'";
            this.autoFriend.CheckedChanged += new System.EventHandler(this.autoFriend_CheckedChanged);
            // 
            // friendsGroupBox
            // 
            this.friendsGroupBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left)));
            this.friendsGroupBox.Controls.Add(this.showFriendOverhead);
            this.friendsGroupBox.Controls.Add(this.setFriendsFormatHue);
            this.friendsGroupBox.Controls.Add(this.friendOverheadFormat);
            this.friendsGroupBox.Controls.Add(this.friendFormat);
            this.friendsGroupBox.Controls.Add(this.friendsGroupRemove);
            this.friendsGroupBox.Controls.Add(this.friendsGroupAdd);
            this.friendsGroupBox.Controls.Add(this.friendClearList);
            this.friendsGroupBox.Controls.Add(this.friendRemoveSelected);
            this.friendsGroupBox.Controls.Add(this.friendAddTarget);
            this.friendsGroupBox.Controls.Add(this.friendsList);
            this.friendsGroupBox.Controls.Add(this.friendsGroup);
            this.friendsGroupBox.Controls.Add(this.friendsListEnabled);
            this.friendsGroupBox.Location = new System.Drawing.Point(6, 3);
            this.friendsGroupBox.Name = "friendsGroupBox";
            this.friendsGroupBox.Size = new System.Drawing.Size(258, 313);
            this.friendsGroupBox.TabIndex = 135;
            this.friendsGroupBox.TabStop = false;
            this.friendsGroupBox.Text = "Friends Groups && Lists";
            // 
            // showFriendOverhead
            // 
            this.showFriendOverhead.Location = new System.Drawing.Point(6, 52);
            this.showFriendOverhead.Name = "showFriendOverhead";
            this.showFriendOverhead.Size = new System.Drawing.Size(184, 23);
            this.showFriendOverhead.TabIndex = 146;
            this.showFriendOverhead.Text = "Show overhead tag";
            this.showFriendOverhead.UseVisualStyleBackColor = true;
            this.showFriendOverhead.CheckedChanged += new System.EventHandler(this.showFriendOverhead_CheckedChanged);
            // 
            // setFriendsFormatHue
            // 
            this.setFriendsFormatHue.Location = new System.Drawing.Point(163, 78);
            this.setFriendsFormatHue.Name = "setFriendsFormatHue";
            this.setFriendsFormatHue.Size = new System.Drawing.Size(59, 23);
            this.setFriendsFormatHue.TabIndex = 145;
            this.setFriendsFormatHue.Text = "Set Hue";
            this.setFriendsFormatHue.UseVisualStyleBackColor = true;
            this.setFriendsFormatHue.Click += new System.EventHandler(this.setFriendsFormatHue_Click);
            // 
            // friendOverheadFormat
            // 
            this.friendOverheadFormat.Location = new System.Drawing.Point(55, 78);
            this.friendOverheadFormat.Name = "friendOverheadFormat";
            this.friendOverheadFormat.Size = new System.Drawing.Size(102, 23);
            this.friendOverheadFormat.TabIndex = 143;
            this.friendOverheadFormat.Text = "[Friend]";
            this.friendOverheadFormat.TextAlign = System.Windows.Forms.HorizontalAlignment.Center;
            this.friendOverheadFormat.TextChanged += new System.EventHandler(this.friendOverheadFormat_TextChanged);
            // 
            // friendFormat
            // 
            this.friendFormat.Location = new System.Drawing.Point(6, 78);
            this.friendFormat.Name = "friendFormat";
            this.friendFormat.Size = new System.Drawing.Size(151, 23);
            this.friendFormat.TabIndex = 144;
            this.friendFormat.Text = "Format:";
            this.friendFormat.TextAlign = System.Drawing.ContentAlignment.MiddleLeft;
            // 
            // friendsGroupRemove
            // 
            this.friendsGroupRemove.Location = new System.Drawing.Point(157, 21);
            this.friendsGroupRemove.Name = "friendsGroupRemove";
            this.friendsGroupRemove.Size = new System.Drawing.Size(21, 25);
            this.friendsGroupRemove.TabIndex = 11;
            this.friendsGroupRemove.Text = "-";
            this.friendsGroupRemove.UseVisualStyleBackColor = true;
            this.friendsGroupRemove.Click += new System.EventHandler(this.friendsGroupRemove_Click);
            // 
            // friendsGroupAdd
            // 
            this.friendsGroupAdd.Location = new System.Drawing.Point(130, 21);
            this.friendsGroupAdd.Name = "friendsGroupAdd";
            this.friendsGroupAdd.Size = new System.Drawing.Size(21, 25);
            this.friendsGroupAdd.TabIndex = 10;
            this.friendsGroupAdd.Text = "+";
            this.friendsGroupAdd.UseVisualStyleBackColor = true;
            this.friendsGroupAdd.Click += new System.EventHandler(this.friendsGroupAdd_Click);
            // 
            // friendClearList
            // 
            this.friendClearList.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.friendClearList.Location = new System.Drawing.Point(174, 274);
            this.friendClearList.Name = "friendClearList";
            this.friendClearList.Size = new System.Drawing.Size(79, 33);
            this.friendClearList.TabIndex = 8;
            this.friendClearList.Text = "Clear List";
            this.friendClearList.UseVisualStyleBackColor = true;
            this.friendClearList.Click += new System.EventHandler(this.friendClearList_Click);
            // 
            // friendRemoveSelected
            // 
            this.friendRemoveSelected.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.friendRemoveSelected.Location = new System.Drawing.Point(94, 274);
            this.friendRemoveSelected.Name = "friendRemoveSelected";
            this.friendRemoveSelected.Size = new System.Drawing.Size(74, 33);
            this.friendRemoveSelected.TabIndex = 7;
            this.friendRemoveSelected.Text = "Remove";
            this.friendRemoveSelected.UseVisualStyleBackColor = true;
            this.friendRemoveSelected.Click += new System.EventHandler(this.friendRemoveSelected_Click);
            // 
            // friendAddTarget
            // 
            this.friendAddTarget.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.friendAddTarget.Location = new System.Drawing.Point(6, 274);
            this.friendAddTarget.Name = "friendAddTarget";
            this.friendAddTarget.Size = new System.Drawing.Size(82, 33);
            this.friendAddTarget.TabIndex = 5;
            this.friendAddTarget.Text = "Add (Target)";
            this.friendAddTarget.UseVisualStyleBackColor = true;
            this.friendAddTarget.Click += new System.EventHandler(this.FriendAddTarget_Click);
            // 
            // friendsList
            // 
            this.friendsList.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.friendsList.FormattingEnabled = true;
            this.friendsList.ItemHeight = 15;
            this.friendsList.Location = new System.Drawing.Point(5, 114);
            this.friendsList.Name = "friendsList";
            this.friendsList.Size = new System.Drawing.Size(247, 154);
            this.friendsList.TabIndex = 4;
            this.friendsList.KeyDown += new System.Windows.Forms.KeyEventHandler(this.friendsList_KeyDown);
            this.friendsList.MouseDown += new System.Windows.Forms.MouseEventHandler(this.friendsList_MouseDown);
            // 
            // friendsGroup
            // 
            this.friendsGroup.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.friendsGroup.FormattingEnabled = true;
            this.friendsGroup.Location = new System.Drawing.Point(6, 22);
            this.friendsGroup.Name = "friendsGroup";
            this.friendsGroup.Size = new System.Drawing.Size(118, 23);
            this.friendsGroup.TabIndex = 3;
            this.friendsGroup.SelectedIndexChanged += new System.EventHandler(this.friendsGroup_SelectedIndexChanged);
            // 
            // friendsListEnabled
            // 
            this.friendsListEnabled.Location = new System.Drawing.Point(184, 23);
            this.friendsListEnabled.Name = "friendsListEnabled";
            this.friendsListEnabled.Size = new System.Drawing.Size(69, 20);
            this.friendsListEnabled.TabIndex = 9;
            this.friendsListEnabled.Text = "Enabled";
            this.friendsListEnabled.UseVisualStyleBackColor = true;
            this.friendsListEnabled.CheckedChanged += new System.EventHandler(this.friendsListEnabled_CheckedChanged);
            // 
            // screenshotTab
            // 
            this.screenshotTab.Controls.Add(this.openScreenshotFolder);
            this.screenshotTab.Controls.Add(this.captureOwnDeathDelay);
            this.screenshotTab.Controls.Add(this.lblOwnDeathMs);
            this.screenshotTab.Controls.Add(this.captureOwnDeath);
            this.screenshotTab.Controls.Add(this.captureOthersDeathDelay);
            this.screenshotTab.Controls.Add(this.lblCaptureOthersDeathMs);
            this.screenshotTab.Controls.Add(this.imgFmt);
            this.screenshotTab.Controls.Add(this.label12);
            this.screenshotTab.Controls.Add(this.capNow);
            this.screenshotTab.Controls.Add(this.screenPath);
            this.screenshotTab.Controls.Add(this.radioUO);
            this.screenshotTab.Controls.Add(this.radioFull);
            this.screenshotTab.Controls.Add(this.captureOthersDeath);
            this.screenshotTab.Controls.Add(this.setScnPath);
            this.screenshotTab.Controls.Add(this.screensList);
            this.screenshotTab.Controls.Add(this.screenPrev);
            this.screenshotTab.Controls.Add(this.dispTime);
            this.screenshotTab.Location = new System.Drawing.Point(4, 44);
            this.screenshotTab.Name = "screenshotTab";
            this.screenshotTab.Size = new System.Drawing.Size(519, 322);
            this.screenshotTab.TabIndex = 8;
            this.screenshotTab.Text = "Screen Shots";
            // 
            // openScreenshotFolder
            // 
            this.openScreenshotFolder.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
            this.openScreenshotFolder.Location = new System.Drawing.Point(266, 201);
            this.openScreenshotFolder.Name = "openScreenshotFolder";
            this.openScreenshotFolder.Size = new System.Drawing.Size(155, 23);
            this.openScreenshotFolder.TabIndex = 62;
            this.openScreenshotFolder.Text = "Open Screen Shot Folder";
            this.openScreenshotFolder.UseVisualStyleBackColor = true;
            this.openScreenshotFolder.Click += new System.EventHandler(this.openScreenshotFolder_Click);
            // 
            // captureOwnDeathDelay
            // 
            this.captureOwnDeathDelay.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.captureOwnDeathDelay.Location = new System.Drawing.Point(419, 263);
            this.captureOwnDeathDelay.Name = "captureOwnDeathDelay";
            this.captureOwnDeathDelay.Size = new System.Drawing.Size(32, 23);
            this.captureOwnDeathDelay.TabIndex = 61;
            this.captureOwnDeathDelay.Text = "0.5";
            this.captureOwnDeathDelay.TextAlign = System.Windows.Forms.HorizontalAlignment.Center;
            this.captureOwnDeathDelay.TextChanged += new System.EventHandler(this.CaptureOwnDeathDelay_TextChanged);
            // 
            // lblOwnDeathMs
            // 
            this.lblOwnDeathMs.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.lblOwnDeathMs.Location = new System.Drawing.Point(453, 267);
            this.lblOwnDeathMs.Name = "lblOwnDeathMs";
            this.lblOwnDeathMs.Size = new System.Drawing.Size(26, 18);
            this.lblOwnDeathMs.TabIndex = 60;
            this.lblOwnDeathMs.Text = "s";
            // 
            // captureOwnDeath
            // 
            this.captureOwnDeath.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.captureOwnDeath.Location = new System.Drawing.Point(235, 266);
            this.captureOwnDeath.Name = "captureOwnDeath";
            this.captureOwnDeath.Size = new System.Drawing.Size(158, 20);
            this.captureOwnDeath.TabIndex = 59;
            this.captureOwnDeath.Text = "Capture your own death";
            this.captureOwnDeath.CheckedChanged += new System.EventHandler(this.CaptureOwnDeath_CheckedChanged);
            // 
            // captureOthersDeathDelay
            // 
            this.captureOthersDeathDelay.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.captureOthersDeathDelay.Location = new System.Drawing.Point(419, 239);
            this.captureOthersDeathDelay.Name = "captureOthersDeathDelay";
            this.captureOthersDeathDelay.Size = new System.Drawing.Size(32, 23);
            this.captureOthersDeathDelay.TabIndex = 58;
            this.captureOthersDeathDelay.Text = "0.5";
            this.captureOthersDeathDelay.TextAlign = System.Windows.Forms.HorizontalAlignment.Center;
            this.captureOthersDeathDelay.TextChanged += new System.EventHandler(this.CaptureOthersDeathDelay_TextChanged);
            // 
            // lblCaptureOthersDeathMs
            // 
            this.lblCaptureOthersDeathMs.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.lblCaptureOthersDeathMs.Location = new System.Drawing.Point(453, 242);
            this.lblCaptureOthersDeathMs.Name = "lblCaptureOthersDeathMs";
            this.lblCaptureOthersDeathMs.Size = new System.Drawing.Size(26, 18);
            this.lblCaptureOthersDeathMs.TabIndex = 57;
            this.lblCaptureOthersDeathMs.Text = "s";
            // 
            // imgFmt
            // 
            this.imgFmt.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.imgFmt.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.imgFmt.Items.AddRange(new object[] {
            "jpg",
            "png",
            "bmp",
            "gif",
            "tif",
            "wmf",
            "exif",
            "emf"});
            this.imgFmt.Location = new System.Drawing.Point(103, 237);
            this.imgFmt.Name = "imgFmt";
            this.imgFmt.Size = new System.Drawing.Size(98, 23);
            this.imgFmt.TabIndex = 11;
            this.imgFmt.SelectedIndexChanged += new System.EventHandler(this.imgFmt_SelectedIndexChanged);
            // 
            // label12
            // 
            this.label12.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.label12.Location = new System.Drawing.Point(6, 237);
            this.label12.Name = "label12";
            this.label12.Size = new System.Drawing.Size(92, 20);
            this.label12.TabIndex = 10;
            this.label12.Text = "Image Format:";
            this.label12.TextAlign = System.Drawing.ContentAlignment.MiddleLeft;
            // 
            // capNow
            // 
            this.capNow.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
            this.capNow.Location = new System.Drawing.Point(266, 173);
            this.capNow.Name = "capNow";
            this.capNow.Size = new System.Drawing.Size(155, 22);
            this.capNow.TabIndex = 8;
            this.capNow.Text = "Take Screen Shot Now";
            this.capNow.Click += new System.EventHandler(this.capNow_Click);
            // 
            // screenPath
            // 
            this.screenPath.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.screenPath.Location = new System.Drawing.Point(8, 12);
            this.screenPath.Name = "screenPath";
            this.screenPath.Size = new System.Drawing.Size(463, 23);
            this.screenPath.TabIndex = 7;
            this.screenPath.TextChanged += new System.EventHandler(this.screenPath_TextChanged);
            // 
            // radioUO
            // 
            this.radioUO.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.radioUO.Location = new System.Drawing.Point(13, 260);
            this.radioUO.Name = "radioUO";
            this.radioUO.Size = new System.Drawing.Size(75, 26);
            this.radioUO.TabIndex = 6;
            this.radioUO.Text = "UO Only";
            this.radioUO.CheckedChanged += new System.EventHandler(this.radioUO_CheckedChanged);
            // 
            // radioFull
            // 
            this.radioFull.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.radioFull.Location = new System.Drawing.Point(103, 260);
            this.radioFull.Name = "radioFull";
            this.radioFull.Size = new System.Drawing.Size(88, 26);
            this.radioFull.TabIndex = 5;
            this.radioFull.Text = "Full Screen";
            this.radioFull.CheckedChanged += new System.EventHandler(this.radioFull_CheckedChanged);
            // 
            // captureOthersDeath
            // 
            this.captureOthersDeath.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.captureOthersDeath.Location = new System.Drawing.Point(235, 240);
            this.captureOthersDeath.Name = "captureOthersDeath";
            this.captureOthersDeath.Size = new System.Drawing.Size(216, 20);
            this.captureOthersDeath.TabIndex = 4;
            this.captureOthersDeath.Text = "Capture death of other players";
            this.captureOthersDeath.CheckedChanged += new System.EventHandler(this.CaptureOthersDeath_CheckedChanged);
            // 
            // setScnPath
            // 
            this.setScnPath.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.setScnPath.Location = new System.Drawing.Point(477, 12);
            this.setScnPath.Name = "setScnPath";
            this.setScnPath.Size = new System.Drawing.Size(35, 23);
            this.setScnPath.TabIndex = 3;
            this.setScnPath.Text = "...";
            this.setScnPath.Click += new System.EventHandler(this.setScnPath_Click);
            // 
            // screensList
            // 
            this.screensList.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.screensList.IntegralHeight = false;
            this.screensList.ItemHeight = 15;
            this.screensList.Location = new System.Drawing.Point(8, 41);
            this.screensList.Name = "screensList";
            this.screensList.Size = new System.Drawing.Size(252, 190);
            this.screensList.Sorted = true;
            this.screensList.TabIndex = 1;
            this.screensList.SelectedIndexChanged += new System.EventHandler(this.screensList_SelectedIndexChanged);
            this.screensList.MouseDown += new System.Windows.Forms.MouseEventHandler(this.screensList_MouseDown);
            // 
            // screenPrev
            // 
            this.screenPrev.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.screenPrev.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
            this.screenPrev.Location = new System.Drawing.Point(266, 41);
            this.screenPrev.Name = "screenPrev";
            this.screenPrev.Size = new System.Drawing.Size(246, 126);
            this.screenPrev.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage;
            this.screenPrev.TabIndex = 0;
            this.screenPrev.TabStop = false;
            this.screenPrev.Click += new System.EventHandler(this.screenPrev_Click);
            // 
            // dispTime
            // 
            this.dispTime.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
            this.dispTime.Location = new System.Drawing.Point(13, 289);
            this.dispTime.Name = "dispTime";
            this.dispTime.Size = new System.Drawing.Size(206, 20);
            this.dispTime.TabIndex = 9;
            this.dispTime.Text = "Include Timestamp on images";
            this.dispTime.CheckedChanged += new System.EventHandler(this.dispTime_CheckedChanged);
            // 
            // advancedTab
            // 
            this.advancedTab.BackColor = System.Drawing.SystemColors.Control;
            this.advancedTab.Controls.Add(this.subAdvancedTab);
            this.advancedTab.Location = new System.Drawing.Point(4, 44);
            this.advancedTab.Name = "advancedTab";
            this.advancedTab.Size = new System.Drawing.Size(519, 322);
            this.advancedTab.TabIndex = 12;
            this.advancedTab.Text = "Advanced";
            // 
            // subAdvancedTab
            // 
            this.subAdvancedTab.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.subAdvancedTab.Controls.Add(this.advancedInfoTab);
            this.subAdvancedTab.Controls.Add(this.advancedStaffDeco);
            this.subAdvancedTab.Controls.Add(this.advancedStaffDoors);
            this.subAdvancedTab.Location = new System.Drawing.Point(6, 3);
            this.subAdvancedTab.Name = "subAdvancedTab";
            this.subAdvancedTab.SelectedIndex = 0;
            this.subAdvancedTab.Size = new System.Drawing.Size(506, 313);
            this.subAdvancedTab.TabIndex = 0;
            this.subAdvancedTab.SelectedIndexChanged += new System.EventHandler(this.subAdvancedTab_SelectedIndexChanged);
            // 
            // advancedInfoTab
            // 
            this.advancedInfoTab.BackColor = System.Drawing.SystemColors.Control;
            this.advancedInfoTab.Controls.Add(this.fontDecrease);
            this.advancedInfoTab.Controls.Add(this.fontIncrease);
            this.advancedInfoTab.Controls.Add(this.groupBox16);
            this.advancedInfoTab.Controls.Add(this.enableUOAAPI);
            this.advancedInfoTab.Controls.Add(this.disableSmartCPU);
            this.advancedInfoTab.Controls.Add(this.negotiate);
            this.advancedInfoTab.Controls.Add(this.openRazorDataDir);
            this.advancedInfoTab.Controls.Add(this.msglvl);
            this.advancedInfoTab.Controls.Add(this.label17);
            this.advancedInfoTab.Controls.Add(this.logPackets);
            this.advancedInfoTab.Controls.Add(this.statusBox);
            this.advancedInfoTab.Controls.Add(this.features);
            this.advancedInfoTab.Location = new System.Drawing.Point(4, 24);
            this.advancedInfoTab.Name = "advancedInfoTab";
            this.advancedInfoTab.Padding = new System.Windows.Forms.Padding(3);
            this.advancedInfoTab.Size = new System.Drawing.Size(498, 285);
            this.advancedInfoTab.TabIndex = 0;
            this.advancedInfoTab.Text = "Information";
            // 
            // fontDecrease
            // 
            this.fontDecrease.Location = new System.Drawing.Point(237, 136);
            this.fontDecrease.Name = "fontDecrease";
            this.fontDecrease.Size = new System.Drawing.Size(36, 23);
            this.fontDecrease.TabIndex = 94;
            this.fontDecrease.Text = "-";
            this.fontDecrease.UseVisualStyleBackColor = true;
            this.fontDecrease.Click += new System.EventHandler(this.fontDecrease_Click);
            // 
            // fontIncrease
            // 
            this.fontIncrease.Location = new System.Drawing.Point(279, 136);
            this.fontIncrease.Name = "fontIncrease";
            this.fontIncrease.Size = new System.Drawing.Size(36, 23);
            this.fontIncrease.TabIndex = 93;
            this.fontIncrease.Text = "+";
            this.fontIncrease.UseVisualStyleBackColor = true;
            this.fontIncrease.Click += new System.EventHandler(this.fontIncrease_Click);
            // 
            // groupBox16
            // 
            this.groupBox16.Controls.Add(this.lastBackup);
            this.groupBox16.Controls.Add(this.openBackupFolder);
            this.groupBox16.Controls.Add(this.setBackupFolder);
            this.groupBox16.Controls.Add(this.createBackup);
            this.groupBox16.Location = new System.Drawing.Point(6, 182);
            this.groupBox16.Name = "groupBox16";
            this.groupBox16.Size = new System.Drawing.Size(225, 99);
            this.groupBox16.TabIndex = 92;
            this.groupBox16.TabStop = false;
            this.groupBox16.Text = "Backup";
            // 
            // lastBackup
            // 
            this.lastBackup.Location = new System.Drawing.Point(100, 55);
            this.lastBackup.Name = "lastBackup";
            this.lastBackup.Size = new System.Drawing.Size(119, 37);
            this.lastBackup.TabIndex = 82;
            this.lastBackup.Text = "Last Backup: 01/01/2019 5:54PM";
            this.lastBackup.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
            // 
            // openBackupFolder
            // 
            this.openBackupFolder.Location = new System.Drawing.Point(6, 55);
            this.openBackupFolder.Name = "openBackupFolder";
            this.openBackupFolder.Size = new System.Drawing.Size(88, 30);
            this.openBackupFolder.TabIndex = 81;
            this.openBackupFolder.Text = "Open Folder";
            this.openBackupFolder.UseVisualStyleBackColor = true;
            this.openBackupFolder.Click += new System.EventHandler(this.openBackupFolder_Click);
            // 
            // setBackupFolder
            // 
            this.setBackupFolder.Location = new System.Drawing.Point(134, 22);
            this.setBackupFolder.Name = "setBackupFolder";
            this.setBackupFolder.Size = new System.Drawing.Size(85, 30);
            this.setBackupFolder.TabIndex = 80;
            this.setBackupFolder.Text = "Set Folder";
            this.setBackupFolder.UseVisualStyleBackColor = true;
            this.setBackupFolder.Click += new System.EventHandler(this.setBackupFolder_Click);
            // 
            // createBackup
            // 
            this.createBackup.Location = new System.Drawing.Point(6, 22);
            this.createBackup.Name = "createBackup";
            this.createBackup.Size = new System.Drawing.Size(122, 30);
            this.createBackup.TabIndex = 79;
            this.createBackup.Text = "Create Backup";
            this.createBackup.UseVisualStyleBackColor = true;
            this.createBackup.Click += new System.EventHandler(this.createBackup_Click);
            // 
            // enableUOAAPI
            // 
            this.enableUOAAPI.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.enableUOAAPI.Checked = true;
            this.enableUOAAPI.CheckState = System.Windows.Forms.CheckState.Checked;
            this.enableUOAAPI.Location = new System.Drawing.Point(240, 82);
            this.enableUOAAPI.Name = "enableUOAAPI";
            this.enableUOAAPI.Size = new System.Drawing.Size(146, 19);
            this.enableUOAAPI.TabIndex = 91;
            this.enableUOAAPI.Text = "Enable UOA API";
            this.enableUOAAPI.CheckedChanged += new System.EventHandler(this.enableUOAAPI_CheckedChanged);
            // 
            // disableSmartCPU
            // 
            this.disableSmartCPU.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.disableSmartCPU.Location = new System.Drawing.Point(373, 136);
            this.disableSmartCPU.Name = "disableSmartCPU";
            this.disableSmartCPU.Size = new System.Drawing.Size(119, 22);
            this.disableSmartCPU.TabIndex = 90;
            this.disableSmartCPU.Text = "Disable SmartCPU";
            this.disableSmartCPU.UseVisualStyleBackColor = true;
            // 
            // negotiate
            // 
            this.negotiate.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.negotiate.Location = new System.Drawing.Point(240, 56);
            this.negotiate.Name = "negotiate";
            this.negotiate.Size = new System.Drawing.Size(197, 20);
            this.negotiate.TabIndex = 89;
            this.negotiate.Text = "Negotiate features with server";
            this.negotiate.CheckedChanged += new System.EventHandler(this.negotiate_CheckedChanged);
            // 
            // openRazorDataDir
            // 
            this.openRazorDataDir.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.openRazorDataDir.Location = new System.Drawing.Point(392, 6);
            this.openRazorDataDir.Name = "openRazorDataDir";
            this.openRazorDataDir.Size = new System.Drawing.Size(100, 44);
            this.openRazorDataDir.TabIndex = 88;
            this.openRazorDataDir.Text = "Open Data Directory";
            this.openRazorDataDir.UseVisualStyleBackColor = true;
            this.openRazorDataDir.Click += new System.EventHandler(this.openRazorDataDir_Click);
            // 
            // msglvl
            // 
            this.msglvl.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.msglvl.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.msglvl.Items.AddRange(new object[] {
            "Show All",
            "Warnings & Errors",
            "Errors Only",
            "None"});
            this.msglvl.Location = new System.Drawing.Point(331, 107);
            this.msglvl.Name = "msglvl";
            this.msglvl.Size = new System.Drawing.Size(161, 23);
            this.msglvl.TabIndex = 87;
            // 
            // label17
            // 
            this.label17.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.label17.Location = new System.Drawing.Point(237, 108);
            this.label17.Name = "label17";
            this.label17.Size = new System.Drawing.Size(99, 18);
            this.label17.TabIndex = 86;
            this.label17.Text = "Razor messages:";
            this.label17.TextAlign = System.Drawing.ContentAlignment.MiddleLeft;
            // 
            // logPackets
            // 
            this.logPackets.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.logPackets.Location = new System.Drawing.Point(240, 27);
            this.logPackets.Name = "logPackets";
            this.logPackets.Size = new System.Drawing.Size(146, 23);
            this.logPackets.TabIndex = 85;
            this.logPackets.Text = "Enable packet logging";
            this.logPackets.CheckedChanged += new System.EventHandler(this.logPackets_CheckedChanged);
            // 
            // statusBox
            // 
            this.statusBox.BackColor = System.Drawing.SystemColors.Control;
            this.statusBox.BorderStyle = System.Windows.Forms.BorderStyle.None;
            this.statusBox.Font = new System.Drawing.Font("Consolas", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.statusBox.HideSelection = false;
            this.statusBox.Location = new System.Drawing.Point(6, 6);
            this.statusBox.Multiline = true;
            this.statusBox.Name = "statusBox";
            this.statusBox.ReadOnly = true;
            this.statusBox.Size = new System.Drawing.Size(225, 170);
            this.statusBox.TabIndex = 84;
            // 
            // features
            // 
            this.features.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.features.Cursor = System.Windows.Forms.Cursors.No;
            this.features.Location = new System.Drawing.Point(237, 164);
            this.features.Multiline = true;
            this.features.Name = "features";
            this.features.ReadOnly = true;
            this.features.ScrollBars = System.Windows.Forms.ScrollBars.Vertical;
            this.features.Size = new System.Drawing.Size(255, 85);
            this.features.TabIndex = 83;
            this.features.Visible = false;
            // 
            // advancedStaffDeco
            // 
            this.advancedStaffDeco.BackColor = System.Drawing.SystemColors.Control;
            this.advancedStaffDeco.Controls.Add(this.itemAppendM);
            this.advancedStaffDeco.Controls.Add(this.itemCopyToClipboard);
            this.advancedStaffDeco.Controls.Add(this.itemSearch);
            this.advancedStaffDeco.Controls.Add(this.itemMovable);
            this.advancedStaffDeco.Controls.Add(this.itemRandomNumber);
            this.advancedStaffDeco.Controls.Add(this.itemRandom);
            this.advancedStaffDeco.Controls.Add(this.itemTileCount);
            this.advancedStaffDeco.Controls.Add(this.itemTile);
            this.advancedStaffDeco.Controls.Add(this.itemAdd);
            this.advancedStaffDeco.Controls.Add(this.itemTree);
            this.advancedStaffDeco.Controls.Add(this.artViewer);
            this.advancedStaffDeco.Location = new System.Drawing.Point(4, 22);
            this.advancedStaffDeco.Name = "advancedStaffDeco";
            this.advancedStaffDeco.Padding = new System.Windows.Forms.Padding(3);
            this.advancedStaffDeco.Size = new System.Drawing.Size(498, 287);
            this.advancedStaffDeco.TabIndex = 1;
            this.advancedStaffDeco.Text = "Decoration";
            // 
            // itemAppendM
            // 
            this.itemAppendM.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.itemAppendM.AutoSize = true;
            this.itemAppendM.Location = new System.Drawing.Point(293, 215);
            this.itemAppendM.Name = "itemAppendM";
            this.itemAppendM.Size = new System.Drawing.Size(178, 19);
            this.itemAppendM.TabIndex = 11;
            this.itemAppendM.Text = "Append [m to the command";
            this.itemAppendM.UseVisualStyleBackColor = true;
            // 
            // itemCopyToClipboard
            // 
            this.itemCopyToClipboard.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.itemCopyToClipboard.AutoSize = true;
            this.itemCopyToClipboard.Location = new System.Drawing.Point(293, 190);
            this.itemCopyToClipboard.Name = "itemCopyToClipboard";
            this.itemCopyToClipboard.Size = new System.Drawing.Size(199, 19);
            this.itemCopyToClipboard.TabIndex = 10;
            this.itemCopyToClipboard.Text = "Copy command to the clipboard";
            this.itemCopyToClipboard.UseVisualStyleBackColor = true;
            // 
            // itemSearch
            // 
            this.itemSearch.AcceptsReturn = true;
            this.itemSearch.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.itemSearch.Location = new System.Drawing.Point(6, 6);
            this.itemSearch.Name = "itemSearch";
            this.itemSearch.Size = new System.Drawing.Size(209, 23);
            this.itemSearch.TabIndex = 9;
            this.itemSearch.KeyDown += new System.Windows.Forms.KeyEventHandler(this.itemSearch_KeyDown);
            this.itemSearch.LostFocus += new System.EventHandler(this.itemSearch_LostFocus);
            // 
            // itemMovable
            // 
            this.itemMovable.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.itemMovable.AutoSize = true;
            this.itemMovable.Location = new System.Drawing.Point(221, 109);
            this.itemMovable.Name = "itemMovable";
            this.itemMovable.Size = new System.Drawing.Size(72, 19);
            this.itemMovable.TabIndex = 8;
            this.itemMovable.Text = "Movable";
            this.itemMovable.UseVisualStyleBackColor = true;
            // 
            // itemRandomNumber
            // 
            this.itemRandomNumber.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.itemRandomNumber.Font = new System.Drawing.Font("Segoe UI", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.itemRandomNumber.Location = new System.Drawing.Point(220, 159);
            this.itemRandomNumber.Name = "itemRandomNumber";
            this.itemRandomNumber.Size = new System.Drawing.Size(75, 25);
            this.itemRandomNumber.TabIndex = 7;
            // 
            // itemRandom
            // 
            this.itemRandom.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.itemRandom.AutoSize = true;
            this.itemRandom.Location = new System.Drawing.Point(220, 134);
            this.itemRandom.Name = "itemRandom";
            this.itemRandom.Size = new System.Drawing.Size(71, 19);
            this.itemRandom.TabIndex = 6;
            this.itemRandom.Text = "Random";
            this.itemRandom.UseVisualStyleBackColor = true;
            // 
            // itemTileCount
            // 
            this.itemTileCount.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.itemTileCount.Font = new System.Drawing.Font("Segoe UI", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.itemTileCount.Location = new System.Drawing.Point(221, 78);
            this.itemTileCount.Name = "itemTileCount";
            this.itemTileCount.Size = new System.Drawing.Size(75, 25);
            this.itemTileCount.TabIndex = 4;
            // 
            // itemTile
            // 
            this.itemTile.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.itemTile.Location = new System.Drawing.Point(221, 42);
            this.itemTile.Name = "itemTile";
            this.itemTile.Size = new System.Drawing.Size(75, 30);
            this.itemTile.TabIndex = 3;
            this.itemTile.Text = "Tile";
            this.itemTile.UseVisualStyleBackColor = true;
            this.itemTile.Click += new System.EventHandler(this.itemTile_Click);
            // 
            // itemAdd
            // 
            this.itemAdd.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.itemAdd.Location = new System.Drawing.Point(221, 6);
            this.itemAdd.Name = "itemAdd";
            this.itemAdd.Size = new System.Drawing.Size(75, 30);
            this.itemAdd.TabIndex = 2;
            this.itemAdd.Text = "Add";
            this.itemAdd.UseVisualStyleBackColor = true;
            this.itemAdd.Click += new System.EventHandler(this.itemAdd_Click);
            this.itemAdd.MouseDown += new System.Windows.Forms.MouseEventHandler(this.itemAdd_MouseDown);
            // 
            // itemTree
            // 
            this.itemTree.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.itemTree.Location = new System.Drawing.Point(6, 35);
            this.itemTree.Name = "itemTree";
            this.itemTree.Size = new System.Drawing.Size(209, 246);
            this.itemTree.TabIndex = 1;
            this.itemTree.AfterSelect += new System.Windows.Forms.TreeViewEventHandler(this.itemTree_AfterSelect);
            this.itemTree.MouseDoubleClick += new System.Windows.Forms.MouseEventHandler(this.itemTree_MouseDoubleClick);
            // 
            // advancedStaffDoors
            // 
            this.advancedStaffDoors.BackColor = System.Drawing.SystemColors.Control;
            this.advancedStaffDoors.Controls.Add(this.doorViewer);
            this.advancedStaffDoors.Controls.Add(this.doorTree);
            this.advancedStaffDoors.Controls.Add(this.doorSouthCW);
            this.advancedStaffDoors.Controls.Add(this.doorSouthCCW);
            this.advancedStaffDoors.Controls.Add(this.doorEastCW);
            this.advancedStaffDoors.Controls.Add(this.doorEastCCW);
            this.advancedStaffDoors.Controls.Add(this.doorNorthCCW);
            this.advancedStaffDoors.Controls.Add(this.doorNorthCW);
            this.advancedStaffDoors.Controls.Add(this.doorWestCCW);
            this.advancedStaffDoors.Controls.Add(this.doorWestCW);
            this.advancedStaffDoors.Location = new System.Drawing.Point(4, 22);
            this.advancedStaffDoors.Name = "advancedStaffDoors";
            this.advancedStaffDoors.Size = new System.Drawing.Size(498, 287);
            this.advancedStaffDoors.TabIndex = 2;
            this.advancedStaffDoors.Text = "Doors";
            // 
            // doorTree
            // 
            this.doorTree.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Left)));
            this.doorTree.Location = new System.Drawing.Point(3, 3);
            this.doorTree.Name = "doorTree";
            this.doorTree.Size = new System.Drawing.Size(168, 281);
            this.doorTree.TabIndex = 32;
            this.doorTree.AfterSelect += new System.Windows.Forms.TreeViewEventHandler(this.doorTree_AfterSelect);
            // 
            // doorSouthCW
            // 
            this.doorSouthCW.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.doorSouthCW.Image = ((System.Drawing.Image)(resources.GetObject("doorSouthCW.Image")));
            this.doorSouthCW.Location = new System.Drawing.Point(420, 84);
            this.doorSouthCW.Name = "doorSouthCW";
            this.doorSouthCW.Size = new System.Drawing.Size(75, 75);
            this.doorSouthCW.TabIndex = 31;
            this.doorSouthCW.UseVisualStyleBackColor = true;
            this.doorSouthCW.Click += new System.EventHandler(this.doorSouthCW_Click);
            this.doorSouthCW.MouseEnter += new System.EventHandler(this.DoorFacingEnter);
            // 
            // doorSouthCCW
            // 
            this.doorSouthCCW.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.doorSouthCCW.Image = ((System.Drawing.Image)(resources.GetObject("doorSouthCCW.Image")));
            this.doorSouthCCW.Location = new System.Drawing.Point(339, 84);
            this.doorSouthCCW.Name = "doorSouthCCW";
            this.doorSouthCCW.Size = new System.Drawing.Size(75, 75);
            this.doorSouthCCW.TabIndex = 30;
            this.doorSouthCCW.UseVisualStyleBackColor = true;
            this.doorSouthCCW.Click += new System.EventHandler(this.doorSouthCCW_Click);
            this.doorSouthCCW.MouseEnter += new System.EventHandler(this.DoorFacingEnter);
            // 
            // doorEastCW
            // 
            this.doorEastCW.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.doorEastCW.Image = ((System.Drawing.Image)(resources.GetObject("doorEastCW.Image")));
            this.doorEastCW.Location = new System.Drawing.Point(258, 84);
            this.doorEastCW.Name = "doorEastCW";
            this.doorEastCW.Size = new System.Drawing.Size(75, 75);
            this.doorEastCW.TabIndex = 29;
            this.doorEastCW.UseVisualStyleBackColor = true;
            this.doorEastCW.Click += new System.EventHandler(this.doorEastCW_Click);
            this.doorEastCW.MouseEnter += new System.EventHandler(this.DoorFacingEnter);
            // 
            // doorEastCCW
            // 
            this.doorEastCCW.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.doorEastCCW.Image = ((System.Drawing.Image)(resources.GetObject("doorEastCCW.Image")));
            this.doorEastCCW.Location = new System.Drawing.Point(177, 84);
            this.doorEastCCW.Name = "doorEastCCW";
            this.doorEastCCW.Size = new System.Drawing.Size(75, 75);
            this.doorEastCCW.TabIndex = 28;
            this.doorEastCCW.UseVisualStyleBackColor = true;
            this.doorEastCCW.Click += new System.EventHandler(this.doorEastCCW_Click);
            this.doorEastCCW.MouseEnter += new System.EventHandler(this.DoorFacingEnter);
            // 
            // doorNorthCCW
            // 
            this.doorNorthCCW.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.doorNorthCCW.Image = ((System.Drawing.Image)(resources.GetObject("doorNorthCCW.Image")));
            this.doorNorthCCW.Location = new System.Drawing.Point(420, 3);
            this.doorNorthCCW.Name = "doorNorthCCW";
            this.doorNorthCCW.Size = new System.Drawing.Size(75, 75);
            this.doorNorthCCW.TabIndex = 27;
            this.doorNorthCCW.UseVisualStyleBackColor = true;
            this.doorNorthCCW.Click += new System.EventHandler(this.doorNorthCCW_Click);
            this.doorNorthCCW.MouseEnter += new System.EventHandler(this.DoorFacingEnter);
            // 
            // doorNorthCW
            // 
            this.doorNorthCW.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.doorNorthCW.Image = ((System.Drawing.Image)(resources.GetObject("doorNorthCW.Image")));
            this.doorNorthCW.Location = new System.Drawing.Point(339, 3);
            this.doorNorthCW.Name = "doorNorthCW";
            this.doorNorthCW.Size = new System.Drawing.Size(75, 75);
            this.doorNorthCW.TabIndex = 26;
            this.doorNorthCW.UseVisualStyleBackColor = true;
            this.doorNorthCW.Click += new System.EventHandler(this.doorNorthCW_Click);
            this.doorNorthCW.MouseEnter += new System.EventHandler(this.DoorFacingEnter);
            // 
            // doorWestCCW
            // 
            this.doorWestCCW.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.doorWestCCW.Image = ((System.Drawing.Image)(resources.GetObject("doorWestCCW.Image")));
            this.doorWestCCW.Location = new System.Drawing.Point(258, 3);
            this.doorWestCCW.Name = "doorWestCCW";
            this.doorWestCCW.Size = new System.Drawing.Size(75, 75);
            this.doorWestCCW.TabIndex = 25;
            this.doorWestCCW.UseVisualStyleBackColor = true;
            this.doorWestCCW.Click += new System.EventHandler(this.doorWestCCW_Click);
            this.doorWestCCW.MouseEnter += new System.EventHandler(this.DoorFacingEnter);
            // 
            // doorWestCW
            // 
            this.doorWestCW.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.doorWestCW.Image = ((System.Drawing.Image)(resources.GetObject("doorWestCW.Image")));
            this.doorWestCW.Location = new System.Drawing.Point(177, 3);
            this.doorWestCW.Name = "doorWestCW";
            this.doorWestCW.Size = new System.Drawing.Size(75, 75);
            this.doorWestCW.TabIndex = 24;
            this.doorWestCW.UseVisualStyleBackColor = true;
            this.doorWestCW.Click += new System.EventHandler(this.doorWestCW_Click);
            this.doorWestCW.MouseEnter += new System.EventHandler(this.DoorFacingEnter);
            // 
            // aboutTab
            // 
            this.aboutTab.Controls.Add(this.linkGitHub);
            this.aboutTab.Controls.Add(this.lblCredits3);
            this.aboutTab.Controls.Add(this.linkHelp);
            this.aboutTab.Controls.Add(this.lblCredits2);
            this.aboutTab.Controls.Add(this.label20);
            this.aboutTab.Controls.Add(this.lblCredits1);
            this.aboutTab.Controls.Add(this.aboutSubInfo);
            this.aboutTab.Controls.Add(this.linkMain);
            this.aboutTab.Controls.Add(this.label21);
            this.aboutTab.Controls.Add(this.aboutVer);
            this.aboutTab.Location = new System.Drawing.Point(4, 44);
            this.aboutTab.Name = "aboutTab";
            this.aboutTab.Size = new System.Drawing.Size(519, 322);
            this.aboutTab.TabIndex = 9;
            this.aboutTab.Text = "About";
            // 
            // linkGitHub
            // 
            this.linkGitHub.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Left | System.Windows.Forms.AnchorStyles.Right)));
            this.linkGitHub.Font = new System.Drawing.Font("Segoe UI", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.linkGitHub.Location = new System.Drawing.Point(9, 157);
            this.linkGitHub.Name = "linkGitHub";
            this.linkGitHub.Size = new System.Drawing.Size(506, 20);
            this.linkGitHub.TabIndex = 25;
            this.linkGitHub.TabStop = true;
            this.linkGitHub.Text = "https://github.com/markdwags/Razor";
            this.linkGitHub.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
            this.linkGitHub.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.linkGitHub_LinkClicked);
            // 
            // lblCredits3
            // 
            this.lblCredits3.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Left | System.Windows.Forms.AnchorStyles.Right)));
            this.lblCredits3.Font = new System.Drawing.Font("Segoe UI Semibold", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.lblCredits3.Location = new System.Drawing.Point(8, 259);
            this.lblCredits3.Name = "lblCredits3";
            this.lblCredits3.Size = new System.Drawing.Size(503, 20);
            this.lblCredits3.TabIndex = 24;
            this.lblCredits3.Text = "Cross-platform implementation by DarkLotus";
            this.lblCredits3.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
            // 
            // linkHelp
            // 
            this.linkHelp.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.linkHelp.Font = new System.Drawing.Font("Segoe UI", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.linkHelp.Location = new System.Drawing.Point(434, 10);
            this.linkHelp.Name = "linkHelp";
            this.linkHelp.Size = new System.Drawing.Size(78, 20);
            this.linkHelp.TabIndex = 23;
            this.linkHelp.TabStop = true;
            this.linkHelp.Text = "Need Help?";
            this.linkHelp.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
            this.linkHelp.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.linkHelp_LinkClicked);
            // 
            // lblCredits2
            // 
            this.lblCredits2.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Left | System.Windows.Forms.AnchorStyles.Right)));
            this.lblCredits2.Font = new System.Drawing.Font("Segoe UI Semibold", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.lblCredits2.Location = new System.Drawing.Point(9, 239);
            this.lblCredits2.Name = "lblCredits2";
            this.lblCredits2.Size = new System.Drawing.Size(503, 20);
            this.lblCredits2.TabIndex = 22;
            this.lblCredits2.Text = "Major design changes including ClassicUO integration by Jaedan";
            this.lblCredits2.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
            // 
            // label20
            // 
            this.label20.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Left | System.Windows.Forms.AnchorStyles.Right)));
            this.label20.Font = new System.Drawing.Font("Segoe UI", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.label20.Location = new System.Drawing.Point(12, 120);
            this.label20.Name = "label20";
            this.label20.Size = new System.Drawing.Size(499, 17);
            this.label20.TabIndex = 21;
            this.label20.Text = "For feedback, support and the latest releases please visit:\r\n";
            this.label20.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
            // 
            // lblCredits1
            // 
            this.lblCredits1.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Left | System.Windows.Forms.AnchorStyles.Right)));
            this.lblCredits1.Font = new System.Drawing.Font("Segoe UI Semibold", 9.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.lblCredits1.Location = new System.Drawing.Point(6, 219);
            this.lblCredits1.Name = "lblCredits1";
            this.lblCredits1.Size = new System.Drawing.Size(506, 20);
            this.lblCredits1.TabIndex = 19;
            this.lblCredits1.Text = "Razor was designed by Zippy, modified and maintained by Quick";
            this.lblCredits1.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
            // 
            // aboutSubInfo
            // 
            this.aboutSubInfo.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Left | System.Windows.Forms.AnchorStyles.Right)));
            this.aboutSubInfo.Font = new System.Drawing.Font("Segoe UI", 11.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.aboutSubInfo.Location = new System.Drawing.Point(6, 75);
            this.aboutSubInfo.Name = "aboutSubInfo";
            this.aboutSubInfo.Size = new System.Drawing.Size(506, 19);
            this.aboutSubInfo.TabIndex = 17;
            this.aboutSubInfo.Text = "Community Edition";
            this.aboutSubInfo.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
            // 
            // linkMain
            // 
            this.linkMain.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Left | System.Windows.Forms.AnchorStyles.Right)));
            this.linkMain.Font = new System.Drawing.Font("Segoe UI", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.linkMain.Location = new System.Drawing.Point(9, 137);
            this.linkMain.Name = "linkMain";
            this.linkMain.Size = new System.Drawing.Size(506, 20);
            this.linkMain.TabIndex = 16;
            this.linkMain.TabStop = true;
            this.linkMain.Text = "https://www.razorce.com";
            this.linkMain.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
            this.linkMain.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.linkLabel2_LinkClicked);
            // 
            // label21
            // 
            this.label21.AutoSize = true;
            this.label21.Font = new System.Drawing.Font("Segoe UI Semibold", 9F, ((System.Drawing.FontStyle)((System.Drawing.FontStyle.Bold | System.Drawing.FontStyle.Italic))), System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.label21.Location = new System.Drawing.Point(52, 98);
            this.label21.Name = "label21";
            this.label21.Size = new System.Drawing.Size(0, 15);
            this.label21.TabIndex = 15;
            this.label21.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
            // 
            // aboutVer
            // 
            this.aboutVer.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Left | System.Windows.Forms.AnchorStyles.Right)));
            this.aboutVer.Font = new System.Drawing.Font("Segoe UI", 15.75F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.aboutVer.Location = new System.Drawing.Point(6, 40);
            this.aboutVer.Name = "aboutVer";
            this.aboutVer.Size = new System.Drawing.Size(506, 35);
            this.aboutVer.TabIndex = 14;
            this.aboutVer.Text = "Razor v{0}";
            this.aboutVer.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
            // 
            // cooldownGumpBox
            // 
            this.cooldownGumpBox.Controls.Add(this.cooldownHeight);
            this.cooldownGumpBox.Controls.Add(this.lblCooldownHeight);
            this.cooldownGumpBox.Controls.Add(this.cooldownWidth);
            this.cooldownGumpBox.Controls.Add(this.lblCooldownWidth);
            this.cooldownGumpBox.Location = new System.Drawing.Point(14, 124);
            this.cooldownGumpBox.Name = "cooldownGumpBox";
            this.cooldownGumpBox.Size = new System.Drawing.Size(232, 151);
            this.cooldownGumpBox.TabIndex = 133;
            this.cooldownGumpBox.TabStop = false;
            this.cooldownGumpBox.Text = "Cooldowns:";
            // 
            // cooldownHeight
            // 
            this.cooldownHeight.Location = new System.Drawing.Point(75, 26);
            this.cooldownHeight.Name = "cooldownHeight";
            this.cooldownHeight.Size = new System.Drawing.Size(36, 23);
            this.cooldownHeight.TabIndex = 12;
            this.cooldownHeight.TextChanged += new System.EventHandler(this.cooldownHeight_TextChanged);
            // 
            // lblCooldownHeight
            // 
            this.lblCooldownHeight.AutoSize = true;
            this.lblCooldownHeight.Location = new System.Drawing.Point(9, 29);
            this.lblCooldownHeight.Name = "lblCooldownHeight";
            this.lblCooldownHeight.Size = new System.Drawing.Size(64, 15);
            this.lblCooldownHeight.TabIndex = 11;
            this.lblCooldownHeight.Text = "Bar height:";
            // 
            // cooldownWidth
            // 
            this.cooldownWidth.Location = new System.Drawing.Point(75, 54);
            this.cooldownWidth.Name = "cooldownWidth";
            this.cooldownWidth.Size = new System.Drawing.Size(36, 23);
            this.cooldownWidth.TabIndex = 10;
            this.cooldownWidth.TextChanged += new System.EventHandler(this.cooldownWidth_TextChanged);
            // 
            // lblCooldownWidth
            // 
            this.lblCooldownWidth.AutoSize = true;
            this.lblCooldownWidth.Location = new System.Drawing.Point(9, 57);
            this.lblCooldownWidth.Name = "lblCooldownWidth";
            this.lblCooldownWidth.Size = new System.Drawing.Size(60, 15);
            this.lblCooldownWidth.TabIndex = 9;
            this.lblCooldownWidth.Text = "Bar width:";
            // 
            // artViewer
            // 
            this.artViewer.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
            this.artViewer.Animate = false;
            this.artViewer.Art = Assistant.UI.Art.Items;
            this.artViewer.ArtIndex = 0;
            this.artViewer.Hue = 0;
            this.artViewer.Location = new System.Drawing.Point(302, 6);
            this.artViewer.Name = "artViewer";
            this.artViewer.ResizeTallItems = false;
            this.artViewer.RoomView = true;
            this.artViewer.ShowHexID = true;
            this.artViewer.ShowID = true;
            this.artViewer.Size = new System.Drawing.Size(190, 178);
            this.artViewer.TabIndex = 0;
            // 
            // doorViewer
            // 
            this.doorViewer.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
            | System.Windows.Forms.AnchorStyles.Right)));
            this.doorViewer.Animate = false;
            this.doorViewer.Art = Assistant.UI.Art.Items;
            this.doorViewer.ArtIndex = 0;
            this.doorViewer.Hue = 0;
            this.doorViewer.Location = new System.Drawing.Point(177, 165);
            this.doorViewer.MaximumSize = new System.Drawing.Size(318, 318);
            this.doorViewer.Name = "doorViewer";
            this.doorViewer.ResizeTallItems = false;
            this.doorViewer.RoomView = true;
            this.doorViewer.ShowHexID = true;
            this.doorViewer.ShowID = true;
            this.doorViewer.Size = new System.Drawing.Size(318, 119);
            this.doorViewer.TabIndex = 33;
            // 
            // MainForm
            // 
            this.AutoScaleBaseSize = new System.Drawing.Size(6, 16);
            this.ClientSize = new System.Drawing.Size(530, 372);
            this.Controls.Add(this.tabs);
            this.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon")));
            this.MinimumSize = new System.Drawing.Size(546, 411);
            this.Name = "MainForm";
            this.StartPosition = System.Windows.Forms.FormStartPosition.Manual;
            this.Text = "Razor v{0}";
            this.Activated += new System.EventHandler(this.MainForm_Activated);
            this.Closing += new System.ComponentModel.CancelEventHandler(this.MainForm_Closing);
            this.Deactivate += new System.EventHandler(this.MainForm_Deactivate);
            this.Load += new System.EventHandler(this.MainForm_StartLoad);
            this.ResizeEnd += new System.EventHandler(this.MainForm_ResizeEnd);
            this.KeyDown += new System.Windows.Forms.KeyEventHandler(this.MainForm_KeyDown);
            this.Move += new System.EventHandler(this.MainForm_Move);
            this.Resize += new System.EventHandler(this.MainForm_Resize);
            this.tabs.ResumeLayout(false);
            this.generalTab.ResumeLayout(false);
            this.subGeneralTab.ResumeLayout(false);
            this.subGenTab.ResumeLayout(false);
            this.groupBox15.ResumeLayout(false);
            ((System.ComponentModel.ISupportInitialize)(this.opacity)).EndInit();
            this.groupBox4.ResumeLayout(false);
            this.groupBox4.PerformLayout();
            this.moreOptTab.ResumeLayout(false);
            this.optionsTabCtrl.ResumeLayout(false);
            this.subOptionsSpeechTab.ResumeLayout(false);
            this.subOptionsSpeechTab.PerformLayout();
            this.subOptionsTargetTab.ResumeLayout(false);
            this.subOptionsTargetTab.PerformLayout();
            this.groupSmartTarget.ResumeLayout(false);
            this.groupSmartTarget.PerformLayout();
            this.subOptionsMiscTab.ResumeLayout(false);
            this.subOptionsMiscTab.PerformLayout();
            ((System.ComponentModel.ISupportInitialize)(this.lightLevelBar)).EndInit();
            this.displayTab.ResumeLayout(false);
            this.displayCountersTabCtrl.ResumeLayout(false);
            this.subDisplayTab.ResumeLayout(false);
            this.subDisplayTab.PerformLayout();
            this.groupBox11.ResumeLayout(false);
            this.groupBox11.PerformLayout();
            this.groupBox3.ResumeLayout(false);
            this.groupBox3.PerformLayout();
            this.subCountersTab.ResumeLayout(false);
            this.subCountersTab.PerformLayout();
            this.groupBox2.ResumeLayout(false);
            this.subBandageTimerTab.ResumeLayout(false);
            this.subBandageTimerTab.PerformLayout();
            this.subOverheadTab.ResumeLayout(false);
            this.subOverheadTab.PerformLayout();
            this.subWaypoints.ResumeLayout(false);
            this.subWaypoints.PerformLayout();
            this.subBuffsDebuffs.ResumeLayout(false);
            this.subBuffsDebuffs.PerformLayout();
            this.buffBarGroupBox.ResumeLayout(false);
            this.buffBarGroupBox.PerformLayout();
            this.dressTab.ResumeLayout(false);
            this.groupBox6.ResumeLayout(false);
            this.groupBox5.ResumeLayout(false);
            this.skillsTab.ResumeLayout(false);
            this.skillsTab.PerformLayout();
            this.agentsTab.ResumeLayout(false);
            this.agentGroup.ResumeLayout(false);
            this.filtersTab.ResumeLayout(false);
            this.filterTabs.ResumeLayout(false);
            this.subFilterTab.ResumeLayout(false);
            this.subFilterTab.PerformLayout();
            this.subFilterText.ResumeLayout(false);
            this.gbFilterText.ResumeLayout(false);
            this.gbFilterText.PerformLayout();
            this.gbFilterMessages.ResumeLayout(false);
            this.gbFilterMessages.PerformLayout();
            this.subFilterSoundMusic.ResumeLayout(false);
            this.subFilterSoundMusic.PerformLayout();
            this.subFilterTargets.ResumeLayout(false);
            this.subFilterTargets.PerformLayout();
            this.hotkeysTab.ResumeLayout(false);
            this.hotkeysTab.PerformLayout();
            this.groupBox8.ResumeLayout(false);
            this.groupBox8.PerformLayout();
            this.macrosTab.ResumeLayout(false);
            this.tabControl2.ResumeLayout(false);
            this.subMacrosTab.ResumeLayout(false);
            this.subMacrosTab.PerformLayout();
            this.macroActGroup.ResumeLayout(false);
            this.subMacrosOptionsTab.ResumeLayout(false);
            this.subMacrosOptionsTab.PerformLayout();
            this.macroVariableGroup.ResumeLayout(false);
            this.scriptsTab.ResumeLayout(false);
            this.subTabScripts.ResumeLayout(false);
            this.subScripts.ResumeLayout(false);
            this.subScripts.PerformLayout();
            this.scriptSplitContainer.Panel1.ResumeLayout(false);
            this.scriptSplitContainer.Panel1.PerformLayout();
            this.scriptSplitContainer.Panel2.ResumeLayout(false);
            ((System.ComponentModel.ISupportInitialize)(this.scriptSplitContainer)).EndInit();
            this.scriptSplitContainer.ResumeLayout(false);
            ((System.ComponentModel.ISupportInitialize)(this.scriptEditor)).EndInit();
            this.subScriptOptions.ResumeLayout(false);
            this.subScriptOptions.PerformLayout();
            this.scriptVariablesBox.ResumeLayout(false);
            this.friendsTab.ResumeLayout(false);
            this.friendsTab.PerformLayout();
            this.friendsGroupBox.ResumeLayout(false);
            this.friendsGroupBox.PerformLayout();
            this.screenshotTab.ResumeLayout(false);
            this.screenshotTab.PerformLayout();
            ((System.ComponentModel.ISupportInitialize)(this.screenPrev)).EndInit();
            this.advancedTab.ResumeLayout(false);
            this.subAdvancedTab.ResumeLayout(false);
            this.advancedInfoTab.ResumeLayout(false);
            this.advancedInfoTab.PerformLayout();
            this.groupBox16.ResumeLayout(false);
            this.advancedStaffDeco.ResumeLayout(false);
            this.advancedStaffDeco.PerformLayout();
            ((System.ComponentModel.ISupportInitialize)(this.itemRandomNumber)).EndInit();
            ((System.ComponentModel.ISupportInitialize)(this.itemTileCount)).EndInit();
            this.advancedStaffDoors.ResumeLayout(false);
            this.aboutTab.ResumeLayout(false);
            this.aboutTab.PerformLayout();
            this.cooldownGumpBox.ResumeLayout(false);
            this.cooldownGumpBox.PerformLayout();
            this.ResumeLayout(false);

        }

        private System.Windows.Forms.CheckBox disableScriptStopwatch;

        private System.Windows.Forms.CheckBox enableHighlight;

        private System.Windows.Forms.CheckBox defaultScriptDelay;

        private System.Windows.Forms.TabPage subBuffsDebuffs;

        #endregion

        private TabPage scriptsTab;
        private TabControl subTabScripts;
        private TabPage subScripts;
        private Button saveScript;
        private Button newScript;
        private Button setScriptHotkey;
        private Button recordScript;
        private Button playScript;
        private System.Windows.Forms.TabPage subScriptOptions;
        private GroupBox scriptVariablesBox;
        private Button changeScriptVariable;
        private Button removeScriptVariable;
        private Button addScriptVariable;
        private ListBox scriptVariables;
        private CheckBox autoSaveScript;
        private CheckBox autoSaveScriptPlay;
        private CheckBox scriptDisablePlayFinish;
        private TabPage friendsTab;
        private CheckBox highlightFriend;
        private CheckBox autoAcceptParty;
        private CheckBox nextPrevIgnoresFriends;
        private CheckBox autoFriend;
        private GroupBox friendsGroupBox;
        private Button friendsGroupRemove;
        private Button friendsGroupAdd;
        private Button friendClearList;
        private Button friendRemoveSelected;
        private Button friendAddTarget;
        private ListBox friendsList;
        private ComboBox friendsGroup;
        private CheckBox friendsListEnabled;
        private CheckBox showFriendOverhead;
        private Button setFriendsFormatHue;
        private TextBox friendOverheadFormat;
        private Label friendFormat;
        private Button scriptGuide;
        private CheckBox showPartyFriendOverhead;
        private TabPage subWaypoints;
        private System.Windows.Forms.CheckBox waypointOnDeath;
        private Label lblWaypointTiles;
        private TextBox hideWaypointDist;
        private System.Windows.Forms.CheckBox hideWaypointWithin;
        private TextBox txtWaypointDistanceSec;
        private Label lblWaypointSeconds;
        private System.Windows.Forms.CheckBox showWaypointDistance;
        private System.Windows.Forms.CheckBox showWaypointOverhead;
        private Button btnRemoveSelectedWaypoint;
        private Button btnHideWaypoint;
        private Button btnUseCurrentLoc;
        private TextBox txtWaypointName;
        private Label lblWaypointY;
        private Label lblWaypointX;
        private TextBox txtWaypointX;
        private TextBox txtWaypointY;
        private Label lblWaypoint;
        private Button btnAddWaypoint;
        private System.Windows.Forms.ListBox waypointList;
        private TabPage filtersTab;
        private TabControl filterTabs;
        private TabPage subFilterTab;
        private ComboBox daemonAnimationList;
        private CheckBox filterDaemonGraphics;
        private ComboBox drakeAnimationList;
        private CheckBox filterDrakeGraphics;
        private ComboBox dragonAnimationList;
        private CheckBox filterDragonGraphics;
        private CheckedListBox filters;
        private TabPage subFilterTargets;
        private Label lblTargetFilter;
        private Button targetFilterClear;
        private Button targetFilterRemove;
        private Button targetFilterAdd;
        private ListBox targetFilter;
        private CheckBox targetFilterEnabled;
        private TabPage subOverheadTab;
        private CheckBox showOverheadMessages;
        private Button cliLocSearch;
        private TextBox cliLocTextSearch;
        private Label lblOhSearch;
        private ListView cliLocSearchView;
        private ColumnHeader cliLocSearchNumber;
        private ColumnHeader cliLocSearchText;
        private Label label13;
        private TextBox overheadFormat;
        private Button setOverheadMessage;
        private System.Windows.Forms.ListView cliLocOverheadView;
        private ColumnHeader cliLocOriginal;
        private ColumnHeader cliLocOverheadMessage;
        private System.Windows.Forms.Button editOverheadMessage;
        private System.Windows.Forms.Button setColorHue;
        private System.Windows.Forms.Button removeOverheadMessage;
        private Label label14;
        private System.Windows.Forms.RadioButton unicodeStyle;
        private System.Windows.Forms.RadioButton asciiStyle;
        private CheckBox overrideSpellFormat;
        private CheckBox reequipHandsPotion;
        private Button agentSetHotKey;
        private TabPage subFilterText;
        private GroupBox gbFilterText;
        private Button removeFilterText;
        private Button addFilterText;
        private ListBox textFilterList;
        private GroupBox gbFilterMessages;
        private CheckBox filterOverheadMessages;
        private Label lblFilterDelaySeconds;
        private Label lblFilterDelay;
        private TextBox filterDelaySeconds;
        private CheckBox filterRazorMessages;
        private CheckBox filterSystemMessages;
        private CheckBox filterSnoop;
        private CheckBox enableTextFilter;
        private System.Windows.Forms.CheckBox disableScriptTooltips;
        private SplitContainer scriptSplitContainer;
        private TreeView scriptTree;
        private TextBox scriptFilter;
        private FastColoredTextBoxNS.FastColoredTextBox scriptEditor;
        private Label scriptHotkey;
        private Button openScreenshotFolder;
        private CheckBox buyAgentIgnoreGold;
        private CheckBox nextPrevAbcOrder;
        private ComboBox wyrmAnimationList;
        private CheckBox filterWhiteWyrm;
        private TextBox hkCommand;
        private Label hkCmdLabel;
        private ColumnHeader cliLocSound;
        private System.Windows.Forms.Button setSound;
        private TabControl subAdvancedTab;
        private TabPage advancedInfoTab;
        private Button fontDecrease;
        private Button fontIncrease;
        private GroupBox groupBox16;
        private Label lastBackup;
        private Button openBackupFolder;
        private Button setBackupFolder;
        private Button createBackup;
        private CheckBox enableUOAAPI;
        private Button disableSmartCPU;
        private CheckBox negotiate;
        private Button openRazorDataDir;
        private ComboBox msglvl;
        private Label label17;
        private CheckBox logPackets;
        private TextBox statusBox;
        private TextBox features;
        private TabPage advancedStaffDeco;
        private UI.ArtViewer artViewer;
        private TreeView itemTree;
        private NumericUpDown itemRandomNumber;
        private CheckBox itemRandom;
        private NumericUpDown itemTileCount;
        private Button itemTile;
        private Button itemAdd;
        private CheckBox itemMovable;
        private TabPage advancedStaffDoors;
        private Button doorSouthCW;
        private Button doorSouthCCW;
        private Button doorEastCW;
        private Button doorEastCCW;
        private Button doorNorthCCW;
        private Button doorNorthCW;
        private Button doorWestCCW;
        private Button doorWestCW;
        private TreeView doorTree;
        private UI.ArtViewer doorViewer;
        private TextBox itemSearch;
        private CheckBox itemCopyToClipboard;
        private CheckBox itemAppendM;
        private FastColoredTextBoxNS.DocumentMap scriptDocMap;
        private System.Windows.Forms.CheckBox playEmoteSound;
        private GroupBox buffBarGroupBox;
        private ComboBox buffBarSort;
        private Label lblBuffSortBy;
        private TextBox buffBarWidth;
        private Label lblBuffBarWidth;
        private CheckBox showBuffIcons;
        private CheckBox showBuffDebuffGump;
        private TextBox buffBarHeight;
        private Label lblBuffBarHeight;
        private CheckBox useBlackBuffDebuffBg;
        private ComboBox showBuffDebuffTimeType;
        private Label lblShowBuffTime;
        private GroupBox cooldownGumpBox;
        private TextBox cooldownHeight;
        private Label lblCooldownHeight;
        private TextBox cooldownWidth;
        private Label lblCooldownWidth;
    }
}


================================================
FILE: Razor/UI/Razor.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Drawing;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Windows.Forms;
using System.IO;
using System.Linq;
using System.Text;
using Assistant.Filters;
using Assistant.Macros;
using System.Diagnostics;
using System.Xml;
using Assistant.Boat;
using Assistant.Agents;
using Assistant.Core;
using Assistant.Scripts;
using Assistant.Scripts.Engine;
using Assistant.UI;
using Ultima;
using Art = Assistant.UI.Art;
using ContainerLabels = Assistant.UI.ContainerLabels;
using Exception = System.Exception;

namespace Assistant
{
    public partial class MainForm
    {
        protected override void WndProc(ref Message msg)
        {
            if (msg.Msg == Client.WM_UONETEVENT)
                msg.Result =
                    (IntPtr) (Client.Instance.OnMessage(this, (uint) msg.WParam.ToInt32(), msg.LParam.ToInt32())
                        ? 1
                        : 0);
            else if (msg.Msg == Client.WM_COPYDATA)
                msg.Result = (IntPtr) (Client.Instance.OnCopyData(msg.WParam, msg.LParam) ? 1 : 0);
            else if (Config.GetBool("EnableUOAAPI") && msg.Msg >= (int) UOAssist.UOAMessage.First &&
                     msg.Msg <= (int) UOAssist.UOAMessage.Last)
                msg.Result = (IntPtr) UOAssist.OnUOAMessage(this, msg.Msg, msg.WParam.ToInt32(), msg.LParam.ToInt32());
            else
                base.WndProc(ref msg);
        }

        private void DisableCloseButton()
        {
            Platform.DisableCloseButton(this.Handle);
            m_CanClose = false;
        }

        private void MainForm_StartLoad(object sender, System.EventArgs e)
        {
            Hide();
            new StatsTimer(this).Start();
            Language.LoadControlNames(this);

            FriendsManager.SetControls(friendsGroup, friendsList);
            DressList.SetControls(dressList, dressItems);
            TargetFilterManager.SetControls(targetFilter);
            SoundMusicManager.SetControls(soundFilterList, playableMusicList);
            ScriptManager.SetControls(scriptEditor, scriptTree, scriptVariables);
            WaypointManager.SetControls(waypointList);
            OverheadManager.SetControls(cliLocOverheadView);
            TextFilterManager.SetControls(textFilterList);
            ScriptManager.SetEditor(scriptEditor);

            scriptDocMap.Target = scriptEditor;

            bool st = Config.GetBool("Systray");
            taskbar.Checked = this.ShowInTaskbar = !st;
            systray.Checked = m_NotifyIcon.Visible = st;

            UpdateTitle();

            Engine.ActiveWindow = this;

            DisableCloseButton();

            if (!Client.Instance.InstallHooks(this.Handle))
            {
                m_CanClose = true;
                SplashScreen.End();
                this.Close();
                System.Diagnostics.Process.GetCurrentProcess().Kill();
            }
        }

        public void MainForm_EndLoad()
        {
            Ultima.Multis.PostHSFormat = Engine.UsePostHSChanges;

            PacketsTable.AdjustPacketSizeByVersion(Engine.ClientVersion);

            SplashScreen.Message = LocString.Welcome;
            InitConfig();
            Show();
            BringToFront();
            tabs_IndexChanged(this, null); // load first tab
            ScriptManager.SetEditor(scriptEditor);

            m_ProfileConfirmLoad = false;
            Config.SetupProfilesList(profiles, Config.CurrentProfile.Name);
            m_ProfileConfirmLoad = true;

            showWelcome.Checked = Config.GetAppSetting<int>("ShowWelcome") == 1;

            m_Tip.Active = true;
            m_Tip.SetToolTip(titleStr, Language.GetString(LocString.TitleBarTip));

            SplashScreen.End();
        }

        private bool m_Initializing = false;

        public void InitConfig()
        {
            m_Initializing = true;

            opacity.SafeAction(s =>
            {
                s.Value = Config.GetInt("Opacity");
                s.AutoSize = false;
            });

            this.SafeAction(s =>
            {
                s.Opacity = ((float) opacity.Value) / 100.0;
                s.TopMost = s.alwaysTop.Checked = Config.GetBool("AlwaysOnTop");
                s.Location = new System.Drawing.Point(Config.GetInt("WindowX"), Config.GetInt("WindowY"));
                s.TopLevel = true;
                if (!IsOnScreen(s))
                {
                    s.Location = new System.Drawing.Point(400, 400);
                }
            });

            opacityLabel.SafeAction(s => { s.Text = Language.Format(LocString.OpacityA1, opacity.Value); });

            spellUnequip.SafeAction(s => { });

            spellUnequip.SafeAction(s => { s.Checked = Config.GetBool("SpellUnequip"); });

            ltRange.SafeAction(s =>
            {
                s.Enabled = rangeCheckLT.Checked = Config.GetBool("RangeCheckLT");
                s.Text = Config.GetInt("LTRange").ToString();
            });

            counters.SafeAction(s =>
            {
                s.BeginUpdate();

                if (Config.GetBool("SortCounters"))
                {
                    s.Sorting = SortOrder.None;
                    s.ListViewItemSorter = CounterLVIComparer.Instance;
                    s.Sort();
                }
                else
                {
                    s.ListViewItemSorter = null;
                    s.Sorting = SortOrder.Ascending;
                }

                s.EndUpdate();
                s.Refresh();
            });

            incomingMob.SafeAction(s => { s.Checked = Config.GetBool("ShowMobNames"); });

            incomingCorpse.SafeAction(s => { s.Checked = Config.GetBool("ShowCorpseNames"); });

            checkNewConts.SafeAction(s => { s.Checked = Config.GetBool("AutoSearch"); });


            excludePouches.SafeAction(s =>
            {
                s.Checked = Config.GetBool("NoSearchPouches");
                s.Enabled = checkNewConts.Checked;
            });

            warnNum.SafeAction(s =>
            {
                warnNum.Enabled = warnCount.Checked = Config.GetBool("CounterWarn");
                warnNum.Text = Config.GetInt("CounterWarnAmount").ToString();
            });

            QueueActions.SafeAction(s => { s.Checked = Config.GetBool("QueueActions"); });

            queueTargets.SafeAction(s => { s.Checked = Config.GetBool("QueueTargets"); });

            chkForceSpeechHue.SafeAction(s => { s.Checked = setSpeechHue.Enabled = Config.GetBool("ForceSpeechHue"); });

            chkForceSpellHue.SafeAction(s =>
            {
                chkForceSpellHue.Checked = setBeneHue.Enabled =
                    setNeuHue.Enabled = setHarmHue.Enabled = Config.GetBool("ForceSpellHue");
            });

            lthilight.SafeAction(s =>
            {
                if (Config.GetInt("LTHilight") != 0)
                {
                    InitPreviewHue(s, "LTHilight");
                    s.Checked = setLTHilight.Enabled = true;
                }
                else
                {
                    s.Checked = setLTHilight.Enabled = false;
                }
            });

            txtSpellFormat.SafeAction(s => { s.Text = Config.GetString("SpellFormat"); });

            txtObjDelay.SafeAction(s => { s.Text = Config.GetInt("ObjectDelay").ToString(); });

            chkStealth.SafeAction(s => { s.Checked = Config.GetBool("CountStealthSteps"); });

            radioUO.SafeAction(s => { s.Checked = !(radioFull.Checked = Config.GetBool("CapFullScreen")); });

            screenPath.SafeAction(s => { s.Text = Config.GetString("CapPath"); });

            dispTime.SafeAction(s => { s.Checked = Config.GetBool("CapTimeStamp"); });

            blockDis.SafeAction(s => { s.Checked = Config.GetBool("BlockDismount"); });

            autoOpenDoors.SafeAction(s => { s.Checked = Config.GetBool("AutoOpenDoors"); });

            objectDelay.SafeAction(s => { s.Checked = Config.GetBool("ObjectDelayEnabled"); });

            txtObjDelay.SafeAction(s => { s.Enabled = Config.GetBool("ObjectDelayEnabled"); });

            msglvl.SafeAction(s => { s.SelectedIndex = Config.GetInt("MessageLevel"); });

            imgFmt.SafeAction(s =>
            {
                try
                {
                    s.SelectedItem = Config.GetString("ImageFormat");
                }
                catch
                {
                    s.SelectedIndex = 0;
                    Config.SetProperty("ImageFormat", "jpg");
                }
            });

            lblExHue.SafeAction(s => { InitPreviewHue(s, "ExemptColor"); });

            lblMsgHue.SafeAction(s => { InitPreviewHue(s, "SysColor"); });

            lblWarnHue.SafeAction(s => { InitPreviewHue(s, "WarningColor"); });

            chkForceSpeechHue.SafeAction(s => { InitPreviewHue(s, "SpeechHue"); });

            lblBeneHue.SafeAction(s => { InitPreviewHue(s, "BeneficialSpellHue"); });

            lblHarmHue.SafeAction(s => { InitPreviewHue(s, "HarmfulSpellHue"); });

            lblNeuHue.SafeAction(s => { InitPreviewHue(s, "NeutralSpellHue"); });

            undressConflicts.SafeAction(s => { s.Checked = Config.GetBool("UndressConflicts"); });

            taskbar.SafeAction(s => { s.Checked = !(systray.Checked = Config.GetBool("Systray")); });

            titlebarImages.SafeAction(s => { s.Checked = Config.GetBool("TitlebarImages"); });

            highlightSpellReags.SafeAction(s => { s.Checked = Config.GetBool("HighlightReagents"); });

            dispDelta.SafeAction(s => { s.Checked = Config.GetBool("DisplaySkillChanges"); });

            titleStr.SafeAction(s =>
            {
                s.Enabled = showInBar.Checked = Config.GetBool("TitleBarDisplay");
                s.Text = Config.GetString("TitleBarText");
            });

            showNotoHue.SafeAction(s => { s.Checked = Config.GetBool("ShowNotoHue"); });

            corpseRange.SafeAction(s =>
            {
                s.Enabled = openCorpses.Checked = Config.GetBool("AutoOpenCorpses");
                s.Text = Config.GetInt("CorpseRange").ToString();
            });

            actionStatusMsg.SafeAction(s => { s.Checked = Config.GetBool("ActionStatusMsg"); });

            autoStackRes.SafeAction(s => { s.Checked = Config.GetBool("AutoStack"); });

            rememberPwds.SafeAction(s => { s.Checked = Config.GetBool("RememberPwds"); });

            filterSnoop.SafeAction(s => { s.Checked = Config.GetBool("FilterSnoopMsg"); });

            preAOSstatbar.SafeAction(s => { s.Checked = Config.GetBool("OldStatBar"); });

            showtargtext.SafeAction(s => { s.Checked = Config.GetBool("LastTargTextFlags"); });

            smartLT.SafeAction(s => { s.Checked = Config.GetBool("SmartLastTarget"); });

            autoFriend.SafeAction(s => { s.Checked = Config.GetBool("AutoFriend"); });
            
            forceSizeX.SafeAction(s => { s.Text = Config.GetInt("ForceSizeX").ToString(); });

            forceSizeY.SafeAction(s => { s.Text = Config.GetInt("ForceSizeY").ToString(); });

            gameSize.SafeAction(s => { s.Checked = Config.GetBool("ForceSizeEnabled"); });

            potionEquip.SafeAction(s => { s.Checked = Config.GetBool("PotionEquip"); });

            blockHealPoison.SafeAction(s => { s.Checked = Config.GetBool("BlockHealPoison"); });

            negotiate.SafeAction(s => { s.Checked = Config.GetBool("Negotiate"); });

            logPackets.SafeAction(s => { s.Checked = Config.GetBool("LogPacketsByDefault"); });

            healthFmt.SafeAction(s =>
            {
                s.Enabled = showHealthOH.Checked = Config.GetBool("ShowHealth");
                s.Text = Config.GetString("HealthFmt");
            });

            chkPartyOverhead.SafeAction(s => { s.Checked = Config.GetBool("ShowPartyStats"); });

            dressList.SafeAction(s => { s.SelectedIndex = -1; });

            hotkeyTree.SafeAction(s => { s.SelectedNode = null; });

            targetByTypeDifferent.SafeAction(s => { s.Checked = Config.GetBool("DiffTargetByType"); });

            stepThroughMacro.SafeAction(s => { s.Checked = Config.GetBool("StepThroughMacro"); });

            showTargetMessagesOverChar.SafeAction(s =>
            {
                s.Checked = Config.GetBool("ShowTargetSelfLastClearOverhead");
            });

            showOverheadMessages.SafeAction(s => { s.Checked = Config.GetBool("ShowOverheadMessages"); });
            overheadFormat.SafeAction(s => { s.Text = Config.GetString("OverheadFormat"); });

            if (Config.GetInt("OverheadStyle") == 0)
            {
                asciiStyle.SafeAction(s => { s.Checked = true; });
            }
            else
            {
                unicodeStyle.SafeAction(s => { s.Checked = true; });
            }

            showOverheadMessages.SafeAction(s => { s.Checked = Config.GetBool("ShowOverheadMessages"); });

            logSkillChanges.SafeAction(s => { s.Checked = Config.GetBool("LogSkillChanges"); });

            lightLevelBar.SafeAction(s => { s.Value = s.Maximum - Config.GetInt("LightLevel"); });

            double percent = Math.Round((lightLevelBar.Value / (double) lightLevelBar.Maximum) * 100.0);

            lightLevel.SafeAction(s => { s.Text = $"Light: {percent}%"; });

            captureMibs.SafeAction(s => { s.Checked = Config.GetBool("CaptureMibs"); });

            stealthOverhead.SafeAction(s => { s.Checked = Config.GetBool("StealthOverhead"); });

            blockOpenCorpsesTwice.SafeAction(s => { s.Checked = Config.GetBool("BlockOpenCorpsesTwice"); });

            showContainerLabels.SafeAction(s => { s.Checked = Config.GetBool("ShowContainerLabels"); });

            seasonList.SafeAction(s => { s.SelectedIndex = Config.GetInt("Season"); });

            bool st = Config.GetBool("Systray");
            taskbar.Checked = ShowInTaskbar = !st;
            systray.Checked = m_NotifyIcon.Visible = st;

            showAttackTarget.SafeAction(s => { s.Checked = Config.GetBool("ShowAttackTargetOverhead"); });

            showBuffDebuffOverhead.SafeAction(s => { s.Checked = Config.GetBool("ShowBuffDebuffOverhead"); });
            
            BuffDebuffManager.ReloadFilter();

            rangeCheckTargetByType.SafeAction(s => { s.Checked = Config.GetBool("RangeCheckTargetByType"); });

            rangeCheckDoubleClick.SafeAction(s => { s.Checked = Config.GetBool("RangeCheckDoubleClick"); });

            blockTradeRequests.SafeAction(s => { s.Checked = Config.GetBool("BlockTradeRequests"); });

            blockPartyInvites.SafeAction(s => { s.Checked = Config.GetBool("BlockPartyInvites"); });

            autoAcceptParty.SafeAction(s => { s.Checked = Config.GetBool("AutoAcceptParty"); });

            minMaxLightLevel.SafeAction(s => { s.Checked = Config.GetBool("MinMaxLightLevelEnabled"); });

            showTextTargetIndicator.SafeAction(s => { s.Checked = Config.GetBool("ShowTextTargetIndicator"); });

            showAttackTargetNewOnly.SafeAction(s => { s.Checked = Config.GetBool("ShowAttackTargetNewOnly"); });

            macroVariableTypeList.SafeAction(s => { s.SelectedIndex = 0; });

            filterDragonGraphics.SafeAction(s => { s.Checked = Config.GetBool("FilterDragonGraphics"); });

            filterDrakeGraphics.SafeAction(s => { s.Checked = Config.GetBool("FilterDrakeGraphics"); });

            LoadAnimationLists();

            showDamageDealt.SafeAction(s => { s.Checked = Config.GetBool("ShowDamageDealt"); });

            damageDealtOverhead.SafeAction(s => { s.Checked = Config.GetBool("ShowDamageDealtOverhead"); });

            showDamageTaken.SafeAction(s => { s.Checked = Config.GetBool("ShowDamageTaken"); });

            damageTakenOverhead.SafeAction(s => { s.Checked = Config.GetBool("ShowDamageTakenOverhead"); });

            razorTitleBar.SafeAction(s => { s.Text = Config.GetString("RazorTitleBarText"); });

            showInRazorTitleBar.SafeAction(s => { s.Checked = Config.GetBool("ShowInRazorTitleBar"); });

            enableUOAAPI.SafeAction(s => { s.Checked = Config.GetBool("EnableUOAAPI"); });

            lastBackup.SafeAction(s => { s.Text = $"Last Backup: {Config.GetAppSetting<string>("BackupTime")}"; });

            targetIndicatorFormat.SafeAction(s => { s.Text = Config.GetString("TargetIndicatorFormat"); });

            nextPrevIgnoresFriends.SafeAction(s => { s.Checked = Config.GetBool("NextPrevTargetIgnoresFriends"); });

            stealthStepsFormat.SafeAction(s => { s.Text = Config.GetString("StealthStepsFormat"); });

            showStaticWalls.SafeAction(s => { s.Checked = Config.GetBool("ShowStaticWalls"); });

            showStaticWallLabels.SafeAction(s => { s.Checked = Config.GetBool("ShowStaticWallLabels"); });

            showFriendOverhead.SafeAction(s => { s.Checked = Config.GetBool("ShowFriendOverhead"); });

            dispDeltaOverhead.SafeAction(s => { s.Checked = Config.GetBool("DisplaySkillChangesOverhead"); });

            macroActionDelay.SafeAction(s => { s.Checked = Config.GetBool("MacroActionDelay"); });

            autoOpenDoorWhenHidden.SafeAction(s => { s.Checked = Config.GetBool("AutoOpenDoorWhenHidden"); });

            disableMacroPlayFinish.SafeAction(s => { s.Checked = Config.GetBool("DisableMacroPlayFinish"); });


            showBandageTimer.SafeAction(s => { s.Checked = Config.GetBool("ShowBandageTimer"); });
            bandageTimerLocation.SafeAction(s => { s.SelectedIndex = Config.GetInt("ShowBandageTimerLocation"); });
            onlyShowBandageTimerSeconds.SafeAction(s => { s.Checked = Config.GetBool("OnlyShowBandageTimerEvery"); });
            bandageTimerSeconds.SafeAction(s => { s.Text = Config.GetInt("OnlyShowBandageTimerSeconds").ToString(); });
            bandageTimerFormat.SafeAction(s => { s.Text = Config.GetString("ShowBandageTimerFormat"); });
            lblBandageCountFormat.SafeAction(s => { InitPreviewHue(s, "ShowBandageTimerHue"); });

            lblTargetFormat.SafeAction(s => { InitPreviewHue(s, "TargetIndicatorHue"); });

            filterSystemMessages.SafeAction(s => { s.Checked = Config.GetBool("FilterSystemMessages"); });
            filterRazorMessages.SafeAction(s => { s.Checked = Config.GetBool("FilterRazorMessages"); });
            filterDelaySeconds.SafeAction(s => { s.Text = Config.GetDouble("FilterDelay").ToString(); });
            filterOverheadMessages.SafeAction(s => { s.Checked = Config.GetBool("FilterOverheadMessages"); });

            onlyNextPrevBeneficial.SafeAction(s => { s.Checked = Config.GetBool("OnlyNextPrevBeneficial"); });
            friendBeneficialOnly.SafeAction(s => { s.Checked = Config.GetBool("FriendlyBeneficialOnly"); });
            nonFriendlyHarmfulOnly.SafeAction(s => { s.Checked = Config.GetBool("NonFriendlyHarmfulOnly"); });

            showBandageStart.SafeAction(s => { s.Checked = Config.GetBool("ShowBandageStart"); });
            showBandageEnd.SafeAction(s => { s.Checked = Config.GetBool("ShowBandageEnd"); });
            bandageStartMessage.SafeAction(s => { s.Text = Config.GetString("BandageStartMessage"); });
            bandageEndMessage.SafeAction(s => { s.Text = Config.GetString("BandageEndMessage"); });

            captureOthersDeathDelay.SafeAction(
                s => { s.Text = Config.GetDouble("CaptureOthersDeathDelay").ToString(); });
            captureOwnDeathDelay.SafeAction(s => { s.Text = Config.GetDouble("CaptureOwnDeathDelay").ToString(); });
            captureOthersDeath.SafeAction(s => { s.Checked = Config.GetBool("CaptureOthersDeath"); });
            captureOwnDeath.SafeAction(s => { s.Checked = Config.GetBool("CaptureOwnDeath"); });

            targetFilterEnabled.SafeAction(s => { s.Checked = Config.GetBool("TargetFilterEnabled"); });

            filterDaemonGraphics.SafeAction(s => { s.Checked = Config.GetBool("FilterDaemonGraphics"); });
            filterWhiteWyrm.SafeAction(s => { s.Checked = Config.GetBool("FilterWyrmGraphics"); });

            soundFilterEnabled.SafeAction(s => { s.Checked = Config.GetBool("SoundFilterEnabled"); });
            showFilteredSound.SafeAction(s => { s.Checked = Config.GetBool("ShowFilteredSound"); });
            showPlayingSoundInfo.SafeAction(s => { s.Checked = Config.GetBool("ShowPlayingSoundInfo"); });
            showPlayingMusic.SafeAction(s => { s.Checked = Config.GetBool("ShowMusicInfo"); });

            autoSaveScript.SafeAction(s => { s.Checked = Config.GetBool("AutoSaveScript"); });
            autoSaveScriptPlay.SafeAction(s => { s.Checked = Config.GetBool("AutoSaveScriptPlay"); });

            highlightFriend.SafeAction(s => { s.Checked = Config.GetBool("HighlightFriend"); });
            
            scriptDisablePlayFinish.SafeAction(s => { s.Checked = Config.GetBool("ScriptDisablePlayFinish"); });

            showWaypointOverhead.SafeAction(s => { s.Checked = Config.GetBool("ShowWaypointOverhead"); });
            showWaypointDistance.SafeAction(s => { s.Checked = Config.GetBool("ShowWaypointDistance"); });
            txtWaypointDistanceSec.SafeAction(s => { s.Text = Config.GetInt("ShowWaypointSeconds").ToString(); });

            hideWaypointWithin.SafeAction(s => { s.Checked = Config.GetBool("ClearWaypoint"); });
            hideWaypointDist.SafeAction(s => { s.Text = Config.GetInt("HideWaypointDistance").ToString(); });

            waypointOnDeath.SafeAction(s => { s.Checked = Config.GetBool("CreateWaypointOnDeath"); });

            showPartyFriendOverhead.SafeAction(s => { s.Checked = Config.GetBool("ShowPartyFriendOverhead"); });

            overrideSpellFormat.SafeAction(s => { s.Checked = Config.GetBool("OverrideSpellFormat"); });

            reequipHandsPotion.SafeAction(s => { s.Checked = Config.GetBool("PotionReequip"); });

            enableTextFilter.SafeAction(s => { s.Checked = Config.GetBool("EnableTextFilter"); });

            disableScriptTooltips.SafeAction(s => { s.Checked = Config.GetBool("DisableScriptTooltips"); });

            buyAgentIgnoreGold.SafeAction(s => { s.Checked = Config.GetBool("BuyAgentsIgnoreGold"); });

            nextPrevAbcOrder.SafeAction(s => { s.Checked = Config.GetBool("NextPrevAlphabetical"); });

            playEmoteSound.SafeAction(s => { s.Checked = Config.GetBool("PlayEmoteSound"); });

            showBuffDebuffGump.SafeAction(s => { s.Checked = Config.GetBool("ShowBuffDebuffGump"); });
            showBuffIcons.SafeAction(s => { s.Checked = Config.GetBool("ShowBuffDebuffIcons"); });
            buffBarWidth.SafeAction(s => { s.Text = Config.GetInt("ShowBuffDebuffWidth").ToString(); });
            buffBarHeight.SafeAction(s => { s.Text = Config.GetInt("ShowBuffDebuffHeight").ToString(); });
            useBlackBuffDebuffBg.SafeAction(s => { s.Checked = Config.GetBool("UseBlackBuffDebuffBg"); });
            buffBarSort.SafeAction(s => { s.SelectedIndex = Config.GetInt("ShowBuffDebuffSort"); });
            showBuffDebuffTimeType.SafeAction(s => { s.SelectedIndex = Config.GetInt("ShowBuffDebuffTimeType"); });
            
            defaultScriptDelay.SafeAction(s => { s.Checked = Config.GetBool("DefaultScriptDelay"); });
            enableHighlight.SafeAction(s => { s.Checked = Config.GetBool("EnableHighlight"); });
            disableScriptStopwatch.SafeAction(s => { s.Checked = Config.GetBool("DisableScriptStopwatch"); });

            cooldownWidth.SafeAction(s => { s.Text = Config.GetInt("CooldownWidth").ToString(); });
            cooldownHeight.SafeAction(s => { s.Text = Config.GetInt("CooldownHeight").ToString(); });

            Engine.MainWindow.Size = new Size(Config.GetInt("WindowSizeX"), Config.GetInt("WindowSizeY"));

            // Disable SmartCPU in case it was enabled before the feature was removed
            Client.Instance.SetSmartCPU(false);

            if (!Client.IsOSI)
                DisableCUOFeatures();

            m_Initializing = false;
        }

        private class AnimData
        {
            public string Name { get; set; }
            public int BodyId { get; set; }
        }

        private List<AnimData> _animationData = new List<AnimData>();

        private void LoadAnimationLists()
        {
            int hue = 0;

            var lines = File.ReadLines(Path.Combine(Config.GetInstallDirectory(), "animdata.csv")).Select(a => a.Split(','));

            _animationData.Clear();
            dragonAnimationList.Items.Clear();
            drakeAnimationList.Items.Clear();


            foreach (string[] line in lines)
            {
                // ant_lion (787),787

                AnimData animData = new AnimData
                {
                    Name = line[0],
                    BodyId = Convert.ToInt32(line[1])
                };

                try
                {
                    Frame[] frames =
                        Animations.GetAnimation(animData.BodyId, 0, 1, ref hue, false, false);
                 
                    if (frames != null)
                    {
                        _animationData.Add(animData);
                        dragonAnimationList.Items.Add(animData.Name);
                        drakeAnimationList.Items.Add(animData.Name);
                        daemonAnimationList.Items.Add(animData.Name);
                        wyrmAnimationList.Items.Add(animData.Name);
                    }
                }
                catch //Unable to verify animation, lets add it anyway
                {
                    _animationData.Add(animData);
                    dragonAnimationList.Items.Add(animData.Name);
                    drakeAnimationList.Items.Add(animData.Name);
                    daemonAnimationList.Items.Add(animData.Name);
                    wyrmAnimationList.Items.Add(animData.Name);
                }
            }

            int animIndex = 0;

            foreach (AnimData animData in _animationData)
            {
                if (animData.BodyId.Equals(Config.GetInt("DragonGraphic")))
                {
                    dragonAnimationList.SelectedIndex = animIndex;
                    break;
                }

                animIndex++;
            }

            animIndex = 0;
            foreach (AnimData animData in _animationData)
            {
                if (animData.BodyId.Equals(Config.GetInt("DrakeGraphic")))
                {
                    drakeAnimationList.SelectedIndex = animIndex;
                    break;
                }

                animIndex++;
            }

            animIndex = 0;
            foreach (AnimData animData in _animationData)
            {
                if (animData.BodyId.Equals(Config.GetInt("DaemonGraphic")))
                {
                    daemonAnimationList.SelectedIndex = animIndex;
                    break;
                }

                animIndex++;
            }

            animIndex = 0;
            foreach (AnimData animData in _animationData)
            {
                if (animData.BodyId.Equals(Config.GetInt("WyrmGraphic")))
                {
                    wyrmAnimationList.SelectedIndex = animIndex;
                    break;
                }

                animIndex++;
            }

            MobileFilter.Load();
        }

        private void tabs_IndexChanged(object sender, System.EventArgs e)
        {
            if (tabs == null)
                return;

            if (tabs.SelectedTab != scriptsTab)
            {
                UpdateTitle();
            }

            if (tabs.SelectedTab == generalTab)
            {
                Filter.Draw(filters);
                langSel.BeginUpdate();
                langSel.Items.Clear();
                langSel.Items.AddRange(Language.GetPackNames());
                langSel.SelectedItem = Language.Current;
                langSel.EndUpdate();
            }
            else if (tabs.SelectedTab == skillsTab)
            {
                RedrawSkills();
            }
            else if (tabs.SelectedTab == displayTab)
            {
                Counter.Redraw(counters);

                titleBarParams.SelectedIndex = 0;
            }
            else if (tabs.SelectedTab == dressTab)
            {
                int sel = dressList.SelectedIndex;
                dressItems.Items.Clear();
                DressList.Redraw();
                if (sel >= 0 && sel < dressList.Items.Count)
                    dressList.SelectedIndex = sel;
            }
            else if (tabs.SelectedTab == hotkeysTab)
            {
                filterHotkeys.Text = string.Empty;

                hotkeyTree.SelectedNode = null;
                HotKey.Status = hkStatus;
                if (hotkeyTree.TopNode != null)
                    hotkeyTree.TopNode.Expand();
                else
                    HotKey.RebuildList(hotkeyTree);

                RebuildHotKeyCache();
            }
            else if (tabs.SelectedTab == agentsTab)
            {
                int sel = agentList.SelectedIndex;
                Agent.Redraw(agentList, agentGroup, agentB1, agentB2, agentB3, agentB4, agentB5, agentB6);
                if (sel >= 0 && sel < agentList.Items.Count)
                    agentList.SelectedIndex = sel;
            }
            else if (tabs.SelectedTab == advancedTab)
            {
                UpdateRazorStatus();
            }
            else if (tabs.SelectedTab == macrosTab)
            {
                RedrawMacros();

                if (MacroManager.Playing || MacroManager.Recording)
                    OnMacroStart(MacroManager.Current);
                else
                    OnMacroStop();

                if (MacroManager.Current != null)
                    MacroManager.Current.DisplayTo(actionList);

                macroActGroup.Visible = macroTree.SelectedNode != null;
            }
            else if (tabs.SelectedTab == scriptsTab)
            {
                RedrawScripts();
            }
            else if (tabs.SelectedTab == friendsTab)
            {
                FriendsManager.RedrawGroup();
            }
            else if (tabs.SelectedTab == screenshotTab)
            {
                ReloadScreenShotsList();
            }
        }

        private void subGeneralTab_IndexChanged(object sender, EventArgs e)
        {
            if (subGeneralTab == null)
                return;
        }

        private void RebuildHotKeyCache()
        {
            _hotkeyTreeViewCache.Nodes.Clear();

            foreach (TreeNode node in hotkeyTree.Nodes)
            {
                _hotkeyTreeViewCache.Nodes.Add((TreeNode) node.Clone());
            }
        }

        private void RebuildMacroCache()
        {
            _macroTreeViewCache.Nodes.Clear();

            foreach (TreeNode node in macroTree.Nodes)
            {
                _macroTreeViewCache.Nodes.Add((TreeNode) node.Clone());
            }
        }

        private void RebuildScriptCache()
        {
            _scriptTreeViewCache.Nodes.Clear();

            foreach (TreeNode node in scriptTree.Nodes)
            {
                _scriptTreeViewCache.Nodes.Add((TreeNode)node.Clone());
            }
        }

        private void RebuildItemCache()
        {
            _itemTreeCache.Nodes.Clear();

            foreach (TreeNode node in itemTree.Nodes)
            {
                _itemTreeCache.Nodes.Add((TreeNode)node.Clone());
            }
        }

        private Version m_Ver = System.Reflection.Assembly.GetCallingAssembly().GetName().Version;

        private uint m_OutPrev;
        private uint m_InPrev;

        private class StatsTimer : Timer
        {
            MainForm m_Form;

            public StatsTimer(MainForm form) : base(TimeSpan.FromSeconds(0.5), TimeSpan.FromSeconds(0.5))
            {
                m_Form = form;
            }

            protected override void OnTick()
            {
                m_Form.UpdateRazorStatus();
            }
        }

        private void UpdateRazorStatus()
        {
            if (!Client.Instance.ClientRunning)
                Close();

            uint ps = m_OutPrev;
            uint pr = m_InPrev;
            m_OutPrev = Client.Instance.TotalDataOut();
            m_InPrev = Client.Instance.TotalDataIn();

            tabs.SafeAction(s =>
            {
                if (s.SelectedTab != advancedTab)
                {
                    return;
                }
            });

            int time = 0;
            if (Client.Instance.ConnectionStart != DateTime.MinValue)
                time = (int) ((DateTime.UtcNow - Client.Instance.ConnectionStart).TotalSeconds);


            statusBox.SafeAction(s =>
            {
                if (string.IsNullOrEmpty(s.SelectedText))
                {
                    s.Lines = Language.Format(LocString.RazorStatus1,
                        m_Ver,
                        Utility.FormatSize(System.GC.GetTotalMemory(false)),
                        Utility.FormatSize(m_OutPrev), Utility.FormatSize((long) ((m_OutPrev - ps))),
                        Utility.FormatSize(m_InPrev), Utility.FormatSize((long) ((m_InPrev - pr))),
                        Utility.FormatTime(time),
                        (World.Player != null ? (uint) World.Player.Serial : 0),
                        (World.Player != null && World.Player.Backpack != null
                            ? (uint) World.Player.Backpack.Serial
                            : 0),
                        World.Items.Count,
                        World.Mobiles.Count).Split('\n');

                    if (World.Player != null)
                        statusBox.SafeAction(x =>
                            x.AppendText(
                                $"\r\nCoordinates: {World.Player.Position.X} {World.Player.Position.Y} {World.Player.Position.Z}"));
                }
            });

            if (PacketHandlers.PlayCharTime < DateTime.UtcNow &&
                PacketHandlers.PlayCharTime + TimeSpan.FromSeconds(5) < DateTime.UtcNow)
            {
                if (Config.GetBool("Negotiate"))
                {
                    bool allAllowed = true;
                    StringBuilder text = new StringBuilder();

                    text.Append(Language.GetString(LocString.NegotiateTitle));
                    text.Append("\r\n");

                    for (int i = 0; i < FeatureBit.MaxBit; i++)
                    {
                        if (!Client.Instance.AllowBit(i))
                        {
                            allAllowed = false;

                            text.Append(Language.GetString((LocString) (((int) LocString.FeatureDescBase) + i)));
                            text.Append(' ');
                            text.Append(Language.GetString(LocString.NotAllowed));
                            text.Append("\r\n");
                        }
                    }

                    if (allAllowed)
                        text.Append(Language.GetString(LocString.AllFeaturesEnabled));

                    text.Append("\r\n");

                    features.SafeAction(x => x.Visible = true);
                    features.SafeAction(x => x.Text = text.ToString());
                }
                else
                {
                    features.SafeAction(x => x.Visible = false);
                }
            }
        }

        public void UpdateSkill(Skill skill)
        {
            double total = 0;
            for (int i = 0; i < Skills.TotalSkills(); i++)
            {
                total += World.Player.Skills[i].Base;
            }

            baseTotal.Text = $"{total:F1}";

            if (Config.GetBool("LogSkillChanges"))
            {
                string skillLog = Path.Combine(Config.GetInstallDirectory(), "SkillLog");
                skillLog = Path.Combine(skillLog, $"{World.Player.Name}_{World.Player.Serial}_SkillLog.csv");


                if (!Directory.Exists(Path.GetDirectoryName(skillLog)))
                {
                    Directory.CreateDirectory(Path.GetDirectoryName(skillLog));
                }

                if (!File.Exists(skillLog))
                {
                    using (StreamWriter sr = File.CreateText(skillLog))
                    {
                        sr.WriteLine("Timestamp,SkillName,Value,Base,Gain,Cap");
                    }
                }

                using (StreamWriter sw = File.AppendText(skillLog))
                {
                    sw.WriteLine(
                        $"{DateTime.Now},{Skills.GetSkillDisplayName(skill.Index)},{skill.Value},{skill.Base},{skill.Delta},{skill.Cap}");
                }
            }

            for (int i = 0; i < skillList.Items.Count; i++)
            {
                ListViewItem cur = skillList.Items[i];
                if (cur.Tag == skill)
                {
                    cur.SubItems[1].Text = $"{skill.Value:F1}";
                    cur.SubItems[2].Text = $"{skill.Base:F1}";
                    cur.SubItems[3].Text = $"{(skill.Delta > 0 ? "+" : "")}{skill.Delta:F1}";
                    cur.SubItems[4].Text = $"{skill.Cap:F1}";
                    cur.SubItems[5].Text = skill.Lock.ToString()[0].ToString();
                    SortSkills();
                    return;
                }
            }
        }

        public void ToggleDamageTracker(bool enable)
        {
            if (World.Player == null)
            {
                DamageTracker.Stop();
                return;
            }

            if (enable)
            {
                trackDps.Checked = true;
            }
            else
            {
                trackDps.Checked = false;
            }
        }

        public void RedrawSkills()
        {
            skillList.BeginUpdate();
            skillList.Items.Clear();
            double Total = 0;
            if (World.Player != null && World.Player.SkillsSent)
            {
                string[] items = new string[6];
                for (int i = 0; i < Skills.TotalSkills(); i++)
                {
                    Skill sk = World.Player.Skills[i];
                    Total += sk.Base;
                    items[0] = Skills.GetSkillDisplayName(i);
                    items[1] = $"{sk.Value:F1}";
                    items[2] = $"{sk.Base:F1}";
                    items[3] = $"{(sk.Delta > 0 ? "+" : "")}{sk.Delta:F1}";
                    items[4] = $"{sk.Cap:F1}";
                    items[5] = sk.Lock.ToString()[0].ToString();

                    ListViewItem lvi = new ListViewItem(items);
                    lvi.Tag = sk;
                    skillList.Items.Add(lvi);
                }

                //Config.SetProperty( "SkillListAsc", false );
                SortSkills();
            }

            skillList.EndUpdate();
            baseTotal.Text = $"{Total:F1}";
        }

        private void OnFilterCheck(object sender, System.Windows.Forms.ItemCheckEventArgs e)
        {
            ((Filter) filters.Items[e.Index]).OnCheckChanged(e.NewValue);
        }

        private void incomingMob_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("ShowMobNames", incomingMob.Checked);
        }

        private void incomingCorpse_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("ShowCorpseNames", incomingCorpse.Checked);
        }

        private ContextMenuStrip m_SkillMenu;

        private void skillList_MouseDown(object sender, System.Windows.Forms.MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Right)
            {
                ListView.SelectedListViewItemCollection items = skillList.SelectedItems;
                if (items.Count <= 0)
                    return;
                Skill s = items[0].Tag as Skill;
                if (s == null)
                    return;

                if (m_SkillMenu == null)
                {
                    m_SkillMenu = new ContextMenuStrip();
                    m_SkillMenu.Items.Add(Language.GetString(LocString.SetSLUp), null, onSetSkillLockUP);
                    m_SkillMenu.Items.Add(Language.GetString(LocString.SetSLDown), null, onSetSkillLockDOWN);
                    m_SkillMenu.Items.Add(Language.GetString(LocString.SetSLLocked), null, onSetSkillLockLOCKED);
                }

                for (int i = 0; i < 3; i++)
                    ((ToolStripMenuItem)m_SkillMenu.Items[i]).Checked = ((int) s.Lock) == i;

                m_SkillMenu.Show(skillList, new Point(e.X, e.Y));
            }
        }

        private void onSetSkillLockUP(object sender, EventArgs e)
        {
            SetLock(LockType.Up);
        }

        private void onSetSkillLockDOWN(object sender, EventArgs e)
        {
            SetLock(LockType.Down);
        }

        private void onSetSkillLockLOCKED(object sender, EventArgs e)
        {
            SetLock(LockType.Locked);
        }

        private void SetLock(LockType lockType)
        {
            ListView.SelectedListViewItemCollection items = skillList.SelectedItems;
            if (items.Count <= 0)
                return;
            Skill s = items[0].Tag as Skill;
            if (s == null)
                return;

            try
            {
                Client.Instance.SendToServer(new SetSkillLock(s.Index, lockType));

                s.Lock = lockType;
                UpdateSkill(s);

                Client.Instance.SendToClient(new SkillUpdate(s));
            }
            catch
            {
            }
        }

        private void OnSkillColClick(object sender, System.Windows.Forms.ColumnClickEventArgs e)
        {
            if (e.Column == Config.GetInt("SkillListCol"))
                Config.SetProperty("SkillListAsc", !Config.GetBool("SkillListAsc"));
            else
                Config.SetProperty("SkillListCol", e.Column);
            SortSkills();
        }

        private void SortSkills()
        {
            int col = Config.GetInt("SkillListCol");
            bool asc = Config.GetBool("SkillListAsc");

            if (col < 0 || col > 5)
                col = 0;

            skillList.BeginUpdate();
            if (col == 0 || col == 5)
            {
                skillList.ListViewItemSorter = null;
                skillList.Sorting = asc ? SortOrder.Ascending : SortOrder.Descending;
            }
            else
            {
                LVDoubleComparer.Column = col;
                LVDoubleComparer.Asc = asc;

                skillList.ListViewItemSorter = LVDoubleComparer.Instance;

                skillList.Sorting = SortOrder.None;
                skillList.Sort();
            }

            skillList.EndUpdate();
            skillList.Refresh();
        }

        private class LVDoubleComparer : IComparer
        {
            public static readonly LVDoubleComparer Instance = new LVDoubleComparer();

            public static int Column
            {
                set { Instance.m_Col = value; }
            }

            public static bool Asc
            {
                set { Instance.m_Asc = value; }
            }

            private int m_Col;
            private bool m_Asc;

            private LVDoubleComparer()
            {
            }

            public int Compare(object x, object y)
            {
                if (x == null || !(x is ListViewItem))
                    return m_Asc ? 1 : -1;
                else if (y == null || !(y is ListViewItem))
                    return m_Asc ? -1 : 1;

                try
                {
                    double dx = Convert.ToDouble(((ListViewItem) x).SubItems[m_Col].Text);
                    double dy = Convert.ToDouble(((ListViewItem) y).SubItems[m_Col].Text);

                    if (dx > dy)
                        return m_Asc ? -1 : 1;
                    else if (dx == dy)
                        return 0;
                    else //if ( dx > dy )
                        return m_Asc ? 1 : -1;
                }
                catch
                {
                    return ((ListViewItem) x).Text.CompareTo(((ListViewItem) y).Text) * (m_Asc ? 1 : -1);
                }
            }
        }

        private void OnResetSkillDelta(object sender, System.EventArgs e)
        {
            if (World.Player == null)
                return;

            for (int i = 0; i < Skills.TotalSkills(); i++)
                World.Player.Skills[i].Delta = 0;

            RedrawSkills();
        }

        private void OnSetSkillLocks(object sender, System.EventArgs e)
        {
            if (locks.SelectedIndex == -1 || World.Player == null)
                return;

            LockType type = (LockType) locks.SelectedIndex;

            for (short i = 0; i < Skills.TotalSkills(); i++)
            {
                World.Player.Skills[i].Lock = type;
                Client.Instance.SendToServer(new SetSkillLock(i, type));
            }

            Client.Instance.SendToClient(new SkillsList());
            RedrawSkills();
        }

        private void OnDispSkillCheck(object sender, System.EventArgs e)
        {
            Config.SetProperty("DispSkillChanges", dispDelta.Checked);
        }

        private void delCounter_Click(object sender, System.EventArgs e)
        {
            if (counters.SelectedItems.Count <= 0)
                return;

            Counter c = counters.SelectedItems[0].Tag as Counter;

            if (c != null)
            {
                AddCounter ac = new AddCounter(c);
                switch (ac.ShowDialog(this))
                {
                    case DialogResult.Abort:
                        counters.Items.Remove(c.ViewItem);
                        Counter.List.Remove(c);
                        break;

                    case DialogResult.OK:
                        c.Set((ushort) ac.ItemID, ac.Hue, ac.NameStr, ac.FmtStr, ac.DisplayImage);
                        break;
                }
            }
        }

        private void addCounter_Click(object sender, System.EventArgs e)
        {
            AddCounter dlg = new AddCounter();

            if (dlg.ShowDialog(this) == DialogResult.OK)
            {
                Counter.Register(new Counter(dlg.NameStr, dlg.FmtStr, (ushort) dlg.ItemID, (int) dlg.Hue,
                    dlg.DisplayImage));
                Counter.Redraw(counters);
            }
        }

        private void showInBar_CheckedChanged(object sender, System.EventArgs e)
        {
            titleStr.Enabled = showInBar.Checked;
            Config.SetProperty("TitleBarDisplay", showInBar.Checked);
            Client.Instance.RequestTitlebarUpdate();
        }

        private void titleStr_TextChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("TitleBarText", titleStr.Text.TrimEnd());
            if (Config.GetBool("TitleBarDisplay"))
                Client.Instance.RequestTitlebarUpdate();
        }

        private void counters_ItemCheck(object sender, System.Windows.Forms.ItemCheckEventArgs e)
        {
            if (e.Index >= 0 && e.Index < Counter.List.Count && !Counter.SupressChecks)
            {
                ((Counter) (counters.Items[e.Index].Tag)).SetEnabled(e.NewValue == CheckState.Checked);
                Client.Instance.RequestTitlebarUpdate();
                counters.Sort();
                //counters.Refresh();
            }
        }

        public void RedrawCounters()
        {
            Counter.Redraw(counters);
        }

        private void checkNewConts_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("AutoSearch", checkNewConts.Checked);
            excludePouches.Enabled = checkNewConts.Checked;
        }

        private void warnCount_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("CounterWarn", warnCount.Checked);
            warnNum.Enabled = warnCount.Checked;
        }

        private void warnNum_TextChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("CounterWarnAmount", Utility.ToInt32(warnNum.Text.Trim(), 3));
        }

        private void alwaysTop_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("AlwaysOnTop", this.TopMost = alwaysTop.Checked);
        }

        private void profiles_SelectedIndexChanged(object sender, System.EventArgs e)
        {
            if (profiles.SelectedIndex < 0 || !m_ProfileConfirmLoad)
                return;

            string name = (string) profiles.Items[profiles.SelectedIndex];
            if (MessageBox.Show(this, Language.Format(LocString.ProfLoadQ, name), "Load?", MessageBoxButtons.YesNo,
                    MessageBoxIcon.Question) == DialogResult.Yes)
            {
                Config.Save();
                if (!Config.LoadProfile(name))
                {
                    MessageBox.Show(this, Language.GetString(LocString.ProfLoadE), "Load Error", MessageBoxButtons.OK,
                        MessageBoxIcon.Warning);
                }
                else
                {
                    InitConfig();
                    if (World.Player != null)
                        Config.SetProfileFor(World.Player);
                }

                Client.Instance.RequestTitlebarUpdate();
            }
            else
            {
                m_ProfileConfirmLoad = false;
                for (int i = 0; i < profiles.Items.Count; i++)
                {
                    if ((string) profiles.Items[i] == Config.CurrentProfile.Name)
                    {
                        profiles.SelectedIndex = i;
                        break;
                    }
                }

                m_ProfileConfirmLoad = true;
            }
        }

        private void delProfile_Click(object sender, System.EventArgs e)
        {
            if (profiles.SelectedIndex < 0)
                return;

            if (MessageBox.Show(this, "Are you sure you want to delete this profile?", "Delete Profile?",
                    MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.No)
            {
                return;
            }

            string remove = (string) profiles.Items[profiles.SelectedIndex];

            if (remove == "default")
            {
                MessageBox.Show(this, Language.GetString(LocString.NoDelete), "Not Allowed", MessageBoxButtons.OK,
                    MessageBoxIcon.Warning);
                return;
            }

            string file = Path.Combine(Config.GetUserDirectory("Profiles"), $"{remove}.xml");
            if (File.Exists(file))
            {
                File.Delete(file);
            }

            profiles.Items.Remove(remove);

            if (!Config.LoadProfile("default"))
            {
                Config.CurrentProfile.MakeDefault();
                Config.CurrentProfile.Name = "default";
            }

            InitConfig();

            m_ProfileConfirmLoad = false;
            for (int i = 0; i < profiles.Items.Count; i++)
            {
                if ((string) profiles.Items[i] == "default")
                {
                    profiles.SelectedIndex = i;
                    m_ProfileConfirmLoad = true;
                    return;
                }
            }

            int sel = profiles.Items.Count;
            profiles.Items.Add("default");
            profiles.SelectedIndex = sel;
            m_ProfileConfirmLoad = true;
        }

        public void SelectProfile(string name)
        {
            m_ProfileConfirmLoad = false;
            profiles.SelectedItem = name;
            m_ProfileConfirmLoad = true;
        }

        private void newProfile_Click(object sender, System.EventArgs e)
        {
            if (InputBox.Show(this, Language.GetString(LocString.EnterProfileName),
                Language.GetString(LocString.EnterAName)))
            {
                string str = InputBox.GetString();
                if (str == null || str == "" || str.IndexOfAny(Path.GetInvalidPathChars()) != -1 ||
                    str.IndexOfAny(m_InvalidNameChars) != -1)
                {
                    MessageBox.Show(this, Language.GetString(LocString.InvalidChars),
                        Language.GetString(LocString.Invalid), MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                m_ProfileConfirmLoad = false;
                int sel = profiles.Items.Count;
                string lwr = str.ToLower();
                for (int i = 0; i < profiles.Items.Count; i++)
                {
                    if (lwr == ((string) profiles.Items[i]).ToLower())
                    {
                        if (MessageBox.Show(this, Language.GetString(LocString.ProfExists), "Load Profile?",
                                MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
                        {
                            Config.Save();
                            profiles.SelectedIndex = i;
                            if (!Config.LoadProfile(str))
                            {
                                MessageBox.Show(this, Language.GetString(LocString.ProfLoadE), "Load Error",
                                    MessageBoxButtons.OK, MessageBoxIcon.Warning);
                            }
                            else
                            {
                                InitConfig();
                                if (World.Player != null)
                                    Config.SetProfileFor(World.Player);
                            }

                            Client.Instance.RequestTitlebarUpdate();
                        }

                        m_ProfileConfirmLoad = true;
                        return;
                    }
                }

                Config.Save();
                Config.NewProfile(str);
                profiles.Items.Add(str);
                profiles.SelectedIndex = sel;
                InitConfig();
                if (World.Player != null)
                    Config.SetProfileFor(World.Player);
                m_ProfileConfirmLoad = true;
            }
        }

        public bool CanClose
        {
            get { return m_CanClose; }
            set { m_CanClose = value; }
        }

        private void MainForm_Closing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            if (!m_CanClose && Client.Instance.ClientRunning)
            {
                DisableCloseButton();
                e.Cancel = true;
            }

            //if ( Engine.NoPatch )
            //	e.Cancel = MessageBox.Show( this, "Are you sure you want to close Razor?\n(This will not close the UO client.)", "Close Razor?", MessageBoxButtons.YesNo, MessageBoxIcon.Question ) == DialogResult.No;
        }

        private void skillCopySel_Click(object sender, System.EventArgs e)
        {
            if (skillList.SelectedItems == null || skillList.SelectedItems.Count <= 0)
                return;

            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < skillList.SelectedItems.Count; i++)
            {
                ListViewItem vi = skillList.SelectedItems[i];
                if (vi != null && vi.SubItems != null && vi.SubItems.Count > 4)
                {
                    string name = vi.SubItems[0].Text;
                    if (name != null && name.Length > 20)
                        name = name.Substring(0, 16) + "...";

                    sb.AppendFormat("{0,-20} {1,5:F1} {2,5:F1} {4:F1} {5,5:F1}\n",
                        name,
                        vi.SubItems[1].Text,
                        vi.SubItems[2].Text,
                        Utility.ToInt32(vi.SubItems[3].Text, 0) < 0 ? "" : "+",
                        vi.SubItems[3].Text,
                        vi.SubItems[4].Text);
                }
            }

            if (sb.Length > 0)
                Clipboard.SetDataObject(sb.ToString(), true);
        }

        private void skillCopyAll_Click(object sender, System.EventArgs e)
        {
            if (World.Player == null)
                return;

            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < Skills.TotalSkills(); i++)
            {
                Skill sk = World.Player.Skills[i];
                sb.AppendFormat("{0,-20} {1,-5:F1} {2,-5:F1} {3}{4,-5:F1} {5,-5:F1}\n", Ultima.Skills.GetSkillDisplayName(i), sk.Value,
                    sk.Base, sk.Delta > 0 ? "+" : "", sk.Delta, sk.Cap);
            }

            if (sb.Length > 0)
                Clipboard.SetDataObject(sb.ToString(), true);
        }

        private void addDress_Click(object sender, System.EventArgs e)
        {
            if (InputBox.Show(this, Language.GetString(LocString.DressName), Language.GetString(LocString.EnterAName)))
            {
                string str = InputBox.GetString();
                if (str == null || str == "")
                    return;
                DressList list = new DressList(str);
                DressList.Add(list);

                dressList.SafeAction(s =>
                {
                    s.Items.Add(list);
                    s.SelectedItem = list;
                });
            }
        }

        private void removeDress_Click(object sender, System.EventArgs e)
        {
            DressList dress = (DressList) dressList.SelectedItem;

            if (dress != null && MessageBox.Show(this, Language.GetString(LocString.DelDressQ), "Confirm",
                    MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
            {
                dress.Items.Clear();

                dressList.SafeAction(s =>
                {
                    s.Items.Remove(dress);
                    s.SelectedIndex = -1;
                });

                dressItems.SafeAction(s => s.Items.Clear());

                DressList.Remove(dress);
            }
        }

        private void dressNow_Click(object sender, System.EventArgs e)
        {
            DressList dress = (DressList) dressList.SelectedItem;
            if (dress != null && World.Player != null)
                dress.Dress();
        }

        private void undressList_Click(object sender, System.EventArgs e)
        {
            DressList dress = (DressList) dressList.SelectedItem;
            if (dress != null && World.Player != null && World.Player.Backpack != null)
                dress.Undress();
        }

        private void targItem_Click(object sender, System.EventArgs e)
        {
            Targeting.OneTimeTarget(new Targeting.TargetResponseCallback(OnDressItemTarget));
        }

        private void OnDressItemTarget(bool loc, Serial serial, Point3D pt, ushort itemid)
        {
            if (loc)
                return;

            ShowMe();
            if (serial.IsItem)
            {
                DressList list = (DressList) dressList.SelectedItem;

                if (list == null)
                    return;

                list.Items.Add(serial);
                Item item = World.FindItem(serial);

                dressItems.SafeAction(s =>
                {
                    if (item == null)
                        s.Items.Add(Language.Format(LocString.OutOfRangeA1, serial));
                    else
                        s.Items.Add(item.ToString());
                });
            }
        }

        private void dressDelSel_Click(object sender, System.EventArgs e)
        {
            DressList list = (DressList) dressList.SelectedItem;
            if (list == null)
                return;

            int sel = dressItems.SelectedIndex;
            if (sel < 0 || sel >= list.Items.Count)
                return;

            if (MessageBox.Show(this, Language.GetString(LocString.DelDressItemQ), "Confirm", MessageBoxButtons.YesNo,
                    MessageBoxIcon.Question) == DialogResult.Yes)
            {
                try
                {
                    list.Items.RemoveAt(sel);
                    dressItems.SafeAction(s => s.Items.RemoveAt(sel));
                }
                catch
                {
                }
            }
        }

        private void clearDress_Click(object sender, System.EventArgs e)
        {
            DressList list = (DressList) dressList.SelectedItem;
            if (list == null)
                return;

            if (MessageBox.Show(this, Language.GetString(LocString.Confirm), Language.GetString(LocString.ClearList),
                    MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
            {
                list.Items.Clear();
                dressItems.SafeAction(s => s.Items.Clear());
            }
        }

        private DressList undressBagList = null;

        private void undressBag_Click(object sender, System.EventArgs e)
        {
            if (World.Player == null)
                return;

            DressList list = (DressList) dressList.SelectedItem;
            if (list == null)
                return;

            undressBagList = list;
            Targeting.OneTimeTarget(new Targeting.TargetResponseCallback(onDressBagTarget));
            World.Player.SendMessage(MsgLevel.Force, LocString.TargUndressBag, list.Name);
        }

        void onDressBagTarget(bool location, Serial serial, Point3D p, ushort gfxid)
        {
            if (undressBagList == null)
                return;

            ShowMe();
            if (serial.IsItem)
            {
                Item item = World.FindItem(serial);
                if (item != null)
                {
                    undressBagList.SetUndressBag(item.Serial);
                    World.Player.SendMessage(MsgLevel.Force, LocString.UB_Set);
                }
                else
                {
                    undressBagList.SetUndressBag(Serial.Zero);
                    World.Player.SendMessage(MsgLevel.Force, LocString.ItemNotFound);
                }
            }
            else
            {
                World.Player.SendMessage(MsgLevel.Force, LocString.ItemNotFound);
            }

            undressBagList = null;
        }

        private void dressList_SelectedIndexChanged(object sender, System.EventArgs e)
        {
            DressList list = (DressList) dressList.SelectedItem;

            dressItems.BeginUpdate();
            dressItems.Items.Clear();
            if (list != null)
            {
                for (int i = 0; i < list.Items.Count; i++)
                {
                    if (list.Items[i] is Serial)
                    {
                        Serial serial = (Serial) list.Items[i];
                        Item item = World.FindItem(serial);

                        if (item != null)
                            dressItems.Items.Add(item.ToString());
                        else
                            dressItems.Items.Add(Language.Format(LocString.OutOfRangeA1, serial));
                    }
                    else if (list.Items[i] is ItemID)
                    {
                        dressItems.Items.Add(list.Items[i].ToString());
                    }
                }
            }

            dressItems.EndUpdate();
        }

        private void dressUseCur_Click(object sender, System.EventArgs e)
        {
            DressList list = (DressList) dressList.SelectedItem;
            if (World.Player == null)
                return;
            if (list == null)
                return;

            for (int i = 0; i < World.Player.Contains.Count; i++)
            {
                Item item = (Item) World.Player.Contains[i];
                if (item.Layer <= Layer.LastUserValid && item.Layer != Layer.Backpack && item.Layer != Layer.Hair &&
                    item.Layer != Layer.FacialHair)
                    list.Items.Add(item.Serial);
            }

            dressList.SafeAction(s =>
            {
                s.SelectedItem = null;
                s.SelectedItem = list;
            });
        }

        private void hotkeyTree_AfterSelect(object sender, System.Windows.Forms.TreeViewEventArgs e)
        {
            ClearHKCtrls();

            if (e.Node == null || !(e.Node.Tag is KeyData))
                return;
            KeyData hk = (KeyData) e.Node.Tag;

            try
            {
                m_LastKV = hk.Key;
                switch (hk.Key)
                {
                    case -1:
                        hkKey.Text = ("MouseWheel UP");
                        break;
                    case -2:
                        hkKey.Text = ("MouseWheel DOWN");
                        break;
                    case -3:
                        hkKey.Text = ("Mouse MID Button");
                        break;
                    case -4:
                        hkKey.Text = ("Mouse XButton 1");
                        break;
                    case -5:
                        hkKey.Text = ("Mouse XButton 2");
                        break;
                    default:
                        if (hk.Key > 0 && hk.Key < 256)
                            hkKey.Text = (((Keys) hk.Key).ToString());
                        else
                            hkKey.Text = ("");
                        break;
                }
            }
            catch
            {
                hkKey.Text = ">>ERROR<<";
            }

            chkCtrl.Checked = (hk.Mod & ModKeys.Control) != 0;
            chkAlt.Checked = (hk.Mod & ModKeys.Alt) != 0;
            chkShift.Checked = (hk.Mod & ModKeys.Shift) != 0;
            chkPass.Checked = hk.SendToUO;

            hkCommand.Text = hk.Command;

            if ((hk.LocName >= (int) LocString.DrinkHeal && hk.LocName <= (int) LocString.DrinkAg &&
                 !Client.Instance.AllowBit(FeatureBit.PotionHotkeys)) ||
                (hk.LocName >= (int) LocString.TargCloseRed && hk.LocName <= (int) LocString.TargCloseCriminal &&
                 !Client.Instance.AllowBit(FeatureBit.ClosestTargets)) ||
                (((hk.LocName >= (int) LocString.TargRandRed && hk.LocName <= (int) LocString.TargRandNFriend) ||
                  (hk.LocName >= (int) LocString.TargRandEnemyHuman && hk.LocName <= (int) LocString.TargRandCriminal)
                 ) && !Client.Instance.AllowBit(FeatureBit.RandomTargets)))
            {
                LockControl(chkCtrl);
                LockControl(chkAlt);
                LockControl(chkShift);
                LockControl(chkPass);
                LockControl(hkKey);
                LockControl(hkCommand);
                LockControl(unsetHK);
                LockControl(setHK);
                LockControl(dohotkey);
            }
        }

        private KeyData GetSelectedHK()
        {
            if (hotkeyTree != null && hotkeyTree.SelectedNode != null)
                return hotkeyTree.SelectedNode.Tag as KeyData;
            else
                return null;
        }

        private void ClearHKCtrls()
        {
            m_LastKV = 0;
            hkKey.Text = "";
            hkCommand.Text = "";
            chkCtrl.Checked = false;
            chkAlt.Checked = false;
            chkShift.Checked = false;
            chkPass.Checked = false;

            UnlockControl(chkCtrl);
            UnlockControl(chkAlt);
            UnlockControl(chkShift);
            UnlockControl(chkPass);
            UnlockControl(hkKey);
            UnlockControl(hkCommand);
            UnlockControl(unsetHK);
            UnlockControl(setHK);
            UnlockControl(dohotkey);
        }

        private void setHK_Click(object sender, System.EventArgs e)
        {
            KeyData hk = GetSelectedHK();
            if (hk == null || m_LastKV == 0)
                return;

            ModKeys mod = ModKeys.None;
            if (chkCtrl.Checked)
                mod |= ModKeys.Control;
            if (chkAlt.Checked)
                mod |= ModKeys.Alt;
            if (chkShift.Checked)
                mod |= ModKeys.Shift;

            KeyData g = HotKey.Get(m_LastKV, mod);
            bool block = false;

            if (g != null && g != hk)
            {
                if (MessageBox.Show(this, Language.Format(LocString.KeyUsed, g.DisplayName, hk.DisplayName),
                        "Hot Key Conflict", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
                {
                    g.Key = 0;
                    g.Mod = ModKeys.None;
                    g.SendToUO = false;
                    g.Command = hkCommand.Text;
                }
                else
                {
                    block = true;
                }
            }

            if (!block)
            {
                hk.Key = m_LastKV;
                hk.Mod = mod;

                hk.SendToUO = chkPass.Checked;
            }

            if (!string.IsNullOrEmpty(hkCommand.Text))
            {
                if (HotKey.ValidateCommand(hkCommand.Text.Trim()))
                {
                    hk.Command = hkCommand.Text.Trim();
                }
                else
                {
                    MessageBox.Show(this, "That hotkey command is already in use, please enter another.", "HotKey Command In Use", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    hk.Command = string.Empty;
                }
            }

            if (!string.IsNullOrEmpty(filterHotkeys.Text))
            {
                TreeNode node = hotkeyTree.SelectedNode;

                HotKey.RebuildList(hotkeyTree);
                RebuildHotKeyCache();

                filterHotkeys_TextChanged(sender, e);

                hotkeyTree.SelectedNode = node;
            }
        }

        private void unsetHK_Click(object sender, System.EventArgs e)
        {
            KeyData hk = GetSelectedHK();
            if (hk == null)
                return;

            hk.Key = 0;
            hk.Mod = 0;
            hk.SendToUO = false;
            hk.Command = string.Empty;

            ClearHKCtrls();

            if (!string.IsNullOrEmpty(filterHotkeys.Text))
            {
                TreeNode node = hotkeyTree.SelectedNode;

                HotKey.RebuildList(hotkeyTree);
                RebuildHotKeyCache();

                filterHotkeys_TextChanged(sender, e);

                hotkeyTree.SelectedNode = node;
            }
        }

        private void key_KeyUp(object sender, System.Windows.Forms.KeyEventArgs e)
        {
            m_LastKV = (int) e.KeyCode;
            hkKey.Text = e.KeyCode.ToString();

            e.Handled = true;
        }

        private void key_MouseWheel(object sender, System.Windows.Forms.MouseEventArgs e)
        {
            if (e.Delta > 0)
            {
                m_LastKV = -1;
                hkKey.Text = "MouseWheel UP";
            }
            else if (e.Delta < 0)
            {
                m_LastKV = -2;
                hkKey.Text = "MouseWheel DOWN";
            }
        }

        private void key_MouseDown(object sender, System.Windows.Forms.MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Middle)
            {
                m_LastKV = -3;
                hkKey.Text = "Mouse MID Button";
            }
            else if (e.Button == MouseButtons.XButton1)
            {
                m_LastKV = -4;
                hkKey.Text = "Mouse XButton 1";
            }
            else if (e.Button == MouseButtons.XButton2)
            {
                m_LastKV = -5;
                hkKey.Text = "Mouse XButton 2";
            }
        }

        private void dohotkey_Click(object sender, System.EventArgs e)
        {
            KeyData hk = GetSelectedHK();
            if (hk != null && World.Player != null)
            {
                if (MacroManager.AcceptActions)
                    MacroManager.Action(new HotKeyAction(hk));

                ScriptManager.AddToScript($"hotkey '{hk.DisplayName}'");

                hk.Callback();
            }
        }

        private void queueTargets_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("QueueTargets", queueTargets.Checked);
        }

        private void chkForceSpeechHue_CheckedChanged(object sender, System.EventArgs e)
        {
            setSpeechHue.Enabled = chkForceSpeechHue.Checked;
            Config.SetProperty("ForceSpeechHue", chkForceSpeechHue.Checked);
        }

        private void lthilight_CheckedChanged(object sender, System.EventArgs e)
        {
            if (!(setLTHilight.Enabled = lthilight.Checked))
            {
                Config.SetProperty("LTHilight", 0);
                Client.Instance.SetCustomNotoHue(0);
                lthilight.BackColor = SystemColors.Control;
                lthilight.ForeColor = SystemColors.ControlText;
            }
        }

        private void chkForceSpellHue_CheckedChanged(object sender, System.EventArgs e)
        {
            if (chkForceSpellHue.Checked)
            {
                setBeneHue.Enabled = setHarmHue.Enabled = setNeuHue.Enabled = true;
                Config.SetProperty("ForceSpellHue", true);
            }
            else
            {
                setBeneHue.Enabled = setHarmHue.Enabled = setNeuHue.Enabled = false;
                Config.SetProperty("ForceSpellHue", false);
            }
        }

        private void txtSpellFormat_TextChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("SpellFormat", txtSpellFormat.Text.Trim());
        }

        private void InitPreviewHue(Control ctrl, string cfg)
        {
            int hueIdx = Config.GetInt(cfg);
            if (hueIdx > 0 && hueIdx < 3000)
                ctrl.BackColor = Ultima.Hues.GetHue(hueIdx - 1).GetColor(HueEntry.TextHueIDX);
            else
                ctrl.BackColor = SystemColors.Control;
            ctrl.ForeColor = (ctrl.BackColor.GetBrightness() < 0.35 ? Color.White : Color.Black);
        }

        private bool SetHue(Control ctrl, string cfg)
        {
            HueEntry h = new HueEntry(Config.GetInt(cfg));

            if (h.ShowDialog(this) == DialogResult.OK)
            {
                int hueIdx = h.Hue;
                Config.SetProperty(cfg, hueIdx);
                if (hueIdx > 0 && hueIdx < 3000)
                    ctrl.BackColor = Ultima.Hues.GetHue(hueIdx - 1).GetColor(HueEntry.TextHueIDX);
                else
                    ctrl.BackColor = Color.White;
                ctrl.ForeColor = (ctrl.BackColor.GetBrightness() < 0.35 ? Color.White : Color.Black);

                return true;
            }
            else
            {
                return false;
            }
        }

        private void setExHue_Click(object sender, System.EventArgs e)
        {
            SetHue(lblExHue, "ExemptColor");
        }

        private void setMsgHue_Click(object sender, System.EventArgs e)
        {
            SetHue(lblMsgHue, "SysColor");
        }

        private void setWarnHue_Click(object sender, System.EventArgs e)
        {
            SetHue(lblWarnHue, "WarningColor");
        }

        private void setSpeechHue_Click(object sender, System.EventArgs e)
        {
            SetHue(chkForceSpeechHue, "SpeechHue");
        }

        private void setLTHilight_Click(object sender, System.EventArgs e)
        {
            if (SetHue(lthilight, "LTHilight"))
                Client.Instance.SetCustomNotoHue(Config.GetInt("LTHilight"));
        }

        private void setBeneHue_Click(object sender, System.EventArgs e)
        {
            SetHue(lblBeneHue, "BeneficialSpellHue");
        }

        private void setHarmHue_Click(object sender, System.EventArgs e)
        {
            SetHue(lblHarmHue, "HarmfulSpellHue");
        }

        private void setNeuHue_Click(object sender, System.EventArgs e)
        {
            SetHue(lblNeuHue, "NeutralSpellHue");
        }

        private void QueueActions_CheckedChanged(object sender, System.EventArgs e)
        {
            //txtObjDelay.Enabled = QueueActions.Checked;
            Config.SetProperty("QueueActions", QueueActions.Checked);
        }

        private void txtObjDelay_TextChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("ObjectDelay", Utility.ToInt32(txtObjDelay.Text.Trim(), 500));
        }

        private void chkStealth_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("CountStealthSteps", chkStealth.Checked);

            stealthOverhead.Enabled = chkStealth.Checked;
        }

        private void agentList_SelectedIndexChanged(object sender, System.EventArgs e)
        {
            try
            {
                Agent.Select(agentList.SelectedIndex, agentList, agentSubList, agentGroup, agentB1, agentB2, agentB3,
                    agentB4, agentB5, agentB6);

                agentSetHotKey.Visible = true;
            }
            catch
            {
            }
        }

        private void Agent_Button(int b)
        {
            if (World.Player == null)
                return;

            Agent a = agentList.SelectedItem as Agent;
            if (a == null)
                agentList.SelectedIndex = -1;
            else
                a.OnButtonPress(b);
        }

        private void agentB1_Click(object sender, System.EventArgs e)
        {
            Agent_Button(1);
        }

        private void agentB2_Click(object sender, System.EventArgs e)
        {
            Agent_Button(2);
        }

        private void agentB3_Click(object sender, System.EventArgs e)
        {
            Agent_Button(3);
        }

        private void agentB4_Click(object sender, System.EventArgs e)
        {
            Agent_Button(4);
        }

        private void agentB5_Click(object sender, System.EventArgs e)
        {
            Agent_Button(5);
        }

        private void agentB6_Click(object sender, System.EventArgs e)
        {
            Agent_Button(6);
        }

        private void MainForm_Activated(object sender, System.EventArgs e)
        {
            DisableCloseButton();
            //this.TopMost = true;
        }

        private void MainForm_Deactivate(object sender, System.EventArgs e)
        {
            if (this.TopMost)
                this.TopMost = false;
        }

        private void MainForm_Resize(object sender, System.EventArgs e)
        {
            if (WindowState == FormWindowState.Minimized && !this.ShowInTaskbar)
                this.Hide();
        }

        private void MainForm_ResizeEnd(object sender, System.EventArgs e)
        {
            cliLocOverheadView.SafeAction(s =>
            {
                s.BeginUpdate();
                s.AutoResizeColumns(ColumnHeaderAutoResizeStyle.ColumnContent);
                s.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize);
                s.EndUpdate();
            });

            cliLocSearchView.SafeAction(s =>
            {
                s.BeginUpdate();
                s.AutoResizeColumns(ColumnHeaderAutoResizeStyle.ColumnContent);
                s.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize);
                s.EndUpdate();
            });

            counters.SafeAction(s =>
            {
                s.BeginUpdate();
                s.AutoResizeColumns(ColumnHeaderAutoResizeStyle.ColumnContent);
                s.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize);
                s.EndUpdate();
            });

            skillList.SafeAction(s =>
            {
                s.BeginUpdate();
                s.AutoResizeColumns(ColumnHeaderAutoResizeStyle.ColumnContent);
                s.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize);
                s.EndUpdate();
            });

            Config.SetProperty("WindowSizeX", Engine.MainWindow.Size.Width);
            Config.SetProperty("WindowSizeY", Engine.MainWindow.Size.Height);
        }

        private bool IsNear(int a, int b)
        {
            return (a <= b + 5 && a >= b - 5);
        }

        public bool IsOnScreen(Form form)
        {
            Screen[] screens = Screen.AllScreens;
            foreach (Screen screen in screens)
            {
                Point formTopLeft = new Point(form.Left, form.Top);

                if (screen.WorkingArea.Contains(formTopLeft))
                {
                    return true;
                }
            }

            return false;
        }

        private void MainForm_Move(object sender, System.EventArgs e)
        {
            // atempt to dock to the side of the screen.  Also try not to save the X/Y when we are minimized (which is -32000, -32000)
            System.Drawing.Point pt = this.Location;

            Rectangle screen = Screen.GetWorkingArea(this);
            if (this.WindowState != FormWindowState.Minimized && pt.X + this.Width / 2 >= screen.Left &&
                pt.Y + this.Height / 2 >= screen.Top && pt.X <= screen.Right && pt.Y <= screen.Bottom)
            {
                if (IsNear(pt.X + this.Width, screen.Right))
                    pt.X = screen.Right - this.Width;
                else if (IsNear(pt.X, screen.Left))
                    pt.X = screen.Left;

                if (IsNear(pt.Y + this.Height, screen.Bottom))
                    pt.Y = screen.Bottom - this.Height;
                else if (IsNear(pt.Y, screen.Top))
                    pt.Y = screen.Top;

                this.Location = pt;
                Config.SetProperty("WindowX", (int) pt.X);
                Config.SetProperty("WindowY", (int) pt.Y);
            }
        }

        private void opacity_Scroll(object sender, System.EventArgs e)
        {
            int o = opacity.Value;
            Config.SetProperty("Opacity", o);
            opacityLabel.Text = $"Opacity: {o}%";
            this.Opacity = ((double) o) / 100.0;
        }

        private void dispDelta_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("DisplaySkillChanges", dispDelta.Checked);
        }

        /*private void saveProfile_Click(object sender, System.EventArgs e)
        {
             Counter.Save();
             Config.Save();
             MacroManager.Save();
             MessageBox.Show( this, Language.GetString( LocString.SaveOK ), "Save OK", MessageBoxButtons.OK, MessageBoxIcon.Information );
        }

        private void edit_Click(object sender, System.EventArgs e)
        {
             if ( counters.SelectedItems.Count <= 0 )
                  return;

             Counter c = counters.SelectedItems[0].Tag as Counter;
             if ( c == null )
                  return;

             AddCounter dlg = new AddCounter( c.Name, c.Format, c.ItemID, c.Hue );

             if ( dlg.ShowDialog( this ) == DialogResult.OK )
             {
                  c.Name = dlg.NameStr;
                  c.Format = dlg.FmtStr;
                  c.ItemID = (ushort)dlg.ItemID;
                  c.Hue = (int)dlg.Hue;
                  Counter.Redraw( counters );
             }
        }*/

        private void logPackets_CheckedChanged(object sender, System.EventArgs e)
        {
            if (logPackets.Checked)
            {
                if (m_Initializing || MessageBox.Show(this, Language.GetString(LocString.PacketLogWarn), "Caution!",
                        MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.Yes)
                    Packet.Logging = true;
                else
                    logPackets.Checked = false;
            }
            else
            {
                Packet.Logging = false;
            }
        }

        private void showNotoHue_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("ShowNotoHue", showNotoHue.Checked);
            if (showNotoHue.Checked)
                Client.Instance.RequestTitlebarUpdate();
        }

        private void recount_Click(object sender, System.EventArgs e)
        {
            Counter.FullRecount();
        }

        private void openCorpses_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("AutoOpenCorpses", openCorpses.Checked);
            corpseRange.Enabled = openCorpses.Checked;
        }

        private void corpseRange_TextChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("CorpseRange", Utility.ToInt32(corpseRange.Text, 2));
        }

        private void showWelcome_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetAppSetting("ShowWelcome", (showWelcome.Checked ? 1 : 0).ToString());
        }

        private ContextMenuStrip m_DressItemsMenu = null;

        private void dressItems_MouseDown(object sender, System.Windows.Forms.MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Right)
            {
                m_DressItemsMenu = new ContextMenuStrip();
                m_DressItemsMenu.Items.Add(Language.GetString(LocString.Conv2Type), null, OnMakeType);
                m_DressItemsMenu.Show(dressItems, new Point(e.X, e.Y));
            }
        }

        private void OnMakeType(object sender, System.EventArgs e)
        {
            DressList list = (DressList) dressList.SelectedItem;
            if (list == null)
                return;
            int sel = dressItems.SelectedIndex;
            if (sel < 0 || sel >= list.Items.Count)
                return;

            if (list.Items[sel] is Serial)
            {
                Serial s = (Serial) list.Items[sel];
                Item item = World.FindItem(s);
                if (item != null)
                {
                    list.Items[sel] = item.ItemID;
                    dressItems.BeginUpdate();
                    dressItems.Items[sel] = item.ItemID.ToString();
                    dressItems.EndUpdate();
                }
            }
        }

        private static char[] m_InvalidNameChars = new char[] {'/', '\\', ';', '?', ':', '*'};

        private void newMacro_Click(object sender, System.EventArgs e)
        {
            if (InputBox.Show(this, Language.GetString(LocString.NewMacro), Language.GetString(LocString.EnterAName)))
            {
                string name = InputBox.GetString();
                if (name == null || name == "" || name.IndexOfAny(Path.GetInvalidPathChars()) != -1 ||
                    name.IndexOfAny(m_InvalidNameChars) != -1)
                {
                    MessageBox.Show(this, Language.GetString(LocString.InvalidChars),
                        Language.GetString(LocString.Invalid), MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                TreeNode node = GetMacroDirNode();
                string path = (node == null || !(node.Tag is string))
                    ? Config.GetUserDirectory("Macros")
                    : (string) node.Tag;
                path = Path.Combine(path, name + ".macro");
                if (File.Exists(path))
                {
                    MessageBox.Show(this, Language.GetString(LocString.MacroExists),
                        Language.GetString(LocString.Invalid), MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                try
                {
                    bool createFromClipboard = false;

                    // TODO: Instead of contains, do we want to look at the first X number of characters
                    if (Clipboard.GetText().Contains("Assistant.Macros."))
                    {
                        createFromClipboard = MessageBox.Show(this, Language.GetString(LocString.NewClipboardMacro),
                                                  "Create new macro from clipboard?", MessageBoxButtons.YesNo,
                                                  MessageBoxIcon.Question) == DialogResult.Yes;

                        if (createFromClipboard)
                        {
                            string[] macroCommands = Clipboard.GetText()
                                .Split(new[] {"\r\n", "\r", "\n"}, StringSplitOptions.None);

                            File.WriteAllLines(path, macroCommands);

                            Clipboard.Clear();
                        }
                        else
                        {
                            File.CreateText(path).Close();
                        }
                    }

                    // If they didn't create from clipboard, create empty macro
                    if (!createFromClipboard)
                    {
                        File.CreateText(path).Close();
                    }
                }
                catch
                {
                    // access issue or other issue, create empty macro and move on
                    File.CreateText(path).Close();
                }

                Macro m = new Macro(path);
                MacroManager.Add(m);
                TreeNode newNode = new TreeNode(Path.GetFileNameWithoutExtension(m.Filename));
                newNode.Tag = m;
                if (node == null)
                    macroTree.Nodes.Add(newNode);
                else
                    node.Nodes.Add(newNode);
                macroTree.SelectedNode = newNode;
            }

            filterMacros.Text = string.Empty;

            RedrawMacros();
        }

        public Macro GetMacroSel()
        {
            if (macroTree.SelectedNode == null || !(macroTree.SelectedNode.Tag is Macro))
                return null;
            else
                return (Macro) macroTree.SelectedNode.Tag;
        }

        public RazorScript GetScriptSel()
        {
            if (scriptTree.SelectedNode == null || !(scriptTree.SelectedNode.Tag is RazorScript))
            {
                return null;
            }
            else
            {
                return (RazorScript)scriptTree.SelectedNode.Tag;
            }
        }

        public void playMacro_Click(object sender, System.EventArgs e)
        {
            if (World.Player == null)
                return;

            // Playing is true if the timer is running which in a step-through scenario isn't true
            if (MacroManager.Playing || MacroManager.StepThrough)
            {
                MacroManager.Stop();
                nextMacroAction.Enabled = false;
            }
            else
            {
                Macro m = GetMacroSel();
                if (m == null || m.Actions.Count <= 0)
                    return;

                // Check if we're going to step through the macro
                nextMacroAction.Enabled = stepThroughMacro.Checked;
                m.StepThrough = stepThroughMacro.Checked;

                actionList.SelectedIndex = 0;
                MacroManager.Play(m);
                playMacro.Text = "Stop";
                recMacro.Enabled = false;
                OnMacroStart(m);
            }
        }

        private void recMacro_Click(object sender, System.EventArgs e)
        {
            if (World.Player == null)
                return;

            if (MacroManager.Recording)
            {
                MacroManager.Stop();
                //OnMacroStop();
            }
            else
            {
                Macro m = GetMacroSel();
                if (m == null)
                    return;

                bool rec = true;
                if (m.Actions.Count > 0)
                    rec = MessageBox.Show(this, Language.GetString(LocString.MacroConfRec), "Overwrite?",
                              MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes;

                if (rec)
                {
                    MacroManager.Record(m);
                    OnMacroStart(m);
                    recMacro.Text = "Stop";
                    playMacro.Enabled = false;
                }
            }
        }

        public void OnMacroStart(Macro m)
        {
            actionList.SelectedIndex = -1;
            macroTree.Enabled = actionList.Enabled = false;
            newMacro.Enabled = delMacro.Enabled = false;
            //macroList.SelectedItem = m;
            macroTree.SelectedNode = FindNode(macroTree.Nodes, m);
            macroTree.Update();
            macroTree.Refresh();
            m.DisplayTo(actionList);
        }

        public void PlayMacro(Macro m)
        {
            playMacro.Text = "Stop";
            recMacro.Enabled = false;
        }

        public void PlayScript()
        {
            playScript.Text = "Stop";
            recordScript.Enabled = false;
        }

        public void OnMacroStop()
        {
            recMacro.Text = "Record";
            recMacro.Enabled = true;
            playMacro.Text = "Play";
            playMacro.Enabled = true;
            actionList.SelectedIndex = -1;
            macroTree.Enabled = actionList.Enabled = true;
            newMacro.Enabled = delMacro.Enabled = true;
            nextMacroAction.Enabled = false;
            RedrawMacros();
        }

        private ContextMenuStrip m_MacroContextMenu = null;

        private void macroTree_MouseDown(object sender, System.Windows.Forms.MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Right && e.Clicks == 1)
            {
                if (m_MacroContextMenu == null)
                {
                    m_MacroContextMenu = new ContextMenuStrip();
                    m_MacroContextMenu.Items.Add("Add Category", null, Macro_AddCategory);
                    m_MacroContextMenu.Items.Add("Delete Category", null, Macro_DeleteCategory);
                    m_MacroContextMenu.Items.Add("Move to Category", null, Macro_Move2Category);
                    m_MacroContextMenu.Items.Add("-");
                    m_MacroContextMenu.Items.Add("Copy to Clipboard", null, Macro_CopyToClipboard);
                    m_MacroContextMenu.Items.Add("Rename Macro", null, Macro_Rename);
                    m_MacroContextMenu.Items.Add("Open Externally", null, Open_Externally);
                    m_MacroContextMenu.Items.Add("-");
                    m_MacroContextMenu.Items.Add("Convert to Script", null, ConvertMacroToScript);
                    m_MacroContextMenu.Items.Add("-");
                    m_MacroContextMenu.Items.Add("Refresh Macro List", null, Macro_RefreshList);
                }

                Macro sel = GetMacroSel();

                m_MacroContextMenu.Items[1].Enabled = sel == null;
                m_MacroContextMenu.Items[2].Enabled = sel != null;

                m_MacroContextMenu.Show(this, new Point(e.X, e.Y));
            }

            //RedrawMacros();
        }

        private TreeNode GetMacroDirNode()
        {
            if (macroTree.SelectedNode == null)
            {
                return null;
            }
            else
            {
                if (macroTree.SelectedNode.Tag is string)
                    return macroTree.SelectedNode;
                else if (macroTree.SelectedNode.Parent == null || !(macroTree.SelectedNode.Parent.Tag is string))
                    return null;
                else
                    return macroTree.SelectedNode.Parent;
            }
        }

        private void Macro_AddCategory(object sender, EventArgs args)
        {
            if (!InputBox.Show(this, Language.GetString(LocString.CatName)))
                return;

            string path = InputBox.GetString();
            if (string.IsNullOrEmpty(path) || path.IndexOfAny(Path.GetInvalidPathChars()) != -1 ||
                path.IndexOfAny(m_InvalidNameChars) != -1)
            {
                MessageBox.Show(this, Language.GetString(LocString.InvalidChars), "Invalid Path", MessageBoxButtons.OK,
                    MessageBoxIcon.Error);
                return;
            }

            TreeNode node = GetMacroDirNode();

            try
            {
                if (node == null || !(node.Tag is string))
                    path = Path.Combine(Config.GetUserDirectory("Macros"), path);
                else
                    path = Path.Combine((string) node.Tag, path);
                Engine.EnsureDirectory(path);
            }
            catch
            {
                MessageBox.Show(this, Language.Format(LocString.CanCreateDir, path), "Unable to Create Directory",
                    MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }

            TreeNode newNode = new TreeNode($"[{Path.GetFileName(path)}]");
            newNode.Tag = path;
            if (node == null)
                macroTree.Nodes.Add(newNode);
            else
                node.Nodes.Add(newNode);
            RedrawMacros();
            macroTree.SelectedNode = newNode;
        }

        private void Macro_DeleteCategory(object sender, EventArgs args)
        {
            string path = null;
            if (macroTree.SelectedNode != null)
                path = macroTree.SelectedNode.Tag as string;

            if (path == null)
                return;

            try
            {
                Directory.Delete(path);
            }
            catch
            {
                MessageBox.Show(this, Language.GetString(LocString.CantDelDir), "Unable to Delete Directory",
                    MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }

            TreeNode node = FindNode(macroTree.Nodes, path);
            node?.Remove();
        }

        private void Script_DeleteCategory(object sender, EventArgs args)
        {
            string path = null;

            if (scriptTree.SelectedNode != null)
                path = scriptTree.SelectedNode.Tag as string;

            if (path == null)
                return;

            try
            {
                Directory.Delete(path);

                TreeNode node = FindNode(scriptTree.Nodes, path);
                node?.Remove();
            }
            catch
            {
                MessageBox.Show(this, Language.GetString(LocString.CantDelDir), "Unable to Delete Directory",
                    MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
        }

        private void Macro_Move2Category(object sender, EventArgs args)
        {
            Macro sel = GetMacroSel();
            if (sel == null)
                return;

            List<string> dirNames = new List<string>();
            dirNames.Add("<None>");

            foreach (string dir in Directory.GetDirectories(Config.GetUserDirectory("Macros")))
            {
                dirNames.Add(dir.Substring(dir.LastIndexOf('\\') + 1));
            }

            if (!InputDropdown.Show(this, Language.GetString(LocString.CatName), dirNames.ToArray()))
                return;

            try
            {
                File.Move(sel.Filename, InputDropdown.GetString().Equals("<None>")
                    ? Path.Combine(Config.GetUserDirectory("Macros"), $"{Path.GetFileName(sel.Filename)}")
                    : Path.Combine(Config.GetUserDirectory("Macros"),
                        $"{InputDropdown.GetString()}/{Path.GetFileName(sel.Filename)}"));
            }
            catch
            {
                MessageBox.Show(this, Language.GetString(LocString.CantMoveMacro), "Unable to Move Macro",
                    MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }

            RedrawMacros();
            macroTree.SelectedNode = FindNode(macroTree.Nodes, sel);
        }

        /// <summary>
        /// Copy the selected macro the user's clipboard
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        private void Macro_CopyToClipboard(object sender, EventArgs args)
        {
            Macro sel = GetMacroSel();
            if (sel == null)
                return;

            try
            {
                string[] macroLines = File.ReadAllLines(sel.Filename);

                Clipboard.SetText(string.Join(Environment.NewLine, macroLines));
            }
            catch
            {
                MessageBox.Show(this, Language.GetString(LocString.ReadError), "Copy Error", MessageBoxButtons.OK,
                    MessageBoxIcon.Error);
            }
        }

        private void Macro_Rename(object sender, EventArgs args)
        {
            Macro sel = GetMacroSel();
            if (sel == null)
                return;

            if (InputBox.Show(this, Language.GetString(LocString.MacroRename),
                Language.GetString(LocString.EnterAName)))
            {
                string name = InputBox.GetString();
                if (string.IsNullOrEmpty(name) || name.IndexOfAny(Path.GetInvalidPathChars()) != -1 ||
                    name.IndexOfAny(m_InvalidNameChars) != -1)
                {
                    MessageBox.Show(this, Language.GetString(LocString.InvalidChars),
                        Language.GetString(LocString.Invalid), MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                string newMacro = $"{Path.GetDirectoryName(sel.Filename)}/{name}.macro";


                if (File.Exists(newMacro))
                {
                    MessageBox.Show(this, Language.GetString(LocString.MacroExists),
                        Language.GetString(LocString.Invalid),
                        MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                try
                {
                    Engine.MainWindow.SafeAction(s =>
                    {
                        File.Move(sel.Filename, newMacro);
                        MacroManager.Remove(sel);
                    });
                }
                catch
                {
                    return;
                }

                RedrawMacros();
            }
        }

        private void Open_Externally(object sender, EventArgs args)
        {
            Macro sel = GetMacroSel();
            if (sel == null)
                return;

            try
            {
                Process.Start(sel.Filename);
            }
            catch (Exception)
            {
                MessageBox.Show(this, Language.GetString(LocString.UnableToOpenMacro),
                    Language.GetString(LocString.ReadError),
                    MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        private void ConvertMacroToScript(object sender, EventArgs args)
        {
            Macro sel = GetMacroSel();
            if (sel == null)
                return;

            try
            {
                string name = sel.GetName();
                string path = Path.Combine(ScriptManager.ScriptPath, $"{name}.razor");

                if (File.Exists(Path.Combine(Config.GetUserDirectory("Scripts"), name)))
                {
                    path = Path.Combine(ScriptManager.ScriptPath, $"{name}-{Guid.NewGuid().ToString().Substring(0, 4)}.razor");
                }

                List<string> scriptLines = new List<string>();

                foreach (MacroAction selAction in sel.Actions)
                {
                    scriptLines.Add(selAction.ToScript());
                }

                File.WriteAllLines(path, scriptLines.ToArray());

                RazorScript script = ScriptManager.AddScript(path);

                RedrawScripts();

                tabs.SelectedTab = scriptsTab;

                TreeNode node = FindScriptNode(scriptTree.Nodes, script);
                scriptTree.SelectedNode = node;
            }
            catch (Exception ex)
            {
                MessageBox.Show(this, $"Unable to convert macro to script: {ex.Message}", "Macro to Script Conversion",
                    MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        private void Macro_RefreshList(object sender, EventArgs args)
        {
            RedrawMacros();
        }

        private static TreeNode FindNode(TreeNodeCollection nodes, object tag)
        {
            for (int i = 0; i < nodes.Count; i++)
            {
                TreeNode node = nodes[i];

                if (node.Tag == tag)
                {
                    return node;
                }
                else if (node.Nodes.Count > 0)
                {
                    node = FindNode(node.Nodes, tag);
                    if (node != null)
                        return node;
                }
            }

            return null;
        }

        private static TreeNode FindScriptNode(TreeNodeCollection nodes, object tag)
        {
            for (int i = 0; i < nodes.Count; i++)
            {
                TreeNode node = nodes[i];

                if (node.Tag.ToString().Equals(tag.ToString()))
                {
                    return node;
                }
                else if (node.Nodes.Count > 0)
                {
                    node = FindScriptNode(node.Nodes, tag);
                    if (node != null)
                        return node;
                }
            }

            return null;
        }

        private void RedrawMacros()
        {
            Macro ms = GetMacroSel();
            MacroManager.DisplayTo(macroTree);
            if (ms != null)
                macroTree.SelectedNode = FindNode(macroTree.Nodes, ms);

            RebuildMacroCache();

            MacroManager.DisplayMacroVariables(macroVariables);
        }

        private void RedrawScripts()
        {
            RazorScript rs = GetScriptSel();

            ScriptManager.RedrawScripts();

            if (rs != null)
            {
                scriptTree.SelectedNode = FindScriptNode(scriptTree.Nodes, rs);
            }

            RebuildScriptCache();

            ScriptManager.RedrawScriptVariables();
        }

        private void RedrawItems()
        {
            StaffToolsManager.LoadItems(itemTree);

            RebuildItemCache();
        }

        public Macro LastSelectedMacro { get; set; }

        private void macroTree_AfterSelect(object sender, System.Windows.Forms.TreeViewEventArgs e)
        {
            if (MacroManager.Recording)
                return;

            Macro m = e.Node.Tag as Macro;
            macroActGroup.Visible = m != null;
            MacroManager.Select(m, actionList, playMacro, recMacro, loopMacro);

            LastSelectedMacro = m;

            if (m == null)
                return;

            Engine.MainWindow.SafeAction(s =>
            {
                if (hotkeyTree.TopNode == null)
                {
                    HotKey.RebuildList(hotkeyTree);
                    RebuildHotKeyCache();
                }
                
                TreeNode resultNode = SearchTreeView(Language.Format(LocString.PlayA1, m.GetName()), hotkeyTree.Nodes);

                if (resultNode != null)
                {
                    KeyData hk = (KeyData) resultNode.Tag;

                    if (hk != null && !string.IsNullOrEmpty(hk.KeyString()))
                    {
                        macroActGroup.Text = $"Actions ({hk.KeyString()})";
                    }
                    else
                    {
                        macroActGroup.Text = "Actions (Not Set)";
                    }
                }
            });
        }

        private void delMacro_Click(object sender, System.EventArgs e)
        {
            Macro m = GetMacroSel();
            if (m == null)
            {
                Macro_DeleteCategory(sender, e);
                return;
            }

            if (m == MacroManager.Current)
                return;

            if (m.Actions.Count <= 0 || MessageBox.Show(this, Language.Format(LocString.DelConf, m.ToString()),
                    "Confirm Delete", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
            {
                try
                {
                    File.Delete(m.Filename);
                }
                catch
                {
                    return;
                }

                MacroManager.Remove(m);

                TreeNode node = FindNode(macroTree.Nodes, m);
                node?.Remove();
            }

            RebuildMacroCache();
        }

        private void actionList_MouseDown(object sender, System.Windows.Forms.MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Right && e.Clicks == 1)
            {
                if (MacroManager.Playing || MacroManager.Recording || World.Player == null)
                    return;

                ContextMenuStrip menu = new ContextMenuStrip();
                menu.Items.Add(Language.GetString(LocString.Reload), null, onMacroReload);
                menu.Items.Add(Language.GetString(LocString.Save), null, onMacroSave);

                MacroAction a;
                try
                {
                    a = actionList.SelectedItem as MacroAction;
                }
                catch
                {
                    a = null;
                }

                if (a != null)
                {
                    int pos = actionList.SelectedIndex;

                    menu.Items.Add("-");
                    if (actionList.Items.Count > 1)
                    {
                        menu.Items.Add(Language.GetString(LocString.MoveUp), null, OnMacroActionMoveUp);

                        if (pos <= 0)
                        {
                            menu.Items[menu.Items.Count - 1].Enabled = false;
                        }

                        menu.Items.Add(Language.GetString(LocString.MoveDown), null, OnMacroActionMoveDown);

                        if (pos >= actionList.Items.Count - 1)
                        {
                            menu.Items[menu.Items.Count - 1].Enabled = false;
                        }

                        menu.Items.Add("-");
                    }

                    menu.Items.Add("Copy Line", null, onMacroCopyLine);
                    menu.Items.Add("Paste Line", null, onMacroPasteLine);

                    menu.Items.Add(Language.GetString(LocString.RemAct), null, onMacroActionDelete);
                    menu.Items.Add("-");
                    menu.Items.Add(Language.GetString(LocString.BeginRec), null, onMacroBegRecHere);
                    menu.Items.Add(Language.GetString(LocString.PlayFromHere), null, onMacroPlayHere);

                    ToolStripMenuItem[] aMenus = a.GetContextMenuItems();
                    if (aMenus != null && aMenus.Length > 0)
                    {
                        menu.Items.Add("-");
                        menu.Items.AddRange(aMenus);
                    }
                }

                menu.Items.Add("-");

                ToolStripMenuItem submenu = new ToolStripMenuItem(Language.GetString(LocString.Constructs));

                submenu.DropDownItems.Add(Language.GetString(LocString.InsWait), null, onMacroInsPause);
                submenu.DropDownItems.Add(Language.GetString(LocString.InsLT), null, onMacroInsertSetLT);
                submenu.DropDownItems.Add(Language.GetString(LocString.InsComment), null, onMacroInsertComment);
                submenu.DropDownItems.Add(Language.GetString(LocString.InsertOverheadMessage), null, onMacroInsertOverheadMessage);
                submenu.DropDownItems.Add(Language.GetString(LocString.InsertWaitForTarget), null, onMacroInsertWaitForTarget);
                submenu.DropDownItems.Add(Language.GetString(LocString.InsertClearSysMsg), null, onMacroInsertClearSysMsg);
                submenu.DropDownItems.Add("-");
                submenu.DropDownItems.Add(Language.GetString(LocString.InsIF), null, onMacroInsertIf);
                submenu.DropDownItems.Add(Language.GetString(LocString.InsELSE), null, onMacroInsertElse);
                submenu.DropDownItems.Add(Language.GetString(LocString.InsENDIF), null, onMacroInsertEndIf);
                submenu.DropDownItems.Add("-");
                submenu.DropDownItems.Add(Language.GetString(LocString.InsFOR), null, onMacroInsertFor);
                submenu.DropDownItems.Add(Language.GetString(LocString.InsENDFOR), null, onMacroInsertEndFor);
                submenu.DropDownItems.Add("-");
                submenu.DropDownItems.Add(Language.GetString(LocString.InsertWhile), null, onMacroInsertWhile);
                submenu.DropDownItems.Add(Language.GetString(LocString.InsertEndWhile), null, onMacroInsertEndWhile);
                submenu.DropDownItems.Add("-");
                submenu.DropDownItems.Add(Language.GetString(LocString.InsertDo), null, onMacroInsertDo);
                submenu.DropDownItems.Add(Language.GetString(LocString.InsertDoWhile), null, onMacroInsertDoWhile);

                menu.Items.Add(submenu);

                menu.Show(actionList, new Point(e.X, e.Y));
            }
            else if (e.Button == MouseButtons.Left && e.Clicks == 2)
            {
                /*if (MacroManager.Playing || MacroManager.Recording || World.Player == null)
                    return;*/

                MacroAction a;
                try
                {
                    a = actionList.SelectedItem as MacroAction;
                }
                catch
                {
                    a = null;
                }

                if (a == null)
                    return;

                ToolStripMenuItem[] aMenus = a.GetContextMenuItems();

                if (aMenus != null && aMenus.Length > 0)
                {
                    if (aMenus[0].Text.Equals(Language.GetString(LocString.Edit)))
                    {
                        if (a.GetType().Name.Equals("IfAction"))
                        {
                            new MacroInsertIf(a).ShowDialog(Engine.MainWindow);
                        }
                        else if (a.GetType().Name.Equals("ForAction"))
                        {
                            aMenus[0].PerformClick();
                        }
                        else if (a.GetType().Name.Equals("DoWhileAction"))
                        {
                            aMenus[0].PerformClick();
                        }
                        else if (a.GetType().Name.Equals("WhileAction"))
                        {
                            aMenus[0].PerformClick();
                        }
                        else if (a.GetType().Name.Equals("MacroComment"))
                        {
                            aMenus[0].PerformClick();
                        }
                        else if (a.GetType().Name.Equals("SpeechAction"))
                        {
                            aMenus[0].PerformClick();
                        }
                        else if (a.GetType().Name.Equals("GumpResponseAction"))
                        {
                            aMenus[0].PerformClick();
                        }
                        else if (a.GetType().Name.Equals("OverheadMessageAction"))
                        {
                            aMenus[0].PerformClick();
                        }
                        else
                        {
                            new MacroInsertWait(a).ShowDialog(Engine.MainWindow);
                        }
                    }
                }
            }
        }

        private void onMacroPlayHere(object sender, EventArgs e)
        {
            Macro m = GetMacroSel();
            ;
            if (m == null)
                return;

            int sel = actionList.SelectedIndex + 1;
            if (sel < 0 || sel > m.Actions.Count)
                sel = m.Actions.Count;

            MacroManager.PlayAt(m, sel);
            playMacro.Text = "Stop";
            nextMacroAction.Enabled = stepThroughMacro.Checked;
            recMacro.Enabled = false;

            OnMacroStart(m);
        }

        private void onMacroInsertClearSysMsg(object sender, System.EventArgs e)
        {
            Macro m = GetMacroSel();
            if (m == null)
                return;

            int a = actionList.SelectedIndex;
            if (a >= m.Actions.Count) // -1 is valid, will insert @ top
                return;

            m.Actions.Insert(a + 1, new ClearSysMessages());
            RedrawActionList(m);
        }

        private void onMacroInsertComment(object sender, System.EventArgs e)
        {
            Macro m = GetMacroSel();
            if (m == null)
                return;

            int a = actionList.SelectedIndex;
            if (a >= m.Actions.Count) // -1 is valid, will insert @ top
                return;

            if (InputBox.Show(Language.GetString(LocString.InsComment)))
            {
                m.Actions.Insert(a + 1, new MacroComment(InputBox.GetString()));
                RedrawActionList(m);
            }
        }

        private void onMacroInsertOverheadMessage(object sender, System.EventArgs e)
        {
            Macro m = GetMacroSel();
            if (m == null)
                return;

            int a = actionList.SelectedIndex;
            if (a >= m.Actions.Count) // -1 is valid, will insert @ top
                return;

            if (InputBox.Show(Language.GetString(LocString.InsertOverheadMessage)))
            {
                m.Actions.Insert(a + 1,
                    new OverheadMessageAction((ushort) Config.GetInt("SysColor"), InputBox.GetString()));
                RedrawActionList(m);
            }
        }

        private void onMacroInsertWaitForTarget(object sender, System.EventArgs e)
        {
            Macro m = GetMacroSel();
            if (m == null)
                return;

            int a = actionList.SelectedIndex;
            if (a >= m.Actions.Count) // -1 is valid, will insert @ top
                return;

            m.Actions.Insert(a + 1, new WaitForTargetAction());
            RedrawActionList(m);
        }

        private void onMacroInsertSetMacroVariable(object sender, System.EventArgs e)
        {
            Macro m = GetMacroSel();
            if (m == null)
                return;

            int a = actionList.SelectedIndex;
            if (a >= m.Actions.Count) // -1 is valid, will insert @ top
                return;

            ToolStripMenuItem mnu = (ToolStripMenuItem) sender;

            m.Actions.Insert(a + 1, new SetMacroVariableTargetAction(mnu.Text));
            RedrawActionList(m);
        }

        private void onMacroInsertIf(object sender, System.EventArgs e)
        {
            Macro m = GetMacroSel();
            if (m == null)
                return;

            int a = actionList.SelectedIndex;
            if (a >= m.Actions.Count) // -1 is valid, will insert @ top
                return;

            MacroInsertIf ins = new MacroInsertIf(m, a);
            if (ins.ShowDialog(this) == DialogResult.OK)
                RedrawActionList(m);
        }

        private void onMacroInsertElse(object sender, System.EventArgs e)
        {
            Macro m = GetMacroSel();
            ;
            if (m == null)
                return;

            int a = actionList.SelectedIndex;
            if (a >= m.Actions.Count) // -1 is valid, will insert @ top
                return;

            m.Actions.Insert(a + 1, new ElseAction());
            RedrawActionList(m);
        }

        private void onMacroInsertEndIf(object sender, System.EventArgs e)
        {
            Macro m = GetMacroSel();
            ;
            if (m == null)
                return;

            int a = actionList.SelectedIndex;
            if (a >= m.Actions.Count) // -1 is valid, will insert @ top
                return;

            m.Actions.Insert(a + 1, new EndIfAction());
            RedrawActionList(m);
        }

        private void onMacroInsertFor(object sender, System.EventArgs e)
        {
            Macro m = GetMacroSel();
            if (m == null)
                return;

            int a = actionList.SelectedIndex;
            if (a >= m.Actions.Count) // -1 is valid, will insert @ top
                return;

            if (InputBox.Show(Language.GetString(LocString.NumIter)))
            {
                m.Actions.Insert(a + 1, new ForAction(InputBox.GetInt(1)));
                RedrawActionList(m);
            }
        }

        private void onMacroInsertEndFor(object sender, System.EventArgs e)
        {
            Macro m = GetMacroSel();
            if (m == null)
                return;

            int a = actionList.SelectedIndex;
            if (a >= m.Actions.Count) // -1 is valid, will insert @ top
                return;

            m.Actions.Insert(a + 1, new EndForAction());
            RedrawActionList(m);
        }

        private void onMacroInsertWhile(object sender, System.EventArgs e)
        {
            Macro m = GetMacroSel();
            if (m == null)
                return;

            int a = actionList.SelectedIndex;
            if (a >= m.Actions.Count) // -1 is valid, will insert @ top
                return;

            MacroInsertWhile ins = new MacroInsertWhile(m, a);
            if (ins.ShowDialog(this) == DialogResult.OK)
                RedrawActionList(m);
        }

        private void onMacroInsertEndWhile(object sender, System.EventArgs e)
        {
            Macro m = GetMacroSel();
            if (m == null)
                return;

            int a = actionList.SelectedIndex;
            if (a >= m.Actions.Count) // -1 is valid, will insert @ top
                return;

            m.Actions.Insert(a + 1, new EndWhileAction());
            RedrawActionList(m);
        }

        private void onMacroInsertDo(object sender, System.EventArgs e)
        {
            Macro m = GetMacroSel();
            if (m == null)
                return;

            int a = actionList.SelectedIndex;
            if (a >= m.Actions.Count) // -1 is valid, will insert @ top
                return;

            m.Actions.Insert(a + 1, new StartDoWhileAction());
            RedrawActionList(m);
        }

        private void onMacroInsertDoWhile(object sender, System.EventArgs e)
        {
            Macro m = GetMacroSel();
            if (m == null)
                return;

            int a = actionList.SelectedIndex;
            if (a >= m.Actions.Count) // -1 is valid, will insert @ top
                return;

            MacroInsertDoWhile ins = new MacroInsertDoWhile(m, a);
            if (ins.ShowDialog(this) == DialogResult.OK)
                RedrawActionList(m);
        }

        private void OnMacroActionMoveUp(object sender, System.EventArgs e)
        {
            Macro m = GetMacroSel();
            ;
            if (m == null)
                return;

            int move = actionList.SelectedIndex;
            if (move > 0 && move < m.Actions.Count)
            {
                MacroAction a = (MacroAction) m.Actions[move - 1];
                m.Actions[move - 1] = m.Actions[move];
                m.Actions[move] = a;

                RedrawActionList(m);
                actionList.SelectedIndex = move - 1;
            }
        }

        private void OnMacroActionMoveDown(object sender, System.EventArgs e)
        {
            Macro m = GetMacroSel();
            ;
            if (m == null)
                return;

            int move = actionList.SelectedIndex;
            if (move + 1 < m.Actions.Count)
            {
                MacroAction a = (MacroAction) m.Actions[move + 1];
                m.Actions[move + 1] = m.Actions[move];
                m.Actions[move] = a;

                RedrawActionList(m);
                actionList.SelectedIndex = move + 1;
            }
        }


        private void OnMacroKeyMoveUp()
        {
            Macro m = GetMacroSel();
            ;
            if (m == null)
                return;

            int move = actionList.SelectedIndex;
            if (move > 0 && move < m.Actions.Count)
            {
                MacroAction a = (MacroAction) m.Actions[move - 1];
                m.Actions[move - 1] = m.Actions[move];
                m.Actions[move] = a;

                RedrawActionList(m);
            }
        }

        private void OnMacroKeyMoveDown()
        {
            Macro m = GetMacroSel();
            ;
            if (m == null)
                return;

            int move = actionList.SelectedIndex;
            if (move + 1 < m.Actions.Count)
            {
                MacroAction a = (MacroAction) m.Actions[move + 1];
                m.Actions[move + 1] = m.Actions[move];
                m.Actions[move] = a;

                RedrawActionList(m);
            }
        }

        private void RedrawActionList(Macro m)
        {
            int sel = actionList.SelectedIndex;
            m.DisplayTo(actionList);
            actionList.SelectedIndex = sel;
        }

        private void actionList_KeyDown(object sender, System.Windows.Forms.KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Delete)
            {
                onMacroActionDelete(sender, e);

                return;
            }

            int origIndex = actionList.SelectedIndex;

            if ((e.KeyCode == Keys.Up && e.Control) && actionList.SelectedIndex > 0)
            {
                OnMacroKeyMoveUp();

                return;
            }

            if ((e.KeyCode == Keys.Down && e.Control) && actionList.SelectedIndex < actionList.Items.Count)
            {
                OnMacroKeyMoveDown();

                return;
            }
        }

        private MacroAction _macroActionToCopy;

        private void onMacroCopyLine(object sender, System.EventArgs e)
        {
            Macro m = GetMacroSel();
            if (m == null)
                return;

            int a = actionList.SelectedIndex;
            if (a < 0 || a >= m.Actions.Count)
                return;

            _macroActionToCopy = (MacroAction) m.Actions[a];
        }

        private void onMacroPasteLine(object sender, System.EventArgs e)
        {
            if (_macroActionToCopy == null)
                return;

            Macro m = GetMacroSel();
            if (m == null)
                return;

            int a = actionList.SelectedIndex;
            if (a < 0 || a >= m.Actions.Count)
                return;

            m.Actions.Insert(a + 1, _macroActionToCopy);

            RedrawActionList(m);

            actionList.SelectedIndex = a + 1;

            onMacroSave(sender, e);
            onMacroReload(sender, e);
        }

        private void onMacroActionDelete(object sender, System.EventArgs e)
        {
            Macro m = GetMacroSel();

            if (m == null)
                return;

            int a = actionList.SelectedIndex;
            if (a < 0 || a >= m.Actions.Count)
                return;

            if (MessageBox.Show(this, Language.Format(LocString.DelConf, m.Actions[a].ToString()), "Confirm",
                    MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
            {
                m.Actions.RemoveAt(a);
                actionList.Items.RemoveAt(a);
            }
        }

        private void onMacroBegRecHere(object sender, System.EventArgs e)
        {
            Macro m = GetMacroSel();

            if (m == null)
                return;

            int sel = actionList.SelectedIndex + 1;
            if (sel < 0 || sel > m.Actions.Count)
                sel = m.Actions.Count;

            MacroManager.RecordAt(m, sel);
            recMacro.Text = "Stop";
            playMacro.Enabled = false;
            OnMacroStart(m);
        }

        private void onMacroInsPause(object sender, System.EventArgs e)
        {
            Macro m = GetMacroSel();

            if (m == null)
                return;

            int a = actionList.SelectedIndex;
            if (a >= m.Actions.Count) // -1 is valid, will insert @ top
                return;

            MacroInsertWait ins = new MacroInsertWait(m, a);
            if (ins.ShowDialog(this) == DialogResult.OK)
                RedrawActionList(m);
        }

        private void onMacroReload(object sender, System.EventArgs e)
        {
            Macro m = GetMacroSel();

            if (m == null)
                return;

            m.Load();
            RedrawActionList(m);
        }

        private void onMacroSave(object sender, System.EventArgs e)
        {
            Macro m = GetMacroSel();

            if (m == null)
                return;

            m.Save();
            RedrawActionList(m);
        }

        private void onMacroInsertSetLT(object sender, EventArgs e)
        {
            Macro m = GetMacroSel();

            if (m == null)
                return;

            int a = actionList.SelectedIndex;
            if (a >= m.Actions.Count) // -1 is valid, will insert @ top
                return;

            m.Actions.Insert(a + 1, new SetLastTargetAction());
            RedrawActionList(m);
        }

        private void loopMacro_CheckedChanged(object sender, System.EventArgs e)
        {
            Macro m = GetMacroSel();

            if (m == null)
                return;
            m.Loop = loopMacro.Checked;
        }

        private void jump2SearchEx_Click(object sender, System.EventArgs e)
        {
            tabs.SelectedTab = agentsTab;
            agentList.SelectedItem = SearchExemptionAgent.Instance;
        }

        private void setScnPath_Click(object sender, System.EventArgs e)
        {
            FolderBrowserDialog folder = new FolderBrowserDialog();
            folder.Description = Language.GetString(LocString.SelSSFolder);
            folder.SelectedPath = Config.GetString("CapPath");
            folder.ShowNewFolderButton = true;

            if (folder.ShowDialog(this) == DialogResult.OK)
            {
                Config.SetProperty("CapPath", folder.SelectedPath);
                screenPath.Text = folder.SelectedPath;

                ReloadScreenShotsList();
            }
        }

        public void ReloadScreenShotsList()
        {
            ScreenCapManager.DisplayTo(screensList);
            if (screenPrev.Image != null)
            {
                screenPrev.Image.Dispose();
                screenPrev.Image = null;
            }
        }

        private void radioFull_CheckedChanged(object sender, System.EventArgs e)
        {
            if (radioFull.Checked)
            {
                radioUO.Checked = false;
                Config.SetProperty("CapFullScreen", true);
            }
        }

        private void radioUO_CheckedChanged(object sender, System.EventArgs e)
        {
            if (radioUO.Checked)
            {
                radioFull.Checked = false;
                Config.SetProperty("CapFullScreen", false);
            }
        }

        private void screensList_SelectedIndexChanged(object sender, System.EventArgs e)
        {
            if (screenPrev.Image != null)
            {
                screenPrev.Image.Dispose();
                screenPrev.Image = null;
            }

            if (screensList.SelectedIndex == -1)
                return;

            string file = Path.Combine(Config.GetString("CapPath"), screensList.SelectedItem.ToString());
            if (!File.Exists(file))
            {
                MessageBox.Show(this, Language.Format(LocString.FileNotFoundA1, file), "File Not Found",
                    MessageBoxButtons.OK, MessageBoxIcon.Warning);
                screensList.Items.RemoveAt(screensList.SelectedIndex);
                screensList.SelectedIndex = -1;
                return;
            }

            using (Stream reader = new FileStream(file, FileMode.Open, FileAccess.Read))
            {
                screenPrev.Image = Image.FromStream(reader);
            }
        }

        private void screensList_MouseDown(object sender, System.Windows.Forms.MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Right && e.Clicks == 1)
            {
                ContextMenuStrip menu = new ContextMenuStrip();

                menu.Items.Add("Copy Image", null, CopyScreenshot);
                menu.Items.Add("-");
                menu.Items.Add("Delete Image", null, DeleteScreenCap);

                if (screensList.SelectedIndex == -1)
                    menu.Items[menu.Items.Count - 1].Enabled = false;

                menu.Items.Add("Delete ALL", null, ClearScreensDirectory);


                menu.Show(screensList, new Point(e.X, e.Y));
            }
        }

        private void CopyScreenshot(object sender, System.EventArgs e)
        {
            int sel = screensList.SelectedIndex;
            if (sel == -1)
                return;

            Clipboard.SetImage(screenPrev.Image);
        }

        private void DeleteScreenCap(object sender, System.EventArgs e)
        {
            int sel = screensList.SelectedIndex;
            if (sel == -1)
                return;

            string file = Path.Combine(Config.GetString("CapPath"), (string) screensList.SelectedItem);
            if (MessageBox.Show(this, Language.Format(LocString.DelConf, file), "Delete Confirmation",
                    MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.No)
                return;

            screensList.SelectedIndex = -1;
            if (screenPrev.Image != null)
            {
                screenPrev.Image.Dispose();
                screenPrev.Image = null;
            }

            try
            {
                File.Delete(file);
                screensList.Items.RemoveAt(sel);
            }
            catch (Exception ex)
            {
                MessageBox.Show(this, ex.Message, "Unable to Delete", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }

            ReloadScreenShotsList();
        }

        private void ClearScreensDirectory(object sender, System.EventArgs e)
        {
            string dir = Config.GetString("CapPath");
            if (MessageBox.Show(this, Language.Format(LocString.Confirm, dir), "Delete Confirmation",
                    MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.No)
                return;

            string[] files = Directory.GetFiles(dir, "*.jpg");
            StringBuilder sb = new StringBuilder();
            int failed = 0;
            for (int i = 0; i < files.Length; i++)
            {
                try
                {
                    File.Delete(files[i]);
                }
                catch
                {
                    sb.AppendFormat("{0}\n", files[i]);
                    failed++;
                }
            }

            if (failed > 0)
                MessageBox.Show(this,
                    Language.Format(LocString.FileDelError, failed, failed != 1 ? "s" : "", sb.ToString()), "Warning",
                    MessageBoxButtons.OK, MessageBoxIcon.Warning);
            ReloadScreenShotsList();
        }

        private void capNow_Click(object sender, System.EventArgs e)
        {
            ScreenCapManager.CaptureNow();
        }

        private void dispTime_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("CapTimeStamp", dispTime.Checked);
        }

        public static void LaunchBrowser(string site)
        {
            try
            {
                System.Diagnostics.Process.Start(site); //"iexplore", site );
            }
            catch
            {
                MessageBox.Show($"Unable to open browser to '{site}'", "Error", MessageBoxButtons.OK,
                    MessageBoxIcon.Warning);
            }
        }

        private void undressConflicts_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("UndressConflicts", undressConflicts.Checked);
        }

        private void taskbar_CheckedChanged(object sender, System.EventArgs e)
        {
            if (taskbar.Checked)
            {
                systray.Checked = false;
                Config.SetProperty("Systray", false);
                /*if (!this.ShowInTaskbar)
                    MessageBox.Show(this, Language.GetString(LocString.NextRestart), "Notice", MessageBoxButtons.OK,
                        MessageBoxIcon.Information);*/
            }
        }

        private void systray_CheckedChanged(object sender, System.EventArgs e)
        {
            if (systray.Checked)
            {
                taskbar.Checked = false;
                Config.SetProperty("Systray", true);
                /*if (this.ShowInTaskbar)
                    MessageBox.Show(this, Language.GetString(LocString.NextRestart), "Notice", MessageBoxButtons.OK,
                        MessageBoxIcon.Information);*/
            }
        }

        public void UpdateTitle()
        {
            string str = Language.GetControlText(this.Name);
            if (string.IsNullOrEmpty(str))
            {
                str = "Razor v{0}";
            }

            str = string.Format(str, Engine.Version);

            if (World.Player != null)
            {
                if (Config.GetBool("ShowInRazorTitleBar") && !string.IsNullOrEmpty(razorTitleBar.Text))
                {
                    Text = razorTitleBar.Text.Replace("{name}", World.Player.Name).Replace("{shard}", World.ShardName)
                        .Replace("{version}", Engine.Version).Replace("{profile}", Config.CurrentProfile.Name)
                        .Replace("{account}", World.AccountName);
                }
                else
                {
                    string title = $"{World.Player.Name} ({World.ShardName}) - {str}";
                    Text = title;
                }
            }
            else
            {
                Text = str;
            }

            aboutVer.Text = str;

            UpdateSystray();
        }

        public void UpdateSystray()
        {
            if (m_NotifyIcon != null && m_NotifyIcon.Visible)
            {
                if (World.Player != null)
                    if (Config.GetBool("ShowInRazorTitleBar") && !string.IsNullOrEmpty(razorTitleBar.Text))
                    {
                        string title = razorTitleBar.Text.Replace("{name}", World.Player.Name).Replace("{shard}", World.ShardName)
                            .Replace("{version}", Engine.Version).Replace("{profile}", Config.CurrentProfile.Name)
                            .Replace("{account}", World.AccountName);

                        m_NotifyIcon.Text = title.Length > 63 ? title.Substring(0, 63) : title;
                    }
                    else
                    {
                        m_NotifyIcon.Text = $"Razor - {World.Player.Name} ({World.ShardName})";
                    }
                else
                    m_NotifyIcon.Text = "Razor";
            }
        }

        private void DoShowMe(object sender, System.EventArgs e)
        {
            ShowMe();
        }

        public void ShowMe()
        {
            // In CUO, this can cause an error.
            try
            {
                Platform.SetForegroundWindow(Handle);
                Platform.BringToFront(Handle);
            }
            catch
            {
                BringToFront();
            }

            try
            {
                this.Show();
            }
            catch
            {
            }

            if (Config.GetBool("AlwaysOnTop"))
                this.TopMost = true;
            if (WindowState != FormWindowState.Normal)
                WindowState = FormWindowState.Normal;
        }

        private void HideMe(object sender, System.EventArgs e)
        {
            //this.WindowState = FormWindowState.Minimized;
            this.TopMost = false;
            this.SendToBack();
            this.Hide();
        }

        private void NotifyIcon_DoubleClick(object sender, System.EventArgs e)
        {
            ShowMe();
        }

        private void ToggleVisible(object sender, System.EventArgs e)
        {
            if (this.Visible)
                HideMe(sender, e);
            else
                ShowMe();
        }

        private void OnClose(object sender, System.EventArgs e)
        {
            m_NotifyIcon.Visible = false;
            m_NotifyIcon.Dispose();
            m_CanClose = true;
            this.Close();
        }

        private void titlebarImages_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("TitlebarImages", titlebarImages.Checked);
            Client.Instance.RequestTitlebarUpdate();
        }

        private void highlightSpellReags_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("HighlightReagents", highlightSpellReags.Checked);
            Client.Instance.RequestTitlebarUpdate();
        }

        private void actionStatusMsg_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("ActionStatusMsg", actionStatusMsg.Checked);
        }

        private void autoStackRes_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("AutoStack", autoStackRes.Checked);
            //setAutoStackDest.Enabled = autoStackRes.Checked;
        }

        private void screenPath_TextChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("CapPath", screenPath.Text);
        }

        private void rememberPwds_CheckedChanged(object sender, System.EventArgs e)
        {
            if (rememberPwds.Checked && !Config.GetBool("RememberPwds"))
            {
                if (MessageBox.Show(this, Language.GetString(LocString.PWWarn), "Security Warning",
                        MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.No)
                {
                    rememberPwds.Checked = false;
                    return;
                }
            }

            Config.SetProperty("RememberPwds", rememberPwds.Checked);
        }

        private void langSel_SelectedIndexChanged(object sender, System.EventArgs e)
        {
            string lang = langSel.SelectedItem as String;
            if (lang != null && lang != Language.Current)
            {
                if (!Language.Load(lang))
                {
                    MessageBox.Show(this, "Unable to load that language.", "Load Error", MessageBoxButtons.OK,
                        MessageBoxIcon.Exclamation);
                    langSel.SelectedItem = Language.Current;
                }
                else
                {
                    Config.SetAppSetting("DefaultLanguage", Language.Current);
                    Language.LoadControlNames(this);
                    HotKey.RebuildList(hotkeyTree);
                }
            }
        }

        private void tabs_KeyDown(object sender, System.Windows.Forms.KeyEventArgs e)
        {
            //HotKey.KeyDown(e.KeyData);
        }

        private void MainForm_KeyDown(object sender, System.Windows.Forms.KeyEventArgs e)
        {
            //HotKey.KeyDown(e.KeyData);
        }

        private void spellUnequip_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("SpellUnequip", spellUnequip.Checked);
        }

        private void rangeCheckLT_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("RangeCheckLT", ltRange.Enabled = rangeCheckLT.Checked);
        }

        private void ltRange_TextChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("LTRange", Utility.ToInt32(ltRange.Text, 11));
        }

        private void excludePouches_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("NoSearchPouches", excludePouches.Checked);
        }

        private void filterSnoop_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("FilterSnoopMsg", filterSnoop.Checked);
        }

        private void preAOSstatbar_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("OldStatBar", preAOSstatbar.Checked);
            Client.Instance.RequestStatbarPatch(preAOSstatbar.Checked);
            if (World.Player != null && !m_Initializing)
                MessageBox.Show(this, "Close and re-open your status bar for the change to take effect.",
                    "Status Window Note", MessageBoxButtons.OK, MessageBoxIcon.Information);
        }

        private void smartLT_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("SmartLastTarget", smartLT.Checked);
        }

        private void showtargtext_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("LastTargTextFlags", showtargtext.Checked);
        }

        private void dressItems_KeyDown(object sender, System.Windows.Forms.KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Delete)
            {
                DressList list = (DressList) dressList.SelectedItem;
                if (list == null)
                    return;

                int sel = dressItems.SelectedIndex;
                if (sel < 0 || sel >= list.Items.Count)
                    return;

                if (MessageBox.Show(this, Language.GetString(LocString.DelDressItemQ), "Confirm",
                        MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
                {
                    try
                    {
                        list.Items.RemoveAt(sel);
                        dressItems.Items.RemoveAt(sel);
                    }
                    catch
                    {
                    }
                }
            }
        }

        private void blockDis_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("BlockDismount", blockDis.Checked);
        }

        private void imgFmt_SelectedIndexChanged(object sender, System.EventArgs e)
        {
            if (imgFmt.SelectedIndex != -1)
                Config.SetProperty("ImageFormat", imgFmt.SelectedItem);
            else
                Config.SetProperty("ImageFormat", "jpg");
        }

        private void autoFriend_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("AutoFriend", autoFriend.Checked);
        }

        private void autoOpenDoors_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("AutoOpenDoors", autoOpenDoors.Checked);
        }

        private void msglvl_SelectedIndexChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("MessageLevel", msglvl.SelectedIndex);
        }

        private void screenPrev_Click(object sender, System.EventArgs e)
        {
            string file = screensList.SelectedItem as String;
            if (file != null)
                System.Diagnostics.Process.Start(Path.Combine(Config.GetString("CapPath"), file));
        }

        private Timer m_ResizeTimer = Timer.DelayedCallback(TimeSpan.FromSeconds(1.0), new TimerCallback(ForceSize));

        private static void ForceSize()
        {
            int x, y;

            if (Config.GetBool("ForceSizeEnabled"))
            {
                x = Config.GetInt("ForceSizeX");
                y = Config.GetInt("ForceSizeY");

                if (x > 100 && x < 2000 && y > 100 && y < 2000)
                    Client.Instance.SetGameSize(x, y);
                else
                    MessageBox.Show(Engine.MainWindow, Language.GetString(LocString.ForceSizeBad), "Bad Size",
                        MessageBoxButtons.OK, MessageBoxIcon.Stop);
            }
        }

        private void gameSize_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("ForceSizeEnabled", gameSize.Checked);
            forceSizeX.Enabled = forceSizeY.Enabled = gameSize.Checked;

            if (gameSize.Checked)
            {
                int x = Utility.ToInt32(forceSizeX.Text, 800);
                int y = Utility.ToInt32(forceSizeY.Text, 600);

                if (x < 100 || y < 100 || x > 2000 || y > 2000)
                    MessageBox.Show(this, Language.GetString(LocString.ForceSizeBad), "Bad Size", MessageBoxButtons.OK,
                        MessageBoxIcon.Stop);
                else
                    Client.Instance.SetGameSize(x, y);
            }
            else
            {
                Client.Instance.SetGameSize(800, 600);
            }

            if (!m_Initializing)
                MessageBox.Show(this, Language.GetString(LocString.ApplyOptionsRequired), "Additional Step",
                    MessageBoxButtons.OK, MessageBoxIcon.Information);
        }

        private void forceSizeX_TextChanged(object sender, System.EventArgs e)
        {
            int x = Utility.ToInt32(forceSizeX.Text, 600);
            if (x >= 100 && x <= 2000)
                Config.SetProperty("ForceSizeX", x);

            if (!m_Initializing)
            {
                if (x > 100 && x < 2000)
                {
                    m_ResizeTimer.Stop();
                    m_ResizeTimer.Start();
                }
            }
        }

        private void forceSizeY_TextChanged(object sender, System.EventArgs e)
        {
            int y = Utility.ToInt32(forceSizeY.Text, 600);
            if (y >= 100 && y <= 2000)
                Config.SetProperty("ForceSizeY", y);

            if (!m_Initializing)
            {
                if (y > 100 && y < 2000)
                {
                    m_ResizeTimer.Stop();
                    m_ResizeTimer.Start();
                }
            }
        }

        private void potionEquip_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("PotionEquip", potionEquip.Checked);
        }

        private void blockHealPoison_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("BlockHealPoison", blockHealPoison.Checked);
        }

        private void negotiate_CheckedChanged(object sender, System.EventArgs e)
        {
            if (!m_Initializing)
            {
                Config.SetProperty("Negotiate", negotiate.Checked);
                Client.Instance.SetNegotiate(negotiate.Checked);
            }
        }

        private void wikiLink_LinkClicked(object sender, System.Windows.Forms.LinkLabelLinkClickedEventArgs e)
        {
            LaunchBrowser("https://github.com/msturgill/razor/wiki");
        }

        private void homeLink_LinkClicked(object sender, System.Windows.Forms.LinkLabelLinkClickedEventArgs e)
        {
            LaunchBrowser("https://github.com/msturgill/razor/wiki");
        }

        private void issuesLink_LinkClicked(object sender, System.Windows.Forms.LinkLabelLinkClickedEventArgs e)
        {
            LaunchBrowser("https://github.com/msturgill/razor/issues");
        }

        private void mleLink_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
        {
            LaunchBrowser("http://www.mlewallpapers.com/");
        }

        private void lockBox_Click(object sender, System.EventArgs e)
        {
            MessageBox.Show(this, Language.GetString(LocString.FeatureDisabledText),
                Language.GetString(LocString.FeatureDisabled), MessageBoxButtons.OK, MessageBoxIcon.Stop);
        }

        private ArrayList m_LockBoxes = new ArrayList();

        public void LockControl(Control locked)
        {
            if (locked != null)
            {
                if (locked.Parent != null && locked.Parent.Controls != null)
                {
                    try
                    {
                        int y_off = (locked.Size.Height - 16) / 2;
                        int x_off = 0;
                        System.Resources.ResourceManager resources =
                            new System.Resources.ResourceManager(typeof(MainForm));
                        PictureBox newLockBox = new PictureBox();

                        if (locked is TextBox)
                            x_off += 5;
                        else if (!(locked is CheckBox || locked is RadioButton))
                            x_off = (locked.Size.Width - 16) / 2;

                        newLockBox.Cursor = System.Windows.Forms.Cursors.Help;
                        //newLockBox.Image = ((System.Drawing.Image)(resources.GetObject("lockBox.Image")));
                        newLockBox.Size = new System.Drawing.Size(16, 16);
                        newLockBox.SizeMode = System.Windows.Forms.PictureBoxSizeMode.AutoSize;
                        newLockBox.Click += new System.EventHandler(this.lockBox_Click);

                        newLockBox.TabIndex = locked.TabIndex;
                        newLockBox.TabStop = locked.TabStop;
                        newLockBox.Location =
                            new System.Drawing.Point(locked.Location.X + x_off, locked.Location.Y + y_off);
                        newLockBox.Name = locked.Name + "LockBox";
                        newLockBox.Tag = locked;
                        newLockBox.Visible = true;

                        locked.Parent.Controls.Add(newLockBox);
                        locked.Parent.Controls.SetChildIndex(newLockBox, 0);
                        m_LockBoxes.Add(newLockBox);
                    }
                    catch
                    {
                    }
                }

                locked.Enabled = false;
            }
        }

        public void UnlockControl(Control unlock)
        {
            if (unlock != null)
            {
                for (int i = 0; i < m_LockBoxes.Count; i++)
                {
                    PictureBox box = m_LockBoxes[i] as PictureBox;
                    if (box == null)
                        continue;

                    if (box.Tag == unlock)
                    {
                        unlock.Enabled = true;
                        if (box.Parent != null && box.Parent.Controls != null)
                            box.Parent.Controls.Remove(box);

                        m_LockBoxes.RemoveAt(i);
                        break;
                    }
                }
            }
        }

        public void OnLogout()
        {
            OnMacroStop();

            features.Visible = false;

            for (int i = 0; i < m_LockBoxes.Count; i++)
            {
                PictureBox box = m_LockBoxes[i] as PictureBox;
                if (box == null)
                    continue;

                box.Parent.Controls.Remove(box);
                if (box.Tag is Control)
                    ((Control) box.Tag).Enabled = true;
            }

            m_LockBoxes.Clear();
        }

        public void UpdateControlLocks()
        {
            for (int i = 0; i < m_LockBoxes.Count; i++)
            {
                PictureBox box = m_LockBoxes[i] as PictureBox;
                if (box == null)
                    continue;

                box.Parent.Controls.Remove(box);
                if (box.Tag is Control)
                    ((Control) box.Tag).Enabled = true;
            }

            m_LockBoxes.Clear();

            if (!Client.Instance.AllowBit(FeatureBit.SmartLT))
                LockControl(this.smartLT);

            if (!Client.Instance.AllowBit(FeatureBit.RangeCheckLT))
                LockControl(this.rangeCheckLT);

            if (!Client.Instance.AllowBit(FeatureBit.AutoOpenDoors))
                LockControl(this.autoOpenDoors);

            if (!Client.Instance.AllowBit(FeatureBit.UnequipBeforeCast))
                LockControl(this.spellUnequip);

            if (!Client.Instance.AllowBit(FeatureBit.AutoPotionEquip))
                LockControl(this.potionEquip);

            if (!Client.Instance.AllowBit(FeatureBit.BlockHealPoisoned))
                LockControl(this.blockHealPoison);

            if (!Client.Instance.AllowBit(FeatureBit.LoopingMacros))
                LockControl(this.loopMacro);

            if (!Client.Instance.AllowBit(FeatureBit.OverheadHealth))
            {
                LockControl(this.showHealthOH);
                LockControl(this.healthFmt);
                LockControl(this.chkPartyOverhead);
            }
        }

        public Assistant.MapUO.MapWindow MapWindow;

        [System.Runtime.InteropServices.DllImport("user32.dll")]
        private static extern IntPtr SetParent(IntPtr child, IntPtr newParent);

        private void btnMap_Click(object sender, System.EventArgs e)
        {
            if (World.Player != null)
            {
                if (MapWindow == null)
                    MapWindow = new MapUO.MapWindow();

                MapWindow.SafeAction(s =>
                {
                    s.Show();
                    s.BringToFront();
                });
            }
        }

        private void showHealthOH_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("ShowHealth", healthFmt.Enabled = showHealthOH.Checked);
        }

        private void healthFmt_TextChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("HealthFmt", healthFmt.Text);
        }

        private void chkPartyOverhead_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetProperty("ShowPartyStats", chkPartyOverhead.Checked);
        }

        private void btcLabel_Click(object sender, EventArgs e)
        {
        }

        private void cloneProfile_Click(object sender, EventArgs e)
        {
            if (profiles.SelectedIndex < 0)
                return;

            string profileToClone = (string) profiles.Items[profiles.SelectedIndex];

            if (InputBox.Show(this, Language.GetString(LocString.EnterProfileName),
                Language.GetString(LocString.EnterAName)))
            {
                string newProfileName = InputBox.GetString();
                if (string.IsNullOrEmpty(newProfileName) ||
                    newProfileName.IndexOfAny(Path.GetInvalidPathChars()) != -1 ||
                    newProfileName.IndexOfAny(m_InvalidNameChars) != -1)
                {
                    MessageBox.Show(this, Language.GetString(LocString.InvalidChars),
                        Language.GetString(LocString.Invalid), MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                string newXml = Path.Combine(Config.GetUserDirectory("Profiles"), $"{newProfileName}.xml");

                if (File.Exists(newXml))
                {
                    MessageBox.Show(this, "A profile with that name exists, try another name.",
                        Language.GetString(LocString.Invalid), MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                File.Copy(Path.Combine(Config.GetUserDirectory("Profiles"), $"{profileToClone}.xml"),
                        Path.Combine(Config.GetUserDirectory("Profiles"), $"{newProfileName}.xml"));

                profiles.Items.Add(newProfileName);
            }
        }

        private void filterHotkeys_TextChanged(object sender, EventArgs e)
        {
            this.hotkeyTree.BeginUpdate();
            this.hotkeyTree.Nodes.Clear();

            if (this.filterHotkeys.Text != string.Empty)
            {
                foreach (TreeNode _parentNode in _hotkeyTreeViewCache.Nodes) // We won't filter on the top parent domain
                {
                    foreach (TreeNode _childNode in _parentNode.Nodes) // lets not filter on the sub-ones either
                    {
                        foreach (TreeNode _subChildNode in _childNode.Nodes
                        ) // we want all these sub child nodes to be filters
                        {
                            if (_subChildNode.Text.ToLower().Contains(filterHotkeys.Text.ToLower()))
                            {
                                this.hotkeyTree.Nodes.Add((TreeNode) _subChildNode.Clone());
                            }

                            if (_subChildNode.Nodes.Count > 0) // Just in case
                            {
                                foreach (TreeNode _subSubChildNode in _subChildNode.Nodes)
                                {
                                    if (_subSubChildNode.Text.ToLower().Contains(filterHotkeys.Text.ToLower()))
                                    {
                                        this.hotkeyTree.Nodes.Add((TreeNode) _subSubChildNode.Clone());
                                    }
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                HotKey.RebuildList(hotkeyTree);
            }

            //enables redrawing tree after all objects have been added
            this.hotkeyTree.EndUpdate();
        }

        private void filterMacros_TextChanged(object sender, EventArgs e)
        {
            macroTree.BeginUpdate();
            macroTree.Nodes.Clear();

            if (filterMacros.Text != string.Empty)
            {
                foreach (TreeNode _parentNode in _macroTreeViewCache.Nodes) // We won't filter on the top parent domain
                {
                    if (_parentNode.Text.ToLower().Contains(filterMacros.Text.ToLower()))
                    {
                        macroTree.Nodes.Add((TreeNode) _parentNode.Clone());
                    }

                    if (_parentNode.Nodes.Count > 0) // Just in case
                    {
                        foreach (TreeNode _subSubChildNode in _parentNode.Nodes)
                        {
                            if (_subSubChildNode.Text.ToLower().Contains(filterMacros.Text.ToLower()))
                            {
                                this.macroTree.Nodes.Add((TreeNode) _subSubChildNode.Clone());
                            }
                        }
                    }
                }
            }
            else
            {
                MacroManager.DisplayTo(macroTree);
            }

            //enables redrawing tree after all objects have been added
            this.macroTree.EndUpdate();
        }

        private void openRazorDataDir_Click(object sender, EventArgs e)
        {
            try
            {
                Process.Start(Config.GetUserDirectory());
            }
            catch (Exception ex)
            {
                MessageBox.Show(this, ex.Message, "Unable to open directory", MessageBoxButtons.OK,
                    MessageBoxIcon.Warning);
            }
        }

        private void createBackup_Click(object sender, EventArgs e)
        {
            try
            {
                string backupTime = $"{DateTime.Now:yyyyMMdd-HHmmss}";
                string backupDir = Path.Combine(Config.GetAppSetting<string>("BackupPath"), backupTime);
                ;

                if (string.IsNullOrEmpty(backupDir))
                    return;

                if (!Directory.Exists(backupDir))
                {
                    Directory.CreateDirectory(backupDir);
                }

                // Backup the macros
                Directory.CreateDirectory(Path.Combine(backupDir, "Macros"));

                // Create folders
                var macrosDirectory = Path.Combine(Config.GetUserDirectory(), "Macros");
                foreach (string dirPath in Directory.GetDirectories(macrosDirectory, "*",
                    SearchOption.AllDirectories))
                {
                    Directory.CreateDirectory(dirPath.Replace(macrosDirectory,
                        Path.Combine(backupDir, "Macros")));
                }

                // Copy macros
                foreach (string newPath in Directory.GetFiles(macrosDirectory, "*.*",
                    SearchOption.AllDirectories))
                {
                    File.Copy(newPath,
                        newPath.Replace(macrosDirectory,
                            Path.Combine(backupDir, "Macros")), true);
                }

                Directory.CreateDirectory(Path.Combine(backupDir, "Scripts"));

                // Create folders
                foreach (string dirPath in Directory.GetDirectories(ScriptManager.ScriptPath, "*",
                    SearchOption.AllDirectories))
                {
                    Directory.CreateDirectory(dirPath.Replace(ScriptManager.ScriptPath,
                        Path.Combine(backupDir, "Scripts")));
                }

                // Copy macros
                foreach (string newPath in Directory.GetFiles(ScriptManager.ScriptPath, "*.*",
                    SearchOption.AllDirectories))
                {
                    File.Copy(newPath,
                        newPath.Replace(ScriptManager.ScriptPath,
                            Path.Combine(backupDir, "Scripts")), true);
                }

                // Backup the profiles
                Directory.CreateDirectory(Path.Combine(backupDir, "Profiles"));
                var profilesDirectory = Path.Combine(Config.GetUserDirectory(), "Profiles");

                foreach (string newPath in Directory.GetFiles(profilesDirectory, "*.*",
                    SearchOption.AllDirectories))
                {
                    File.Copy(newPath,
                        newPath.Replace(profilesDirectory,
                            Path.Combine(backupDir, "Profiles")), true);
                }

                MessageBox.Show(this, $"Backup created: {backupDir}", "Razor Backup", MessageBoxButtons.OK,
                    MessageBoxIcon.Information);

                Config.SetAppSetting("BackupTime", DateTime.Now.ToString());
                lastBackup.Text = $"Last Backup: {Config.GetAppSetting<string>("BackupTime")}";
            }
            catch (Exception ex)
            {
                MessageBox.Show(this, ex.Message, "Unable to create backup", MessageBoxButtons.OK,
                    MessageBoxIcon.Warning);
            }
        }

        private void titleBarParams_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (titleBarParams.SelectedItem.ToString().Contains("{") && titleBarParams.Focused)
            {
                titleStr.AppendText($" {titleBarParams.SelectedItem} ");
            }
        }

        private void OnMacroVariableAddTarget(bool ground, Serial serial, Point3D pt, ushort gfx)
        {
            TargetInfo t = new TargetInfo
            {
                Gfx = gfx,
                Serial = serial,
                Type = (byte) (ground ? 1 : 0),
                X = pt.X,
                Y = pt.Y,
                Z = pt.Z
            };

            if (InputBox.Show(this, Language.GetString(LocString.NewMacroVariable),
                Language.GetString(LocString.EnterAName)))
            {
                string name = InputBox.GetString();

                foreach (MacroVariables.MacroVariable mV in MacroVariables.MacroVariableList
                )
                {
                    if (mV.Name.ToLower().Equals(name.ToLower()))
                    {
                        MessageBox.Show(this, "Pick a unique Macro Variable name and try again",
                            "New Macro Variable", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        return;
                    }
                }

                MacroVariables.MacroVariableList.Add(
                    new MacroVariables.MacroVariable(name, t));

                // Save and reload the macros and vars
                MacroManager.DisplayMacroVariables(macroVariables);
            }

            Engine.MainWindow.ShowMe();
        }

        private void OnMacroVariableReTarget(bool ground, Serial serial, Point3D pt, ushort gfx)
        {
            TargetInfo t = new TargetInfo
            {
                Gfx = gfx,
                Serial = serial,
                Type = (byte) (ground ? 1 : 0),
                X = pt.X,
                Y = pt.Y,
                Z = pt.Z
            };

            MacroVariables.MacroVariableList[macroVariables.SelectedIndex].TargetInfo = t;

            // Save and reload the macros and vars
            MacroManager.DisplayMacroVariables(macroVariables);

            Engine.MainWindow.ShowMe();
        }

        private void linkLabel2_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
        {
            Utility.LaunchBrowser("https://www.razorce.com");
        }

        private void targetByTypeDifferent_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("DiffTargetByType", targetByTypeDifferent.Checked);
        }

        private void stepThroughMacro_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("StepThroughMacro", stepThroughMacro.Checked);
        }

        private void nextMacroAction_Click(object sender, EventArgs e)
        {
            /*if (actionList.SelectedIndex + 1 > actionList.Items.Count - 1)
            {
                actionList.SelectedIndex = 0;
            }*/

            MacroManager.PlayNext();
        }

        private void disableSmartCPU_Click(object sender, EventArgs e)
        {
            Client.Instance.SetSmartCPU(false);
        }

        private void lightLevelBar_Scroll(object sender, EventArgs e)
        {
            if (Client.Instance.AllowBit(FeatureBit.LightFilter) && World.Player != null)
            {
                byte selectedLightLevel = Convert.ToByte(lightLevelBar.Maximum - lightLevelBar.Value);

                World.Player.LocalLightLevel = 0;
                World.Player.GlobalLightLevel = selectedLightLevel;

                Client.Instance.SendToClient(new GlobalLightLevel(selectedLightLevel));
                Client.Instance.SendToClient(new PersonalLightLevel(World.Player));

                double percent = Math.Round((lightLevelBar.Value / (double) lightLevelBar.Maximum) * 100.0);

                lightLevel.Text = $"Light: {percent}%";

                Config.SetProperty("LightLevel", (int) selectedLightLevel);
            }
        }

        private BoatWindow _boatWindowForm = null;

        private void boatControl_Click(object sender, EventArgs e)
        {
            if (_boatWindowForm != null)
            {
                _boatWindowForm.Show();
            }
            else
            {
                _boatWindowForm = new BoatWindow();
                _boatWindowForm.Show();
            }
        }

        private void showTargetMessagesOverChar_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ShowTargetSelfLastClearOverhead", showTargetMessagesOverChar.Checked);
        }

        private void openUOPS_Click(object sender, EventArgs e)
        {
            MessageBox.Show("Soon(tm)");

            return;

            /*if (World.Player != null)
            {
                if (MapWindow == null)
                    MapWindow = new Assistant.MapUO.MapWindow();
                //SetParent( MapWindow.Handle, Client.FindUOWindow() );
                //MapWindow.Owner = (Form)Form.FromHandle( Client.FindUOWindow() );
                MapWindow.Show();
                MapWindow.BringToFront();
            }*/
        }

        private void logSkillChanges_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("LogSkillChanges", logSkillChanges.Checked);
        }
        
        private void saveProfile_Click(object sender, EventArgs e)
        {
            if (profiles.SelectedIndex < 0)
                return;

            Config.Save();
            Counter.Save();

            string profileToClone = (string) profiles.Items[profiles.SelectedIndex];
            MessageBox.Show(SplashScreen.Instance,
                $"Saved current settings to profile {Path.Combine(Config.GetUserDirectory("Profiles"), $"{profileToClone}.xml")}",
                "Save Profile", MessageBoxButtons.OK, MessageBoxIcon.Information);
        }

        private void stealthOverhead_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("StealthOverhead", stealthOverhead.Checked);
        }

        private void captureMibs_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("CaptureMibs", captureMibs.Checked);
        }

        private void trackIncomingGold_CheckedChanged(object sender, EventArgs e)
        {
            if (World.Player == null)
            {
                GoldPerHourTimer.Stop();
                return;
            }

            if (trackIncomingGold.Checked)
            {
                GoldPerHourTimer.Start();
            }
            else
            {
                GoldPerHourTimer.Stop();
            }
        }

        private void objectDelay_CheckedChanged(object sender, EventArgs e)
        {
            txtObjDelay.Enabled = objectDelay.Checked;

            Config.SetProperty("ObjectDelayEnabled", objectDelay.Checked);
        }

        private void showBuffDebuffOverhead_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ShowBuffDebuffOverhead", showBuffDebuffOverhead.Checked);
        }

        private void blockOpenCorpsesTwice_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("BlockOpenCorpsesTwice", blockOpenCorpsesTwice.Checked);

            if (blockOpenCorpsesTwice.Checked)
            {
                if (World.Player == null)
                    return;

                World.Player.OpenedCorpses.Clear();
            }
        }

        private void showAttackTarget_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ShowAttackTargetOverhead", showAttackTarget.Checked);
        }

        private void rangeCheckTargetByType_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("RangeCheckTargetByType", rangeCheckTargetByType.Checked);
        }

        private void rangeCheckDoubleClick_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("RangeCheckDoubleClick", rangeCheckDoubleClick.Checked);
        }

        private void agentSubList_MouseDown(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Right && e.Clicks == 1)
            {
                ContextMenuStrip menu = new ContextMenuStrip();
                menu.Items.Add("Export (Copy to clipboard)", null, OnAgentExport);
                menu.Items.Add("-");
                menu.Items.Add("Import (Copy from clipboard)", null, OnAgentImport);

                ToolStripMenuItem submenu = new ToolStripMenuItem("Import from profile");

                foreach (string profile in Config.GetProfileList())
                {
                    submenu.DropDownItems.Add(profile, null, OnAgentImportFromProfile);
                }

                menu.Items.Add(submenu);

                menu.Show(agentSubList, new Point(e.X, e.Y));
            }

            if (agentList.SelectedIndex < 0 || agentSubList.Items.Count == 0)
                return;

            if (e.Button == MouseButtons.Left && e.Clicks == 2)
            {
                if (agentList.SelectedIndex < 0)
                    return;

                Agent a = agentList.SelectedItem as Agent;

                switch (agentList.SelectedItem)
                {
                    case RestockAgent _:
                        a.OnButtonPress(3);
                        break;
                    case BuyAgent _:
                        a.OnButtonPress(2);
                        break;
                }
            }
        }

        private void OnAgentExport(object sender, System.EventArgs e)
        {
            if (agentList.SelectedIndex < 0 || agentSubList.Items.Count == 0)
                return;
            
            StringBuilder sb = new StringBuilder();

            Agent agent = (Agent)agentList.SelectedItem;

            switch (agent)
            {
                case OrganizerAgent organizerAgent:
                    sb.AppendLine("!Razor.Agents.Organizer");

                    foreach (ItemID item in agentSubList.Items)
                    {
                        sb.AppendLine(item.Value.ToString());
                    }

                    break;
                case BuyAgent buyAgent:
                    sb.AppendLine("!Razor.Agents.Buy");

                    foreach (BuyAgent.BuyEntry entry in agentSubList.Items)
                    {
                        sb.AppendLine($"{entry.Id},{entry.Amount}");
                    }

                    break;
                case RestockAgent restockAgent:
                    sb.AppendLine("!Razor.Agents.Restock");

                    foreach (RestockAgent.RestockItem entry in agentSubList.Items)
                    {
                        sb.AppendLine($"{entry.ItemID.Value},{entry.Amount}");
                    }

                    break;
                case ScavengerAgent scavAgent:
                    sb.AppendLine("!Razor.Agents.Scavenger");

                    foreach (ItemID item in agentSubList.Items)
                    {
                        sb.AppendLine(item.Value.ToString());
                    }

                    break;
                case SellAgent sellAgent:
                    sb.AppendLine("!Razor.Agents.Sell");

                    foreach (ItemID item in agentSubList.Items)
                    {
                        sb.AppendLine(item.Value.ToString());
                    }

                    break;
            }

            Clipboard.SetDataObject(sb.ToString(), true);
        }

        private void OnAgentImport(object sender, System.EventArgs e)
        {
            if (agentList.SelectedIndex < 0)
                return;

            Agent agent = (Agent)agentList.SelectedItem;

            if (!Clipboard.GetText().Contains("!Razor.Agents"))
            {
                return;
            }

            List<string> items = Clipboard.GetText()
                .Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.None).ToList();

            if (agent is OrganizerAgent organizerAgent && Clipboard.GetText().Contains("!Razor.Agents.Organizer"))
            {
                items.RemoveAt(0);

                foreach (string item in items)
                {
                    if (!string.IsNullOrEmpty(item) && ushort.TryParse(item, out ushort gfx))
                    {
                        organizerAgent.AddItem(gfx);
                    }
                }
            }
            else if (agent is BuyAgent buyAgent && Clipboard.GetText().Contains("!Razor.Agents.Buy"))
            {
                items.RemoveAt(0);

                foreach (string item in items)
                {
                    string[] split = item.Split(',');

                    if (!string.IsNullOrEmpty(item) && ushort.TryParse(split[0], out ushort id) && ushort.TryParse(split[1], out ushort amount))
                    {
                        buyAgent.AddItem(new BuyAgent.BuyEntry(id, amount));
                    }
                }
            }
            else if (agent is RestockAgent restockAgent && Clipboard.GetText().Contains("!Razor.Agents.Restock"))
            {
                items.RemoveAt(0);

                foreach (string item in items)
                {
                    string[] split = item.Split(',');

                    if (!string.IsNullOrEmpty(item) && ushort.TryParse(split[0], out ushort id) && ushort.TryParse(split[1], out ushort amount))
                    {
                        restockAgent.AddItem(new RestockAgent.RestockItem(id, amount));
                    }
                }
            }
            else if (agent is ScavengerAgent scavengerAgent && Clipboard.GetText().Contains("!Razor.Agents.Scavenger"))
            {
                items.RemoveAt(0);

                foreach (string item in items)
                {
                    if (!string.IsNullOrEmpty(item) && ushort.TryParse(item, out ushort gfx))
                    {
                        scavengerAgent.Add(gfx);
                    }
                }
            }
            else if (agent is SellAgent sellAgent && Clipboard.GetText().Contains("!Razor.Agents.Sell"))
            {
                items.RemoveAt(0);

                foreach (string item in items)
                {
                    if (!string.IsNullOrEmpty(item) && ushort.TryParse(item, out ushort gfx))
                    {
                        sellAgent.Add(gfx);
                    }
                }
            }
        }

        private void OnAgentImportFromProfile(object sender, System.EventArgs e)
        {
            if (agentList.SelectedIndex < 0)
                return;

            Agent agent = (Agent)agentList.SelectedItem;

            string file = Path.Combine(Config.GetUserDirectory("Profiles"), $"{sender}.xml");
            if (!File.Exists(file))
                return;

            XmlDocument doc = new XmlDocument();
            doc.Load(file);

            XmlElement root = doc["profile"];
            if (root == null)
                return;

            switch (agent)
            {
                case OrganizerAgent organizerAgent:

                    try
                    {
                        foreach (XmlElement el in root.GetElementsByTagName("item"))
                        {
                            try
                            {
                                string gfx = el.GetAttribute("id");
                                organizerAgent.AddItem(Convert.ToUInt16(gfx));
                            }
                            catch
                            {
                                // ignored
                            }
                        }
                    }
                    catch
                    {
                        // ignored
                    }

                    break;
                case BuyAgent buyAgent:
                    try
                    {
                        foreach (XmlElement el in root.GetElementsByTagName("item"))
                        {
                            try
                            {
                                string gfx = el.GetAttribute("id");
                                string amount = el.GetAttribute("amount");

                                BuyAgent.BuyEntry entry = new BuyAgent.BuyEntry(Convert.ToUInt16(gfx), Convert.ToUInt16(amount));

                                buyAgent.AddItem(entry);
                            }
                            catch
                            {
                                // ignored
                            }
                        }
                    }
                    catch
                    {
                        // ignored
                    }

                    break;
                case RestockAgent restockAgent:

                    foreach (XmlElement el in root.GetElementsByTagName("item"))
                    {
                        try
                        {
                            string gfx = el.GetAttribute("id");
                            string amount = el.GetAttribute("amount");

                            RestockAgent.RestockItem entry = new RestockAgent.RestockItem(Convert.ToUInt16(gfx), Convert.ToUInt16(amount));

                            restockAgent.AddItem(entry);
                        }
                        catch
                        {
                            // ignored
                        }
                    }

                    break;
                case ScavengerAgent scavAgent:
                    try
                    {
                        foreach (XmlElement el in root.GetElementsByTagName("item"))
                        {
                            try
                            {
                                string gfx = el.GetAttribute("id");
                                scavAgent.Add(Convert.ToUInt16(gfx));
                            }
                            catch
                            {
                                // ignored
                            }
                        }
                    }
                    catch
                    {
                        // ignored
                    }

                    break;
                case SellAgent sellAgent:
                    try
                    {
                        foreach (XmlElement el in root.GetElementsByTagName("item"))
                        {
                            try
                            {
                                string gfx = el.GetAttribute("id");
                                sellAgent.Add(Convert.ToUInt16(gfx));
                            }
                            catch
                            {
                                // ignored
                            }
                        }
                    }
                    catch
                    {
                        // ignored
                    }

                    break;
            }
        }

        private void showContainerLabels_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ShowContainerLabels", showContainerLabels.Checked);

            containerLabels.Enabled = showContainerLabels.Checked;
        }

        private ContainerLabels _containerLabelsForm = null;

        private void containerLabels_Click(object sender, EventArgs e)
        {
            if (_containerLabelsForm != null)
            {
                _containerLabelsForm.Show();
            }
            else
            {
                _containerLabelsForm = new ContainerLabels();
                _containerLabelsForm.Show();
            }
        }

        private void seasonList_SelectedIndexChanged(object sender, EventArgs e)
        {
            //Season Flag:
            //0: Spring
            //1: Summer
            //2: Fall
            //3: Winter
            //4: Desolation
            //Default server

            if (seasonList.SelectedIndex < 0)
                return;

            Config.SetProperty("Season", seasonList.SelectedIndex);

            if (seasonList.SelectedIndex < 5)
            {
                Client.Instance.ForceSendToClient(new SeasonChange(seasonList.SelectedIndex, true));
            }
        }

        private void blockPartyInvites_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("BlockPartyInvites", blockPartyInvites.Checked);
        }

        private void blockTradeRequests_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("BlockTradeRequests", blockTradeRequests.Checked);
        }

        private void autoAcceptParty_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("AutoAcceptParty", autoAcceptParty.Checked);
        }

        private void setMaxLightLevel_Click(object sender, EventArgs e)
        {
            int lightLevel = lightLevelBar.Maximum - lightLevelBar.Value;

            if (lightLevel > Config.GetInt("MinLightLevel"))
            {
                MessageBox.Show(this,
                    $"Selected maximum light level {lightLevel} exceeds minimum light level {Config.GetInt("MinLightLevel")}",
                    "Set Max Light Level", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            else
            {
                Config.SetProperty("MaxLightLevel", lightLevel);
            }
        }

        private void setMinLightLevel_Click(object sender, EventArgs e)
        {
            int lightLevel = lightLevelBar.Maximum - lightLevelBar.Value;

            if (lightLevel < Config.GetInt("MaxLightLevel"))
            {
                MessageBox.Show(this,
                    $"Selected minimum light level {lightLevel} exceeds maximum light level {Config.GetInt("MaxLightLevel")}",
                    "Set Min Light Level", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            else
            {
                Config.SetProperty("MinLightLevel", lightLevel);
            }
        }

        private void minMaxLightLevel_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("MinMaxLightLevelEnabled", minMaxLightLevel.Checked);
        }

        private void showStaticWalls_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ShowStaticWalls", showStaticWalls.Checked);
        }

        private void showStaticWallLabels_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ShowStaticWallLabels", showStaticWallLabels.Checked);
        }

        private void showTextTargetIndicator_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ShowTextTargetIndicator", showTextTargetIndicator.Checked);
        }

        private void showAttackTargetNewOnly_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ShowAttackTargetNewOnly", showAttackTargetNewOnly.Checked);
        }

        private void addMacroVariable_Click(object sender, EventArgs e)
        {
            if (MacroManager.Playing || MacroManager.Recording || World.Player == null)
                return;

            //switch (macroVariableTypeList.SelectedIndex)
            //{
            //    case 0:
            Targeting.OneTimeTarget(OnMacroVariableAddTarget);
            //        break;
            //    case 1:
            //        Targeting.OneTimeTarget(OnDoubleClickAddTarget);
            //        break;
            //}


            World.Player.SendMessage(MsgLevel.Force, LocString.SelTargAct);
        }

        private void insertMacroVariable_Click(object sender, EventArgs e)
        {
            if (MacroManager.Playing || MacroManager.Recording || World.Player == null)
                return;

            Macro m = GetMacroSel();

            if (m == null)
                return;

            int a = actionList.SelectedIndex;

            if (macroVariables.SelectedIndex < 0)
            {
                return;
            }

            string[] macroVariableName = {MacroVariables.MacroVariableList[macroVariables.SelectedIndex].Name};

            switch (macroVariableTypeList.SelectedIndex)
            {
                case 0:
                    m.Actions.Insert(a + 1, new AbsoluteTargetVariableAction(macroVariableName));
                    break;
                case 1:
                    m.Actions.Insert(a + 1, new DoubleClickVariableAction(macroVariableName));
                    break;
                case 2:
                    m.Actions.Insert(a + 1, new SetMacroVariableTargetAction(macroVariableName));
                    break;
            }

            RedrawActionList(m);
        }

        private void retargetMacroVariable_Click(object sender, EventArgs e)
        {
            if (MacroManager.Playing || MacroManager.Recording || World.Player == null)
                return;

            if (macroVariables.SelectedIndex < 0)
                return;

            Targeting.OneTimeTarget(OnMacroVariableReTarget);

            World.Player.SendMessage(MsgLevel.Force, LocString.SelTargAct);
        }

        private void removeMacroVariable_Click(object sender, EventArgs e)
        {
            if (MacroManager.Playing || MacroManager.Recording || World.Player == null)
                return;

            if (macroVariables.SelectedIndex < 0)
                return;

            MacroVariables.MacroVariableList.RemoveAt(macroVariables.SelectedIndex);

            // Save and reload the macros and vars
            MacroManager.Save();
            MacroManager.DisplayMacroVariables(macroVariables);
        }

        private void macroVariableTypeList_SelectedIndexChanged(object sender, EventArgs e)
        {
            //MacroManager.DisplayMacroVariables(macroVariables);
        }

        private void filterDragonGraphics_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("FilterDragonGraphics", filterDragonGraphics.Checked);

            if (filterDragonGraphics.Checked)
            {
                MobileFilter.ApplyToMobiles();
            }
        }

        private void dragonAnimationList_SelectedIndexChanged(object sender, EventArgs e)
        {
            try
            {
                if (dragonAnimationList.SelectedIndex < 0)
                    return;

                Config.SetProperty("DragonGraphic", _animationData[dragonAnimationList.SelectedIndex].BodyId);

                MobileFilter.Load();
            }
            catch
            {
                MessageBox.Show(this, "Unable to find animation in file", "Animation Error", MessageBoxButtons.OK,
                    MessageBoxIcon.Error);
            }
        }

        private void drakeAnimationList_SelectedIndexChanged(object sender, EventArgs e)
        {
            try
            {
                if (drakeAnimationList.SelectedIndex < 0)
                    return;

                Config.SetProperty("DrakeGraphic", _animationData[drakeAnimationList.SelectedIndex].BodyId);

                MobileFilter.Load();
            }
            catch
            {
                MessageBox.Show(this, "Unable to find animation in file", "Animation Error", MessageBoxButtons.OK,
                    MessageBoxIcon.Error);
            }
        }

        private void trackDps_CheckedChanged(object sender, EventArgs e)
        {
            if (trackDps.Checked)
            {
                DamageTracker.Start();
            }
            else
            {
                DamageTracker.Stop();
            }
        }

        private void showDamageDealt_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ShowDamageDealt", showDamageDealt.Checked);
        }

        private void damageDealtOverhead_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ShowDamageDealtOverhead", damageDealtOverhead.Checked);
        }

        private void damageTakenOverhead_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ShowDamageTakenOverhead", damageTakenOverhead.Checked);
        }

        private void showDamageTaken_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ShowDamageTaken", showDamageTaken.Checked);
        }

        private void filterDrakeGraphics_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("FilterDrakeGraphics", filterDrakeGraphics.Checked);

            if (filterDrakeGraphics.Checked)
            {
                MobileFilter.ApplyToMobiles();
            }
        }

        private void showInRazorTitleBar_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ShowInRazorTitleBar", showInRazorTitleBar.Checked);

            UpdateTitle();
        }

        private void razorTitleBar_TextChanged(object sender, EventArgs e)
        {
            Config.SetProperty("RazorTitleBarText", razorTitleBar.Text.TrimEnd());
            if (Config.GetBool("ShowInRazorTitleBar"))
                UpdateTitle();
        }

        private void razorTitleBarKey_Click(object sender, EventArgs e)
        {
            //Replace("{name}", World.Player.Name).Replace("{shard}", World.ShardName)
            //.Replace("{version}", Engine.Version).Replace("{profile}", Config.CurrentProfile.Name).Replace("{account}", World.AccountName);

            StringBuilder sb = new StringBuilder();
            sb.AppendLine("You can insert these variables into the Razor Title Bar to display specific information.");
            sb.AppendLine(string.Empty);
            sb.AppendLine("{name} - Character name");
            sb.AppendLine("{shard} - Shard/Server name");
            sb.AppendLine("{version} - Razor version");
            sb.AppendLine("{profile} - Selected profile name");
            sb.AppendLine("{account} - Account name");

            MessageBox.Show(this, sb.ToString(), "Razor Title Bar Variables", MessageBoxButtons.OK,
                MessageBoxIcon.Information);
        }

        private void linkHelp_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
        {
            Utility.LaunchBrowser("https://www.razorce.com/help/");
        }

        private void enableUOAAPI_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("EnableUOAAPI", enableUOAAPI.Checked);
        }

        private void setBackupFolder_Click(object sender, EventArgs e)
        {
            //Config.SetAppSetting("UODataDir", dataDir.Text);

            FolderBrowserDialog folder = new FolderBrowserDialog();
            folder.Description = "Select Backup Folder";
            folder.SelectedPath = Config.GetAppSetting<string>("BackupPath");
            folder.ShowNewFolderButton = true;

            if (folder.ShowDialog(this) == DialogResult.OK)
            {
                Config.SetAppSetting("BackupPath", folder.SelectedPath);
            }
        }

        private void openBackupFolder_Click(object sender, EventArgs e)
        {
            try
            {
                Process.Start(Config.GetAppSetting<string>("BackupPath"));
            }
            catch
            {
            }
        }

        private void targetIndicatorFormat_TextChanged(object sender, EventArgs e)
        {
            if (string.IsNullOrEmpty(targetIndicatorFormat.Text))
            {
                Config.SetProperty("TargetIndicatorFormat", "* Target *");
                targetIndicatorFormat.Text = "* Target *";
            }

            Config.SetProperty("TargetIndicatorFormat", targetIndicatorFormat.Text);
        }

        private void nextPrevIgnoresFriends_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("NextPrevTargetIgnoresFriends", nextPrevIgnoresFriends.Checked);
        }

        private void stealthStepsFormat_TextChanged(object sender, EventArgs e)
        {
            Config.SetProperty("StealthStepsFormat", stealthStepsFormat.Text);
        }

        private void showFriendOverhead_CheckedChanged(object sender, EventArgs e)
        {
            if (friendsGroup.SelectedIndex < 0)
                return;

            FriendsManager.SetOverheadFormatEnabled((FriendsManager.FriendGroup)friendsGroup.SelectedItem,
                showFriendOverhead.Checked);
        }

        private void dispDeltaOverhead_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("DisplaySkillChangesOverhead", dispDeltaOverhead.Checked);
        }

        private void linkGitHub_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
        {
            Utility.LaunchBrowser("https://github.com/markdwags/Razor");
        }

        /// <summary>
        /// Quickly disable UI elements not used when ClassicUO is the client
        /// </summary>
        public void DisableCUOFeatures()
        {
            forceSizeX.SafeAction(s =>
            {
                s.Enabled = false;
                s.Text = "0";
            });

            forceSizeY.SafeAction(s =>
            {
                s.Enabled = false;
                s.Text = "0";
            });

            gameSize.SafeAction(s =>
            {
                s.Enabled = false;
                s.Checked = false;
            });

            rememberPwds.SafeAction(s =>
            {
                s.Enabled = false;
                s.Checked = false;
            });

            highlightSpellReags.SafeAction(s =>
            {
                s.Enabled = false;
                s.Checked = false;
            });

            showNotoHue.SafeAction(s =>
            {
                s.Enabled = false;
                s.Checked = false;
            });

            titlebarImages.SafeAction(s =>
            {
                s.Enabled = false;
                s.Checked = false;
            });

            showWelcome.SafeAction(s =>
            {
                s.Enabled = false;
                s.Checked = false;
            });

            showHealthOH.SafeAction(s =>
            {
                s.Enabled = false;
                s.Checked = false;
            });

            healthFmt.SafeAction(s => { s.Enabled = false; });
        }

        private void macroActionDelay_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("MacroActionDelay", macroActionDelay.Checked);

            if (m_Initializing)
                return;

            MessageBox.Show(this, Language.GetString(LocString.NextRestart), "Notice", MessageBoxButtons.OK,
                MessageBoxIcon.Information);
        }

        private void autoDoorWhenHidden_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("AutoOpenDoorWhenHidden", autoOpenDoorWhenHidden.Checked);
        }

        private void disableMacroPlayFinish_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("DisableMacroPlayFinish", disableMacroPlayFinish.Checked);
        }

        private void showBandageTimer_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ShowBandageTimer", showBandageTimer.Checked);
        }

        private void bandageTimerLocation_SelectedIndexChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ShowBandageTimerLocation", bandageTimerLocation.SelectedIndex);
        }

        private void onlyShowBandageTimerSeconds_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("OnlyShowBandageTimerEvery", onlyShowBandageTimerSeconds.Checked);
        }

        private void bandageTimerSeconds_TextChanged(object sender, EventArgs e)
        {
            Config.SetProperty("OnlyShowBandageTimerSeconds", Utility.ToInt32(bandageTimerSeconds.Text.Trim(), 1));
        }

        private void bandageTimerFormat_TextChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ShowBandageTimerFormat", bandageTimerFormat.Text);

            if (string.IsNullOrEmpty(bandageTimerFormat.Text))
            {
                Config.SetProperty("ShowBandageTimerFormat", "Bandage: {count}s");
                bandageTimerFormat.Text = "Bandage: {count}s";
            }

            Config.SetProperty("ShowBandageTimerFormat", bandageTimerFormat.Text);
        }

        private void setBandageHue_Click(object sender, EventArgs e)
        {
            lblBandageCountFormat.SafeAction(s => { SetHue(s, "ShowBandageTimerHue"); });
        }

        private void friendRemoveSelected_Click(object sender, EventArgs e)
        {
            if (friendsGroup.SelectedIndex < 0 || friendsList.SelectedIndex < 0)
                return;

            FriendsManager.RemoveFriend((FriendsManager.FriendGroup) friendsGroup.SelectedItem,
                friendsList.SelectedIndex);
        }

        private void friendsGroupAdd_Click(object sender, EventArgs e)
        {
            if (InputBox.Show(this, "Add Friend Group", "Enter the name of this new Friend Group"))
            {
                string name = InputBox.GetString();

                if (!string.IsNullOrEmpty(name) && !FriendsManager.FriendsGroupExists(name))
                {
                    FriendsManager.AddFriendGroup(name);
                }
                else
                {
                    MessageBox.Show(this, "Invalid name, or friends group already exists", "Error",
                        MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }
        }

        private void friendsGroupRemove_Click(object sender, EventArgs e)
        {
            if (friendsGroup.SelectedIndex < 0)
                return;

            if (MessageBox.Show(this, Language.GetString(LocString.Confirm), Language.GetString(LocString.ClearList),
                    MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
            {
                if (FriendsManager.DeleteFriendGroup((FriendsManager.FriendGroup) friendsGroup.SelectedItem))
                {
                    FriendsManager.RedrawGroup();

                    if (friendsGroup.Items.Count > 0)
                    {
                        friendsGroup.SafeAction(s => s.SelectedIndex = 0);
                    }
                    else
                    {
                        friendsList.SafeAction(s => s.Items.Clear());
                    }
                }
            }
        }

        private void friendsGroup_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (friendsGroup.SelectedIndex < 0)
                return;

            var friendGroup = (FriendsManager.FriendGroup) friendsGroup.SelectedItem;

            friendsListEnabled.SafeAction(s => s.Checked = friendGroup.Enabled);

            friendFormat.SafeAction(s =>
            {
                int hueIdx = friendGroup.OverheadFormatHue;

                if (hueIdx > 0 && hueIdx < 3000)
                    s.BackColor = Hues.GetHue(hueIdx - 1).GetColor(HueEntry.TextHueIDX);
                else
                    s.BackColor = SystemColors.Control;

                s.ForeColor = (s.BackColor.GetBrightness() < 0.35 ? Color.White : Color.Black);
            });

            friendOverheadFormat.SafeAction(s => s.Text = friendGroup.OverheadFormat);
            showFriendOverhead.SafeAction(s => s.Checked = friendGroup.OverheadFormatEnabled);

            FriendsManager.RedrawList(friendGroup);
        }

        private void friendClearList_Click(object sender, EventArgs e)
        {
            if (friendsGroup.SelectedIndex < 0)
                return;

            if (MessageBox.Show(this, Language.GetString(LocString.Confirm), Language.GetString(LocString.ClearList),
                    MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
            {
                FriendsManager.FriendGroup friendGroup = (FriendsManager.FriendGroup) friendsGroup.SelectedItem;
                friendGroup.Friends.Clear();

                FriendsManager.RedrawList(friendGroup);
            }
        }

        private void friendsListEnabled_CheckedChanged(object sender, EventArgs e)
        {
            if (friendsGroup.SelectedIndex < 0)
                return;

            FriendsManager.EnableFriendsGroup((FriendsManager.FriendGroup) friendsGroup.SelectedItem,
                friendsListEnabled.Checked);
        }

        private void friendOverheadFormat_TextChanged(object sender, EventArgs e)
        {
            if (friendsGroup.SelectedIndex < 0)
                return;

            //FriendOverheadFormat
            if (string.IsNullOrEmpty(friendOverheadFormat.Text))
            {
                targetIndicatorFormat.SafeAction(s => s.Text = "[Friend]");
            }

            friendOverheadFormat.SafeAction(s => FriendsManager.SetOverheadFormat((FriendsManager.FriendGroup)friendsGroup.SelectedItem,
                s.Text));
        }

        private void setFriendsFormatHue_Click(object sender, EventArgs e)
        {
            if (friendsGroup.SelectedIndex < 0)
                return;

            friendFormat.SafeAction(s =>
            {
                FriendsManager.FriendGroup group = (FriendsManager.FriendGroup) friendsGroup.SelectedItem;

                HueEntry h = new HueEntry(group.OverheadFormatHue);

                if (h.ShowDialog(this) == DialogResult.OK)
                {
                    int hueIdx = h.Hue;
                    
                    if (hueIdx > 0 && hueIdx < 3000)
                        s.BackColor = Hues.GetHue(hueIdx - 1).GetColor(HueEntry.TextHueIDX);
                    else
                        s.BackColor = Color.White;

                    s.ForeColor = (s.BackColor.GetBrightness() < 0.35 ? Color.White : Color.Black);

                    FriendsManager.SetOverheadHue((FriendsManager.FriendGroup)friendsGroup.SelectedItem,
                        hueIdx);
                }
            });
        }

        private void friendAddTarget_MouseDown(object sender, System.Windows.Forms.MouseEventArgs e)
        {
            if (World.Player == null)
                return;

            if (friendsGroup.SelectedIndex < 0)
                return;

            if ((e.Button & MouseButtons.Right) != 0)
            {
                ContextMenuStrip menu = new ContextMenuStrip();
                menu.Items.Add(Language.GetString(LocString.AddAllMobileFriends), null,
                    onAddAllMobilesAsFriends);
                menu.Items.Add(Language.GetString(LocString.AddAllHumanoidsAsFriends), null,
                    onAddAllHumanoidsAsFriends);

                menu.Show(friendAddTarget, new Point(e.X, e.Y));
            }
            else
            {
                FriendsManager.OnTargetAddFriend((FriendsManager.FriendGroup) friendsGroup.SelectedItem);
            }
        }

        private void onAddAllMobilesAsFriends(object sender, System.EventArgs e)
        {
            if (friendsGroup.SelectedIndex < 0)
                return;

            if (World.Player == null)
                return;

            FriendsManager.FriendGroup friendGroup = (FriendsManager.FriendGroup) friendsGroup.SelectedItem;
            friendGroup.AddAllMobileAsFriends();
        }

        private void onAddAllHumanoidsAsFriends(object sender, System.EventArgs e)
        {
            if (friendsGroup.SelectedIndex < 0)
                return;

            if (World.Player == null)
                return;

            FriendsManager.FriendGroup friendGroup = (FriendsManager.FriendGroup) friendsGroup.SelectedItem;
            friendGroup.AddAllHumanoidsAsFriends();
        }

        private void friendsList_KeyDown(object sender, System.Windows.Forms.KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Delete)
            {
                if (friendsList.SelectedIndex < 0 || friendsGroup.SelectedIndex < 0)
                    return;

                FriendsManager.RemoveFriend((FriendsManager.FriendGroup) friendsGroup.SelectedItem,
                    friendsList.SelectedIndex);
            }
        }

        private void friendsList_MouseDown(object sender, System.Windows.Forms.MouseEventArgs e)
        {
            if (friendsGroup.SelectedIndex < 0)
                return;

            if (e.Button == MouseButtons.Right)
            {
                ContextMenuStrip menu = new ContextMenuStrip();
                menu.Items.Add("Import 'Friends' from clipboard", null, onImportFriends);
                menu.Items.Add("Export 'Friends' to clipboard", null, onExportFriends);

                menu.Show(friendsList, new Point(e.X, e.Y));
            }
        }

        private void onImportFriends(object sender, System.EventArgs e)
        {
            if (friendsGroup.SelectedIndex < 0)
                return;

            try
            {
                if (Clipboard.GetText().Contains("!Razor.Friends.Import"))
                {
                    List<string> friendsImport = Clipboard.GetText()
                        .Split(new[] {"\r\n", "\r", "\n"}, StringSplitOptions.None).ToList();

                    friendsImport.RemoveAt(0);

                    foreach (string import in friendsImport)
                    {
                        if (string.IsNullOrEmpty(import))
                            continue;

                        string[] friend = import.Split('#');

                        FriendsManager.FriendGroup friendGroup = (FriendsManager.FriendGroup) friendsGroup.SelectedItem;

                        friendGroup.AddFriend(friend[0], Serial.Parse(friend[1]));
                    }

                    Clipboard.Clear();
                }
            }
            catch
            {
            }
        }

        private void onExportFriends(object sender, System.EventArgs e)
        {
            if (friendsGroup.SelectedIndex < 0 || friendsList.Items.Count == 0)
                return;

            StringBuilder sb = new StringBuilder();

            sb.AppendLine("!Razor.Friends.Import");


            FriendsManager.FriendGroup friendGroup = (FriendsManager.FriendGroup) friendsGroup.SelectedItem;

            foreach (FriendsManager.Friend friend in friendGroup.Friends)
            {
                sb.AppendLine($"{friend.Name}#{friend.Serial}");
            }


            Clipboard.SetDataObject(sb.ToString(), true);
        }

        private void setTargetIndicatorHue_Click(object sender, EventArgs e)
        {
            lblTargetFormat.SafeAction(s => { SetHue(s, "TargetIndicatorHue"); });
        }

        private void filterSystemMessages_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("FilterSystemMessages", filterSystemMessages.Checked);
        }

        private void filterRazorMessages_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("FilterRazorMessages", filterRazorMessages.Checked);
        }

        private void filterDelaySeconds_TextChanged(object sender, EventArgs e)
        {
            Config.SetProperty("FilterDelay", Utility.ToDouble(filterDelaySeconds.Text.Trim(), 3.5));

            if (Config.GetDouble("FilterDelay") < 0 || Config.GetDouble("FilterDelay") > 20)
            {
                Config.SetProperty("FilterDelay", 3.5);
                filterDelaySeconds.SafeAction(s => s.Text = "3.5");
            }
        }

        private void filterOverheadMessages_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("FilterOverheadMessages", filterOverheadMessages.Checked);
        }

        private void onlyNextPrevBeneficial_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("OnlyNextPrevBeneficial", onlyNextPrevBeneficial.Checked);
        }

        private void friendBeneficialOnly_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("FriendlyBeneficialOnly", friendBeneficialOnly.Checked);
        }

        private void nonFriendlyHarmfulOnly_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("NonFriendlyHarmfulOnly", nonFriendlyHarmfulOnly.Checked);
        }

        private void ShowBandageStart_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ShowBandageStart", showBandageStart.Checked);
        }

        private void ShowBandageEnd_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ShowBandageEnd", showBandageEnd.Checked);
        }

        private void BandageStartMessage_TextChanged(object sender, EventArgs e)
        {
            if (string.IsNullOrEmpty(bandageStartMessage.Text))
            {
                Config.SetProperty("BandageStartMessage", "Bandage: Starting");
                bandageStartMessage.SafeAction(s => s.Text = "Bandage: Starting");
            }

            Config.SetProperty("BandageStartMessage", bandageStartMessage.Text);
        }

        private void BandageEndMessage_TextChanged(object sender, EventArgs e)
        {
            if (string.IsNullOrEmpty(bandageEndMessage.Text))
            {
                Config.SetProperty("BandageEndMessage", "Bandage: Ending");
                bandageEndMessage.SafeAction(s => s.Text = "Bandage: Ending");
            }

            Config.SetProperty("BandageEndMessage", bandageEndMessage.Text);
        }

        private BuffDebuffOptions _buffDebuffOptions = null;

        private void buffDebuffOptions_Click(object sender, EventArgs e)
        {
            if (_buffDebuffOptions != null)
            {
                _buffDebuffOptions.SafeAction(s => s.Show());
            }
            else
            {
                _buffDebuffOptions = new BuffDebuffOptions();

                _buffDebuffOptions.SafeAction(s => s.Show());
            }
        }

        private void CaptureOthersDeathDelay_TextChanged(object sender, EventArgs e)
        {
            Config.SetProperty("CaptureOthersDeathDelay", Utility.ToDouble(captureOthersDeathDelay.Text.Trim(), 0.5));

            if (Config.GetDouble("CaptureOthersDeathDelay") < 0 || Config.GetDouble("CaptureOthersDeathDelay") > 5)
            {
                Config.SetProperty("CaptureOthersDeathDelay", 0.5);
                captureOthersDeathDelay.SafeAction(s => s.Text = "0.5");
            }
        }

        private void CaptureOthersDeath_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("CaptureOthersDeath", captureOthersDeath.Checked);
        }

        private void CaptureOwnDeath_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("CaptureOwnDeath", captureOwnDeath.Checked);
        }

        private void CaptureOwnDeathDelay_TextChanged(object sender, EventArgs e)
        {
            Config.SetProperty("CaptureOwnDeathDelay", Utility.ToDouble(captureOwnDeathDelay.Text.Trim(), 0.5));

            if (Config.GetDouble("CaptureOwnDeathDelay") < 0 || Config.GetDouble("CaptureOwnDeathDelay") > 5)
            {
                Config.SetProperty("CaptureOwnDeathDelay", 0.5);
                captureOwnDeathDelay.SafeAction(s => s.Text = "0.5");
            }
        }

        private void TargetFilterRemove_Click(object sender, EventArgs e)
        {
            if (targetFilter.SelectedIndex < 0)
                return;

            TargetFilterManager.RemoveTargetFilter(targetFilter.SelectedIndex);
        }

        private void TargetFilterClear_Click(object sender, EventArgs e)
        {
            TargetFilterManager.ClearTargetFilters();
        }

        private void TargetFilterEnabled_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("TargetFilterEnabled", targetFilterEnabled.Checked);
        }

        /*private void onAddAllMobilesTargetFilter(object sender, System.EventArgs e)
        {
            if (targetFilter.SelectedIndex < 0)
                return;

            if (World.Player == null)
                return;
            
            TargetFilterManager.AddAllMobileAsTargetFilters();
        }

        private void onAddAllMobilesHumanoidTargetFilter(object sender, System.EventArgs e)
        {
            if (targetFilter.SelectedIndex < 0)
                return;

            if (World.Player == null)
                return;

            TargetFilterManager.AddAllHumanoidsAsTargetFilters();
        }*/

        private void TargetFilterAdd_Click(object sender, EventArgs e)
        {
            if (World.Player == null)
                return;

            TargetFilterManager.OnTargetAddTargetFilter();
        }

        private void FriendAddTarget_Click(object sender, EventArgs e)
        {
            if (World.Player == null)
                return;

            if (friendsGroup.SelectedIndex < 0)
                return;

            ((FriendsManager.FriendGroup) friendsGroup.SelectedItem).AddFriendToGroup();
        }

        private TreeNode SearchTreeView(string p_sSearchTerm, TreeNodeCollection p_Nodes)
        {
            foreach (TreeNode node in p_Nodes)
            {
                if (node.Text.Contains(p_sSearchTerm))
                    return node;

                if (node.Nodes.Count > 0)
                {
                    TreeNode child = SearchTreeView(p_sSearchTerm, node.Nodes);
                    if (child != null) return child;
                }
            }

            return null;
        }

        private void SetMacroHotKey_Click(object sender, EventArgs e)
        {
            try
            {
                Engine.MainWindow.SafeAction(s =>
                {
                    Macro sel = GetMacroSel();

                    tabs.SelectedTab = hotkeysTab;

                    TreeNode resultNode = SearchTreeView(Language.Format(LocString.PlayA1, sel.GetName()), hotkeyTree.Nodes);

                    if (resultNode != null)
                    {
                        KeyData hk = (KeyData) resultNode.Tag;

                        hotkeyTree.SelectedNode = resultNode;
                        hkKey.Focus();
                    }
                });
            }
            catch
            {
                // ignore
            }
        }

        public void SaveMacroVariables()
        {
            MacroManager.DisplayMacroVariables(macroVariables);
        }

        public void SaveScriptVariables()
        {
            ScriptManager.RedrawScripts();
        }

        private void filterDaemonGraphics_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("FilterDaemonGraphics", filterDaemonGraphics.Checked);

            if (filterDaemonGraphics.Checked)
            {
                MobileFilter.ApplyToMobiles();
            }
        }

        private void daemonAnimationList_SelectedIndexChanged(object sender, EventArgs e)
        {
            try
            {
                if (daemonAnimationList.SelectedIndex < 0)
                    return;

                Config.SetProperty("DaemonGraphic", _animationData[daemonAnimationList.SelectedIndex].BodyId);

                MobileFilter.Load();
            }
            catch
            {
                MessageBox.Show(this, "Unable to find animation in file", "Animation Error", MessageBoxButtons.OK,
                    MessageBoxIcon.Error);
            }
        }

        private void soundFilterEnabled_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("SoundFilterEnabled", soundFilterEnabled.Checked);
        }

        private void soundFilterList_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (soundFilterList.SelectedIndex < 0)
                return;

            SoundMusicManager.Sound sound = (SoundMusicManager.Sound) soundFilterList.SelectedItem;

            if (soundFilterList.GetItemChecked(soundFilterList.SelectedIndex))
            {
                SoundMusicManager.AddSoundFilter(sound);
            }
            else
            {
                SoundMusicManager.RemoveSoundFilter(sound);
            }
        }

        private System.Media.SoundPlayer sp = new System.Media.SoundPlayer();

        private void playSound_Click(object sender, EventArgs e)
        {
            sp.Stop();

            if (soundFilterList.SelectedIndex < 0)
                return;

            SoundMusicManager.Sound sound = (SoundMusicManager.Sound) soundFilterList.SelectedItem;

            if (playInClient.Checked && World.Player != null)
            {
                Client.Instance.SendToClient(new PlaySound(sound.Serial));
            }
            else
            {
                Ultima.UOSound s = Ultima.Sounds.GetSound(sound.Serial);
                using (MemoryStream m = new MemoryStream(s.buffer))
                {
                    sp.Stream = m;
                    sp.Play();
                }
            }
        }

        private void showFilteredSound_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ShowFilteredSound", showFilteredSound.Checked);
        }

        private void showPlayingSoundInfo_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ShowPlayingSoundInfo", showPlayingSoundInfo.Checked);
        }

        private void playMusic_Click(object sender, EventArgs e)
        {
            if (playableMusicList.SelectedIndex < 0 || World.Player == null)
                return;

            Client.Instance.SendToClient(new PlayMusic(Convert.ToUInt16(playableMusicList.SelectedIndex)));
        }

        private void showPlayingMusic_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ShowMusicInfo", showPlayingMusic.Checked);
        }

        private void playScript_Click(object sender, EventArgs e)
        {
            if (ScriptManager.Running)
            {
                ScriptManager.StopScript();
                return;
            }

            if (string.IsNullOrEmpty(scriptEditor.Text))
            {
                return;
            }

            if (Config.GetBool("AutoSaveScriptPlay"))
            {
                SaveScript();
            }
            
            RazorScript selScript = GetScriptSel();
            
            // We want to play the contents of the script editor

            ScriptManager.PlayScriptFromUI(scriptEditor.Lines.ToArray(), selScript != null ? selScript.ToString() : "N/A", Config.GetBool("EnableHighlight"));
        }

        public void LockScriptUI(bool enabled)
        {
            Engine.MainWindow.SafeAction(s =>
            {
                scriptEditor.Enabled = !enabled;
                recordScript.Enabled = !enabled;
                setScriptHotkey.Enabled = !enabled;
                scriptTree.Enabled = !enabled;

                saveScript.Enabled = !enabled;
                newScript.Enabled = !enabled;

                playScript.Text = !enabled ? "Play" : "Stop";

                recMacro.Enabled = !enabled;
                playMacro.Enabled = !enabled;
                macroTree.Enabled = actionList.Enabled = !enabled;
                newMacro.Enabled = delMacro.Enabled = !enabled;
                nextMacroAction.Enabled = !enabled;
            });
        }

        private void scriptEditor_LostFocus(object sender, EventArgs e)
        {
            if (Config.GetBool("AutoSaveScript"))
            {
                SaveScript();
            }
        }

        private bool _savedCurrentScript = true;

        private void scriptEditor_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyData == (Keys.Control | Keys.S))
            {
                BeginInvoke(new Action(SaveScript));
            }
            
            if (_savedCurrentScript)
            {
                UpdateScriptWindowTitle(false);
                _savedCurrentScript = false;
            }
        }

        private void SaveScript()
        {
            if (_selectedScript == null)
            {
                string filePath = $"{Path.Combine(ScriptManager.ScriptPath, $"auto-{Guid.NewGuid().ToString().Substring(0, 4)}.razor")}";

                File.WriteAllText(filePath, scriptEditor.Text);

                RazorScript script = new RazorScript
                {
                    Lines = File.ReadAllLines(filePath),
                    Name = Path.GetFileNameWithoutExtension(filePath),
                    Path = filePath
                };
                
                TreeNode node = ScriptManager.GetScriptDirNode();

                ScriptManager.RedrawScripts();

                TreeNode newNode = new TreeNode(script.Name)
                {
                    Tag = script
                };

                if (node == null)
                {
                    scriptTree.Nodes.Add(newNode);
                }
                else
                {
                    node.Nodes.Add(newNode);
                }

                scriptTree.SelectedNode = newNode;
            }
            else
            {
                File.WriteAllText(_selectedScript.Path, scriptEditor.Text);
                _selectedScript.Lines = File.ReadAllLines(_selectedScript.Path);
            }

            UpdateScriptWindowTitle(true);
        }

        private void recordScript_Click(object sender, EventArgs e)
        {
            if (World.Player == null)
                return;

            if (ScriptManager.Recording) // stop recording
            {
                recordScript.Text = "Record";
                ScriptManager.Recording = false;
                scriptEditor.Enabled = true;
                playScript.Enabled = true;
            }
            else //start recording
            {
                recordScript.Text = "Stop";
                ScriptManager.Recording = true;
                scriptEditor.Enabled = false;
                playScript.Enabled = false;
            }
        }

        private void newScript_Click(object sender, EventArgs e)
        {
            if (InputBox.Show(this, "New Razor Script", "Enter the name of the script"))
            {
                string name = InputBox.GetString();
                if (string.IsNullOrEmpty(name) || name.IndexOfAny(Path.GetInvalidPathChars()) != -1 ||
                    name.IndexOfAny(m_InvalidNameChars) != -1)
                {
                    MessageBox.Show(this, Language.GetString(LocString.InvalidChars),
                        Language.GetString(LocString.Invalid), MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                TreeNode node = ScriptManager.GetScriptDirNode();

                string path = (node == null || !(node.Tag is string))
                    ? Config.GetUserDirectory("Scripts")
                    : (string)node.Tag;
                path = Path.Combine(path, $"{name}.razor");

                if (File.Exists(path))
                {
                    MessageBox.Show(this, Language.GetString(LocString.MacroExists),
                        Language.GetString(LocString.Invalid), MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                File.CreateText(path).Close();

                RazorScript script = ScriptManager.AddScript(path);

                TreeNode newNode = new TreeNode(script.Name)
                {
                    Tag = script
                };

                if (node == null)
                {
                    scriptTree.Nodes.Add(newNode);
                }
                else
                {
                    node.Nodes.Add(newNode);
                }

                scriptTree.SelectedNode = newNode;
            }
        }

        private void saveScript_Click(object sender, EventArgs e)
        {
            SaveScript();
        }

        private void setScriptHotkey_Click(object sender, EventArgs e)
        {
            try
            {
                Engine.MainWindow.SafeAction(s =>
                {
                    RazorScript script = GetScriptSel();

                    tabs.SelectedTab = hotkeysTab;

                    TreeNode resultNode = SearchTreeView($"{Language.Format(LocString.PlayScript, script)}",
                        hotkeyTree.Nodes);

                    if (resultNode != null)
                    {
                        KeyData hk = (KeyData) resultNode.Tag;

                        hotkeyTree.SelectedNode = resultNode;
                        hkKey.Focus();
                    }
                });
            }
            catch
            {
                // ignore
            }
        }

        private void addScriptVariable_Click(object sender, EventArgs e)
        {
            if (ScriptManager.Running || ScriptManager.Recording || World.Player == null)
                return;

            Targeting.OneTimeTarget((ground, serial, pt, gfx) =>
            {
                if (InputBox.Show(this, Language.GetString(LocString.NewScriptVariable),
                        Language.GetString(LocString.EnterAName)))
                {
                    string name = InputBox.GetString();

                    if (ScriptVariables.GetVariable(name) != Serial.MinusOne)
                    {
                        MessageBox.Show(this, "Pick a unique script variable name and try again",
                            "New Script Variable", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        return;
                    }

                    ScriptVariables.RegisterVariable(name, serial);
                    ScriptManager.RedrawScripts();
                }

                Engine.MainWindow.ShowMe();
            });

            World.Player.SendMessage(MsgLevel.Force, LocString.SelTargAct);
        }
        private void changeScriptVariable_Click(object sender, EventArgs e)
        {
            if (ScriptManager.Running || ScriptManager.Recording || World.Player == null)
                return;

            if (scriptVariables.SelectedIndex < 0)
                return;

            var name = scriptVariables.SelectedItem.ToString();
            name = name.Split('(')[0].Trim();

            Targeting.OneTimeTarget((ground, serial, pt, gfx) =>
            {
                ScriptVariables.RegisterVariable(name, serial);
                ScriptManager.RedrawScripts();
                Engine.MainWindow.ShowMe();
            });

            World.Player.SendMessage(MsgLevel.Force, LocString.SelTargAct);
        }

        private void removeScriptVariable_Click(object sender, EventArgs e)
        {
            if (ScriptManager.Running || ScriptManager.Recording || World.Player == null)
                return;

            if (scriptVariables.SelectedIndex < 0)
                return;

            string name = scriptVariables.SelectedItem.ToString();
            name = name.Split('(')[0].Trim();

            ScriptVariables.UnregisterVariable(name);
            ScriptManager.RedrawScripts();
        }

        private void autoSaveScript_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("AutoSaveScript", autoSaveScript.Checked);
        }

        private void CopyScriptToClipboard(object sender, EventArgs e)
        {
            RazorScript script = GetScriptSel();
            if (script == null)
                return;

            try
            {
                Clipboard.SetText(string.Join(Environment.NewLine, script.Lines));
            }
            catch
            {
                MessageBox.Show(this, Language.GetString(LocString.ReadError), "Copy Error", MessageBoxButtons.OK,
                    MessageBoxIcon.Error);
            }
        }

        private void ReloadScripts(object sender, EventArgs e)
        {
            RedrawScripts();
        }

        private void OpenScriptExternally(object sender, EventArgs args)
        {
            RazorScript script = GetScriptSel();
            if (script == null)
                return;

            try
            {
                Process.Start(script.Path);
            }
            catch (Exception)
            {
                MessageBox.Show(this, "Unable to open script",
                    Language.GetString(LocString.ReadError),
                    MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        private void scriptEditor_MouseDown(object sender, System.Windows.Forms.MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Right && e.Clicks == 1)
            {
                ContextMenuStrip menu = new ContextMenuStrip();

                menu.Items.Add("Cut", null, OnScriptCut);
                menu.Items.Add("Copy", null, OnScriptCopy);
                menu.Items.Add("Paste", null, OnScriptPaste);
                menu.Items.Add("Delete", null, OnScriptDelete);
                menu.Items.Add("-");
                menu.Items.Add("Select All", null, OnScriptSelectAll);
                menu.Items.Add("-");

                menu.Items[0].Enabled = false;
                menu.Items[1].Enabled = false;
                menu.Items[3].Enabled = false;

                if (!string.IsNullOrEmpty(scriptEditor.SelectedText))
                {
                    menu.Items[0].Enabled = true;
                    menu.Items[1].Enabled = true;
                    menu.Items[3].Enabled = true;

                    menu.Items.Add("Comment", null, OnScriptComment);
                    menu.Items.Add("Uncomment", null, OnScriptUncomment);

                    if (!string.IsNullOrEmpty(scriptEditor.SelectedText) && !ScriptManager.Running && !ScriptManager.Recording && World.Player != null)
                    {
                        menu.Items.Add("-");
                        menu.Items.Add("Play selected script code", null, OnScriptPlaySelected);

                        int space = scriptEditor.SelectedText.IndexOf(" ", StringComparison.Ordinal);

                        if (space > -1)
                        {
                            string command = scriptEditor.SelectedText.Substring(0, space);

                            if (command.Equals("dclick"))
                            {
                                menu.Items.Add("-");
                                menu.Items.Add("Convert to 'dclicktype' by gfxid", null, OnScriptDclickTypeId);
                                menu.Items.Add("Convert to 'dclicktype' by name", null, OnScriptDclickTypeName);
                            }
                        }
                    }

                    menu.Items.Add("-");
                }

                menu.Items.Add(scriptSplitContainer.Panel1Collapsed ? "Show script tree" : "Hide script tree",
                    null,
                    OnScriptHideTreeView);


                menu.Show(scriptEditor, new Point(e.X, e.Y));
            }
            else if (e.Button == MouseButtons.Left && e.Clicks == 2)
            {
                if (ScriptManager.Running || ScriptManager.Recording || World.Player == null)
                    return;
            }
        }

        private void OnScriptSelectAll(object sender, EventArgs e)
        {
            scriptEditor.SelectAll();
        }

        private void OnScriptDelete(object sender, EventArgs e)
        {
            if (!string.IsNullOrEmpty(scriptEditor.SelectedText))
            {
                scriptEditor.SelectedText = string.Empty;
            }
        }

        private void OnScriptPaste(object sender, EventArgs e)
        {
            scriptEditor.Paste();
        }

        private void OnScriptCopy(object sender, EventArgs e)
        {
            if (!string.IsNullOrEmpty(scriptEditor.SelectedText))
            {
                scriptEditor.Copy();
            }
        }

        private void OnScriptCut(object sender, EventArgs e)
        {
            if (!string.IsNullOrEmpty(scriptEditor.SelectedText))
            {
                scriptEditor.Cut();
            }
        }

        private void OnScriptHideTreeView(object sender, EventArgs e)
        {
            scriptSplitContainer.Panel1Collapsed = !scriptSplitContainer.Panel1Collapsed;
        }

        private void OnScriptComment(object sender, System.EventArgs e)
        {
            string[] lines = scriptEditor.SelectedText.Split(new[] {"\r\n", "\r", "\n"}, StringSplitOptions.None);

            scriptEditor.SelectedText = "";
            for (int i = 0; i < lines.Count(); i++)
            {
                scriptEditor.SelectedText += "#" + lines[i];
                if (i < lines.Count() - 1)
                    scriptEditor.SelectedText += "\r\n";
            }
        }

        private void OnScriptUncomment(object sender, System.EventArgs e)
        {
            string[] lines = scriptEditor.SelectedText.Split(new[] {"\r\n", "\r", "\n"}, StringSplitOptions.None);

            scriptEditor.SelectedText = "";
            for (int i = 0; i < lines.Count(); i++)
            {
                scriptEditor.SelectedText += lines[i].TrimStart('#');
                if (i < lines.Count() - 1)
                    scriptEditor.SelectedText += "\r\n";
            }
        }

        private void OnScriptDclickTypeId(object sender, System.EventArgs e)
        {
            Serial itemId = Serial.Zero;

            try
            {
                itemId = Serial.Parse(scriptEditor.SelectedText.Split(' ')[1]);
            }
            catch
            {
                return;
            }

            Item item = World.FindItem(itemId);

            if (item == null)
                return;

            scriptEditor.SelectedText = "";
            scriptEditor.SelectedText = $"dclicktype '{item.ItemID.Value}'";
        }

        private void OnScriptDclickTypeName(object sender, System.EventArgs e)
        {
            Serial gfxid = Serial.Zero;

            try
            {
                gfxid = Serial.Parse(scriptEditor.SelectedText.Split(' ')[1]);
            }
            catch
            {
                return;
            }


            Item item = World.FindItem(gfxid);

            if (item == null)
                return;

            scriptEditor.SelectedText = "";
            scriptEditor.SelectedText = $"dclicktype '{item.ItemID.ItemData.Name}'";
        }

        private void OnScriptPlaySelected(object sender, System.EventArgs e)
        {
            if (ScriptManager.Running)
            {
                ScriptManager.StopScript();
                return;
            }

            if (string.IsNullOrEmpty(scriptEditor.SelectedText))
                return;

            string[] lines = scriptEditor.SelectedText.Split(new[] {"\r\n", "\r", "\n"}, StringSplitOptions.None);

            
            RazorScript selScript = GetScriptSel();
            
            // We want to play the contents of the script editor
            ScriptManager.PlayScriptFromUI(lines, selScript != null ? selScript.ToString() : "N/A", Config.GetBool("EnableHighlight"));
        }

        private void autoSaveScriptPlay_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("AutoSaveScriptPlay", autoSaveScriptPlay.Checked);
        }
        
        private void highlightFriend_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("HighlightFriend", highlightFriend.Checked);
        }

        private void scriptFilter_TextChanged(object sender, EventArgs e)
        {
            scriptTree.SafeAction(s =>
            {
                s.BeginUpdate();
                s.Nodes.Clear();

                if (scriptFilter.Text != string.Empty)
                {
                    foreach (TreeNode _parentNode in _scriptTreeViewCache.Nodes) // We won't filter on the top parent domain
                    {
                        if (_parentNode.Text.ToLower().Contains(scriptFilter.Text.ToLower()))
                        {
                            s.Nodes.Add((TreeNode)_parentNode.Clone());
                        }

                        if (_parentNode.Nodes.Count > 0) // Just in case
                        {
                            foreach (TreeNode _subSubChildNode in _parentNode.Nodes)
                            {
                                if (_subSubChildNode.Text.ToLower().Contains(scriptFilter.Text.ToLower()))
                                {
                                    s.Nodes.Add((TreeNode)_subSubChildNode.Clone());
                                }
                            }
                        }
                    }
                }
                else
                {
                    RedrawScripts();
                }

                //enables redrawing tree after all objects have been added
                s.EndUpdate();
            });
        }
        
        private void disableScriptPlayFinish_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ScriptDisablePlayFinish", scriptDisablePlayFinish.Checked);
        }

        private void btnUseCurrentLoc_Click(object sender, EventArgs e)
        {
            if (World.Player != null)
            {
                txtWaypointX.SafeAction(s => s.Text = World.Player.Position.X.ToString());
                txtWaypointY.SafeAction(s => s.Text = World.Player.Position.Y.ToString());
            }
        }

        private void btnAddWaypoint_Click(object sender, EventArgs e)
        {
            WaypointManager.Waypoint waypoint = new WaypointManager.Waypoint();

            waypoint.Name = !string.IsNullOrEmpty(txtWaypointName.Text) ? txtWaypointName.Text.Replace("#", string.Empty) : "N/A";

            txtWaypointX.SafeAction(s =>
            {
                waypoint.X = Utility.ToInt32(s.Text.Trim(), 0);
            });

            txtWaypointY.SafeAction(s =>
            {
                waypoint.Y = Utility.ToInt32(s.Text.Trim(), 0);
            });

            if (waypoint.X != 0 && waypoint.Y != 0)
            {
                WaypointManager.AddWaypoint(waypoint);
            }
        }
        
        private void btnHideWaypoint_Click(object sender, EventArgs e)
        {
            if (World.Player != null)
                WaypointManager.ClearWaypoint();
        }

        private void btnRemoveSelectedWaypoint_Click(object sender, EventArgs e)
        {
            if (waypointList.SelectedIndex < 0)
                return;

            WaypointManager.RemoveWaypoint((WaypointManager.Waypoint) waypointList.SelectedItem);
        }

        private void showWaypointOverhead_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ShowWaypointOverhead", showWaypointOverhead.Checked);
        }

        private void showWaypointDistance_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ShowWaypointDistance", showWaypointDistance.Checked);

            if (showWaypointDistance.Checked)
            {
                WaypointManager.StartTimer();
            }
            else
            {
                WaypointManager.StopTimer();
            }
        }

        private void txtWaypointDistanceSec_TextChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ShowWaypointSeconds", Utility.ToInt32(txtWaypointDistanceSec.Text, 10));

            WaypointManager.ResetTimer();
        }

        private void hideWaypointDist_TextChanged(object sender, EventArgs e)
        {
            Config.SetProperty("HideWaypointDistance", Utility.ToInt32(hideWaypointDist.Text, 4));
        }

        private void hideWaypointWithin_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ClearWaypoint", hideWaypointWithin.Checked);
        }

        private void listWaypoints_MouseDoubleClick(object sender, MouseEventArgs e)
        {
            if (World.Player == null || waypointList.SelectedIndex < 0)
                return;

            WaypointManager.ShowWaypoint((WaypointManager.Waypoint)waypointList.SelectedItem);
        }

        private void waypointOnDeath_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("CreateWaypointOnDeath", waypointOnDeath.Checked);
        }

        private void scriptGuide_Click(object sender, EventArgs e)
        {
            Utility.LaunchBrowser("https://www.razorce.com/guide/");
        }
        private void listWaypoints_MouseDown(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Right && e.Clicks == 1)
            {
                ContextMenuStrip menu = new ContextMenuStrip();
                menu.Items.Add("Import Waypoints", null, onImportWaypoints);
                menu.Items.Add("Export Waypoints", null, onExportWaypoints);
                menu.Items.Add("-");
                menu.Items.Add("Clear All Waypoints", null, onClearWaypoints);

                menu.Show(waypointList, new Point(e.X, e.Y));
            }
        }

        private void onClearWaypoints(object sender, EventArgs e)
        {
            if (MessageBox.Show(this, "Are you sure you want to clear all of your waypoints?", "Clear Waypoints?",
                MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
            {
                WaypointManager.ClearAll();
                WaypointManager.RedrawList();
            }
        }

        private void onExportWaypoints(object sender, EventArgs e)
        {
            StringBuilder sb = new StringBuilder();

            sb.AppendLine("!Razor.Waypoints.Import");

            foreach (WaypointManager.Waypoint waypoint in WaypointManager.Waypoints)
            {
                sb.AppendLine($"{waypoint.Name}#{waypoint.X}#{waypoint.Y}");
            }

            Clipboard.SetDataObject(sb.ToString(), true);
        }

        private void onImportWaypoints(object sender, EventArgs e)
        {
            try
            {
                if (Clipboard.GetText().Contains("!Razor.Waypoints.Import"))
                {
                    List<string> waypointImport = Clipboard.GetText()
                        .Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.None).ToList();

                    waypointImport.RemoveAt(0);

                    foreach (string import in waypointImport)
                    {
                        if (string.IsNullOrEmpty(import))
                            continue;

                        string[] waypoint = import.Split('#');

                        WaypointManager.AddWaypoint(new WaypointManager.Waypoint
                        {
                            Name = waypoint[0],
                            X = Convert.ToInt32(waypoint[1]),
                            Y = Convert.ToInt32(waypoint[2])
                        });
                    }

                    Clipboard.Clear();
                }
            }
            catch
            {
            }
        }

        private void showPartyFriendOverhead_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ShowPartyFriendOverhead", showPartyFriendOverhead.Checked);
        }

        private void filterTabs_IndexChanged(object sender, EventArgs e)
        {
            if (filterTabs.SelectedTab == subFilterTargets)
            {
                TargetFilterManager.RedrawList();
            }
            else if (filterTabs.SelectedTab == subFilterText)
            {
                TextFilterManager.RedrawList();
            }
            else if (filterTabs.SelectedTab == subFilterSoundMusic)
            {
                SoundMusicManager.RedrawList();
            }
        }

        private void cliLocSearch_Click(object sender, EventArgs e)
        {
            cliLocSearchView.SafeAction(s => s.Items.Clear());

            if (string.IsNullOrEmpty(cliLocTextSearch.Text) || cliLocTextSearch.Text.Length < 4)
                return;

            foreach (StringEntry entry in Language.CliLoc.Entries)
            {
                if (entry.Text.IndexOf(cliLocTextSearch.Text, StringComparison.OrdinalIgnoreCase) >= 0)
                {
                    ListViewItem item = new ListViewItem($"{entry.Number}");
                    item.SubItems.Add(new ListViewItem.ListViewSubItem(item, $"{entry.Text}"));

                    cliLocSearchView.SafeAction(s => s.Items.Add(item));
                }
            }

            if (cliLocSearchView.Items.Count == 0)
            {
                if (MessageBox.Show(this,
                    $"Unable to find that message. Would you still like to setup an overhead message with '{cliLocTextSearch.Text}' anyway?",
                    "Overhead Messages",
                    MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
                {
                    setOverheadMessage.PerformClick();
                }
            }
        }

        private void setOverheadMessage_Click(object sender, EventArgs e)
        {
            int hueIdx = Config.GetInt("SysColor");
            string newItemText;

            if (string.IsNullOrEmpty(cliLocTextSearch.Text))
                return;

            if (cliLocSearchView.SelectedItems.Count > 0)
            {
                ListViewItem selectedItem = cliLocSearchView.SelectedItems[0];
                newItemText = selectedItem.SubItems[1].Text;
            }
            else
            {
                newItemText = cliLocTextSearch.Text;
            }

            ListViewItem item = new ListViewItem(newItemText);

            if (InputBox.Show(this, "Enter text to display overhead", newItemText))
            {
                string overheadMessage = InputBox.GetString();

                item.SubItems.Add(new ListViewItem.ListViewSubItem(item, overheadMessage));
                item.SubItems.Add(new ListViewItem.ListViewSubItem(item, "None"));

                item.SubItems[1].BackColor = hueIdx > 0 && hueIdx < 3000
                    ? Hues.GetHue(hueIdx - 1).GetColor(HueEntry.TextHueIDX)
                    : SystemColors.Control;

                item.SubItems[1].ForeColor = (item.SubItems[1].BackColor.GetBrightness() < 0.35 ? Color.White : Color.Black);
                item.UseItemStyleForSubItems = false;

                cliLocOverheadView.SafeAction(s => s.Items.Add(item));

                OverheadManager.OverheadMessages.Add(new OverheadMessage
                {
                    SearchMessage = newItemText,
                    Hue = hueIdx,
                    MessageOverhead = overheadMessage,
                    Sound = 0
                });
            }
        }

        private void editOverheadMessage_Click(object sender, EventArgs e)
        {
            if (cliLocOverheadView.SelectedItems.Count == 0)
                return;

            ListViewItem selectedItem = cliLocOverheadView.SelectedItems[0];
            string oldMessage = selectedItem.SubItems[1].Text;

            //ListViewItem item = new ListViewItem(newItemText);

            if (InputBox.Show(this, "Enter Overhead Text", "Enter text to display overhead", oldMessage))
            {
                string newMessage = InputBox.GetString();

                if (string.IsNullOrEmpty(newMessage))
                    return;

                selectedItem.SubItems[1].Text = newMessage;

                foreach (OverheadMessage list in OverheadManager.OverheadMessages)
                {
                    if (list.MessageOverhead.Equals(oldMessage))
                    {
                        list.MessageOverhead = newMessage;
                        break;
                    }
                }
            }
        }

        private void removeOverheadMessage_Click(object sender, EventArgs e)
        {
            if (cliLocOverheadView.SelectedItems.Count > 0)
            {
                cliLocOverheadView.SafeAction(s =>
                {
                    OverheadManager.Remove(s.SelectedItems[0].Text);
                    s.Items.Remove(s.SelectedItems[0]);
                });
            }
        }

        private void setColorHue_Click(object sender, EventArgs e)
        {
            if (cliLocOverheadView.SelectedItems.Count > 0)
            {
                OverheadManager.SetOverheadHue();
            }
        }

        private void unicodeStyle_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("OverheadStyle", unicodeStyle.Checked ? 1 : 0);
        }

        private void asciiStyle_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("OverheadStyle", asciiStyle.Checked ? 0 : 1);
        }

        private void overheadFormat_TextChanged(object sender, EventArgs e)
        {
            Config.SetProperty("OverheadFormat", overheadFormat.Text);

            if (string.IsNullOrEmpty(overheadFormat.Text))
            {
                Config.SetProperty("OverheadFormat", "{msg}");
                overheadFormat.Text = "{msg}";
            }

            Config.SetProperty("OverheadFormat", overheadFormat.Text);
        }

        private void showOverheadMessages_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ShowOverheadMessages", showOverheadMessages.Checked);
        }

        private void displayCountersTabCtrl_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (displayCountersTabCtrl.SelectedTab == subOverheadTab)
            {
                OverheadManager.RedrawList();
            }

            if (displayCountersTabCtrl.SelectedTab == subWaypoints)
            {
                WaypointManager.RedrawList();
            }
        }

        private void overrideSpellFormat_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("OverrideSpellFormat", overrideSpellFormat.Checked);            
        }

        private void reequipHandsPotion_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("PotionReequip", reequipHandsPotion.Checked);
        }

        private void agentSetHotKey_Click(object sender, EventArgs e)
        {
            if (agentList.SelectedIndex < 0)
                return;

            try
            {
                Engine.MainWindow.SafeAction(s =>
                {
                    Agent agent = (Agent) agentList.SelectedItem;

                    tabs.SelectedTab = hotkeysTab;

                    string search = string.Empty;

                    switch (agent)
                    {
                        case OrganizerAgent _:
                            search = $"{Language.GetString(LocString.OrganizerAgent)}-{agent.Number:D2}";
                            break;
                        case RestockAgent _:
                            search = $"{Language.GetString(LocString.RestockAgent)}-{agent.Number:D2}";
                            break;
                        case UseOnceAgent _:
                            search = agent.Name;
                            break;
                        case ScavengerAgent _:
                            search = Language.GetString(LocString.ScavengerEnableDisable);
                            break;
                        case SellAgent _:
                            search = Language.GetString(LocString.SetSellAgentHotBag);
                            break;
                    }

                    TreeNode resultNode = SearchTreeView(search, hotkeyTree.Nodes);

                    if (resultNode != null)
                    {
                        hotkeyTree.SelectedNode = resultNode;
                        hkKey.Focus();
                    }
                });
            }
            catch
            {
                // ignore
            }
        }
        private void addFilterText_Click(object sender, EventArgs e)
        {
            if (InputBox.Show(this, "Enter text to filter", "Text Filter"))
            {
                string message = InputBox.GetString();
                TextFilterManager.AddFilter(message);
            }
        }

        private void removeFilterText_Click(object sender, EventArgs e)
        {
            if (textFilterList.SelectedIndex < 0)
                return;

            TextFilterManager.RemoveFilter((string) textFilterList.SelectedItem);
        }

        private void enableTextFilter_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("EnableTextFilter", enableTextFilter.Checked);
        }

        private void disableScriptTooltips_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("DisableScriptTooltips", disableScriptTooltips.Checked);

            ScriptManager.InitScriptEditor();
        }

        private RazorScript _selectedScript;

        private void scriptTree_AfterSelect(object sender, TreeViewEventArgs e)
        {
            if (e.Node.Tag is string)
            {
                return;
            }

            _selectedScript = e.Node.Tag as RazorScript;

            if (_selectedScript == null)
                return;

            Engine.MainWindow.SafeAction(s =>
            {
                UpdateScriptWindowTitle(true);

                if (hotkeyTree.TopNode == null)
                {
                    HotKey.RebuildList(hotkeyTree);
                    RebuildHotKeyCache();
                }
                
                TreeNode resultNode = SearchTreeView($"{Language.Format(LocString.PlayScript, _selectedScript.ToString())}", hotkeyTree.Nodes);

                if (resultNode != null)
                {
                    KeyData hk = (KeyData)resultNode.Tag;

                    if (hk != null && !string.IsNullOrEmpty(hk.KeyString()))
                    {
                        scriptHotkey.Text = hk.KeyString();
                    }
                    else
                    {
                        scriptHotkey.Text = "Not Set";
                    }
                }
                
                ScriptManager.SetEditorText(_selectedScript);

                ScriptManager.ClearAllHighlightLines();
            });
        }

        private ContextMenuStrip m_ScriptContextMenu = null;

        private void scriptTree_MouseDown(object sender, MouseEventArgs e)
        {
            RazorScript selScript = GetScriptSel();

            if (e.Button == MouseButtons.Right && e.Clicks == 1)
            {
                m_ScriptContextMenu = new ContextMenuStrip();

                m_ScriptContextMenu.Items.Add("Add category", null, AddScriptCategory);

                if (scriptTree.SelectedNode != null && scriptTree.SelectedNode.Tag is string)
                {
                    m_ScriptContextMenu.Items.Add("Delete category", null, Script_DeleteCategory);
                }
                else if (selScript != null)
                {
                    m_ScriptContextMenu.Items.Add("Move to category", null, MoveScriptCategory);
                    m_ScriptContextMenu.Items.Add("-");
                    m_ScriptContextMenu.Items.Add($"Rename '{selScript.Name}'", null, RenameScript);
                    m_ScriptContextMenu.Items.Add($"Delete '{selScript.Name}'", null, DeleteScript);
                    m_ScriptContextMenu.Items.Add("-");
                    m_ScriptContextMenu.Items.Add($"Open '{selScript.Name}' externally", null, OpenScriptExternally);
                    m_ScriptContextMenu.Items.Add("Copy to clipboard", null, CopyScriptToClipboard);
                }
                
                m_ScriptContextMenu.Items.Add("-");
                m_ScriptContextMenu.Items.Add("Reload all scripts", null, ReloadScripts);
                m_ScriptContextMenu.Items.Add("Hide script tree", null, HideScriptTreeView);

                m_ScriptContextMenu.Show(scriptTree, new Point(e.X, e.Y));
            }
        }

        private void UpdateScriptWindowTitle(bool saved)
        {
            if (_selectedScript != null)
            {
                string append;

                if (World.Player != null)
                {
                    append = $"{World.Player.Name} ({World.ShardName})";
                }
                else
                {
                    append = $"Razor v{Engine.Version}";
                }

                Text = saved ? $"[{_selectedScript.Name}] - {append}" : $"[*{_selectedScript.Name}] - {append}";
                _savedCurrentScript = true;
            }
        }

        private void HideScriptTreeView(object sender, EventArgs e)
        {
            scriptSplitContainer.Panel1Collapsed = true;
        }

        private void DeleteScript(object sender, EventArgs e)
        {
            RazorScript selScript = GetScriptSel();

            if (selScript == null)
            {
                Script_DeleteCategory(sender, e);
                return;
            }

            if (MessageBox.Show(this, Language.Format(LocString.DelConf, $"{selScript.Name}"),
                "Confirm Delete", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
            {
                try
                {
                    File.Delete(selScript.Path);
                    ScriptManager.RemoveScript(selScript);
                }
                catch
                {
                    return;
                }

                RedrawScripts();

                TreeNode node = FindNode(scriptTree.Nodes, selScript);
                node?.Remove();
            }

            RebuildScriptCache();
        }

        private void RenameScript(object sender, EventArgs e)
        {
            RazorScript selScript = GetScriptSel();

            if (selScript == null)
                return;

            if (InputBox.Show(this, "Enter a new name for the script", "Rename Script", selScript.Name))
            {
                string name = InputBox.GetString();

                if (string.IsNullOrEmpty(name) || name.IndexOfAny(Path.GetInvalidPathChars()) != -1 ||
                    name.IndexOfAny(m_InvalidNameChars) != -1)
                {
                    MessageBox.Show(this, Language.GetString(LocString.InvalidChars),
                        Language.GetString(LocString.Invalid), MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                string newScriptPath = Path.Combine(Path.GetDirectoryName(selScript.Path), $"{name}.razor");

                if (File.Exists(newScriptPath))
                {
                    MessageBox.Show(this, "A script with that name already exists.",
                        Language.GetString(LocString.Invalid),
                        MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                try
                {
                    Engine.MainWindow.SafeAction(s =>
                    {
                        File.Move(selScript.Path, newScriptPath);
                        ScriptManager.RemoveScript(selScript);

                        RedrawScripts();
                    });
                }
                catch
                {
                    // ignore
                }
            }
        }

        private void MoveScriptCategory(object sender, EventArgs e)
        {
            RazorScript selScript = GetScriptSel();

            if (selScript == null)
                return;

            List<string> dirNames = new List<string>
            {
                "<None>"
            };

            foreach (string dir in Directory.GetDirectories(Config.GetUserDirectory("Scripts"), "*", SearchOption.AllDirectories))
            {
                dirNames.Add(dir.Replace(Config.GetUserDirectory("Scripts"), "").Substring(1));
            }

            if (!InputDropdown.Show(this, Language.GetString(LocString.CatName), dirNames.ToArray()))
                return;

            try
            {
                string newPath = string.Empty;

                if (InputDropdown.GetString().Equals("<None>"))
                {
                    newPath = Path.Combine(Config.GetUserDirectory("Scripts"), $"{Path.GetFileName(selScript.Path)}");
                }
                else
                {
                    newPath = Path.Combine(Config.GetUserDirectory("Scripts"), $"{InputDropdown.GetString()}/{Path.GetFileName(selScript.Path)}");
                }

                File.Move(selScript.Path, newPath);
            }
            catch
            {
                MessageBox.Show(this, Language.GetString(LocString.CantMoveMacro), "Unable to Move Script",
                    MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }

            RedrawScripts();

            scriptTree.SelectedNode = FindScriptNode(scriptTree.Nodes, selScript);
        }

        private void AddScriptCategory(object sender, EventArgs args)
        {
            if (!InputBox.Show(this, Language.GetString(LocString.CatName)))
                return;

            string path = InputBox.GetString();

            if (string.IsNullOrEmpty(path) || path.IndexOfAny(Path.GetInvalidPathChars()) != -1 ||
                path.IndexOfAny(m_InvalidNameChars) != -1)
            {
                MessageBox.Show(this, Language.GetString(LocString.InvalidChars), "Invalid Path", MessageBoxButtons.OK,
                    MessageBoxIcon.Error);
                return;
            }

            TreeNode node = ScriptManager.GetScriptDirNode();

            try
            {
                if (node == null || !(node.Tag is string))
                    path = Path.Combine(Config.GetUserDirectory("Scripts"), path);
                else
                    path = Path.Combine((string)node.Tag, path);

                Engine.EnsureDirectory(path);
            }
            catch
            {
                MessageBox.Show(this, Language.Format(LocString.CanCreateDir, path), "Unable to Create Directory",
                    MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }

            TreeNode newNode = new TreeNode($"[{Path.GetFileName(path)}]")
            {
                Tag = path
            };

            if (node == null)
                scriptTree.Nodes.Add(newNode);
            else
                node.Nodes.Add(newNode);

            RedrawScripts();

            scriptTree.SelectedNode = newNode;
        }

        private void openScreenshotFolder_Click(object sender, EventArgs e)
        {
            try
            {
                var psi = new ProcessStartInfo { FileName = Config.GetString("CapPath"), UseShellExecute = true };
                Process.Start(psi);
            }
            catch (Exception ex)
            {
                MessageBox.Show(this, ex.Message, "Unable to open directory", MessageBoxButtons.OK,
                    MessageBoxIcon.Warning);
            }
        }

        private void buyAgentIgnoreGold_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("BuyAgentsIgnoreGold", buyAgentIgnoreGold.Checked);
        }

        private ContextMenuStrip m_AgentsMenu = null;

        private void agentList_MouseDown(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Right)
            {
                Agent agent = (Agent)agentList.SelectedItem;

                if (agent != null && (agent is OrganizerAgent || agent is RestockAgent || agent is BuyAgent))
                {
                    m_AgentsMenu = new ContextMenuStrip();
                    m_AgentsMenu.Items.Add($"Set alias for '{agent.Name}'", null, OnAgentAlias);
                    m_AgentsMenu.Show(agentList, new Point(e.X, e.Y));
                }
            }
        }

        private void OnAgentAlias(object sender, EventArgs e)
        {
            Agent agent = (Agent)agentList.SelectedItem;

            if (InputBox.Show(this, $"Set '{agent}' Alias", "Enter an alias for this agent"))
            {
                string alias = InputBox.GetString();

                if (string.IsNullOrEmpty(alias) || alias.IndexOfAny(Path.GetInvalidPathChars()) != -1 || alias.IndexOfAny(m_InvalidNameChars) != -1)
                {
                    MessageBox.Show(this, Language.GetString(LocString.InvalidChars),
                        Language.GetString(LocString.Invalid), MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
                else
                {
                    agent.Alias = alias;

                    int sel = agentList.SelectedIndex;

                    Agent.Redraw(agentList, agentGroup, agentB1, agentB2, agentB3, agentB4, agentB5, agentB6);
                    if (sel >= 0 && sel < agentList.Items.Count)
                        agentList.SelectedIndex = sel;
                }

            }
        }

        private void nextPrevAbcOrder_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("NextPrevAlphabetical", nextPrevAbcOrder.Checked);
        }

        private void wyrmAnimationList_SelectedIndexChanged(object sender, EventArgs e)
        {
            try
            {
                if (wyrmAnimationList.SelectedIndex < 0)
                    return;

                Config.SetProperty("WyrmGraphic", _animationData[wyrmAnimationList.SelectedIndex].BodyId);

                MobileFilter.Load();
            }
            catch
            {
                MessageBox.Show(this, "Unable to find animation in file", "Animation Error", MessageBoxButtons.OK,
                    MessageBoxIcon.Error);
            }
        }

        private void filterWhiteWyrm_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("FilterWyrmGraphics", filterWhiteWyrm.Checked);

            if (filterWhiteWyrm.Checked)
            {
                MobileFilter.ApplyToMobiles();
            }
        }

        private void setSound_Click(object sender, EventArgs e)
        {
            if (cliLocOverheadView.SelectedItems.Count > 0)
            {
                OverheadManager.SetOverheadSound();
            }
        }

        private void fontIncrease_Click(object sender, EventArgs e)
        {
            foreach (Control c in Controls)
            {
                int size = (int)c.Font.Size;
                c.Font = new Font("Segoe UI", ++size);
                c.AutoSize = true;

                if (c is Button button)
                {
                    button.AutoSizeMode = AutoSizeMode.GrowAndShrink;
                }
            }
        }

        private void fontDecrease_Click(object sender, EventArgs e)
        {
            foreach (Control c in Controls)
            {
                int size = (int)c.Font.Size;
                c.Font = new Font("Segoe UI", --size);
                c.AutoSize = true;

                if (c is Button button)
                {
                    button.AutoSizeMode = AutoSizeMode.GrowAndShrink;
                }
            }
        }

        

        private void subAdvancedTab_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (itemTree.Nodes.Count == 0)
            {
                RedrawItems();
            }

            if (doorTree.Nodes.Count == 0)
            {
                StaffToolsManager.LoadDoors(doorTree);
            }
        }

        private void itemTree_AfterSelect(object sender, TreeViewEventArgs e)
        {
            if (e.Node.Tag != null)
            {
                artViewer.ArtIndex = (int)e.Node.Tag;
            }
        }

        private void itemAdd_Click(object sender, EventArgs e)
        {
            //string command = "[add static 7893 set movable False hue 0 light Circle225";
            ItemAddCommand(null, null);
        }

        private ContextMenuStrip _itemAddContextMenu = null;

        private void itemAdd_MouseDown(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Right && e.Clicks == 1)
            {
                if (_itemAddContextMenu == null)
                {
                    _itemAddContextMenu = new ContextMenuStrip();
                    _itemAddContextMenu.Items.Add("Single", null, ItemAddCommand);
                    _itemAddContextMenu.Items.Add("Self", null, ItemAddCommand);
                    _itemAddContextMenu.Items.Add("Multi", null, ItemAddCommand);
                    _itemAddContextMenu.Items.Add("Contained", null, ItemAddCommand);
                    _itemAddContextMenu.Items.Add("Area", null, ItemAddCommand);
                    _itemAddContextMenu.Items.Add("Region", null, ItemAddCommand);
                    _itemAddContextMenu.Items.Add("Online", null, ItemAddCommand);
                    _itemAddContextMenu.Items.Add("Global", null, ItemAddCommand);
                }

                _itemAddContextMenu.Show(itemAdd, new Point(e.X, e.Y));
            }
        }

        private void ItemAddCommand(object sender, EventArgs e)
        {
            
            if (itemTree.SelectedNode != null)
            {
                TreeNode selectedNode = itemTree.SelectedNode;

                if (selectedNode.Tag == null)
                {
                    return;
                }

                string command = itemRandomNumber.Value > 0
                    ? $"[add static {selectedNode.Tag} {itemRandomNumber.Value:F0} set movable {itemMovable.Checked}"
                    : $"[add static {selectedNode.Tag} set movable {itemMovable.Checked}";

                if (itemAppendM.Checked)
                {
                    command = $"[m {command.Substring(1)}";
                }

                if (sender == null)
                {
                    World.Player.SendMessage(MsgLevel.Info, $"Command: {command}");
                    World.Player.Say(command);
                }
                else
                {
                    ToolStripMenuItem item = sender as ToolStripMenuItem;

                    switch (item?.Text)
                    {
                        case "Single":
                            command = $"[single {command.Substring(1)}";
                            break;
                        case "Self":
                            command = $"[self {command.Substring(1)}";
                            break;
                        case "Multi":
                            command = $"[multi {command.Substring(1)}";
                            break;
                        case "Contained":
                            command = $"[contained {command.Substring(1)}";
                            break;
                        case "Area":
                            command = $"[area {command.Substring(1)}";
                            break;
                        case "Region":
                            command = $"[region {command.Substring(1)}";
                            break;
                        case "Online":
                            command = $"[online {command.Substring(1)}";
                            break;
                        case "Global":
                            command = $"[global {command.Substring(1)}";
                            break;
                    }

                    World.Player.SendMessage(MsgLevel.Info, $"Command: {command}");
                    World.Player.Say(command);
                }


                if (itemCopyToClipboard.Checked)
                {
                    Clipboard.SetDataObject(command, true);
                }
            }
        }
        
        private void itemTree_MouseDoubleClick(object sender, MouseEventArgs e)
        {
            if (World.Player == null)
            {
                return;
            }

            if (itemTree.SelectedNode != null)
            {
                ItemAddCommand(sender, e);
            }
        }

        private void itemTile_Click(object sender, EventArgs e)
        {
            //[TileZ 0 static 7894 set movable True hue 0 light {light}
            if (World.Player == null)
            {
                return;
            }

            if (itemTree.SelectedNode != null)
            {
                TreeNode selectedNode = itemTree.SelectedNode;
                string command = $"[tilez {itemTileCount.Value:F0} static {selectedNode.Tag} {itemRandomNumber.Value:F0} set movable {itemMovable.Checked.ToString()}";

                World.Player.SendMessage(MsgLevel.Info, $"Command: {command}");
                World.Player.Say(command);

                if (itemCopyToClipboard.Checked)
                {
                    Clipboard.SetDataObject(command, true);
                }
            }
        }

        private void doorTree_AfterSelect(object sender, TreeViewEventArgs e)
        {
            if (e.Node.Tag != null)
            {
                doorViewer.ArtIndex = ((DoorInfo)e.Node.Tag).BaseId;
            }
        }

        private void doorWestCW_Click(object sender, EventArgs e)
        {
            if ((DoorInfo) doorTree.SelectedNode?.Tag != null)
            {
                StaffToolsManager.AddDoor((DoorInfo)doorTree.SelectedNode.Tag, "WestCW");
            }
        }

        private void doorWestCCW_Click(object sender, EventArgs e)
        {
            if ((DoorInfo)doorTree.SelectedNode?.Tag != null)
            {
                StaffToolsManager.AddDoor((DoorInfo)doorTree.SelectedNode.Tag, "WestCCW");
            }
        }

        private void doorNorthCW_Click(object sender, EventArgs e)
        {
            if ((DoorInfo)doorTree.SelectedNode?.Tag != null)
            {
                StaffToolsManager.AddDoor((DoorInfo)doorTree.SelectedNode.Tag, "NorthCW");
            }
        }

        private void doorNorthCCW_Click(object sender, EventArgs e)
        {
            if ((DoorInfo)doorTree.SelectedNode?.Tag != null)
            {
                StaffToolsManager.AddDoor((DoorInfo)doorTree.SelectedNode.Tag, "NorthCCW");
            }
        }

        private void doorEastCCW_Click(object sender, EventArgs e)
        {
            if ((DoorInfo)doorTree.SelectedNode?.Tag != null)
            {
                StaffToolsManager.AddDoor((DoorInfo)doorTree.SelectedNode.Tag, "EastCCW");
            }
        }

        private void doorEastCW_Click(object sender, EventArgs e)
        {
            if ((DoorInfo)doorTree.SelectedNode?.Tag != null)
            {
                StaffToolsManager.AddDoor((DoorInfo)doorTree.SelectedNode.Tag, "EastCW");
            }
        }

        private void doorSouthCCW_Click(object sender, EventArgs e)
        {
            if ((DoorInfo)doorTree.SelectedNode?.Tag != null)
            {
                StaffToolsManager.AddDoor((DoorInfo)doorTree.SelectedNode.Tag, "SouthCCW");
            }
        }

        private void doorSouthCW_Click(object sender, EventArgs e)
        {
            if ((DoorInfo)doorTree.SelectedNode?.Tag != null)
            {
                StaffToolsManager.AddDoor((DoorInfo)doorTree.SelectedNode.Tag, "SouthCW");
            }
        }

        private void DoorFacingEnter(object sender, EventArgs e)
        {
            if ((DoorInfo)doorTree.SelectedNode?.Tag != null)
            {
                Button button = sender as Button;

                doorViewer.ArtIndex = ((DoorInfo)doorTree.SelectedNode.Tag).BaseId + StaffToolsManager.GetDoorOffset(button.Name);
            }
        }
        private void itemSearch_KeyDown(object sender, KeyEventArgs e)
        {
            if (sender is TextBox textBox)
            {
                if (e.KeyCode == Keys.Enter || e.KeyCode == Keys.Return)
                {
                    e.Handled = true;
                    e.SuppressKeyPress = true;
                    itemTree.Focus();
                }
            }
        }

        private void itemSearch_LostFocus(object sender, EventArgs e)
        {
            if (itemSearch.Text != string.Empty)
            {
                string search = itemSearch.Text.ToLower();

                itemTree.SafeAction(s =>
                {
                    s.BeginUpdate();
                    s.Nodes.Clear();

                    foreach (TreeNode node in _itemTreeCache.Nodes)
                    {
                        TreeNode[] nodes = FindNodeByString(search, node);

                        s.Nodes.AddRange(nodes);
                    }

                    s.EndUpdate();
                });
            }
            else
            {
                RedrawItems();
            }
        }

        private TreeNode[] FindNodeByString(string search, TreeNode parentNode)
        {
            List<TreeNode> filteredNodes = new List<TreeNode>();

            foreach (TreeNode currentNode in parentNode.Nodes)
            {
                if (currentNode.Text.Contains(search))
                {
                    filteredNodes.Add((TreeNode) currentNode.Clone());
                }

                if (currentNode.Nodes.Count > 0)
                {
                    TreeNode[] nodes = FindNodeByString(search, currentNode);

                    if (nodes.Length > 0)
                    {
                        filteredNodes.AddRange(nodes);
                    }
                }
            }

            return filteredNodes.ToArray();
        }

        private void playEmoteSound_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("PlayEmoteSound", playEmoteSound.Checked);
        }

        private void showBuffDebuffGump_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ShowBuffDebuffGump", showBuffDebuffGump.Checked);
        }

        private void showBuffIcons_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ShowBuffDebuffIcons", showBuffIcons.Checked);
        }

        private void buffBarSort_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (buffBarSort.SelectedIndex < 0)
                return;

            Config.SetProperty("ShowBuffDebuffSort", buffBarSort.SelectedIndex);
        }

        private void buffBarWidth_TextChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ShowBuffDebuffWidth", Utility.ToInt32(buffBarWidth.Text, 100));
        }

        private void buffBarHeight_TextChanged(object sender, EventArgs e)
        {
            Config.SetProperty("ShowBuffDebuffHeight", Utility.ToInt32(buffBarHeight.Text, 28));
        }

        private void useBlackBuffDebuffBg_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("UseBlackBuffDebuffBg", useBlackBuffDebuffBg.Checked);
        }

        private void showBuffDebuffTimeType_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (showBuffDebuffTimeType.SelectedIndex < 0)
                return;

            Config.SetProperty("ShowBuffDebuffTimeType", showBuffDebuffTimeType.SelectedIndex);
        }

        private void defaultScriptDelay_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("DefaultScriptDelay", defaultScriptDelay.Checked);
            
            ScriptManager.ResetTimer();
        }

        private void enableHighlight_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("EnableHighlight", enableHighlight.Checked);
        }

        private void disableScriptStopwatch_CheckedChanged(object sender, EventArgs e)
        {
            Config.SetProperty("DisableScriptStopwatch", disableScriptStopwatch.Checked);
        }

        private void cooldownHeight_TextChanged(object sender, EventArgs e)
        {
            int height = Utility.ToInt32(cooldownHeight.Text, 28);

            if (height < 1)
            {
                height = 28;
            }

            Config.SetProperty("CooldownHeight", height);
        }

        private void cooldownWidth_TextChanged(object sender, EventArgs e)
        {
            int width = Utility.ToInt32(cooldownWidth.Text, 110);

            if (width < 1)
            {
                width = 110;
            }

            Config.SetProperty("CooldownWidth", width);
        }
    }
}


================================================
FILE: Razor/UI/Razor.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <metadata name="m_NotifyIcon.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
    <value>17, 17</value>
  </metadata>
  <assembly alias="System.Drawing" name="System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
  <data name="m_NotifyIcon.Icon" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
    <value>
        AAABAAEAICAAAAAAAACoCAAAFgAAACgAAAAgAAAAQAAAAAEACAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAB
        AAAAAAAAAACAAACAAAAAgIAAgAAAAIAAgACAgAAAwMDAAMDcwADwyqYABAQEAAgICAAMDAwAERERABYW
        FgAcHBwAIiIiACkpKQBVVVUATU1NAEJCQgA5OTkAgHz/AFBQ/wCTANYA/+zMAMbW7wDW5+cAkKmtAAAA
        MwAAAGYAAACZAAAAzAAAMwAAADMzAAAzZgAAM5kAADPMAAAz/wAAZgAAAGYzAABmZgAAZpkAAGbMAABm
        /wAAmQAAAJkzAACZZgAAmZkAAJnMAACZ/wAAzAAAAMwzAADMZgAAzJkAAMzMAADM/wAA/2YAAP+ZAAD/
        zAAzAAAAMwAzADMAZgAzAJkAMwDMADMA/wAzMwAAMzMzADMzZgAzM5kAMzPMADMz/wAzZgAAM2YzADNm
        ZgAzZpkAM2bMADNm/wAzmQAAM5kzADOZZgAzmZkAM5nMADOZ/wAzzAAAM8wzADPMZgAzzJkAM8zMADPM
        /wAz/zMAM/9mADP/mQAz/8wAM///AGYAAABmADMAZgBmAGYAmQBmAMwAZgD/AGYzAABmMzMAZjNmAGYz
        mQBmM8wAZjP/AGZmAABmZjMAZmZmAGZmmQBmZswAZpkAAGaZMwBmmWYAZpmZAGaZzABmmf8AZswAAGbM
        MwBmzJkAZszMAGbM/wBm/wAAZv8zAGb/mQBm/8wAzAD/AP8AzACZmQAAmTOZAJkAmQCZAMwAmQAAAJkz
        MwCZAGYAmTPMAJkA/wCZZgAAmWYzAJkzZgCZZpkAmWbMAJkz/wCZmTMAmZlmAJmZmQCZmcwAmZn/AJnM
        AACZzDMAZsxmAJnMmQCZzMwAmcz/AJn/AACZ/zMAmcxmAJn/mQCZ/8wAmf//AMwAAACZADMAzABmAMwA
        mQDMAMwAmTMAAMwzMwDMM2YAzDOZAMwzzADMM/8AzGYAAMxmMwCZZmYAzGaZAMxmzACZZv8AzJkAAMyZ
        MwDMmWYAzJmZAMyZzADMmf8AzMwAAMzMMwDMzGYAzMyZAMzMzADMzP8AzP8AAMz/MwCZ/2YAzP+ZAMz/
        zADM//8AzAAzAP8AZgD/AJkAzDMAAP8zMwD/M2YA/zOZAP8zzAD/M/8A/2YAAP9mMwDMZmYA/2aZAP9m
        zADMZv8A/5kAAP+ZMwD/mWYA/5mZAP+ZzAD/mf8A/8wAAP/MMwD/zGYA/8yZAP/MzAD/zP8A//8zAMz/
        ZgD//5kA///MAGZm/wBm/2YAZv//AP9mZgD/Zv8A//9mACEApQBfX18Ad3d3AIaGhgCWlpYAy8vLALKy
        sgDX19cA3d3dAOPj4wDq6uoA8fHxAPj4+ADw+/8ApKCgAICAgAAAAP8AAP8AAAD//wD/AAAA/wD/AP//
        AAD///8ACgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoK
        CgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCrcKCgoKCgoKCgoKCgoK
        CgoKCgoKCgoKCgoKCgoKCgoK+QoKCgoKCgoKCgrSCgoKCgoKCgoKCgoKCgoKCgoKCgr5+QoKCgoKCgr5
        sQoKCgoKCgoKCgoKCgoKCgoKCgoKCvn5CgoKCgoKsbEKCgoKCgoKCgoKCgoKCgoKCgoKCgoK+ZQKCgoK
        CuPjCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgr5sQoKCgpHsQoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgpq
        Cgr5QbEKCgqxtwoKCgoKCgr5CgoK+QoKCgoKCgoKCuP5lPmUCgoKCrGxt7f5+fkKCvkK+fkKCgoKCgoK
        CgoKFkH5lAoK+QoK+bcKCgr5t7cK+fn5CgoKCgoKCgoKCrdB+fkKCgoK0rext7EKCvn5Crf5+QoKCgoK
        CgoKCgqx+UdBCgoKCgq3+fkKt5QK+fkK0vn5CgoKCgoKCgoKCgq3+UGUCgoKCvmxtwoKsbcK+QqUCvn5
        +QoKCgoKCgoKCgr5F0f5CgoKCmqxCgoKavn5+eP5arexagoKCgoKCgoKCgqU+Wrj+QoKt7cKRmlq+Qq3
        lJQXF+MWCgoKCgoKCgoKCvn5+flq4/kKCuvs7O0KCgoKCgoKCgoKCgoKCgoKCgoKCkfjCgoWRxaSku3s
        7OwKCgoKCgoKCgoKCgoKCgoKCgoK+fkKCgr5bpKS7e3t7eztCgoKCgoKCgoKCgoKCgoKCgr5+ZQKCgqS
        kpLt7e3t7e3tCgoKCgoKCgoKCgoKCgoKCgr54woK7++SkpLt7e3t7Ozs7fcKCgoKCgoKCgoKCrHjFkEX
        FhZpku/3kpLt7e3s7Ozs7JIKCgoKCgoKCgoKR/n5+fn5+fkg7e+SkpLt7Ozs7Ozs7ZIKCgoKCgoKCgpH
        QUFBQUcXahbt95KS7e3s7Ozs7Oztkvf3CgoKCgoKCgoKCgrs6+wKCpKS7e3t7Ozs7Ozt7ZL39+/vCgoK
        CgoKCgoKCuzr6uzs7ZLt7ezs7Ozs7ZKS9+/v7+/vCgoKCgoKCgrr7JLrbeyS7ezs7Ozs7ZKS9/fv7wcH
        BwcKCgoKCgoK7BLs7/fs7Ozs7Ozs7O2S9+/v7+8HBwcHBwoKCgoKCgoSbe8H7+zt7Ovs7O2Skvfv7+8H
        BwcHBwcHCgoKCgoK7ezv7++S7O3v9+zs9/fv7+8HBwcHBwcH8fAKCgoKCuwS6+ztkvfv7+8HB/f3B7y8
        vPDw8PDwvPP/8/////////////////f////3/v//8/n///Pz///z5///88////sc/u/4PAaf+GziP/Dw
        ZH/h8SR/8PGVH/h5wA/8GQgP/AYf//5gD//+cAP//jgB//8wAD/4AAAf+AAAD/gAAAP/jAAB/4AAAP8A
        AAD+AAAA/gAAAPwAAAD4AAAA
</value>
  </data>
  <data name="scriptEditor.ServiceColors" mimetype="application/x-microsoft.net.object.binary.base64">
    <value>
        AAEAAAD/////AQAAAAAAAAAMAgAAAFdGYXN0Q29sb3JlZFRleHRCb3gsIFZlcnNpb249Mi4xNi4yMy4w
        LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWZiOGFhMTJiOTk0ZWY2MWIMAwAAAFFTeXN0
        ZW0uRHJhd2luZywgVmVyc2lvbj00LjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2Vu
        PWIwM2Y1ZjdmMTFkNTBhM2EFAQAAACJGYXN0Q29sb3JlZFRleHRCb3hOUy5TZXJ2aWNlQ29sb3JzBgAA
        ACg8Q29sbGFwc2VNYXJrZXJGb3JlQ29sb3I+a19fQmFja2luZ0ZpZWxkKDxDb2xsYXBzZU1hcmtlckJh
        Y2tDb2xvcj5rX19CYWNraW5nRmllbGQqPENvbGxhcHNlTWFya2VyQm9yZGVyQ29sb3I+a19fQmFja2lu
        Z0ZpZWxkJjxFeHBhbmRNYXJrZXJGb3JlQ29sb3I+a19fQmFja2luZ0ZpZWxkJjxFeHBhbmRNYXJrZXJC
        YWNrQ29sb3I+a19fQmFja2luZ0ZpZWxkKDxFeHBhbmRNYXJrZXJCb3JkZXJDb2xvcj5rX19CYWNraW5n
        RmllbGQEBAQEBAQUU3lzdGVtLkRyYXdpbmcuQ29sb3IDAAAAFFN5c3RlbS5EcmF3aW5nLkNvbG9yAwAA
        ABRTeXN0ZW0uRHJhd2luZy5Db2xvcgMAAAAUU3lzdGVtLkRyYXdpbmcuQ29sb3IDAAAAFFN5c3RlbS5E
        cmF3aW5nLkNvbG9yAwAAABRTeXN0ZW0uRHJhd2luZy5Db2xvcgMAAAACAAAABfz///8UU3lzdGVtLkRy
        YXdpbmcuQ29sb3IEAAAABG5hbWUFdmFsdWUKa25vd25Db2xvcgVzdGF0ZQEAAAAJBwcDAAAACgAAAAAA
        AAAAlgABAAH7/////P///woAAAAAAAAAAKQAAQAB+v////z///8KAAAAAAAAAACWAAEAAfn////8////
        CgAAAAAAAAAAjQABAAH4/////P///woAAAAAAAAAAKQAAQAB9/////z///8KAAAAAAAAAACWAAEACw==
</value>
  </data>
  <data name="doorSouthCW.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
    <value>
        R0lGODlhPQA9AIcAAAAAAAgEBAgICBAQEBQQDBgQDBgUEBgYGBwYGBwcGCAcGCQcFCQcGCAgICQgGCQg
        HCggGCQkICgkICwkHCgoKDAoIDAoJCwsLDAsKDAwMDgwKDgwLEAwJDg0MEA0LDg4ODw4NEA4MEA4NEg4
        KDw8PEg8MEBAQERAOFBAMFBANEhEQFBEOFVENEhIREhISFlENFBIRFlINFlIPFBMSGFMOFBQUF1QQGFQ
        QFlVUGlVQFlZWWlVRG1VQGFZUGFdVXFZQGFhYXVdSGlhWXFhTGllYWllZXVlUGlpaYFlTHFxcYVtUHVx
        aXl1cY1xVX11bXl5eX19fZV5WZV5XYmBeZ19XYWFhY2JgaWFZY2Nja6NaZWVlbaRbZmZla6VfbaVcbqV
        bZ2dmZ2dnaqhmcaddaWlpcqhea6qqs6lfa6urrKysr6yqra2tt6yhdK2leKyhd62ib6+vuK6jcbGxuq+
        kd7Cne6+je7Cke7ClebGpc7OzvbGld7SxtbW1v/Omf/Ond7e3v/atuLi4ubm5urq6u7u7v/u4vb29v//
        /wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        ACH/C05FVFNDQVBFMi4wAwEBAAAh+QQAAAAAACwAAAAAPQA9AAAI/wAPCRxIsKDBgwgPysFRRFDChxAj
        Sjy0xsOVKBv+TNzIkSAWgmtW6OnTh82JQB1TRmSyw4rAkCNJAtojQqPKmwZnZLljBSbJPoAK+WEjwRDO
        owIJiTgTZ0LMPjKm+CGZQwtSpIQiEIjxo06dIQjK/EyB5urRkG76KAkQQMKbn15UmMXpk2QbH1NJeoFh
        dG7KukALvbiil6/fvyJ/BvWjh8OYvX0PbwS8mCQbCCoiS5ZIWShcECQ0b37YOW8fyGGAjI5YGq7hQ0es
        rkbYunBkQQ1Ez6aYWKZn2wWfVNkNsndg05ANGmrgkHjt068NYkni3Hhl4AiXNx/9PPnD6au7R/9PaGiA
        7qvizx90sUZy+o1ajhx+v/FPA7/0OVLgYzY/R+EqyUHIQP5xBIcJKbWggQgDFsiRfSktMccZIphh3W/Q
        qbcRACqJMQcVDjx1XYZXHbAdR04s8IViGHqHVAZ5IIYEDSThIQQKW2B3FXsd+YRCE4BY0EQWI1Dh4lVA
        hMFRXVFAoAYHP8XQgYYqQQHFRmQYV0IPdhTwlA1gHBbbRIYYUMdPRijw1hk0/nRDmHPVUJZEeVTwUxcD
        vEVSECz81Mebc30gx0YYnHGca1zc4CegVzVgk0R/hEBHi4aBoaibcB4lAJUG/YGDniQKZOmimapEyAAp
        RXqFHlKMd8iomOKUxAcFKnkaABHnwUoSoymBN5quf5a6EY+rAcsrmebtZqywEKFRA3GvXrorswklCW20
        pE7k6LXYxgqRHB9wK6q0wUIkp7jjZovQgegOtCxCMLbrLrnHCuSsvAS9S1C8+M6r7iFk6NBvQe/+kcGA
        A+dLrgdpfMBfwgRLe8UDc0Ic8Zk8uGAxQmAYwEACCG9s0CAXcGpQQAA7
</value>
  </data>
  <data name="doorSouthCCW.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
    <value>
        R0lGODlhPQA9AIcAAAAAAAgEBAgICAwMCBAQDBAQEBQQDBgQDBQUEBgUEBgYGBwYFCAYECAYFBwcHCAc
        GCQcFCAgICggGCgkICwkIDAkHCgoKCwsKDAsKDgsIDAwMDgwJDgwKDwwJEQ0KDg4ODw4NEA4MEA4NEQ8
        NEBAQERAPFBAMFVAMEhEQFBEOEhISFlENFBIQFVIOFBIRFlIOFBMSF1MOGFMOFBQUGFMPGFQQFlZWW1Z
        QF1dWW1ZRGFdWWFhYWlhWXlhSGlpaX1lTHlpVXFtbX1tWXFxcYVtUHVxcYFxXYVxXY11VXl5eZF1WX19
        fZV5XZl9XYWBgZ19XYWFhY2FfYmJiY2JgaWFZY2NjZWNgZGRkZmRia6NaZWVlbaRbbaVcZ2dmZ2dnbad
        gaqhmcKddcaddaWlpbKlncqhea6qqs6lfcKqia6urtKqgdaugba2ttqugd6yhca6rt62ib6+vua6icLC
        wsbGxuq+kd7Cne6+je7Clc7OzvbGlfbKldLS0uLSxtbW1v/Omf/Ond7e3v/atuLi4ubm5vbm2urq6u7u
        7v/u4vb29v///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        ACH/C05FVFNDQVBFMi4wAwEBAAAh+QQAAAAAACwAAAAAPQA9AAAI/wAVCRxIsKDBgwgTKlzIsKHDhxAj
        SpxIsaLFixgzatzIsWPEPHHoeKwYZ8kMEhoAANBA4oNKCyRULEkzMiEhLzYKkJgZJ89BP3HYmBQwQ0ug
        mooSafmgYMeYQxETpfERQQMUqAsTiXToxYKPrRfzJLFQJVFCNgk4TDiqMI2FHWw3EhpiwctBNinu/FkT
        Im7BOB9m+EEaaIcFmgPx6vnD2I4OvwKhkACLVJGfGT4EKmb8RxAiOH0HJrKRpPJBLSTMpFjMGA0iQH+y
        wBA4x8EV0wilDCjDGQiBPYz1BFDkxECOB11wF8TbJkOWP0cewOGMJIgXBGcY10iuXNFmPSaMJP9gwpmL
        i0RxLmTXzt30ZsaCyBwQw9i8WUVjXnD+s939as6eAUKEDH/YR1AXNezXX03vdfYaYz10cJ5BCCrYHkcN
        BsiZB0pEgVCFnC24UYYP1sfBFnhM8WGCIV54EYmw1eeCISKcoQYOK1qYEYzlTXgIBg/wkRCI7L34H3wl
        FjjhQ0Ty5yJEPMp4H0RNigjlkQ7GqOSUEVX55EJRbmmRlw+FaeBFZDJk5pIYpXkWlhpKyZGbBq3JpUZ0
        JgZnkmd6lKedlbkJqGlkDopblUXsqWWfyjV5QhMA8slmd4o0uQIVWfZ4J6Vd6MeYGwzEKSaly20QA2Ny
        NFDIopOS6t1qT0iJ8EMFVrC6KaXvrSHEG7a6SlCDX/CAqZy+ChQHB6z9IQQAK0gggx43oHArpTA8x1gL
        C0z3hxIQ0AACVsUqEgQS8GERRnkj1HGGCOD6eggLbohqHxh1/LBEuAIFUkIfvSqCBQWQ+RpICG4QK9Ag
        +BIUyAQ0vCBtwgol4sUYEFds8cUYZ6zxxhwTFBAAOw==
</value>
  </data>
  <data name="doorEastCW.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
    <value>
        R0lGODlhPQA9AIcAAAAAAAgEBAgICBAMCBAQEBQQEBgQDBgUEBgYGCAYFCAcGCAgICggGCggHCgkICwk
        HCgoKCwoJDAoIDAoJDAsKDgsIDAwMEAwJDw0LEA0LEQ0KDg4OEA4MEQ4KEA4NEQ4LEA8OEg8MEBAQFBA
        MFBANExEQFBEOEhISFBIRFlINFlMQF1MOFBQUGFMPGFQRGlQPFlZVVlZWWlVRF1ZVV1ZWWlZTG1ZRGFd
        WXFZRHFdSGFhYXVhSHlhTG1lXXFlXWlpaX1lTH1pUHFtbXFxcYVtUH1xYX11aXl5dY11VXl5eYl1ZYF5
        bX19eX19fZl9YYWFgYWFhZ2BYaWFZZWJfY2Nja6NaaWRfZWVlbaRbZmZmbaVcZ2dnb6ZcaWhncaddaWl
        pc6lfa6ursKqkdaugba2tt6yhc62neKyhca6qr6+vuK6jea6icbGxu6+jc7OzvbGld7OvvrKmdbW1v/O
        md7e3vbauu7eyuLi4ubm5v/iwu7u7v/u2vb29v///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        ACH/C05FVFNDQVBFMi4wAwEBAAAh+QQAAAAAACwAAAAAPQA9AAAI/wD7CBxIsKDBgwgTKlzIsKHDhxAj
        SpxIsaLFixgzatzIsWNGOWnYeKzIpgkLERYAAIAgYoPKBSJENAnDZyRCPV9iENgwM42bg3TSpDEp4MQV
        OhPl6Gm4ZQOBGF+WRiTzYwGEJlIZ6gHR4MAThWEW6BCJUU6TBVBqKtTjgcucNzyYHCRjgQVSjnqSLKCS
        UA8MM3MCzwkidyAbESd+2sQzZMEXg2zB7MkjeHDhKxvS2CxIJ4YOtQKFIAm8R0zlIEd+/NiMcIsIPAMV
        lBGsQIXgNQlOsE5IBkEWgVRyCG4zocYcMBW8EN5tkIwCGw9mCLwRRTAYAEoqzLbMfCAZE2/eFv8YMr36
        2wFT6pwuvPt7+LcKwgykPofIizmT17cHL5jHV4I3aJCCYPkJtpxN7hnI3kBdSMFAZQUGdmBHCUq4oEBd
        qFHGAU5ASJmCFPJnoUFJaFEGB3TQR+CHI2pUIXcG3UGBAnepSBqLMF704oQM2YgfjjxOtOOFPZp3o34U
        DTmRjxHmCJGSFDEJJJELQVmRlEg2ZKVFWILI0JYXddkibyI6mZGYZhIEpkZoBinQmhu1eSGcHMnpXZlu
        jmQnnXoa+eNpNOBJJWtiYtHBe2l2h6UXFyCaZ3d9SDlCFYLtMCikkfq5RwZuzQHEB5di6iMaEgBxARCJ
        YlpeZXAU0WmqqtpxyIUPVmSpakEzrNAGEQaMEIALlclwxa0F8YFCCwwMOEcbEWAg2BgOEDuQsVrEwYGR
        ZyzxIRcgSCtQGCTEYUSmHrbBgWLS6kFBD/P5aUcJ6Hp7R0EqmhuvtwfdEAIODtyL71xUwPbvwAQXbPDB
        CCeMcEAAOw==
</value>
  </data>
  <data name="doorEastCCW.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
    <value>
        R0lGODlhPQA9AIcAAAAAAAgICBAQEBgQDBgUEBgUFBwUEBgYGBwYFCAYECAcGCAcHCQcFCAgICggGCgg
        HCgkIDAkHCgoKDAoIDQsJDgsIDAwMDQwMDgwKDwwKEAwJDg0MDw0LEA0LDg4ODw4NEA4LEA4MEA4NEQ4
        LEg4KEw8LEBAQFBANEREREhEQExEPFBEOFVENEhISFlENFBIRFVMSFlMQFlMRGFMOFBQUGFMPF1QRGlQ
        PGFVRFlZWV1ZVXFZQGFdWWVdVWFhYXVdSGllYXlhTHllUH1lTH1pUHFxcYVtUH1xZX11aY1xVXl5dXl5
        eZF1XX19eX19fZV5XY2BcYWFgYWFhZ2BYYmJiaWFZZmJdY2NjbaRbbaVca6ZhZ2dnb6Zda6djaWhncad
        daWlpc6lfa6urtaugba2tt6yhb6+vs6+quK6jea6ida+ocbGxu6+jcrKys7OzvbGlebKrvrKmdbW1v/O
        me7Stt7e3vbexubm5v/iwv/mzu7u7vb29v///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        ACH/C05FVFNDQVBFMi4wAwEBAAAh+QQAAAAAACwAAAAAPQA9AAAI/wD5CBxIkKAeJynEFFzIsKHDhxD1
        iBiC5UQTiBgzajSYIsycj0QuDqSyZ6PJjRLP4PkIUqQXJilOyoS44cucPCtZhvSCpoyCmUAXrsHAsgsH
        lnMycCkTok7QpwLrKGDJhkKMMm+SlDCAwClUqECeUMUAYMCMOW+EiPz6lMcUpEe0IA3JFqrbj1802MnZ
        sm7bKWkqlLnJdw5dv0B1OLD5EefctYhN+vjwlqVjnZAjY7xShM9dy4UPa4ZoxsTAz41DZx690IIbgqgJ
        P2bdUAyNhbEv96Vd0DXD3Kp5DwSTwyHw2bz3NLjz8Dhm3pwxOt892rf0yqmRR67TYON0w6u/bv/xYfK7
        6Lo0FJbHLvt53T0CSp40H34mmRZA6bMtciWofoF7mDFTC2T8hZRu4PGxxwsdbKDHSdb5xx6CRCjxQhZx
        9CDTAczZNWFhIPwQBxIzAVDXdGMwoMJMdxzg12dhuCCDGh8lwcJ5GrlhAWJuYVFBFVU8AAcWCVCnUWmR
        pUDCGx/tAAUON7h3pGl+kbECkx9FEAYUBGiHEXdVXsnSEEPMwQYGNiA1wWsZ7RFAXVZiOccPLLD0BgRW
        sFTDFhsJ8CBUcWJ2HBsK/JmRBHIAKuZuudERApsamSBgUIEaiRobMECqkQ98AlVpggXxMEQaXzwq03ie
        LgrqQk4U4CCLLsp49CmOiEWo0az11eWEEybhKtwaHmzkq3B8cJjRsMTyhxGyxN7RgHwNMUssH8pGqyqt
        zT7LkLTTCrSEFAtx262CyxEk7rh8RCfQuejyQSAf7LarhwVtKCAntu0SJMcCRkiZr0NLjPBRELn+S9AF
        BBAQhcEaoTDpuAEBADs=
</value>
  </data>
  <data name="doorNorthCCW.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
    <value>
        R0lGODlhPQA9AIcAAAAAAAgEBAgICBAMCBAMDBAQEBgQDBgUFBgYGBwYFCAcFCAcGCAgHCAgICQgGCgg
        GCgkIDAkHCgoKDAoJDAsKDgsIDAwMDgwKDgwLDQ0NEA0KDg4OEA4MEA4NEQ8MEA8PEg8MEBAQERAOFBA
        MEhEQFBEOEhISFlENExIRFBIRFVIPFlIOFBMSFBMTGFMOFBQUFlQSFlVTGlQPFlZWWlZSHFZQGFdWXFZ
        RG1dTHFdSGFhYXVdSGlhWXlhSGllZWlpaX1lTHFpZX1pUHFtaXFtbYVpUHFxcYVtUHl1cX11aY1xVY11
        VXl5eY11WX19eX19fZV5WZ19XYWFgYWFhZ2BYaWFYY2Nja6NaZWVkZWVlbKRabaRbZ2ZmbaVcZ2dncad
        daWlpcahecqhea6urs6qhbKyrra2trq2ts6yldKyld6yhd62ib6+vua6ieq6ic7CtsbGxt7Cne6+je7C
        kerGpc7OzvbGldLS0vrKmdbW1v/Omf/Ond7e3v/atu7i0ubm5u7u7v/u4vb29v///wAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        ACH/C05FVFNDQVBFMi4wAwEBAAAh+QQAAAAAACwAAAAAPQA9AAAI/wAHCRxIsKDBgwgTKlzIsKHDhxAj
        SpxIsaLFixgzatzIsWNHPh45gjmwgASgkBjNlGijZ0uHkygfouAyUKUdPTjRtIAZc6EZD2TODLKJU0+f
        QGFe9lz4B4MaMlJK3MSZJtAePVB8LF3Ih8MWBVWK4khwVY8cAlsXYlGgZYSMKyUWrCm6hEjahETt1BgA
        Yy7OLikE3T1IFGefN2X1ABY8uGBhPXEmRDCwRXHgxo6lFu3DQ4meNiOKXMZcU7PhQBW+4LSjoQzp0lON
        Wo3ioqidEmZePz5aFkgP27gx77ZatAsFIcBz3x2eeLET5KuDb2VefPTz5Eup/x0t8Hp05SG1W/9mTNC7
        ntvgOYpfjNA8+o7ruR90Lz1jfPIJ6aeveN+h/ov9PfQfRQFCNGBEBUZ0oEMJSrSgQUgMAdtmxG2HH0UP
        DsREDk3YMJRpsjUnn0UZCpQEHlSQACJv1V14UYmDJDHHAG5QKKKLGJVohgM12NgiSg/adEIUIf4Y04FE
        qREAHRWOt5V5bRwgWGFtBBDDbxbeZV4CG7ABQmw0TLDHESPIwd5gTqywxQ4MCEJCZTipIBdOVzzwAY5L
        ebHAByexcIVhQYhR3AcZsIEZHyGMMVAeF8jBooWAhDAFnh6NYUEdBdUhgh83athAFtlZ8AJPBN3BgRxZ
        EvTHDw2AERIcIZhrgGlCdUBwwwok4MnHDBbsZ1EdL3TZ0B9WuLpQHSYgoAMYpEJkhhESWKBoSH94MUMB
        IViRx7DWCmCCtnexAS0AAGwQwgtPpKtDCCEIAICyYFCaFhxsjJHuE16wwYa8r/Xr778AByzwwAQ/FBAA
        Ow==
</value>
  </data>
  <data name="doorNorthCW.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
    <value>
        R0lGODlhPQA9AIcAAAAAAAgEBAgICAwMCAwMDBAMDBAQEBgQDBgUEBgYGBwYEBwYFCAYECAYFBwcHCAc
        FCAcGCAgICwkGDAkHCgoKCwoJDAoIDAsKDAwMEAwJDg0MDw0KDg4ODw4NDw4OEA4MEA4NEg4KEg4LEg8
        MEBAQERAOExAMFBANEhEQFBEOEhIREhISFlENFBIRF1IOFlMQFBQUGFZUGlZSHFZQGFdWWFhYXVdRHlh
        SGllYX1hSGlpaX1lSH1lTH1pUHFtbX1tWXFxcXlxaX11aY1xVYV1YXl5eY11WZF1WX19eY15ZX19fZV5
        XZl5XYGBgZ19XYWFhaWFZY2Nja6NaZWVlaqRebaRbZmZma6VfbaVcbqVbZ2dnaGdnb6ZccKddcaddc6l
        fa6urs6qhb6ypba2trq2tsK2qtqyhd6yhca6rt62ib6+vsq+sua6ieq6ic7CtsbGxu6+je7Cje7Ckc7O
        zvbGlfbKlfrKme7OqtbW1v/Omf/Ondra2vbWst7e3v/atubm5vbm2u7u7v/u4vb29v///wAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        ACH/C05FVFNDQVBFMi4wAwEBAAAh+QQAAAAAACwAAAAAPQA9AAAI/wAJCRxIsOBALXMMKlzIsKFDhU0Q
        eFDzsKLFiwLHKPjCZcQYjCBDDhzkgEeePHRSfBTJsiKMKBZOolTZsubCJ0UIIekhM+VKm0DHrBi4sydN
        oDYxJCTK86RPpC3BwDBY1OlRqBgHYcCjsOrMn1grRgHC0OvTsA8HRfjT0OxVtAvHPnQLFm5BpRXp2jXY
        J8JFvXsHTtGBEXDgFXXnNv0aeJCBQSENoxXKUjLBNzSeBBIJJEpLy4TGWHByA8RmkIhrSh6Tgs7JLx1O
        X8SrevFZ1q5P+lljGmMCtjbp4pbpR5CeLxcwAoBqdsSG3HlelNFz8gQYi32xmjVR5eSPBV1kWv+3+IZD
        WLMM2FwJkEYmFhQXKYelYUPmDSIxWLhvAdmiGhJhsZbDDHDAMYEbS2RwEhb8YZQdVMMNcQACYlAXQhUM
        9nfRIAJA2JpMfABCXR5xPKCBhhgZIFtLw+lmnEwu7BAGGSJRwFVNLeZR3Ih5vFfCGTOGRAJFLH7oIo8Z
        9vHBEBWsWJEOUxQJ3Y779deHD32EpEUNLOVI5YIN2hSIASJ5+SKYKNbEwRsgmYlkmEgpoQRGblYZ1hwY
        xGekjmf2CCdWEWT5UJ1o2tXZoHt+6WeaWP0RAaMEEbpoYIQcupCkGVJKyB8UOJlRon1mqikhchWE6Z+U
        qgXcp1OGiqqmpYaUBuqbkGoKw3Wn1qqpVlbMaueoC20xQBvEuarrqKxloSCftAJ76YdDzKCoqM6auqcM
        aDRbrbXQJYFAA1AUui1BgxQA3Q8ILCFFCEyIUMGxyI4gExUEtHeSBEcYQcO4BQ0CARt81rFfEHYsgQO/
        BM3xwR3GEiKEGRAgnDANcvxKiAp7SJzwB17QscSrGiesQQA4wGtXQAA7
</value>
  </data>
  <data name="doorWestCCW.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
    <value>
        R0lGODlhPQA9AIcAAAAAAAgEBBAMCBAMDBAQEBQQDBgQDBgUEBgYFBgYGBwYEBwYFCAYECAYFCAcGCAg
        ICQgHCggHDAkHCgoKCwoJDAoIDQsIDQsJDgsIDAwMEAwJDg0MEA0KDg4OEA4MEQ8NEg8MEBAPEBAQFBA
        NEhEQFBEOFBEPEhISExISFBIRFBMSGFMOFBQUGFMPGFQRFlVUGlQPGVVQFlZWV1ZVV1dWXFZQGFdWXFZ
        RGVdWXFdSGFhYWllYXlhTGllZWlpaXlpWX1pUHFxcYVtUIVtVYFxZXV1cXV1dXl1cY1xVYV1ZX19eX19
        fZV5WZV5XZl5XYGBgZ19XYWFgYWFhZ2BYaWFZY2NjaqJZa6JZa6NaZWVlaWZjZ2dnbaZeb6ZcbKlmb6q
        kc6lfa6urra2tt6yheKyhb6+vua6icbGxu6+jc7OzvbGlebKruLOvtbW1v/OmebWxt7e3vbauubm5v/i
        wvbm0u7u7v/u2vb29v///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        ACH/C05FVFNDQVBFMi4wAwEBAAAh+QQAAAAAACwAAAAAPQA9AAAI/wDxCBxIsKDBgwgLypGSsKHDhxAH
        pnlRQEbEixgdpvFAZYyFJxlDityIxo0bLAjgiFwJkaRJNzmMdLjDsuZBlyan2MAThoXNnwJxutE50EcW
        oDWFEh0oJ4McpCM9lMy5s2CVIFAzKq1a8M6Dp1lbSn259ODVsA+3NrwzQSVahGod9nx7cyxViHcI0KQr
        0e5Qrg9ZhOEb1G9ZiFt0EI57Ec4DvowxZkgj8s6WF4PrTv27cskSkS9aUBmhxGDkjGVEZLzTY8pLIKX7
        bj4c0jHGOym8zHnpBnbh2YBXAsD4goobO7tfKzm9MgHYh3AcvGTzgXeMC8CRTo4o58BLMhBcmP8EoyE7
        0hNiLu5o8hKNgyRuDJghG9ymji0Ybbg2KSTCFw0vObFBWJ5lpJ9JNcBAhwBjqIHECr5BZVRI+pFXkhYN
        MFCDSRECJZhIKChAxkt2rMFbhzZ1cEZIaXABBQe8IXdibDY94NZFLaoBAgn7mSSjcj8NlxEFTICQ3oEk
        JschjSLJkUBIdfRQxkBI+qhkb0xqlQFQVR53JYoYncVlj17OKJIIUyLV5Y9LZlRHAnupSSabWGI0V1hr
        fpllQ/e9laeZEDlH159AOnRGB4QR2mZDaBKGh6J1InSno5CCOdB2jgpU6Z6TZvronHoSdEcHlHlKJaiA
        4iGmqafGGGobGcSHyaqmqL5WRAY3ztpqkrw1QIOuBxFaAxKWApsnEzAsCixBXb5hghqFLrtrFxIE8EOq
        0uKxAQZXYEAFFRGI91IFpUqrBA9WNACtG2gscK1JN1SRbRQ8uEHEDD2qIaMaEeSqqwpYEEHTmnGUkF62
        dYQQZ5Vq4HBwtsEOgcYYBkPc0BEDOPCwQwEBADs=
</value>
  </data>
  <data name="doorWestCW.Image" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
    <value>
        R0lGODlhPQA9AIcAAAAAAAgICAwICBgQDBgUEBgUFBgYGBwYECAYECAcGCQcFCAgICggGCwkHDAkHCgo
        KCwoJDAoIDAoJDAsKDgsIDAwMDgwKEAwJDg0MDw0KDg4NDg4OEA4MEg8MEg8NEBAQEhEQFBEOFBEPEhI
        SFBIRFlINExMTFBMSGFMOFBQUFlQSFlVUF1VSGlVQFlZWWlVRF1dXXFZQGFdWWldUHFdSGFhYWVlYXlh
        SGllYXlhTGlpaX1lTH1pUIFpUHFxcYVtUIFxZXV1cXl1dY1xVXl5dXl5eX19eX19fZl9XZ19XYWFgYWF
        hZ2BYaGBYY2Nja6NaZWVlbaRbZ2dnbaZeb6ZcbKdicKZdcKddaWlpc6lfa6ursaynba2trq6tt6yhc62
        nb6+vuq6icbGxu6+je7CjcrKyuLGqs7OzvbGldbW1v/Ome7Wvt7e3vbauvbexubm5v/iwv/mzu7u7vb2
        9v///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        ACH/C05FVFNDQVBFMi4wAwEBAAAh+QQAAAAAACwAAAAAPQA9AAAI/wDpCBxIsKDBgwgTKlzIsKHDhxAj
        SpxIsaLFixgzatzIsePDN3I8bpwjgwABJSIxziHBRA2aHEZSWrRRRY1NNTxiCiyDYY5MhnNWMIkD5ybO
        mGem/BDyc6ETGjbjmCFzk4eNKWg6gGmq8MSTmxYyoLGZBUGUDly4KoTS4iYaDxGS3LhgpUEQtQtltLQ5
        ZgYBFGNs5sSrUK/RLUWr6iR80HBZCgS+GB3MuHGPC17UZImQWPDiygPPRAjscsCazkdBh+ZAWs2PG2qI
        Tv5M+Azrm0hQ3JStuLLt1kwg7I2KmrLa3zeZyKBjeHdx2imR21Q+sDnx2U2lq6FO0Hrs5zK1c/8v6J23
        Z5HilyMsD55j+rzDv2PX+J4h+/kX6ze839uifof8nUfRfw8FmJpEBEJkoHEOJRjRgtAl5KBEEA7kBA4+
        GTThRBUaQcMQJmh423TqbbQgCDmoAUSGqwFXIkcGKnDFigVtiFGATRxARI0jbveiSPdFcQEaxsnhVXI/
        plReGw58dWANApA2HlfWJaECAFT0p0EJVNCQZFOGxYACGiJ4YNQLUNAxBwwFHKHaCgwMwVcEHNzkRQKh
        VSBGZWlUAMJwYbCQWBYTECTHB0uw2BQUG7DBXHxEoRFCWgTNUcQDUjSlRQU6hCSQd26oQKlBbNTwgBYi
        gbFBCmcY1JykXSxqlEYKG2xF3wgf7LleBztIMOpCYnxgQA1aKAoRFzosUMGvCHFxRBoRvSFFCgGM4ISj
        DLEBBbUjQIEtV1z4sAAAAGzwgQtHpFvDBx+Qu4AOxao2kBhgYJHuEVKAYau8/Pbr778AByzwwBcFBAA7
</value>
  </data>
  <metadata name="$this.TrayHeight" type="System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
    <value>63</value>
  </metadata>
  <data name="$this.Icon" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
    <value>
        AAABAAIAICAAAAAAAACoCAAAJgAAABAQAAAAAAAAaAUAAM4IAAAoAAAAIAAAAEAAAAABAAgAAAAAAAAE
        AAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAgAAAgAAAAICAAIAAAACAAIAAgIAAAMDAwADA3MAA8MqmAAQE
        BAAICAgADAwMABEREQAWFhYAHBwcACIiIgApKSkAVVVVAE1NTQBCQkIAOTk5AIB8/wBQUP8AkwDWAP/s
        zADG1u8A1ufnAJCprQAAADMAAABmAAAAmQAAAMwAADMAAAAzMwAAM2YAADOZAAAzzAAAM/8AAGYAAABm
        MwAAZmYAAGaZAABmzAAAZv8AAJkAAACZMwAAmWYAAJmZAACZzAAAmf8AAMwAAADMMwAAzGYAAMyZAADM
        zAAAzP8AAP9mAAD/mQAA/8wAMwAAADMAMwAzAGYAMwCZADMAzAAzAP8AMzMAADMzMwAzM2YAMzOZADMz
        zAAzM/8AM2YAADNmMwAzZmYAM2aZADNmzAAzZv8AM5kAADOZMwAzmWYAM5mZADOZzAAzmf8AM8wAADPM
        MwAzzGYAM8yZADPMzAAzzP8AM/8zADP/ZgAz/5kAM//MADP//wBmAAAAZgAzAGYAZgBmAJkAZgDMAGYA
        /wBmMwAAZjMzAGYzZgBmM5kAZjPMAGYz/wBmZgAAZmYzAGZmZgBmZpkAZmbMAGaZAABmmTMAZplmAGaZ
        mQBmmcwAZpn/AGbMAABmzDMAZsyZAGbMzABmzP8AZv8AAGb/MwBm/5kAZv/MAMwA/wD/AMwAmZkAAJkz
        mQCZAJkAmQDMAJkAAACZMzMAmQBmAJkzzACZAP8AmWYAAJlmMwCZM2YAmWaZAJlmzACZM/8AmZkzAJmZ
        ZgCZmZkAmZnMAJmZ/wCZzAAAmcwzAGbMZgCZzJkAmczMAJnM/wCZ/wAAmf8zAJnMZgCZ/5kAmf/MAJn/
        /wDMAAAAmQAzAMwAZgDMAJkAzADMAJkzAADMMzMAzDNmAMwzmQDMM8wAzDP/AMxmAADMZjMAmWZmAMxm
        mQDMZswAmWb/AMyZAADMmTMAzJlmAMyZmQDMmcwAzJn/AMzMAADMzDMAzMxmAMzMmQDMzMwAzMz/AMz/
        AADM/zMAmf9mAMz/mQDM/8wAzP//AMwAMwD/AGYA/wCZAMwzAAD/MzMA/zNmAP8zmQD/M8wA/zP/AP9m
        AAD/ZjMAzGZmAP9mmQD/ZswAzGb/AP+ZAAD/mTMA/5lmAP+ZmQD/mcwA/5n/AP/MAAD/zDMA/8xmAP/M
        mQD/zMwA/8z/AP//MwDM/2YA//+ZAP//zABmZv8AZv9mAGb//wD/ZmYA/2b/AP//ZgAhAKUAX19fAHd3
        dwCGhoYAlpaWAMvLywCysrIA19fXAN3d3QDj4+MA6urqAPHx8QD4+PgA8Pv/AKSgoACAgIAAAAD/AAD/
        AAAA//8A/wAAAP8A/wD//wAA////AAoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoK
        CgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoK
        Cgq3CgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCvkKCgoKCgoKCgoK0goKCgoKCgoKCgoKCgoK
        CgoKCgoK+fkKCgoKCgoK+bEKCgoKCgoKCgoKCgoKCgoKCgoKCgr5+QoKCgoKCrGxCgoKCgoKCgoKCgoK
        CgoKCgoKCgoKCvmUCgoKCgrj4woKCgoKCgoKCgoKCgoKCgoKCgoKCgoK+bEKCgoKR7EKCgoKCgoKCgoK
        CgoKCgoKCgoKCgoKCgoKagoK+UGxCgoKsbcKCgoKCgoK+QoKCvkKCgoKCgoKCgrj+ZT5lAoKCgqxsbe3
        +fn5Cgr5Cvn5CgoKCgoKCgoKChZB+ZQKCvkKCvm3CgoK+be3Cvn5+QoKCgoKCgoKCgq3Qfn5CgoKCtK3
        sbexCgr5+Qq3+fkKCgoKCgoKCgoKsflHQQoKCgoKt/n5CreUCvn5CtL5+QoKCgoKCgoKCgoKt/lBlAoK
        Cgr5sbcKCrG3CvkKlAr5+fkKCgoKCgoKCgoK+RdH+QoKCgpqsQoKCmr5+fnj+Wq3sWoKCgoKCgoKCgoK
        lPlq4/kKCre3CkZpavkKt5SUFxfjFgoKCgoKCgoKCgr5+fn5auP5Cgrr7OztCgoKCgoKCgoKCgoKCgoK
        CgoKCgpH4woKFkcWkpLt7OzsCgoKCgoKCgoKCgoKCgoKCgoKCvn5CgoK+W6Sku3t7e3s7QoKCgoKCgoK
        CgoKCgoKCgoK+fmUCgoKkpKS7e3t7e3t7QoKCgoKCgoKCgoKCgoKCgoK+eMKCu/vkpKS7e3t7ezs7O33
        CgoKCgoKCgoKCgqx4xZBFxYWaZLv95KS7e3t7Ozs7OySCgoKCgoKCgoKCkf5+fn5+fn5IO3vkpKS7ezs
        7Ozs7O2SCgoKCgoKCgoKR0FBQUFHF2oW7feSku3t7Ozs7Ozs7ZL39woKCgoKCgoKCgoK7OvsCgqSku3t
        7ezs7Ozs7e2S9/fv7woKCgoKCgoKCgrs6+rs7O2S7e3s7Ozs7O2Skvfv7+/v7woKCgoKCgoK6+yS623s
        ku3s7Ozs7O2Skvf37+8HBwcHCgoKCgoKCuwS7O/37Ozs7Ozs7Oztkvfv7+/vBwcHBwcKCgoKCgoKEm3v
        B+/s7ezr7OztkpL37+/vBwcHBwcHBwoKCgoKCu3s7+/vkuzt7/fs7Pf37+/vBwcHBwcHB/HwCgoKCgrs
        Euvs7ZL37+/vBwf39we8vLzw8PDw8Lzz//P////////////////3////9/7///P5///z8///8+f///PP
        ///7HP7v+DwGn/hs4j/w8GR/4fEkf/DxlR/4ecAP/BkID/wGH//+YA///nAD//44Af//MAA/+AAAH/gA
        AA/4AAAD/4wAAf+AAAD/AAAA/gAAAP4AAAD8AAAA+AAAACgAAAAQAAAAIAAAAAEACAAAAAAAAAEAAAAA
        AAAAAAAAAAEAAAABAAAAAAAAAACAAACAAAAAgIAAgAAAAIAAgACAgAAAwMDAAMDcwADwyqYABAQEAAgI
        CAAMDAwAERERABYWFgAcHBwAIiIiACkpKQBVVVUATU1NAEJCQgA5OTkAgHz/AFBQ/wCTANYA/+zMAMbW
        7wDW5+cAkKmtAAAAMwAAAGYAAACZAAAAzAAAMwAAADMzAAAzZgAAM5kAADPMAAAz/wAAZgAAAGYzAABm
        ZgAAZpkAAGbMAABm/wAAmQAAAJkzAACZZgAAmZkAAJnMAACZ/wAAzAAAAMwzAADMZgAAzJkAAMzMAADM
        /wAA/2YAAP+ZAAD/zAAzAAAAMwAzADMAZgAzAJkAMwDMADMA/wAzMwAAMzMzADMzZgAzM5kAMzPMADMz
        /wAzZgAAM2YzADNmZgAzZpkAM2bMADNm/wAzmQAAM5kzADOZZgAzmZkAM5nMADOZ/wAzzAAAM8wzADPM
        ZgAzzJkAM8zMADPM/wAz/zMAM/9mADP/mQAz/8wAM///AGYAAABmADMAZgBmAGYAmQBmAMwAZgD/AGYz
        AABmMzMAZjNmAGYzmQBmM8wAZjP/AGZmAABmZjMAZmZmAGZmmQBmZswAZpkAAGaZMwBmmWYAZpmZAGaZ
        zABmmf8AZswAAGbMMwBmzJkAZszMAGbM/wBm/wAAZv8zAGb/mQBm/8wAzAD/AP8AzACZmQAAmTOZAJkA
        mQCZAMwAmQAAAJkzMwCZAGYAmTPMAJkA/wCZZgAAmWYzAJkzZgCZZpkAmWbMAJkz/wCZmTMAmZlmAJmZ
        mQCZmcwAmZn/AJnMAACZzDMAZsxmAJnMmQCZzMwAmcz/AJn/AACZ/zMAmcxmAJn/mQCZ/8wAmf//AMwA
        AACZADMAzABmAMwAmQDMAMwAmTMAAMwzMwDMM2YAzDOZAMwzzADMM/8AzGYAAMxmMwCZZmYAzGaZAMxm
        zACZZv8AzJkAAMyZMwDMmWYAzJmZAMyZzADMmf8AzMwAAMzMMwDMzGYAzMyZAMzMzADMzP8AzP8AAMz/
        MwCZ/2YAzP+ZAMz/zADM//8AzAAzAP8AZgD/AJkAzDMAAP8zMwD/M2YA/zOZAP8zzAD/M/8A/2YAAP9m
        MwDMZmYA/2aZAP9mzADMZv8A/5kAAP+ZMwD/mWYA/5mZAP+ZzAD/mf8A/8wAAP/MMwD/zGYA/8yZAP/M
        zAD/zP8A//8zAMz/ZgD//5kA///MAGZm/wBm/2YAZv//AP9mZgD/Zv8A//9mACEApQBfX18Ad3d3AIaG
        hgCWlpYAy8vLALKysgDX19cA3d3dAOPj4wDq6uoA8fHxAPj4+ADw+/8ApKCgAICAgAAAAP8AAP8AAAD/
        /wD/AAAA/wD/AP//AAD///8ACgoKCgoKCgrt7O2SAAAKCgoKCgoKCgoA7Ozs7O2SAAoKCgoKCgoAkpKS
        7ezs7ZIACgoKCgoKAJKS7e3t7e3tkgoKCgoKAJKSkpLt7e3t7e0KCgoKCgDt95KS7e3t7e3sCgoKCgoA
        AO33kpKS7e3t7AoKCgoKCgoA7/eSku3t7OwKCgoKCgoKAPeSku3t7OzsCgoA7QoKCu33ku3t7ezs7AoK
        7Ozs95LskpLt7Ozs7OwKkuzt623skpLt7Ozs7OzsB23r75Ls6+zt7ezs7OztkuwS7O/vkuzs6+zs7Ozt
        kvfr7O8H7+3skpLr7O2Skvfvkvf395Lt7ffv7+3t7+/v7/8PAAD/AwAA/gEAAP4AAAD8AAAA/AAAAP4A
        AAD/AAAA/wAAAO4AAADAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAA=
</value>
  </data>
</root>

================================================
FILE: Razor/UI/SoundEntry.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Drawing;
using System.IO;
using System.Windows.Forms;
using Assistant.Filters;

namespace Assistant
{
    /// <summary>
    /// 
    /// </summary>
    public class SoundEntry : Form
    {
        private Button btnOk;
        private Button btnCancel;

        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.Container components = null;

        private int _soundId;
        private string _soundName;
        private ComboBox _soundList;
        private CheckBox _playInClient;
        private Button _playSound;

        public delegate void SoundEntryCallback(int sound);

        public static SoundEntryCallback Callback = null;

        public int Sound => _soundId;

        public SoundEntry() : this(0, string.Empty)
        {
        }

        public SoundEntry(int soundId, string soundName)
        {
            _soundId = soundId;
            _soundName = soundName;
            //
            // Required for Windows Form Designer support
            //
            InitializeComponent();

            //
            // TODO: Add any constructor code after InitializeComponent call
            //
        }

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (components != null)
                {
                    components.Dispose();
                }
            }

            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.btnOk = new System.Windows.Forms.Button();
            this.btnCancel = new System.Windows.Forms.Button();
            this._soundList = new System.Windows.Forms.ComboBox();
            this._playInClient = new System.Windows.Forms.CheckBox();
            this._playSound = new System.Windows.Forms.Button();
            this.SuspendLayout();
            // 
            // btnOk
            // 
            this.btnOk.Location = new System.Drawing.Point(107, 92);
            this.btnOk.Name = "btnOk";
            this.btnOk.Size = new System.Drawing.Size(52, 35);
            this.btnOk.TabIndex = 4;
            this.btnOk.Text = "&OK";
            this.btnOk.Click += new System.EventHandler(this.okay_Click);
            // 
            // btnCancel
            // 
            this.btnCancel.DialogResult = System.Windows.Forms.DialogResult.Cancel;
            this.btnCancel.Location = new System.Drawing.Point(12, 92);
            this.btnCancel.Name = "btnCancel";
            this.btnCancel.Size = new System.Drawing.Size(52, 35);
            this.btnCancel.TabIndex = 5;
            this.btnCancel.Text = "Cancel";
            this.btnCancel.Click += new System.EventHandler(this.cancel_Click);
            // 
            // soundList
            // 
            this._soundList.FormattingEnabled = true;
            this._soundList.Location = new System.Drawing.Point(12, 12);
            this._soundList.Name = "_soundList";
            this._soundList.Size = new System.Drawing.Size(147, 23);
            this._soundList.TabIndex = 6;
            // 
            // playInClient
            // 
            this._playInClient.AutoSize = true;
            this._playInClient.Location = new System.Drawing.Point(41, 70);
            this._playInClient.Name = "_playInClient";
            this._playInClient.Size = new System.Drawing.Size(93, 19);
            this._playInClient.TabIndex = 8;
            this._playInClient.Text = "Play in client";
            this._playInClient.UseVisualStyleBackColor = true;
            // 
            // playSound
            // 
            this._playSound.Location = new System.Drawing.Point(22, 41);
            this._playSound.Name = "_playSound";
            this._playSound.Size = new System.Drawing.Size(127, 23);
            this._playSound.TabIndex = 7;
            this._playSound.Text = "Play Selected Sound";
            this._playSound.UseVisualStyleBackColor = true;
            this._playSound.Click += new System.EventHandler(this.playSound_Click);
            // 
            // SoundEntry
            // 
            this.AcceptButton = this.btnOk;
            this.AutoScaleBaseSize = new System.Drawing.Size(6, 16);
            this.CancelButton = this.btnCancel;
            this.ClientSize = new System.Drawing.Size(174, 142);
            this.ControlBox = false;
            this.Controls.Add(this._playInClient);
            this.Controls.Add(this._playSound);
            this.Controls.Add(this._soundList);
            this.Controls.Add(this.btnCancel);
            this.Controls.Add(this.btnOk);
            this.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog;
            this.MaximizeBox = false;
            this.MinimizeBox = false;
            this.Name = "SoundEntry";
            this.ShowInTaskbar = false;
            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
            this.Text = "Select a Sound";
            this.Load += new System.EventHandler(this.SoundEntry_Load);
            this.ResumeLayout(false);
            this.PerformLayout();

        }

        #endregion
        
        private void okay_Click(object sender, EventArgs e)
        {
            if (_soundList.SelectedIndex > 0)
            {
                SoundMusicManager.Sound sound = (SoundMusicManager.Sound)_soundList.SelectedItem;

                _soundId = sound.Serial;
                _soundName = sound.Name;
                DialogResult = DialogResult.OK;
                Close();
                Callback = null;
            }
        }

        private void cancel_Click(object sender, EventArgs e)
        {
            DialogResult = DialogResult.Cancel;
            Close();
            Callback = null;
        }

        private void SoundEntry_Load(object sender, EventArgs e)
        {
            Language.LoadControlNames(this);

            int selectedIndex = 0;
            
            _soundList.BeginUpdate();
            _soundList.Items.Clear();

            int index = 0;
            foreach (SoundMusicManager.Sound sound in SoundMusicManager.GetAllSounds())
            {
                _soundList.Items.Add(sound);

                if (sound.Name.Equals(_soundName))
                {
                    selectedIndex = index;
                }

                index++;
            }

            _soundList.SelectedIndex = selectedIndex;
            
            _soundList.EndUpdate();
        }

        private System.Media.SoundPlayer sp = new System.Media.SoundPlayer();

        private void playSound_Click(object sender, EventArgs e)
        {
            sp.Stop();

            if (_soundList.SelectedIndex < 0)
                return;

            SoundMusicManager.Sound sound = (SoundMusicManager.Sound)_soundList.SelectedItem;

            if (_playInClient.Checked && World.Player != null)
            {
                Client.Instance.SendToClient(new PlaySound(sound.Serial));
            }
            else
            {
                Ultima.UOSound s = Ultima.Sounds.GetSound(sound.Serial);
                using (MemoryStream m = new MemoryStream(s.buffer))
                {
                    sp.Stream = m;
                    sp.Play();
                }
            }
        }
    }
}

================================================
FILE: Razor/UI/SoundEntry.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
</root>

================================================
FILE: Razor/UI/SplashScreen.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System.Threading;
using System.Windows.Forms;

namespace Assistant
{
    public class SplashScreen : System.Windows.Forms.Form
    {
        private static SplashScreen m_Screen;

        public static SplashScreen Instance
        {
            get { return m_Screen; }
        }

        public static void Start()
        {
            if (m_Screen == null)
            {
                Thread t = new Thread(new ThreadStart(ThreadMain));
                t.Name = "Razor Splash Screen";
                t.Start();
                while (m_Screen == null)
                    Thread.Sleep(1);

                m_Screen.CreateControl();
            }
        }

        private delegate void CloseDelegate();

        public static void End()
        {
            if (m_Screen != null)
            {
                if (m_Screen.InvokeRequired)
                    m_Screen.Invoke(new CloseDelegate(m_Screen.Close));
                else
                    m_Screen.Close();
            }
        }

        private delegate void SetMsgDelegate(SplashScreen screen, string arg);

        private static void SetMessage(SplashScreen screen, string msg)
        {
            //screen.message.Text = msg;
        }

        public static string MessageStr
        {
            set
            {
                try
                {
                    if (m_Screen != null)
                    {
                        if (m_Screen.InvokeRequired)
                            m_Screen.Invoke(new SetMsgDelegate(SetMessage), m_Screen, value);
                        else
                            SetMessage(m_Screen, value);
                    }
                }
                catch
                {
                }
            }
        }

        public static LocString Message
        {
            set { MessageStr = Language.GetString(value); }
        }

        private static void ThreadMain()
        {
            try
            {
                using (m_Screen = new SplashScreen())
                {
                    Application.EnableVisualStyles();
                    Application.Run(m_Screen);
                }

                m_Screen = null;
            }
            catch
            {
            }
        }

        private System.ComponentModel.Container components = null;

        public SplashScreen()
        {
            try
            {
                InitializeComponent();
            }
            catch
            {
            }
        }

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (components != null)
                {
                    components.Dispose();
                }
            }

            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            System.ComponentModel.ComponentResourceManager resources =
                new System.ComponentModel.ComponentResourceManager(typeof(SplashScreen));
            this.SuspendLayout();
            // 
            // SplashScreen
            // 
            this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
            this.BackColor = System.Drawing.Color.White;
            this.BackgroundImage = ((System.Drawing.Image) (resources.GetObject("$this.BackgroundImage")));
            this.BackgroundImageLayout = System.Windows.Forms.ImageLayout.None;
            this.ClientSize = new System.Drawing.Size(435, 331);
            this.ControlBox = false;
            this.DoubleBuffered = true;
            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.None;
            this.Name = "SplashScreen";
            this.ShowInTaskbar = false;
            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
            this.Text = "Razor Splash Screen";
            this.TopMost = true;
            this.TransparencyKey = System.Drawing.Color.White;
            this.Load += new System.EventHandler(this.SplashScreen_Load);
            this.ResumeLayout(false);
        }

        #endregion

        private void SplashScreen_Load(object sender, System.EventArgs e)
        {
            this.Activate();
            this.BringToFront();
            this.Focus();
        }
    }
}

================================================
FILE: Razor/UI/SplashScreen.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <assembly alias="System.Drawing" name="System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
  <data name="$this.BackgroundImage" type="System.Drawing.Bitmap, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
    <value>
        Qk1yPwYAAAAAADYAAAAoAAAAswEAADkBAAABABgAAAAAAAAAAABgDwAAYA8AAAAAAAAAAAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////lJSTlJSTlJSUlJOTlZSUlZWV////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////lJSTlJSTlJSTlJSUlJOTlZSUlZWVlZWVlpWVlZSU////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////lJOTlJOTlJSUlJSUlZSUlpSVlZWVlZWVlpWVlZSUlZWUlpaWl5aW////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////fXx7kI+PlJOT
        lJOTlZSUlpWVlZSVlZSUlZSUlZSUlZWUlpaWl5aWlpWVl5aVlpaW////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////fXx7fXx7fXp7goCAioiIkpCRlpWVlpWU
        lZSTlZSUlpWUlpWVlZSUlpSUlpWVl5aVlpaWmJeXl5eXl5aX////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////gH18gH18fXt7e3l5e3d4fXh5g4CAioqKk5KSlZWVlpWVlpWV
        lpSUlpWWl5aWlpaVl5aWmJeXl5eXl5aXmJeXmJeXmJaX////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////fXl5f3t7f319fHt5fHp5fHl5enl4enh3e3h3hIGBjIqKk5KSlpWVl5aWl5aWlpaW
        lpaWl5aWl5aXl5eWmJeXmJeXmJaXl5aWl5aWl5aW////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////fXl5
        fXl5fnp6gH18gX59fnx7fHp6enh4e3l4e3h5fXl5fHl4e3h3g4GAjIuLlZSUlpaWl5aWl5eXl5aWl5aW
        mJeXmJeXmJeYl5aWl5aWl5aWmJaWmJaXmJeY////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////gX59gX59f318f3t7f3x7
        gH19f3x8fXt7fXp6fnp7fXp6end4eXZ2eHZ2eHZ2fHl5hoOCjoyNlpaXl5eXl5WWl5aWmZiYmZiZmJiY
        mJeXl5aWmJaWmJaXmJeYmZiYmZeYmJeX////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////hoSEhIKCg4GAgoCAgH9/gX5+gn9+gH19f3t8
        fnp7fnt7fHp6fnx8fnp6fnp5fHl5fXh4fXh4fXp6hYODjo2NlpWVmJeXmZiYmZiYmJiYl5aXmJaWmZiZ
        mZiZmZiYmZeYmJeXmpmZmpmZmpiZ////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////hoSEhoSEhYOChYOChYODhIODgoCAgX19gX5+f31+fnx7f3x7gX5+gH19
        gXx8gHt7fnp6fXl5fXl5e3h4end3e3h4gH19iIaFkI6OmZiYmZeYmJeXl5eXmZiYmpmZmZmZmZmZmZiZ
        mpmZmpmZmpiZmZeXmZiYmZmZ////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////h4aGhoOEhoSEhYKChIGChIGBg4GBgn9/g4CAg4CAgH59gH19gX19f3x7f3t7gHx8f3x7fnt6
        fHl5e3h4enh4fHl6f3x8fXp6enh4f3t7iYaFkI+PmJeXmZmZmZiYmZiYmZiZmZmZmZiYmJiYmZiYmZeX
        mZiYmZmZm5mZmpmam5mZ////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////h4aGh4aGh4aG
        hoSEhoOEg4CAhYKChoSDhIGCg4CAhIGAhICAgn9/gH19gHx9g4B/gn9+gH19gH18gX18f3t7fnp6fnt6
        fXt7fnp7fXp6fHh5e3h3e3l5f3x8iIaGkY6PmZeWmZeXmJeXmZiYmJiYmJiYmpiXmpeWmpiXm5mZmpma
        m5mZm5mZm5manJub////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////iYeIiYeIh4WFh4WFiIWGh4OEhoSD
        hoODhYGChYKDhYKChIGBg4GAgX9/g3+AhoKBhYKAgn5+hIB/hYGAg39+gHt7gXt6f3t6gHx8gH18gHx8
        fnp6fXl5e3d4eHV2d3R1fXl5h4WEkpCQmJeYmZiYmZiZmpiYnJeWm5eWmpiYmpmZm5mZm5mZm5manJub
        nJycnJubnJub////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////jYiHioeGiIaFiIaGioeHiYeGh4WEhYGChYKDhoODh4WE
        hYSEhYKChIGBhIGAh4KCiIODhYGBhICAhYGAgn9+gHx8g317hX98gX17gHx7gX18gn19gHx7fHl4eXd3
        eHV1e3d3eXZ1eHV0gX18i4iHk5GRmZiYm5eWnJmXm5iYmZmZmpmZmpmZm5manJucnJycnJubnJubnJyc
        nZ2cnJub////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////jYiHjYiHjIiIi4eIiYaGioeHioeHiIWFh4SEhoODhoSEhoSEhoSEhYKChYKBhoOC
        iYWEiYSEhYGBhIB/hIGAg4GAgn9/hH9+hH99gn59gHx8gXx8gX18gH18fnt7fXp6fHl5fHl5enh4eXd3
        fHl5fnl4gHl3hH99i4iHlZKSm5mZm5qZmpmYmpiYm5qanJubnJycnJubnZycnJycnZ2cnJubnJubnZuc
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        j4qKj4qKj4uKi4iIioeIiYaGiYWGiYaGiIaGiIaFh4SDhoODhoODhoSEhYKChoOChYOChoODhYKChoSD
        hYKCg4CAg4GAg4B/hX9+hn9+g35+gX19goB/gH5+fnt7fnp6fnt6fXp6fXp6fnp6fXt6fHl5fnl4f3t6
        e3l4eXZ1gH18ioiIlZOTmpiZm5qanJqanJubnJubnJqbnJucnZycnJybnJubnZucnpycnpycnJyc////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////ko+Pko2Nj4uLjYqK
        i4iJioeIiYWFioaFiYaGiYaGiIWFiIWFiYeGiIaGhoODhIKChIKChYKCh4SEhoWEhoOChICAg4CAg4B/
        iIF+i4WBhYF/gX5+goB/g39+g358gX59gH19f3x8fnt7fXp6fHl5e3h4e3h4fXt6fXx7end3enZ2end3
        end3gX9/jIqLl5aWnJubnJubm5qanJqbnZycnZycnZucnZybnpycnpycnJycnZycnpycoJ6e////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////ko+Pko+Pk4+PkY6OjYuKi4iJioiHjIqJi4iH
        iIWFhoOEiIWFioiHi4iIioiHh4WFhoODhYOChoKCh4ODiIWFh4ODhoOChYKChH+Ai4SCjYiEhoGAf3t8
        gX5+hoF+iIJ/gn9+gH5+gH19gX59fnt7fHl5fXp5fXl6fXp6fnt6fXp5fXp6fXt6fHh4e3d3enZ3enZ2
        g4CAjouMl5WWnZubnJybnZubnJucnZybnp2dnp2dnZycnZycnpycoJ6eoZ6fn52dn52d////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////kY6OkY6OkY6OjouMjYuLjouLjouLjoyLj42NjYqLiYaGiIaFioeH
        ioeHi4iIi4mIioiHiYeGiIWEiIWFiIWGiISEhoKChoKChH9/ioSCjIWDhoKBgX9/g359h398hoF/hIGA
        g39/gn5/gX59gH18fnp6fnt6fXt7fHl6fXl6gHx9gH59fnx7f3t8f3t8fnt7fHl5e3h4e3d3end2hIKB
        joyMl5aWm5ubnZucnp2dnp2dnpycnpycnp2doZ+eoZ6fn52dn52dn56dn56en56e////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////ko+Oko+OkpCPkI2NkI2Nk4+PkY6OkI6OjoyNjoyLjYqJjYuKjImKjIiJioeHioeHioiH
        i4mIi4iHi4iIioaHiYWGiIWFhoODhoGAhoGAiIWEh4WEh4SDhYGAhn9+iYOCiIKBhoKCg3+AgX19gX19
        gX59fXt6fnt7fnp7fnp7f319fnx8fXp6f3x8f35+fXp7fXp7fXp6f3t6fnp4end2enZ2fHl5hYODkI6O
        mpmZnZycnZycnpyboJ6doZ6eoJ6fn52dn52dn56dn56en56en56eoZ6doZ6e////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////lJGQ
        lJGQlJGRlpKTlpOUlZOSkY+Pj4uMjYqKjYqJkY6Nj42NjImKi4iIjIiIjIqJjImJjIiIiYaGioaGi4iI
        i4iIi4eHiYWFh4ODhYKCiISEjoaFi4SChYOEhoOEiIOChoKAhYKChYKCf3x8fnp6f3x8gH18gX59gH19
        f3t8f3t7fnt7fXp7f3x9fnx8fHl5fHl5fnt7gHt7gHt6fnp5fnt7fXt7fHl5fHh4e3h4hIKCkI6OmpmZ
        np2cnp2cnp2dnp2dn56dn56en56en56en56eoZ6doZ6en56dn56foJ+f////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////lJGQlpKSlpOUlZOT
        k5KRkY+PkIyMkY2Nko+PkI6PjoyMi4mJi4iIjYqJj46MjouLjYqKi4iIi4iIjImJi4iHjIaGjoaFjYaE
        iIOCi4SDkoWCkYaCi4WEhoOEhIGBg4B/hIGAhYKBgn9/f318gX5+hICAhYKBgn9/gX19f3x7gH19gX5+
        gX5+gH19fnt7fXp6fHl5fXt6fnt7f3x8f318fnx7fXp6fnt7fHl5end3e3d3fXp6hIKDkY+PnZucn56d
        n56dn56enp2dnZydn52dop+eoqGfn56dn56foJ+foqCfo6CgoJ6f////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////lJKSlJKSkpCPj4yMko+Oko+Pk5CQlpST
        lpSUkI2OjouLjoyMjIqJjouKjoyLjYuLjoyLjoyLjYuKj4uKjomIjYeGkIeFkIWCjISCi4WEj4aEk4aC
        koaCioSDh4SEhoKBhICAhYKBiIWEiYeFiIWFhoODhIKChIKBgX9+gn5+hIGBg4B/gH18gn5+gX9+gH59
        fnx7fnx8fnx8fHl6fXp6fnx6fnt7fnx8f318fnt7fXp6e3h4eXd3fHl4gn58i4iHlJKSnpycn56dnp2d
        npycoZ+eoqCgoJ6dn52en5+eoqCfo6CgoJ6foZ+foZ+foKCf////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////lJKSkY2Nko2Nk4+Pk5CRlJKSmZeXlZOTkIyMj4yMj42M
        jouLj4uLjouLjImJjouKjouLj4yMkIyMj4qJjYiHjomHj4iGjYaFjIiIi4eHjYaEkIWCjYWEiYeGiYaG
        h4SFh4SEiIWEiIWFh4WFhYOEg4KChIKCg4GBgX5/g4B/goB/gH19f3x8gX5+gX5+gn9/gn5/gH19fXp6
        fHp6f359f319fnt8f3x8gH19fnt6fHl5e3l4fHl5end3eXZ3e3d3fnt7iYeHlJKSnpycoJ6eoqCfoJ+f
        n5+foZ+eoZ+doJ6eoJ6eoZ+foZ+foKCfoaCgoZ+foaCg////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////mJSUmJSUl5WVlZOUkpCRk5CQlpOUlpOTkY2NjouKjouLjouLkI2NkI6NjoyL
        jouLkIyMkY6OkY6NjIiJi4iHjoqJjoqKjoiIj4uKjIqKiYaGi4aGi4aFioaHi4eHiYaGhIOCg4KChIKD
        hoODhIKChIGChIGBhYODgYB/fXt6gn9/hYKDgX5/gH5+gn9/gn9/gn9+gn9/gH5+gH5+gX9/gX9/gH19
        f3x9fnx7f3x8f3x8fnt7fHp6fHp6e3d4enZ2eXd2d3V0dnR0e3l5iYaGlpSUoZ+foaCfn52enpubn56d
        oJ+goaCgoZ+goJ+eoaCgoZ+foaCgoqGho6KipKKi////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////mJSUmpiYlpSUlpOUlpKSlJGRk5CQkpCPkI6NkY6NkY6Oj42Nj4yMkY2NkY6OlJGRlZOTk5CQ
        kIuLjYmJj4uMj4mJjoiIjoqKjYqJjIiIjYmJj4yLjoqJioeGh4ODhoSEhoaGiIiJiYaHiYWFh4OEh4SE
        hoSEhIOCgX9+hYGBiISEhIKBhYKCg4GBg4GAg4B/gn+AgX9/gn9/g4CAhICBg4CAgH5+gH5+gX19gn5+
        fnx8fXp6fXp6fnp6fnt6fXt6end3eHV1eHV1eHV1enh4gH19i4iIk5GSnZucoJ+foqGgoaCfn56en52d
        oZ6foZ+goaCgoqGho6KipKKioqCgo6ChoqCh////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////mpeYmpeY
        m5mZmpiYmJaVlZKSk4+PlZKSlZKSk5CPkpCQkY+PkY6OkY6Oko6OlZOTl5WVlJKSko+PkY2NkYyKkImI
        jImIjouLjomJjIiIjImKj4yMj4yLioeGh4SEiIaGi4qKiomJioeIjIiIjomHi4eGioeHiYaGiIWFiIaF
        hYOChIGBhYOChYKChYGChIGBgH5+gn9/hICAgoB/g4GBhIGBg4CAgoCAgX5+gn9/gn+Af3x9fnx7fnx7
        f3x8f3x9fnt7fXt6fXp5e3h3e3h4fHh4e3l4e3h3fnt7ioiIl5aWoJ6en52doaCfoqGhoqGhoqCgoqGi
        pKKjo6GhoqCgo6ChoqChoqCgoqGho6Ki////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////mpeYmpeYm5mYmZeWmZaVmZeW
        lZKTlZCQmJWVl5aWk5GRk5CQlJGQk5CQlJCQmJSVl5SUkI2NjouLkY+OlI+Oj4mKjIqKjouLj4uMjImJ
        h4SFhYOEioiIjIqKi4qKjIuLjouLjYqJioiIjImJjoqIjYmIjImJjYmKjImJi4mJiYaGh4SEh4WEh4OD
        hoOEgoCAgX5+g39/hYKChIGBhIKChYKCg4CAg4B/gn9/goCAhIGBg4GAgoCAgX9/gH5+gH1+f3x8fnt7
        fnt6f3x6fnt7fXt6fXt7e3l4e3d3eXV1eXZ2gH19jImJmpiYo6Kio6Gho6ChoaChoqChoZ+foJ+eoqCg
        oqGhoqCgoqGho6KipaSkp6ampaSk////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////mpiXmpiXmpeXmJWUmJaVmJaVlpOTmZSUoZ+en5+e
        l5SUlJGQlJKRlZKRlJGQl5SUl5WWk5CQko6NkY+OjoyMkI6Oko+QkY6OjouLjImJioaHioiJiomKjoyM
        j42Nj42NjouLjImJi4mJjIqKjYqKjImJjImJi4mJjIqKi4mJioeIiYaGioeHioaGh4SFhIGBhICAh4OD
        h4SEhYODhIGChoODhoOCh4OChIGBgH1+gX19g4CAhYODg4GBgX9/f3x8gHx8f318f319f3x7f3x8fnx7
        fXp6fHp5fXt7fXp7end3eXd3eXd3enh4goCAj42Nm5iZoqCgoqGhoqCgoJ+foqCgoqGho6GhoqCgo6Gi
        paSkp6ampaSkpKKio6Ch////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////m5iYnJmYnJmZm5mYmZaWmZaVl5STmpeXnZybm5qZl5SUl5WUlZKRlJGR
        lJGQlZOTmZeWmZaWlJGRjouMiomKk5GQlZOSkI2NjIqKioeIjYuLkY+PkY6OkI2NkY6OkI2NjYqKi4mI
        jIqKjYuLjYuLjYuLjImJi4iIi4mJjImJiYeHioiIjImJi4iJioaHiIWGiYWFioeGiYaGhIODhIKChYKD
        h4SEhoODh4SDhoKCg4CAgH5+g4GAhIOCgH5+gH18gX59g4CAgoCAgn9/f319fXp6fnp6fnt7fnx8f318
        fHp5end3e3h4e3h4eXZ3d3V0eHV0goB/kI6OnJuboqCgoaChoqKhpKOio6GgoZ+fo6GhpaSjpaKjpKKi
        o6Cho6GhpKOkpaSj////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////m5iYm5iYnJmZnZubnZqanZmZnpqanZqZl5WVlZOTl5OUmZWWl5SUl5SUlpOTlZKSlpOSl5STmJWV
        lJGRjoyNjoyOkpCQkI6Oj4yNjoyNjYyMjYyMkY+Pko+Pko+PkY6Oko+PkI2NkI2NjoyMjYqKjouLj42N
        joyMjYqLjYqLjYmJjYqJjIuKi4qKioiIi4mJjIqJjImJjImIi4iJiYaHhoWEh4WFhoSEh4WEiYaFiIeG
        hIKDg4CAhYKChIKBgn5+goB/hIGAhICAhIGBg4GBgX9/f3x9f3x9fXp6e3h5fXp5fnx7fnp7fnl5fHl5
        end3d3R0eHR1e3h4enl4enh4hIKCkI+OnJubo6Kio6Kio6GhoqChoqCgoqCgo6Kho6Cgo6GhpKOkpaSj
        paOjpKOjpKSj////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////rKqpq6morKqpq6ioqaamqKWlp6Wk////////
        ////////////////////////////////////////////////////////////////////n5ycnpycnZub
        nZqanJiYnZmZoJ2cn5ycmZaWlpKSnJiYnJmZmJWVmpiXmJeXlJGRlZGRl5OTmpeXmpiYlpOTlZKTkpCR
        kI2Ok5CQlpSUlJKRk5CRkpCQk4+Pko6PkpCQkpCQk5CRk5GRko+Pj4yNkI6Oj46OjoyMj42Mj42NjouM
        jYmKjYqLi4qKjYuKjIqKi4mJi4mJjIqJjouLjYqKioiIiYeHioeHioiHiYeHhYOEhYKCh4SEh4SFhYKC
        h4ODhoOChIKBhIGBgn+AgYCAgoB/gn5+fnt8fnt6fnp6fnt7f3x9gH1+fnx7fHp6fnt7fHh5fHl5e3h4
        e3h4e3h4enh4eHZ1eHV0hYKClJGRn56do6KhoqCgoqCgo6GhpKGipKKjpaSkpaOkpaOjpKOjpKSjpKOi
        pKKipaOj////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////qqemq6iorKqpq6morKqpq6ioqaamqKWlp6WkqKWmqKampqWk////////////
        ////////////////////////////////////////////////oqCfn5ycn52bn52cnpqanpubnZmZm5iY
        mpeXmZeWmpiXnZuanZuamZeWmpeXmpiYlZOSlZORmZaWnZucnZubmJWVmJSUmZeXmZaVm5eXmpeXmJWV
        lpSUlZSTlJGQk5CQko+Qk5CQk5GQk5CRkpCQkpCQkI6PkI6OkI2Mj42MkI6Ojo2NjIqLjYmKjoyMjoyL
        joyMjImJjImJjIqKi4mJi4eIioiHi4iIjImIi4iIiIaHh4WFiIWFh4WFhIGChoODiIaFh4SEhoSDhoSE
        hIKCg4GBhIKBgn9+gH19gn9/gn9/f319gX5+g4CAgn9/fnt7fnt7gH99gH59fHp6e3h5fHp5end2enZ2
        eXV2enZ2eHZ1enZ2hoKCkY6Pn5yco6Kio6KipaSkpaSkpKKjpKKho6Kio6KipKOipKKipaOjpqSkpqSj
        pqSj////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        rKqpqqemq6ioq6iorKqprqurrKqqq6ioq6iop6SlqKWmqKampqWkqqemqKalpqOj////////////////
        ////////////////////////////o6KhoqCfnpycnpuboJ2dpKGgoqCgn5ycnZqZnZuZnJqam5iYnZmZ
        nZqZm5iYmZaWmpeXmJaVmpiXmpeYmpeXmJaWlpWVmJWWnZqanZuam5eXmZaWmZeXmZeXl5SUlZOSk5KR
        k5GRlJGRlZOTkY+PkpCPlJGRk5CRk4+Pko+PkY6OkY+Pj42NjouMj4yMjoyLjYqLjYqKi4mJioeHjIiI
        ioiIioiIi4iIi4mJioiIioiIioiIi4iHioiHiIaGh4WFiIaFiYeGiIWFh4WFh4WFiIaGiIaFhoSDhIKC
        hICAhICBgoCAgH59gH59hIGBhIGBgn5/f3x8goGAf3x8fHl6fHp6fXp5fXl5fHl5fHp5eXZ1eHZ2eXV1
        fHRzfHV0e3l4iIWFk5GRoaCfpaSjo6Kio6GhpKKipqOjpaSkpKOjpaOipqSkpqSjpqSjpaOkpqOkp6Sk
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////raqqrKqprKmorKmorKmp
        rauqr62srKqprKqprqurrKmpqaampqSkp6SkqqemqKalpqOjpKKio6GhqKWk////////////////////
        ////oZ+gnJyfo6KhpaOio6GgoZ2dpqOiqqiopaOkoJ2doJ6dnpubo56do5+en5ycm5mZmZeXmZaXmJaX
        mpiYm5mZnZqanJmZm5iYmZeXnJmZn5ycn52dnJuamZeXmZWXmZaXmZeWlpWUlZOTlZKSl5SUlZSUk5KS
        lJGRlpOUlZOTlZOSk5GQko+PkY6PkY+OkY+Oko+PkI2NjouLjoyLjIqKjIqJjouKjouLjImKjouLjoyM
        jYyLi4qKi4mJjImIioiHiYeIi4mJjYqJioeGiYaGiYaGh4SFhoSEiIaFiIWFh4SEhYOCg4GBg4KBgYB/
        gX9+gn9/hIKChIKBgn5/goCAgH1+f3x8fn19fnt7fHl5fXp6fHl4end3eXZ3fHd3gnl3gHp3enh3end3
        enZ2e3h4h4WFlZOUoqChpqSkp6Wmp6ampqSkpKOjpqSjp6WkpqSkpaOkpqOkp6Skp6WkpqSkpqSk////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////raqqraqqraqqr6ysr6ysrauqr6ysr62srquqrquq
        sK2trKmpqaWlqaamrKmpqqioqqioqKampKKio6GhqKWkrqyrrKmorauq////q6eopKGhoZ+gnJyfnZ2g
        pKKipqOio6CfqKalrauspqOkoZ2doZ6doJ2dpJ6epaCfn52dmZqbmZmanZucn52dnJqanZqbn5ycnJqa
        mZaWmpaWnpqaoZ6eoZ6fn52empmZl5SUl5SUlpWVmJWVl5WVl5SUlZKSlZKTlZOTlpOUlZOSlpSUlZSU
        lpSVlJKRkpCPko+Pk5GQk5CQko6OkY6OkY6OkY+PkI2Nj42MjoyLjouMjouMjoyMjYuMj42NjoyMjouL
        jImJioeIi4mJjImJi4iIioiHi4iHh4WFiIWFioeGiIWFhYODhoSEhoOEhYKCg4GBhIGBhYKChIGBg4GA
        goB/g4GBhYOChIKCgX5/fnt7fXp5fnt6fXp5enZ2e3d2fXh4fnt5fXp5fHh4e3h3fXp6fHp6e3h4fHp5
        fnx7iYeHmJaWpKKipqWkpaSjpqSkp6SkpqSkpqOkpqSkpqSkp6WkpqSkpqSkpqSjpqWjpqWk////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////tLGxrqursKyssa6ur62sraqpr6ursK2tr62tr62tsa6tr6yrq6inraqq
        rKqpq6iorKmqrKqqp6WlpaOjq6morqyrrKmorauqrKmoq6eopKGhoqGhoaGjoqGjpKOjo6Ghop+fpaKh
        pqSko6GhoZ2cop6eop+fo5+foJ2bnZubm5qbnp2doJ6eoJ2enJmZnpuaoJ6dm5mZmZWWnJmZn52cop+f
        op+fn5ydnJqamZeXl5aVmJaXmJWWmJaVm5iZnZqamZaWl5WUlZOTlZOTlpKTlZGSlJKSlZSTlJKRlJKS
        k5GRk5CQko+Pko+Pk5CQlJCQkY+Pj42NkI2Nj4yNkI2Nj42MjoyMkI6OkY+Oj42Nj4yMjIqKioiIi4iI
        i4iIjImIjImJioiHiYaHi4eIiYaGhoSEhoODhIGBhIGCg4KCiISDioWEhoGCgn9/goB/g4CAhoSEhYOC
        gX5+f3t7gHx8gH18gH19f3p6fnh3fnp5fXt6fnt7fnl5fXl4fnt7fXp6e3d2fHh3enZ2end3end3fHp5
        ioiHl5aVpKKipqSjpqSkpqSjpqSkpqSkpqSkpqSkpqSkpqSjpqWjpqWkpaOjo6KhpaOj////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////tLGxtLGxs6+vtLCwsa6ur6ysrqurrquqsq6usa6usK6us7Cvsq6urqyqrq2sraqqrqursK2trKqp
        qqenqKamq6moraqpqqemq6iorKmoqqampqSjqKamqaenqKaloqKioqGipKKipKKhoZ6eoZ6dpaGgpKGh
        o6CgoZ+en5ybnZqaoZ+fpaOio6CgoZ6enZubn5ybn5ybnZqaoZ6eo6Gin52dnZqan52doZ+enpubm5mZ
        m5mZnJqampeYmJaVnZyboZ+gnJqal5WUl5OUlZKTlJOTk4+Qko+PlJGSl5OUlpOTlZOSk5GQlJGRk5CQ
        kpCPkY+OkY+PkpCQk5CRlJCQk5CQlJGRkpCPkY+PkI6Oj42Nj4yMjoyLjYqKjYqKjIqKjImJjImJiYaH
        iYaHioeIiYeHiYWFiIWFhoSEhYODhYODioWEjYeFi4WDh4KBhIKBhYKChYGCg4CAgX19gX59gH18gX5+
        g39/hX99gHp5f3x7gX9+gH19f3t7fnt7f3x7fXp6fHh4e3d3fHl4fXl5e3h4eXd3eXd3d3V0fHl5ioeH
        mpeXpqSjpqSkpqSkpaSjpaOjpqKjpqSipqWkpqSjpaOjo6KhpaOjpaOipaKipqSk////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////s7Cws7CwtbOz
        s7Gwsa+usq+vsa+ur6yssq+utLCwsq+usq+vsa2tsq+usK+urqursq6vsa+urquqraqqrKqqq6mor6yr
        sq+vr62trKmprKmprKmpqqamqqinp6SjpaKio6KjpaKjpqOjp6SjpaGhpaKhpKGho6CfpKGhoZ6eoJ2d
        o6GhqKalqaamqKampKKin52cnZmaoZ6epqSjo6Ginpucm5mZoZ+eo6Cgn52cm5iYnJmZnZqanJmZm5mZ
        nZybnZucmpeYmZaWmJSUlpOTlZSUlpSUlZKSl5OTl5OUlpSUlZKSlJGSk5GRlJGRkpGQkpCQk5GRk5GR
        lJKSlZKSlZOSlpKSlJGSk5CQk5CQkI6Oj42NjoyMjouLjouLjoyMjoyNjIqLioeIi4iIjIqKioiIioiH
        i4mIi4mIh4SEiIaGioeGjIeFjYeFioWEh4SEhoSEhYODhICBhICAg39/g39+gX19g39+hX99gn59gn9+
        gX5+gHx9gH19gX9+gH19f3x8fnt6fXt7f318gH18fHp6fHl6e3h4eXV1enZ1eHR0d3V0fXp6ioiHmJaW
        paOjpaSjpaSjp6Wkp6WkpqSjpaSkpKSkpaSjpaOipaKipqSkp6amqaenqain////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////s7Gxs7CwtLKxs7Cws7Cvs7Gws7Gw
        sa+usa+vtLGxsrCvrqyrsa+utbKxsa6urqussa6usa6trqyrsK+vrq2trqursa6utbOzs7Kxr62trqyt
        rqusqqeoqaamqaemq6ioqaampKGhqaemr66tqqmppKGhpaKhqKSjp6OjpKGhoqCgpaOip6Wjp6WkqKam
        p6Wlop+goZ6fpKKjpaOjoZ6eoJ2doaCfo6Kho6GhoZ+foJ6en52cnpycnJqanJqam5mZm5iYm5iYmpeY
        mpeXmZaWmZaWmJaWmZeXmZaWl5WVlpSVlpOUlJGRlJGRlJOSlJKSlJGRlZKSlJKSlJKSkpCRkZCPk5CQ
        k5CRk5GQlJKRkZCQj42Oj46OjoyNjoyMkI2NkI2OjoyNjYyLjYuLj4yMjYyMi4qKi4qJi4iJioiIioiI
        iIaGh4SEioeGi4iHioaHhoKChoSDh4aFhYODhoKChYCAgX19f3x8gn9/g4GBgn9+gHt7gX19g4B/gn9/
        gX5+gH19gH19f3x9f319f359gH1+f3x8fnt6fHl5fXl4eXZ1d3R0d3R0dnNyd3NyfXl5i4mJm5iYp6Wk
        qKWkp6Wlp6amqKempaKhop2cpJ+epaSkp6amqaenqainp6WlqKalp6am////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////s7Gxs7Gxs7CwsrCvtrKytbKxs7CwtLGxs7Cwsq+vs7GwtLGx
        sa6us7CvsrCvrqyrr6yssK6tr6ysrqyrsK6ur62traursKytsK6usK2trqqqraurr62srayrq6iorauq
        sa+vrqusqaanq6mosbCvrKqrpaKiqKalqaemp6Ojp6SkqaWmqKWlp6WlpaKipqOkpaKjp6SkqKamqaeo
        qaanp6WlpaKjop+goZ6fpKKipaSkpaOjpaOjoJ+fnZubnJqanJmZnJmZnZqanJqam5iZm5iZm5iYm5iY
        mpeXmZeXmJaWmJaWmJWVl5SUl5WVmJaVlpSUlZKSlZKSlpKTlJGRkpCQkpCQlZOTkpGQkI6OkY+PkI+P
        kI6OkI2OkY6Pj42NkI2Oj4yNkI6Ojo6Nj42MkIyNj42OjYyMi4mJjImKjYuLioiIiIWFiIaFiIaGiYeG
        iIWFh4ODh4WEiIaFh4WFhoSDhoOCg4CAgn5+gX5+hIGBgn9+gn9+hICAg4B/gX5+gX19gX5+gn5+gn59
        gH59gX9/gn+AgX5+fnt7f359fXt7end3eXZ1eHV1eHR0eXd2eXZ2d3Rzd3V0f318jouLnJubp6Wlp6Wl
        pKKipaCfqKSip6Wlp6Wlp6Wlp6Slp6WlqKalp6amqaeoqqioqqeo////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////sq+vtbSztbGxtbGyuLa1uLW1tbOytbKyt7S0tLGwsq+vtrKzuLW1tbOysa6usK6t
        sa+ur62trayrrqysr6ursK2sr62ssK2tr6usr6yssa+ur62tsK6usa+uraqqrqqqsa6tr62tq6mqq6io
        rKioqqenqKWlqqioqqioqKWlqqenrqqqq6ioqqeoraurq6mpqKWmqaeorKurrKmqrKmqqaiop6WmpKGh
        o6CgpaKjpqOjp6SkpqOkoZ6fnZubn5ycnZubm5qZm5mZm5iZmpiYm5mZnpubnZuampeXmZeWmpeXmZaX
        mZiXmZeXmpiYmZaXmJaWl5WVmZaWmZaWlZOTlZKSmJaVl5aWk5KSko+Pk5CQko+Pko+PlJGQkpGRkpCQ
        kI6PkI6Pjo2Oj42NkI2Nj4yMjouLjYuLjYyLjo2MjouKiYeHioeHi4eHioeGh4WEhoSEh4SDiIWFioaG
        ioeHh4WFhYODhoSEhoSDhoKBh4OChIGBg4CAhYKBhIGBg4CAgX59gX19gn5+g39/gn9/goCAgH9/fnt7
        f318gH9+fXp6end3e3h3e3l3eXd3enh4fHl4fHl4enh3eXZ1eXRzenV0gX19kI2Nn5ycqaalqKalp6Wm
        p6anp6WlpaWkp6alqainqKeoqaeoqqioqqeoq6mpq6qqqqmp////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////sq+v
        sq+vuLa1uri3u7i4vbq5ure3uba2t7S0t7W0tbKytbGyuLW2ube3trS0srCws7Gws7CwsrCvsrCwsq+v
        sq+vsa6tsK2tsK2tsa6usa+vsa+vsK6ur6ysr62srqursKurr6urraysraurr6ussa6ur6ysr6yssK2t
        r62trKqqraqqrqurrqyrrqyssK2trqysrKqqrqyrraurraqrq6ipqKenqKemqqioqainqaamqaamqaen
        p6Wmo6CgoJ2dn5ycn5ycnZqanZmanJmZm5mZnJqZnZubnZqampiYm5iYm5mYm5eYmpeXm5mZmpaXmZWW
        mZaWmpiYm5mYmpiYl5WVl5WVmZeXmJaWl5WVl5SVmJSVlpOTlJGSk5GRkpGRkpCQlJGRkpCRkI6Pj42N
        kY+OkI6Pj46NjouLjouLjYuLjYmJi4iHi4iIjYmJi4iIiYWFiIWFioeHioiIi4eHioWFiISEh4SEiYeG
        iYaGioWDioaFh4SEh4ODhoOChoKChIKChIKCg4B/gn9/f3x9e3p7fHt8fXx8fXp6e3l5e3l5enp4fHp5
        fHp6fXp6fHh4e3d3eXd2eHZ3eXd4eXV1f3d1gXh1fHZ1eHZ1e3d3hIGBkY+Pn52eqKenp6enp6amqKan
        q6iorKqpqainqKanqaenq6mpq6qqqqmpq6qrq6mq////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////vLi4vLi4vLi4v7y8wb6+
        wLy8v7y8vLm5uba1t7S0uLW1ube2uLe2trS0tbGytLGxs7GwtbGxtrOztrW0tbOzs7Cwsa+vsK2tsa2u
        sq+vs7GwsbCvrqysraqrrqqrsK2tsKysr6usrqysrayrrampr6yrsrCvtLKytLKysK6ur6yssa2ssK2s
        raurrqyssKytsK2usa6usK6tr6ysrqusrqysrKurqqioq6ipraurq6ioqqioqqiqqqipqKampKKioJ2e
        n5ybn5ydoJ2dn52cnpybn52cnpycnZubnJmam5mZnJmZm5iYmpeYm5iYnpqZnZmZnJiZmpiYm5mYm5iY
        mZeYmJaWmpeXmpiYm5qZnJqamJaXlZOTlJGRlZKTlJKSk5GRk5GRk5GRkI+Oj42NkI2OkI6Oj42MkI2N
        kY6OjoyMi4eHi4eGjYmJjYuLjYuKjIiIi4iJjImJjYqKi4mJiYeGh4ODiISEiYaGiIWFiIWFiYaGi4iI
        iYaGhoODhYGCh4ODhoOCgX9/hIGAhIGBfXt8fXx9goCAgH19fHl5e3l5f3x7fXt6fHt7fHp7fXt7e3h4
        dnNzc3Fyc3BxeHR1gXp5gXl2e3V0end3e3h4e3l5eXZ2eHRzgH19kZCQoJ+fqaioqqiorKmoqqinqKan
        qKanqaioqqmpq6uqq6qrq6mqqaioqKamqaeo////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////vru7vbq5u7e4vbu7wcDAwL69v7u7u7i4ube1
        u7i3vLq5vLu6uba2trOytLGxtbGxtrOzt7S0t7S0tbKytLKysrCvsrCvs7GxtLGxtbKysrCwsrCwsq+v
        sa+vsq+vsq+vsa+vsrCvsK2traurq6moq6ems7CuuLa2tbOzsrGxsK6vsa2usa2tsa6usrCwsK2trqqq
        sKyssa2ur62ur6+vsbCwrqytrKiprKiprKqqq6inqqWmqaanqaenqqeoqKempqSjpaGhop6fn5ydn56d
        oaCfoZ6eoJ2en52coZ6enZubnJqanJmZnJiZnZmZnpubnZuam5mYm5iYnJmanZqbmZeXmJWVmJWVm5iY
        nJuampiZmJWWl5SUlpSUlZOTlpOTlJGRlZKSlpSUlJKSkpCQk4+QkY6PkY6Pko+PkpCQj42NjYqKjYqJ
        joqKjouLjYuKjYmJjImJjYuKjoqKjIqKioiIiYaFh4SEiYWFh4ODiISEiYaGioiIiYeHh4ODhoODh4SE
        hoODg4GBiYWDjYeEh4OBg4CAhIGBgX9/gH19gn9+gX5+gH59f318f3x8fXt7fXp7fHp6fXp6eXV1dnR0
        eHV1e3h3fXp6f3t8fXp6eXZ2eHR0eXRycW5tcnBwdXNygX5+kpCQo6CgqqioqqioqaenqKamqaenqqmp
        q6urqqmqqaioqKamqaeoqqmpq6mqq6mp////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////vru7vru7wsDAwb6+wb+/wcDAwsDBwLu7vLi3uLW1vrq6wL++vbu7u7e4
        uba2t7W0trSzuLW1ube2trSzs7Cxs7Cwsq+us6+wtbKztrS0trS0tLGxsrCwsbCvsq+vtbKysrCwsa6u
        sa6usa2ttrOztLSzsK6ttrKxuLa2trOztLKxs7CwsK6usK6usa+vs7Gwsa+vsKyrsa6utLKysq+wsK2u
        r62trqussKytr6usraqqrauqrquqq6moqaanp6Smqaamq6ioq6iopaKjoZ2eoqCfo6Kio5+goJ2do6Cf
        pKGhn52dm5iYnZmZoJ2doJ6enZucm5mZm5mZmZaWm5eXnpucnJqbmJWWm5iYnJmZm5iZmJaXmJWVmZWU
        l5WVl5WVmJWWmJWVl5SUl5SVlZKTlpKTlZKTlZOSk5CRkY6PkI6OkY6Ok5CPkY6Oj4yMkI6NkIyMj4uM
        jYmIi4iIjIiIjIiJjYqKi4iIioeHi4iIioeHiYWFiYeGiYaHiISEiYWFi4eHiYaGh4SEiIWEiISDioWD
        iYSDh4ODhYKChIKBhIGBhIGBgX5+gH19gX59f3x8fXp6fHl5fnt7gH9+f319fHh5fHp6fHl5e3h4fXp6
        fnt7fHl5fnp5fHd2eXZ1dXJzb2xtdHFxenh3d3RzhoOClpSTpKKiqqenqqipqampq6qqrKusq6qrqqio
        qaenqqmpq6mqq6mpqqmorKqqraqq////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////wb6/wb6/xMPCx8XFx8TFxcLDw8DBwr+/vry7vbq5wL6+wb+/vLm5ura3u7i5ube3uLW1t7S0
        uri3uLa1tbOztLGxtLCwtbKytrOztrOztLKys7Cwsq+us7Cwt7Szuba2tbOzsK2tr6urs6+uuba2u7q5
        ube3uba3trOzt7S0t7S0tbKysrCwsrCws7Gxsq+vtLGytLGxs7Gxs7GxtbOztLGxsa6vr62trqysrqys
        rqysr62tr62srqysqqmqqKanqaanrKqqq6qpqKWmpqOjpKKhop+fop6eop6foqCgoZ+fn52dnpubn5yc
        oZ+eoJ6eoJ2dn5ycm5iZmZeWmpiXoJ2doJ6gnpydnJqZm5iYnJiZnZycmpiYl5OUmZaWm5mZm5manJqa
        mpeYl5SVmZaXl5WVl5WVmJaWlpWVkpCQk5CRlZOTl5SUkpGQkY+PkY6NkI2NkI2Nj4yMjouLjYqKjYqJ
        i4eHi4eHjIqKjoyLjImJjYqKjIqJjIiIioaFioeGjYmJi4iIiYaGiYaFh4SEhoKDh4ODhoODhoOChIKB
        g4GBhIGCg4CAgn5+gn9/gn9+fnt6fXl5fnp6gH5+f319f3x8f3x8f3t7fnp5f318gH19fXt7fXp6fXl5
        f3x7e3h3cW1ub2tsdnR0enh3end4eXZ3eXd3hoSEl5WVpqSkrKurraysrKyrqainqKWmqqeoqqioqqmp
        qqmorKqqraqqrKqqrKipq6io////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////wb6+wr6/
        xMLCxsTEx8TEyMTExMLBw8LCwsHBwb++wL6+vru7vLi4u7e3u7e4u7m4uba2uLS0u7e3u7m4uLW1t7S0
        t7S0t7W0t7S0tLCxtbGxtLGxs7Cwt7KyvLm4vLq6t7a2s7Cwsa6usrCvtLGwu7a3vLq7ube4trOzt7S0
        t7a3tLOzs6+utrGxtrS0tbKytbOztbO0srCws6+vtbKyt7SztbKys7GxsK6ur62trqysrKqqrKmqr6us
        rqusq6mqraurrKurq6mqqaanqKWmo6GioZydop2dop+goZ+foJ6dpKCfpKGhpKKhoqCgoZ6eop6eo6Cg
        npubn5ycoZ+eoZ6eoqCgoJ+fnJmYmZaWnpqaoJ+enZycm5ianZubnZuanJubnZucnJqbm5qZnZubm5iY
        m5iYnJqbmJiYl5aVl5SVmpiYmJeXlpSUlJKRko+Pj4yMkY+Oko+Pko+PkpCQkI6Ni4eHioeFjYuKjYqJ
        jImJj4yMjouLjImJjouKjYqKjYqJjYmJioeHiIaFiYaGiISFiISFiIWEhYOCg4GAg4GAhYKChoODhYOC
        hYKChIKBgX9/gH19hICAgn9/f3x8fnx7fnt7gX18g4B+gn9/g4CBf3x8end3fnt7fnx7f3x7fHl5cm9v
        b2xse3h4eXd3eXV2d3Z2cW9wc3Bwe3h4iIWFmJaWp6WmqKamqKamq6qpq6qqqqmpqqmqqqmprKmqrKqq
        rKipq6iorausrausrKmq////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////wb6+wb6+x8PDyMXFx8TFx8TEyMbF
        x8XExcTExcPEw8DBvru8vrq6wLy8vru7vLm5vbq6u7q4ure2vLm4vLm5ure3t7S1uba2ure2uba2trKy
        ubW1u7m5ube3uba2u7i3u7m3trW0tbKytrOzsq+wtLCwuri2vbu7uba2t7W0uLa1t7a2tbKzs6+utrGx
        uLW1uLa1t7W0trO0tbOztLKxtLGxtbCxtrGytbKytLKzsa6vr6usrqysrqysrqurrqqrr62tr66trqur
        rKmqrKmqq6ipqKampaKio5+gop+foqCfo6Ggp6OiqqWjqaWlpqOkop+fop6eo6GgoZ+eo5+fo6CgoZ6e
        oqCfoZ6enZmanZqan5ycn5ydnpubn52enpycnZqanpubnpydnpucnJqampiYmpeYnZqam5mZmJaXmpiY
        m5iYmZeWmZeYl5WVmJaVlpSUkpCQkI6NkY+OkY6Ok5CQkY6PjouLjoqJkIyLjoqLjYqKj4uLjoqKjYqK
        j4yMjoyMjYmKjoqKjoqKjIiJioeGiYWFioeGi4mIiYaGhoODh4SDhYKBh4SEiIWEiIWEhoODhYKChYKC
        hYODg4GBgoB/gn9/gX5+hIGAg4CAgn5/gn9/gX59f3x7gX9+gX5+gX5+gYB/enh4dXJyeXZ2eHV1eXV1
        e3l4dHFydHBxeHV0dXNzcm9wdXFxi4iIm5iZqaenq6mpqqmoqqenqqeoqqmprKqqraqqraqqrausraus
        rKmqqaenqaioqaen////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////xsTDxsTDyMXFysfIysjIycbGyMXGycXGyMXGx8XGx8XF
        w8HBwr+/wb++wL2+vry8vbq6vru6vLm4vLi5u7m4u7i4u7i4u7i4ure2ube2vbm4wb69w8HBv729uri4
        u7i4u7i4trOztrOzt7S0tbKytLGxuLa0ube3ubW2u7m3vLq5uba3tbKytrOzuLW2uLa3uLa2uLW1ubW2
        t7W1trS0trSztrS0tbGytbKytLGys7Cxsq6vs7Gxs7GxsK+ur62tsK2ur62trqyssK2tr6ysr62trqyt
        rKqqqaamp6SlpKKioZ6fpKCfq6ajq6inpKKjn5ycoZ6epKKhpKGhop+foJ2doZ6doqCfo6GgoqCgoZ+e
        oZ+en52doJ2doZ6foJ6fnpycnpubnZubnpubnJiZmpaXmpeYmpiYmZWUmpSUnZqZm5qZl5SUlpOTmJWW
        mZeXmZeXlZOSkpCPkI2NkI6NkI2NkY6OkY2NkY6OkY6OkI2OkIyMj4uLj4yMj42MkI2NjYuLjYqKjouL
        kI2Nj4uMjYqKjIqJjIqJjImJioeHioeHi4iHiYaFiIWEiYWFiYeGioiHh4ODhIGBhYOChoODhoSDhYOC
        hIGBhYOChoODg4CAg39/goB/g4GBgX5+gn9/g4CAg4CAgH5+fHt6eHZ1d3R0enh3gH17fnt6eHV1eHR1
        e3h3e3l5dHNzeHZ1fHp6f3x8jYqKnJqaqKemqqioq6morKqqrausrKurq6qpqqioqqioqaenqaioqaen
        qqiprKmqraur////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////ysjHycjHycbHysbHyMbFyMbGysfIycbGyMTFyMXGysfIx8bGxMHBwb6+wb6+
        wsDAwL29v728vry7v7u6vLm5u7m4wr+9wb69uri4u7i4vru7wsC/w8DBwL29vLu6vLq6ure3uba1t7Oz
        tbCwt7a1trW1s7CxtLCxuLW0vLq5vbu6vLm5ura3uri4u7i4ube3uLa2uLa1uLW1tbKytrOyuba2ubm4
        uLe2t7S0trS0tLOzs7GxtLCwtLKxsbGwsa+wsK2urqytsK6usa6usa6tsa6usK6vrqysrKuqq6ioqKam
        pKGhpKChp6WkpqSjo6GhpKGhpaKio6CgpKGhoZ+foJ6doZ6do6CfoqCgoqCfop+go6CgoqCgo6Gho6Gh
        oJ6fn56en56en52dn5ybnpubnZuanZ2dnZqanZaUnZiWm5mZmpiZmpeYmZaWmJSUmZaWmJaWmJWVlpSU
        lZKSk5CPk5GQko+Pk5CQlJGRk5GRkY6OkY2MkIyMj4yMkI2Nj4yMkI2Mj4yLjouMjoyMj4yMkI6NkI6N
        joyMjouLjYmKi4iHioeHioeGioeGjIiIjImKioiIioeHiYaHiYWGh4SEhYKChIKChYSEiIaGiIWFhoOD
        hYOChoODg4CBgX5/gX9/hIKBhYKCgX9+fHp6fnx7fnt7fXl5f3t7f3x8f319fnp7eHV2cXBwc3Jxenh3
        fnt7fXp6fHl5fXp6gX5+j4yNnZubqqeoq6qqq6qqq6ioqaeoq6iprKqqq6qqq6qpqqiprKmqraurraur
        raurrKqq////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ysjHysjHzMrJycfIycfHysjIycjIycfHx8TFyMXFycbGyMXHx8bGxsTDxMHBxcPCxsXFw8HAwL29v7y8
        v7y7vLq5vru7wb69wLy8uri4vLm5wb69wr+/wb6/v7u8u7m5uri4vLm4vbu6u7e3t7Ozu7i4vbu8tbO0
        s7Cwuba2v729vr28vbu7vru7vbu7vLu6u7m5u7m6ure3ura1uLSzt7S0uLa2uLe2t7W0tbKytbKztrW0
        tLKytbGytLGxsrGvsa+vsa+vr6ytsK6usK6ur62sr6urr6usr62trqysrqysraqpq6enqqenp6alpKKh
        qKWkqqiopKKio6CgpKGgpKGgoZ6dpKCgpqOjpaOjpKGho6GhpKChpKCgpKKho6KioqCgoZ+foZ6foJ2e
        oZ6eoJ+foJ+fn56eop+epKCdoJ2dmpmZnJiZn5ycnJqZmZaWmJWWmZWWmpaXm5iYmJWVlZKSlZKSlZGR
        lpOTmZaXlpOTlJCQko6OkI6NkI2Nj42MkY2NlJCPk4+Pj4yMjoqKjouLkY6OkY6Oj42MjIqJjYmJjYuK
        jYuKjYqKi4iHi4iHiYeHioeHjYqJjoyLioeHiIWFiIWFiYaGh4WFhoSEhYOChYOBh4WEiYaGhYKCgn9/
        gn1+g4CBgoCAfHh4fXl5hYODhYOCg39/f3t7gHx8gX5+eXh4bWxsa2ppcW5ufHp4f3x8gX9/gX9+fXp6
        fHp6fXt7fHp6gH19j42Nnpycq6mpq6ipq6mqraurraqqrKqqq6qqraurraurraurraurrKqqrqyrsKys
        r62s////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////zsvMzsvMzMnLysjI
        zMrKzs3MzMrKycXGycXGycbGyMXFxsPEyMXGycjIyMfGysfHysjIxMPDv7y9v7y8wL29vru7vbu6vbq6
        vbm5vru7wb6+w8C/wb69wL29vru8u7a3vLi4vru7vbm4v7u7vbu7vbq6wL29v729uba2uba1vbq7vru7
        vru7vr28vr29vby7vbu7vLm6vLi5vbq5vLq5ube4uba2ube0t7Szt7S1t7W1uLW1tbOzs7GytrOzt7S0
        tbSzsrGxsa+vrqurrqytr66tr62tr6yssK2tsq+wsa+vr6ysramqrKipqKWmqKWkq6inqaeoo6GipKGg
        paOipaKipKGgpKGgpaOkpqSlp6Skp6alpqSlpaKipKOjpaSkpqOkpKKjo6Cgo6CgpKKipKOjoqCgn5yc
        npubn52dnpydnpucn5ycoJ2dn5ubm5eXmpeYmZiYm5qZnJuam5iWmJKSmZWWmZiYm5mZmZaXlpOTlJKR
        lZKRlZKSk5KSkpCQko+Pko+Oko+OlJGQk5CQjoyMj4yLkpGPj4yMjImJjoqKkI2MkI6Nj42Ni4iJi4eH
        jYmIjYqJjIqKi4mIiomHiYaGiYWGioaGiYaGhYODhYKCh4SDh4WFh4aFh4WEiIOEhIGBg4GAgoCAgX5+
        gHx9hIGBhYOChYOCgoCAgX19fnt7dXN0cm9weXZ1fHh4fnp6gH19gn9/gn9+gH19gH1+f3x8fHl4fHh5
        fHl6fHp5gX9+kI6On52erKqqrKqqrausraurraurraqqraurraysrayrrqyrsKysr62ssK2tsa+vsa6u
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////ysjIz8vMzcvLzcrLz8zMz87OzszMzMjJ
        zMnJzMrKysjIysjIycbHycfHycjHysjIyMXFxMHBw8HBwb+/vru8v7u7wLy7v7y8wr+/x8TExsTEw8DA
        xcLCxcPDwb+/vbi5vru6wb+/wLy8wr6+wcDAwb/Aw8DAxMLCwcC/vry8vry7vrq6vru7vry8vry8vru7
        vbq6vbq6vbq7vbq6vLq6vbu7vLq6ure3uba2uLe2uLa1ube2uLa3trS1t7W1ure2uba2t7S1trKzs7Cw
        sK+vr62trqysraurrqyssK6vsrCwsbCwraqrp6Okp6OkqKWlqKalp6Wlp6SkpqOiqKamp6amo5+go5+e
        pqOhqKWlqKWlp6ampaSkpqOjpaKjpqSlp6WmpqSlpKKio6GhpKOjpaOjpaKipKGhn5ydmpiZnZqZnZqb
        nZubnZqanZqampeXmZeXnJqanJqZnJqam5iYnJiXnZuan52empmZlZKSlZGRlZSTlZKRl5OTl5WUl5WV
        lZOTlZKSlZKRlJKRkpCQkY2Oko+Pk5GQkY2NkIyMko+OkY6NkI2NkI2OjouMj4uKko2MjouLioiIi4eI
        i4iIjImKi4eGioeGioeHh4OEhYGCiIaGiYeGiIaFiYeGh4SEhIOCh4SCiIWEhYKCgn9/gX5+g4CAgHx8
        gn9/g4CAfnx7e3h4gHx9h4OChYKCgn+Agn+Agn9/gX18gH59gX9/gX5+fnt6fnp6fXp6fHh4fHl5fHp6
        fHp6g4GBlJGRo6KirqysraurrKqqraurrqyrrqysr62tsK2tsK2ssK2tsa+vsa6usK2tr66tsK6u////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////ysjIysjIzszLz8zN0M3O0M3OzszNzsvLzsvKzszLzczMzcvMzcvK
        y8jJysjIy8jJycfHyMbGx8TEx8XFxMLCwLy9w7+/x8TDx8XEycjIysfIyMXFxsTDyMXFx8XFxcLCw8HB
        wb+/xMHAxcPCw8DAxMPDxcTFw8LCwcC/wsDAwsDAwL28vry7vry8wL2+v7y8v7y7vru6vru7vbu8u7m5
        vbm6v729vLq6ubW2u7m5uri4t7Oyure3uri5uLe3t7W0uba2uba3ubW1uLS1t7a1trS0tLCwsq6vsK6u
        raysrqyrsa2tsbCxr62trqqnrKinqqioqqenramoraioqqenqainqqiopqOlqKSirKekqqemp6WmpqOk
        pqKjqKSlqKWlp6SlqKanqKampqOko6GhoqCgpKKjp6ampqSln52doJybop2cn5ybnZqanZqanJqanJmZ
        m5eXnJmZnZubnZman5ydnp2dn52coJydnJmalpOTmJSVmZaXlpOTlpKSmJSTmZaWmZaWmJWVl5WVlJKT
        k5CQlJCQk5CQkY6Pk5CPlJGQkpCPk5CPkY2NkI6OkY+PkY+Oj4yMj4uMjoyMjouLjoqLj4uMj4yMioiH
        i4iIioeHioeHioiIiYeGioeHioeHh4SEhoKCiYaFiYaFh4SDhoOCg4GAgn1+g319hYGAhoSDhIOChIKB
        hoKChoKCh4SEhoODhYOEhIKChIGBgn9/gX5+gX9+gX59gHx9gHx8gX59gX5/f3x9fXp6fn19fnt9fHh5
        hYOClZOTo6Cgrqurrqusr6usr62trqurrquqr62tsa6usK2tsK2tr66tsK6usK6tsKyssKyu////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////zMnJzMnJzcrJ0c7O0tDP0M7OzsvMz8rKz8vJz8zLzczMzMrKzcnJzsvLz8zNzcvMy8nJ
        zMnJzMnJycfIyMbGx8PEyMXFysnIzMzLy8rKx8TFxsTEycfHycfHx8PDx8XFyMfGxcPDxMDAxsPDxsPD
        xcLDw8DAwb+/wL29v7u6wb69v7y9v7y8wL29wr++wr+/wb+/wL6+vrq6vru6vru7wL2+wL6/u7i4ura1
        vLm5vbq6u7e2vLq6vLq6uri3ure3uLW2uLa2uLa2uLS0uLW1uLa2uLW1t7S0trS1s7Gwsq6tsK2sr6ur
        s6+utrOwsrCur6yssa2usq6tsKysrqusrKmpqqiorKqrrKqpramorKmpqqmpqqioqKWmqqamq6ioqqip
        qKanqaanp6SlpqSkpKKipaOjp6Wlo6Ghop+epqKhpqKhoZ6doZ+eoqCfoZ6eoZ+fn5ycnpqboJ2doZ6f
        oZ6foJ2dn52doZ6en5ycnZqam5mZnJmZmpeXl5SUmJSUm5eYm5eXl5WUlpSTlpOTlpOSlpSTk5CQkpCQ
        lZORlZKRk5CQlJGRlZKSk5GQk5GRkI6OkI2Nko6OkY6OjYyLjouLkI2Nko+PjouMjIiJjo2Mj42Mi4iJ
        iYWGioeHioeGioaGioeHioeHhoSEhoSEiYSEh4GBhYGAiIWEiYaFhYKChoOCiIWEiIWEg4GBg4GAhYKB
        hoOCiISEiIWGhoOEhYGAhIKBg39/g39/gX5+g4KBhIKCgX5/gH19gH1+fnt8fHl5fHp6e3h4fHh4hoKD
        lZKTpKKirq6trqurraqqrqyrraurrqussK2tr62tr62tsK6tsKyssKyusK6usa6usa2t////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////zcvL
        zcrKzcrL0c/O0tHQ0M7O0M7O0c7O0MzMz8zMzszMzsvLzszMz83Nz8vNzcrLy8nKzMrJzsvLzcvLzMnK
        zMjJycbGysfIy8nIyMXExsPDxsbFysjJy8jIycbGyMXGyMfGxsXDwsDAwr6/x8TEw8DAv7u7wb6+wr+/
        wLy8wb69w8DBwb+/w769wr+9w8HBuLa+kpGwraq3op+0w8C/wr+/wL2+v7y8vru6v7y7v7y9vru7vLu7
        vru7vru6vLm5ure3ube3u7m5ube1uLS0uLW2uLi3ubi4uLa2trKytLCws7Gwsq6ttLCusrGwsK6usa2u
        s7CxsrGxr66tr6ytr6ysraurrayrq6mpqqenraqqraurq6qqqqmoqaamqqenqKenqKamqKWmqaeoqaen
        p6ampaKjpqOkpqOkpqOjpqSjop+hop+gpKKipqSjpaKipaOjo6Ghop+fo5+go6Cfop6eoJ2dn56eoaCf
        op+eoJ6enpycnZuanpubmJWVmJWVm5iYm5qZmJaWlpOTmJSTl5STl5WUlZOSl5STmJWUlpOTlZKSlZKS
        lZKSlpSUko+Pko+PlJGQlJGRkY6Oj42NjouLj4uLkY6Oko+Pj4uLkI6Nj42Mi4eIi4mKi4mIi4iHi4eI
        jIqKioeGh4SFh4SFjISDjYSCiYWEiYeGiIWFhoOCg4CAhoKCiIWFh4SEhIKBhoODh4OBiIOAh4ODh4SE
        iIWEiIWFhoKDg4GAg4GBg4GBg4KCgoCAg3+Ag35/f3x9fnx8fXt6fXp5fXp5gHx8fnx7fHl6h4SFmJWV
        p6Wlrqyrrauqrqusr6ysrqurr62sr6ysr6ysr62ssK6usa6usa2tsbCvsa+usq+v////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////zcvLzcvL0c7P0c7P0tDQ0tHR
        z83Nz83M0c/O0M7O0M3O0MzO0M7Oz87Oz8zNz8zNzcvLzMvLzcrKzcrKzszMzszMy8fIysjIy8jJysbG
        x8HAxcDAx8XFysjJycfHyMXFyMTFx8XExcPDwsHAwb++xcPDw7/AwLy8w8DAxcTExcPDxMHCxMLDxMLC
        w8DAxMHBw8LCiIiuBweEExOIUVGdwb+/w7+9wsC9wcDAv729vry8vry9vbu7urm4vLm6vru8vrq7vbu6
        vbq7vbm6vbq6uba2uba2uba3ube3uLW2trO0t7S0t7OztbOysa+usK6usq+wsa+wsa+vsq+vsbCwsK6t
        sa6usK+vq6mpqaWmraqqrqysqqioqaamqqmoq6ioqaamqaamqaenq6ipq6ipqqioqaanpqOkp6WlqKan
        qKamp6WlpKGipKGipqSkpaOjqaampqSkoZ+eoZ6epKGipKGgpqKhpKGhoJ2doJ6epKOioqGhnZubnZqa
        n5ydnZmZmZaWmpeWmpiYmpmZmpiYm5eXmZaWl5SUmJaWmpeWmJaVlpOTl5OTlpOTlJGRlJKSk5CQk4+P
        lJKSk5GRkpCPkY+OkI2OkI2Nko+PkpCPj4yMkI2NkI2Nj4yMj42NjYyLjImIjYqKjoqKjImJiIaGioaG
        j4eGkIqHioeGiIWFiIWFiYaGiYeHh4SEiIWEi4eHioeGiIaGiISEiISDh4ODhoKDhoODiIWGh4SFhoOD
        hYODhoSFhYKDhIKBg4CAgn5/gH59gH19gn5+gn9+gX9/gH5+fn19fnx8f319fHp6e3h4hoSDl5WVp6am
        r6ysr6urr62tsK6ur62sr62ssK2tsK2tsa+vsbCvsa+usq+vtLKytbGy////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////z8zMz8zM0c7O0MzN09DQ0c/QzMrKy8jIzsrK0M7N
        0tDQ0M3O0M7O0M7O0M3N0M3Nz83Nz87Oz83NzsvLzsvLz8zMzcrLzMnJy8jIysfHzMjIy8fHzMfJysfI
        yMbGysbGycfHycfHyMbGxsTExMLBxsPDxcLDw8DBw8DBxsPDxsPExsTExsPEx8XGxsPEw8DBwb6/bWyk
        BQSEAACDGhqKsa66w767xMG9wsC/wr/AwL29vLm5vLm5vr29wL6/wb6/wL29vr28v729v7y8vru8vLq6
        u7q6u7i6ubW3uba3uLa3uba2ubSztrOys7Kxs7GxtLGysbCwsK6usa6usa6vsa+usK2tr62tq6iorKio
        r6ysr66urKqqramqq6ipq6iorKuqrausq6mqrKurr62srqqprKmpqaipqaeoqKWmqaeoq6ipqqmpqaem
        qqalqqeoq6qpqaiopaOjpKKipqOkpaKjpaOiqKSkpqGgpaGhpaSkoaGgnJqanZqaoJ2dn5ycnpubnJmZ
        m5mZm5mZnJmZm5iZm5iYmpaXmZaXmZaWmJWVmJWVmJWUl5SUlJKSmJSUmZaVlZKRlJGRlZKSk4+PkY+O
        ko+PlJCQk4+Qko6OkI6Nko+Pk5GQk5GQkY6OjouLjoqJjouKjoyMi4iIioaGi4aGjIiIi4iIi4iIioaG
        i4iHjYqKjImJioiHiYeGi4eHjIiIioeIiIWFiYaGioiIioiIiIaGiIWFh4OEhIGChoODiYaGiIWFhICA
        g4CAg4CAg4GAgn9/gn5/goCAg4GBgn+AgH5+gH9/fnx8e3h4fHh4e3l3e3h3fnt8i4mJmJaXqKamsK6t
        sK2tr6yssK2tsa+vsrCwsa+vsrCvs7KxtLKytbGysrCwt7a2uLa3////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////08/Q0c7N0M3N0c7N1dPS09HQzcrKyMbFzMjI0c7O0dDO0tDP0c/P0c7O
        0c/O0c/P0tDP0tDP0c7Oz87Oz83N0c7Oz83NzszMz83Nz8/P0NDPz83Mz8zMz83MzMvLy8nJysjHysjH
        zMvLy8rKyMXGxcLCxcPCx8XFyMTEyMXFyMbHx8bFx8XEyMbGxsTExMHBxMHAd3WpAgKDAACDFRSJsa67
        xcLAxcPBxMHAw7/AwsC/v728wL29wsHBw8HBwb++wL29v729wL69v768vry7vry8vry8vbq7vLm6uri3
        uLW1uLW2uri3trOzsa2us7Cxs7Kysa+vsa6tsrCwsrCxsq6usa6tsK2tsK2urqurr6yssa6usK2trqyr
        rqurrampraurrKurqaanqqenr62tsa6tr6ytrausq6ioq6inqaenqqeoqaemqqenrKmorKuqqKinpqWl
        p6amp6amqKampaKjo6GgpaOipqOjpaOipKOjoZ6enpubn5ycnpqan5ybn5ycnpybnZqanZuanpuanpub
        nJmZm5eYmZeXmZaWmZaXm5iYm5iXmJaVl5SUl5SVmJWWlZKSlJGRk5CQkpCQkY+QlJGRl5KRlpGRk4+P
        kI6OkI2NlJGRlJGSkY6OkI2NjoqKj4yMkI6OkIyMjomHjYmIjYqKjouKjYmJi4eGi4eHjImJjYqKj4mJ
        jYeHi4aGi4iIi4iJiYeHioiIjIqLi4qJioiHioeHiIWFhIGBhIF/h4SCh4SEhYODhIKBhYKChYKChYOD
        g4GBg4GBg4CBgX19gHx9gX5/gH19f3t7fnp6fHl5fXp6f3x8gH1+fnt7fXp6jIqKnZqaqaemsK6tsrGw
        srCwsq+vsq+wtLKxtLKxsq6vsrCwt7a2uLa3tLOytLOytrSz////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////08/Q08/Q1NHR09DQ09DP1NHQ09DP0M3Ny8jHzcnJ09HQ1NTS1NPS09HQ0s/Q09HS0tHR0s/N083L
        0czLz87P0M7P0M7Oz87Oz83Nz83Mz87Nz87Oz83Nz8zM0MzNz83NzMvKzMnJzcrKzczMzcvLy8jJyMXF
        yMXFy8rKy8rJy8nIy8nJycfHx8bFyMbFx8XFyMXFyMfGbGuoAACDAACDGRmLvbvAxsTExMTDxMLCxMDB
        wsHAw8HBw8HCw8HCwsC/wb69wL29wb6+v729vby7vry8v728v7y8vLu7vry8vLu6ura3ura4uri4t7S0
        tLCwtrKztbO0tLGytLGxsrGxsq+vsK6tsbCvsrCwtLKysrCwsKyssK2tr6ytr62tsK2tsK6usK2ur62t
        q6ipqqeorKqpraqrrausrq2trKmoq6inrKqqqqinqaamqaanq6ipqainp6WlpqSkpqOjpaKipqOjpaSk
        oqGgoqCgop+fpKCgpKKhpKGio5+foZ+doJyboJycoJ2doJ2doJ2cn5ycoJycnpybnZqanJmZnJiYm5aX
        mZaWmZiXmpeXmZaWmJWWmZWWmJWVmJWUl5OSlpSTk5GRlJGRl5OSm5WTm5WSmZKRk4+OkpCQlJKSk5CR
        ko6Pk4+PkI2Nj42MkY6Ok42MkYqIjoqJkI6Nj4yMjouLjYqKjYqJjImIjouKj4yMj4uLjomJjYmIjImJ
        i4iIjouLjoyMjIqKioeHi4iIiYeGiYeGiIWFh4SDiISEiISFh4WFhYKDhoKDh4SEh4WEhYODhYKCgn9/
        gX1+gX5+gX9+gX5/gn9/g4CAgX9+gH19f3x8f3t7fnp6fnt7f3x8gX9/j42Nn52crqyrsrCwsa+vtLGy
        tLKxsK6trqursrCvtbOztLOytLOytrSzt7SztLKys7Cw////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////1tLT1tLT1tPU
        19XU1dLS0M3O0c3O0s/P0M3Nz83M1NLS2NbW1dLS09DR09HR1NDR0s/P09DP1NDP0czNz83O0c7P0dDQ
        0M7O0MzMz8zMz8zM0M3N0M3NzsvLz8vLzsvLzcrKzsvLz8zMzsvLzszMzcvLzcrLzMrLy8rKy8vKysjI
        ycbHx8XGxsLDx8LDysfHysjIyMfHV1WgAACDAACDCQmGl5a1yMfHx8XGw8HBwr/Awr+/w8DAxMPCwb+/
        wr6/wr6/wr+/wb++wL6+vbu8vru6v728vru8vrq6v7y7v729vru8vry8vbu7ure3ube3t7W1uLa2trW1
        tbO0trOztLOysrCwsq+vtbGytrO0trSzs7GxsrCws7Cxsq6wsq+wsK6vsK6vsa+wsK6uraqprauqrqyu
        rqytr62tq6moqaenq6iprKioqqenqqioqKamp6Sjp6Skqaamp6WlpKGgpaGhpqSkpaOjpKGhpKGho6Cg
        o6CgpaKipKGhop6eop+eop+foZ+fop+eoJ2coJydoZ2doJ2cnpucnpybnJqanJmZnJmYnZubm5iZl5SV
        mZWWm5iYm5mZmZaWmZeWmZeWl5SUlZKSmJaVl5OTmpWTm5WUmZSUlZKSk5KRk5CRlpGRl5OTlZKSkY6O
        ko6OlI+Oko6NkY6NkIyLjYqKj4yMkI2Nj4yLj4yMj4yMj42NjouLjYmJjYiIjYqKjYuLj4uMj4yMj42N
        joyNi4iJjIiIjIqJiYaHiIWFiYWFiYWGiYWGh4SFhYSEh4WEhoSEhoOEhoSEh4WFhYKCgn9/gX5+goCA
        hYKBhIGChIGBgoCAgX9/f3x8fXp6fnt7gX5+gn9/f35+f319hIGBko+PoJ6fsa2us7Cxsa+urqusr6yr
        sa+us7Gxs7GxtrOyt7SztLKys7CwtLCwtbGxs7Gx////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////09DQ1NHR1tPT1dPS1tTU1NHR0c7O
        z8vMz83Mz8zLzcrK0c/O1tTU1tPT09HS09DQ09HR1dTU1tTV1NHR0c/P09DR09HS0c7P0M3N0c7P0tDQ
        09DQ0s/P0MzN0M3Nz83Oz8zN0M3Nz83Nz83Nzs3NzcvMz83NzszOzMrKy8rKy8jJx8TExsPDx8PEycXG
        ycbGycbHycbHYWCjAACDAACDAgKEnp65x8bHx8XFxcPCw8HBxMHCxMHCxcPDw8HBw8DAw7+/wr6/wr+/
        wb+/wL6+wb28wb69v729v7q5v7u7vru8vbu7vby7vry8vLq6u7i5uri4ubi3t7W1t7S1u7i5ubi4tbS0
        tbKztrKzt7S0tLSztbO0trS0t7S1tbK0s7Gysa+wr62tsq+vsa+vsK2sr62sr62usayts6+vsK6uq6mp
        rKioraiprKipq6ipqqenqaWlqaemqqmoqqiopqOjpKGhpqOjpqOjp6Slp6SkpKKho6CgpaGipKGho6Cf
        oZ6fop+fop6eop6eoZ6eoZ6doZ+en52dnpycnJqanZubnJqanpubn5ubnZubm5qZnJqZnJqZnJmZmpmZ
        mZiYm5eYmpeYmZeXl5WUlpOTlpOTmJaVmZWWl5KTlJGRlpSTl5SUl5WVlpOTlI+PkY2NkY6PkpCRk5CP
        kYyLj4uLko6OkI2NkIyMkIyNkI2NjouKjYqKjYqKj4yMj4yNjoyMjouLjouLj42NjoyMjImJjIiIjIiJ
        ioeHjImJioaHh4SEiISEioWGiYeGiIWFiIWFhoODh4SEiIeGh4aGhIGBhICAhIGBhYKCg4CBgn9/g4GA
        g4GBgH5/f3x8gX9+gn9/g4GBgX5+fXt7fXt7gn9/goGBgYCAkI2NoZ6esK6tr62sr62tsq+vsq+vsq+u
        tLKxtrS0tbKytLCwtbGxs7GxtrOztrKyt7W0////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////09DQ09DQ1tPT19XU1tTT2dbW19TU0MzMzcnJ0M7Nz8vKx8LD
        y8nJ2dnZ2dfX1dTU1dPU1tXW19bW1tTU1dLT1dLS1NLS1NLS0tDR0tDR1NPS1dTU1NLR0s/P0s/P09HR
        0tDQ0tDQz83OzcvMz83Nzs3NzcvMzszNzsvMzcvLzcvLzszMzcrJysfGzMrKzMvLysfIysfHy8nJZGKl
        AACCAACDCwuHiIaxwr/AxMHAyMXEyMXFyMbGx8bGx8TExsPExMHBwr6/w76/xMHBw8LBwsC/wr6+w7+/
        wsC/v729v729vbu7u7i4vLm5vLm6vbq6vLm5vbu7uri4t7S0ubW2u7m5u7m6uba3ube3trS0tLKytLOz
        trS0t7S1t7O0trKztLKys7Gys7Cxsq+usa6usK2tr6ysrqqqsayss7CwsrCwrqurrquqrqyrraqrrKmq
        rKmorKmprKqpq6moqaanqaanqKalqaWkpqOjpqOjp6SkpqSjpaKipqKipqOjpqOjpaGhpKCgo6Cfo6Cf
        o6CfoZ6eoJ6dn52dnpubn5ubn5ycnpycnZqanZqanZubnpycnZubnpuanZmam5mZmZiYmZeXnJmZm5iX
        mJWUmJWVmJWUl5STl5SUlpKSlpOSl5SUmJWVlJOTlJGRlZGRk5CPkY6Ok5CQk5CPkY6Nk4+Pko+Pko+P
        kIyMkIyMkIyMkIyLkIyMkY2NkI2OkY+Pj4yMj42NkI6Nj4uLjouMjoyMjYuMjImJjYqKj42NjoyMioaG
        iYWFioeHioeHi4eHioeHiIaFhoSDh4SEh4SEiIWFh4SEhoKDhIKChIKCg3+AhICAhIGBgX9/gn9+g4GB
        g4GBgX5/gX5+f3t8f3x8gX9/goB/fXt7fXt7fnx8hIGAkpCPn5ydsK2tsa6usK+usrCvtbOzt7S0trOy
        tbKxtbOztrOztrKyt7W0uLa1trOztbGx////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////2tna2tna2tjY2dfW2tfW29jY19TU0c3N0s3N19TT1NLRzMjIzcrK19bW2dfX2NbW
        19XV1tTV1dPT1NHR1tPT19XV1tTU09LR0s7O08/P1dPT1dTT09DR0c7P09HR1NHS0tDQ0dDPz83NzMnK
        zsvMz8zOzszNzczMzcrKzcrLzsvNz83Nz83Nz8zNz87Ozs3NzMvLzcvLzMnJS0ucAACCAACCAACDeHes
        xsLCx8TDycfHycbGyMbFyMbGyMbGx8TFxsPDxMHBxcHCxcLCxcPDw8HBwr/Aw7/AwsDBwb/AwL+/v729
        v7y8v7y9wL29v7y7vru7vbq7vLm6u7i5uri4ubi4uri4ura3uba2uLa2trO0trS0trS0trO0t7OztbGx
        s7GxtLGytbKzs7Cwsq6usq+vsK2tsK2tsK6tr66traqqrqqrr6yrr62sr6ytr6usrqqqrKqprKmqrKmp
        rKmprKmprKmpqqemqaalqKakqaamqKWlpqOjpqOiqKWkqKWlp6SjqKSkpqOjp6SjpKGhoZ6eop6eop+e
        op6eo5+fop+foJ6dn52dnpucnZucnJmanZqan5ybnpubnJmZnJmZnJqZnJmYmZaVl5SUmpaWmpeWmJWU
        lpSTmJWVmJaVmpaXmpWWl5OUlZKSl5WUl5WVl5SSlpORlZKSko+Pk5CPlJGQlJGRkY+OkY2Nko6OkY2N
        kY6OkY6OkY2NkY6Pko6Oko+Pk5CQkY+PkI2OkY6OkI6NkI2NjouLjoyMjYuKjoqKjYqKjIuKi4iIi4eH
        i4iHi4mIiIWGh4OEiYWFioeHiYeGh4OEhYODhYKChYKDhYGChIGBgoB/gn9/hIKBg4GBgH1+gH19g4CA
        hYKChIGCgH19f3x8gX5+hIGChIKCgoGCgYCAhIGCkpCQo6GgsrKxsrCwtLCwt7Ozt7WztrS0trOztrOy
        t7a1uLa1trOztbGxt7S0uLW1ubW2////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        3drb3tzd3Nra2tfW2tbW29nY2dfW1dPS1tPT2NXW2tjY19XU0MvM0s7O2NbW2dfY1tTU1dLT09DQ0tDP
        19TU19XW19XV1dLT0MvL0s3M1dLS1NHS0s/Q0s/Q09DR09DR0c/P0c/P0c7P0s/P0c3O0M3O0M7OzszM
        z8vL0MvM0M3Oz8zNzcvLzszMz8zMzsvMzszMzszLycbKTUydAACCAACCAACCcG+py8rLy8rJycjHysfH
        ysbGycbGyMbGyMXFx8TFx8TEx8XExsTExcLDxsPExMLCwsHAw8HBw8DBwsHAwb++wb6+wr/Aw8HBwb+/
        vry8vru7vry8v76+vry9vLq6u7m4uri4ube4uLa3ube3uLW1uLW2uLa2uLa2tLGxsq+wtLKytLKys6+v
        s6+vtbKxtLKxtLGxs7CwsKysrqyssK6tsa6tsKysr62tr62ssKysrqqqrKipraurrauqraqqq6ioqqen
        qqinrKmoqqWlqqenqqenqKWkqKSjqKSkqKWlqaWmqaWlqKSkp6Skp6OkqKSkpaKhop+fop+fop+foZ6e
        o6CgmZacnpycnZubnpuan5ycnZubnJqanpqanpubm5iYmpaWmZaVmpaWm5iYmZWVmZWVmpeXnJmZnZmZ
        npmZnJiWmpeXmJaWmZaWmpWUmpaVmZWVmJSUlZKRlJCQlJGRlJGRlJCRk5CQko6OkY6NkpCPko6Oko6O
        k4+Pk5CQkpCPkY+PkY6Pko2OkY2LkY2MkI2NjImJioeGi4eHjomKjoyMj42MjoqKjYuLjIqKioaHiYWG
        ioeIiYeHiYWFiIWEh4SEiISEh4ODh4OEhIKCg4GBhIKChICAhICBg39/hICBhIGChYKCg4GBg4GBg4B/
        g4CAhYKChYOEhIKCg4CBgoCAgX9/gX9/h4SFk5CSn5ycs6+vt7W1t7OztLGxtbOztrS0tbKytrKytrSz
        t7S0uLW1ubW2uba3u7i5ube3////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////3drb3drb3tzc3Nra29jZ
        29jZ29nZ2tjX2NXV2tfX29jZ29nZ3Nva2NXU0c3N1dPT2dfY2NfX2NfW1tTU1dLS19XU19XU19XU19TV
        1NHQ1dLQ1tPT1NHS09HR1NDQ1NLS1NLS1NLS1NHR1tPT2NbX19XV1NHR0tDQ0c/P0c/P0tDP0c/P0M3N
        z8zMz83Nz83NzcrLzsvLz8zMycfKUlKfAACCAACCAACCUFCey8nKysfIycbGycfGysjHy8jHysfHx8XE
        xsPEx8XFyMbFyMXFxsTExsTDyMXFxsXExsXExcLCw8HBxMLBwsDAwb6+wb6/wr/Awb2+wL69v769v72+
        v729vbq6vLq6vLq6urm5uri4ure4ure4uri4urm5uLa3t7S1trKztLOytbKytLCwtLGwtLKytLGytLGx
        t7OzuLOytbOys7Kxs6+vs7CwsLCvsK6tsKussKyssKysr62srqurrampq6ioqqamq6inq6ioqqenq6eo
        rKmoqqemqaamqqenqqioq6ioqaamqKWkqaalqqemp6WlpaKjo6Cfo6Cgo5+foZ6emJWbXVyKMTB7goCT
        n5ucnpucnpubnZqZoJycnpucmpeXmpaVnZmYnJmZnJqZnJmYm5eYmpeXmpeWnZqaoJybn5uYm5iXmpeX
        mJWUmJSUmJWVmpeXmZaWl5SUlZGRlpKSlpKRlJCRk5CQk5CPk5CPlJGRlJCPk4+Pk5GQko+Pk5CPlJGP
        lZKRk5CQko2Nko6PkI6OjImIioeGi4mIjImKkIyMkI2Nj4uMjoyNjoyNjYqKjImIioeHiIWGiYWFiIWF
        ioeGiYaFiIWFiIWFiIWGhYKDhYKChICAhIGBhYKCh4SEh4OEhIGBhIKChoODhYODg4GAg4GAg4CAhYKC
        hYODg4GCgoCAgn9/gH1+fnt8fHl5hIGBl5SVqKSltrOytrS0tLCwtLCwtrS0t7W1t7W2ube3ure3uba3
        u7i5ube3uba2ure3u7m3////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////zs3N39zd3dvb3Nra3Nra3Nva3Nvb3Nra29jY
        3NrZ3dvb29nb3drb3dvb1tPTz8vL0tDQ2dfX2djX2NfW2NbW19XW2NXV2NXV19PT2NTU2NbW1tXV1NLS
        09HQ0s/P1tTT2dfX19XV1tTU1tTU2NbX19XV3tra3NnZ2NbW1NLS0c/P0M7O0M/O0M7O0M7O0M7P0MzM
        0c7O0c7Oz8zMVVWgAACBAACCAACCQUGayMXJysjIysfHysfIysjJy8nJysjHyMbGycfHysjJysbHycfH
        x8bFxcLCyMXFx8TFxsHCx8TExsPExcPDxMLBwr++wr+/xMHBxMLDwb/Av729vbq6vLm6vry8vry9vLq6
        ure3vbq7vby7vLu6vLq7u7q7ubm6ube3uba2uLW2ubW1uLS0trOzs7Cxsa6utbKyubW0u7ayuLSztbO0
        tbKytbKytLKyr66usKytsa2tsa2tr6ysrqursKurr6urraqprKiorKmprKinrKmoqqemqqemrKioraqq
        raurq6ioqaamqaalqqenp6SkpqOip6OjpqOjpKGhpaKilpOcREODEBByAABtGxt1jImYop+foZ+foZ2e
        oJ2dn52dnZqanZmZnZmYnZqZnpubn5ubnpqanJqZnpuan5yboJ6dnpycnJiZm5iYmpaWmJSTmZaWmZaW
        l5WVlpOTlpOSlpOTlpOTlZGSlJGRk5CQlI+PlJGQlZGRl5OSlJKSkY6QlJCOmZWQmZWPlpGPk4+Pk4+Q
        kpCQkY6NkY6NkI2MjouLj4uMkIyNjouLjYuLj4yMkI6NjoyMjImJi4aHioeHiYeHiIWFiIaFiIaFiYaH
        ioeHiYWFhYKChIGBhIGChYODhoOChoKDhoWFh4WFh4SEh4SEh4WFg4GAgn+Ag4GCgoGAgX5+gn+BgoCA
        gH9+gX9+gH5+f35+gH5+gX1+iYaFmJaXp6SltbCwuLS0uba3uba2uba3u7i3vLi4vLm6ure4uba2ure3
        u7m3u7i3u7m5u7q5////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////zs3Nzs3N393e3trb3dnZ3tvb3tzd3dzc3dzc3t3d393d3dzb2tjW2NTU
        2tbW2dbW0c3Mz8zL09LR0c3N08/P29nZ29na2tjY2NXV19PU2tfW2tjY2NbW19TT1dPT1tPU1dHT0M/P
        zMvM1tTU1tTU////////3tra3NnZ2NbW3Nrb2NXW1NLS09LR0s/P0c/P0c7P0s/P0tDQ0tDPzsvMVlWg
        AACBAACBAACBMTCUv77HzMrKzMrKzcrLy8jJzMnKzMnJy8jJy8jIy8fHysfHycfHxsPDxMDBxsTDyMbG
        yMbGyMbGycbGyMbGxsTExMHBxsTDxsTDxcTDxcTExMLCwcDAwL6/wr/AwsDBv76+vLq6wL6+wsC/v7y7
        vru7vbu9vLy9vLu8vLm5vLm5uri5uri4uba1t7S0trOzuLW0ure2ure3uba3t7W2t7S0uLSyt7OzsrCw
        sK6usrCvs6+vsq+vsK6tsKyrr6yrr6ysr6ysrqurrquprampraqprKmorKiprKmprqyrrKmpqqioq6ip
        rKipqqemp6Sjp6OjpqKioZ6hfXqWMTB+AABuAABuAABtAABtHBx2eXeTo6CgoZ2en5ycoJ2do5+foZ6d
        n5ycn5ycnpubn5ubn5uboJuboZ6doZ6eoJydn5ucnJmZnpuanJmYmpaWm5eXm5mYmJWVmJSTmpWVmZaW
        mJWVl5SUlZGRlZCQlZCQlpKSlZKRlpOTlJGRk5CRl5OSmpSRmpaTmJWTlpWVlJKTk5GRkpCQlJGRk46P
        kY2NkY6OkIyNj4yMkIyNkI2Mj4yMjouLi4iIi4iIjImJjIiJi4eHiYaGiYaGiYaFiYeHiYeGh4SEhYOD
        h4SEiISEhoSDhYKChoODhoODhIGBhoODiIWFhoSDhIKDhYKDhIGAgn9/g4CAhYKDg4KBhIKChIKCg4GB
        gX5+gH19goCAgH9+f319iYaHm5iZrKmqt7W1uLa2u7e3vLm5u7e3uba2uri4vLq7u7m5u7i3u7m5u7q5
        u7i4u7q5vLq6////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////4N7d4N7d4N/f39zd4Nvb4N7d393d39zd3tvb29rZ3dzc3tra3NjV2dXU19PV3NrZ1tPSz8vK
        0s7O19TU2tfY29na29jY3NrZ2tjY19TT2dXU29fY2tjY2dbW19XV2tfY1dLTtrS0zMvM////////////
        ////////////////3Nrb2NXW3Nra19TU09DQ0s/P0c3O0M3O0c7P0c7P0MvMY2ClAACBAACBAACBKimQ
        x8bKzszMz8zMz8zMzsvLzsvLzszMzcrLzMjIy8jHzMnJy8jIx8TFxsXFyMbGysjHysnJycbHyMTEyMTE
        x8XFyMbHycbGx8TDxMLCxsTExsTDxMLCw8HCwsDAwb/Avr2+vrq7wL28wb+/wL29vbq6v7y8vru9vbu8
        vLm6u7i4ube4uLW2ura2ure2vLi3vLi4ure4uba3t7W1ube2uri3uLa1t7OztrKys7Gws7GwtbGxtbKy
        tLGxsa2tsq6usq6usK2sr6yrr6yrr6yssa2tsKysrKmprKioraqqraurq6mqrKmprKmorampq6ioqKWl
        pqKkYV+PIB95AABvAABvAABuAABuAABuAABtFxZ1c3KTo6GgoJ2dpKChpqSjpKGhoZ+eo5+eoJybn52d
        n5ycoJuboJ2coJ6en5ydnpqanZqanpybnpuanJmZnZqZm5iXm5eWm5iWnZmYnZmZm5mZl5SUlZGQlZKR
        lpOSlpOTmJWUlpSUlZKRl5SUmJWUmZWUmJaXmJeXlpOUlpOTko6Oko+PlZGRk4+QkY6Pko+Pko+Pko+Q
        k5CRkY6OkY6PkY6Pj4yMjYqJjYqLj4qKkIyMjoqLi4iJioeHioaGiYeHiIWGi4iJjYyLjIiIiIaGhoSE
        hoKCh4ODhYKDhICBh4SEiIWFiYWGiIWFhoODhYGChoKDhoKDhYODg4GBgoCAg4GBhIGCg4GCg4KCg4KB
        g4GAgoCAgH1+f3t8iYaGnJmZr6urubW1uLa2ube2ura2u7i5u7i5u7m5vLq6u7m6u7i4u7q5vLq6ube2
        u7i3uri4////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////zs3O4N7e
        4N/f4d/f4d/f393d393c39zc3tra2dbV3NjZ39vb39zb3tzc3Nna393d2tjY19TU2NXU29nY3Nna2tjY
        29jY3NnZ2tnZ2NXU2tXU2dXW2NbX2NbX2dbX2NbW2tjYtrS0////////////////////////////////
        ////////3Nra19TU1NHR1NDQ0M/Pz87P0M3O0s3N0M3OU1KfAACAAACBAACBFRWJt7bE0M3O0c7Oz8zM
        zszMz83Nz8vLzsrKy8nJy8nJzMvKzszMzMnJy8jHzcrIzMnJysfHycfHx8TDx8LBycXEycbHyMXGx8TE
        xsPDxcPDxsPCxcHBw7/Awb+/v7y8vbu8v729v7y8vr29wL6/v7y8vbq6vbu8u7m6vLi4vbi3vbi2uLW1
        uLW1u7a2ura2ube4ure4uba2t7S1uLa2u7m5uLe3trOztbKytbKyt7OytrKytrOztLGys7CwtLCvs7Gw
        sa6usa6usK6ur6ysr6yrsK2tsa6ur6ytr6yssKyrsKurraqpq6iorKmpq6ipmJWiSEeIAQFwAABwAABw
        AABvAABvAABvAABuAABuAABtAABtXV2MpqKjqKWlqaiopaOjpKCfpqKhpaGfop+eop+foZ6eop+foZ6e
        npubnZqanpubnpubnZqanpubnpuanJiYnZmYnpuanJmZnJiYm5iYm5eXmZaWl5STl5OTmZaVmZaWlpOT
        mZWVm5iWmZaVmJWVmJWWlpSUlpOUmJaVl5WUlpOTl5WUlpOTlZKRk5KRkpGQkpCQlJKRk5CQk5CQkY+P
        kY6Pko+PkI2OkI2NjouMjYqKjYqKjYqKjYqKjYqKjouMj4yMjIqKi4iIioeHh4aFiIaGiYeHiYiIiISF
        iIeHiIWHiISFh4SEh4SFiIWFhoODhoODhoGChoKChIGBg4CAhYKDhoOFhIKDhIODhYODhIODg4KCgX5+
        gX19f3x9gH5+jYqKnpubsK6uure4vLe5u7i5vLu6vbu7u7i5ure4u7i5uri4ube2u7i3uri4u7i4vrq5
        vrm5////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////zs3Ozs3O4N7f4uDg4+Hh4uDh4N3d
        4N3d39zc3trb3trb39zc39zd3t3e397d39zd3tzd3dvc3tzc3NjX1tHQ08/P2NbV29jY2NXV1dPT1NLR
        1tPS2dXW2tfY29jY19TVy8jJuLe3uLe3////////////////////////////////////39zb39zb2dfW
        1tPT1NHR09LS0tLS09DQ08/P0dDQZWSnAACAAACAAACBAACBn5y70czN09DP0M3NzszN0M3Oz8zL0MzL
        zczLy8rKzczLz83Nz8zLzcjFzMjFzMnJycbHycfIycfHyMXFyMXEycXGyMbGyMbGyMbFxsTDx8LDxsLD
        xMDBxcHBwr+/vry9wb+/wL6/v76+wb+/wb69v7y8v76/vry9vLi4wbu6w726vru5uba3ubW2uba1uba2
        uba2uba2uba3uLa3uba3uLW2t7S1t7S0t7KyubSzuLOztbKytLKys7Gxs7CwsrCwsq+wsq+vs6+wsK6u
        rqyrsq6ts7CxsrCxsq+vtK2ss6yrsa2tr6ytrqurgX6bNjSCAABxAABxAABxAABwAABwAABvAABvAABv
        AABuAABuAABuCwpwU1KJm5mhp6Slp6Slp6SjqqenqKSjpqKgpKGhpKGhpaGgpaCgop+foZ+foJ2cn5qb
        nZqan5uboJycnZqanpubn5ycnZqam5eXnJiYnZqanZqam5eXm5aWnJiYm5iYmZWWmpaXmpaVl5SSmJWU
        mZaWmZaVmJaVmpmYm5qZmpmZmJaXl5OUlpKSlpWTlZOTlJKSlJKRlJCQkYuMjImJjYuLko+PlJGRkY+P
        jo2NjYqKj4uKkY6OkI2Oko+QmpiYnpqblJGRkY6OjouLioiIjImKjYqKjIqJjImJioiIiYiJiYaHiYaH
        i4mJioeHh4SEhoOEiIOEh4OEiISFhYKDhYKDhIKCg4GChIGDg4GChIKDhYSEhIKBgn5/gX6AgH1+gH59
        gH19fnx8jYuMoZ+ftLCxvLq7vLq6vLm5vLi4u7i4vLi4u7i4vLi4u7e4u7i4vrq5vrm5uri3ura2////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////4N7e4N7e4d/g4+Hh4+Dg4d7f4d/e4d/f4t/f4N7f4t/g
        4uDg4N7e3dvc3NrZ3dra3dnZ4Nzb4d/d3drZ1s/P0szL09DP09HQ09DP19TU09DQ0M3M2dfX3t3d3dra
        1NHSsK6vuLe3////////////////////////////////////////////39zb29nY1NLT1NLT1NHR1NHS
        1NPT1NLS1NLSbmyqAACAAACAAACABgaCoZ680c3N0s7O0c7P0c7P0c/P0M7O0c7O0M3OzsvLzsvLz8vM
        zsrKzsrJzcnHzcvKy8nJysfHysjIycjIycfHysfIycfHx8XFyMXFyMXGyMXFx8PDxcLCxcLCxMPCw8HB
        xcLDxMPDwsHAwr6+wb29wL6+wL6/wL6/wLy7w8C/xcG/w727v7u7vLm6vbq5vbi4u7e3u7i5uri4uba3
        uLW1ubW2u7e3ure3uba2uLW1uLS0tbGytbOytLKxs6+ws7CxtLCwtLCwtLCwsq+vsq+utrKxtbGwsq6v
        tLCwtK+ttK+usq+vsa2ur6ytJyZ/AAByAAByAABxAABxAABxAABwAABwAABwAABvAABvAABvAABuAABu
        AABtOTh/mpWcp6OkqqenrKqprKemqaOip6KhpaKhpaKhpqKhpqSjpKGhop+foJ2doZ6doJybnpqZnpub
        npycnpycnZmZnJmZnZmZnpqbnJmZm5eXnJiYnZmYnZmYnZmZm5eXmJWUmJSTmZWVnJmam5mZm5iXmZaX
        mpiYmpiYmZaWl5OUl5SUmJaVmJaWlpSVlpOTl5OTko6OjouKj4yMkI2OkY6Ok5CQkY+PkY+Qko6Pk4+Q
        jYqLi4mKmpiYnpqblJGRqaWlnpubk5CRjoqKjoqJjYmJi4eIjIiIi4mIi4mJjYuLjo2NioiIiISFiYaH
        iIaHhoOEh4OEh4SEg4CAg3+AhIOChYKDg4CBgn5/g4CBg4GBg4CBhICBgn9/gH1+gX5/f319gH9/gX9/
        gH5+j42OoZ+ftLGxvbq6vbm5vLi3u7i3vLm4u7i4vLm5vrq7vbu5uri3ura2ura3uri3vLq5////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////2NbW5OLh5eLj4+Dg4d7e4d3d4d7e4d7e4+Hh5OPj4d/f4N3d4t/f4N7e3dra
        3tra3tnY4NzY4eDd4eDg29fX1c7N0s7M0c7O1tPU3tvb1NLRzcnJ2dfV39/e3tzd1tTUsK6v////////
        ////////////////////////////////////////2tnZ2tnZ1tXV1dPU1NHS1NDR1dPT1dLS1dPTZmWn
        AQF/AACAAACACAiDh4Wz0tHQ0c/P0s/Q09HQ0c/P0M3Oz83N0c3O0M3O0M3Nz8vKzcrKz83Oz83NzcvK
        zcvLzcnJysfHycfHysjIy8jJysbHx8TEx8PCyMbHycfGyMXDyMTExsTEw8HBxcPDyMbHx8bGxMLBwr+/
        wsDBwL6+wLu6wr28xMHAxsTDxsLBxL68wry7wL29v7y7wLu7v7y7vry8uri4uLW1ure3u7i5u7e4u7e3
        uri5ubi5uLa3t7S0trOzt7SztrKytrKytrOxtLGwtLCwsq6utLCwt7OytrKxsq+vtLGxtbGwtLGwsa6u
        rqursKytWFeQAABzAAByAAByAAByAABxAABxAABxAABwAABwAABvAABvAABvAABuAABuAQFuJiZ6gX6W
        qKOkq6emrKinq6alqKOipaKipaKipqKipaKipKKio6Cgop+foZ6eoZ2dn5ubnpuanpqanJqZnpqanZqZ
        nZmZnZiYnJmYm5iXnJqYnJiXnJiWnpqZnJiXm5eXmpiXm5iXnJmZnJqam5iZmZaXmpaXm5eYm5iYnJqZ
        m5mYmpiYmJWWmJSVmJaWmpiXlZSTlJKSlpOUlJKTkI6PkY6Pko+PlJGSk4+QkY2OjYqLi4mK////////
        ////qaWlrKmpl5SVjYmJjoqKjYqKjIuKjImJjIiIi4iIjImJioiIiYaHiYaGi4mKiYiIh4SEiIWFh4WF
        hIGBhH+AhoOChYOChoOChIGCg4GBg4GBg4GAhIGBhIGBhICCgoCAgX9/gH5+goCAgn+AgoCAgoCAgX5/
        ko+PpqOjtrSyvLm5vbq5vbu7vLm6u7m5u7m5uri3ura2ura3uri3vLq5ure2uba1u7i4////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        2NbW2NbW5eTl5eLi5OHh4uDg4N7e4d7e4Nzc4d7e5OLi4N7e3dra4eDf5OPi4d7f393d4N7d4d3b4Nzb
        4N/f393c2tbV2NXU2tjX3dra3NnZzcvLysbG29jX3dvb1tTUysjIysjI////////////////////////
        ////////////////////////3tvc3tvc1tTV1dPU1dLT1dPT1tPT1dLT09HTbm2rAgKAAAB/AACAAACA
        eXet1dPS0tHR09HQ1NLR0tDQ0c/P0c/O0M7O0c7O0c/Oz8zMzsvL0M7N0M7OzcvKzcrKz8vMzcnKzMnJ
        y8nJzMnJysbGyMXFyMTEyMXFyMbFycbFy8jIycfHxcLCxsPDx8bFx8TEw8DBwsDBw8LDw8DAw767xb69
        xMC/xsHBxcHAxL+9wry7vrq6vru7v7u7wL28vry8vLm5uba1u7i3u7i5ure4vLi4vLe3urm5uLe3uLa2
        uba1ura2ure2ubW0t7SztLKxtLGws7CvtbKytrOztLGxtLGxs7GxtLGxtLCws7Cwsa6usK2tko+jBgZ1
        AABzAAByAAByAAByAABxAABxAABxAABwAABwAABwAABvAABvAABvAABuAABuExNzgHyYqKSlqaamqqal
        qaWkp6SkpqOkp6Ojp6SkpqOjpaKio56eop6eo6CgpKKioqCeoZ2coJycn5ycn5ybnZqanZmZnZqZnZqZ
        nJiYnZqZnpuaoJ2cnZuanJmZm5iXmpeWmpeWm5iZnpqbnZybnJqbnZmbm5mam5qZnZubmZiYl5SUmJWV
        mpeXmZeWmJaWk5GTlJGSmZeWmJeXlJKTk5CRlZGQkY6KkY2O////////////////////////rKmpl5OT
        j4uMjouMkI6PkZGQjoyMjoqLj4uLjIiJiYWGiYSFi4eHi4iHi4iIioiIi4mIi4iIh4WFh4WFh4SEh4OD
        h4ODhYODhIKChYODhoSEhoSEhYODhYODhIKDgX+Ag4GBhYOEhYOEg4KChIKCg4CBgH5+gX9/goCAlJGR
        p6SkuLa2u7i5uri3vbi4vLm5vbq6vbq6vbi4ure3ure2uba1u7i4vLi4vLq6vbu7////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////5eLj5eLj5ePj5OLi
        5OHh5OLj4+Lh4+Dg4d7f4t/f5OLi5OLi4uHh4+Lh4+Hh4uDh4d/g4d/f49/d4Nza3tra39zd4N7e4N7e
        4N7d393d3NnY09DP087O4Nzc2tjXure3ysjI////////////////////////////////////////////
        ////////3dna3dna1tPU1tPT1dPU1tPU1tPT1dPT1NLTgH6xAAB/AAB/AAB/AQF/VlSg1tLT1dPT1NTS
        09DQ0c3N09HQ09HR0c/Pz8zLz8zK0MzM0M3O0M7Oz8zMz8zLz8zMz8zL0M7Oz8zNzsvLzcrKzMnIysjH
        y8jIy8fHysfHy8nJy8rKycbIx8PFyMXGycbGyMTFxMHCxMHCxcPDxsPDxcLBx8LBx8HBxL/Aw8DAw7+9
        wb28vru7vru8v7y8v7y8v7y7vbq6vLi4u7i4vbq7v729paKyv7q5vLq5vLm6u7m4u7m4uba3uLW1uLW0
        uLW1uLS1trOytrOytrOytLKxtbKyt7S0tbKytLGws7CwtLCxtLCxsa6urqurQ0KKAABzAABzAABzAABy
        AAByAAByAABxAABxAABxAABwAABwAABvAABvAABvAABuAABuDAtyZGOQn56kqaamqaalqKWlqaamqqip
        qqmoqqimqKalpqGhpaGfp6Wlp6Skp6ShpqOhpKCfoZ2coJ6doZ6doZ2dnpybnJmYnpqZoZ6dop+foZ+e
        n56dnpycmpeYm5eWoZ2cop+foZ6en52cnpubnpubnJqanpubnZmbm5eYmpeXm5iYnJmZnZmanJiYlJGS
        kI2OlZKRmZeWl5WVl5OVmpWSkIyIkIyI////////////////////////nZuanZuakpCQjouLkIyNkY6P
        kI2Nj4yMkY6NkIyNjYmKjImKjYqLjYqJi4iHi4iIjIqJjYqKi4iJiIaGiIWFiYSFiYaGh4SEh4SFh4SG
        h4WFh4SEh4WGhoWFhIODhIKCg4CBgX9/gn+Ag4CBg4GAhYKCg4CBgX5/fnx8f3t8gX5+g4KClZOTqKSj
        uLS0vbq6vru6vbq6vbi4ura2ubW2ura2u7e3vLi4vLq6vbu7vry8vru7vru7////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////29jZ5eLi5OLi5OLi5eLi5uPj5eTk5OLh
        4+Dg4+Dh5OHh5OLi4+Dh4+Dh4uDg4eDg4+Dh49/g5OHg4+Hf4d/f4uDg4d/e4N7e4t/g4N3d3dra3tzb
        4N7e393dz8zMure3////////////////////////////////////////////////////////4d/g3Nra
        2NbW1tXV19XV19TV19TV1tTU1tTUfXuxAwN/AAB/AAB/AAB/REOa2NXV1tTU1dPT1NDO083N1NHS09DR
        0c7P0MzMz8zLz83M0M7O0M/P0M7P0M7N0c/Nz83M0M7O0M7OzsrLzcrJzcvLzcvMzcrLzszMz83LzcvK
        ysjIyMXFycfHysnIysjIycXHxsTFxsLCxsLCxsLCxsLCx8TDx8TExMPCwsHBwr+/wr6+wb69wL29wsDA
        wb+/wb++wsC/v7q5rKixhYOqUE6YHx+Fk4+rvrq4vrq6vbu7vbq7vbq7u7m6uri3ure3vLi4ure2uLW1
        uba2t7S0t7W1uLW1tbGxtrGxtLGxtLCxs7Cws7Cvsq+vkI6jBgV2AABzAABzAABzAAByAAByAAByAABx
        AABxAABxAABwAABwAABwAABvAABvAABvAABuBgZwSEiGqqWorKioqqenqaamqaemqqenqqanqqamqqal
        qaWkp6SjqaWlqqakqaWkpaGho5+fop+fo6GgoqCfoJydoJycoZ6do6Cfop+fop+foJ6dn52doJ6fn5yc
        pKGfqaamqKWlpKChpqKip6Skqaamraqqqaeno6Khn5ydnpqaoZ2eqKSlq6emoZ+dmJaVlZOTl5WVlpSU
        lZGRmpWSmpaVmpaV////////////////////////oZ+goZ+gkpCRj4yMkY2Nko+PkY6Pj4yMkY6Ok5CR
        kY+Pj42NkI6PjYyMjImIjIiIjYmJjImJioeIiYeIioeHiYWGiYaHi4qJioiIiIWHh4WFh4WGiIWHiIeG
        h4aFiIaGhIKCgX5/g4CBgoCAgn+AhYGCgoCBfnx7fnx7f3x8gn6AhIGBg4CAgn+AhoWFl5SVqKWluLW0
        ure2u7i3vLm5vrq6vbm5vrq6v728wL29vry8vru7vru7ure3tbOztLKx////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////29jZ29jZ5ePj5OLi5eLj5+Tk6ebl5uPk4uDg4uDf5OHh5OLi5OHi
        5OHh5uPi5eLj4+Dh4+Hh4d/f39zc4Nzc4N7e4N/f4d/f4d/g4d7f39ra4d3d5OHi4+Hg3NnZvbu6vbu6
        ////////////////////////////////////////////////////4d/g4d/g29ja2NXW1tTU2NbV2NXW
        19XV19XV2NbWiIe2CAeBAAB+AAB+AAB/KyuQxsTO19XV19PU1tLR1dHR1NLT0s/Q0tDQ1NTT1dTU0c/O
        z8rJ0c7N0tDQ0M3N0c/Oz83Mz8zM0M3Nz8vLzcvLzczMy8rLzcrLz8vK0c7Lz8zLy8jIyMbGycfHycbG
        ycbGysfHyMXGxsLDxcDBxsLBxsPCxsTDx8XFxsPEw8DBxcHBxcLCw8DAwr+/wr+/wsC/uLW8n5yzbWqh
        KCeKFRWDAAB8AAB8WVaZvLe5v7u6vru8vry9v7q6v7m4vrm4vbm4vbm4u7m5ure4u7e4uba2trOzuLW1
        t7S1uLSztrKxtLCws7Cws7GwtbGxtbGxPj2JAAB0AAB0AABzAABzAABzAAByAAByAAByAABxAABxAABx
        AABwAABwAABvAABvAABvAABuAABuMzKAjYufrKqpq6ioqaWmq6enq6enqqWlq6emqqamqKSlqaWmq6en
        q6emqKWmpaKipaKio6Ghop+eo56do6CgpaKipKCgop+fpKCgpaGhpKGhqKampaOjnpubqaamqKWlsq+x
        pqKip6Skqaamraqqqaent7S0q6inop+eoZ2eqKSlq6emoZ+ds7Gwp6WmnZqcl5WWlZGR////mpaV////
        ////////////////////////oZ6fmZaXlJGRk5GQk5CPk4+Pk4+PkY2NkY6Oko+QkI6NkI2NkY6PkY+P
        kI6OkY+PkI6OjoyNi4mKjIiJjIiIiYaGhoSFioiIjYyLi4iJiYeIiIeIiYeIiIWGiIaHiYaHiIWGiIaF
        iYeIiIWGhYKDhYOEg4KCgX9/g4KAg4CAgn5/hIGChIGCgoCBgYCAgn+Ag4KBhoWElpSUqqemvbq5wL28
        v7y7vru6v7q6v7u7vbu7vbu7vbq5ure3tbOztLKxuri4vrq6wLu6////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////5+Pj5+Pj5+Tk5+Tl6OXl6OXl5uPj5uHj4+Dh4d/f4+Hh5ePj5+Pj5+Pi5+Xk5+Tl5eLj
        4+Li4uDg4N3e4t/g4+Hi4d/g4N7f4N3e3tzc29nX39zc4t/g4Nzc08/Ovbu6////////////////////
        ////////////////////////////////////////4d/g3tvc2NXW19XW2dfX2tfY2tjY2dbW2NbVlJS6
        AAB+AAB+AAB+AAB+EBCFwb3J1tTU19TV2NXV19XU19PT1tLT1tPU19bW19bW1NDP0czK08/N09HR09HR
        09HQ0c7O0M7N0MzMz8vLz8zLzsvKy8jIzMrJzcrIzcnIzsrLzcrKzcrKzcrLy8fIy8jIycjHycbGxsPE
        xcPDx8TDyMTExcPDxsLDxsPExcHBx8LCx8TDxMHBw8DAsKy5fnunQD6TIyKKAAB9AAB9AAB9AAB9Bwd+
        OjiQure8v7u9v729wb+/wby6wbq3wbu7v7u7u7i4ure3vLi3u7e3uba3t7Ozt7SzuLa1uLWzubW0uba0
        trSztLCvtbGxtrSzhYKhBwd2AAB0AAB0AABzAABzAABzAAByAAByAAByAABxAABxAABxAABwAABwAABw
        AABvAABvAABvAABuIiJ6fXuYramprampraqprKqpqqenq6enq6ioqqenqqemq6inrampqaenpqOjpaGh
        paChpaKhpaKhp6SkpqOjpKGhpqOiqKWkr6urs7GwqKampaOjnpub////////sq+x////////////////
        ////t7S0q6inop+e////////////////s7Gwp6Wmr6ytl5WWlZGRmpWS////////////////////////
        ////oZ6foZ6fl5OUlpKTlpSUk5GRko+Pko2Nko6Oko6Oko+PkpCQkY6PkY2OkY+Qk5KTk5OSk5KRj46O
        jouNjoqLj4yMjYyLioiIi4iJjYyMj4yMjYuLi4qKi4mJjImKioiJioeHiIWGiIeHioiIjImKioiJh4WF
        hoSFhoOEiISFhIGBg4CAhIGChIGCg4CAhIGChIGBhIKCg4GBf319gH5+iIaGmZWWraqqu7i4u7a2vbi4
        vbu6vbu6vbm5uba2trSztrO0uri4vrq6wLu6wLy8wL29v7y8////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////4d/f
        5+Tk6ebm6efm6efn6Obm5+Pj5+Pj6Obm5OLj5eLj5uPk5+Pj5+Tj6OTk5+Tk5uPi5eLh5ePj5uXl5uXl
        5ePj4+Hh4N3e3tzc3dva29nY3tva4N3d29fXycXEycXE////////////////////////////////////
        ////////////////////////4uDg3tzc29jZ29jZ29ra29rb3Nra29nY2NbVjo23AgJ+AAB9AAB+AAB+
        HBuIv7rG19PT2NbW2dfX2NXV1tPT19XU1tTU1tLS1tLS1NLR1NLR1dLS1NHR1NLS1NHR09LQ09HR0s7P
        0c7O0s/P0c3Mz8vLzsvKzsvKzcrLz8zN0c7O0c7Nz83My8nJy8nJysjIysfHysfHyMbFycbFyMTFx8PE
        xsPDxcPCxcHBxsPDvLrAmpmzUE+aMzKQAAB+AwN/AAB+AAB+AAB9AAB9IyOJW1qcmZexwsDAwL2+v7y8
        wb+/xMHAw8G9wr+/wb6/vry8vbm5vbm4u7i3ubW1uba1ubW1uLW0uba1u7i3vLm5uLW1t7KztrOztrOz
        qqeuHBt+AAB1AAB0AAB0AAB0AABzAABzAABzAAByAAByAAByAABxAABxAABxAABwAABwAABvAABvAABv
        AABuAABuYV+PrquqsKysraqpqqenqKWlrKiorqupraqnrKinqqanqqemqKWkpqKiqKOkqaenqqmnrKmp
        rqqrpaKio5+fqKWkr6urs7Gw////////////////////////////////////////////////////////
        ////////////////////////r6yt////////////////////////////////////////sq+vsq+vp6Wl
        nZubmJWWlJKSkZCPkpCQkY6Pk5CPlJKSlZOTk5GRko6Oj4yMkI2OkpCQkpCPkY+OkIyMkIyNkY6PkpCQ
        kI6OjoyMjYqKjYuLjYuLjIqKjYqLjoyLjImKioeHiYeHiIeHiYiIiYiIioiJiIaGhoOEh4SEiISFhoOE
        hIKDhYODhIGChYKDh4SFhYODhIKDhYKEgH1+fnx8gX5+fnt8fnt8iIWGm5iXraqqv7u6wL29wb69v7u7
        vrq7u7i4ure3ura3vbq6wLy8wL29v7y8w7/AxMC/wL29////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////4d/f4d/f6Obm6ufn6efm6ebm
        6ebm6ebm6efm6efm6OXm5+Tk5uXl5eLi5uTk6OXk5+Lg5ODf5eLi5+Tl5+fm5OLi4+Df4d/f4d/g4N3d
        3NjY3tra4+Hh3tvb2NXUzcrKzcrK////////////////////////////////////////////////////
        ////4uDg4uDg3dvc3Nna3dra3tvc3dvb29nZ29ra2tjZo6DADw+DAAB9AAB9AAB+CQmCpKG92NXU2tjY
        2tfY19TV1NLS1NPS1tTT19LT1dLS1NLS1dPU1tTV1dHS1dDR1NDQ1NLR1NLS1NDR09DQ09HQ0tHQ09DQ
        0c7O0c3O0M3O0M7P0c/Q0M7OzszMysnIysfGy8jIzMnKzMjJy8fGysfGycfHyMXFx8XExcLBpaG3cG6m
        QUGWAAB/BQWBAAB/AAB/AAB/AAB+BweADAyCX16fqKW2vbm9w7/Aw8DAwb69v7u7wb6+xMLDw8LBwb++
        wb6+wsDAwL6+vru7vLm4u7i4u7i4vLi5vLm4vLq5vLq5ure3uLS1uba2ube2t7S0t7OzYF6VAAB1AAB1
        AAB0AAB0AAB0AABzAABzAABzAAByAAByAAByAABxAABxAABxAABwAABwAABwAABvAABvAABvCgpyTUyI
        oJykr6uqraqoqKWkq6ensK2ssK2rrquqq6eorKioqqenrKmpr6ysr6usramprKmprqqrtbGxo5+f////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////sq+vsrCvoJ6dmJaVlpSUlJOT
        lpSUlZKTlJGRlpKSlJGRk5CQk5CPkY2NkI2Nko+QlJCRk5CQko+Pko+QlJKSko+QkY2OjouLjoqKjYqL
        j4yMjYqLjImJjIqKjImKi4mJjIqKjYuLiomJiYiIioiIioeHiIWFiIWGioiIiYeHh4WFhoWFhoWFhoSE
        iIWGhoODhIODhIKDhIKCg4CAgoCAgH5+fHp6f3t7gX9+fXx8hYOCm5iXsa2twb++wL6+vry8uri5t7W2
        u7m6v72+vbq8v7u9w7/AxMC/wL29wLy8vrq4vru5////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////6efo6efo6efn6ebm6ebm6uXk6ubl6efo6ujo5+Tk
        5uPj6OXl5+Xl5uPj5uTk5+bl5uHf5d/e5eLi5eLj5OLi5ODh49/f4d7e4+Li4+Hh3tva4d3e5+Xk19TV
        x8PDzcrK////////////////////////////////////////////////////////////39zd39zd3drb
        3drb3Nra3dvc3dvb29nZ29rb3Nrbq6nFAgJ9AAB9AAB9AAB9AwN+lZO52dfX29nZ2dbW19XV1tXV1dTU
        2NXV2NbW1tTT09HS1NHT1dPT1tLS1tPT09HR09DQ1NHS09HQ0s/O0s7O0tDQ0tDQ0s/Q09HR0s/P0c7O
        0M7OzszNzsvMzcnKzMjIzcrJzMrKy8jJy8jIy8jJy8nIu7nBh4WuXlygFRWHDQyEAACAAACAAACAAAB/
        AAB/AAB/JyeMXFqcpKG0x8TDyMbDx8TDxcHCxMDAxMHAwr6/wr6+wb6+wL29wL28wL29wL6+v7y9vrq6
        vbu6vby8vLq7vbm6v7y7v7y6vbq5uLW0uLW1ube3ure2ure2uLW1ramxHRyAAAB1AAB1AAB1AAB0AAB0
        AAB0AABzAABzAABzAAByAAByAAByAABxAABxAABxAABwAABwAABvAABvAABvAABuJCN6joygsa6traqo
        rqursK2usq6tsa2pr6yqr6usqKampqOkr6ysr6usramp////////tbGxo5+f////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////srCvnJmZmZaWmZaWmZaWmZeWmZaXlpKUlZKR
        lZGRlJCRlpOSlZSTlpSUlpOTk5CRkY+Qk5GRlJKSkZCQkY6PkI2NkI2NkI2NkY2OkI2Oj42NjYyLjYqL
        jouMjIqLjYuLjouMjYqLjImKjYyMjY2Mjo2Mi4uLioiJiYaGiYaGiYiHiYeHh4WFiIaGiIWGg3+Afn18
        gH5+hIGChYKDhIKCgH5+gX9+gX9+cnBxcXBvfXt6gX+AiYeInJmZsK2svbq4vbq6vbu6vLm3vLm5vbu6
        ure3ure2vru7wLy8vrq4vru5xMDBw7+/xcPE////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////5ePi6+jo6ujn6Obm5+Xk6ubk6+fm6+nq6efo5+Xm5+Xk6Ofm5uTl5OLj
        5ePk5uPk5uPj5uPj5eLi4+Dh5ODi5OLj4uHh4+Dg5ePj5eTk4+Li5OLh4uDfyMXGx8PD////////////
        ////////////////////////////////////////////////////4N7f39zd4N3e3t3e3Nzb3Nva3Nvb
        3dva3tra3drbqajFERGDAAB8AAB9AAB9BAR/eniv29nY29rZ2NbW2NXV2tjX2dfW19XV19TV1tPU1dPT
        1tTT1dPS1tTS1tXU1NHS1dPT2NbW1tTT0tDP0c7O1tPT09DQ0c7O09DQ1NHR1NDR09HR0c/O0M3Nz8zM
        z8zM0MzMzsvLzMrKysnKnJq4bmyoGBiJFRSIAACBAACBAACBAACAAACAAACAAACADw+EVlWco6G4xcLB
        xMHBx8TFycbFycXCxsPBxsPDxsPExMLCwb6+wb29wb6+wr++wLy8v7y7wLu7v7u7v7y7vLq6u7m5vrq5
        v7q4v7u5vbq5ure2ube3uba2uLS0ure2ube2uLW1ZmSZAQF2AAB1AAB1AAB1AAB0AAB0AAB0AABzAABz
        AABzAAByAAByAAByAABxAABxAABxAABwAABwAABwAABvAABvAQFvHx95c3GYraqrsq6utK+vs66ssKyp
        r6yqrauqmJWUpqOk////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////oqCfoqCfm5mYmpeXmpeYmZaWmJaWmJeWl5WVlpWVlpOTl5OTl5SUl5aW
        mJaWlpSUkY6OkIyNlJOTkY+Pi4eIkY6Ok5CQkpCQk5KRkpGRkI6Oj42NkI6OjouMkI2Nj4yMjYqKjouM
        jYyNjoyMjYuMjYyMjYyMjYyMi4mJioeIioeHioiIiYiIiIeIioeHioaHg3+Afnx8fXt8fnx+g4GChYKD
        hIGBg4KBg4GBfHp6e3l4gX9/goCAgH9/gH5/gH5/jYuLoqChtrS0w8LAwcHAxMPDxcPCxcTDx8XFyMbE
        xsTCxcPDxMDBw7+/xcPExsPExMHCxcLC////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////5ePi5ePi7Orq7Ono6ufn6efn6Obm6ufn6+np6ebn5+Tl5+Xl5uXk5+Xm5ePk5uPk5OLi5OLi5uTk
        5uPj5uPj5uPk5OLj4t/g5OLi5uTk5uPi5OLi5uPj393euri4uri4////////////////////////////
        ////////////////////////////////4N7f4N7f4N7f4N3e4N3d393d3tvc29na3dra3dvY3NnZwL7P
        GBiGAAB8AAB8AAB8AAB9YWGn3dvb3dzb2tjY2NTV2NbX2NbW2NXV19TV19TU2NbV2dfW19TV2NbW2NfW
        19bV2tnZ2NbW3tvb2dXW2NXV2dfX2NXV19TU19TU1NHR1NHR1NLR09HR0dDQ0tDQ0tDQz83OrarBiomz
        REOaICCNAACCAACCAACCAACBAACBAACBAACBAgKBDAyETkybnJqzu7i/x8PEyMTEycbFysbGy8bEysXC
        x8PAxcPCx8XFxMLCw8DAw8DAw8DAw8DAw8HAwr++wLy9wL28wLy6vrm4vbm4vru5vbm4vrm6v7u7vrq6
        v7y7vLm5ura3ube3ube2uLW1o6CtDQ16AAB2AAB2AAB1AAB1AAB1AAB0AAB0AAB0AABzAABzAABzAABy
        AAByAAByAABxAABxAABwAABwAABwAABvAABvAABvAABuS0qJpKGps7CvtbOytLKysK2usKysmJWUpqOk
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////s6+voJ2dmpeWmZaWmpeYmpiYmpeXmZaXmJaWlpSVmJOUl5STlpSSlpKRlpKSlpSTlpSTl5SU
        l5eXkZCQjomKlZKTl5aVlZOTk5KTkpGRkI+OkZCQkI2OjoqLkI2NkY6PkIyNkI2Oj46Ojo2NjYqLi4iJ
        jYqLjYuMjoyMjYyMjoyMjIuLi4mLioiJioiIiomJhoSEhIGChoSFgoKDfn6AhIOEhoSEhYODhIKChoSE
        hYODg3+AgX5/gX9/gn+Agn9/gYB/gH5/gX5/j42NoqGhtrW2xMLDw8HCw8DBxMC/xMDBw8LDw8DBxMHB
        xcLExsPExMHCxcLCwr6+w8DBxMLC////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////6+jp6+jp6+np
        6+jo6+np6+rq6Obm6ebm6ufn6efn6Obm5+Tk5uPk5uXl5uPl6Obm5+bm5OPk5uTk5+Tk5uTk5eXk5eLj
        5+Lk5+Xl5+bl5ePj5eLj5uTl2tjZuri4////////////////////////////////////////////////
        ////////////////4Nzc4Nzc4uDg4N/f397e4N3e4N3e3tvc3drb3Nra29ravLrNAQF7AAB8AAB8AAB8
        AAB8RkWb0s7V3dra29jY2dXX2NbX2NbW2dfX2dfX2NbX2djX2dfX2tfY2tfY19XW0M7O2tnZ////3tvb
        2dXW2NXV2dfX2NXV4uDg397d2tjX1dLS09HR09HR0dDQvLvHk5G5U1KhLS2TAACDAgKEAACCAACCAACC
        AACCAACCAACBAACBHh6LUU+dlpO1y8jHysfIysbGycXGx8XFyMXFycbFy8jHysjIxsPDxcHBx8TDxMHB
        w8HBxMLCw7+/w7+/xsPDxcLCxMDAxMHBw8C/wb69wb28v7q6v7u7v7y9wL6+wb69wb69vbu6uba2u7i4
        uri5ura3ubS1Pz6MAAB2AAB2AAB2AAB1AAB1AAB1AAB0AAB0AAB0AABzAABzAABzAAByAAByAAByAABx
        AABxAABxAABwAABwAABwAABvAABvBQVxMC9/iYagtLOztra2sa6wsKys////pqOk////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////s6+vs6+vqqam
        op6enpqanJiYmpaWm5eXnJmampeXmJSUmJWVl5WUlZOSl5OTmJSUmJSVmJWVmJaWmJaWmJaXlpSUlZOT
        lpSUlZOUk5GSko+Qk5CQlJKTk4+Qj4uKj4yNkI2OkI2Oko+PkI6OjoyNj4yNj42Nj4yOj4yOj42Nj46O
        j4+PjIuLioeIjYqLjYyMjYyLiIeIgoCCiIWHi4uLh4aHgoKChYOEh4SFhoSEhoSEhYKCg3+AgoGBhYSE
        hoODhIKCg4CCg4CCg4CAhIGAgX9/gH5+j42Mo6Cht7O0wr6+wsDAwr7Awb7AxMPDw8LDwr/AwL++wb6+
        wr6+w8DBxMLCxMLCxcLExsTF////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////5OPj6enp6+rq6+np6+nq6ujp6efn
        6ujo6+jo6ufo6ujp6efo6efo5+fm6Ofn6ujo6+jp6Obm5+Tk6Obl6Obm5uTk5ePj6ebm6ujo6Obm5uTk
        5uTl5ePkzMvLzMvL////////////////////////////////////////////////////////////////
        4d7d4d7d2tbW3dra4N7e4d/e4N/f3dzc3Nna3tzc3t3dwsDQICCJAAB7AAB7AAB8AAB8LSyP3dvb3NrZ
        3Nra3Nna29jZ2tjY29jZ2tfX2dbX2djY2tjY3NnZ2tfY19XW0M7O////////////////////////////
        4uDg5eTk3tzc2NXVx8TMvLrIZmWpQD+aAACDAQGDAACDAACDAACDAACDAACCAACCAACCBQWEBweFXFqi
        op65v7zDzMjHzMjHzMjHysfHycbGycfGyMXFyMbGysnJycnJxMLDw7/AxsTDyMXExMLBwb+/wr+/w8DA
        xcLCxcHBxcHBxcLBxMLBw8LBxMHBwr6/wb6+wb29wL29v729v729vbu6ure2u7e2vLm5vLm5vbm4mJWr
        BQV5AAB3AAB2AAB2AAB2AAB1AAB1AAB1AAB0AAB0AAB0AABzAABzAABzAAByAAByAAByAABxAABxAABw
        AABwAABwAABvAABvAABvBARwZWSPkI6Psa6w////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////s6+vqqamop6es66uq6empKCf
        oJ2dnZubmZaWmZWVm5iXmpeYmZWWmJWVmZaXlpOUlpKTlZKSl5SVmZaXmJWVlZKSlpKUlZKTk5CQkpCR
        k5GRlJGRlJGRkpCQkY+Pko+PkpCQkpGQkpGRk5GSk5GSkpGRkI2Oj4yNjoyMjoyNkI2OjYqLjImJjouM
        j42NjouMjYuMhYSFg4GDioiIioiHhIKChoOEh4WFh4SEiIWFhoWEhYODhIKDhIODhIKChYGChoSFh4aG
        hYSEhYOEhYOEg4CBgX+AgX5/goCAkpCRpaOkura3w7/AwsHBwcDAwLy9wb6+w8HBwr7Awr6+xMHBxMLC
        xcLExsTFx8XFxsXF////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////5OPj5OPj6ejo6ujo6efn6+jo6ejn6efo6ufo6ebm6ujo6ujp
        6ujo6ujp6uno6efn5+Xn5+Tm6OXl6Obm6ejo6ejo5+Xm5+Tl5+bm6Obm5+Tk5uTk6Ofn4+Hivby8vby8
        ////////////////////////////////////////////////////////////////////4d7d2dXV2tXW
        4N3d4uDg397e3Nrb3dvb393d393d3NrcICCIAAB7AAB7AAB7AAB8IyOLxcPR3Nva3NnZ29jZ2tjY29jZ
        3Nna3Nrb3Nra3Nna3Nra3NnZ////////////////////////////////////////////5eTkxMLScnGw
        VFOjCgqGAwODAACDAACDAACDAACDAACDAACDAACDAACDAACDISGOWFahqae/zsvMzsrLzMrKzcrKzcnJ
        zMjHzMnIy8jIy8fHysfGy8jHzsvLzMrMysfIyMXEx8XEysjHyMbFw8DAwb+/w8DAxMHBxcHBxMG/wr++
        w7+/xMHBw8HBxMDBxMHBxMDAw7+/wL6+v728vbm5u7i4vLi3vbm4vbq6vry6u7m5QUCNAAB3AAB3AAB2
        AAB2AAB2AAB1AAB1AAB1AAB0AAB0AAB0AABzAABzAABzAAByAAByAAByAABxAABxAABxAABwAABwAABw
        AABvAABvCwtykI6P////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////s66uq6empKCfs7CuqqemoZ+enpyc
        nJqampeYmpaXmpeXl5SVlpOUlZKSlZGQlJGRl5SVmJaWmJWVlpOTlpOUl5SUmJWVlZOUk5GRlJGRlJKU
        lZOUlZOSlZOSk5KTk5GSkY+PkY6OkY6PkI2OkY+PkI6OkIyNkI6PkY+Qj4yMjoqLjIqLjouMkI2NjIuL
        hISGhYSFiYeGiIaFh4SFhYODhoSEhoOEh4WFh4WFiIWGh4WFh4WEg4GBg4CBhYOEhIODhYSFh4WGhYKD
        g4GBg4GBgX9/gH5/f3x9fnx9kI+PpaKjuLW0wL27wLy8wsDBwsHCw7+/xcDAxcLDxcLDx8PFx8XFxsXF
        x8bGyMPCycK/////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////6ujo6ujo6ufo6Obm6eXn6ebm5+Tk5+Xl6OXm6Obm6uno6efo5+Tl6eXm6ubn6ebn
        5+Xl5uPk5uTk6Ofm6ujo6ebo6OXn6Obn5+bm5+bm5uTl5+Tk6Obl3Nnavby8////////////////////
        ////////////////////////////////////////////////5OPj5OPj4d7f39zd4d7e4uDg4N7e4dze
        4t/g4N7e3tzcy8nVISCJAAB6AAB7AAB7AAB7AgJ8ubfL3Nrb3drb3dra3dvb3Nvb3tzc3t3d3Nra3Nna
        3Nra////////////////////////////////////////////////////xMLSAACCAACCAACCAACCAACC
        AACDAACDAACDAACDAACDAACDDw+IYmGmoJ680M3Nz8zMzsvLzsvMzsrLzsvLzsvLzcrJzcrJzcvLy8nK
        zMnK0MvJ0czK0M3L0M3Jz8vJzcnKy8jKy8nJy8nJycbGyMTDysfGyMXExMHAwr6+w8DAxMHBw8C/xMDB
        xsLCxcHBxcLBw8LBwr++wL69v728vru7ure4u7i4vbq6vru7fn2lAAB3AAB3AAB3AAB3AAB2AAB2AAB2
        AAB1AAB1AAB1AAB0AAB0AAB0AABzAABzAABzAAByAAByAAByAABxAABxAABwAABwAABwAABvAABvAABv
        AABv////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////s7CuqqemoZ+esq6wqaamoZ6enJmZmpaX
        l5SVlpSUmJaVmJWVmZSTmJKTmZWWmZeWlpSTl5SUmZaWmZaXmZiYl5aWlZKTlZKTlpWVlZOUlZKTlpSV
        kI6Oi4mIjouKko+Rko+QkpCQkpCQko+PkY+PkI6OjoyLjouLjIqLjouLkI2Nj46OjYyNhoaIhoWGioiI
        iYeHh4aFh4aGh4OEh4OFiIaGiYaGiYaHiIWGhoSDhIGChIODhIKChYKDhYODhYOChYOEg4KCg4CAgX9/
        gH5/gH5/gX9/gH5/gX5/k5GRp6Sjuba3w8HCxMLCxMDAxcHCxsLExsLDx8PFxsXHx8bGyMPCycK/xMHC
        xMHBxMHB////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        4t/f5+Xl6OXl5+Xl6eXm6OXn5+Tl6eXm6Obn6Ofn6ebm6Obn6ebn6+fo6ujo6ebn6Obm6Obm6Obm6ujn
        6+jp6ebo6Obm6Ofn6ufn6ujo6ejo6unp5+TkzszMzszM////////////////////////////////////
        ////////////////////////////////6OXm5eLj5uPj5OLi4uDg4d/f4d7f4+Dg4+Hh4uDg4d/e3tzd
        QUGYAAB6AAB6AAB6AAB7Dg6BqKbF3tvb4Nzc4Nzd4d/f4N/f3tzc3t3d////////////////////////
        ////////////////////////////AACAAACAAACBAACBAACBAACBAACCAACCAACCAACCAACCAACDAACD
        BweFS0qeuLfGzcvN0s7O0c3N0MzMz8zLz83N0MzNz8vLz8zLzszMz8rLz8zMzszNz8vN0s3M0s/K0tDJ
        0dDH0cvI0cvMzcrKzcrKzMrLzMnKzMnHy8jGyMbEyMTEyMTEx8TExcLCxcHAx8TDx8TExsHCxMHBxcLC
        xMLBwsHAwb+/wLy9vLq7vLm5vrq6vru7ZGKbAQF4AAB4AAB3AAB3AAB3AAB2AAB2AAB2AAB1DQ16FxZ9
        AAB0AAB0AAB0AABzAABzAABzAAByAAByAAByAABxAABxAABxAABwAABwAABwAABvAABvAABv////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////sq6wu7a2rquqoqCgnJiYmZWWm5mYnJmZnJqa
        nJiXmpWVmJSVmpiYmJWVmJWWlpSUl5aWmpeYmpiYmJWWmJaWl5aVlZKTlpSUlZOUkY+Pj42Mko+Qk5GS
        lJKTk5GRlJKSk5CQko6PjoqKjIqJkI6OkI2OkI2NjoyMjo2NkI2NjIqKiIaHi4iIi4iJioiIioiIi4eJ
        i4eIiYeHiIaGhoOEiIWGioeIiYaGhYODhoSFhoSFhYODhYODhoSEhIGChIKChIKCgoCBgoCBgoCAgoCB
        goCBgYCAgX9/gn+AlZGTq6envbq7w8HBxcLDxMDBw7+/w8HBxsLDxMLCxMLCxMHCxMHBxMHBxcPDxcPD
        xcLC////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////4t/f4t/f5+Tl5+Xl6OXl
        6Obm6Obn6efn6ebn6ebn6efo6ubo6ubo6ufo6+jp6+rq6ujo6ufo6+jp6unp6+np6+jp6ujp6ujo6efn
        6ubn6+jn6unp7Ovr5+Xlv72+v72+////////////////////////////////////////////////////
        ////////////6OXm6OXm5uTk5eHi4t/f4uDg4t/g4d7e4N7e4eDg4+Li49/g4d/fQkKXAAB5AAB6AAB6
        AAB6AwN8ioi44t7e4t7d4N3e4d/f4N/f////////////////////////////////////////////////
        AAB/AAB/AACAAACAAACAAACBAACBAACBAACBAACBAACCAACCAACCAACCGRiLQkGbjIq309DP0s/O0c/O
        0c3N0c3N0c7O0M3N0c7O0M7Oz8zMz8zN0M3O0s7N08/L087L0s7L09DL0c/Lz83K0tHJ0c3Jz8rH0c/J
        z83IyMTFx8PEy8nIycXFx8TDyMfGyMbFyMbFx8TExsPCxsXEx8XEx8TDxcHBxcPCxMLCv729v7y7wL29
        wL6+wb6+wLy8uLW4WlmYAAB4AAB4AAB4AAB3AAB3AAB3AAB3AAB2AAB2AwN3cW+dLy6GAAB1AAB0AAB0
        AAB0AABzAABzAABzAAByAAByAAByAABxAABxAABwAABwAABwAABvAABvAABvAABu////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////u7a2ure3qqmopqOjoJ2dnZuanpubnZqanJqampiYmZeXmZeY
        m5eZmJWWlpWUl5WWmZaXmJaWmZiYmZiXmJSUl5OUmJeXlpWVlZOTl5WWlZSVlJGSlZKTlZKSlJGRlJKS
        k5KSkpCQkI2OkY6Pko+QkY6OkIyMjouMjouMjouLjouLjImKi4mKioiIi4iIi4qKjIuLiomJh4aGh4aG
        iIaHioeIiIaGhoOEh4SGh4aGhIODhoWFh4WGhICChYODg4GCg4GBg4KCg4GCgn+AhIGBhIKCgX+AgH1+
        gH19gH19fnt9k5CRrKurwL2+wr+/wb29wLu8wb6/xcPExMLCwr6+w8HBxcPDxcPDxcLCyMTFx8TEx8TE
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////6ebn6ebn6ebn5+Tl5eHi5uTl6Obm6+np6ejo
        6Obm6ebn6ebn6ebn6ujp6ujp6ujo6ufn6eXm6+jo7erq7erq6+jp6efo6unp6+jq6ufo6efn6ebn6ebn
        39zdv72+////////////////////////////////////////////////////////////////////////
        6OXm6Obn5OPj4+Dg5OHh5OLi4d7f4N7e4t/f4+Dh4+Dh19XbSUmaAAB5AAB5AAB6AAB6AAB6cXCt4+Dg
        4t7d4N3e////////////////////////////////////////////AAB+AAB+AAB+AAB/AAB/AACAAACA
        AACAAACAAACAAACBAACBAACBAACBAwOCBgaET06fmpi7wr3J1NHR09HR0s/Q0c7O0c3N0s7P0s/Q0c3O
        0czM0s7O0c7O0MzO0s7L1dLK1dPK1dHL1NLJ09LIz8zJzMnK0M7K0c/Lz8zI0c/I0M7IysbFyMTFycfG
        ycbHycbGycbGxsLCxsPCyMTExcLBxcPCx8TEx8TDxMLBxMLCxMLCwb2+wb29wL6+wLy8wb6+wb++s7G5
        OjmOAAB5AQF5AAB4AAB4AAB4AAB3AAB3AAB3AAB2AAB2YWCZvLm5b2ycIyKBAQF1AAB0AAB0AABzAABz
        AABzAAByAAByAAByAABxAABxAABxAABwAABwAABwAABvAABuAABv////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////ure3qqmotrS0qKamnpubnJmZnZqam5iYm5iYnJmanJmampeYl5SUmZaWmpiZ
        mJaXmZaXmZiYmJaWlZGSlpOTmJaWmZeXl5WVlpSVl5WUlpOUlpOUlZKTlZKSlJSTlJOSlJKTlZOUkpCR
        kY6PkI2NkY6NkY6PkI+PjoyNjImKjYqLjIqKi4mJi4iJioiIiomJioiJioeIioiIiIeHiIWGh4WFh4WG
        iIaGhoSEhoSEhoWFh4WFhoOEh4SFhYSEhIKChYODhIODg4CBg4CBhYKDhIKChIGCgoGBgH9/fHl6fXp6
        f359g4CBmJWVraqqvru6wLy8wb6+wL6+wr29xcLCx8PDxsPCx8TEyMTFx8TEx8TEycTGysbHy8fJ////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////4N7e6OXl6efm5+Xl5eLi5OHi5ePj5+Xl6ebn6Ofn6Ofn5+Tk5+Tk
        6efn5uTk5+Tk6efm6+jo6+jn6ufm6ufn6+rq6+np6ujp6ujo6ufn6OXm6efn5uTkz83Nz83N////////
        ////////////////////////////////////////////////////////////////6Obn6Obn5uTl5eLj
        5ePj5ePi4+Hh5OHh5eHi4+Li4+Pj3tzeXFuiAAB4AAB5AAB5AAB5AAB6UE+c4+Dg////////////////
        ////////////////////////AAB9AAB9AAB9AAB+AAB+AAB+AAB/AAB/AAB/AAB/AACAAACAAACAAACA
        AACBAACBGhqLTEygmpq91dLS1NHR1NHQ08/P0tDQ09DQ1dLR0tDO0s/PvrzIq6nAko+2vrrH0c3P0c7O
        1dLM1tXK1tbQ1tXS1dTM1NLJ0czKzsrKz8nIz8nJzsrKzsrKzcrIzMnHy8nIycfGycbFy8fHy8jHycXF
        yMPDyMTDxsTDxsTDx8TExsLCxcLBxMLBw8HAwsC/wsDAwr+/wb29wb++w8C/tLC6KiqJAAB5AAB5AQF5
        AAB4AAB4AAB4AAB3AAB3AAB3AAB3BQV4paKwu7i3lpOrQD+MAAB1AAB0AAB0AAB0AABzAABzAABzAABy
        AAByAAByAABxAABxAABwAABwAABwAABvAABvAABv////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////trS0uLa2q6iopaKin5ycmJSVnJiYoZ+en52dnJqam5iYnpubnZuampiYmZeXm5qamZeY
        lZGSlpOTmZeYmJeWmJeWmJaWmZaVmZaWlpWVl5WVlZOTlZKSlZKSlJGRko+Qko+QkY6Nko6NkZCQkZCQ
        j46Oi4iIi4iJjYqLjYqLjImJjIqKjIiJjImJi4eIioeHiYeIiIaHiYeHiYiIiYeHh4WGhoSEhoOEh4WF
        hoWFh4WFiIWGh4WGh4WFhoSFhoSEhYOEhIKCgoCAg4GCg4KCg4OCgH9/fnt7fnt7goB/g39+gH18e3t8
        g4GCmZWVq6iowL29w7+/xsTEx8PEx8PEx8TDyMTFyMbGycbGycTGysbHy8fJy8fIysfHyMXG////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////4N7e4N7e5ePj6Obm6efn5+bm5uPk5OHi5eLi5uPk5ePk5uTk5+Tk5ePj5uTk5uPj5uLj6ebm
        6+jp7Ojo6ufn6efo6efp6ebn6ufn6+jp6+np6ujo7evr5uPkv72+v72+////////////////////////
        ////////////////////////////////////////////////6unp6unp5+Xl5eHh5ODg5uLh5eLi5eLi
        4uDg397d4+Hg5OHiXl6kAAB4AAB4AAB5AAB5AAB5UE+c////////////////////////////////AAB8
        AAB8AAB8AAB9AAB9AAB9AAB+AAB+AAB+AAB+AAB/AAB/AAB/AAB/AACAAACAAACAAACB////GhqL1tPZ
        2dbV1dPT1NHR1NHQ1NHQ1NHR1NHR1NLR09HQ1NDPdXOtDQ2IFBOKZ2Wo1NHR1tPT19XT19bO19XO19PP
        1tTO1dXN1dTQ1NLR0c7N0MzLzsvLzcjIysbFy8jGzcrJzMnIzcfGzsjHzcnIysjHysfGycbFycbGycbG
        ycbFxsPDxsTDx8TDxMDAwb6+wb++w8HBw7+/v7u7wL29l5WxBgZ8AAB6BQV7CAh8AgF6AAB5AAB4AAB4
        AAB4AAB3AAB3AAB3VlSUwLu6v7q4vbq5enihLSyFBQV2AAB0AAB0AABzAABzAABzAAByAAByAAByAABx
        AABxAABxAABwAABwAABwAABvAABvAABv////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        uLa2raqqsK2uoZ+gnJubnZubnZqbnZqbnJmanJuanZuanpubnJmam5qam5qam5iYmZaWm5iYm5mam5qa
        mJeXlpWVmZeYm5mampiZmZiYlpSVlZKTmJWWlJKSkY6Pko+Pko+PkY6Oko6QkI2Oj42Nj4yMkY6Oj46O
        jYyMjouLjoyMj4uLjYmJjImJi4iIioiJiIaHhYSEhoSFh4WGh4WFhoSFh4WFiYeHiYiIiIaGiYaGh4WF
        hIKCg4GBhYKDhoSFhYSFg4GBg4CAhIGBg4CAgX9/f319f35+gX9/gn9/gX59fnt7fnt8fHp7e3h4gn9/
        mZaWsa2uxcPDxcLDxsLDycXGycfIyMbIycbIy8bIy8fIy8fIysfHyMXGzMjKzcrMy8jK////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////5OHi5OHi
        5OHi5ePj5+bm5+bm5+Xl5OLj5eLi5+Tl5uTl5uTk5uPj5ePj5+Tl6ebn6ebn6ufo6ufo6ufn6ujp6ejp
        6ebn6ubn6ufo6+jp7Onp7Orp7uzs39zev72+////////////////////////////////////////////
        ////////////////////////////////////6unp6efn5uPj5ODh5eLj5uTk5uTj4+Hh4N3d4uDg5ePj
        eHeuAwN5AAB4AAB4AAB4AAB5AAB5////////////////////AAB6AAB7AAB7AAB8AAB8AAB8AAB8AAB9
        AAB9AAB9AAB9AAB+AAB+AAB+AAB+AAB/AAB/AACAAACA////////////////1tPZ29jY19XU1tPT1tLT
        1dLR1dHR1dHR1NLR1dLS1NHRaWipAQGDAACDHx+Ozs3S19PW2NTS2NfR2NfQ2NbS19TQ19XP19fT1tXT
        09DQ0M3N0c3N0c3MzsvKzsvKz8zLz8vKzcnJz8rJ0c7N0M/PzszMy8jIysfGzMnIysfHycXFyMXFx8XE
        yMXFxsPDxcPDxsPDxsLCxMHAxMHAeXemAAB6AAB6Hx6FXFubAAB5AAB5AAB5AAB4AAB4AAB4AAB3AAB3
        CQl6ram0vrq5vrq6vLq6p6WwVFKTAAB1AAB0AAB0AAB0AABzAABzAABzAAByAAByAAByAABxAABxAABw
        AABwAABwAABvAABvAABv////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////raqqsa6uqKem
        pKOioJ6dnpubm5qZnJmanZubnZqbnZqbnZqbnJmanZubnZubnZucnZqbnpuanJqamZiYl5WWmpaYm5iZ
        mpiYmpiYmJWWlpOUmJaWlpOTkI2OkY6PlZGPlpKQko+Pko+Pk4+Qk5CQk5CQk5CQkI6OjYyMjIqKjImK
        jYmKjouLjouLjIqKjYuLi4iJioeIiIaGiYaGiYeIi4mJjYqKjImJi4iJiIeHh4WFfXp7eHZ2eXh3hIKB
        iYaGh4OEhYKChYGChICAgX5+f319fXx7f35+gX+Ag35+gn19gX5+f319fHt7fXp7fHp6fXt7h4aGnZub
        tLGxyMXFycXHyMXGyMXHycbGycTFyMXFxsTEyMXEzMjKzcrMy8jKysbGyMTEysbG////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////4+Dg5eTk5eLj5ePj5OPj5ePk
        5uPk5ePj5OLi5+Xl6Ofn5+bn5+Xm5+Xm5uTk5uTk5+Xl5+Xm6Obn6Obm6efn6uno6ebm6ebm5+Xl6efn
        6ujo7erq6ujozcvLzcvL////////////////////////////////////////////////////////////
        ////////////////////////6efn6efn5+Tl6OXm5+Xm6Ofm5+Xl5uPj4uDg5ePjeHeuAAB3AAB3AAB4
        AAB4AAB4AAB4////////AAB5AAB5AAB6AAB6AAB7AAB7AAB7AAB8AAB8AAB8AAB8AAB9AAB9AAB9AAB9
        AAB+AAB+AAB+AAB/AAB/////////////////////////4d7e4d7e2tfW19PT2NXV19TT19TT2NTU19PT
        19TT19TTnpy9DAyIAACDBASFpaK/19LR2dXP2djQ2dnV2NjV2NXO2NXM1tPN0s3M0MzM0c3M0s7O1NLR
        09HQ0MzMzcrJzcrKzsvLzsvK0c7N0M7OzsvLzcnJzcrJzcrKy8jIycXFycXFyMbFycfHyMXGxsPEyMXF
        x8XEycbFyMTER0aVAAB7AAB7MDCLpKC2HBuEAAB5AAB5AAB5AAB5AAB4AAB4AAB4AAB3XFqYw7+9wL29
        wL29wb28wbu8iISkLy5+AAB0AAB0AAB0AABzAABzAABzAAByAAByAAByAABxAABxAABxAABwAABwAABw
        AABvAABvAABv////////////////////////////////////////////////////lpSUko+Pnpubl5SU
        ////////////h4OD////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////uba3uba3srCxqqion5ycn5ycnp2d
        npycnpycnZqbnJqam5manJmbnZubn56dn52en52dnpybnJqamZiZmZeXmZeXmZeXmZiXmpeXmJWWlJKS
        lpOSlpOTko+Rk5CRmpaRmpaPkY+OkY+QlJGSkY6PkY+PkpCPkY6OjYuMjYqLjIqKjImKjouMjouLjYqK
        jYuLjoyMjouLjYqKjYqKjYuMjIqLi4mJi4iIioiJiYiIYF5ePDs7T05NVlVTXlxacm5tgX5+hoODhoOD
        hoKDg4GBf35+f319gH9+gX9/gH19gn5+gn+AgX9+f359gH+AgH9/gH5+gH5+fXt8e3h5hoSEn5ydt7S1
        ycbGycfGyMXFyMPDxsPDyMTFzMjKzMvLysfIysbGyMTEysbGzMrJy8fIyMTF////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////4+Dg4+Dg5ePi5eLj5OLj5OLi5eLj5uTk5uPj5eLi5eTk
        5ePj5ePj5+Xl5+Xl5OPj4uHh4+Hh5OHh5eLi5+Xk5+bm6efn6Obm5+Xl5uXk5uTk5uTk6ufn5eLiv768
        v768////////////////////////////////////////////////////////////////////////////
        ////////6efn6efn5+Tl7Orq6ujp6ujp6ujo5uPj////////////AAB3AAB3AAB3AAB4AAB4AAB4AAB4
        AAB4AAB5AAB5AAB6AAB6AAB6AAB7AAB7AAB7AAB7AAB8AAB8AAB8AAB8AAB9AAB9AAB9AAB+AAB+////
        ////////////////////////////////4d7e39zb2tfX2NXV19TU2NXV2dfX2NTV2NXV2tfXubfJAgKD
        AACDAACDg4Kz2tbQ2tbS2tfT2tnV2dnR2dnO2dbO1M/MzsnK0M3M0c7N0s7O1NLR29fX2NPT1dLQ08/N
        0M3MzsvLzMjIzMnJzMnJzcvKzcvKy8jIy8jHysjHysfGycXFyMTEyMXFyMXGycbGysjHysjIwb3EMjGO
        AAB7AAB7MzKNuba9f32oAAB6AAB6AAB5AAB5AAB5AAB4AAB4AAB4DQx7u7a5wb++wb6/w76/wr6+rKqp
        Ly5+////AAB0AAB0AAB0AAB0AABzAABzAABzAAByAAByAAByAABxAABxAABwAABwAABwAABvAABvAABv
        ////////////////////////////////////////oJ+fqKenlpSUko+Pnpubl5SUr62tp6WkoJych4OD
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////uba3vbu7raqqpqOjo6ChoZ+foZ6fn56en52dn5yc
        n56enZydnZqbnpucnpycnpydnpydnJqbmpiZmZaXmZaWmZiXmpiYmZiXmJaXl5SUmJWVlZKSkY6PlJKT
        mZaTm5WQlpCOk5CQk5GRk5GSko+QkY+OkI2Nj42Nj46OjouLjouLjoyMjouLjImKjIqKjIuLj4yMjouL
        joyMjIqLiIeHhoWEiIaGiYeHioeIKyopHx8eMDAvKSgnIyMiOjk4XFtafnx8hIODhIKChIODhIKChIGB
        hIGBgoCAgn9/goB/gX+AgH1+gX5+gn+AgX9/f3x9f319fXt8enh4e3h4e3h4e3l5iYaHoZ6eubW2ycXE
        yMPDx8PEysbHysfHysfGy8jIysbGy8fHzMrJy8fIyMTFyMTFx8PEyMbE////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////5OHh5OHh49/f4d3e4uDh5eHh5uLi5uPk5OLi5OHh4+Dh5N/e5N/f5OHi4+Hi
        4+Hh4+Hh5OLj5uHg59/e5+Lg5uTk5uPk5uPk5uPk5+Xm5+Xm5uPj5+Pj29fXv768////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////7Orq6ujp6ujp6ujo////////////////AAB2AAB3AAB3AAB3AAB3AAB4AAB4AAB4AAB5AAB5AAB5
        AAB6AAB6AAB6AAB6AAB7AAB7AAB7AAB8AAB8AAB8AAB7AAB9AAB9////////////////////////////
        ////////////////4uDg4uDg3dvb29jX2dXU19TU2dbW2dbW2dbW29bVzMnPLy6TAACCAACCTEuf3NjQ
        29jT29rW29nT2tjO2NfQ1tPT1tLSzMrJyMbF0c7N////////29fX2NPT1dLQ3dnX1dPS08/QzcnKyMXF
        y8rJ0M7OzcrKysbGzMnJy8nIycfHysfGycbGysjIysjIyMbFysjHysjIo6K5IB+IAAB8AAB7R0aVw8DB
        uLe9Cwt+AAB6AAB6AAB5AAB5AAB5AAB5AAB4AAB4W1eXw7+9wr+/xcPCxcLCtbGxhoOCnpyc////////
        AAB0AAB0AAB0AABzAABzAABzAAByAAByAAByAABxAABxAABxAABwAABwAABwAABvAABvAABv////////
        ////////////vri2q6alqqemoJ+fqKenrKqpr6yss7CwsrCwr62tp6WkoJych4ODcW9u////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////vbu7raqqu7q5sK6upqSkop+fop+foqCgoqChoqCgoKCfn52dnpuc
        nJmZnZubnZqbnJqanJmZm5iZm5manpubnZqanJmYmZeXmpeXmZeWlZKTlJGRl5WVlpOVmJKSnJaSmJSS
        lpOTlpSUlpOTk5CQkpCQkpCQkI6Oj42Mj46NkI2Nj4yNj42NjoyNj42Nj42Mj4yMjouMjYuLiYeHiIWF
        iYeHi4iJbWtrISAfGxoZHRwbIyIhPTw8HBsaQD8+YWBehIODh4WFhYODbGpqXl1bZ2VkbmxrfHh5g4GB
        goCAgoCBgoCBgn9/f3x8fnt7gH1+gX9/fnx8fHl5fHh5e3h4fXl5fXl5fHl6iYeHoZ2dubW0ysbFysbH
        ysjIy8jIzMfHysXFyMTDycfFycfIyMTFx8PEyMbEysbGysTGyMPE////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////3NnZ4d/f4N3d4d7e4uDh4+Hh5N/f4uDh4N7f4N/f4t/f5N/f5ODg4uHh4t/g4t/f4+Hh4+Li5+Pi
        6uDd6t/c5uHg5OLj5eLj5uLj5uTl6Obm6efm5uTkycfHycfH////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////AAB0AAB1AAB1AAB2AAB2AAB2AAB3AAB3AAB3AAB4AAB4AAB4AAB4AAB5AAB5AAB5AAB6AAB6
        AAB6AAB7AAB7AAB7AAB8AAB8AAB7////////////////////////////////////////////////////
        ////4uDg4d7e3dva29jX2tfX2dbW2NbV2tfV2tXU1tLTQ0OcAACCAACCCQmFxsLK2tjS29rU29jU2dXR
        1tHR0c3O0s7OysbFyMbF////////////////////////3dnX1dPS3NnY0tDQycbGzMrJ0c/PzcrKysbH
        zsvLzcnJy8jIzMrJzMrKzMrJy8rJysfHycbGyMXFkY+yFxeFAAB8AAB8ZWOgx8PExMHDS0mWAAB6AAB6
        AAB6AAB6AAB5AAB5AAB5AAB4CQl7ubS6yMO/y8jFyMTCx8HAt7Kxnpycnpyc////////////AAB0AAB0
        AAB0AABzAABzAABzAAByAAByAAByAABxAABxAABwAABwAABwAABvAABvAABv////////////////vri2
        q6alqqemr66usa+vs6+wtrO0trS0trS0t7S1tbKyr6urmJSUcW9uiIaG////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////u7q5urm5qqmopKKipKGho6CgoZ+foJ+eoaCfoZ+gn52enZubnpubnpycnZyc
        nZubnJuanpycn5ycnpubnZmZm5mZmpmYmJeWlpOTlpOTmZiXmZaXmJWWmZaVmJaVlpOUlpOUlpSUlpSU
        k5KRkpCQko6Ok5CQkI+Pj4yNkI2NkI+OkY+Pko+QkI6NkY6OkI6Pjo2Nj42MjYqLjYqKjYuLdXNzPz4+
        GRkYHR0cRUREaWdnGhkYKCgnSEdFcnBxiYaHXVpaIiEhLy4tPj07PTs7VVJTYmBggX9/hIGChIGCgoCA
        gX9/f319gX5+gX59gH5+gH19gH19f319fnt8fXt8fHl6fHl4fHp6e3l5jImJpKChvLm6yMbGy8fHy8bG
        ycTEycXGysjHycbGx8HCxsLCysbGysTGyMPEzMK+x7u3xcDA////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////3NnZ3NnZ393d393d
        4N7e4uDg4d/f4d7e393d39zc4d7e4d/f4d/g4+Hi5OHi4t/g4N3d4d/f4uDg4t7f5+Dd6ODc5eDg5OHi
        5uLi5eLi5uPj6Obl7Orq4+Liu7m5u7m5////////////////////////////////////////////////
        ////////////////////////////////////////////////////////AAByAABzAABzAABzAAB0AAB1
        AAB1AAB1AAB2AAB2AAB2AAB3AAB3AAB3AAB3AAB4AAB4AAB4AAB5AAB5AAB5AAB6AAB6AAB6AAB7AAB7
        ////////////////////////////////////////////////////////////////////5ePi5ePi3dvb
        29ra3Nrb2NbW1tTV2NbX2NfX1dPVcG+uAACCAACCAwODlJG619TV2NXV2NXW1tPT2NTTzcrJtbKzysbF
        ////////////////////////////////////3NnY2dbW0M3N0MzM0c7OzcvLy8jJzszMzszLzsvLz8zL
        zcvKzMrJzcrKzMnJysfHx8TFeXepBAR+AAB8AwN9eXipyMbGy8jGpKC4BgZ9AAB7AAB6AAB6AAB6AAB5
        AAB5AAB5AAB5bWuhycPAx8LBxcLBxsLBxsPDrqurmZaV////////////////AAB0AAB0AAB0AABzAABz
        AABzAAByAAByAAByAABxAABxAABxAABwAABwAABwAABvAABvAABvBARwLCx7vri2t7KxtLKxt7W1trOz
        trKztLKytbOztbOzsq+wr62tsq+wrKmpnJqZiIaGqaennpyckI6OmZiYpKKin5yck5CPdHFx////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////urm5rayso6Kiop+gop6foZ+fo6Ggo5+foJ6eoJ6edXNzXFpZcG9tiIeGl5aWnZycnZuanJmZ
        mZeYnJmZnJqZm5qamZiXl5SUl5WVmpiYnZmXmpeVlZSVlpSVlpSUlJKSlJKRlJGRk5CRkY6Pko+Pk5CR
        k5GRkZCPkpCQko+QkI6OkI6Oj42NkI6OkY6PkI6Ojo2NkY6OkY6Oj4yMdXN0V1ZWIyMiKyopYF9eZGJj
        GRgXHRwcOTg3aGVliYaGNzY2ISEgHBsaHRwbHRwbKyopQD8/Z2dngH1+hICBhIKCgn+AgH5+gX59gH18
        gH19gX5+gH5+gH5+gH5/gH5+f3x8fXt6fXt7fHp6fXt7fHp6end3jImJpqSivbu7ycfHycbHycfFycbE
        xsLCxL/Bx8TEyMTFy8bGzMK+x7u3xcDAz87NzsrKzsnJ////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////3tvb3tvb3tzc393d3tzd393d4t7e393d
        3Nrb39vc4d/f4N/f4N7e4+Dg4uDg4N3d4N7e4uDg4uDg4d7f4t7f49/g4+Hh5OLh5OLg5OHh5eLi6OXl
        6efn2dfXu7m5////////////////////////////////////////////////////////////////////
        ////////////////////////AABwAABxAABxAAByAAByAABzAABzAABzAAB0AAB0AAB0AAB1AAB1AAB1
        AAB2AAB2AAB2AAB3AAB3AAB3AAB4AAB4AAB4AAB4AAB5AAB5AAB6AAB6////////////////////////
        ////////////////////////////////////////////////////////5ePi4N7e3dra29jZ2NbW2tjX
        2djY2NbX2tjZi4q6AgKCAACCAQGCXl2m19PT2NXV2NXV19XU1dLSx8TEtbKz////////////////////
        ////////////////////29jY29jY1dLR0s/Oz8zMzsrLzsvLz83MzszNzsvLzMjIzMrJzszLzcrJzMnJ
        zMnJycbHWFedAAB9AAB9ExOEi4qwycfGycbFw8DDRUOUAAB7AAB7AAB6AAB6AAB6AAB6AAB5AAB5EBB/
        qqe3xsLCxcPDw8PCw8HBvLm4mZaVura3////////////////////AAB0AABzAAB0AABzAABzAABzAABy
        AAByAAByAABxAABxAABwAABwAABwAABvAABvBARwLCx7hIKftLO1uLW1t7O0t7S1uLa2t7S1tbKytbOz
        tLKysq+vsa6ttrOyt7OzrqusqaennpyckI6OmZiYpKKin5yck5CPdHFxh4OD////////////////////
        ////////////////////////////////////////////////////////////////////////rKusrKus
        pKOjoqChoqCgoqChop+gpaGgpaGgX11dLCsqPz49KyopT05OdXRzgH1+mpeYmpmYm5mYnJmZnZmZnJiY
        m5iXmZaWmZeXmpiYmpeYm5eXmJWUmJWVlpSUlJKSlJGRlJCRk5CRk5GRk5GRlZSTlZOSlJKSlJKTlZOU
        k5GSk5GQkY6Oj4yMkI2NkI6Oj42OkI6OkY+Pj42OWllYSEdGKysrOzo5YWBebm1sISEgHBwbNTQzZWNi
        iYeHOTg3JCMiJCQjIyMigX9/KCcnLSwqUlBPbWxthIKCgoCBgH5+gX5+g4CAgn5/gH19gX19gn5+gH5+
        f35+f319fnx7fnx8fXt7fnt7fXt7fHl6end3e3l4fHl5fHp6kI6Pqaanu7e2xsHAysfHy8jIycbGyMbF
        yMPDw7e1v7OxxsPBz87NzsrKzsnJzsnIzMjJ////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////2NfX3Nra3Nra3dra39vc4N3d4d/f4d7e3tvc3tzb4N7e4N7f
        4t3c5N7d4N3d3tzc4d7e4t/f4t/g4uDg4t/g49/g5OHh5OPh4+Dg4t/g5OHh6OTl5ePjx8XFx8XF////
        ////////////////////////////////////////////////////////////////////////////////
        ////AABwAABwAABxAABxAAByAAByAAByAABzAABzAABzAAB0AAB0AAB0AAB1AAB1AAB1AAB2AAB2AAB2
        AAB3AAB3AAB3AAB3AAB4AAB4AAB5AAB5////////////////////////////////////////////////
        ////////////////////////////////////////5eLj5eLj3tvc2NbW3NjX39zb2tfX2NbX29nZwL7O
        Dg6HAACBAACBGhqMzcvR19XV2dfX19XV2dbWysfHysfH////////////////////////////////////
        ////2tjY2tjY1NHR0c7OzsvLzsvK0M3N0c/P0M7OzcvLzMrJzMrKzcrKz8vKz8vKzcrKzMnJLi6PAAB+
        AAB9HByHm5m1ycbGxsTDx8XEn5y2BgZ9AAB7AAB7AAB7AAB6AAB6AAB6AAB5AAB5PDyPxMHDxsPDxsPC
        xsLCxsTDxcHBura3ysfHyMbGure1////////////////AAB0AABzAABzAABzAABzAAByAAByAAByAABx
        AABxAABxAABwAABwAABwAABvAABvAwNvTUyMn5yqt7S0uba2ura3ube3uLW1tbOztbS0tbGxtLCwtLGx
        tLGxtLGwtbKytLGxsq+vsa6usa+urq2rqaemn5ubh4ODn5ube3h3////////////////////////////
        ////////////////////////////////////////////////////////s7Kys7KyqqmopaOjpKKioqCh
        oqChpaKiqaWjKyopODc2TU1MHx8eISAfICAfPDs6a2lnoJybnpuanpuanpmZnZmZmpiYl5WVl5WUmZiX
        m5mZnJiYm5eWmpaXmZeXlpWVl5WVlpSUl5WVl5aVl5WWlZOUlJKSk5CRlZKTlZOUlJOTk5KSkpCQko+P
        kpCQko+QkI2Oj4yNj4yNkI6OPDs6Hh4cLCsrOTg3c3JxZmRkKiopHR0cIyIhaWdnioeIIyIhHRwbMC8u
        QD8+hoOENjU0Hh0cRENCWVhWhYSDg4GAgn9/hIGBg4CAgX9/gH59gn9/g4CAg4GBgX+AgH5+fnx7fXt7
        fnt7gH18gH19fXp6e3h4fHl4fHl5e3l4fHp6fHp6f3x9k5GRrKmqxsTEzsvMy8nKx8PDxL++xcG/x8TD
        yMfHzMjIzMfGzsnIzMjJy8fGy8fHzMnJ////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////2NfX2NfX29nZ29jZ29jY3tra4Nzc4d/f4eDg4N7e3dra3tzb397f4t7e49/e39zc3tvc
        4d/e4d/g4t/g4+Dh4+Hi5OHj5uLj5eHi5OHh5OHh5ePj6Ofo4N/ftrS0trS0////////////////////
        ////////////////////////////////////////////////////////////////////AABwAABwAABw
        AABxAABxAABxAAByAAByAAByAABzAABzAABzAAB0AAB0AAB0AAB1AAB1AAB1AAB2AAB2AAB2AAB3AAB3
        AAB4////////////////////////////////////////////////////////////////////////////
        ////////////////////////////5eLj4d/g3NrZ39za4d7d3Nja2tjZ29nZy8nSKCeRAACBAACBAACB
        oZ/B2NXV2dfX09HRzcvLysfHysfH////////////////////////////////////////3dzb3dzb1tTU
        0c/O0c7O0c7O0c7O0M/P0dDP0M7OzszLzcvLzcrLz8zL08/M0c3LvLnEBweBAAB+AAB+GxuHsq++y8fG
        ysbFysbFycXESkmXAAB8AAB7AAB7AAB7AAB6AAB6AAB6AAB6AAB5paO3xsPCyMTEx8XFx8XEyMXExsLD
        ysfHyMbGure1y8jHyMXFtbOy////////////AABzAAB0AABzAABzAABzAAByAAByAAByAABxAABxAABw
        AABwAABwAABvAABvBQVxKSh+cG6ZuLa2uba2uLW1tbOzs7CwtbKytrS0trOztbKysq+vsa6usq6usrCw
        tbKytLGxr6ysrquqsK6tsq6vrKion5ube3h3gHx9////////////////////////////////////////
        ////////////////////////////////////////wL69wL69tbOzrKqqpaOjpqOjpaKjpaOjiomINDMy
        Pz49Ojo6IiIhmpeYPz4+MjEwPz48gn9+oJycn5ycnpubnpqbnZqampeXmpeXmpiXmpiXmZaWm5iYm5mZ
        mpiXmZeXmZiYmpiZmZeXmZeXlpSVlJGSlJGRlZOTlZOTlJOTk5GSlZOTlpSTlJKSkZCPkpCPk5CPkI6O
        joyMj4yMOjo5HBwcKSkoODc2c3JySkhIHh0cNTU0LS0scW9uend4GhkYGxsaHx4dTUxLhoSEICAfHBsa
        MzIyQD8+hIKBhIKChYKChIGBgX5+gX19gH5+f319goCAhIGCgoB/gH5+gX5/gX5+gX9+gH59fnt7fHl6
        fHl5fHl4e3h3fHp6fXt7e3l5fHl6f31+fn19fXt8lZOTr62txsPDy8rJysjIxcLCxcHCysbGy8fHzcnH
        zMjHy8fGy8fHzMnJzsvKz8vLz8vL////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////29rZ
        29rZ3NnZ2tjZ2tfY3dra393c393d4N7e3tzc3drb3NnZ39zd4uDh4eDh39zd39vb4+Df4uDg4t/f4+Dg
        4+Hh5ePj5uPk5OHi5OHh5eLi5ePk5OPj1NPTtrS0////////////////////////////////////////
        ////////////////////////////////////////////////////////AABwAABwAABwAABwAABxAABx
        AAByAAByAAByAABzAABzAABzAAB0AAB0AAB0AAB1AAB1AAB1AABzAAB2AAB3////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////5OLi5OLi4N7d3tvb3Nna3drb3Nra29ra09DWSUidAACBAACBAwOCZGKo2NTV19TUwsHA
        zcvL////////////////////////////////////////////////////3dzb1NHR0c/O0s/P0s/P0c/O
        0M7N0c/O0tDP0M7N0M3M0M3Nz83N0c7N0M3MiIexAAB+AAB+AAB+JyeMycbIzsrIzsnIzcnIzMfHoZ63
        BAR9AAB8AAB7AAB7AAB7AAB7AAB6AAB6AAB6UlGYycTCy8XFx8XFx8XDycTDx8PDxcLDxcLCxcLBy8jH
        yMXFtbOyycXFxsLCsK2s////AAB0AABuAABzAABzAABzAAByAAByAAByAABxAABxAABxAABwAABwAABw
        AABvAABvAABuLy+AgICfrKqwtbO0tbKytbKzt7W1trS0tLKytLKys7Cxsq+wsq6vsq+vsK2tsK6ur6ys
        r6uss7CxtbGxsayro56dgHx9gHx9////////////////////////////////////////////////////
        ////////////////////////////wL69wL6+rqysp6SlpqKjpqSlpKKjbm1sHx4dJCMiPTs7VFJRoqGg
        XVtbMzMyUVBQZWNkoJ2dkY+PUVFRbmxrjYuLnpybnZqanpqbnJmanJmZnJqZmpiYmpeXm5iYnJiZmpiY
        mJWVmJWWl5WVlJKSlZKSlJGRlJGRlZKSlpOTlpOTl5aWlZSTk5CQko6Ok5GQk5GRkpCQkY6OKikpGxsa
        HR0cJycmjoyNOjg4Hh0cJyYlQT8/hYKCbGlpGxoZIyMhICAeSklJiYeHGRgYHBsaLCwrOTg3hICAhYKB
        hoODhYKChIGAhIGBhIKCbm5tVVNTeXd3gYB/gH19gX5/gn5/gX5+gH19f3x8fnt7fXp5e3h4e3l4f318
        gX+Afnx9f3x9f35+f35+fnx8fXp6fXt7gX9/lZKTraurw8HAy8fHzMjIy8nIzMjHzcjIzsjJzsnKzcnJ
        zsvKz8vLz8vL0MzM0czN0czN////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////1NLS2tfX29fY2dfX2tjY
        29jZ29na3dvb3tvb3Nra3Nrb3drb3tzc4eDh4ODh393d4Nzc4dzd39zc393e4d/f4t/e4+Dh4uDh4N7e
        4t/f4+Dg5eLi4N3dwsDAwsDA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////AABwAABwAABwAABxAABxAABxAAByAABy
        AAByAABzAABzAABzAAB0AAB0AAB0AAB1AABz////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        5OLi4d/f3dra2tfY3dvb3Nra3Nrb3NvbcXCuAACAAACBAACBMzKVz8zU1dHRsq+vsq+v////////////
        ////////////////////////////////////2tbX2tbX1NHR0s/O0c7O0c7O09DP0tDO0c7O0M3Nz8zM
        0M3N0c7PzszNzcvKzszLZWSkAgKAAAB/AAB+T06bzsvKzcvKzcrKzsrKzcrKxMPGPj2TAAB8AAB8AAB8
        AAB7AAB7AAB7AAB6AAB6CAh9r6u7ysXFycbFx8TDx8TDx8TDxMHAw8C/xMHAxcLCxMLBxMDAycXFxsLC
        sK2sxsLBgn19S0loFBNjAwNtAAByAABzAABzAAByAAByAAByAABxAABxAABwAABwAABwAABvAABvAABv
        FBN1U1KNr6yyube4ubi4ubi4uLa3trW0uLa2uLW2tLCys7CxsrCwsq+usq+vsq6usq6us7CxtbGxubSz
        s62sn5iXioaF////////////////////////////////////////////////////////////////////
        ////////////////wL6+tLKyqKWlpqOkpaOjpaKib21sKCcmKyopIyIhVlRUo6CgQ0FALCwramhoWlhX
        oZ+fXVxbJycmSUhHWlhXZ2VkdHJyj4yMm5iZnpqbnZqanJqZnJqbm5mampeYmZaWmJWVmZaXmpeXmJaW
        lZOTlZKSlpKSl5OTlZGRlJCRlZOTl5aVlJGQkY6OkpCQlJKSlJKSlZKTOzo5JCQjJiUlODc2j42NMjEx
        JCIiHh4dPz09gH1+YF5eJSQjKCcmR0dGVVRShYODGhoZHRwcMC8vTkxMiIaGiIaGhYKChoGChoODiIaG
        h4aGiIWGHBwbOjk3TkxMcG1ugn9/gn1+gn5+gX9+gX5+gXx9gX19gHt8f3x8gH5+gH5+gX5/gn+Agn+A
        gX+AgYCBf319fnx9fHl6eXd3fHl6goCAmJaWsa2tyMXEzMnJzcjIz8vKz8vLz8vJz8vLz8zMz8vL0MzM
        0czN0czN0M3O1NDR1tPU////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////1NLS1NLS1tPT19PU2dbX2tjY19TU19TU29jY3NnZ
        3Nna3tzc39zc3t3d3t3d3tzd3dvb4Nzd3trb39zc4uDi4eDh4Nzc4N3d397e3dvb39zc4d7d5+Li39vb
        wsDA////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AABwAABwAABwAABwAABxAABxAAByAAByAAByAABzAABz
        AABzAAB0AAB0AAB1////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////5eLh5eLh3tzc3Nra
        3dvb3tzc3dzc3dvboJ7BAgKBAACAAACABASDtrTM19TUsq+v////////////////////////////////
        ////////////////////29jY29jY19TU09DP0c7O0s/Q09DQ09DQ0s/Oz8zMzsvL0M3N0M3NzsvLzsrJ
        yMXJQ0KYAQF/AAB/BASAb22nysfJy8nJzcrKzcrKzcvKzcvLhIKvAgJ9AAB8AAB8AAB8AAB7AAB7AAB7
        AAB7AAB6TEuXysfGysfGyMTDyMTEycbFxsTDxcLBxcHBw8DAw8DAxcHBx8TDw8DAwL28xsLBxcDAsa6u
        iIaSUU95GhlsAABzAABzAABzAAByAAByAAByAABxAABxAABxAABwAABwAABwAABvAABvAABuIiF7cG+b
        qKaxu7e4uba2ube3uri3uba2trKztbKytbOztLGxtLCwtLCwtbKxs7Cwsq+wtLGxt7KwrKWjioaFioaF
        ////////////////////////////////////////////////////////////////////////////////
        vry8vry8sK6up6WmpaOjpqKiaWZmPj07PTs6NDQybmxspKGiW1paLy8uKSgnUU9NoZ+fQUBAIB8gJSQj
        NTQzOjk5KiooS0lIT01NlpKTnpycjIuKlJGRnJmanJmZmpiYmZeXmpeWm5eWmZiXmJWVl5WUmJaVlpOU
        lpOTlZKSlJGQlZKSlJKRkpCQkpCRko+PlJCQlJKSHx8eJycmIB8eNjQzkI6OHh0cLi0sLi0sQUA/kI2O
        WFZXHBsaJCQjPj09ZWRjb21tGxoZHRwbNDMzUlFSjIqKioiHiIWFiIWGiYeHiIaGiIWFh4SEGhoZJSQj
        Ojo5YmBgeXV1Pz09amdmeHZ1gX9+gn5/fHh4f3x8gn9/g4CAgoCAg4GBhIKCgoCBgoCBgoCBgX9+f319
        fHl6fXp6gH5+fnx+fHl6fHp6gX9/mJOUsq+vyMbGy8nJz8vL0MvMz8vMz8vL0c3O087P0M3O0M3O1NDR
        1tPU087P0s7P0MzM////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////1dHR1dHR1NHS1dLT2dbW2dfY09LR1dLS29nZ29na29nZ29na29nZ3NrZ
        3dvb3dra3dra3tvb3dvb4eDf5eTl5eTl4N/e39zc397e3dvb3tva4t7e5N/f1NDQ1NDQ////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////AABwAABwAABwAABwAABxAABwAAByAAByAAByAAByAABzAABzAABzAAB0
        AAB0////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////5eLh4N/f3dra3Nna4N7e393e3drb
        t7TKBgaCAACAAACAAACAc3KvzcvLzcvL////////////////////////////////////////////////
        ////////29jY2NTV1NLR1dPS1NLS09HQ09DQ09DQ0M7O0s/O0c/PzszM0MzM0s3NrarAMzKTAACAAAB/
        DAyDg4GvysfJy8fHzsrJzcvKzcrJz8vLwr7HJCOKAAB9AAB8AAB8AAB8AAB8AAB7AAB7AAB7BgZ8r6y8
        ycbGycXEysbFy8fGycbGycXFycXFx8XExsLDxcHBw8HAxMHAxMHAxMHAwr+/xMDAyMXExMDApaGocnGg
        LCyFAABzAABzAABzAAByAAByAAByAABxAABxAABwAABwAABwAABvAABvAABvAABuNDKCh4Oiu7e3ura3
        ubW2t7S0uLa1t7S0trOztbGxtLGxtbOztrOztrOztLKytbKyubOxsq2rnZqah4SF////////////////
        ////////////////////////////////////////////////////////////////////vry8s7Cxq6mp
        qaenqKanYmBgQD89NjU0SEdGdXNzpaOjpKKipaOjbm1tZ2ZloZ+fQUBAISAfNTQzYV9fZGJiISAfQkA/
        Q0FAoJ2eaWdnRERCZGJidXJyhoSDmpeXi4iIjoyKmpeWmJaVl5OTl5STl5WUmJWVmJWVmJWUlJGQlJGQ
        lJKRlJKSkJCQkZCPk5GQe3p5JiYkKCcmQD89VVNSk5GRNTUzHx8eMTAvPj08kY+QUU9PIiEgHBwbISAf
        Z2VkaGZmJCMjHh4dMTEwU1JRi4eHioeHi4qJjIuKioeHiIWFiYaGiYeGHBsaKCcmMC8vZGJgbmxsLy4t
        QkJAT01MZWNiYF5dPTw7Tk1LVVRSaGdlf31+hIODhIOCgYCAf31+f3x8fnt7fnt7fnt7gH19gH5+fnx9
        fXt7fHt6e3h4fHh5e3h3gH59mJWVtLCxzsrM0M3N0c3O0MvM0c3O0c3Nz8zM0c7P1NHR087P0s7P0MzM
        0c3P1dPU1NHS////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////0c/O1NHR1dPT1tTU1tTU19XW1dPT1dPT2tjZ29na2tfY2dfX2NbW2NbX29jZ3dra3dra3tra
        393d4ODg5OPj5OTk4N/g3drb3dvb3tzc39zc5eHh4d3dwb++wb++////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////AABwAABvAABwAABwAABw////////AAByAAByAAByAABzAABzAABzAABz////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////4+Hh4+Hh39zb3NnZ4d/f4d/g3tvc3tvbKSiQAACAAACA
        AACAIiKLzcvL////////////////////////////////////////////////////////2tjY2tjY1tPU
        19TU1tTT1NLS09HQ1dLS1dLS09DQ09DQ0tDQ0c/O0s/P1NDRqqbAFhaIAACAAACAAgKAiYeyzszMzcvK
        zsvLzszLzcrJzsrKz8zLcG6nAQF9AAB9AAB8AAB8AAB8AAB8AAB7AAB7AAB7RkWWz8vMzcrJy8jIysXF
        y8bGysbGysfGy8jIyMbGxMHBxcLBx8TEycbFxcLCw8HAxMHAxMHBxMDAxMC/wr++ure6bmydLy6FCgp3
        AABzAAByAAByAAByAABxAABxAABxAABwAABwAABwAABvAABvAABuFxd3V1aRpaKuuLS0uLa2ubi4u7i3
        t7OztbKytrS0t7S0trKzt7S0t7S0trKytrKytrSzrKuqh4SFh4SF////////////////////////////
        ////////////////////////////////////////////////////ure3ure3srCwq6mpqaenTk5MLS0r
        YmFgOjk4f318o6GhpaKip6WkqKalpaOjo6GhHh4dIiIgQ0JBb25sZWNjIyIhNzc1RkVEoZ+eQT8+ISAf
        NzY1PTw7VlVTg4CBNzY0Xlxbbm1se3l5l5STmZWUmZeWmJaWl5OTlpKSl5WUmJWVl5STlJKRlJKSk5GS
        k5KScnJxTUxMIB8eMC8ua2pqfXt7JSUjHR0bHx8eS0pJk5GSXFpZMzMyJSUkKikodnN0W1lZHBwbHx4d
        MzIxZWNijImJi4iIi4qKioiHioaFioaGioiIi4mJHR0bMTAwODc2QD49MjExKikoLSwrMjEwdnRzKSgn
        IB8eJiUkHBsaJCQjT05Nd3V1fnt7fnx8fXt7fHp5fXp6fXt7f319f3x8fHp6fXp6f3x7fHp4enZ3fHl5
        fHt7enl4eHV1d3R0gX5+nJmauLW20M3M0c7O0s7O0MzMz8zMz83N0MvM0MzM0MzM0c3P1dPU1NHS087Q
        0c7Oz8zL////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////0c/O0c/O09HR
        1dLT1tPU1NLS19XV19XU1dLS19TU2dfX2tfX29jY2dbW19bW2tjY3Nra3dva39zb4N3e4d/g4uDh4N7g
        3drc3Nna3Nra3dvc4d7f5uPj3drawb++////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        AABvAABvAABwAABwAABwAABwAABxAABxAAByAAByAAByAABzAABz////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////4+Hh4uHh3t3d39zd4d7f393d29nbWVikAAB/AAB/AACAIiKL////////
        ////////////////////////////////////////////////////2tjX2tjX1tTU19PT1dHS1dLS1dLS
        1dPT1dLS09DP0tDP09HR0tHQ0tDP0c7Pk5G5BgaCAACAAACAAgKBqKa90M7Mz83Mz83NzszLzszLzsrK
        z8zMvLnDFBSEAAB9AAB9AAB9AAB8AAB8AAB8AAB8AAB7AwN8np2+19XV1NHQzsvLz8zLzMnIy8jHzcrK
        y8rJyMfGysbHzMnJysjIx8bFxcPDxMDAwb6+w8HAw8DAw7+/xMDBvbq9o5+waGaaGhl9AABzAABzAABy
        AAByAAByAABxAABxAABwAABwAABwAABvAABvAABvAABuDg1zVlWPm5eqt7S3vbm4vbi2ure2ube3t7S0
        tbOztrOztbKytbKytrO0t7W1tLGwoZ2doZ2d////////////////////////////////////////////
        ////////////////////////////////////////ure3vLm6rqurqaalYWBeVVRUXFtaUFBOjYyLjYqL
        ioeInpubo6CgpKKipKKiHR0cIiIhPj08bmxsZmVkIiEgNDMyYmFgoZ6eSEZGHh0cHx8fQ0JBhIGBYV9f
        ICAfMTAvOTk4Pj49mpiYn5qZnZiYmpeXmJaUl5WUnJmaoJ6em5mYl5WUmJWVlpSUkI+RcHBxOTk4Ozo5
        Hx4dY2Jid3R1Hh0cR0ZFISAfUlFQlJKRXVxaKCYmLy8tLCsqdXR1WllZHBwbIyMiNjU0bGlpjIqKioiI
        jImIjIiHi4iIjImKi4mKi4mKHRwbJiUkHRwcHRwcGhkYHBsaJyYlNzY1d3R0FxYVFxcXGRkYd3V0GBgY
        MTAuVlRTfHh5fHl6dXJyend3f318f359fnx8fXt6e3l4fXp5fHp5e3h4e3h4fHp5fXt7fXt7enh5eHV1
        d3N0eHR0eXd3hoODnpububa2z8zM0MzM0c7O0dDP0c/O087P1dHS1tLU1NDR087Q0c7Oz8zLz8zM08/R
        1dLT////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////09HR09HR09HR1dTU1tTU1NHR1NPS
        1dPS1NLS1tPU2NbV2NbW2NXV19XV1tTU19XW2dfX29nZ3tzc3tzd4N3e393e3Nna29jZ393c393d3tvc
        39zc3tvay8jIpKGi////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AABvAABvAABv
        AABwAABwAABwAABxAABxAAByAAByAAByAABy////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////5eLj5eLj4d/f3tzc39zd3drb3tzcd3eyAAB/AAB/AAB/AAB/////////////////////////
        ////////////////////////////////////2tfY2tfY19XV1tPT1dPT1dTU1dPT1NHS1NLR09HQ09DQ
        09HR0tDQ0s/P0c/PXFujAACBAACBAACAIyKNzMjL0M3M0MzM0c7N0M3Nz8zMzszMzsvLzsvKZmSkAAB9
        AAB9AAB9AAB9AAB8AAB8AAB8AAB8AAB7GRlz19XV1NHQ2tnX1tTT0s/O0c3MzszLysjIysjIy8jIzcrK
        zMrLysfIycbGxsTEw8HBwsDAxMHBxMHAxsPDxMHBv7u7v7u6pqOzaWebHx9/AABzAAByAAByAAByAABx
        AABxAABxAABwAABwAABwAABvAABvAABuAABuJyZ9eXacubS2v7m4vri4uba2trS0trS0uLW1tbKytbOz
        t7S0ubW1t7OznpmZhYKB////////////////////////////////////////////////////////////
        ////////////////////////wsC/wsC/s6+vq6ioYV9fMTAvQ0JBYWBfjYuLa2lpQ0JBcnFvjIqJmpeX
        pKKiHx8dJCQiQD8+hoKDQ0NBIiIgPDw6ZGJhop+fMDAvOzo5Ly4tbm1rn5ydYWBfHR0cHx8eJycleXh4
        ZWNjYl9dioaEkY+Om5mYmpiXn52doqCgnZqZl5STmJaVmZiWlpWVlZOTl5STbGppS0pJZ2RleXd3JiYl
        HBwbHx4dXFtalZSUWllZHh0cLCsrPz49kY6PPDs7HR0cKSgnODc1d3V1jIqLi4mIjYmIjouLjIuLjYuL
        jYuLiYeHHBsaIyMhHBwbZGNiJiYlGhoYKSgnTkxMhYOCb2xsSklIREJBfHp5GhkYLi0rVFNRgH18W1lY
        Ozo5TExKVFJSZ2Rke3h3f3x8fnt7fXt6fnt7fXt7fXt7e3h4fHh4fnp7fXt7fHp6fHt6fHl5end4enh3
        d3V1eHV1hoODop+fvru70c/Q1NHS09DR1dHS09DR0M3O0s7O0c7OzszKz8zM08/R1dLT1dHQ1dXT09HT
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////0M3O0s/Q0tDR09HS1NPT09HR09HQ09HQ09HQ1tPT2NXV
        1tTU1NLS1tPT1tXV19XV2NTV2dfX2tnZ29jZ3dra3dzb2dfX29nY4t/g4d/g3drb3NnZ2tjYzMrKpKGi
        pKGi////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////AABvAABvAABvAABwAABwAABw
        AABxAABxAABxAAByAABy////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////5eLj
        4+Hh393c3tzc3Nna3dvboZ/DBweCAAB/AAB/AAB/AAB/////////////////////////////////////
        ////////////////////3dva3dva2dfW19TU1tPT1dLS1dLS1dPT1dLS09HQ1NHR1NHR1NDQ1tHQ1NHQ
        NjaVAACBAACBAACBRkWa0s7P0c7O0M3O0c7Oz8zMz83Mz8zLzcnJzcnJu7nEFxeHAAB+AAB9AAB9AAB9
        AAB9AAB8AAB8AAB8GRlz////////2tnX1tTT0s/O2dbV1dHQz8rJz8zLzsvLycbFyMTFycbHy8nJy8nJ
        yMXFw8HAwr+/w8C/w7+/w8DAwr++wr++w7+/wr6+t7W6bWueLi6FCwt3AAByAAByAABxAABxAABxAABw
        AABwAABwAABvAABvAABvAABuCAhxNTSDg4Ghu7a3vbe3ura1uLW0t7OztbKztbKzt7S0ura2uLS0pqKi
        hYKBioeH////////////////////////////////////////////////////////////////////////
        ////////////wsC/sa6vrKqqhoSEc3JxIyIhPDs6kY+OVlVUNDQzTUxLU1JRiYeGg4GBHx8fJiUkRENC
        hYODQ0FBIiEgOTg3a2lno6CgISAgKyopRkVEe3l5np2cUVBOISEfRkVET01MnpybSUdHJyYlRENDbGpo
        hoWCi4iHn52dn52cmpeXl5SUlpSUmZeXmZeVl5STlZKRlpOTmJaWnJubi4qKXV1cfn19TkxLcG5tmJaX
        j46PKyopHh4dPT08XVtbNzY1Hx4dKCcmMTAugoGAj42NjYuLjIqKjImKjIqKjIqKj4yMjYuLHBwaMzIx
        JiUkiISEGRkYHRwbLy0samdnhYKBf3x7ZmRkXVpaRUNCJSQjMzIxQD49gX5+KCYmIB8eJiUkHBsaJCQj
        Tk1MeXV2gX5+gH19gn5/hICBgX9/gH5/gHx9gHx9fXl6enl4fXt6fnx7fHl4e3l5fHl5end3eXd3dnRz
        dnR0iIeGpqSkwLy90czO0MzN0MzM0M3N09DQ1NDQ1dPR0c/R0MvM1dHQ1dXT09HT0c7P0s7O1NLS////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////0M3O0M3O0s/Q1NHR09HR09HR1NHR1NHS0s/Q0c/P09DQ1NDQ08/Q1dHS1tTU19XW
        2NXW2NbW2NbW2NbW2tfX2dfX2dfW29nZ3tzc393e3dvc29nZ2tjX4N3d2NbXpKGi////////////////
        ////////////////////////////////////////////////////////x8TEwr6+x8bF0c/Quri4////
        ////////////////////////////////////////////AABvAABvAABvAABvAABwAABwAABwAABxAABx
        AABx////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////5OHi5OHi39vc3tvc39zc
        3tzcx8bSHR2LAAB+AAB/AAB/AAB/////////////////////////////////////////////////////
        ////39zc39zc29jY2dfX2NXW2NXV2dbW2NbW19TU1NHR1dLS1dHR1NDP1dHQwb7KBgaEAACBAACBAgKC
        WViiysjM0c7O0M3Nz8zMz8zM0M3Nz8zMzsrJzsvKz8zMZGOjAAB+AAB+AAB9AAB9AAB9AAB9AAB8AAB8
        AAB8AAB8////////////////2dbV1dHQz8rJ2NXV1NLSzcrKyMXFyMTEy8fHy8jIyMXFx8TDxcLCxcHB
        xMHBw8DAxMHAxcHBxcLCw8DAw7++wLu8p6OyaWicHBt+AAByAAByAAByAABxAABxAABxAABwAABwAABw
        AABvAABvAABuAABuAABuSUeKiIOhsKuwt7W0uLa1uba2uLa2uLW2ure3uLW2tbKzrqysioeHioeH////
        ////////////////////////////////////////////////////////////////////////uLa2uLa2
        r66urauqraqqX11cTEtKLS0sMzIxKyopJCQiJiUkNTQzp6Wle3h4IB8eJCMiQkFAoJ2dMjEwJCMiQUE/
        d3V1k4+PHx4dJCMiRENCioeGnZuaQD89JiUkQ0JBa2looZ+fQUA/KSknOTg3Xl1cb2xrREJBYV9ehoOC
        mpmYmpiXmpeXmZaWmZWVmJSUl5SUmpeXm5mYm5iXnJmZnZubnJqakI+OiYiHmZaWl5aWfHt7ISAfHR0c
        KSkoHh4dHh0cHx4dLy4tkI2NkI2MkI2NjoyMj4yMj4yNiomJjIqJkI2MHR0bNTQzMjEwd3RzGhoZHh0c
        LCsqgX18d3V0Ly4uNzY1PTw7JyYlGxsZHBwaKyopcm9vFhYVFxcXGhkYeXV1GBgYMTAvXlxbgX9+gH5/
        g4GBhoSDhoSEhIGCgX9/gH58fnx7fXp6fnx7e3p5enh3fHp6fnx8fXp6enh3d3R0dXNzeXZ2eHZ0d3V0
        ioeGpKGhwb2909DQ1dHS2dXW29jY1tPU0c7P0c7O1dLR1NHS0c7P0s7O1NLS1NHR1dLT2NLU////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        0c/Q0c/Q0c/P0c7P0dDQ0M7O09HQ0tDQz8zN0c3O0s/P0c/O09DQ1dLT1dLT1tTV19XW1tTU1tPT19TU
        2dbW1tTU1dLT2tfY3Nra2tjY2tfY29na2tjZ2tbXz83Nz83N////////////////////////////////
        ////////////////////////////////4+Hh1tTTx8TEwr6+x8bF0c/Quri429naysjImpeW////////
        ////////////////////////////////AABvAABvAABvAABvAABwAABwAABwAABxAABw////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////5OHi4t/g4d7f4d3e4N3d3NvcLy+SAAB+
        AAB+AAB/AAB+////////////////////////////////////////////////////////39zd29nZ2tfX
        2djX2tjY29fX2dbX2NXV1dPS1tLS1dLR1dPR1tLS1NDRkpC5AACCAACCAACBBwaDbWupzsvN0c/O0s/O
        0c7O0s7O0s/P0c7O0MzM0MzLz8vLu7jDGBiHAAB+AAB+AAB+AAB9AAB9AAB9AAB9AAB8AAB8////////
        ////////////////////2NXV1NLSzcrK1tTTzMnIyMTEyMTFycbGysjIycbGxcLCxsPCxcLBx8PDycfH
        x8TExcHBw8C/w7+/wL29wb6+oJ6zbGmeFxZ8AAByAAByAABxAABxAABxAABwAABwAABwAABvAABvAABv
        AABuBARwFRR2UE6NoqGuu7i4u7e3uri4u7m5urm5ure3u7i4trS0op+gop+g////////////////////
        ////////////////////////////////////////////////////////wb6+wb6+t7S0srCwr6ysraur
        c3JyTk1OHh0cHx8eHh4cICAeY2JhqqeoaWdnJyclIiIhNTQzqqenIB8eIyIhQD49cm9xgX+AKCcmJSQj
        Q0JAiIWFn5ybLy8tISEgKikodHNyop+fMjEwIiEgPz48VVNScG1tQkFBMTAvZGFigYB+TEpKf317kY2N
        mZaVmpiXc3JxcnBwgH58jouLmpaXnZmanJqanJuanZubmZaWmJWVmpeXk4+PS0lJISAfGRgXGRkYIyMi
        e3h4kY2OkI2NkY6NkY6Oko6Nko+PjoyMj42MkpCPHRwbOTg3MC8uZWRjGxsaISAfRkRDiYWETUtKIiIg
        GhoZGxoZGRgXFxcWJyUkZ2VkgX9/bGtqSklIRkRDg4CAGxoZMC8uWFZVb21sRUNCbmtqenh4goCAgH19
        e3h3d3Z0fXt6fnt7fXp6e3p5e3h4e3l5fXt7fXt6fHl5enh3eXd3enZ2end1eXZ1enh4dnV1dXNzjIqK
        qaamxMLC1dHS1dPT1NPT0M3P0czO1tLS09DP0c7O1NDR1NHR1dLT2NLU2NXV19fX1dLR////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////zMrL1NLSz83OycfI
        zszM0M7O0c7Oz8zM0tDO19TS1NDQ0M/P09LR09LR09DR1NLS1NLS0s/Q09DR1dPS1tPT1dPT1dLT19PU
        19TU2dfX3Nra3NnZ2tfZ1dPUuLa2uLa2////////////////////////////////////////////////
        ////////////////4+Hh1tTT2tjY4N3d4+Hj5eTl4uHh29naysjImpeWmpeW////////////////////
        ////////////////////AABvAABuAABvAABvAABvAABwAABwAABwAABw////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////5OHi4t/g5uPj5eDg4t7f4uDhZGOqAAB+AAB+AAB+AAB+AAB5
        ////////////////////////////////////////////////39zd39zd29jZ2tjY2tnZ29nZ2dXV19PT
        19TU19TU1tTT1dPS19XU2NTU1dLSZ2aoAwKDAACCAACCAgKDiIa01NDQ0s/O09DQ1NLR1dLS1tPT09DQ
        0M3M0c3N0s7P0c7OZGOlAAB+AAB+AAB+AAB+AAB9AAB9AAB9AAB9AAB8AAB8////////////////////
        ////////////////1tTTzMnIyMTEzcvLzMrJy8rJysfGx8LCyMTFycfHysjIy8jJyMXFxcLBxsPDx8TE
        xsPCxsLBxMDBw8HCw76/d3KhNTOHCAh1AAByAABxAABxAABxAABwAABwAABwAABvAABvAABuAABuAABu
        GBh3VFKPoJ2tu7i4u7m5u7m4vbm4v7q5uLa1op+g////////////////////////////////////////
        ////////////////////////////////////////////wb6+w7+/ure4sa+vr62tr6ytrqurcm9vaWhm
        aWhmdHJyraqqrKmpfHp5Ly8tJycmNDQym5qaHx8dIyIhPDs6ioiJf35/IiIgLCsqPDs6nJmZop+fHh4e
        KyopOTg3dHJxop6fHRwcISAfOjk4cG9tWVdXMzIxODc2aWdmfXp6IiIhTUtKYF5clJKSg4GBISAfIiIh
        LSwrRENBXFtaiIaFnJqan52dnpybnZubnpycnpybm5iXlZOSk5CQdHJxdXNylJOSlJKSlJGRk5GRk5CQ
        kY6OkI6Oj42Mj42Njo2Njo2NKiopJSQjMTAvXFpaHh4cMDAuYV9diISDODc2LCsqIyMiNzc2a2hoeHR0
        hIB/g4GAhIKCfnt7Z2ZlYF9fR0ZFJiUkMC8tNTQzUlBQHRwbOjk4UlBPfHp6bWtrOTg3SkdHVFJSZWJh
        dXJzfXt7f3t7fnt7fn18fXt6fHl5fXp6fHp5fXp6fXp6end3eHV1end3fHp6e3l5dnNzdXJyjIqKqaem
        xcLC08/P1NHS1tLU1dLS1M/Q1tLS19TU1tTU19LT2NXV19fX1dLR0c3M19TS2NbV////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////zMrLzMrL0tDQzczLyMbGy8jJ0M3Oz83N0M3M
        2NbT2djU0s7O0M7P0tDR0s/Q0s/Q09HS0s/P0c7O09HR1NLT1dLT1tPT1NLS1NLR19XV29nZ3Nvb2tfY
        29jZ0M/PuLa2////////////////////////////////////////////////////////////////4+Hh
        4+Hh393c3Nva4N/f4+Dh4+Dh4+Hg5OHh19TUuLa1mZeX////////////////////////////////////
        ////////AABuAABuAABvAABvAABvAABwAABwAABw////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////5uPj5eDg5ePj5OHiZGOqAwN7AAB+AAB+AAB+AAB5AAB+////////////
        ////////////////////////////////397e397e3dra3Nrb3Nra29nY2NXV2NXV2tbW2dXV1tPT1tPT
        2NXU2NXUzcrPSEieAgKDAACCAACCAwKDrqzD1NLR09DP1NHQ1NHQ1dLS19TU1dLS0c7N0tDP1NLS1dPS
        s7HCDAuCAAB/AAB+AAB+AAB+AAB+AAB9AAB9AAB9AAB9////////////////////////////////////
        ////////////zcvLzMrJ0c/PzsvJy8bEzMnJzs3Ny8nJx8PEx8LDx8TEx8TEycbGy8fGzMfGyMHBxcDA
        xcLCxMLCvLm+c3GgNTSHCQl2AgFyAABxAABxAABwAABwAABwAABvAABvAABvAABuAABuAABuGhp3WFeR
        m5mrtrO2vbm5wLy8trSzkpCPkpCP////////////////////////////////////////////////////
        ////////////////////////////////w7+/v7y9sq+vsK2tsK2ur62trqysrKqqrKmprKmprqurrquq
        raqqrKmpmZeXeHZ3f35+GxsZHh4cJCQibWxrICAfIB8fJiUkYF5dqqinpaKiJCMiLy4tQ0JBf3x8o6Cg
        Hh0dIiIgNTUzZ2VkMzIxKSknPz48bWtqbWtqHx8dLi0sQkA/npublpSUc3FxUU9OJycmSklJICAgVVRT
        j42LoqCgoJ6eoZ6eop+gnpycmJWVl5SUmZaVmJeWmJaVlJKSlJKSlpSTlpWUk5GRkY6PkpGRkZGQjYuL
        jYuMjoyNPDs6Ly4tLy4uPz49Ly4tNjU0aWdnhoSETk1MHh4cPTw7c3FwSkdHVFFQbGhogX9+enh4MC8v
        NzY1PTw7JyYlGxoZGhoZKSgmUlBPISEgKikoQ0E/gH19Q0FAHBwbJiUkHh0cIiEgSEdGcnBvgX99gX59
        f319f3x8f3x8fnx8fHp5fHl5e3l6eHV2eXZ2f3x6f3x7e3h4d3R0dXJzeHZ2e3h4enh3kY6Oraqry8bI
        19LU2NTV29bY2tjZ19XW1tLT1dHS0s7Q0MzM0c3M19TS2NbV0MzMzcjK////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////zcvLzcvLzszMzMrKzMrKzMjJzsrLz83N0c7N1NHP1M/Pz8zN0c/Q
        0tDR0c/P0c/P0tDR0dDQ0dDP09LS1dPU2NXW19XV09DR0s/P2NfX29ra2tfY2dbX1tPUxMHAxMHA////
        ////////////////////////////////////////////////////////////29nY4N3d3tvc3trb3NrZ
        3dvb4N3e4N7e4d/e39zczcrLmZeXmZeX////////////////////////////////////////AABuAABu
        AABuAABuAABvAABvAABvAABv////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////5ePj5OHi////AwN7AAB9AAB9AAB+AAB+AAB+AAB+////////////////////////
        ////////////////4N7d3t3d3dvb29nZ29nZ29nY29jY29nZ2tbV19PS1tLS2NTU2NXU2NXUsq/GMzKW
        AACDAACDAACCHR2NyMbO1NPS0tDP1NHP1NHQ1dHR1NHR09HR1NHR1NHR0tDP1dPS0M7NSkiQAAB/AAB/
        AAB+AAB+AAB+AAB+AAB9AAB9AAB9AAB9////////////////////////////////////////////////
        ////0c/P0M3OzcvLzszL0MzMy8jJxcLCx8PDyMbGx8TEyMTEycbGzMfGzMXDx8LBxMLCxcLBysXDxL/A
        qaW0bm2dMC+FAAByAABxAABxAABxAABwAABwAABwAABvAABvAABuAABuAABuBgZvKip+bWyZrqy0vLq6
        tbOynpubnpub////////////////////////////////////////////////////////////////////
        ////////////////vry7vry7tLGxsa+vsa+vsq+vsa6vrqysrqurr6ysr62sr62traqqqaioqaanp6Sk
        p6SkjIqJXVtbTkxMjIuLOTg3KCgnJiUkSUhHfHt7Ly8tICAeJCQiSUhInpqagoCAKikoJiYkU1FRd3V0
        Hh4dIiIgOTg3Z2VlZGJiHx8eKyopUlFQoqChnJqaWVhWXVxbeHd2n5ydLi0tIiEgQkFAmJeXoqCgoJ2d
        o6Cfn52cmJeWm5iYnpybm5iYl5SUlZKTlZOUlpWVlZKSko+Pko+PmJaWmJeWlJGRk5CQlpOTPz08Ly4t
        KCgnKSkoLy4tLi0sj4yNjIqLa2ppGRgXJCMiVFJRRURCPDo4QD8+cnBvUE9OIyMhGxoZGxoZGRgXGBcW
        KCcmamhnRENCGxoZKikoNTQygHx8JSUkFxcWGhkYZ2ZlLiwsIiEgTEtKfXx7f3x8cW5ueXh3goB/fnt8
        fHl5fXt6fXt6e3l5fnx7gH59fXp5fHl5fXt7e3l5e3d4fHl5fHl5end3c3Bxb21ujYqKrqyszMnK19PU
        19TV1dPS1NDR0s7P0c7N1NLR2NXV1NPT0MzMzcjK19TU19TU1dLT////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////zMrKzcvLzMnJzcrLz83Nz8zNzsvLzszMzszMzMnJzMnKz83O0c/Q0tDQ0c/P0c7P0M7O
        0M7O0M/P1NLS1tTU1dTU1tPU1NHR0s/Q1tTU2NfX19TV2NTV1NDRsq6vsq6v////////////////////
        ////////////////////////////////////3dvb3dvb29nY393d39zd4Nzd39zc3tzc393c4d7f4uDg
        4uDh2NXWu7m5nZua////////////////////////////////////////////AABuAABtAABuAABuAABv
        AABvAABvAABv////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////AAB9AAB9AAB9AAB9AAB+AAB+AAB+AAB+AAB+AAB+////////////////////////4N7d
        4N7d3dva29jY29nY3Nva3dvb3drb29jZ2NXV2NTU2dbV2dfV19XU19TUtLHHFRWLAACDAACDAACDPj6a
        zcvR1NLS0s7O1NHQ1tPS1dPT1NLS09HQ1dPR1NHQ0c3N09DPzcvLoqCtDAx/AAB/AAB/AAB/AAB+AAB+
        AAB+AAB+AAB9AAB9////////////////////////////////////////////////1NHS1NHS0M3OzMvL
        zsvLzsvLzcrKysfHycfHy8jIysfGx8TFyMbFzcjGzcjGx8TExMLCyMTDzsnGzcfEyMLBxcLBtLK7hYKn
        NzaIAABxAABxAABxAABwAABwAABwAABvAABvAABvAABuAABuAABuAABtJSR8a2qYp6WwmZeXmZeX////
        ////////////////////////////////////////////////////////////////////////////////
        vbq6vbq6uLS1tbKytbGwtbGwsq+vsK6usq+usrCwr66urq2traurqaenpaOkpqOkqqenrKipqqioqKWm
        qqWmV1VUISEfLSwsMjEwSEdHR0VFMjEwJCQjSUhIY2JghYKCISEfNzY1S0lIgX9+OTg3IyIhVlVUi4mJ
        XVtbISEgNzY1YWBepqSlaWhnKCcmTExKXl1bZWJjOzk5TExKY2JhkY+OoJ2dn5ycoZ6enZybmZiYmpeX
        mZaVl5SUl5OUl5aVmJaWl5OUlJCQk5CQlpSTmZaWmpiYnJqZmpiXlJKROzk4GxoZGxsaHBwbIB8eUlFQ
        mpaWlZOSioiIWFdXICAfHR0bJCQjHBwaHx4djYqKOTk4LCsqJCMiOTk4bmxrfHt6i4iIioeHNjY1GhoZ
        KSgnSkhHh4SEeHZ1UlBQMTEwhoODODY2KikoU1JRbWxrVlVUODc1VFNTYV9fbGlofnt7gX9+goB/goB/
        gH1+gH19fnx8fXt6fnx8gH5+f319fXt6fXt7fHl5dHJxcW9vdnRzeXd3eHZ2kpCQsbCvzsvM1dDR1NDP
        1dPS2NTV19XU1NHS09DQ1tLS19TU19TU1dLT////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////zMrKzMrK
        y8nIysjIzszN0NDQ0M/OzsvLzcrKzsvLzsvLzcvLz83N0M3Oz83N0M7O0c/Q0M3N0M3N0M7P0s/Q1NLS
        09HS1NHR09DQ09HR1dLT1dLS1NHR1dPT1NHRwr/Awr/A////////////////////////////////////
        ////////////////////3dvb3dvb2NXV29jZ3tvc4N3e393d397d393d4d7f4+Dg4uDg393d0M3NnZua
        nZua////////////////////////////////////////AABtAABtAABtAABuAABuAABuAABvAABvAABv
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////AAB8
        AAB8AAB9AAB9AAB9AAB9AAB+AAB+AAB+AAB+AAB+AAB/AAB/////////////g4Gv4t/f39zc3dnZ3drZ
        3dra3Nra3tzc3dvb3NnZ29nZ3dza2tnZ19PT09DRlJK7BweGAACDAACDAgKETk2gysjP1dHQ1tHR19PT
        1NHR1NHR1NHR1NHQ1dLR1NHR08/P1NHR0M3Nure2Li2CAAB/AAB/AAB/AAB/AAB+AAB+AAB+AAB+AAB9
        AAB9////////////////////////////////////////////1dHR1dHRz8zMzcrKzszMzszMzcvKzMnK
        ysjJy8jIzMnJycfHycfGy8fGysfGyMfHyMXFycTEzsjFzcbDyMTDxcLCxMHCw8DAxMLClZKuTEuQHh59
        AABxAABxAABwAABwAABwAABvAABvAABuAABuAABuAABtAABtHh55X16MX16M////////////////////
        ////////////////////////////////////////////////////////////////wb+/wb+/uLW2tbGx
        trKwt7KwtLCwsq+ws7GxsbCwrqysrampr6yssa6urqysrKmqq6iorqmqrKmpqqamrKalaWdlJyYlICAg
        SEdGpaSkdHJzIB8eIiEgNjU0KikoaGZmISAfKikoSEhGjIqIOjk4MzIwYV9flpSUQ0JCIiIgODc2ZGNh
        op+fZWNjICAeJiUkMTEvMjIwISEgOTg4UU9Pi4qJoZ+fop+foJ2dmJaXlJSUmJeWm5mYmpiYmpiYmpiX
        mJaWl5STlpKSlZSTmJaVnJqanZmZnZmZmJaWlJKSg4CBXFpZMTAvGBcWHRwbYF5el5SUmZeWlJGSjImK
        hIKCV1ZVPTw8Pz08b21tjImJTk1MHh0cPTw7dnN0TExMV1dWbm5thIKCODc2HBsaLCwrTEtKjIqJiYeG
        bWtrZmRjUE5OKikoODY1PDs6amhoNjU0HBwbLy8uMjEwSEZGgoB/hIKBhIGAg39/gn5/f3x9gHx9fnt7
        fnt7gH59fnt7end3enh3fnt7end2d3R0eXZ2e3l5d3R0cnBwcW9vd3R0kY+PrqyrzsrL1M/Q1NHS1dDR
        19LT2NbU1tTU1dPT1dLT1dLT////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////wL6/ycfHyMbGyMbGysjIy8rK
        zcrKzsnIzMjHy8nJzszNzszMzMvLzszLzszMz83N0c/Q0M7Oz8zMz8zMzszM0M3N0c/P09HR09HQ09HR
        1tLU19TV1tXV19bW19XWyMbGyMbG////////////////////////////////////////////////////
        ////4N3e3dvb3NnZ29jZ2tfX2tjY3Nra3drb3dvb39zd4N3e4d7f4+Dh2NbWs7CwlpOU////////////
        ////////////////////////////AABsAABsAABtAABtAABtAABuAABuAABvAABvAABvAABv////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////AAB8AAB8AAB8AAB9
        AAB9AAB9AAB+AAB+AAB+AAB+AAB/AAB/AAB/AAB/AAB/g4Gv2NXd4Nzd3tvb3tva3Nna3Nna3tzb3Nra
        29jZ29nZ3Nra2dbW19TU19PUZGOpAACDAACDAACDAwOEYV+n0c/R1dHQ2dbV29jY1dLS1NDQ1NDP1NHR
        1tXV19XU1tPT19XV09HQtrW0YmCEAACAAACAAAB/AAB/AAB/AAB/AAB+AAB+AAB+AAB+////////////
        ////////////////////////////////2NXU2NXU1dHQ0M3NzcvLzcvK0M3Nz83Ny8nJysfHy8jJycbH
        ycbGysfHysjIysnIycfHyMTFy8XEysXEx8TEx8TEx8TEx8XEx8LCx8LCwL3An52xUVCQJyeACAh0AABw
        AABwAABwAABvAABvAABvAABuAABuAABuAABtCQlxAABt////////////////////////////////////
        ////////////////////////////////////////////////u7m5u7m5trS0tbKytLGxtK+wtbCws7Gy
        sLCxrq6vrqysrqursa2stLCvtLGwsa6ur6urr6uqr6uqrqior6mpramprKenfHp6ioiHsK+ufXx8Li0s
        Hh4cISAfnZubZ2VkHx8dJCQiQUA+iISFICAgODc2V1ZVpaOjQ0NCJCQiQD49d3V0oJubSUhHIB8eLy4s
        YWBebWxsJycmISAfIiEglpSUoJ6eop+foZ2dmpeXkpGTY2NkbWxrh4WEnJmZnJmYmZeXmZaVlpOSlJGR
        mJaWnZuam5eXl5KSlpKSlZKSlpOTlZKSlJCRg4B/XVxaiYeHmZeXmpiYm5iYkY+Oi4mJjoyMkI2Nj42L
        j4yMjouLbGpqGRkYJCMiUk9PRURDPT07QUA/cm9uISAfHBwbNDIybGlpiIWFOzk5Ojk4QUA/KiopGxsa
        GxsbHRwbdXNzPTs6GRkYGhoaNzY1b2xsd3V1U1JRZGFhdnRzgn9/gX5+gX1+gH19f3x8gH19fnt7eHV1
        eHV1fHl5fXt7e3h4eHV1d3R0d3R0dHJyc3FydXN0dHN0cG5vd3V1lZKSsa6uzsnK1NDQ09DQ09DQ1dDQ
        0s7OzsrK////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////wL6/wL6/x8bFxsTDxsPDyMPEyMTFysfHzMjIysfHyMbG
        y8nJzcrKy8nJzcvLzsvM0M3O0M7NzcvLzcnKzszMzs3NzszL0M3N0dDP0c/O0c/P1NLT1dLT1NHS1tTU
        1dPUure3ure3////////////////////////////////////////////////////4N3e4N3e29fZ2tjZ
        3Nra2dbW2tfW3NrZ29jZ3Nra393d39zd4N3e4eDg3dzcycbIlpOUlpOU////////////////////////
        ////////////AABsAABsAABsAABsAABtAABtAABuAABuAABuAABvAABvAABv////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////AAB8AAB8AAB8AAB8AAB9AAB2AAB+AAB9
        AAB+AAB+AAB+AAB+AAB/AAB/AAB/AAB/Dg6GUE+ioJ7D2dba3tvb3dzb3tzc3dra2dfX2dfX2tfW19TT
        2NXV2tjYNjWXAACDAACDAACDAACDgH6029jX2NXU2dbV2tbX19TU1tTT1tLS1tPS19XV19TU1tLS2NXV
        2NXVzsvLt7a2Hh6CAACAAACAAAB/AAB/AAB/AAB/AAB+AAB+AAB+AAB+////////////////////////
        ////////////////3Nna3Nna1dPS1NDQ0MvLzcnJ0M3Nz83NycfIycfIzMrKysjIysfHysjIy8jIzMjI
        y8fHycbFysbFzMjGy8bFx8PEx8XEyMXFx8TEx8PDyMTEw7+/srC3nJquYWCXHh59BQVzAABwAABwAABw
        AABvAABvAABuAABuAABuAABtAABtAABtAABt////////////////////////////////////////////
        ////////////////////////////////wb6+tLKxsrGwtbOztLGxtLGysq+ws7CwsK6vrq2tr62ssa6u
        sq+vsq+vs66usK2sr62tsa+us6+usaurr6urrqurq6inrampr6ysr6ysramqq6iojYuLcnBwqaWmb21t
        HRwbHh0cIyMhdXNyISEfMTEvWllZpqSlISEfJSQjQT8+dnRzo6CfSkhHISAfNzY0bGppbWxsHx8eXFta
        W1lZn5ycnpuaop+fo56enZiZl5aXTU1NS0tLPj08XVpadnRzj42Nl5WVl5OUl5SUmJaVmZaVl5SUmJWV
        l5STl5STl5STl5WUlZKRko+OlJGQl5SUl5OUmJaWmZWUko+Pi4mJjYuLkI2NkY+OkI2Nj4uLjYqKXVxb
        ICAfHBwbJCQjHBwaISAfjImIGhkYHh0cPTw7aGZmY2FhIyIhHBwaGxoZGBgXFhYWHh4cU1FShoSEKign
        MjEwJiUkWVhXhIKCTEtKLy4tPTw7TUxLaGVlaWdmfHl5gHx9amhodnR0fnx8enh3e3d4fHp6gH5+fnt8
        dnNzdHNzeXd3e3d4eXZ2eXd4e3l5d3V1cnBwcW5ucnBwfXt7mpaWsaytzsrK1NDQ0s7NzsrKzsrK////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////xcLCxcLCxcLCxcPCyMXFxsPDxcLCx8XFycfHyMbGx8XFycfHysfGycbGysjJ
        zMrKz83Nz8zNzcrKzsvL0M7Oz8zNzcrKzsrKzszMz83M0M3Oz83NzszLzsvM1dLS0tDQure3////////
        ////////////////////////////////////////////////2tfY2tfY1tPT1dTU19bV19XU1tTT2dbW
        3NnZ3dvb3tzc3tvb3tvb3tzc4N7e1NLTtbS0tbS0////////////////////////////////////AABr
        AABrAABsAABsAABsAABtAABtAABtAABuAABuAABvAABvAABv////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////AAB7AAB7AAB8AAB8AAB8AAB2////AAB9AAB+AAB+AAB+AAB+
        AAB+AAB/AAB/AAB/AAB/AAB/AACAQ0KbfXyzr67J29nc393d3NnZ2tfX2tfX2tfW2tfXw8DOBASEAACC
        AACDAACDAwOEravG29jY2dfX2NXV2tXV2NTV2NXV2NXU19XU19TU1tPT1tLS2dbV29jY29fXw8HBbWuO
        AACAAACAAACAAACAAAB/AAB/AAB/AAB/AAB+AAB+AAB+////////////////////////////////////
        ////3Nna1NPS0c7O0c7OzsvLz8zMz8vLy8nIy8nIzMjJycbGyMbHy8jIzcnJzsrKzsnJy8jHzMjHzsnH
        zMfFycXEysfGy8jHyMXExsHBxsHBxcHBwr+/wsDAwb6/o6GxenigNzaGAABwAABwAABwAABvAABvAABv
        AABuAABuAABuAABtAABtAABtAABt////////////////////////////////////////////////////
        ////////////wb6+wb6+uLW0tLGxtbOztbOytLOztLOzt7S1uLS0tbKxtLGxtLGxtLKxs7Cwta2rt62q
        tK6ss6+vs66us6yrs62rsq2rr6uqsKuqsa2tr6urraqqq6ioqqenq6iorKioc3FvfHp5cnFwYl9fbGpr
        Hh4cISEfLy8thoODIiEgKCcmOzs5ioqIqKWlMTEwIiIgLSsqZ2Vlf319R0VER0RDXFtboZ2cnpuaoZ+e
        n5ybnJmZnpuaSEdHNjY2ICAfXFtbSkpKX2Bge3t8lZOVmJWWnJiYm5iXmJaWm5qampiYlZKSlJGRl5SU
        l5STkpCPkI2LkI2MlZGRlZKSlJGQkI2NjYuMjoyLko+Oko+PkI2NjouLkI2NkI6Nh4SEVlRUPTw7Pj08
        bmtrd3RzGhoZHx4dNzY1YGBfWFZWIiIhKysqKikoZGJicW5thIGAhoSEiYeHHBwcJCMiOjk4Z2Zlg4GB
        NTQzHBsaIyIhLy4uJCMiQEA/TEtKU1FRUlFQNzY0VVNScG1tfXt6f318gX9+f3x8e3l5e3l5fnx8fHl5
        enh3e3l4e3l5d3V1dXJydXJxd3V0eXh3eHZ1cm9veHZ2l5SUuLW1w7/Aw7/A////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////vLm5w8C/wsDAw8HBx8XFyMbGx8TFx8XFx8XFxsPDxsTEycfIysjJysfHycbGyMbGzMrK0c/P0M7O
        zcvKzsrKzsrKzszMz83NzszMzsvMzMnJy8jIzsvLz83NzszMwL29m5eY////////////////////////
        ////////////////////////////////1dLS19XV1dPT09HR1NLR1NHR09DR19XV29jZ29jY29jY29nZ
        29fY29jY3dvb2tnZy8rKs7Gy////////////////////////////////////AABrAABrAABrAABrAABs
        AABsAABtAABtAABtAABuAABuAABuAABvAABv////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////AAB7AAB7AAB7AAB8AAB8AAB8////////////AAB+AAB+AAB+AAB+AAB+AAB+AAB/
        AAB/AAB/AAB/AgKBBAOBFBSJSUiegX+1srDJ29jZ3NnZ3dra3NnZnJm/AACCAACCAACCAACCHR2OzMrT
        2tjX2NXV2dXU3NjY2tfY2dbW2dbW19TU19XU2NTU2dXW2NXV19TU2NXUy8nIoqChFxd7AACAAACAAACA
        AACAAAB/AAB/AAB/AAB/AAB+AAB/////////////////////////////////////////2tfX0c/PzczM
        zszMz83Nz83N0czLz8vKzMrJy8jIycfHysjJy8nKzcnKzcrKzcrKzcrKzMnJy8fGy8bFysbFy8fHzMrI
        y8jHx8TExMLCw8HBw8DAxMLBxcPDw8HAwb++wr6+lJKtWVeVGBd6AABwAABwAABvAABvAABuAABuAABu
        AABtAABtAABtAABtAABsCQlv////////////////////////////////////////////////////wr++
        wr++vbq6t7SztrSzuLa1t7W1uLa1ube2ube2uLa0tbKytLCwtLGwtLKxuLCvvrGtvLCstq6ss62stKyq
        uK2qta2rs62ss66ts6+usK6tr62sr6ysrauqrqurrKmpRkVDJyYlTUxKcW9vnJqaamloVVRSYF5eQ0JA
        Hx4dIyMhPTw7h4eGq6mqISAfNjY0UU9PlZOSaWdmJyclRUVDZGNhpKGhoqCgpKGhnpybm5mYnJmYbGpo
        OTk4MTIxODg3ICAfUFBPfX19hoWGZWVkgX59lpOSmJWUmZeXm5mZlpOTk4+PlJCQlJCQlJGQk5GPk5CP
        lZKSlJCQkY6NkpGRk5GRlJGRk5GQko+PkI2MkI6OkI6Nj4yMj4yMj42MjouKjYuKjIqJbWxsGhkYHRwb
        LCsqcXBvYF9dJCMiLSwrZmRkX11cRkRDZ2ZkfXt6end3GRkYHBwbNzY1cnBviIaFNDQ0GRgXHRwbXFpa
        RUNDOzk5OTg3VlRTVFNSJiYlOTg2Y2FfW1lYSUhHa2ppd3V0gX9+f3x9e3l5enl4enh4eXd3dHNydHFx
        d3V1enh3eXd2eHd2dXR0dHJyb2tsbGpqe3p5w7/A////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////vLm5vLm5xMHBw8HB
        w8DAw8DBxcPDxsTEx8XGx8TEx8PCyMXEycfHy8jJysjIycbGx8TFycfH0dDPz87OycfHycXFzMnK0M7P
        0tHR0M3OzMnKycfHy8nJ0M3N0M7Oy8nJvbq6m5eYm5eY////////////////////////////////////
        ////////2dXW2dXW1dLS19XV1dLS09HQ1dPS19XU2NXV2dbX2dbX2NXW2dfY2tjZ29jZ29nZ3Nra3dvc
        1tPUs7GylZKU////////////////////////////////AABqAABqAABqAABrAABrAABsAABsAABsAABq
        AABtAABtAABuAABuAABvAABu////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAB7AAB7AAB7AAB7AAB8AAB8////////////////AAB+AAB+AAB+AAB+AAB+AAB/AAB/AAB/AAB/
        AAB/AACAAwOBBAOBGBeKTEufg4G1tbPK3NnZbGutAwODAACCAACCAACCNzeYzMnT2tbW2dbV3NnY3tzb
        3Nzb2tjX19TU1dLS19TT29fX2tfY2NXV19TU3tvb09LRqaenNDNWAACBAACAAACAAACAAACAAACAAAB/
        AAB/AAB/AAB/AAB/////////////////////////////////2tfX2tfX1dPS0c/Pz8zNz83N0M3N0MvL
        z8vLzMrLzMrKzcvLzsvMzszMzczMzMrKzMnKzMrKzMnKy8nJysjHycXFyMXFysfHy8jIycbGxsPDxsLC
        wsDAv729w8DAxMLCwr/Aw8HCxMLDxMLCsrC5YmGZOTiIERF3AABvAABvAABvAABuAABuAABuAABtAABt
        AABsCQlvAABsAABsFBRy////////////////////////////////////////vbq6v7y8ube2uLW1uba1
        ube2u7i3uLW1trOys7GwtLKytrKytLCvs7CvtLGxtrOzurOxv7KvvbCutK6ts62sta6stq6ttK6us7Cv
        sq+vsK2tsK2tsK2tsa6usK6trquqjoyLX15dMzIyZGNjr6ysrampq6enq6ioe3p6Li4sHx8fPz09qaan
        q6qqIyMiR0ZEUVBPko+QUE5NJCMiPDw6ZWNipqSkp6SlpaKioZ+enpybnZmZMTAvSEdFT05MZGNinJmZ
        ko6Nko6OOTg3OTg3VlVVYWBegX59hIGAmZaVmZaVl5OTiYaGZGFhcG5tg4B/joyLl5WUlZGRk5CPk5KR
        lZOUlZOTlZOTlJGRkpCQkY+OkI2NkI2NkY+PkI6NjouLjYuKjIuKdnRzISAfGhkYHh0cb21shIOCICAf
        Hh0cR0VET01NODg3SUhHZGFhbGlpICAfHR0cNjU0cG5ti4iIPj08ICAfJSUjb21sODg3KyopOjg4UE5O
        Pj49KyopOTc2ZmRjU1FQJCMiQD8+VFFRgn9/f318bmtqcG5tfXt6eHV2dnN0d3RzeXZ2eHZ2eXZ1d3R0
        dnR0eHZ1cm9vcGxue3p5////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////xMDBxMDBw8HCwsDAw7+/wr/AwL2+wL+/
        w8HCxMHCyMTDy8fGycbGxsPEx8TEyMTFx8XFyMXFy8nJy8nJycbGycbHy8nKzcvM0M3Nz8zMzMnIzcrK
        zcvKzMrKzMrK0M7Nx8TEm5eY////////////////////////////////////////////////2dXW2dXW
        0c7P1NHS09DQ1dLS19TU2NbW2NbW2NXV2NXV2dbW2tnZ29na3Nra3tzc3Nvb29na2dbYycfIlZKUlZKU
        ////////////////////////////AABpAABpAABqAABqAABrAABrAABrAABsAABqAABtAABtAABtAABu
        AABuAABuAABuAABv////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAB6AAB6AAB7
        AAB7AAB7AAB7////////////////////////AAB+AAB+AAB+AAB+AAB+AAB/AAB/AAB/AAB/AACAAACA
        AACAAwOBAwOBGxuMTEufKCiRAQGBAACCAACCAQGCTk6izcnT2tXW3NnZ397d3tzc3tzc29nY1tPS1tPT
        2tbW29jY2tjY2dfX29fY3NnZ0c/PramoeXV0AQFoAACBAACBAACAAACAAACAAACAAAB/AAB/AAB/AAB/
        ////////////////////////////////////2tfX3Nra1tLT0dDQz87Oz83Mz8zMz8zNzszNzszM0MzM
        zsvMzczLzs3Mz8zMzsnJzMnKzcvMz8zNzMrKycfHyMbGycbGysbGycXFzcXDz8bEyMPDwL2+vry8wL2+
        w8DAxsPExcPEw8LCw8LBwL3At7W7mZauTkyQHBx8BwdyAABvAABuAABuAABuAABtAABtAABtAABsAABs
        FBRyAABsAABrR0WD////////////////v7y9v729w8LBvbq6vbq6uLa2uLW1ubW2uba2ure3uLW1tbKy
        s7CwtbGxuba2uLS0t7OyuLSztrO0trOzvLSyvbSztrGxsrCvs6+vs6+vtLCws7Cws6+wsa6usa6usq6u
        sa6usa+ur6urrqurraqrsK6usK2trKmoq6ioramqrqyssa+unZuba2hompiXrKmorKmpMzIyLCwrPz49
        f3x8Li4sJyYlQkFAend3paKipqOjpaKhpKKho6CgoJ2dMzIxOzo5MTAvg4B+nJeWm5eWmpaVJSUjISAf
        MjEwLy4tJCMhSEVEZWNhgH58m5eXSEZFHx4dISEfNTQySEZFbm1slpSTlJGPko+PkZGSkZGSlJOTmZaV
        lpSUkpCQkY+Pk5CQk5CPko6Oj4yNj42MkI6OcXBvY2Fha2loRENDjouMjoyMdnNzKCcmGxoZJCMiHR0c
        JCMic3FwbmtqHRwbJSQjMTEwgn9/iIaFcXBvICAfHR0cXlxaOjk4HBwbKyopODc2GxsaJiUkMzIxamZm
        REJCGhkZLCsqSkdHg4CAbWxrLCsqS0lIW1hYZmNjfXp7fXp6e3h3end3eXV1eHR1eHV1eHV1d3V1eXZ3
        eXZ3////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////uLa3wb+/wL+/wL6+wb+/wsDBwL/Av729v7y9wb6+xsLDycbH
        x8TFxMHCxMLCxcPDxcPCxsTDxcPDyMXFy8jIzMnKysnJycfFysjIzMnKy8jIzsvLzMnKyMbGy8nIz83M
        vru7jYqL////////////////////////////////////////////////0s7O19TV0c/Q09HR1NLS2NXV
        1tPU1NHS09DR1NLS1tPU2NbW2tjX2tjY2dfX2dbX2NXV2dbX3Nrb0M/Qr66ur66u////////////////
        ////////////AABpAABpAABpAABqAABqAABqAABrAABs////////AABtAABtAABtAABtAABuAABuAABv
        AABu////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAB6AAB6AAB6AAB7AAB7AAB7////
        ////////////////////////////AAB+AAB+AAB+AAB+AAB/AAB/AAB/AAB/AAB/AACAAACAAACAAACA
        AgKCAACBAACBAACBAACBAwODXl2o39zc3dnZ3dvb3tzc3dva3dra3NnY2tbW3NrZ39zc3dra29jY2tfX
        2tfX3NjY1tTUwb6+ko+QPz5rAACBAACBAACBAACAAACAAACAAACAAACAAAB/AAB/AAB/////////////
        ////////////////////////3Nra2tjY09HR0M/Ozs3Mz83N0s/Q0M3OzcrKzsvLzcvLzMrKzcvL0MzM
        0MzLz83M0M7Nz8zMzcrKy8rKy8nJzcnJy8jIzMjH0MjG0MjFy8bFyMbGxsTFxsPDxsPDx8PDx8TExsTE
        xsPDxMPBwsHBwr/AtbK7kpGtZGOaNjaGGhp6BgZyAABuAABuAABuAABtAABtAABsAABsAABsAABrR0WD
        CQlvOTiDfnuXxMHCv7y9v729w8LBvry8u7i4vLq6vLm5uba3ura3uLW1uLW0ure2ura2ubW1ura4vLi4
        vbe2vba1uLKyt7OyubW0uLW1uLS0tbGwtbCwtLGxtbKytbGytLCxtLGws7Cvs7CwsrCvsq+vsK2tsa2t
        sa6vsK6usK6trqysr62tsK2usK2tsa2trqurrqqqrqyrraqprKipkpCRMTAwIiIgIiIgICAeJCMiNTQz
        fHp6p6WlpaKipaOjqaenp6WlkI+PIyMhNjY0Ojg4hYKBn5ubpKGhmZeWHR0cICAeLSwqend1Pj08ISAe
        Q0E/Xl1cmpeWfnx8XltaNDQyNDMyLS0sLi4sZ2Zkko+OlJGQlZOTkZCQkZGSl5SUmZWVlpOSlJGRlJGR
        k5CQkpCPko+PkY+Pk5GQW1pZIB8eNjU0XFpZj4uMkIyNj4yMjYuKXl1cRkRENzY1YWBfeHV1GxsbHBsa
        ISAfUE5Ni4iIgH5+amlogHx9MTAvHh0cJCMiHx4dNzU1VFJSGBgXHRwbLy4ubmprNDMyGhoZLCsqWVdW
        gn9/Uk9QGxoZKCgnMC8uMC8ugH5+fnx8fnp6fXp6end2d3R0d3V1d3R1e3l5e3p6e3p6////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////uLa3uLa3wL6+v729wL69wL6+wb+/w8HBxMLCwsDAwb6+wsDAxcLCxMHCxcPDxsXExcTD
        xcPDxMLCxcLCx8TEysjIysjIysjHysfHysfHysjIycfHysjIycbHx8XFzMnKzcvLvLm5jYqLjYqL////
        ////////////////////////////////ycbFzMnJ0s7O09HR09HS09HS1NLT19XV1tTU1dLT1dLT1NHS
        1dLS19XU19TU1tTU1tPU19TV19XV2dbW3NnZ1tXVxcTEr6yt////////////////////////////////
        AABpAABpAABpAABpAABqAABqAABrAABr////////AABtAABtAABtAABtAABuAABuAABuAABu////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAB6AAB6AAB6AAB6AAB6AAB7AAB7////////////////
        ////////////////////AAB+AAB+AAB+AAB+AAB/AAB/AAB/AAB/AACAAACAAACAAACAAACAAACBAACB
        AACBAACBEBCJb22usrDK39zc3tvb2tfY3dra3tva3tvb3dva3Nra3NnZ3NjZ3NjZ2tjY2tjZ3dvb1dPT
        wr+/lJKVDg14AACBAACBAACBAACBAACAAACAAACAAACAAAB/AACA////////////////////////////
        ////////3dvb3dvb1dPT0c/Pz8zMz83N0s/P0s7OzsrKzMjJzczLzszMzszMzszN0M3N0c7O0M3Nz8zM
        zszLzsvLzcrKzsrKzcnJy8jIzMjIy8fGy8jGysjIy8jIzMnIycbGxsTEx8TEx8XDx8PDyMXFzszMysjH
        x8XFx8XGw8LFr6y6lJKvZGKaMTCEAQFuAgJvAABuAABtAABtAABtAABsAABsAwNsCQlvOTiDfnuXxMHC
        wsDAwsDAxMLCwb6/v728wL69vru7vLi5ure4uri3ure2ura2ura2ure3u7e4u7i4vbm4vbe2vLWyuLOy
        trSzuLWzvbe0urSyta+vtrOxtrKyt7OztrKztLGxtLGxtLGws7Gws7Gws7Cwsq+vsq+vrqyrrqyssrCw
        srCwsq+usKyssK2traurraqrr6yrr6yrr6ysr6ytpaOihoWDmJWVPz8/HRwbJCMihYSEraurrKqqrKur
        rKqrq6ingoB/R0ZFPz8+SUlIT05MhIKClpOSgn9+QUFAIiEgOzo4fXl5Pz48ISAfNzY0aWdmmpiYamhn
        UlBPX11dioeHYF1eKCcmKSgmZGJhl5WUl5OSlJCPk5CQkpGRk5KRl5OTlpOTlpOTlpOSlZKSk5CQk5CR
        k5GRg4GAWVdXMTAvNDMykI2Nj42MjYqKj42MkI6OkY6OkI6OkI6Ofn18MTAvIyMhICAfPTw7ZGJicW5u
        WlhYSkhHUU9PT0xMGRkYJCMiOzo6V1RUIB8fHRwbTUtKhoOCLi0sHBwbNTQzYV9fgn9+UE5OGBgXGhoZ
        ISEgZmRkgoB/gH18fXp6fHp6fHp5end3eHV2enl6fXx7e3p6////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////vbu7
        vbu7vry8v7y8wLy9wb29v7y8v729wcDAwsDAv7y8wLy9wb2+wr6/xMLCxcTDw8HBxsTDxsTExcLCxcLD
        x8XFycfGyMbGycbHycXFyMXFyMbGycfHyMbFx8XFx8XFy8jJxcPDrKmpiIWF////////////////////
        ////////////////ycbFzMnJzMrL0tDR1NLS1NLS1dTU1dTU09HS1NLS1tTT1NHR09DQ1NHR1dHS1NLT
        1tPU1tTU1tTU19TV19TU2NXVzcvLr6ytr6yt////////////////////////////AABoAABoAABpAABp
        AABpAABqAABqAABq////////////AABtAABtAABtAABtAABtAABuAABuAABu////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////AAB6AAB5AAB6AAB6AAB6AAB6////////////////////////////////
        ////////////AAB+AAB+AAB+AAB/AAB/AAB/AAB/AAB/AACAAACAAACAAACAAACBAACBAACBAACBAACB
        AACCLSyUZ2WshIO3ubnN3trc1NDY3tzb2NXV3NjY4+Dg4N7e2dbW1dLT2NXV3NnZy8nInpycLi5TAACA
        AACBAACBAACBAACBAACAAACAAACAAACAAACAAACA////////////////////////////////////3dvb
        29nZ1NLR0M7P0M7P09DQ09DQ0c7Oz83Nz8zNzcvMzszMzcvLzMrKzsvLz8zMzszMz83Mz8zMz8rKzsvL
        zsvKy8jIy8fIy8fIy8jHysjIycbGycbGysfHyMXFx8PDx8TEyMXEwr+/wb+/zMnJzMnJy8jJy8nJysjH
        ycbGwr/Dqqi4Y2GZMjKECwtzAgJvAQFuAABtAABtAABsAABsAABsAABrXlyVvru9wb29wb6+wr2+wr6+
        wsC/wb6+wL29v7y7vbm6vLm5vLm4ure3u7i4vLq5vLm5uri4vbm4wbq4vri2uba1trOzvLi2wry5vba0
        trGyt7S0t7Szt7OzuLW1t7OztbKxs7GwsrCvtLGxtLKxtLGxsq+vr62srqussKytsa+usa+ur62srqys
        sK6usa+vs7Cwsq+vr6ysrKqqrKmprKmqrqussa6wlJGSZGJinZqaraqqrquqraurrqusrqurfHt6JSUj
        RkVEPTw6KikoMjEwb21scG1tMjIxKyspQ0JAn52cHh0cISAfOzo4b2xrmpaWKSknOjg3V1VTUE1NXlxb
        RkVDamhnaGZmmZaWmJSUjoqKjouKlJKSlZOTlpOUmJaWmJeWmJWVl5KTlpOTlJKSlJKSlZKRlJGQkI6O
        kI2Nko+PkpCPkIyMj4uLkI2NkI6Oko+PkY6OkI2NSkhIHBwbJiYkKiopPz09bWtrHBwbLCsqWVhXfXp6
        GRgXHRwbOTg3amhpKyopKikpWFdWhoODGRkYHRwbNTMyYl9ehYOCRENCHBsaOzo5QT8+goCAgoGAg4F/
        gX59f319fnx8fXt7fXt7f319gH19gH19////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////tbOzu7i5vLm6v7y8v7y8
        vry8vru7vru8wL6+v7y9vbu7vry7v7y8wL2+wr/AxMHBxcLCyMbFyMXFxcTExcTExsTDxsTExsTExcLD
        xsPDxcPCxsTDx8XFxsTExsTExsTEyMXFx8TEuba2iIWFjIqK////////////////////////////1NHQ
        ycbFzMvKzMvL09HR09HR09DQ09DQ0s/Pz83Nz87N09HQ1NHR0tDQ0tDQ09DQ09HR1dLS1NLS09LR1NLS
        1NLS19TU09HRwb6+paKi////////////////////////////AABoAABoAABoAABoAABpAABpAABpAABp
        ////////////////////AABtAABtAABtAABtAABuAABuAABu////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////AAB5AAB5AAB5AAB6AAB6AAB6////////////////////////////////////////////////
        ////AAB+AAB/AAB+AAB/AAB/AAB/AAB/AACAAACAAACAAACAAACAAACBAACBAACBAACBAACCAACCAACC
        ISGPVVSkZWOqxsPQ2NbV29jX4t/e4d7f29jY2dfX3NnZ2dfWzMnJo6GhdXNyAQFrAACCAACBAACBAACB
        AACBAACBAACAAACAAACAAACA////////////////////////////////////////29nZ2NXV0s/P09HQ
        1NPT1NLS09HR0tDR0M3NzszMz87Oz83NzcvLz8zN0M7Oz83M0M3N0M3Mz8vMz8vMzsvLzMnIysfHy8jI
        zMnJzMnJysbGycTEycXFycbFyMbFyMbGyMXEv7u7mpeXzMnJw8DAz83Oy8nKycfHycfHysfHyMbFx8XF
        vLnBkpCuYmGYLSyBCQlyAgJuAABtAABtAABsBgZvfXuiwL69wb29wb69wL29wr6+wr6+wLy9wL69wcC+
        wb6+vbq6vLm5vLm5vLm5vrq6vbq6vbq6vbq5v7q4vbq4u7m5ure3vrm3xL25v7i2ubW1uLW1t7OzuLW0
        ube2uLW1tbKytLGxtLKytbOztrSztbOytLGxsq+vsa+usa6tsq6tsa6tsK2usa6vsq+vtLGwtLCwsq6u
        r6ysraurraqqraqrsrGytbS1s7KysK6urqurraioraqprKmpraqrr6ysbGtqLi0rODc2NjU0cW9vQ0FA
        gX59aGVkISAgMzMxSEZGoZ6eHx4dIyIgPjw7goB+n52cHh0dISEfLy4sOTg3Hx4dMC8uPjw7dHJxm5iY
        YWBgTk1MX15cY2JgeHd2k5GRl5aWmJaWlpOTmJWVmZaWl5SUlZKSlJGRlJGQkpCPkY+OkY+Ok5GQk5CQ
        ko+Pk5CQkpCQlJGRk5GRkY+PWVhWISEgGxsbPTs6hoWEhYKCISAfJSQjX11db21tHRwbHx4dMjEwW1pZ
        HR0cNDMyWVhXiIWEGhkYHh0cNDIycG1tiYeGODc2IB8eNzY1V1ZUgoB/gX9/goB/goB/fXt7fXt6f3x7
        fXt6fXt7fXp6fXp6////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////tbOztbOzvbq7vry8vbu7vLm5u7m4u7m5vLm6v7y8
        v769wL6+wb+/v7y8v729w8LBxcLCxMDBw8LCxcLCxsTEx8bFxsTExMLCxcPCxsPDxsTDxcTDxcPDxcLD
        xMHCxcPDx8XEx8bEyMXFv72+q6mpjIqKraur////////////////////wr/A1NHQw8DAwsDAysnJz83O
        z87P0s/Pz83NzszM0M7N0M3N0M3N0M3O0M7O0dDP0dDP0M7N0c7O0tDP09HR1NPT1dPT1tTU2NbVysfG
        paKipaKi////////////////////////AABnAABnAABnAABoAABoAABpAABpAABp////////////////
        ////////AABtAABsAABtAABtAABtAABuAABu////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////AAB5AAB5
        AAB5AAB5AAB5AAB6AAB6////////////////////////////////////////////////////////AAB+
        AAB/AAB/AAB/AAB/AAB/AAB/AACAAACAAACAAACAAACBAACBAACBAACBAACBAACCAACCAACCAACCgoG0
        19bV3tzb4t/g4d7f4N3e4Nzd3Nra3NrZ1dPSwr++iIWFKCZZAACCAACCAACBAACBAACBAACBAACBAACA
        AACAAACAAACA////////////////////////////////////1NLR1NLR0M3M0c7N1NPS09LR09HR1NHR
        0tDQ0M/P09HR1NLS0tDQ0M7O0M7O0M7O0c7P0c3Nz8vLzszM0M3Nz8zNzcrJzsnIz8nIzsrJzMjJysbG
        ysbGysfHycfHzMrKx8XEsK2rmpeX////w8DAz83Oy8nK1NHRzMrKx8TExsPDysnJysnJy8jIysfGt7S+
        jYuqXl2XJyZ/Dw90DQ1zOjqFuLa7w8HAxMC/w7+/wL69wb6+wL29wLy8wL29wsDAxMC/wr29wL28wb6+
        v7y8vru7vbq6vbq6vbq5vbm5vbu7vry7vLm5vbi4wLm3vri3u7i3u7i4ure3u7i4ure3uLW1uLW0t7Sz
        t7SztbOytrS0trOztrKytbGxtLKxtLKys6+wsa6usa6vsrCwtLCwtbGwtbCwsq6tr62tsK6tsa+ur62s
        srGxtrW2s7KyrqysrKmprKmpq6inrKioraursK2tbGtqICAeIiIhKyooq6enqaWlpqOiXV1cHx8eJCMi
        UE5NioeHHx4dJSQjPj07gn9+iIeFHx4dIyIhMTAvj4uLLSwrJSUlISAfZWNijoyMIiEgJSQjIyIhIiEg
        KyopW1pZj42MlpSTlZOTl5WVmpiXmZaWlZKSkpCPkpCQlJKRlZKRk4+Pk5GQlZSTlJOTlpSUlZKSlpOU
        lpWUlJKQk4+PlJGSamhoc3Fxj4yNj42NX11dOjk4TEpKLS0rGxoZGxsaJCQjSEhHHRwbMC8uXFlZbWpp
        GxoZIB8eMzIxb2xsiYaFKSknHBsaIiEgX15dg4B/gX5+gX9/f319end3d3RzenZ1eXd3e3h5fXp6////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////ure3ure3u7i4vLq6u7m5uri3u7m5vLq6vbu7v7y8wL++wsHBxMLCwr+/
        wsDAxMLCwb+/wLy9wL6+wsDAxcLCxsPDw8LBwr+/w8DAxcPDxcPCxcLCxcLDw8HBxMLCxMHBxcLCycfH
        y8rJzMvKxcTDvbq6raurxMLCvbq6r62srayrvbm5wr/AzsvLyMXFxcTEycfHzMnJz83N0M3OzMjJzMnK
        0M7O0c/O0M7Oz83N0M3M0c7O0dDP0M7O0M3N0tDP1NLS1dLT1dLT09LS1NHS0M3Ovbu6qaio////////
        ////////////////AABmAABmAABnAABnAABoAABoAABoAABo////////////////////////////AABs
        AABsAABtAABtAABtAABuAABtAABu////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////AAB4AAB4AAB4AAB5AAB5AAB5
        AAB5////////////////////////////////////////////////////////////////AAB/AAB/AAB/
        AAB/AAB/AAB/AACAAACAAACAAACAAACAAACBAACBAACBAACBAACCAACCAACCXFyo3t3c4t/g4+Dh4t/g
        49/f4d7f3dvc29nZ3dra09DQq6eodHF2Cgl4AACCAACCAACCAACBAACBAACBAACBAACBAACAAACAAACA
        ////////////////////////////////19TU19TU1NLR09DQ09HR1dPT1dTU1NLS0s/Q0tDQ0tDQ1NDR
        1dPT0tDQ0M7N0c/P0tDQ0c7Oz83M0M7O0c/P0M7N0M3M0MvL0MvK0s/O0tDQz83NzcrJy8jIzcvKzsvK
        w8DAsK2r////////////////////1NHRzMrKx8TE0M3Nzs3N0c/PzcnJzcnIycXFx8XEyMXFs7G8j42s
        c3KfnZqxxsPDxsTExcLCxMDAwr+/v729wb++xcC/xL6+xcC/xsG/x8C+xcC/wb6+vry8vry8wL28vru7
        vbq6vru7v7y7v7y7vrm5vbi4v7q5wLu5vbm4vLi4vLq5vLm4vLi3vLi4vrq6vLi3uba0t7Szt7S0t7W1
        trSztrS0trSztrOztrO0tbKztbKxs7GwtLGxtbCwtbCvs6+vr62tr62tsrCwsq6usq+vs7Kzsa+vraqp
        rqmqraqqrKqqrqurr6yrrqurY2FhKyopLy4tUlFRqqenqaWlqaSjRUJCKikoLSwqW1pZhoSDHx8dJycl
        R0ZEmZeXh4WEHh4cJyYlQT8+oZ+fMjEwOzo4YmBfbGlpbmxsIB8eKSgoICAfi4mIMC4uPTw7bWtrlZOT
        l5WVlpSUl5WVmZaVmJWUmJWVl5SUlpSTlpOTlZKSlpOTl5WUl5WVl5WVl5WUlZOTlZKSkpCPko+Pk5GR
        lZKSko+PkI2NjouMkI2NaGZmOTg3QT8/KiopQkJBUU9PNzY2GRkXHBsaOjk4WVdXHBwaKSgnOjg2gX18
        hoOCGRkZIyMiLi0sX11dhICAhICAgoCAgX9+fnx8fXp6fHl5fXt7fnx7fnx7////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////tbO0uLa2uLW1uba2u7q5vLu6vLm6vbq7vby7vry8vry8wb++wcC/wb+/wsDBwb6/v7y8vry8
        wb6+wsC/wsDAwb6+wb++wb6+wL29wL6+wr6+w8DAw8DAw8DAxMLCxMHBw7/AxsPEyMbGycfHysfHysfH
        xsTExMLCvbq6r62srayrvbm5ycbGysfHzMnJzsvLzMnIy8jIz8zMzsvMzcrKzszM0M7O0M7O0c/Q0c/Q
        0c7O0c7P0s/P0c7P0tDQ09HR09DR09DR09DR09HQ0s/P0tDQycjIqaioqaio////////////////////
        AABmAABmAABmAABnAABnAABnAABoAABoAABo////////////////////////////AABsAABsAABsAABt
        AABtAABtAABuAABu////////////////////////////yMXF0tDP0tDPvLu7pKKi////////////////
        ////////////////////////////////////////AAB4AAB4AAB4AAB4AAB5AAB5AAB5////////////
        ////////////////////////////////////////////////////////////AAB/AAB/AAB/AAB/AAB/
        AAB/AACAAACAAACAAACAAACBAACBAACBAACBAACBAACCJiWS3dri5+Tk5OLi4+Hh4uDg4uDg4t/f4N3d
        39zc29nYzcrLr62tVVSBAACCAACCAACCAACCAACBAACBAACBAACBAACBAACAAACB////////////////
        ////////////////////19TU393c2tnZ1dTU1tPT19XV1tPT1NDQ1NHR0c7P0s/Q1dPT1NLS0s/Q1NHR
        09LR0c/P0s/Q08/R0M3NzsrK0M3N0M7O0M3M09DQ1NPS0c7Oz8vL0MzMz83MzsvLxsLCxsLC////////
        ////////////////////////0M3Nzs3N0c/P1NDQxsPIzMnJycXFycXFyMTEx8XFx8XEyMTEycXFx8TF
        xsPExcLCxMHBxMLCxcLBx8LAx8HAx8G/xMC+xL+/xsC/wr29v7y7wL28wLy8vbq6vru7wb29wr69wr29
        wby8v7u6wLy6wry5wLq4vLm4vbq5vru6vbm5v7u6wbu7v7q6u7i3ure3uba2uLe2uLe2uLW1trOztbGy
        t7W1ube2uLa2trS0tLGxtbGxtLGxtLKxsrCvsq+vtLKytLGxs7CvsrCwsa6vsa2tsq2tsa2tr62usK+w
        r62sraqpRkVFLSwqJiUkSUhGX1xaf3l2sKejTktLIB8eJSQjaGZlfnx7IiIhNzY1SEdHpaKgbWtrHh0c
        IiEgMjEwp6WkT05MU1FQRURCdnRzZmNjIyIhSUdGPj08oZ+fHh0cJiYkSklHkpCQmZeXlZOTlpOUmJaW
        mZeXmpiYmpmYmJaVmZaWmpiXmZeWmJWVmJWVl5SUl5WUlJGRko+Pk5CRlJKRlZSTlJGRko+PkI6OkY+P
        ko+PkpCPj4yMfnt7WFZWcXBwkY+Pd3V1VFNTTk1MQUA/MDAwGhoZHR0cNTIyhoKBh4WDHR0bJyUkNjU0
        aGVkgX5+gn5+gH19f319gH9+gX9/gX9/gX5+f318f318////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////tbO0tbO0urm4
        uLW1uLW2uri4vLm5u7i4u7m5vbu8vry8vLm6vbq6wL29wL6/v72+wL29wb++wb+/wL6+wr+/v76+v729
        wr6+wr+/v728vru6v7y9wb6+wb+/wsDAxMHBxMLCxMLCxMLCxcLCxMLCxcLDxMLDx8XFy8nJzMjIxsLD
        x8XFy8nJzMvLy8nJysfIzcrKzMnJysjIzMrKzszM0dDP0tDP0M7P0M7P0c7Q0c7P0M7O0M7P0M3O0M7O
        09HR09HR0dDQ0dDQ0tDQ0tDQ0s/Q0tDRzs3OvLq8oqCf////////////////////AABlAABlAABmAABm
        AABmAABnAABnAABoAABo////////////////////////////////AABsAABsAABsAABtAABtAABtAABu
        AABt////////////////x8TE1NDQyMXF0tDP0tDPvLu7pKKiwsHAkI2O////////////////////////
        ////////////////////////////AAB4AAB3AAB4AAB4AAB4AAB5AAB5////////////////////////
        ////////////////////////////////////////////////AAB/AAB+AAB/AAB/AAB/AAB/AACAAACA
        AACAAACAAACAAACBAACBAACBAACBAwOA3dri5+Tk6ebm5+Xl5uXl5ePk5OHi5ODh4t/f4uDg3tzcu7m5
        e3h6AQFwAACCAACCAACCAACCAACCAACBAACBAACBAACBAACBAACB////////////////////////////
        ////////393c2tnZ3dvb19XV1tPT1tLS19PT1dHR1dHS09LS1NLS09DR09HS1NLR1NHR1M/P1NDQ0s/Q
        0czN0s7N0s/O0s/O0M3N0MzN0M3Nz8zLz83M0c7OzsvLxcLCxsLCxsLC////////////////////////
        ////////////////////1NDQVVSUhoSt0s/OzcnJzcnJzcnJy8fHycXFysbFycTEycXEyMXEx8XFxsLD
        xsHBx8PCxsPCxMDAw8DAwb/AxcDAx7++w768wL28v7u7vru7v7y9wL29w7++w7+/w7+/wr++wLy8wLu6
        wLq5v7u6wLy8wb69v7y7vbq5v7u6v7u6vLi5ure4u7m5u7i4uri3uba3uLS1t7W1uLW1uLW1uLW2t7W1
        t7W1t7W1t7W1trOztrOztrOztrS0trSztbKxtLGws7CwtLGxs7Cvsa6usa2usa6usK2trquraWhoREFA
        MzAvLCooMC4sRkE+tqukiIOBODc2KyooMS8uNjQ0IyIhNTQzQ0FAp6KgZ2VkICAfPjw7cnBvoJ2cIiEg
        Ly4sQ0JAgX59ZGJiJCMiRENCZ2dloJ2cHBsaHh4dLy8thIOCnZqam5iYmJaWmZeXl5WWmJaWmpiYmpiY
        m5mYnZuam5iYmZaWl5SUlpOUlpOTlJGRk5CQlZOTmZeXmJWVlpOTk5GRk5GRk5GQlJKRkpCQkY+Pj4yM
        jYuLjouLj4yMjoyMkI+OkpCQkY+OVFNSFRUUGBgXS0hIhoOEIyIhGhkYHRwbOzo6fnt6fnt7fXt6fHl5
        eXZ2d3R0end2e3l4eHR1f318////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////t7O0t7O0t7W1uLW1uba2ube3uba3
        ube3uri4vry8v729vLu7vbq6wL2+wb/Av72+v7y9wb+/wcDAv76+v7y8vru8v729wb+/wL69wL29wL29
        v729wb6+wsDAw8HBxMLDxcTExsXExsPDxsLDxcPDxcHDxsTExcTDxsTExsPEycbGzcvLzMvLzczMy8jJ
        x8TFycfIzMrJysnJy8rKzszN0M7Pz83Nzs3Nz87O0M3Oz8vMzcvLz8zNz8zN0s7O0s/Q0c/Q0dDQ0c/P
        0c7O0M3O0M3Oz83N0tDRycbGoqCfoqCf////////////////AABlAABlAABlAABlAABmAABmAABnAABn
        AABn////////////////////////////////////AABsAABsAABsAABsAABtAABtAABtAABtBARvYmCY
        0M3Nx8TE1NDQ2tbW3tzb393d3NnZ1tTTwsHAkI2Ok5GS////////////////////////////////////
        ////////////AAB3AAB3AAB3AAB4AAB4AAB4AAB4////////////////////////////////////////
        ////////////////////////////AAB+AAB+AAB+AAB+AAB/AAB/AAB/AAB/AAB/AACAAACAAACAAACA
        AACBAACBAACBAwOA////////6ebm5+Xl5uXl6efn6Obm5+Tl5uLj4+Hh29nZw8HBioeHJCNWAACDAACC
        AACCAACCAACCAACCAACBAACBAACBAACBAACB////////////////////////////////////////////
        3dvb3Nra19XV2NXU2NXV19TU2NbX29nZ2NXV1tPT1NLT0tDR1NDQ1tDP09DP0s7P2dPS3NjU1dHQ0c7O
        0s7Pz8vMzMnJ0M7N09HRz83Nx8PExcLC////////////////////////////////////////////////
        ////AAByAABwBgZuWVh+zcnJzcnJ1tLR0c3Nz8vLz8rIzcXCzcTCycTDyMbGysfHyMXFyMbGx8TExMHB
        w8HBxMLCxcDAx8C+w7++wL++wb++wr+/w8DAwr+/wsDAwr+/wb6+wr+/wb6/wL29wLy8v7q6wLy8wL28
        v7y7vbq6v7y7v7y7u7i4ure3u7m4vbm5vLm4u7m5u7m5uri4uba2t7O0uLW2uLa2uLe3uLe3uLW1t7Oz
        t7OzuLS1t7O0trO0tbGys7Cws7Gxs7Cwsa6urqursKyssq2rsKyssK2ur6ysrqmonZWTb2dlR0JALysp
        tqqlr6qojYyMX11dRUNCMjAwISEgNDIxaWZlp6SkaGZlIyIhU1FPcW9uiYaGICAfLi0sR0ZEf319QUBA
        ISEgRURCZmVjhIKBc3BvUVBPMTEvhoSDn5ycn52dnJqZmpiXmpeYmZaXmpiYm5mZnJqanZmZm5eYmJWW
        mJaWmZeXmpeXl5SVlpOTmJWVmpeXmZeXmJaVlpSUlZGSlJCRk5CQlJKSk5GRkpCQkY+PkI6NjouLjouL
        j46NkI2Ni4iIiIWFZmNjWFZWgYB+iIWFNTQ0KCYlHR0cOTg2V1NTfnp6fnx7fXt6end3dnFydXBxdnJy
        dHBwdHBw////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////tLGxtLGxtLKyuLa2ube3uba2uLa2t7a2uLa2u7i4vry7
        vLu6u7i5vLq6vbu7vLq6vLm5vrq6v7y9v7y9vbq6u7i4vLm5vbu6wL28wsDAwcDAvry7wb6+xMHBxMLD
        xcPDxsPDxcLCxMLCxMLDxsTEx8XFxsXExcPDxsPDyMbGycfGycbGyMbHysjIycjHxsXEx8XFycfHy8nI
        y8nJzcrLzcrLzMrKzcvLzszMzsvLzcvLzszMz87Nz83Nz8vMz8zNz8zNzsvMzsvLz8zM0M3O0M3N0MzN
        0c7OzcvKuri4op+g////////////////////AABlAABkAABlAABlAABmAABmAABmAABm////////////
        ////////////////////////////AABsAABrAABsAABsAABtAABtAABtBARvYmCY0M3N1tPT29nY3Nra
        3NrZ2tfY2tjY3dvb1NLSwL6/k5GSk5GS////////////////////////////////////////////AAB3
        AAB3AAB3AAB3AAB3AAB4AAB4////////////////////////////////////////////////////////
        ////////////AAB9AAB9AAB+AAB+AAB+AAB/////AAB/AAB/AAB/AACAAACAAACAAACAAACAAACBAACB
        ////////////////////6efn6Obm5+Tl6ebn6Obm5OLj3Nvburi4dXJ0AAByAACDAACDAACCAACCAACC
        AACCAACCAACBAACBAACBAACB////////////////////////////////////////////3Nra19XV397d
        2NXV19TU2NbX29nZ2NXV3NnY2tjY1dPT1dLR1NLR0tDQ1NHQ29bT29fT09DO0c7O09DR0M3Ny8jJ0c/P
        2dbW09DQx8PE////////////////////////////////////////////AAB0AABzAABzAAByAAByAABx
        WVh+////////1tLR0c3NzsvLzcfG08nHzcTDy8TEysbGy8fFy8jFysbFysTDyMPCxcPDyMXFyMTExcHA
        wsDAw8DAxcHBxcDBxMHBw8HBxMLBxcHAw76+wr+/xMHBw8DBwb6+vry7vru7v7u7v7u6v7y7v7u7vrq6
        vLm4vbm5vLm5u7m4vbq5vLm5u7m5u7m5u7i5ube3ube3ure4uba3uLW1t7Szt7Ozt7SzuLa0t7OztbKy
        tLGys7GxtLGxs7CwsK2tsKyss66tta6rsKyrsK2usa2usa2ssKuqr6qqr6qor6imsaqorqqpq6mpq6mp
        rqqqRENCISAfJCQiZmRjqqencG5tJyYlKSknYF9eaGdmIyIhNzY0R0ZFoJ2dPz49Hh4dIyMhPTw7QUA+
        WllXcHBvh4SFnpycnpybnJqanJqZnJmZnpybnZqampeXm5mYnJqZnJqanJqZm5qZnJqanZqampiYmZiY
        mpiYmpaXmJWVlpSUl5WVmJWVl5SVlJKSlJKSlZSTlpOTk5CQlJGRkY+PkY6Oj4uMjouLi4mIiYaFh4SE
        iYeHjoyMjoyMiISEWVdWGRkYGxsZKSgnJyYlgn18gHp5f3t7gH18fnl5e3R1fHV1fnd1fnd1////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////sK6vs7Cxt7S0t7a2uLa2uLa2ube2t7W1trS0ube3u7q5vLm5ubW2ure3ubi3
        ure3uba2uri4vru7v7y9vbm5vbe3v7u7wL6+v76+wL6/vbu7uba3u7i4wL6/w8HBw8HAwb2+v7u8wL6+
        xMLCxcTExcPDw8HBxMHBxsPDx8XFyMbGx8TFyMbGycfHycjHycjHysfHy8jIy8nJzcrLzcrKzMrJzMrK
        zMrLzczMzczLzMvLzszNz83NzszMzcvLzMvLzcvMz8zMzsvMz8zMz8zNzszLzs3Mzs3Mzs3MxMLCop+g
        op+g////////////////AABkAABkAABkAABlAABlAABlAABmAABm////////////////////////////
        ////////////////AABrAABrAABsAABsAABsAABtAABtAABtW1qa19TX29nZ2tnY29nZ29nY2tjY2tnZ
        397e19TVwsDAwsDA////////////////////////////////////////////AAB2AAB2AAB2AAB3AAB3
        AAB3AAB4AAB4////////////////////////////////////////////////////////////////AAB9
        AAB9AAB9AAB+AAB+AAB+////////////AAB/AACAAAB+AACAAACAAACAAACAAACBAACB////////////
        ////////////////6ebn6Obm5OLj6+np5+bmpqSkKCdeAACDAACDAACDAACCAACCAACCAACCAACCAACB
        AACBAACB////////////////////////////////////////////////////397d////////////////
        ////3NnY3tzb19TV1NLS1NLS09LR1dLR1tHR1M/P0c7O1NHQ1NHR1NHR0s/Q0c/P2dbW09DQx8PE////
        ////////////////////////////AAB1AAB1AAB0AAB0AABzAABzAABzAAByAAByAABxAABy////////
        ////zsvLy8bGyMLCy8fHy8jIzcjHzcfEzMfEysfFysbFyMTEx8XFyMbGysfHyMXFx8TExcHBxMDAxMHB
        wr+/w8C/xMHAx8HBxsDAxMLBxsPDxcHBwr6/wL6+wL29wb29wb29wLy8wr29wby8wL29vru8vbu6uLa4
        u7i6vbm6u7i4vLq6vby8vry8vbu6vLq5vLq6ure3t7S0trSzuLWzuLW0uLS0trKytbGxtbKytbKys7Gx
        sa6us7Cws7Cwsq6usa6usK6usa+vsa6vsK6usK6usa6urqysrqyssa2urquqraqpraurRUVEPTw8UlFQ
        dXNzq6ioqKWlW1lYHRwbIiEgISEfIB8eIyIhPDs6o6CgQD8/JiYmICAeV1ZVRENBMC8tU1FQWllXoZ+f
        npycnJqam5mZnJmZn5ycnpybnZubn52dn52dnpybnZuanZqanpubnJuam5qZm5qanJqanJiZm5iYmJaW
        l5SVmZWWl5SUlpSUmJaVmZaWlpOTlZOTlZKSk5GQko+OkI2NjImJi4mIi4iIjImIjImIjImIioeHiYWE
        YV5dJCIiGBcWGhkYfXh3g317g318gn19gX9+gHx8gHt7gXt6fnd1////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        sK6vsK6vtLGyt7S0tLGxs7Gxt7W1t7S0trOztrS0ubW2uba2ura3ubW2uba3urm4uri4uLS1trKzuba2
        vLi4u7e3vLi3vrq6v7y9wL2/wL6+vbu7u7i4vbq6v7y9wL6+vru7u7e4vLm6wb/AxcPDxMLBwr+/wb6+
        wr/AxcLDxsTEx8XGysjJysjJycbHycXHysfIysjIysfHycbHycjIy8jJzMjIy8jIy8jJzsvMzcvLy8nJ
        zcrMzsvMzsvNzcvMzszLzs3Mz83NzszMzszMz8zN0M3N0M/Pz87Nzs3MysjHt7S0oJ6e////////////
        ////AABjAABjAABkAABkAABkAABlAABlAABmAABm////////////////////////////////////////
        u7i4BARsAABrAABrAABsAABsAABtAABtAwNuWFeZyMbQ3Nra3Nna2tfY2dfX29ra393c3drZxMLCxMLC
        ////////////////////////////////////////////////AAB2AAB2AAB2AAB3AAB3AAB3AAB3////
        ////////////////////////////////////////////////////////////AAB9AAB9AAB9AAB9AAB9
        AAB9////////////////////AAB+AACAAACAAACAAACAAACAAACA////////////////////////////
        ////////////6+np5+bmpqSkt7W6AwN2AACDAACDAACDAACDAACCAACCAACCAACCAACCAACBAACB////
        ////////////////////////////////////////////////////////////////////////3tzb3Nna
        2dXW1dHR09DP09DP1NDQ0s/Q1dPT1dLR1dLS1NHR0s/Q////////////////////////////////////
        AAB2AAB2AAB2AAB1AAB1AAB0AAB0AAB0AABzAABzAABzAAByAAByAAByAABy////////19XU19XUzMrK
        zMnJzMjJzcjHzcfGy8bGysfHycjHyMXFyMXFycbGyMXFx8TEycXFycPDw7+/wr6/xMLBxMHBxMHBxcHB
        x8PDx8TDx8PDxcHBxMHBw8DAwr+/xL+/xL++wb6+wr6+w7++wb6+f32eUE6HWliMlJGnvru7v7u7vbu7
        vbu7vbu6vru7vry7vry7vLq5uba2uba2uLW1t7OzubOwvbOvubKxtbKztbOztLGxtLGwtbKytbOzs7Gy
        tLCxsa6ur6yssa6us7CvtLCxs7GxsrCwsa6usa6usK2trqqrrqysa2ppNDMyU1FQf319rqurq6ioqKWl
        i4mJhIKBhIOCGRkZHh0cPT07pqOjVFNSOjk4Li0scnBvTEpJISAfNDMyV1VVoqCfoZ+fn5ycn5ycnp2c
        n52cnpycnpycnpycnpubn5ubnpycn5ycn5ubnpubnZqZm5iZmZaWm5mZnp2dnJmamJWVmZaWmJWVmJWV
        mJaVmJWVmJWWlpSTk5GQkY6Nj4yLjoyLj4yLjYmJjImKjYqKioaFhoGChYGCh4ODiIOChYB/bmtqXFlY
        iISDhoB/hn9/hH9+gnx8gXx8gn19g359g359////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////sK2tsK2ts7Cxsq+w
        sa6vsa+vsrCvsK2tsq+wuLW2ure4ure4uLW2uri4vLu7vLq7ure4uLW1uba2uri5uba2ube2urm4vLq6
        u7m6vbq7vru7v728wcDAxMLCw8LCwcDAvry8u7i5vbu7wr+/w8HBwsDAwb6+wsHAxMPExsPExcLDxcTE
        yMbGx8TFxsPDx8XFyMXGx8XGx8TExsPDxMLCxcPDyMTFyMbGzMnKz83NzsvMy8jJy8nKy8rKzcvLzMrL
        zcrLzszMz83Nz8zMzcvLzszM0s/Q09LSz87OzcrKzMrKw8HBoJ6eoJ6e////////////AABjAABjAABj
        AABjAABkAABkAABlAABlAABl////////////////////////////////////vr29u7i4UE+NAABqAABr
        AABrAABsAABsAABsAABtAABtMjKGz83U3tvc2tfX1tTU2tjY3tzc2tfXxMHBxMHB////////////////
        ////////////////////////////////AAB1AAB1AAB2AAB2AAB2AAB3AAB3////////////////////
        ////////////////////////////////////////////AAB8AAB8AAB9AAB9AAB9////////////////
        ////////////////AACAAACAAACAAACAAACA////////////////////////////////////////////
        ////////t7W6AwN2AACDAACDAACDAACDAACDAACCAACCAACCAACCAACCAACC////////////////////
        ////////////////////////////////////////////////////////3tzb3Nna3tra3NjY2dbW2NXU
        19TU19XV2tfX09DQ1dLS////////////////////////////////AAB4AAB4AAB3AAB2AAB2AAB2AAB1
        AAB1AAB1AAB1AAB0AAB0AAB0AABzAABzAAByAAByAAByAABy////19TU19TU0M7OzsvK0MzJzsrIysfI
        ysfIzMrKzcvLzMnIysfHycfHyMXFx8XFycbFycTExsLCxcLCxsPDxcLCxMLBw8DAxMHAxcLBxMHAxcLB
        xsLCxcDAxMC/xcHAxcHAwb6+wL29wL29uba5QUCBAABjAABibGqVu7i6wL29v7y8vbm5vLi4vLq6vbq6
        vLq5vLq7vLm6vLi4ure3ubW1u7SyvrKuvbSyuLW1trW1trOztbKytbOztbOzt7KxtrCws7CwsK+vsa+v
        tbGyt7KytrO0tLGys66usayssa2usK6usK6vs7CwqKWld3R0npubr62trKmpqqamqqenrKmpq6mpoJ6e
        cW9vaWdnpqOjiIaFJSUjIyIgWFVVODc2IyIhMjEwYmBfoqCfoJ2doZ6eo6CfpKKhoqGgop+foZ+foJ6e
        npubn5ydoZ6foZ+en52cn52cn5ybnZmYnJmYnJubnpubmpeXmZeWmZeWmpeXmZaWl5WVmJaWl5WVlZOS
        ko+PjoyLi4mJjIqKjoyLjouKjYiIjYmJjIiHiYODh4GBioaFjImIioWEhX9+hX9/h4KCiIODhH9/g359
        h39+iIGBh4GCg39/g39/////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////rauqrauqsq+vs7Gys7Kysa+vrqysr62t
        s7CxtrW1t7W1tbSztbOzt7a1urm4u7i5vLm5vLu6vby8vbu9ura4ube2urm5u7q6ubi4ube3vLq6wL6+
        xMHCxMLDwsHAv72+v7y9v728wL29wL6+v729v769wL2+xMHBxcXExcPExcHDxMHCxMLDxMHBw8HAxcPC
        xsTExMHCxMLDx8bGx8bFxsTEx8XGycbHy8jJzczMzMrLy8nJycjHycfHy8rJzMvLy8nKy8nKzszMzszM
        zMrKzsrLz8zN0c7P0M3OzcrLzcrLyMfGtbOzo6Cg////////////AABiAABiAABiAABjAABjAABkAABk
        AABkAABk////////////////////////t7S1v7y8yMbFvr29y8nJw8HGXl2XAgJrAABrAABrAABrAABs
        AABsAABtAQFtOjmJuLbH2dbW19TV2NfX2tjY2tjYzcrKzcrK////////////////////////////////
        ////////////////AAB1AAB1AAB1AAB2AAB2AAB2AAB3AAB3////////////////////////////////
        ////////////////////////AAB8AAB8AAB8AAB8AAB8AAB8////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        AACDAACDAACDAACDAACDAACDAACDAACCAACCAACCAACCAACC////////////////////////////////
        ////////////////////////////////////////////////3tra3NjY2dbW2tbX19TU19XV2tfX09DQ
        ////////////////////////////////////AAB4AAB4AAB3AAB3AAB3AAB2AAB2AAB2AAB1AAB1AAB1
        AAB0AAB0AAB0AABzAABzAABzAAByAAByAABy////19TUzsvLzsnI0c3Jz8vKysjJysfIzsrJz8zLzsrK
        zMvKzMnIzMfIzMjJzMnJy8fIysfIycbGxsLCxcPDxsTExcLCxMHBxcLCxsPDxsPCxsPCxsHBxcDAxcHA
        w8DAwb+/wb+/wb6+sa+2OTd+AABjAgJkUlGIvLq7vry8wL69wb68v7y8vbm5u7e3u7i4vLq7vLq6u7i4
        u7i5vLm6vLm4vLW0vLOyurW1trW1t7W1t7S0trS0t7Szt7GwtrGxtrOztrOztrOzuLW1uLW0trOztbKz
        s6+vtK+vtLCws7GysbCwsrCvsrCwsa6usq6tsa6tsK2srKmpqqenq6ioq6ioq6qprKyrrKmpqKSkpaKi
        dXNzLi4tIB8eHh4eHx8eISAfgn9+o6CgoZ6foqCfo6Cfo6Cfo6GgpaKipaGhoJ2doJ2doqCgpKKjoqCg
        n52coJ6doJ+fn52dn5ycoJ2dnJqam5mYnJmZm5mZmZaXlpOTlpSUmZaWl5SUlZKSkpCQkI+Nj42MjIiI
        jIqKj42NkIyLj4uKjouKjIiHjIiHjIiHiISEiIKCi4WEiYSEhoGBhYCAg359hoB/jIaFjoqJioSEg39/
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////q6mpq6mpsK+utrS0tLKysa6vsa+wtLOztrW1tbOzs7Cwsa6u
        sq+vtLGxtLGxt7W1uri4vLq6vLq7vLm6uri4uLW2uri4u7m6uri4uba2ubi3u7q6vbq7v72+vru8vLq6
        vbq6v728vry8vry8vry9v769wL6/v7y9v76+wb+/w8DBxMHBw8HBw8LCwr/Aw8HBxcPDxcPCxMHCxcPD
        yMfHy8nKysjIyMXGx8XFyMbFyMXGx8TFycbGysnIy8nJy8nJysjIysjIzMnJzMrKy8jIrqy6gH6gdHOb
        srG8zMvLzcvLzszLvry8o6Cgvbq6lZOS////AQFdAABhAABiAABiAABjAABjAABjAABkAABk////////
        ////////////v729t7S1v7y8yMbF0M/O09HR1NHQ1M/OWViVAABqAABqAABrAABrAABsAABsAABsAABt
        MTCEvLrI2NbW2dfX2tjY2dbWwb+/wb+/////////////////////////////////////////////////
        AAB0AAB0AAB1AAB1AAB1AAB2AAB2AQF2////////////////////////////////////////////////
        ////////AAB7AAB7AAB7AAB8AAB8AAB8////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AACDAACDAACD
        AACDAACDAACDAACDAACCAACCAACCAACCAACC////////////////////////////////////////////
        ////////////////////////////////////////////2tbX////////////////////////////////
        ////////////////////AAB4AAB4AAB4AAB3AAB3AAB3AAB2AAB2AAB2AAB1AAB1AAB1AAB1AAB0AAB0
        AAB0AABzAABzAAByAAByAAByxsTJzsrKzsrJz8zLzsrLzcrKzMnIz8jH0cnIzcrJzsvLz8rI0MrIz8vL
        zsvLzMrKzMnJy8fHx8XEyMbFysfHycfGyMXFx8XEyMbFyMXEx8TDx8PCxcHBxcLCxcLCxsPDxcLBw8C/
        w8DANDN8AABkAABjVlWLwL6+wL6+wL69wcC+wb++wb28vrq6vbq6vLq6u7m5vLq5vbu7vru7vLq6u7m5
        u7e2ure2uLa2t7W1uri4u7i4ure3uLa2uLe3uba2uLW0ubW1uba2t7W1trOzt7O0trOztrS0t7Oztq+u
        tK+tsa+vs7Cwsq6usq6tsq6usa2trqysrKmprKipq6eoqqenq6mprKqpq6ioqaamqKWlnpycbmxsSEZF
        QD89d3V1pKKhpKKipaOio6GgoJ2dn5ycoJ6eo6GhoqCfoJ2doJ6eoqCfop+foqCgoqCgoZ6enpubn5yc
        oJ6eoJ2dnpycnZqanpycnpubm5iYlpSTlpOTlpOTlZOSmJWVlJGSk5GQkpCPj4uMjouMkY+PkY+OkY6N
        jouKjouKkIyLkIuLioSEi4WEkY2Lj4uKiYWEiYOCjISDjIWEioaGjoqJioSE////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////q6mpr62tsa+vsa2ssa2ss7CwtLOztbW0tLKysa2usKytsa6ts7Cws7Cxs7Gx
        trOztrO0trO0t7Szube2uba3ura4vLm6u7m5ure3uLW1t7W0t7W1u7i4vbq7vLu6vbu7vbq7vbu7vru7
        v7y9wL6/wL+/vbu7vbq7v72+wL+/wsC/wcC/w8HBxMHCw8HCw8LDxcXDxcLCwr7AxMHCx8XFx8TFxsTE
        xcPDxcLCxcLDxcLDyMXGy8rKycbHycbGysjHysjIysnJy8jJvbvAJCNuEBBlAABcMjF3enmeubi/ycfI
        ysjIyMXFvbq6lZOSkI2RAQFdAABhAABhAABiAABiAABiAABjAABjAABj////////trO0wb++yMbFv729
        ycbG0M3N0tDQ09HQ09DP09DP0s7O0c7OUE+RAABqAABqAABrAABrAABrAABsAABsAABtHh17n5262NfW
        29nZ2NbWtbOztbOz////////////////////////////////////////////////////AAB0AAB0AAB1
        AAB1AAB1AAB2AQF2Dw93////////////////////////////////////////////////////AAB6AAB7
        AAB7AAB7AAB8AAB8////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AACDAACDAACDAACDAACDAACDAACD
        AACDAACDAACCAACCAACC////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAB4AAB4AAB4AAB4AAB4AAB3AAB3AAB3AAB2AAB2AAB2AAB1AAB1AAB0AAB0AAB0AAB0AABzAABz
        AABzAAByUlGWz8zMz83N0c7O0c3N0s7K0s3K0MnIz8jHzsvKzcrKzcjHzcnHzsrJz8zLzsvLzcrLy8jJ
        ycbGysjHy8jHzMnJzMnJyMbFx8TDycbGycfGyMXFx8TDx8TDysbFycbEx8PCw7+/u7i8GxpxAABkAABk
        Pz6Cvbq8xL/Awr6/wL6+wsDAxMHAw8C/wL29v7y8vry7v7y8v729vry7vbq6vLq6vLu7u7m5vLm5u7m5
        vLq6vbu7vLq6vLu7u7m5ube2t7W1uba2uba3t7W2t7W1t7W1t7S0t7a2t7OyuK+st66stbKztbKytbGx
        s7Cws7Cvsa6urqysrKqqrKiorqiosKmorqqqrKurrKqprKiprKiprKmoqqemqaamq6qpq6mopaOjpaSj
        p6WjpKKhoZ6en52eoJ+foZ+foqCfoaCfoqCgoJ2doJycoZ+fpKGhoJycopuZo5yaoJ2doJ6eoJ2dnpuc
        nZuanZqanJmZnZubmZeXlJGSk5GRk5KSkY2Oko6Pk5CRk5CQlJGQk5CQkY+PkY+PkY6OkIyNkouLkouL
        k42MkYyLkIqJkImJkYuKkYuIjoeGjIWEioaG////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////rKqqrKqqrqysr6yssa2ssKuqsKyssK2tsK6usK6ur62tsa6us7Gxs7Gxs7CwtLGxs7KysrCws7Cw
        tbOytrS0uLW1u7m5u7q5uri5u7e4ube3ube3ube3u7m5vbu7vby8vbu7vbu7v728vry8v7y9wL2+v729
        wL2+wb/AwcHBwb+/wb+/wr+/xMLCxMLCwcHAxMPCxcPExMLDwsDBwsDAwsC/xMHBxcLCxMLDxsTEyMbG
        yMXGyMbGxsXFyMXGysfHyMfHycjIysfIg4GhAABbAABbAABcAABcDg5kPDt9eHecrqu5zsvLycfHtbKy
        kI2RHh1mAABgAABhAABhAABhAABiAABiAABjAABjAABjf32etrO0wb++yMbFzMrK0c/P09DQ0s/O0M3N
        0M7O0s/O0s7N0M3Nwb/HVlaTBARsAABqAABqAABrAABrAABsAABsAABsHh57oqC72dfY0c/PtbOz////
        ////////////////////////////////////////////////////AAB0AAB0AAB0AAB0AAB1AAB1AAB1
        Dw93aWiT////////////////////////////////////////////AAB6AAB6AAB6AAB7AAB7AAB7AAB7
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////AACDAACDAACDAACDAACDAACDAACDAACDAACDAACC
        AACCAACC////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAB5AAB5AAB5
        AAB4AAB4AAB4AAB3AAB3AAB3AAB2AAB2AAB2AAB1////////AAB0AAB0AAB0AAB0AABzAABzAwNzenio
        0c7O0s/P1dHO2NPL2NPM0s7MzsvL0M3MzsvLzMjIy8fHy8jIzcrJ0MzLz8zLzcnJy8bGysfHycbGy8jI
        zcrKy8fIysbGzMnIysjHyMbFyMXFy8fGzMbEy8XDyMPCx8LBqKazHx5zAABlAABlMjJ8v7u9xMDBxMHC
        w8DBxMHBxcLCxMHAwr+/wb6/wr6/wb2+wL+/wL+/v7y8vry7vru8vru8vru8vru7u7m4u7i4vLm6vLm5
        u7m5ure3uba3uba2ube3uri4uri4uLa2trOztrO0t7S0t7Szt7S0t7S2uLW1trOztLGxs6+wsa+vsK6t
        raurraqqsauqta2rsa2tr66urq2sr6ysrqurrKqpqqenqaenr66vr62tqKalpaOiqKWkpqOjpKGho6Gh
        pKOio6GhpKGhpKGhop+foZ6eoZ6eop+foZ+fo56dqqGdqZ+bopyboZ+gop+goJ2dnJqZmpeWnZuan52d
        mpeXlZGSlZKSkI+Pj4yMk5COk5CQlJGRlpSUlpOTko+PkY6Ok5CPlJCQk42MkoyLkYyLj4qJjoeHk4uK
        lo+Oko2LjoeG////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////rKqqrKqq
        rqytrKqrrqurr6qqr6mor6ypr66trqytsa6usq+vsq+vs7Kys7Kxs7Cws7CwtLOztLOys7KxtLKytrSz
        t7W1uLW2ure4u7m5urm4uri4u7i4vbq7vbu7vbu7vbu7vby7vbu7vbq6v7y8v7y9wb6+wsHBw8LCw8HB
        wr+/wL6+wb++wb+/wL++wsHBxcPExcPDw8HBwb+/wb++w8DAxcLCxcPExsTFyMXGxsTExcTDxsXFxsTE
        xsPDxcPDxsTFycbHOzp6AABaAABaAABbAABbAABcAABcAABdIB9ubGqVq6m4ycbGxMHBPj18AABgAABg
        AABgAABhAABhAABiAABiAABiAABjf32ex8TEzcvKzcrKz8zM0c7O0M3N0c7N0c/O0c7O0s/P0c/Pz83N
        0M7N0c/OTUyOAABqAABqAABqAABrAABrAABrAABsAABsDQ1zlpW1vbq6vbq6////////////////////
        ////////////////////////////////////AABzAABzAAB0AAB0AAB0AAB1AAB1AAB1aWiT0s/Qwb6/
        pqOj////////////////////////////////AAB6AAB6AAB6AAB6AAB6AAB6AAB6////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////AACCAACCAACDAACDAACDAACDAACDAACDAACDAACDAACCAACD////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAB5AAB5AAB5AAB5AAB4AAB4AAB4
        AAB4AAB3AAB3AAB3AAB2AAB2////////////AAB0AAB0AAB0AAB0AABzAABzDAx5m5m30s3O1dHO2NbO
        2djO2NPN0s7Mz8zMzsvLzsrKzcvJzMrJzcnJz8vK0MvKzsnIzcjHzMjHysfHy8nJzMnIzMjJzMnKzcrJ
        zMjHysXEy8XEzsfGzsfFzcfEzcbEzMXDtK+5KSh5AABmAABlLy57vbq/xsPExsTExMLDxMLCxMLCw8HB
        wsDAwb+/wb6+wb6+wb/AwsHBw8C/wb6+v728vru8vru8vLm5u7i4vLm5vbq6u7m5vLm6vry8vLq5ure3
        ure4u7m6u7m5uLa2t7S0t7S1uLa3uLe4uLe4uLW2uLW2trSztLGxs7GxsrCwsrCvsa6tsK2ssK6tsK6u
        sa6vsK6usK2tr6ysr6ysrqqrq6moqqioraqrrqurqaenpqWkp6WkqKWlp6SkqKamqaenpKKipKGhpaKi
        pKGgo6Cfo6Ggo6GgoqCgpaCerKKfqp+copycoJ6eoZ+eoJ6doJ2dnpubnZubmpeXlpOTmJWVmJWVl5WV
        lpWVmJaVlpKSlZKSlpSTl5STlJGQko6OlZCPk4+OlJKRlJGQkYyMkIuMlZCPlI6NkI2Lko2L////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////qKSlqKSlqqeoq6mpraurrqus
        squptrCpsq6rrKurraurr6ussq6usq+vsq+vsa+vtbOzt7a2t7a2trS0t7S1t7W2trS1tbKytLGytrS0
        t7S1uLW2uri5u7i5vLi5vLm6u7q6uri4ube4uri5vbm6vry9v76+wL6/wL2+wL29wL69wL6+wL6+wb/A
        w8DCwr/Bwb6+v728wb6+wb+/wr+/w8HBw8HBxcPDxcPExMLDw8HBw8DBxMLCxMLCxMLCxsPEx8TEvbq/
        ERFiAABZAABaAABaAABbAABbAABcAABcAABcAABdAABdQUCAk5GsYF+RAABfAABfAABgAABgAABhAABh
        AABhAABiAABiWFeOx8XHzMvKzMnJzcvKzcvLy8jJzsvL0c7O0M3N0c7O0c7Oz83M0M3M0s/Pw8LIOjqF
        AABpAABqAABqAABqAABrAABrAABsAABsFhZ3gH6igH6i////////////////////////////////////
        ////////////////////AABzAABzAABzAABzAAB0AAB0AAB0AAB1QD+R0s/Qwb6/pqOj09HQwb+/pqSj
        ////////////////////AAB5AAB5AAB5AAB6AAB6AAB6////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////AACCAACCAACDAACDAACDAACDAACDAACDAACDAACDAACDAACD////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAB6AAB6AAB6AAB5AAB5AAB5AAB4AAB4AAB4AAB3AAB3
        AAB3AAB3////////////////AAB0AAB1AAB0AAB0AAB0AABzExN8wLzH1dDN1tHO2dbO2tTN1M3MzsvM
        zcrKz8zL0M7N0M3Mz8vLzsvLz8vLz8vKzcrJzMnIy8nJzMnJzcnJy8jIysjIy8fIzcfG0MbDzcXDzcfF
        z8jF0MjGz8jGzcjFwr7CERFvAABmAABmFRVvray5xsPExsPExcTEw8HBxMHBxMHCw8HBwsHAwsDAw8DB
        w8DBw8DAwr+/wr+/wb6+v7y8vru7vry8vru7v7u8vrq7vbu7vry8v7y9vLu7uri3uba1uba2vbq5vLm5
        u7m5ube3t7W1uLa2ube3uba3uLS0trOytLGxtLGytLGxs7Cwsq+vsq+vs7GxsrCxsq+vsa6ur62trqys
        r6ysr62tr6urraqqrKmpq6ioqainqKemqaemqqemqqioq6iprKmpqKWlp6Wkp6WkpqOjpaOjpqOjpaKi
        paKipqOipqGgpZ+fop+eop+foZ6doJ6eoZ6eoJydnJmZmZaWmZeXmZeYm5mZnJmampmYmZeWmJaVmJWV
        mJWUl5KSmJKSl5GRl5CQk4+PlZKRlZKSk5GRlpKTl5SUlJORkI2L////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////qKSlqqeoqqiorKurq6mqrqqosaunr6uprKur
        rKqrramqrqurr6yssK6usrCxs7GxtrSzt7W2t7W2trO0trS1t7W2tbKytLKxtbOztrO0trS0ube3uba3
        ure4vLq7u7q6ube4uLW3u7m6vLm6vbu7vr29vry9vru9vLq7vbu7v7y9wL2+wb+/wb/Awr+/v729vry8
        v769wsDAw8DBwsDBwb+/w8LBxcPDwr/Awr+/w8DBxcLCxcPDxMLCxcLCxsPDlpSpDw9gAABZAABZAABa
        AABaAABaAABbAABbAABcAABcAABdAABdDg5kExNoAABeAABfAABfAABgAABgAABgAABhAABhAABiLi55
        y8nJzszNzszLzcrJzMnIy8jJzcvLz83Mz8vLz8vM0M3NzszMzsvM0c7O0dDPtrTBPDuGAQFpAABqAABq
        AABqAABrAABrAABrAABsBwdvBwdv////////////////////////////////////////////////////
        ////////AABzAABzAABzAABzAAB0AAB0AAB0CAh5xcLS3Nna2NbV09HQwb+/pqSjycbGsq+woZ+f////
        ////AAB4AAB5AAB5AAB5AAB6AAB6////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////AACC
        AACCAACCAACCAACDAACDAACDAACDAACDAACDAACDAACDAACD////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAB7AAB6AAB6AAB6AAB5AAB5AAB5AAB4AAB4AAB4AAB4AAB3////////////
        ////////trSzAAB1AAB1AAB0AAB0AAB0AABzQ0KQ08/P0s3P2NHP2NLO0c3Nz83O0c7O0c/O08/P087P
        0MzMzsvLzsvLz8vLzsrKzcvKz83M0MzMzcnKzMnJzcvLzcnKzcfGzsjFy8fFzMfGz8nHz8nHzcfGy8jG
        qqe4DQ1tAABnAABmFBNvuLS9yMTFyMXFyMbGxcPDxMLCxMHCxMLCxMPDxMLCxMHCxcLDxMHCwr/Awr+/
        wr6+wL29wL2+w8HBwsDAwb2+wb6+v729vru7vbq6vbu7u7q5uLW1t7O0u7i4vbq6vLq6vLq5ure3ure3
        ube3uLW2uLW1t7SztLGxs7CxtbKytLGws7CvtLGxtbKytbKytLGxtLCxsq+wsa6vsK2tsK2tsa6usa+v
        sa6vrqysrKqpq6moqqenq6iorKmpq6ioq6ioq6moqainqKamp6SkqaanqqenpqOjpaChpaKipqWkpKKi
        pKGhpaKipaGioZ6en5ycnZqam5iYm5mYnZubnpudnJqampiXmpmYmZeXmZeXm5iXmZaWl5OTl5GQmJKR
        mJOSl5KRlpCQkY2OlJKSm5eXmpaWlJOR////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////qqeoqqioqaeop6WlqKSkqqenqaioqqioqqeorKqprayrrayr
        sa6us7CxsbCwsq+vs7Cxs7Gxs7Gxs7KytbSzs7Gwsa+us7GxtrO0trW0trS0t7S1t7S1uba3u7m5uri4
        uri5vLm6vLq6u7m6vLm7vbu8vbu7vLq7vLu7v7y9vbu8vbu7vry8vry8vry9vr29wL6+wL6/wb/Awb6/
        wb+/wcC/wb+/wsDAw8HCxsPExsTExsXFx8TExMLCxMLCYF+MAQFYAABYAABZAABZAABZAABaAABaAABb
        AABbAABcAABcAABcAABdAABdAABeAABeAABeAABfAABfAABgAABgAABhAABhBgVkrqy6zMjJzcrKzMnI
        ycbGysjJzcvLz8vLzsvLz8zM0c7Pz87OzszM0M7N0c7O0c7PyMbMLi6AAABpAABpAABqAABqAABqAABr
        AABrAABsAABr////////////////////////////////////////////////////////////CAh1AABy
        AAByAABzAABzAABzAAB0AAB0aGek3NnZ393e4d/g3t3d2djXycbGsq+woZ+fo6K7JSWEAAB4AAB4AAB5
        AAB5AAB5AAB5////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////AACCAACCAACCAACC
        AACDAACDAACDAACDAACDAACDAACDAACD////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        AAB7AAB7AAB7AAB6AAB6AAB6AAB5AAB5AAB5AAB5AAB4AAB4AAB4////////////19PU29nZtrSziomx
        CAh4AAB1AAB1AAB0AAB0AgJ1aGeh09DR1tLQ08/O0M3O09DP09DQ0s/O1NDQ0s/Q0c3N0c7N0M3NzszM
        z83N0c/P1NDR08/Qz8zLzsvKzsvLzMnKy8fHysfHy8jHzsrIzsrJy8jIycXFycXFrKm5IyN5AABnAABn
        Dg5unpuxysbGysfIycbHyMXFxsTDx8TExsTExcPExMPDxcLDxMLDxMLCxMLCxMLBw8DAwr+/wb+/wcDA
        w8HBwr+/wr6/wb6+v7u7v7u7vbu7vbu7vLm5ure3ube2uLa1ura3vLm5vLq6u7i5u7e4uba2t7S0tbOz
        s6+wtLGxtrOytLGxsq+wtbKzt7S0tbKytbOytLKytLKys7Gws7Cwsa6usK6usa+wsq+vr6urramprKqp
        qqinqqenrKqpq6ioq6morKqqq6moqKamqKamqaamqqenqaampqOjp6KjqaSkp6Sjp6WkqaampaOjoqCf
        oJ6dnZuam5mYnJmZnZubnZubnJmZnZqanZycmpeYmpeXmpeXmJSUlpKRl5KRmJOTmpaVm5aWmZSUkI2O
        joyNlZKRk5CPk5CP////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////qaeop6WlpaKkp6Wmp6WmqKWmqqamqqinq6qpq6qqrqyssq+wsrCxsa+w
        sa6usa6usa+vsa+vsbCvsK6ur6yssq+vtLKytLKytbKztbOztbGys7CxtbO0t7a3uri5vLm6vLq6u7q6
        u7m6vLm6vLq6vb29vr6+vry9vbu8vLm6u7m5vLq6v76+wcDAwL+/wL7Awb7AwsDBwcDAwL2+v729wb+/
        wsHBxMHCxMLDxMHBxcLCxMHBu7m9RUR8AgJYAABXAABYAABYAABZAABZAABaAABaAABaAABbAABbAABc
        AABcAABdAABdAABdAABeAABeAABfAABfAABgAgJhBwdke3mgtLK+zMnIxsPDx8TEyMfIzMvLzszMzMnJ
        y8jIzcrKz8zMz87Nzs3MzszM0M3N0s/O0s/PvrvFMzOBAABpAABpAABqAABqAABqAABrAABrAABrAABr
        ////////////////////////////////////////////////////////CAh1AAByAAByAAByAABzAABz
        AABzAAB0GxuA1dPW3drb3Nra3dvb4N7f3Nna1NPT09PSo6K7JSWEAAB4AAB4AAB4AAB4AAB5AAB5////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////AACCAACCAACCAACCAACCAACCAACDAACD
        AACDAACDAACDAACDAACD////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////AAB7AAB7AAB7AAB7
        AAB6AAB6AAB6AAB6AAB5AAB5AAB5AAB4////////////////19PU29nZzcnJ08/PcnCpAwN3AAB1AAB1
        AAB0AAB0AAB0lpS11NLR0s/P0s/P1NDP0c7O0c3N0c/O09HQ08/O087O0c7O0M3N0c/P09HR09DR08/P
        0s/O0c3M0MzMzsvLy8nJycfHzMnJzcrKzcvLysjIyMXGyMXFvLnAERFwAABoAABoAABniYeoycbGyMXF
        ycbFyMXFx8XFx8TFyMbHx8XGxcPDxcPDw8HBw8HBxMPDxcPDw8HBxMHBwb+/v7y8wL2+wb69wL29wL6+
        wb29wb29v729vry9v7y8vbq7u7m5uri3uba2ura3u7i5vLm5u7e3ura2ubW2uLa2trOztbKytbKys7Cw
        tLGxt7S0t7S0trO0trS0tbSztLKxtbOytbKytLCxsa6vsa6usa+vr6ytr6ysrqurrKmpq6ipq6mpqqin
        qaenqqioqaenqqinqqinqaenqKemq6mop6WlqqamrainqaWlqKWlp6WkpKKioZ+foZ6en5ybnpybnpuc
        n5ycnZqZnJmZnZubnJqampiYm5mYm5iYmJWVmJWUmpeXnJmam5eXmpaWmpeYlJKSjIqKlJGQk5CP////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////paKkp6Wmp6WmqqamqqamqKamqaenqaenqaemrKmqr6ussa2us7Cws7CwsrCvr62t
        r62tsK6usq+vs7GwtLCxsq+wtLKztbOztbKztrOztLOztbO0t7W2uLe3ubi4ube4ube4uri4u7m5uri5
        u7m7vLq7vbq7vLm5u7m4vbu8vry+wL6/v72+wL6/wb/Awb/AwL/Awb/AwsDBwb7AwL6+wL6+wb+/wb++
        wL++wb++qKWxNTRzAABWAABXAABXAABYAABYAABZAABZAABZAABaAABaAABbAABbAABcAABcAABcAABd
        AABdAABeAABeAABeAABfBARhQkGCmJavu7nBxsXGxcPDyMfHzczNzMzLysjHycbGyMbGysjIzcrKzcrK
        zcrLzcvLzszL0M3NzszLzMrKrq28JCR6AABpAABpAABpAABqAABqAABqAABrAABrAABr////////////
        ////////////////////////////////////1dLTISGBAABxAABxAAByAAByAAByAABzAABzCwt4oqC9
        2tfX29nZ29nZ3Nra3dvc3dzb3Nvcl5W7ExJ/AAB3AAB3AAB4AAB4AAB4WViU////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AACCAACCAACCAACCAACCAACCAACDAACDAACDAACDAACD
        AACD////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////AAB8AAB8AAB7AAB7AAB7AAB7AAB6AAB6
        AAB6AAB5AAB5LSyJ////////xMLCzMnJ19PU2dfX2NXV19LT1tPTSEeWAAB1AAB1AAB1AAB0AAB0GBh/
        zcrP09DQ08/P09DQ0c/P0c7O0s/P09HQ1NDP0s7N0s7N0c7N0c7O0M7OzszL0c3N08/P0s7N0c3N0MzM
        zsvLzsvLzszNzMrLzMrKzMnJy8nJy8rJq6i4CwtuAABpAABoAgJpgoClyMXGyMXFycbGycbHyMTFx8TF
        yMbHysjIyMbHyMbHx8XFxcHBwsDAw8DBw8DBxMLCxMPDwsDAwL29wb69wb+/wr/Awb+/wb++wb+/wb6/
        wb6/v729v7y8v7y8u7i4u7m5vbq7vbq6vLm5u7i4u7i4u7i4ure3ubW2t7S0trKyt7O0uLW1trSztrS0
        t7W1t7a1trS0trS0t7S0tbKztbOztLKxs7Kxs7KzsrCxsa6tr6ysraqqq6ipq6mpq6mpqqioqqiorKmp
        rKmpqKamqKWlqaamp6Wkp6Wkqqioqaamp6SkpaKhoZ+eoZ6eoZ2dop6en52doaCfo6CgoJ2dnZqbnZub
        mpeXmJaVmpeXmpmYm5qZnJuanJubnZubnJmZnJqZnJubmJeWkpCPl5KSl5KS////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////qqamqqamqKampqWlp6Slqaamraurr6ytraqqrqysr62usa+vsK2urqyrr6ytsK6usq+v
        sa6usa6usrGxtLOztrS0t7W1trOzs7CxtLKztbS0t7W2trS1t7W1ure4uLa2t7O1uLW2uri4ube4urm5
        vLq6vbu8vbq7vbq7vbu7vLu7vby8vbu8v7y9wb/Awb/Av72/v7y9v729v7y9vry8vru8vru8hIKcExNf
        AABWAABWAABXAABXAABXAABYAABYAABZAABZAABaAABaAABaAABbAABbAABcAABcAABdAABdAABdAABe
        AABeAABfCQhjIyJxOTh8aGeUlJSrtbO+ysjJy8jHyMXFyMbFycjHy8nJzcrKzcrLzcrKzcvLzMnIycbH
        yMbGy8nIzcvLraq7ERFwAABoAABpAABpAABqAABqAABqAABrAABrAABr////////////////////////
        ////////////////1dPT1dLTXl6dAABxAABxAABxAAByAAByAAByAABzAABzXl6e1dPV2tjZ2tjX29nZ
        29na2dbW2dXVhYSxAgJ3AAB3AAB3AAB3AAB4AgJ5WViU0c7PysfGsa6u////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AACBAACBAACCAACCAACCAACCAACCAACCAACDAACDAACDAACDAACD////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////AAB8AAB8AAB8AAB8AAB7AAB7AAB7AAB6AAB6AAB6AAB6LSyJ
        x8XEysXFxMLCzMnJ1NHS2tfY2tfX2dbW1tPSw7/JIyKFAAB2AAB1AAB1AAB1AAB0WVib1dHR1NHR1dHR
        1NHR09HR1NLS1NDQ08/O0s/O08/O0s7O0M3O0M3M0MzK0s7N0s/P0s7N0s3M0MzLz8vL0M7O0c/Qz83N
        zszMzszMz83N0M7NvrzFKip+AABpAABpAgJpamiaysjIysjIy8jIy8fIycXGyMbGyMfGycbGysfHysnJ
        ysnJyMXFxcLCxMHCxMHBxMLCxcTDxMLCwr+/w7+/w8DAw8DBwsDAwsHBw8HBw8DAwb+/wb+/wb6+wL29
        wL69wcC/wL69vbq6vbu7vbq6u7m5uri4ure3u7i4ura3ubW2ubW2ube4ube3uLW1uLW2uLa2uba2uba2
        uLa2t7S0t7W0t7W1t7W2uLa3tbKzs7CvsK2sraqqraussK2trqyrq6mprKqqraqqq6moqaamqKWlqKWl
        p6WkpqSjpqOjpaOipaOjpKGhoJ6eo6GhpKCho5+foJ6doaCfo6Khop+foZ2dn52dnpubnJmZnJuanJqZ
        nJqanZubnZuanZuanZqaoJ6enpuamJaWk5GSlpKSlpKS////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////pqWlp6SlqaamsK6vsK6urKqqqqmqrKqrrqytr6ytr6usramqraqrrqusrqusrqursK6usbCv
        s7Kxs7Gys7Cxs7Cws7GxtbKztbOzt7W1uLa2uLW2trS0uLS2ube3uLa2ube4u7q7vbu9vLm6urm4vLq5
        u7m5urm5u7m5vLq7vLm6vbq7vLu8vby8vry8vru8vLm6vLq6v7y8vbq8dnWVBARXAABVAABWAABWAABW
        AABXAABXAABYAABYAABZAABZAABZAABaAABaAABbAABbAABcAABcAABcAABdAABdAABeAABeAABeAABf
        AABfCQllHR1vQT+BYF6RdXOcoZ6zx8TGycfHycfHycfHz83N0c7OzsrLy8fIyMXFxsPDyMXFzcrKzcrL
        lZOvFhZzAABoAABpAABpAABpAABqAABqAABqAABrAABr////////////////////////////////1dPT
        1dPT0M7OhoSuAgJxAABwAABxAABxAABxAAByAAByAAByFRV9zMvS2NbV1tLS2NXW29nZ19TUzcrOSUiV
        AAB2AAB2AAB2AAB3AAB3DAx8gH+v0c7PysfGsa6u1dHSy8jIs7Gx////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////AACBAACBAACBAACCAACCAACCAACCAACCAACDAACDAACDAACDAACD////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////AAB9AAB9AAB8AAB8AAB8AAB7AAB7AAB7AAB7AAB6AAB6R0aYx8XEysXF2dbV2dfW
        2dfX2tjY29fX29nX2dfW2dbWp6TBDw99AAB2AAB1AAB1AAB1AgJ1lpO219XV2NTU1tPS1tTU1tPT1c/P
        1M/O1dLR1dLS1NDS0tDQ1NDO1dHP09DP0c7O09DP1NDO0M3Mz8vL0M7N0s/P0tDP0c/P0tDQ0M3O0s/Q
        0c7SHh55AABqAABpAABpXVyVyMXGy8nKzMrJy8nIysfIy8nJycjHyMTEycXFysfHycfHycbHycbHycfH
        x8XExsPDxMDAwr+/wr/Awr6/wsDAxMHBw8DAwsDAw8DBw8DAwb++wcC/wb+/wb++w8LBw8HAv7y7vbq6
        vLq6vLm5u7m4ure3ure3u7i4vLm4uba2uLW1ube3vbu7vLq6uri4ure2uba2ure3uLa2t7W1t7O0uLa2
        uri4ure3t7Ozs7CwsrCvsK6usa+usK2trauqrKmqrKqqraupq6moq6iprKmpqqioqqemqKakp6SjpqSk
        p6WlpKKio6GhpqWkpaOipKKhpKCgo6ChoqCgpKGgo6Gfop+foJ6fn52dnpucnZubnZqaoJycoJ2dn5yc
        npucm5mZmpeXk5CRkY6PlpGRlpGR////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////sK6vsK6uraurr66uraysrKqqraqrrqusrKmqrKqqrqytrqusr62trqysr62tsrCwtLKzsq+wsa+u
        srCvtLGytbKztrS0tbOztbKyt7W2uLa3t7a2t7W1ube4u7m5ure4ube3ube3urm5uri5ube3u7m5vLq7
        u7q6uri5vLm6u7m5u7i5vLq7u7m5vbq6vry8u7m5TEp9AABUAABVAABVAABVAABWAABWAABXAABXAABX
        AABYAABYAABZAABZAABaAABaAABaAABbAABbAABcAABcAABdAABdAABdAABeAABeAABfAABfAABgAABg
        CAhkAwNjExNrREOEdnSdoqCyxcLCy8rKz87OzMvLy8nKzMrKycbGx8PDysfHzcrKy8jIjIqqDg5vAABo
        AABoAABpAABpAABqAABqAABqAABrAABq////////////////////////////29nZ29nZ1NHRvbvHDQ11
        AABwAABwAABxAABxAABxAAByAAByAABylpW51tPT1NHR1tPU2NbW19XUxcPLHByCAAB1AAB2AAB2AAB2
        AAB3ExN/mZi63dvb29nZ19XV1dHSy8jIs7Gx1tPUycbHsK2t////////////////////////////////
        ////////////////////////////////////////////////////////////////////////AACBAACB
        AACBAACBAACCAACCAACCAACCAACCAACCAACDAACDAACD////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        AAB9AAB9AAB9AAB8AAB8AAB8AAB8AAB7AAB7AAB7AAB6joy12tfV2NXV29jY3NrZ29nY2tfX2dbW2NXV
        2tjX3NnZ3NnZe3mtAAB2AAB2AAB2AAB1AAB1ExN+wr/L2dbW19TU2NXU19TT1tLR19LS2NXV19XV1tTU
        1tPT1dPR1dLR1NHQ08/P1NHR1tLR087N0c3N0tDP0M7N0c7Oz8zMy8jI0M3O0s/Q0c7SDg5wAABqAABq
        AABqR0WKyMTFzMnJzsvLzcrLzMrLzcvLzMrJycXFyMTFysbHysfHysbHysjIycfHyMbFxsPCxcLCxcPD
        xMHCw8DAw8HAxsPDxMHBw7/Aw8DAxMHBw8DAwsC/w8HBw8HBw8DAwL29vru7v7u7vru7vLm5vru6vbq6
        vbu7vLq6vLm5ure3uLa1ura2u7m4vby7vbu6vLm5u7i4ure3ure3uLa1uLO0t7S1ube3ube3t7S0tLGx
        tLKxtbOzsq+vsKysrqurr62tr62trqyrraqprKmprKqqq6ioqaampqOjpqSkqqmoqaempqOjpqOjp6Wk
        paOipqKhpqKjpqSkpaOio6GgoqCfoZ6eoJ2enpubm5iYnZqan52doZ6epKGho5+fnZqamJaXlJOTkY6O
        kY2NlY6OmZSU////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////raur
        rKqqraurqqioq6mprKqqq6mpq6morKqpq6iorKqqrqusrqytsbCxtLKys7GxsK+vr62tsK2us7CxtbKz
        tLKytLKztrS1t7W1uLW2ubW2uLa1t7W1trS0trS0trS0trSzuLa2t7W1uLa1ure4uri4uri4ura2urW2
        uba3uri5ube3u7e4vbq6sa+0REJ4DAxaAABUAABUAABVAABVAABWAABWAABWAABXAABXAABYAABYAABZ
        AABZAABZAABaAABaAABbAABbAABcAABcAABcAABdAABdAABeAABeAABeAABfAABfAABgAABgAABhAgJi
        AwNjGBhuODZ9WliOl5WvysnJycjIysjKzMvLysnKycjHysfHysfHzcrLdHOgAABnAABoAABoAABpAABp
        AABpAABqAABqAABqAABq////////////////////////1NHR19TU1dPS09HQMTCGAABvAABwAABwAABw
        AABxAABxAABxAAByLi6H09DS1NLS19XU2NTV19TUqajAAAB0AAB1AAB1AAB1AAB2AAB2FxeAtLPG29nZ
        29jZ3dvb4d7e4Nzd29fY1tPUycbHsK2t09DRx8XFraur////////////////////////////////////
        ////////////////////////////////////////////////////////////AACBAACBAACBAACBAACB
        AACCAACCAACCAACCAACCAACDAACDAACD////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////AAB9AAB9AAB9AAB9
        AAB9AAB8AAB8AAB8AAB7AAB7DQ2By8nR3tva3drZ2tfW2tfW2tbW2dXV2dbV2dbW2tbX3NnZ29rZ2NXX
        NzaQAAB2AAB2AAB2AAB1AAB1WVec2NXV1tPT1tLS2NTS2dTS2tXT2tbU2NXV2NXV2dbV19TU19PS1tLS
        1NDR1NDQ1tHQ19DO1dDQ0c/OzcrKy8fH0c3Ny8jI////////////Dg5wAABrAABqAABqQD+J09HQ09HR
        0M3OzcrKzsrLzszMzszMzMnJysjJy8jIy8jHysjIysfHycbHyMXGx8XFx8XFyMXFxsPDxsPCx8TEx8TF
        x8TFxcPDxMHBwr+/w8DBw8DAwb6+wr6+wL29wL69wL+/wsDAwb6+v7y9wL6+wr6/wL29vru8vbq6vbq5
        ure3ubW1ure3vLq5vbq6vLm5u7i4u7m5vLu7u7m5ura2ura4uba3uri5uLa2trOztbOztbOztLGwsq+v
        sq+vs7GxtrSztLGxr6ysrKmoqqenqqenp6WlpKKjpqSkqKamqKWlp6WkqKWlpqKjpaKio6CgpKGhpKGh
        op+foZ6eoZ2foZ6foJ2doZ+foZ6eop+foZ+eoJ+eoZ+eoJ6em5qamJiZk5GSjoyMjYqKj4uLmZSUmZSU
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////rKqqp6Skqqenqqen
        q6iorKqqraurrampq6ioqqmprKqqraysr62tsK2tsK2tr62ur6ytsK6usa+wsq+wsa+vtLGytLKztbO0
        t7W1t7S0trOztbOztbS0tbW0tbO0tLKztrOzt7S0t7S0uba2uLa2uLW2t7O0trO0ube3ure5ube4uLa2
        ura2t7S1mJambGuPHBxiBARWAgJVAABVAABVAABVAABWAABWAABXAABXAABYAABYAABYAABZAABZAABa
        AABaAABaAABbAABbAABcAABcAABdAABdAABdAABeAABeAABfAABfAABgAABgAABgAABhAABhAABiAABi
        AABiHh5yVlSOdXSfpqW3tbS+t7W+yMXFyMbFysfIyMXJYWCWAABnAABoAABoAABoAABpAABpAABqAABq
        AABqAABq////////////////vr291NHRz8vL0c7O0M3QbGugAABvAABvAABvAABwAABwAABxAABxAABx
        AAByqqm/1dLT2NbW19XV1dPUZmWiAAB0AAB0AAB1AAB1AAB1AAB2LCuJ09HT29jY29jY29nZ3Nra3Nna
        3tvc4N7e2tjZ1dPT09DRx8XFraur19TUycjHr62t////////////////////////////////////////
        ////////////////////////////////////////////AACBAACBAACBAACBAACBAACBAACCAACCAACC
        AACCAACCAACCAACC////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////AAB+AAB+AAB9AAB9AAB9AAB9AAB8AAB8
        AAB8AAB8QUCX39vb39zb3dva3drZ3NnZ29fY29jY29jY29jY29jY3Nna3dra3dnaubbKDw59AAB3AAB2
        AAB2AAB2Bwd4pKS/1tTT1tPT19PS29XS3tjU2tfV19PT19LS19TT2NXV2dXU2NXV19TT19PQ2dPS2dTU
        19TU1dLS0M3Nwb++sa2tsa2t////////////AABrAABrAABrAABrCQlewb/H2tnZ0s/PzsrJzcnJzszL
        zszLy8jJy8jJzMrKzMjJy8nJy8jIy8fIysfHycbGyMXFyMXEyMXEx8XEyMbFyMXFyMXFx8TFxcPDxMHB
        w8DBxMHBwr+/wsC/wr/Awb++wsHAw8HBwr6+wL29wL6+wr+/wr2+v7y8vru7vbq6vbq5u7i4vLm5vLm5
        vLm5vLi4vLi4u7m5uri5u7m5vLm5u7m5uba2t7S0uLe3uLa3t7S0tLGxtLGxtLGxs7Cwsq+vsrGwtLKz
        s7CwsK6tr6ysq6mqqKenqKenrKurrKqpq6mop6Wlo6CgpKKio6GhoZ+fop+go6Gho6GhpKGhpKKjpKKi
        pKGhpqOjpqSkpKKjpaKio6GhoZ+foJ6eoJ6enpqampOTmJOTm5mZop+fqaWkramo////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////p6SkpqWlp6WlqKWlqaemp6WlqKWl
        qaamq6ipqqeoqKamqainq6mpq6ipq6ipraqrrqursa6usK2tsK2us7CxtLGxsq+vs7GysrKysq+ws7Gx
        tbO0t7a2trW1tbO0trO0tbOzt7W1t7a2t7W1trO0t7S1uLW1ure3u7m5urm5uLa3trO0u7i4vbu7t7a2
        mJajcXCPRkV5FxdhBARWAgJWAABVAABWAABWAABWAABXAABXAABYAABYAABZAABZAABZAABaAABaAABb
        AABbAABcAABcAABcAABdAABdAABeAABeAABeAABfAABfAABgAABgAABhAABhAABhAABiAABiAABjAABj
        GBdvNjV+SEeHeHaffXuhp6a2y8jJy8jJTk6KAABnAABnAABoAABoAABpAABpAABpAABqAABqAABq////
        ////vr29vr290M3NzMnJzcvL09LSkI+yBQVwAABvAABvAABvAABwAABwAABwAABxAgJyaGeh1dLT19XV
        1dPT0tDRKCiFAABzAAB0AAB0AAB0AAB1AAB1YF+f19TV2tbX29fY2tfY3Nra3dnZ3NnZ29nZ2dfX29jX
        3tvb3dvb2dfX19TUycjHr62t1dLSxcPDq6mp////////////////////////////////////////////
        ////////////////////////////////AACBAACAAACBAACBAACBAACBAACBAACCAACCAACCAACCAACC
        AACC////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////AAB+AAB+AAB+AAB+AAB9AAB9AAB9AAB9AAB8AAB8aWiq3dna
        4N3d4N7d4N3c39zc3tvc3tzc3dva3dra3NrZ3NjY3dna3tva3drZeXitAAB3AAB3AAB2AAB2AAB2KyqI
        1M/T2tfW19TU2dTU29TT2dTU19PU1tPT1tPS2dTT2tTU2tbU29fT3NfT3dfU3NjV2tbU2NXV0M3Nq6ip
        sa2t////////////////AABsAABsAABsAABrAABkwb/H3Nvb1NHSzsrKzMnIzczLzs3MzsvLzcnKzMrK
        zMnKzMnKzMnJzMnIy8jHysbHyMXFyMbFycfGyMXFx8TDxsTDxsLCxcLCxsPDxsTExsPDxcPDxcLDxcLC
        xcHCw8HBw8HBxMDBwr6/wL29wL28wb29wb29wL++wL29v7u6vru6vry8v7y9v729v7y8vrq7vLi4u7e4
        u7i5vLm5u7i4uri4ure3uLS0ube3u7m5uLW0tbKytbKytrOzs7Gxsa+urqyrr6yssK2tsa6us7Cwr66u
        rKurrqyssrCwsK6tqqiop6Sko6GipaOkpKGipKGhp6Skp6alp6Wlp6SlqKenqamop6alpqSkqKWmqKam
        p6SkpaKipaOjpqSkoaCfoJmYopqaqqWlsK2ssq+ur6yrramoramo////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////paOkpaOkp6WlpqSjoZ+foJ6fo6Ghp6Skp6Skqaenq6ip
        q6ipq6mpqqmpqqmorKqrrKmqraqrr6yrr6ytsK2usK2usa+vsa+wsK+wsa+wsrGxtLKztrO0trO0tLKy
        tLOztbOztrS1t7S1tbKytrOzt7S1uLW1t7W0uri4u7q6t7W2tbO0ube3trS0rKqqqaenrKmpsq6unJqp
        dHOUQUF4FBRgAwNXAgJWAABWAABWAABXAABXAABYAABYAABYAABZAABZAABaAABaAABaAABbAABbAABc
        AABcAABdAABdAABdAABeAABeAABfAABfAABgAABgAABgAABhAABhAABiAABiAABiAABjAABjAABkDg5r
        BgVnGBdwKCh5Z2aZgoCgDg1qAABnAABnAABoAABoAABoAABpAABpAABqAABqAABq////ubjEzszMzcrL
        zs3N0M3N0c7Ox8TKCQlyAABuAABuAABvAABvAABvAABwAABwAABxKCeDyMXM1NHS0c/OtrTCDAx4AABz
        AABzAAB0AAB0AAB0AwJ2d3Wq1tPU2dbW2tfX2dbW2tfX2tfX29jY3Nna29jY2dfW2tfX29fX39zc5OHh
        393d2tfX1dLSxcPDq6mp3dra3NnZwb6+////////////////////////////////////////////////
        ////////////////////AACAAACAAACBAACBAACBAACBAACBAACCAACCAACCAACCAACC////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////AAB+AAB+AAB+AAB+AAB+AAB9AAB9AAB9AAB9CAh/kY+63Nna3tzc39zc4Nzc39zc
        39zd39zc39zb3tvb3NnZ29jY3NjZ3NjY3NjY2dbXHBuEAAB3AAB3AAB3AAB2AAB2hICw3NjY2NXV1tTU
        29TT3tTS3NbV2NbW1tLS1tLR2dXU2tfV2dXT29XU3djV3NbT2NTS2dbV0MzNq6ip////////////////
        ////////AABsAABsAABsAABk////3Nvb1NLT0M3NzMrKzMvLz83N0M7Nz8zLzcnKy8nJzMrKzMnJzMnJ
        ysfHy8jHy8jIy8nJysfIx8PFx8TEyMXFxsPCxsPCx8TFxsPFx8TEyMbFyMXFxsPExcLDxcLDxMHBxMHB
        w8DAwr+/wr6/wb6+wr+/w8HBwsC/wb69wr29wr6+wr/Awr+/wr+/v72+v7y9vru7vLm5u7i4ure3uri4
        u7i4u7i3ure3u7i4ube3trOzt7S0uLW1t7S0tbKysKysrqqpsa6us7Kxsq6ur6urrKipr62usrCwr62s
        raqpqqenqKamqKamqaamqqiorKuqqqenqaamqqioqqenq6mpqainqqenqaemp6WkpqSjqKSkqqenp6Wk
        oJ2do56dq6emsa6tsq2sr6mosKuqsKurrqqr////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////paOkqKWmpqSjoqCgoZ+gpaOkpqSlqKWlq6qqr6ytrKmprKmpraurrKqq
        rKqqrKqqrKmqrqqrrqurraqqrqusr62tsq+vsa6vsa+vsa+vsa+usa+vs7GytLKys7KytbOztLGytbKz
        tLKytbOytrO0tbKytbKytrS0uLa2t7W0ube3sq+wo6ChoZ6epqSkqaWmrqurube3vry9vry8mJembm2P
        Pjx2EhJfAwNYAQFWAABWAABXAABXAABYAABYAABZAABZAABZAABaAABaAABbAABbAABcAABcAABcAABd
        AABdAABeAABeAABeAABfAABfAABgAABgAABhAABhAABhAABiAABiAABjAABjAABjAABkAABkAABlAABl
        AABlBARnAABmAABnAABnAABnAABoAABoAABpAABpAABpAABqAABqubjEz8vMy8jJ0M7Oz83NzMnJxcHF
        PDuJAABtAABuAABuAABvAABvAABvAABwAABwAwNxk5G109DR0s/PiYivBgZ1AAByAABzAABzAAB0AAB0
        EhJ8qqnA09DQ1dHR1tPT2NbV2dbW19TV2NXW2tfX2tbX2dfX29jY2tfX29jY3tzc3tvb3tvb4N3c3Nva
        29nZ3dra3NnZwb6+wb6+wb6+wb6+wb6+////////////////////////////////////////////////
        ////AACAAACAAACAAACAAACBAACBAACBAACBAACBAACCAACCAACCAACC////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        AAB/AAB/AAB/AAB+AAB+AAB+AAB+AAB9AAB9FxeHoZ7C39vb3tva3tvb3trb39zc3tvb39ra3tva3dra
        3drb3dra29fX2tbW2dXV2NXVkY+3AgJ5AAB3AAB3AAB3AAB2JCSG2dbY2tbW2NXV3djW4NfU3dbU2dbW
        2NXV2dXT2tbU19TT1tLT19PT2dTT2tXT1NHR0c7Ovru7vru7////////////////////////AABtAABt
        AABsAABp2dbX2dbX19TU0s/PzsvMzszMz8zMz83N0M3MzsrKzMjIzMrKzsvLzcrLzcnJy8jIy8nJysjI
        yMXGycfIy8nJy8jIycbGycbHysbHycTFyMXFycbFyMXGxsTFxcPEw8HBw8DAwsHAxMLBxMHBw7/Aw8DA
        xMDAxcDAw7/Aw8DBxMHAw7+/w8DAw8DAwr+/wsDAwr+/wb6+vru6vbq6vLq5oaCreniWg4Kbure5ure4
        ube2uba1uLa1uLW2t7S0ubW2t7OztbGytbKytbSztbKxsq6ur6ysraqrraurq6ioq6inraqqrKqqraqq
        raurrqysrauqrKioq6emq6elqqamqaamrKmpraqqq6ioqaamqaamqaamqaenp6Wkop2eqKOjrqqqsa6t
        r6mpr6mosaursKurrqqrr6usraqr////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////paOjpaOjpKKhpaKip6Slp6WmqKanqaenq6mqqqipqaemqKWlqqeoqqioq6mpraurramqramp
        q6ioqqioq6qprauqrqqrr6usrqursK2usa6usK6vsa+vs7Gxs7Gxs7Cxs7Gxs7CxtLGytbKys7Gxsa+v
        s7GxtbOytLGxt7S0ubi3rqytoZ2fp6SjsK6tsK6tsrGxuLe3vbu8vbu8u7m6uba2t7S0k5Gja2mONjVy
        KilsHh1mCAhbAABXAABYAABYAABYAABZAABZAABaAABaAABaAABbAABbAABcAABcAABdAABdAABdAABe
        AABeAABfAABfAABgAABgAABgAABhAABhAABiAABiAABiAABjAABjAABkAABkAABkAABlAABlAABmAABm
        AABmAABnAABnAABoAABoAABoAABpAABpAABqLSx/uLS/y8jIzcvLz8zNzcvLysfIZmSbAQFtAABtAABu
        AABuAABuAABvAABvAABvAABwSkqT0M7P0c/QTEuTAgJzAAByAAByAABzAABzAABzJyeGrqzB1NDQ0c7N
        0c7O1dLS2NXW2dXV2NTU19TU19TU2NbW2dfX2dfW2tjY3dvb3dvb3Nra3Nra3Nna19TU3dra3NnZwb6+
        wb6+wb6+////wb6+////////////////////////////////////////////////////AACAAACAAACA
        AACAAACAAACBAACBAACBAACBAACBAACCAACCAACCAACC////////////////////////////////////
        ////////////////////////////////////////////////////////////////AAB/AAB/AAB/AAB/
        AAB+AAB+AAB+AAB+AAB9ISCMvLjP4t/f4N7d39zb39zc4d7e4d3d4d3c4Nzc3tra4Nzc4N3c3dnY3NjY
        29jY2tfX19TWPj2TAAB4AAB4AAB3AAB3AQF3c3Gq3dnZ3dnZ3NnY29fX29bW2tfX29jZ3tjX3dfW2dTV
        2dXW2dbV2dXU3NfX0s/Ps7Kyvru7////////////////////////////AABuAABtAABtAABp////2dbX
        19TU0c7Oz8zN0M3Nz8vMzcrLz83M0MzMzsnJzsrKzsvL0M3Mz8vMy8jJycfHysfGysjIzcvLzszMzMjJ
        ysjIzcjI0MjEzsXBycXEyMbHyMXGyMXFy8TBx8HAw8HBxMLCxcPDxsPDxMHBxcLCxcHAx7+8xr++w8HC
        w8HBwr6+xL/Aw8DBwsC/w8C/wr6+wLy9sq+1mZioZmWNHh1nERFfFxdjoqKuu7m4ura1vbm3u7i3uLW1
        t7W1uba2uri3uLa2trS0tLKytbKytLOxsbCvrKqqq6ipp6Slp6Wlr62ssK6trqusraqsrqyrqqenpqOk
        qaamqqalqaalqKemqaamq6enramprKqqqqenqqanqqioqKempqKiqqSkr6qrsq6usq+usq2tsq2tr6ys
        r6ysr6usraqrr62urqqqqqem////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////oJ+foJ+f
        oZ+fpKGipqOjpaKjpqWlqKampqOkpaOjpaOjpqSkp6Wlqqeoq6ipq6ioqqanq6inqqioqainq6morKmp
        rKmpq6iorKmprqussq+wsa6vr62tsK2ssa6usK2usK2tsa6usq6wtLKys7GxsrCws7Cws7CwtLGytbKz
        tLOyrqysraurtLKyuLa2tbOztrS1uLa3u7i5uri5uLe4ube4ube4ure3ura2tbK0nZunjoygY2KLNjVz
        GhplBwdaAABYAABYAABZAABZAABZAABaAABaAABbAABbAABcAABcAABcAABdAABdAABeAABeAABeAABf
        AABfAABgAABgAABhAABhAABhAABiAABiAABjAABjAABjAABkAABkAABlAABlAABlAABmAABmAABnAABn
        AABnAABoAABoAABpAABpAABpSUiMwb7DzcrL0M7O0M/OzcvLnJqyBgZvAABtAABtAABtAABuAABuAABv
        AABvAABvCwt1xMLIwb3FJiWBAABxAABxAAByAAByAAByAQFzREOSv77J19TU1NHQ0s/P1NHR1dPT19TU
        19TT2NTU19TU19TU1tTV2NXV2tfX29nZ3NnZ3tvc393d4N3d19TU////////////////////////////
        ////////////////////////////////////////////////////////AACAAACAAACAAACAAACAAACA
        AACBAACBAACBAACBAACBAACCAACC////////////////////////////////////////////////////
        ////////////////////////////////////////////////AAB/AAB/AAB/AAB/AAB/AAB/AAB+AAB+
        AAB+ISCMvLjP6ebm5uLi5ODg4uHg4uDg4d7d4d7e4d3d4d7d4t7e497e4d3c4N3d4Nzc39zc3tvboqDB
        CAh7AAB4AAB4AAB3AAB3Cgp8u7nL4Nzc3NnY2dbX29ja3drb3dra3dna3NjZ29fZ3NnZ3NnY3dnY3djX
        ysbGs7Ky////////////////////////////////AABuAABuAABtAABu////3tze1tTV0s/P0M7N0M3O
        zsvMzcvLzszM0MzN0MzNz8vLzcvLz8zMzsvMy8jJysfHy8nJzcrKzcvLzszLy8nJy8fH0MjF1MjB0sbA
        y8TDx8TFx8XFy8TD0sXAzsXCx8XFxsTFx8TEx8TExsPDxcPExsLBy8G/ysLAw8HAwr+/w7++xcDAxMHB
        wb69vLe6trS4e3maQD96Hx5oAABYAABXAABXAABWioigv7y7vbm5v7q6vru7u7m5u7m4u7m5u7i4trSz
        tbOztLGysK2tsbCvr62tr66vrq2tqaenqqmpsrCvsrCvr62sraqrrqurqqiopKOjp6Wmqqiop6Skp6Sk
        pKChpaKirquqr62sq6ioqqenqqeoqKWlqqWlrqmosKytsq+vsK2ssKussayssa6tsa2tsa2ur6ytr62u
        rqqqqqemqaWkqKOjqqWm////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////oZ+goZ+gop+gpKKio6Cgop+g
        pKKipaOioZ+foqGgpqSkp6amp6WlpqOkqKamqaenqaamqaanqaioqaenqqenq6mqrKqqrKmpqqenrKmp
        raurrqusraqrrqqqr6usrqusq6iprayssK6usa+vs6+xsrCwsq+vsa6vs7Cxs7Gxr6ysp6WlqqiotbOz
        t7W2tLKztbS0t7W2uLe4uLa3uri5u7m6ubi4ube4ure4ube2uLa2ube3trS2pKOtiYifX16JNTRzLy9x
        CgldAABYAABZAABZAABaAABaAABaAABbAABbAABcAABcAABdAABdAABdAABeAABeAABfAABfAABgAABg
        AABgAABhAABhAABiAABiAABiAABjAABjAABkAABkAABkAABlAABlAABmAABmAABmAABnAABnAABoAABo
        AABoAABpFhVzqKa5zsrLz87NzszMzMnIxsLEHR15AABsAABtAABtAABtAABuAABuAABuAABvAABve3mm
        q6m8IiJ/AABxAABxAABxAAByAAByAgJzT06W0tDQ1dPT1dPU1dPT1dLS09DR0s/Q1dLS19TU2NXU1tPT
        1tTU2NbW2tfX2tfX3NnZ3tvc393d4N3d////////////////////////////////////////////////
        ////////////////////////////////////////AAB/AAB/AAB/AACAAACAAACAAACAAACBAACBAACB
        AACBAACBAACCAACC////////////////////////////////////////////////////////////////
        ////////////////////////////////AACAAACAAACAAAB/AAB/AAB/AAB/AAB+AAB+////////6ebm
        5uLi5ODg5+Xk5OPi4t/f4N3d393d4N3d4t7f4t7e4d3e4d7e4+Dh4d/g4N3d3trbOzqTAAB4AAB4AAB4
        AAB4AAB3YV+i3drb3dra29jZ3Nrb3tzd3dvb3Nna3Nna3Nna29na2tjY39vb29fXvru7vru7////////
        ////////////////////////AABuAABuAABuAABu3tze3tze2NfY09HR0c7N0c3Nz8zM0M/P0M3Nz8rK
        0c7N0s/OzsvLzMrKzszMzcvLzMjJy8jIzMjIzMnJzcrKzMrKzMjH0MjG0sjF0cfEzsbDycXFyMXFy8XE
        zsbDy8fFycfHyMbGyMXFyMTEyMXFx8TEx8PDyMPDx8PDx8PCxsLBxcLCxcLBv7u9jImjUlGEMjJ0AABa
        AgJaAABZAABYAABYAABXPTx3lI+kwr69wLy+wL2+wL6/wb6/v7y8vbq5uba2trS0t7S0tbOzsq+wsa6v
        raqstbO0trS0r62sr62ts7CxtLGxsq+ur6ysrqysq6mpqqenqqmoqaiopaKio56eo5+go6GhqainrKmo
        qqinqaemp6SkqKOjraamsKyrsq+vsq2ur6qprqmpsaytsa6tsa6vsa6vsa+wraqqqqemqaalqaWkqKOj
        qqWmrKinsaurs6+u////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////n52dn52doZ+foaCgoaCgoZ+hpKGio6GhoZ+foaCf
        pKKjp6WlpqSlpqSlp6WlqainqKemp6amqKWmqaamqaWlqqenrausrausqqioqqenqqeoq6mpraurrKqq
        rauqrqysrausr62tsa6usK2usK2vr66ur66usK6usa6usrCwr6yspaKjpaKjs7Gxubi4tbO0trS0t7W2
        trW1tbS0uLW3uri5ubi4t7W1t7S0uLW1uLa2ube3ure3ure3u7m5tbO2o6Gtrq2yiIefVlaGLi5xCQle
        AABZAABZAABaAABaAABbAABbAABcAABcAABcAABdAABdAABeAABeAABeAABfAABfAABgAABgAABhAABh
        AABhAABiAABiAABjAABjAABjAABkAABkAABlAABlAABlAABmAABmAABnAABnAABnAABoAABoTUyOvbrD
        zsvLzsvLy8nJysfHycXGWViTAABsAABsAABsAABtAABtAABtAABuAABuAABvISF+eHelEA93AABwAABw
        AABxAABxAABxAABygX+r08/P1NHR09LS1NHS1tPT1dLS09DQ1NHR1dLS1tPU2NXV2dbW2dfX1dHS2tfX
        3NnZ////////////////////////////////////////////////////////////////////////////
        ////////////////////////////AAB/AAB/AAB/AACAAACAAACAAACAAACAAACBAACBAACBAACBAACB
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////AACAAACAAACAAACAAAB/AAB/AAB/AAB/AAB/////////////////////5+Xk5OPi
        4t/f5uPj4+Dg4t/f4t/f4d/e393c4N7d4+Hh4+Dg5ODf5eDfoZ/BAwN6AAB5AAB4AAB4AAB4FBSAxsTQ
        3Nra3drb3Nra3dvd3tzd3tzc3tzd3tzd3dvc3dvc2tjY2tjYx8XFx8XF////////////////////////
        ////////AABvAABvAABvAABu////3tze2dfX1dLS0s7P0M3M0MzN0c/P0c/Oz8rJ0cvL0s7Oz8zMzcrL
        0M3N0c7Oz8zMzsvLzMnJzMfHzcnJzsvLz8zMz8vLzcnJzcjIzcjGysbFycXFysfGycfHyMbGycXGysbG
        ysfHycbGycXGycXFyMXFxcTExsPDycXEysbFp6SzcG6WPj18AABcBgZeAABbAABaAABaAABZDg5gIyNr
        dHOVtLG2wb2+wb6+wb29wb6+wL6/wb+/wsDAv7y7u7i4uri4ube2tbKytLKzsrGxraystLKytbOzsa+v
        sa+vuLW1uLW1sK2trKmprKqppqOjpKKhq6moq6mppaGhpaCfpqOjpqSkpKCgoJ2doZ+fqKamq6inrKem
        saurs7CwtLKytK+vsq2ssKyssa2usq+wsrCxsrGxsa+vrKioqqamqqalqKKhqaOiqaSlrKinsaurs6+u
        sKuqq6qps7Gy////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////nJqanJman5ydoaCgoJ+fo6GipKGio6GhoqChoqGhpKKipKGipKGhpKOj
        p6Wlp6amp6WlpqSkqKWmqaWmqKWlqKemqqioqaenqqmorKqqq6mprKqqq6qqq6mprKuqr62tr6ytr6yt
        rqussK2usa+wr66vrqytrqysr62tr62tr62uqqiop6Wlr66uubi5tbO1trS1uLa3t7W2tbO0tbO0t7a2
        t7W2tbOztLGytrKzuLa2uLa2uba3uba3ure4uri5u7m6u7q6ube3uba4sK61oqGueXeXPDt4DAxfDw9i
        AQFaAQFbAABbAABbAABcAABcAABdAABdAABdAABeAABeAABfAABfAABgAABgAABgAABhAABhAABiAABi
        AABiAABjAABjAABkAABkAABkAABlAABlAABmAABmAABmAABnAABnDQxug4Cmy8jIzMnJysjIx8XFyMbG
        zMrJhIOoCAhvAABrAABsAABsAABtAABtAABtAABuAABuAABuHR18AABvAABvAABwAABwAABxAABxAgJy
        oZ650tDQ09HR09DQ08/Q1dHS1tLS1dTT19TV1dHS1tPT2NXV09DQ2dfX1dHS////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////AAB/AAB/AAB/AAB/AACAAACAAACAAACAAACBAACBAACBAACBAACB////////////
        ////////////////////////////////////////////////////////////////////////////////
        AACAAACAAACAAACAAACAAACAAAB/AAB/AAB/////////////////////////////////5uPj4+Dg4t/f
        6ebm5ePj4uDf4N7e4d7e4N3d4t3d4t7e39vdMzKQAAB5AAB5AAB4AAB4AAB4b26q3trc39zc3tva29na
        3dvc3t3d3tzd3tzd3t3d3dvbzMrKycfHx8XF////////////////////////////////////AABvAABv
        AABvAABvERFuzMrL2NXV19XU1dHR0s7O0s/P0c3Oz8vL0M3N0c3O0M3Nz83Oz83N0c7O0c7O0c7Oz83N
        zsvMzsvLzcrKzcrKzsvMz8zMzsrKzcnKzcrKy8jHyMXEyMXEysfHy8jHysfHycbGysfGysjHysbHycXG
        yMbGxsTEsK64jIqmV1WKExNnDAxjAABdAABcAABcAABbAABbAABaODd3dXOWsK21wL29wL28wL69wL6+
        wb6/wr/Awb6+v729wb+/wcG/vry7uri3uLW1t7S1trS0tbSzsq+vs7GxtbS0s7GxtLGxuLa2uLW2s7Cx
        sK6ur62sqKalp6Wkrqursa6ur6yssbCwsbCvsK+vrKmpoqCgnpydpKKir6qqsa2ts7GxtrS1trS1tbKy
        s6+wta+wtK6vsq+vs7GytLK0sa+vraiorKmoq6emqaOiqqKirKWlrqelsqups6yqsKuqq6qps7Gyraqr
        qaan////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////mZeXnJqanZqbn5ydnpycnpycoJ6eoqCgoZ+foZ+foZ+go6GhpKGhpKKipqSlpqSlpaOjpaKjpaOj
        pqSkqKWmpqSlp6alqaalqKWlqaenqaenqKWmqaeoq6mpq6mpraurrausrKqrrKqrrKqqraussK6vrqyt
        rqussK2tsa6usK6ur62urq2tqqinq6mpsrGwtbO0tbO0uLa3t7a3tLO0trS0t7a2tbOzs7CxtLOytbKz
        trS0tbOztrS1ube4uba4ube4uri5u7i4ure4ure3uri4uri4u7i4u7i5rayzjo6kX16LNjZ2LS1xFRVm
        BARdAABcAABcAABcAABdAABdAABeAABeAABeAABfAABfAABgAABgAABhAABhAABhAABiAABiAABjAABj
        AABjAABkAABkAABlAABlAABlAABmAABmAABnJSR4pqW2yMbGyMXFx8TExcLCxMLCx8bFqqe2CgpuAABr
        AABrAABsAABsAABsAABtAABtAABtAABuAABuAABvAABvAABvAABwAABwAABwHRx+zcrN09DQ09DQ0s/P
        08/P1NHS1NLS1tTU1NHR1dLS1tPU2NXV09DQ////1dHS////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        AAB/AAB/AAB/AAB/AAB/AACAAACAAACAAACAAACAAACBAACBAACBAACB////////////////////////
        ////////////////////////////////////////////////////////////////AACBAACBAACBAACA
        AACAAACAAACAAAB/AAB/////////////////////////////////////////////6ebm5ePj4uDf5+Pk
        5uPj5eLi49/f4d3e4N3elZO8BAN7AAB5AAB5AAB5AAB4FBSBwsDP4Nzd3tzc3dvc3t3e393e3drb3dna
        4d3e29nZuLa2ycfH////////////////////////////////////////AABwAABwAABwAABvERFuwb/L
        1NHS1NLS1NHQ09DQ1tTU1NHRz8vM0M3N0c/P0MzN0M3O0M/O0M7O0tDR0tHR0tDQ0M3Oz83Oz8zMzcrL
        zszMzszMzsvLzs3Nz83OzsvMy8jJycbHysfHzMjIy8jHysbFysfHy8jIy8jIwr/Dm5mwZ2WUHh1uFxZr
        AABeAABeAABeAABdAABdAABcAABcLCtzf36esK22wr+/w8DAw8DAyMTAxsG+wb69wb/Aw8HCw8HBwr/A
        wb6/wb+/v7y8vLm5uba3uLW2uLW2uLW1tbOztLGxtrSzt7a1t7W1t7W1tLOysa6vsa6vs7GxtbSztrSz
        t7SztrSzt7W1uLe4t7W2t7W2t7W1sK6uq6mpr6ystLCwtrW0t7W1t7W1t7S1tLGys7CytbCxtK+vsa6u
        tLGytbO0srCwramprKemrKalqKKhp6GhqKCeqZ2ZqqCdr6mosa6trqyrtbS0raqrqaanqqenqqmp////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////lJGSmZeXm5mYnZuc
        npyenZubnJqanp2dn56doZ+foJ6eoZ6fop+gpKGhpKKipaOkpaOkpaKipKGho6Cho6GhpKKjpKGjpKGg
        paOhpqSkqKanqKamqKWmqaenq6ipq6iprKmprKmprKmqraqrrKurraytrqysrqysrqurrqusrqussK2u
        sK6us7GxrKmqpKCgrKqptbW1tLO0sq+vsq6vtbK0tbO0raqqpqOjrqurtbOztbOztbOytLKztLOztrSz
        t7S2t7W2uba3ure2ure3uLa3uLe3ube2ube3ube3uri5vbu7u7m4rquxn52rgoCdaWeQU1KFKilwBARe
        AABcAABdAQFdAABdAABeAABeAABfAABfAABgAABgAABgAABhAABhAABiAABiAABiAABjAABjAABkAABk
        AABkAABlAABlAABmAABmTUyLu7m/xsTDxcHBxcLCxcTExcPDxcPDxMLCMjGAAABqAABrAABrAABrAABs
        AABsAABtAABtAABtAABuAABuAABuAABvAABvAABvAABwRkWQz8zO0s7P0s/P0s/P09DP1NHR09DQ0c/P
        xcLCwb6+1tPU////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAB/AAB+AAB/
        AAB/AAB/AAB/AACAAACAAACAAACAAACBAACBAACB////////////////////////////////////////
        ////////////////////////////////////////////////AACBAACBAACBAACBAACAAACAAACAAACA
        AACA////////////////////////////////////////////////////////5+Pk5uPj5eLi6eXm5+Pk
        5eLi39zeLCuNAAB6AAB5AAB5AAB5AAB4dnSt393e39ze3tzc393d393d3dvc3tvc4d7f19TUuLa2////
        ////////////////////////////////////////AABxAABxAABwAABwAwNwsa7C1NHR09DQ1NLT1tTV
        2NXW19TT0tDQ0s/P0s/P0c7O08/Q09DQ0dDP0tDR09HS0tDQ0c7O0M3O0M7O0c/O0c7O0M7NzszLzszM
        0M7O0M3Oz8vMzsrLzMnJzcrJzMjIy8fGycbHqKa3h4WmMzJ7IB9xAABgAABgAABfAABfAABfAABeAABe
        CAhhHx5tcnCYyMXEx8TDxcLCw8HBxcLBysfDzszDycTBwb/AwsLCxcPCx8TDxsPCxMDBwr+/wb6+v7y9
        u7m5uba3uri4uri4uLa2uLW1uba2uri3ube3tLKxrauqraqrsrCws7Gxt7a2u7m4u7m4uri4ubi4uri5
        uri5uri5u7i5trS0s7CwtrGyt7W1ubi4uri4uLW0t7S0trS0t7W2tbS0tLGytLGytrO0t7W2trW0rqyr
        q6alrqemrKenqqamqqakpZqZo5mZrKurtba2rq2st7a2raqrqaamqqenqqmprKqq////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////lpWVlJGSmZeXmpiXm5iZm5mam5qam5mZm5mZ
        npycop+foqCgoZ+foZ+gop+gop+foZ6fop+gop+goqCgo6Ggo6Cfo6Cfo6Cgo6Cgo6CgpaKipqSkp6Wm
        p6anqqioq6ipqqipqaemqaWlqqenq6eoraysrq2uraqrq6mprKuqq6iprKmqrqussK2usa+vpqKknpuc
        qaintLSzs7Kyr6qrraiotLGysrGyqKampqSjsK2ttbOztLKytLKytLKzs7Gxs7GwtbKztrO0trS0uLW1
        uLW2ube4ube4ubi4uri4uba3uba2uba2uLW0t7S0uba3uLa2s7Czure3sK6zoJ+rcG+TTUyCKipxGxtq
        FRVoAgJfAABeAABeAABfAABfAABgAABgAABhAABhAABhAABiAABiAABjAABjAABjAABkAABkAABlAABl
        Dw9sf36ix8XFxcLDxsPExsXFx8XFyMbGyMbGyMfHammaAgJrAABqAABrAABrAABrAABsAABsAABsAABt
        AABtAABuAABuAABuAABvAABvAQFvc3GjzMnM0c7O0c7O0c7O09DQ1NLS1NHR09DQu7m5wb6+////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAB+AAB+AAB+AAB/AAB/AAB/AAB/
        AACAAACAAACAAACAAACAAACBAACB////////////////////////////////////////////////////
        ////////////////////////////////AACBAACBAACBAACBAACBAACBAACAAACAAACA////////////
        ////////////////////////////////////////////////////////6eXm5+Pk5eLi6Oble3qyAAB6
        AAB6AAB5AAB5AAB5ISGI2dba4N3d4N3c4Nzb39zc3tvc39zd3t3cyMfHyMfH////////////////////
        ////////////////////////AABxAABxAABxAABwCwt2o6G+2NXU1NLR19TV2NXW2NXV19TU1tTU1NLR
        09DP1dHR1tTU1tPU09DQ08/Q09DR09DQ0s/O0c7O0c7P09HR1NHR0s/P0c7O0M7Oz83Nz83M0M3N0M3N
        zsvK0MzMv7vDkY+sS0qIKSl3AABiAQFiAABhAABhAABhAABgAABgAABfAABfLSx1bmqVqKKyy8bFycbG
        ycXFxcLCw8HBxMLCycbDzMjDycTCxcPDxMLCxsLByMTBxsLBxMHAxMHAw7+/wLy8vry7vru7u7i4ube3
        ubi4vLq6vLi4uba2vbu6t7a1rqursK6utbOytbKxtLKxtrS0uLa2u7m5vLm6ure3u7i5vLm7u7m6uLe2
        trOztbKyt7W2ure5vrm5vLi2ubW2ube4ubi5uLe4t7S2uLS1t7S1uLa3uLe3srCvramoraior6yrr62t
        raqqqKOin5mZpKOksrOzrq2st7a2sK6uraysrKqrq6mqrKqqr62t////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////lpSUlpWVmZeYmJaXm5mam5iYm5iZnJqbm5mZmJWWm5manZubn52coJ6e
        oJ6foJ2fn52doJ6foJ6foJ6foJ6foZ6eoZ2eop+epKGgo6KipKGipKGhpKKipKKipqSkp6WlqKamqaen
        qaamp6SlpqSjqKamqaioqaeoqKWmqqemqqmpq6qqrKqqramqrqysrKqqpKKjoJ6fpqSjrq2tsrCwsa2v
        sK2usbCwsbCxr62usa+wtLKztbS0tLKzs7CxsrCws7GxtLKzs7KytbKytrOztrS1trS2t7W2uLa3uba3
        ure4ube3uLa3ubW1trOztbOztrOztbKys7CxtrS0urm4uri5u7m5vbu6rq20k5Glg4GeZ2aRTEqCLSx0
        AQFfAABfBQViAgFhAABgAABgAABhAABhAABiAABiAABiAABjAABjAABkAABkAABkJiZ3o6GyxsPExsTE
        x8XGyMbGyMXFycfGycfHysjJmZiwCQhtAABqAABqAABqAABrAABrAABrAABsAABsAABtAABtAABtAABu
        AABuAABuDg51hIOqzcrLz8zMz8zM0M3NzcrKzszM1NHR2tjYu7m5wb6+////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////AAB+AAB+AAB+AAB+AAB/AAB/AAB/AAB/AACAAACA
        AACAAACAAACA////////////////////////////////////////////////////////////////////
        ////////////////AACCAACCAACCAACBAACBAACBAACBAACAAACA////////////////////////////
        ////////////////////////////////////////////////////6Oble3qyAgJ7AAB6AAB6AAB6AAB5
        AAB5mZe84N3c4d7d4N3c4d3c39vb4dzd29jZuLe3uLe3////////////////////////////////////
        ////////AAByAAByAABxAABxAgJxhoSx2dfX19XV2NXV19XV19XV19XV19TU1tLS1NDR1tTU2NbW2NbW
        1tLU1dHS1dLS09DQ0tDQ09LS0s/R09HS1dPS1NLS09DS09DS0c/P0c/O0M7Nwr/Fqqi5ZWSXPz6EAABk
        AwNmAABjAABjAABiAABiAABiAABhAABhCgplHh1vcW+ZvbW8zcTB1MvGzsnIy8jIysfHx8TExsLDx8TF
        xcPCycTCzcfEzMfExsLCxcHCx8TCxsLBxMHBw7+/wr6+wLy8wL28v728u7i3uLa2ube3vry8vLm6ure3
        wcC/xMLCvLi5ube3uba2uLW0tbOytbKyt7S0ure3uri4t7S0ubW2vru8vr29vLq6uLa2uLa2ubi5u7m6
        vLi4vLi4u7i5u7m6u7q7uri6uri5ube4ube3uri4t7W1s7CvsKysr62sr62trqurqaSlqqalop2doqCh
        sbCwsK6uube3s7GxtLOzsK6vraqrraqrr62tr62t////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        l5SVmJSUlpSUl5WWmJaXmZeZmpmanZubnJmanJqbnJmam5iZmpiZmpmZm5manpydn52fnpyen56en56f
        oJ+goJ6eoJ6en5ydoJ2doZ6eoZ+eo6ChpKKipKKjo6Cho6Cgo6GhpKKipKKipqOkpqSlpqWlp6amqaio
        p6OkpKChpqOjqaamqaanqaeoqqeoqqanq6mpqqipq6mqqaioqKWnq6iprqytsa+xsK+xsK6vsK6vsbCx
        srCxsq+xsK+wsa+vsa+vsq+vtLGytLKzs7GxtLKytrS1trS1tLK0tLKztLOytbO0t7S1uLa2t7W1t7S0
        tbKytLKytrO0tbKys7CwtLOyuri4ure4uba3u7i4vLm5vLq6vbu7t7S4tLK1uLa3pKOveniaYV+NRkWB
        OTh7IiJxAgJhAABhAABhAgJiAABiAABiAABjAABjAABjAABkU1KMu7m/xcLDxcPDxMLCxcLDxcLDxsTE
        x8bGyMbGwL3CHx93AABpAABpAABqAABqAABrAABrAABrAABsAABsAABsAABtAABtAABuAABuJCN+oZ61
        zMjIy8jIzsvLzMnJt7S0zszM////2tjY////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////AAB+AAB+AAB+AAB+AAB+AAB/AAB/AAB/AAB/AACAAACAAACAAACAAACA
        ////////////////////////////////////////////////////////////////////////////////
        AACCAACCAACCAACCAACBAACBAACBAACBAACB////////////////////////////////////////////
        ////////////////////////////////////////////AgJ7AAB7AAB6AAB6AAB6AAB5QD+W4N3d4t/f
        4N7e4N3d4Nzc4t7e4N3euLe3////////////////////////////////////////////////AAByAABy
        AAByAABxAABxa2ql2dfY2tfX2NXV19XW2NbX2NbW19TT19LS1tPT1dTU2NbW2NfX19XW19TV19TU1dPT
        1NLT1dTV1NLT1NHS1dPS1dLS1NHS09DRycbLuLbDeHaiS0qLAABmBgZoAABlAABlAABkAABkAABjAABj
        AABjAABiAABiMzJ7bmyZtbG9z8nI08rF0sfC0MjGzcjIzMnJy8jIysfHzcnHzcfGy8bEzMjG0czIzcfE
        xsLCxsPEx8XGx8XFxsPDxMDBwr+/wr+/v7y8vbq6vbq5ure3uba2v729wL29u7m5v729xsTExcPDwb+/
        vbq7u7i5uba3uLW2u7i4ure3t7S0trS0uLW2vLq6vr29vru8vLm6vLq7vLm6u7m5u7i5ube4u7m6vLq7
        vLm7vLm7vLq7u7m6urm6vLq6ube3s7Cvrauqq6inrKioq6enqaSlq6enrKursbCxt7a2srGxuri5tbOz
        tbOztbKzsa6wr66usbCxtbO0////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////lZKUlpSVl5SVmJSUl5OTlpOU
        mZaXmZiYmZeYmpeZnJmZmpiZnJqbnJqbnJqanpycnpydnZydnp2dnp2dnZucnpucn5ydoJ6doJ2eoJ2e
        oJ6doJ+eoJ6fo5+go6Cgo6Gho6GipKKjpaOjpKGho6ChpKKjpqSlpaSkp6anqaeoqaamqKWlqKamqaeo
        qKWmpqKjp6SlqaanqaanqqiorKqpsK+vsK+xrqusrKqrrayur66vr62usK6vr66usK+vsa6wr62urq2t
        sa+wsrCxs7Gys7CxtLGytbO0trO1tbK0tLKztbO0tbKztbO0trW2trW1trS1trO0trO0t7S0uLa2ure3
        uri3uri4u7m5uri4t7S1uLS1ubW1u7i4vbq7vLm5u7m5uri4vLq7vru8vrq7sa+1qKexo6GwmJaqcG6Y
        SEeEOzp+JCRzIiJzAgJjAABiAABjBARlX16RxMLCxMLDxMHBxcHBxMHCxcPExcTExsTFx8XFx8XFYmGW
        AABoAABpAABpAABqAABqAABqAABrAABrAABrAABsAABsAABtAABtAABtMzKFtbK9y8fHy8nJz8zMycbG
        t7S0////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////19bV////////////////////////
        ////////////AAB+AAB9AAB+AAB+AAB+AAB+AAB/AAB/AAB/AAB/AACAAACAAACAAACA////////////
        ////////////////////////////////////////////////////////////////AACCAACCAACCAACC
        AACCAACCAACBAACBAACB////////////////////////////////////////////////////////////
        ////////////////////////////////AAB7AAB7AAB6AAB6AAB6BQV8xcPU5eLi4+Hg4N3e4d7e4+Lh
        4N3euLe3////////////////////////////////////////////////AABzAABzAAByAAByAAByTU2X
        1tTY3Nra3NnZ29nZ29nZ2dbX2dbV2NXV19TU2NXW2dbX2NbW19XV19XV2NbV19XV1tPU1NPU09LR1dPS
        1NHSysfM0tDQf32mW1qVFhZzDAttAABnAABmAABmAABmAABlAABlAABkAABkAABjAABjAABigX+ns7G/
        z8zMzcrKzcnIzsfFysTDycbHy8jJzsrKzcrKzsrI0s7Iz8rGzcjGzcjHzsrHysfFx8TEyMXFyMXFyMXF
        x8XFx8TExsPDxMHCwL6+vru8v729vry7v7u8wr+/wb6+vLm5uri4v729xcTExcTEwr/Av7y9vbm6vbq6
        v729v7y8vLi4u7i4uri5ube3vLu7v7u8wLy9vLq6ubS0ura2vr29vbu7u7m6vLm7u7i6u7m6vbq6vbq7
        vLq8u7m6u7m6trSzqqempaCgq6Slrampraqrr62utba1urm5ure3srGxu7u7t7W1trS0trS0trW1t7S0
        t7S1tbO0tbO0////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////lZKUlZKUlpSVlZOUlpKTlZKSlpOUl5OVmJWVlpSUl5SV
        mJWWmZeXmJeXmZiYmpeYnJmam5mZm5mZnp2dnpycnZmanZqanJqanZubnpycnp2dn56dn52doZ+go6Ch
        o6Cgop+go6GipKSkpaOkpKKjo6GipaSkpqWmpaOlpqOlqaeoqKinp6elpqSlqaeoq6mqqqeoqaioqqmp
        qqeoqqioraqrraurr6ytrqutrKusrKysr66ur62tr62usK6vsLCws7KysrCwsbCvsrCwsrGxsbCxs7Cx
        srCxtLKztrS1trO0trW1t7W2t7W2t7W2uLa3t7W2t7a2uLa2uLW2uLa2uri4vb29vr6+vLu8vLq7u7q6
        u7m5uri3u7q5vbu7vry8vb28vLu7vbu7vLm5vry8wL6/wcDAv7++wL++wsDAwcDBwcDBs7G4np2wo6Gy
        lJKqcnGaSEeGQECCioilxMLCxcPExsTEyMbFyMbGx8bGycfHx8bGxcXExsbFlpWvAQFoAABoAABpAABp
        AABpAABqAABqAABrAABrAABrAABsAABsAABsAgJuTUyQycbHz83Nz87O0c/PzMrKzMrK////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////sK2t////////////19bVz83Nq6io////////s7GxoZ+f////////////AAB9
        AAB9AAB9AAB+AAB+AAB+AAB+AAB/AAB/AAB/AAB/AACAAACAAACA////////////////////////////
        ////////////////////////////////////////////////////AACCAACCAACCAACCAACCAACCAACB
        AACB////////////////////////////////////////////////////////////////////////////
        ////////////////AAB7AAB7AAB7AAB7AAB6AAB6Ojp+5eLi4+Hg5eLj4d7e4+Lh////////////////
        ////////////////////////////////////////AABzAABzAABzAAByAAByODeN2tna3dzc3tzb3dvb
        3dra29jY2tfX2dXW19TV2dfY2dbW19TV1tTV19TU19TU2NfW19TU1NLSy8jNz87Rh4asYV+ZGRh1CQlu
        AABpAABoAABoAABnAABnAABnAABmAABmAABlAABkAABk////////////gX+n2NXW1NHRz8zMzMrKysjI
        ysfHysfHzMrKzcvLzMnJzsrH0MzIzMnHy8bHycTFyMXGzMnHzcnHyMXFx8XFx8TFyMXFx8XFx8XGyMXF
        yMXFxcPDxMLDxMPDwr/Awr6/wL69v729v7+/wsHBx8XFx8TEwr+/wL+/wr+/wr28wr6+wcDAwb6/wL29
        vby9vLq6vrq7vbm6v7y8v729u7e3u7m5v72+wb6/vbu8vby8vby8u7m5vLq7wL29vry8u7m6vLq7uri3
        rqysrKmqsq6vs6+vsq+xtLKzt7W2uLa3uLa2srKwvLy7uri3uLe2trS0uLW1uLW1t7W2t7a2t7a2////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////jouMkY+OlpONl5SRkY+QkY6OlpKQmZWQk5COkpCPlI+PlpSTlJKSlZGRmZWW
        mZeXl5WVmZeWmpiXnJqZmpiYmJWWmZeWmZeVmJaUmZWVm5iZnp2cn56dn52doJ2cnpyanp2bnpyaoJ+e
        npycnJqbn56doqCfo6CgpaGiqaWmp6WlpKOio6GhpKGio6KhpaOipqOipqSjqaempqWlpaWjqKalq6mn
        qainqaioqqipqainq6moraqqqKeoo6KipaKiq6morq2trqysraurrayrr62sraysq6ytrq2usbCwsbCw
        sK6usa+vsrCxtbS0t7W1trSzsrGwrKqrrqyrs7KxsbCwraysr6yssa6utbOzuLi3tbOzraysrauss7Gx
        tbSzsrCwsa+vt7W0vLq5vry8vr29vLq5vrq3v7q5u7m5vLm4vLm4vLq5vbq5wL28v769v728wb6+trO7
        vry/wL69wr+/xsTExcTDxMHAxMLBxMPDw8HCxMHBxcPCrau3GBhyAABoAABoAABoAABpAABpAABqAABq
        AABqAABrAABrAABrAABsAABsf3ylxcPCwsC/z87O0c/PzMrKzMrK////////////////////////////
        ////////////////////////////////////////////////////////////////19PUyMXGycjIzMnK
        y8jJsK2tz83NxMHBxMLB19bVz83Nq6io0c/PzszMs7GxoZ+fycjHsbCw////////AAB9AAB9AAB9AAB9
        AAB+AAB+AAB+AAB+AAB/AAB/AAB/AAB/AACAAACA////////////////////////////////////////
        ////////////////////////////////////AACDAACDAACCAACCAACCAACCAACCAACC////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAB7AAB7AAB7AAB7AAB6Ojp+////////5eLj////////////////////////////////////////
        ////////////////////////AAB0AAB0AABzAABzAABzISCBwb/N3dvb4N7e3NfX2tnY3d3e3Nna2tXU
        29jX3dva4N/f3t3e2dfX1dLR2NXU09DV2NfXlJOzbWugMTGECgpwAABqAABqAABpAABpAABpAABoAABo
        AABoAABnAABnAABmAABl////////////////////////2NXW1dHQ0MzLzcrKzcrJycbGycfGzczLyMbH
        wb+/xMHCx8PDxsPDycfGyMXFxMHBxcLDx8XExcLCxcPCxsPDwLy8xMHAxsPBv7y8wL28xMC/vru7vLq5
        wr69vLi3uba1u7e2ure3t7S0uLS0u7e3uri2ube2tLKxs6+vtbGwubW0vLm4u7e3ubW2vbu6u7i3u7e3
        u7e3t7SzubW2vbm6vLi4vbm5vbq5u7q5uba3uLS0uLS0t7O0trO0ubW1vLa1ubWzuLS0u7i4vbu8u7i6
        uba3uLa2trS0tLCvtrSyuLa2uLW1uLa2uLa2uLa3t7e2t7a1uri4urq5urq5////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        jouMjouMjoyLlJGNkpCNjImKjoqLko6Ok4+NlpKOlJCOk5CQlJKSk5GRkY6Oko+PkpCRlJGRlZOSl5SU
        lpSUlZOTlZKSl5STlpWUl5SUmZaWmZeYmZeYm5iZnZybnZuanZqanZuan5ycn56enp2dm5mZm5iYnZyc
        oJ6en5ydoJ2eo6Cgo6Kho6Cgop+foZ+goZ+fpKGhpKKjo6GhpaKipqOjqKWlqaanqaenqKemqaioqKen
        qqenqKWmpaOjpKKjp6Okqaamq6mpqqeoqqenq6mprKmqrqurrqysr62tsK6vsK2ur62usK6vr62usa6v
        s7Kys7GysrCwraqqrqyss7GxtbOzsK6urKmqr6yts7KytbOztbOzsK2tr6ystbOzuLa2tbOztrS0uLW1
        uLS1uLW2u7m4vrq4v7q5vbu7u7i5u7m5vLm6vbq7vbu7v7u8vry8vby7v729v729v7y9wsC/xMLCw8HC
        wb+/wr+/xcLBxcLDwb6/wL6/w8HCvr2+RESGAABnAABnAABoAABoAABpAABpAABpAABqAABqAABrAABr
        AABrAABspqO4xMLBwsC/////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////19PUyMXGycjIzMnKy8jJzszMz83NxMHB
        xMLB0c7O3NnZ1dLS0c/PzszM0M3O1NHSycjHsbCw0s7PxsTEHBx3AAB9AAB9AAB9AAB9AAB+AAB+AAB+
        AAB+AAB/AAB/AAB/AAB/AAB/////////////////////////////////////////////////////////
        ////////////////////AACDAACDAACDAACDAACCAACCAACCAACC////////////////////////////
        ////////////////////////////////////////////////////////////////////AAB8AAB8AAB7
        AAB7AAB7AAB7////////////////////////////////////////////////////////////////////
        ////////AAB0AAB0AAB0AABzAABzBwd2x8fT393f4t/h4d7f4d/e4eDg4N3e39zc4N/e397e4d/f4d/g
        2Nba29nanJy7dnapODeJDQ1yAABsAABsAABrAABrAABqAABqAABqAABpAABpAABpAABoAABnAABnAABm
        ////////////////////////////////1dHQ39zd2tfY1tPT0M7O0c/P0tDQ0c7PzcvMz8zN0M7O0MzN
        0M7Nz8zLzcrKzszNz83OzsvMzcvMy8nIyMbFzMrKzcvLysfIycfGy8jIycXGxsPCy8bEx8TDxMPDx8TE
        xcLBwsC/xcHBxsPDxMLBwMC/vby7vru6wb69xMDAxcHBw8DBwsDBw8HAwsC/w8DBxMLCwsDAw7/AxMHC
        w8DBwsC/wsDAw8HBwb2+wb2+wcDAwL+/wL69v729wb6+v7y7vry7vr29vru8vrq7vbq6u7m5u7m5vLq5
        vby6ube4ube3uLe3uLW2tLKzsa+wsK6tsa6uq6mqq6mq////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////jImJjImJi4iIjYmK
        kI2Lko6LkoyLkoyLko6Kl5ONk5COkY6PlJCQkY6PjouMj4qJk42Lko6Ok5CQlJGRk5CRlJKSlpOTlpKS
        lZKTlpOTl5WVlZKSlZKSl5SUmJWVmZaWmpaXm5mZm5iZm5iZnJmZnJqZnJmZnZqbnpybnJqanJqbn5yd
        oZ+foZ6eoZ6foZ6fop+go6Cgop+hoZ6eop+fo6CgpKKipqSkpqSkqKWlqKWlp6Wmp6WmpaOkpaKjqaen
        p6WlpaKjqaanqKamqaamqaanqaeoq6iprKmpq6ioraqrrqusr62ur62urqusrqyssK+vsK2ur6ytsa6u
        sK6usq+wtrO0srCwpqOjpqOkr66urauqsq6usq+vsq+vs7CxtLGys7GxtbOytrS0tLGytrKyurSzu7a1
        u7e4u7m6u7m5u7m4vLm6vbm6vLq6vbm6vbu7vby7u7m6vLm6vLi5vrq6vbu7vbq7vru8wL69w7+/wr+/
        wL29wL29wr+/v7y9h4WiAABmAABnAABnAABoAABoAABoAABpAABpAABqAABqAABqAABrIyJ7ysfHtbKx
        tbKx////////////////////////////////////////////////////////////////////////////
        ////////////////////////raqqxcLC19PU0s/R0s/P1tPT1NHS1NHS2tfX2dbX1dPT09DR1tPU2dbX
        29nZ2NbW19XV3NnZ3NrZ1tPT0s7PxsTEenmeAAB8AAB8AAB9AAB9AAB9AAB9AAB+AAB+AAB+AAB+AAB/
        AAB/AAB/AAB/////////////////////////////////////////////////////////////////////
        ////AACDAACDAACDAACDAACDAACCAACCAACC////////////////////////////////////////////
        ////////////////////////////////////////////////////AAB8AAB8AAB8AAB8AAB7AAB7////
        ////////////////////////////////////////////////////////////////////////AAB1AAB1
        AAB0AAB0AAB0ExN9q6rH4d7g4d7g5ePl4+Hi4N3c3tvb3tzc3tzc3Nna3NjZpaLAeXirQ0KPCQlzAwNw
        AABtAABtAABtAABsAABsAABrAABrAABrAABqAABqAABpAABpAABo////////////////////////////
        ////////////////////39zd4t/g2dbX19XW1NLU1NLS1tPT1NHT09HS1NPT08/R0c7P0s7O08/Q09DR
        0dDR0c/Q0M/QzcvLzszMz83OzczNzczNzczNzcrMz8zNzcrLzcvLz87Oz83Ozs3OzszNz8zMz87Pz83O
        zczMyMfHxsTEysjHzczLzcvMy8jJycjIyMbGyMTFycbHy8jJycfHxsXGxsTEx8TEx8XGxsPExcPExcPD
        xsPDxcLDxcPDxMPDxMLCw8LDwsHDv76/v76+wsDBwb6/wb6+v729vbq7vbq7vry8wb+/u7i5vry8vr6+
        ubm6sK6vrqqrrampqKGioZycoZyc////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////i4eHioiIioeIiYWGkoyJlpCMko2LkYyJ
        ko2Lk4+Mj4yMj4yNkY6Ok46OlIyKl4yHmZCLlI+Oko+Pko+PkY6Ok5CQlJGSlJGRlJGRlJGRlJGRlZKS
        lZGRlJGRlJGSlZKSl5SVmpeYmpiYmpaXm5iZnJmanpubnZqanZqanpydnp2enpucnpycn5ycoJ2eoZ+g
        oZ+goZ+gn56eoJ2coZ2doZ6eoZ+foqChop+go6GhpaKjpqOkpqWlpaSjpqSjqKemqaiopaOkpaOipqOj
        qaemq6eoqqenqainqaenq6eoq6mprKmqrqysrqysrKmqrqurr6urrqqqrqursK6tsa6ur6yssK2tsK2t
        q6moq6iosK+vrKmprqqps7GwtLGxs6+wsa6vsq+vs7CvtLKxtbKytrKyuLKzuLS0uba2ube3ubi3u7i4
        vLi5u7m5u7m4vbq5vru6vby7vbq6vbq6vry8vLu6ubi3u7e3vrq6vru6vrq6v7u8wL69wr++wr69wby8
        tbK4ExNvAABmAABnAABnAABnAABoAABoAABpAABpAABpAABqAABqZmSZxMHBnpubhoOD////////////
        ////////////////////////////////////////////////////////////////////////////1NHR
        ysfHyMPEraqqxcLCzszN0tHR0tDQ09HR1NLS1dLS1tPT1NLS0c7O09DQ1dPT1dLT1dLT1dPS19TT19TV
        19XV2tbW3NjZ2NXVz8zPPTyUAAB8AAB8AAB9AAB9AAB9AAB9AAB+AAB+AAB+AAB+AAB/AAB/AAB/AAB/
        ////////////////////////////////7uzs7uzs////////////////////////////AACDAACDAACD
        AACDAACDAACDAACDAACD////////////////////////////////////////////////////////////
        ////////////////////////////////////AAB9AAB9AAB8AAB8AAB8AAB7AAB7////////////////
        ////////////////////////////////////////////////////////AAB1AAB1AAB1AAB0AAB0AAB0
        lJK84N7f3tvc3Nrb393e3tzc3dvczcvUpKK+aGeiS0qVAABwCgl0AABvAABvAABuAABuAABtAABtAABt
        AABsAABsAABsAABrAABrAABqAABp////////////////////////////////////////////////////
        ////////4t/g2djZ1tPU1dPU1NLT1dPT1dPU09LT0tHS0c/Q0M7O0M7O0c/O0c/P0c/Qz83NzcvLzcnK
        zMnKzczOzczNzMvLzMrMzMrMzMvKzMvLy8rLzc3OzszMzcvLzs3NzMrMysnLzczNzMzMysjJyMbGysnI
        ysnKycjJysjJycjIyMXFyMXGycjJzMzLycjIxsTFxMPEw8LCxcPEw8HCxcPExcLDxMLCw8HCwr/Awb6/
        vry9v7y+wMDAv76+v7y8wb6/wL6/vbu8vbu8v729v729vbq7v72+vry8v769uLe4sbCwr6urraipr6qr
        raioq6inq6in////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////i4eHi4eHjIiHioaHioaGkIqHkoyJjYiGi4iHi4iJi4iIjYqKkIyM
        kI2NlI6NmI+KmY+ImI+MkY2Nj4uLkY2Mk4+Pk4+PkY6OkI6OkY6Oko+Pko+OlZKRlpOSlpOTlZKSk5GR
        lZOSmJaWmZeWm5iYm5iam5ianJqanZuam5iZm5mam5qbm5mZnZqbnpubnpqbn5ydoJ6foZ+fn52dnJmZ
        oZycoZ6eoZ+foZ+foZ6foJ6eoZ+foZ+fpKGhpaOhpKKgpqOjqKamp6WloqCgpKKiqKalqqamqKSlqaam
        qqioq6ipqqipqqamramoraqqrKqrq6ipraipr6qqrquqrqqqr6yrrqqpq6iorqussq+vs7Cwsq+wr6ys
        r6yssrCvtLGxtK+ws7Cws7GxtLGxs7CwtLGxtbKytbKzt7W0t7SztrOytrOzubW1ura3uLa2ure2vLi3
        u7i4u7i4vru6v7y7vry8vb28u7m5vbq5vru6vrq6vbm5vru7wL29wLy8wb69wr69wL6+UE+JAABmAABm
        AABmAABnAABnAABoAABoAABoAABpAABpAABqZWSXvru7paOihoODhoOD////////////////////////
        ////////////////////////////////////////////////////////1NHR1NHRysfHyMPExsPDzczM
        z87O09HR09HR0tHQ09HR0s/Q09HR0tDP0MzM1NDR1dLS1NDS1NLS1dLR1dLR1tPU1tTU1tTU19TU1tLR
        2tXUsa7HEBCDAAB8AAB8AAB8AAB9AAB9AAB9AAB9AAB+AAB+AAB+AAB+AAB/AAB/////////////////
        ////////////////////7uzs7uzs3NnZtbOz////////////////AACDAACDAACDAACDAACDAACDAACD
        AACD////////////////////////////////////////////////////////////////////////////
        ////////////////////////AAB9AAB9AAB8AAB8AAB8AAB8////////////////////////////////
        ////////////////////////////////////////AAB2AAB2AAB1AAB1AAB1AAB0fHqv5OPi3t3e19TU
        u7nHrqzEZWSjRkWUAABxCQl1AABxAABwAABwAABvAABvAABvAABuAABuAABuAABtAABtAABtAABsAABr
        AABr////////////////////////////////////////////////////////////////////3drc3drc
        1NHS1tPU1NLT09DR09HR09HT0M/Q0c/Q0M/Pz87Oz87O0M/P0dDQz83NzMnJzcnKy8fHzszNzs3NzMnK
        zcnLzcrMy8jJy8jIysjIysjIysjIy8jIysfHxsTFxcLEycfIycfHx8bHx8bHx8XFx8XFxcTFxsPFx8TE
        ycfGysjHyMfHycnIycbGx8LDxcLDw8HBw8HAwsDAw8LCw8HCwL6+wL+/wL+/vru8vLu8vru8v728wL69
        wLy8wLy8vbu8uri5u7i5v729wL+/v729wb6+wL+/urm6qKaoqaOjsa2sr6qqsq+vs7GxtLKxtLKx////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////ioaEioaEjYiFioeGiYeHi4iIjomGj4uGi4iGiIaGh4SEioiHjYqJjouLkYyMlY6LlY6K
        kIqKj4uLjomIkIuLk46Ok46PkI2Nko+OkY6NkY6OkY6Nko+OlJCQlpKSl5OTlZKRlpSTlpSTlpSTl5WV
        mZaXmZeXm5iZnJmZm5mZmJWWmZaWmpeWnJmYm5iYnJiZnZqbn52doJ6dnpqanJiYnpuboJ6eoJ2dop+f
        oqCgoJ6enpyboJ2dop6eo6CfoqCfop6epaGipqOjpaKipqOjp6WkqKWlqKWmqKSlqKSlqKWlqKWmqaan
        qqanrKmqrKurrKqqq6iprKmprKmorqqpr6yrrqurraqqrqussa2usa6usK6usa6usq+vsq+us7Cvs7Cw
        s6+wtLKytbKztLGytbKxtbOytbKytbKxtbKxtbGxtrKytbOztrOztrKztrKzt7OztrKzt7S0ure2u7i3
        uri4vLm6vbq6vbq6vru6vru7v7y8vru6vrq6vbq6v728wb++v7y8gH6fCAhpAABlAABmAABmAABnAABn
        AABnAABoAABoAABpAABpICB3wsC/u7m4raqqraqq////////////////////////////////////////
        ////////////////////////////////////////0M3N09HR0M7O0M3N0M3O0M7P0c7O0c7P0c7O0c/O
        0M7Nz8zM0M3N0c7O0s/P1NHR1NHR1NHS1dPT1dLS1NLS1dPT1dLS1dPS1dPS1dHR19LR19PSZWSlAAB8
        AAB8AAB8AAB8AAB9AAB9AAB9AAB9AAB+AAB+AAB+AAB+AAB/AAB+////////////////////////////
        ////7uzs7uzs3NnZtbOz09DQtLKy////////JiV+AACDAACDAACDAACDAACDAACDAACD////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////AAB9AAB9AAB9AAB9AAB8AAB8////////////////////////////////////////////////
        ////////////////////////AAB2AAB2AAB2AAB1AAB1AAB1WlmexcTUpaXFV1ebPDuNAQFzBQV1AABy
        AAByAABxAABxAABxAABwAABwAABwAABvAABvAABvAABuAABuAABtAABtAABs////////////////////
        ////////////////////////////////////////////////////////////3drc2dbX1dPT1NLT09HS
        09DR0tDP0c/Q0c7P0M/P0c7P0c/Q0M/Q0c/P0M7Oz83Oz8zNzsvLz8zMz8zMzsvLzsvLzcrLy8jKy8nJ
        y8jJzMfGy8jHycfHyMXFyMXFyMbGyMXGyMTFycbGycbGycbGysjIycbGxcHBx8PDy8bGysbFx8TCxsLC
        xsHBxsLCx8PDxcHAwr6+wr+/wb+/wL+/v7y8v7y9wcC/wL+/wL+/wcDAwb69wb6+vry7vru7v7y8vbq6
        u7m5u7m6vLu7vry8w8HBw8HBvr6+q6qrqKGhsa2ss7CwtbOytbKxtLKx////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////hoKD
        ioeGioeGiYaGh4eHhoOFj4qGk5GIjouHiIWFh4WFiIWFi4iHjIiIjYmKjoqKjouLjoqKjoqJjomIjoqJ
        kIyMj4uLkI2Nk4+Ok5CPko+QkY+PkI2NkY2Nko+Ok5CPk5CQlJGRlpKTl5SVl5SVlZOTlZOSmJWVmpeX
        mZeWmZeXmJWVmpaWmpiYm5mZmpiYm5mYm5mYnJmZm5iYm5iXm5iYnJmZoJ2coZ6foJ6fnZubnZqaoJyc
        oJ2dop+goZ+fn5ycop6epKGhpaKjpqOjpqOkp6Wmp6Wlp6Wkp6OipqKhpqOjqKanqaaoqqeoraqqrKqq
        q6ipqqiprKqqrKqqrKmqrKmrrausr6ysr6ysr62tsa6tsa6usK6tsq6tsq+usq+vsq6vtLGxtbKys7Gx
        trOztrOztrKxtLGxtrOztrSztrSztrS0trSztrOztLGytLGytLKytrS0t7S0trO0uLW1uLa2ure3u7e4
        vLm6vbu7vLu7vLq6vbm5v7y7vry7vry7vru7sKy1CAdoAABlAABlAABmAABmAABmAABnAABnAABoAABo
        AABoAABpenmfw8DApaKipaKi////////////////////////////////////////////////////////
        ////////////////////ysfH0M3N0tDPzsvLzMrKz83Nz83Oz8zMz8zM0MzM0M3Mz8zLz8vL0M3N0c7O
        0s/O0tHQ09HR09LR1NLS09DR09HR1NLS09HR09HQ09DR0tDQ09HQ1tPSu7nIDAyAAAB7AAB8AAB8AAB8
        AAB8AAB9AAB9AAB9AAB9AAB+AAB+AAB+AAB+AAB+////////////////////////////////7uzs6Obm
        5uPk09DQtLKy09HRxsTFJiV+AACCAACDAACDAACDAACDAACDAACD////////////////////////////
        ////////////////////////////////////////////////////////////////////////AAB9AAB9
        AAB9AAB9AAB9AAB8AAB8////////////////////////////////////////////////////////////
        ////////AAB3AAB3AAB2AAB2AAB2AAB1FRV/OzqSBgZ3AAB0AAB0AABzAABzAABzAAByAAByAAByAABx
        AABxAABxAABwAABwAABvAABvAABvAABuAABt////////////////////////////////////////////
        ////////////////////////////////////////////397d397d19XV1NLS1tTV1dPU09HQ0c/P0tDQ
        0tDQ09DQ0tHR09HR0s7P0M7O0tHR0c/Qz83Oz83Nz87Nz87NzszNzcvLy8rKzMrLzcvMzcnIzMnIysnI
        yMfHycjIysnJysjIycbHzMbFzsjEzMnHzcvLzMfHx8PDx8XFyMTExsHCx8PDx8HBxcHBxsXEyMbFxsPC
        w7/Awb/AwL29wL6+wb/Awb6/wsDAxMLCwcDAwL/Aw8HBw8DAv729v729wL2+vby7vby7u7i4uba2vbu7
        w8LCw8LCxMXFube4raOjsaemtbKws7CwtbCvtbCv////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////hoKDhoKDh4SEh4WFh4aGhYOE
        hIGBi4aCjoqGiIaGiIWFhoSEiYaFioiHi4iIjYmJjouKjYiIjYmIjImIjIiIjoqKjYqKjYmJjoqKkY2N
        kY6NkY6OkI2NkIyMkY2MkY6Nko6OkI2Nj4yMko6PlpOTlZOUlZOUlJKSlZOTlpOUlpOTlpSUl5WWmJWW
        mpiYmpmZmZiYmJaWmZaWmJWWmZWWm5iYmZWWmZaWnpuboJ2dnJmanZqZnZqanZqbnJqaoZ6eo6CgoZ6f
        oJ6eoZ+foZ6fo6GhpaKipKKipaKjpqOjp6OjpqOipqSkp6SlqaanqKenqqenq6eoqqanq6iprKqrq6qr
        qqipq6mprampraqqrKqrrqyssa6tsK2tr6yrr6ursK2tr6ytsK2tsq6usrCvsa6vsq+wsq6us7CvtrOz
        t7O0trOztbOzt7SzuLW0t7S0trS0trO0t7S0trOztrKztrKzt7W1t7S0trOzubW2ure4uri5u7m5vbu6
        vry8v728vbu6vLq6v728v7y8Pz6AAABkAABlAABlAABlAABmAABmAABnAABnAABnAABoBARqjYuoura3
        paKi////////////////////////////////////////////////////////////////////////////
        ysfHysfHycbG0c7OzcvLy8jIzMrJzsvLzcrKzsvLz8zM0MvM0MzM0M3N0M3O0c7P0c/O0dDQ0s/Q0M3O
        0c7O0c7Q0c/P09HR09HR0s/P08/Q09HR09HR1NHS1NHScG+pAAB7AAB7AAB8AAB8AAB8AAB8AAB9AAB9
        AAB9AAB9AAB+AAB+AAB+AAB+////////////////////////////////////6Obm4N3d2dXV1dLS09HR
        xsTFV1aZAACCAACCAACCAACDAACDAACDAACD////////////////////////////////////////////
        ////////////////////////////////////////////////////////AAB+AAB+AAB+AAB9AAB9AAB9
        AAB9////////////////////////////////////////////////////////////////////AABlAAB3
        AAB3AAB2AAB2AAB2AAB1AAB1AAB1AAB0AAB0AAB0AABzAABzAABzAAByAAByAAByAABxAABxAABxAABw
        AABwAABvAABv////////////////////////////////////////////////////////////////////
        ////////////////////////////////397d29ra1tTU1dLT1NHT1NLS09HR09LS09HR0tDP1NLS1dPU
        0tDQ0M7P0tDQ0tDQ0M7P0M/P0M7Pz83OzczNzcvMzcvMzszNzszNzcvLzszLzszMzMrLzMrKy8rKzcvM
        y8nKycbGy8jGy8nHzMnJy8fIyMbHx8fHxcTFxsPFx8XGyMfGyMbGx8bGxsXExsXFxsTFxMLDw8HCw8HB
        w8HBwsDBw8DCxMLDw8LDwL6/vr6+wL+/w8DBw8DBwL6+vrq7v729vry8vLm5v72+xMPCwb/Awr++vLe1
        tquotqmmta6ts66tta6uta6u////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////g4KCg4KCg4CBhIKChoSEhoKDhIKBhIKBhIGAg4CA
        hYKChoODhoSDiYWFiYaGi4iIjImIjIiHioeHioeHioeHjImJjImJi4iIjYqJjYuLj4uLj4uMj4yMj4yL
        j4yMj4yMkY6OkY2NjYqKjouLko+Oko+Qk5CQlZGRlZKSlZKTk5CQlJGRlZOTlpSUlpSUmZeXmZaXmZaW
        l5aVl5WWmJSUmJaWmJWVmJOUmpeXnJmZnJiYnpuaoJ6dnZubnpybnpyboJ2doZ6foZ+foZ6foJ2eop+f
        oqCfoZ6fo5+ho6Chop+fpKKip6alqKamqKamp6Wlp6WlqKenqqioqqipq6mqqqipqaenq6inrKmpq6ep
        q6ipq6mqraqrrqqqr6qpr6urrqurr6ussKussKysrqyssK2srqysr6yssa+vs7Cws7Cxs7CxtbKytbOy
        tbKytbKyt7OytrOztrOzuLS1t7S0t7S0t7S0t7S0uLW1ubW1ube3ube3ura2ure3vLq5vbu7vbq7u7i5
        u7m5vLm5jYujAABkAABkAABkAABlAABlAABmAABmBQRoAABnHx91TEuKu7i7s7Cwi4iIi4iI////////
        ////////////////////////////////////////////////////////////////zszMzszMyMXFy8jJ
        zMrKy8fIy8jIzcrJzcnJzcnKz8vMzszMzs3MzszMz83M0M/O0c/Pz83Oz8zMzsvLzsvL0M7O0c/P0tDQ
        0s/Q0c7P0c/P0tDQ09DQ0tDQ09DQy8nOHx+IAAB7AAB7AAB7AAB8AAB8AAB8AAB8AAB9AAB9AAB9AAB9
        AAB+AAB+AAB+////////////////////////////////3tvc3tvc29ra29rZ4N7d3draioi2CAeFAACC
        AACCAACCAACDAACDAQGD////////////////////////////////////////////////////////////
        ////////////////////////////////////////AAB+AAB+AAB+AAB+AAB9AAB9AAB9////////////
        ////////////////////////////////////////////////////AAB5AABlAAB3AAB3AAB3AAB3AAB2
        AAB2AAB2AAB1AAB1AAB1AAB0AAB0AAB0AABzAABzAABzAAByAAByAAByAABxAABwAABw////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////4eDg4eDg29ra19TV09DR1NLT09LS09HS1NLS0tDR09DR1NHR0tDQ09DR1NLS0tHR
        0tDQ0c/Pz87Oz87Ozs3Oz87Oz87Oz87P0M7O0M/O0M7O0tHRz87O0M7O09HR1dPU0dDQzMrLy8nLycfI
        ycfHysjJycfIyMXGxsTFxsXGyMbGx8XFyMbHyMbHxsPExcPDyMbHx8bHxcTFxsTExcLCxMLBxcPDxcPF
        w8HCwL6+vLq6vr29w8HCxMLDwsDAwL29wL6+v729wb6/wr/BxsTFwr/Aw729w7y6wLq3vbWyubOyt7Cw
        ta6u////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////gn5+hYODgoCBg4GBhIGBhYGBhIGBh4OCh4SDg4GBhIGBg4GBgoCAhICA
        h4ODiIWFiIWFiIWFiYaGioeHi4iIjYmIjYiIiYeHiomJjIqKjoqKj4uMjouLj42MjouLjYqKjIuLjo2N
        jouLj4uKkY2Mk46Nk46Ok4+QlJGSlZKSlZKSk46Pk4+Ok5CQlZKSl5SUmZaWlpSUlZKTl5SUmpaWmJKS
        l5KRmJaVmJeXmJSUmpaVm5iYnZuanZuanZycm5qanZuboZ6foJ2dn5ycnp2doJ6eop6fop+foqCgop+g
        o6ChpKKjp6WmpqSkpaOjpaOjp6WmqKanqaeoqKanqaenqqipqaeoqaenqqioqqeoqaanqqeoq6eor6mo
        saqpr6qpraqqr6urtK6tsq6tsK6usK6urqysrqyrsK2tsK2tr6ysr6yssa2usq+usq+vs7CwtLCwtLKx
        trOzt7S0tbOztbKytrOztrO0t7W1t7S0uLW1uLS0tbGxtrOyt7W1uba3uLa2t7S0uba2uLa2rqywGxtv
        AABjAABkBQVmAABlGRlwMzJ8V1aNfXuelJGou7i6wb29t7S0npubhYOC////////////////////////
        ////////////////////////////////////////////////0M3NzMnJxsLCx8TEy8jIzMjIysfHysfI
        y8jIzMnJzcvLzszNzczLzcvLzszMz8zN0M3Nz8zLzcrKzMnJzcrJz8zM0tDP0dDP0c7O0s7P0c/P0s/P
        0s/Q0s/Q0c7O0M3NhoWwAAB6AAB7AAB7AAB7AAB8AAB8AAB8AAB8AAB9AAB9AAB9AAB9AAB+AAB9////
        ////////////////////////////////3tvc3tzc2dbW2tfX2tfXubjMDAuGAACCAACCAACCAACCAACC
        AQGDX16jrqyt////////////////////////////////////////////////////////////////////
        ////////////////////////////AAB+AAB+AAB+AAB+AAB+AAB+////////////////////////////
        ////////////////////AAB6AAB6AAB6AAB5AAB5AAB4AAB4AAB4AAB3AAB3AAB3AAB2AAB2AAB2AAB1
        AAB1AAB1AAB0AAB0AAB0AABzAABzAABzAAByAAByAABx////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////4eDg393d2dfX1dTT1tPU1NHS1NLS1tTV1dTU09HR09DR1NHS1NHS1NHR0tDR0tDQ0tDP0M3NzszN
        z87O0dDP0dDR0dDQ0c/P0c/OysjJyMbHz87O0M7O09HR1dPU0dDQ1tXV09HSz8zNzMrKy8rKzMnJzMnI
        ysfHycnIysnJysfIysfJycjIx8bFx8TFx8TFx8bGx8XGxsPExsPDxcPDxcTEw8HCw8DBwb++vLu6vbu7
        wL29wsDBw8HCwr+/wb6+wb6+w7+/w76+xsTExsTEx8TEyMPDxL69vrm4urS1ubKyubKy////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////gn5+gn5+hIGAhYODhIKDg4CBgn+AhYGAiYOBh4SCgYCBhIODhIKCg4CAhIGAhoSEhYODhIGBhoKD
        iYWFioeGiYaGi4iHi4eHioeHioaHioeHjImKjImJjYqKjYqLj4yMjoyMkIyKkouJkIqJjYqKj4uKk4uI
        lo2LmI+Nlo6Mko+OkpCRk5CQkY6Oko+PkY6Ok4+QlZKSlZOTk5CRlpOTmZaVmZWVlpGRmJaWmJiXl5SU
        mJSUmZaVm5mZnJucnpyenZqbn5ydoJ6eoJycn5ydn56goJ6eoqCgoqCgo6GhpaOkpKOkpKOjpaOjpqKj
        pqKipqOjpaOjp6SlqKanp6Slp6SkqKanqKanp6Wmp6Wlqaamq6ioqKanq6alsq2rs7Gtr6uprKioramp
        rqqqrqyrsK6vsa+vr6ysr6urr6yssa2ur6ysrqurrqqrr6yrsK6tsa+usa6usq+vtbKytLGxsa6vsK6u
        srCwtLCxsrCws7GxtrKzt7OytbKxtbKytbKzs7Cxs7CxtbKyuLW1trOztbKxZmSQBARlSUiEWlmNiYih
        joyju7i4s7C0vLi4vbq6vbq6vbq6vrm6sKyshYOChYOC////////////////////////////////////
        ////////////////////////////0M3N0M3Ny8jIycbGyMTGycbGy8fHysbHysfHzMnIy8jIycfHy8rK
        zcvLzsrKzcnKzMrKzsvKzcvKy8jIzMnJzcvLz8zM0M7O0M3Nz8zM0c7O0M7Oz8zM0M3N0s/P0c7Oz83M
        zcrLJiaJAAB6AAB7AAB7AAB7AAB7AAB8AAB8AAB8AAB8AAB9AAB9AAB9AAB9AAB9////////////////
        ////////////////////3tzc3NnZ2dXW29jYwsHQHByMAACBAACCAACCAACCAACCAACCX16jrqyt1NDQ
        ycbFsK2t////////////////////////////////////////////////////////////////////////
        ////////////AAB/AAB/AAB+AAB+AAB+AAB+////////////////////////////AAB8AAB8AAB7AAB7
        AAB7AAB6AAB6AAB6AAB5AAB5AAB5AAB4AAB4AAB4AAB3AAB3AAB3AAB3AAB2AAB2AAB2AAB1AAB1AAB1
        AAB0AAB0AAB0AABz////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////4uDg4uDg29na
        19XW2NXW1dTU19bW2NfW2NbX2NbX2NbW1tTT1dLT1NLS1NLS1NLS0tDQ0c7O0c/P0s/Q0s/Q0tLR0tHQ
        0dDQz87Pu7u7yMbH////////////////////1tXV09HSz8zN09LT0M/PzsvKzMnJzMnJy8rKzMrKysjJ
        y8jJy8nJycjIysjJysnIycfHycbHysjIyMjHx8XFx8XFxsPDwsDBwsHAv7y8wLy9wL6+wL+/wsHCw8HB
        wsDAwsDBxsXExsPBw8HAyMXGysjIyMTFxsLCwr7Avrm6urW1urW1////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////f3x8f3x8fnx8
        gH5+g39/g35+gX1+g4B/hoSCg4GBgoCAg4GBgoCAgn9/hIGBhoSEhYKChICAhYKBiYWFiYSDiISDh4SE
        iIaFjoaEkIaEiYaFiYiIiYaGi4iIjImJi4iJjIqKlIqHl4qFj4mIjIqKjYmKkYiHmIuFmo6Ilo2KkI2N
        kpCRlJKRk5GRkpCQkY6OkI2Nko+QlJKSlZOSlJGRlpOTmJSUl5SUlZOTlpOTl5SUmJWWmJaVmpeYm5ma
        nZqcn5ycnpubnZubn5ycoJ6fnpydn5ydnp2dn56eoqCho6GioJ6foJ6eo6GhpaGhp6KhpaKhpqOjpqOj
        pqKkpqKjqKSlqKamqKWmpqOlpKGip6Ojq6inqaenqaSjsKypsK+srKqpqqanrKmoq6ioq6iorKqprquq
        r6urr6ursayssKysr6ysrqursKyssK2ssa+usK6tsa2tsq6us7Cwsq+vsa6usq+vsrCwsq+vsK2tsa+v
        s7Cws6+vtrOyt7S1tbKzsrCws7CwtbO0t7S0ubW0uba2uLW2kY+jtrS1ure3ure4ubW2t7S0uba1ure2
        u7i4vLm5vLq5v7u7trKzoJ6eoJ6e////////////////////////////////////////////////////
        ////////////ysbGysbGycbFycfIycbHx8TFyMXFycbGy8nIy8nJysjIyMXFycfGzMnJzsnKy8nJysfH
        zMjJzcrKy8jIzMnJzsvLzszMz8zNz8vMz83N0M3NzcvLzMrKz8zM0MzM0MzM0c7N0c7OkZC0AAB6AAB6
        AAB6AAB7AAB7AAB7AAB8AAB8AAB8AAB8AAB9AAB9AAB9AAB9AAB9////////////////////////////
        ////////3NnZ3NrZ29nY1tXZSEifAACBAACBAACBAACCAACCAQGCRUWe19TU1NDQycbFsK2t1dPTyMXF
        rqyr////////////////////////////////////////////////////////////////////////AAB/
        AAB/AAB/AAB/AAB+AAB+AAB+////////////////////AAB8AAB8AAB8AAB7AAB7AAB7AAB7AAB6AAB6
        AAB6AAB5AAB5AAB5AAB5AAB4AAB4AAB4AAB3AAB3AAB3AAB2AAB2AAB2AAB1AAB1AAB0AAB0AAB0////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////4uDg3drb19bW19fX2NbW2dfX
        2tfX2NbW2tnZ19XU0cvK0s3O1tbW1tXU1dPU1NHS09HR09LT1dLU1NLS09HR09LSzs3Oz83PwcDBwcDB
        ////////////////////////////////09LT09DQzMnLycfIy8nJy8rKysnJycfHysjIysjIycfHysnJ
        zcvLzMrKysjHysjIysjHycfGycfHx8XGxMHDw8DBxMHAwr6/w7+/w8C/wb6+v72+wL2+w8HBxcPCwsHB
        w8DByMXGy8nJyMbHxMHBxMDAxcLCurW1////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////enZ3fHl6enh4end3f3t6gn17fnp5
        gH59g4GCgYCBgX59gX5+gH59gX9+gn9/hICAhYGBhoODh4WEh4SFiIODhoKBh4WFh4SFjIWCjYSBioWF
        iYeIiYaGioeHiYeHh4WEh4WFjoeFkIiFjYqKjYqLjYuLjomJlIqFlYyHko2Nj4yNko+PlJOSk5GRkY+P
        kI2Nj42NkY6PlpGSlpOSlJKSk5CQlpCQl5STlZOTlJCRl5OUlpSVl5SVmpaWmpiXm5mZnJqam5iYm5eY
        nZqanpubnZubnZqanpybnpycnpydm5iZm5eXnZqaoJ6eoZ6eo56epKCfpKCgo5+go56fp6GgqKOipqOk
        pKGhpqGhpqOjp6SjqKWkqKSlp6OkqKSkqaSkqKOjqqalq6inq6inqKWlp6WkqKSkqqalq6inrqqqrqqq
        rKmorqqqr6uqr6yrsK2trqyrrquqr62ssK2tsq6us6+vtLCvsq+vsrCvs7Gws7Cwsq+vsa6vs7CwtrS0
        tbOytrSztbOztbKztrOzuba2uba2t7S1t7S0tLKytrOzure2uLSztbGxuLa1u7m4u7i4vLm5v7u6wL29
        vLq6rqurnZmY////////////////////////////////////////////////////////////////zMnI
        x8PDx8LDxsTExcTDxsTDyMTEycjHycjHycfHysjIyMbGx8TEycbGzMrJysjHyMTEy8fHzcnJzcrJzsrL
        zcrLy8nJzcvLz83Nz83NzszLzMrKzcvLz8zMzcrKzcrK0M3M0c3Oz8zNNTWOAAB6AAB6AAB6AAB7AAB7
        AAB7AAB7AAB8AAB8AAB8AAB8AAB9AAB9AAB9////////////////////////////////////39zc39zc
        2NbV2dfXeXiyAACBAACBAACBAACBAACCAACCLy+V1NLX4N3c3dnZ2dbW1dPTyMXFrqyr1NHRx8PFrqus
        ////////////////////////////////////////////////////////////AAB/AAB/AAB/AAB/AAB/
        AAB+AAB+////////////////////AAB8AAB8AAB8AAB8AAB8AAB7AAB7AAB7AAB6AAB6AAB6AAB6AAB5
        AAB5AAB5AAB4AAB4AAB4AAB3AAB3AAB3AAB3AAB2AAB1AAB1////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////4uDf4uDf3Nra29ra29jZ2tfY29jZ2dbX19fW1dPS
        1M7O19TT2tnZ2NfX1dPT1dTU1dXV1dXW19XW1tTU09HS0dDRxMLCuba3wcDB////////////////////
        ////////////////1dHS1dHSzcvMy8jJzMnKzMrKysjIysjIy8rJy8nJycfHysjHzMnKy8nJysjIycfH
        ysfHycfIx8bGxsTFxcTFxcLDx8XFx8bGxsPExsHBxb+9wby7v7y8xcPDw8DBwL2+x8PDysfIy8nKxcTF
        wr6/x8LCyMbFyMbF////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////enZ3enZ3e3h5end3e3h4e3l5fHl4e3l4fnt7gH1+f319f3x8
        f318gH59gH19gX5+g3+AhYKChYSDhYODhoSEh4OEiISDiIWFh4SFh4ODiYSEiISEiIWFiISFiYaGiYeG
        h4aEhoSEh4WFiIaHi4iJjYqLjIqJjYqKjomJj4uLjYuMjouLkIyMkI6Oj4yNjouMkI2NkY6Oko+Pk5CQ
        lJGRk5GRkpCQko6NlZGRlZOSlpSTlpOTlZKTlZKTmJWVmZaVmJaWmJaWm5iYm5iYmZaWm5iYnZqanZub
        npubnpucmpiYmpaWnJeXnZqanpubnpuboJyaop6doZ2dn5ydo5+epaCdo5+dop+go6CgpqCeqqOgpqKh
        o6CgpqKip6Slp6KiqJ+eqqCfqaSjqaWlqKOjp6SjpaKip6Ojp6KjqKSkqaanqqeoq6inrKenraiorKmp
        raqqrKiprKmprKqprquqr6ussK2ssa6tsa6utLGws7Cwsa6usa6usrCvsa6usq+vtbOytrSztrS0tbKy
        tbOytLKxs7CvtbKzt7S0t7SztrKyuLSztrOytbGxt7S0uLa2u7i4vLm5vru6v7y8wL29t7S0nZmYgn9/
        ////////////////////////////////////////////////////////zMnIzMnIyMXFxsLCxMLCw8HA
        xcPDyMTFxsPEx8TEyMbGyMbGxsPDxsLDyMbFyMbFx8PExsPDycbGysfHzMnJzMrKy8rJycfGy8jIzszM
        z8zMzMrKzMnJzcrKzcvLzcrLzsvLzsvLzsrLz8zMqqm+Cgp9AAB6AAB6AAB6AAB6AAB7AAB7AAB7AAB8
        AAB8AAB8AAB8AAB9AAB9AAB9////////////////////////////////////39zc2dXV1tLToqDAAQGA
        AACBAACBAACBAACBAACBAQGCwb/O29nZ3NnZ39zc4eDg39zc2tfW1NHRx8PFrqus1tTUxMLBp6Sk////
        ////////////////////////////////////////////AACAAACAAAB/AAB/AAB/AAB/AAB/////////
        ////////////AAB8AAB8AAB9AAB8AAB8AAB8AAB7AAB7AAB7AAB7AAB6AAB6AAB6AAB5AAB5AAB5AAB5
        AAB4AAB4AAB4AAB3AAB3AAB2////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////4uDf4t/g3drb29nY3NnZ2dbX2NbW2NfW2dfX3Nvb3tzc29jZ19XW
        1dPT1dTT1tXV19XW1tTU1dPT09LT1tTVw8DBuba3////////////////////////////////////////
        19TU19TUzs3NzszMzsvMzcvMy8jJzMnKzMvLzMvLy8nJy8nKy8nKycfIycjIysjIycfIyMbIx8XGx8XG
        x8bHx8fHyMfIy8rKycjJyMTEycTCyMLAxcHAxsPExsPExsHAysbEysjJyMXFw8DBxsLDycbGx8TEx8TE
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////dXFydXFyeXZ2end3e3h4end3end3fHp6fnt7fXp6fXp5fnt7fnt8fnt7f3x8gH19
        gn9/goCAgoCBhIGBhYKChYKDhoKChoKBhYKBiIWFh4SFhoODhYKChoODhoOEiIWFh4WFiIaGioeHioeH
        ioeIi4iIi4mHi4iIi4iKi4iJi4iHi4iIjYuLjYmJjIiKjouMkI6PkY+OkI2MkI2Nko+Pk5CQkZCPkY+P
        k4+QlZKRlpSTlZSUkpCRlJGRlpSTmJaXlJKTlZGRmZaWmpeXmJWVmpiYnJmZm5iYm5iZm5iYmpeXmpeX
        nJmZnJman5uboZybpZ+bpZ+co56dop6do6Ceop+en5yboZ6eo6Cgpp+eqJ6cpZ6doJ2eo6CgpqKiqqOi
        raOgq6KgqKKip6KiqKOkqKWkqKWkp6SjqaSlqqanqaamqaamq6ioq6inrKmpraqqrKmoramqramqrKqp
        rKmpraqqraqqraqqr6yssq+vsKysrKioraqqr6ysr6ysr62tsa+vsrCvs7GxtbOzsq+vr6yrsK2stLGx
        trOzuLW0trSztbKyuLW1uLa2trOztbKyuLW1u7e3ure3u7m5vru8vLm5rquqgn9/gn9/////////////
        ////////////////////////////////////////ysfIysfIx8PDxcPDxMLCxcLCxcLDxcLCwr29w8DA
        x8bFxsLCxMHBxcLCxsXExMHBxMDBx8TFx8XFx8TDycbGycfHysjIy8jIy8jIzcrKzsvLzMnKysfHysfH
        zMnJzcrKzsvMz8zMzcvLzsvLz8zMWlmeAAB5AAB5AAB6AAB6AAB6AAB7AAB7AAB7AAB7AAB8AAB8AAB8
        AAB8AAB9AAB9////////////////////////////////29jZ29jZ2NXWwL/NHx+MAACAAACBAACBAACB
        AACBCQmFmZe92tfY29jZ29jY3NnZ3dvb4N7d4t7e3Nna2dbX1tTUxMLBp6Sk0tDPwr+/qqam////////
        ////////////////////////////AACAAACAAACAAACAAAB/AAB/AAB/////////////////////////
        ////AAB9AAB9AAB8AAB8AAB8AAB8AAB7AAB7AAB7AAB6AAB6AAB6AAB6AAB5AAB5AAB5AAB1AAB4////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////4+Hi4+Hi3Nrb2NbW2tfX2NXW19XU2NXV29nZ3t3d29na19TV1tPU1tTU1tTU19TU1tPU
        09HR1tTU0c/Qz8zNw8DBuba3////////////////////////////////////////2dfX2dfX0c/QzcvL
        zszNz83PzcvMzcvMzMvLzMrKzcrMzcvMzMrLycfJysjIy8rJycjIycbHysfIyMfHycjJy8rLysfIysfI
        ysjJyMXEycTDysfGycbEx8TDycXFy8fGy8jIysjJxcLCxcLCysfIyMXHx8TE////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        hYSEcW5udHJxd3R0eXZ2eHV1eHV1e3h4fXx8fHl5e3h3fXp6fXp7fXp6f3x8f3x9f3t8gHx8gX5+hIGB
        g4CBg3+AgH5+gX59gn59hIKBhYODhYGBhYKCg4CAhIGBh4ODiISFh4WFiIaGiYWGioeHioeIi4iIioaH
        iYeHioeHiYaGioeHioiHi4mIjYmJjYyLjYuKjYqLjoqLkI2Mko+OkY6Oko+QkY+Qko+Qk5CQlZGSlJOT
        k5GRko6OlJGRl5WVlpWVk5GRlJGRlZGSlpOTmZeXmpiYmpeXmpeXmpaWmZaVmpeXm5iZnZqanpqbo5+d
        pqGepqCdpaCco6Ccop6co52cop2cn5yboZ6doZ2eo52dpJ6dop6eoZ6epaGgpqGgqKGgp6OipqKipqOj
        qKWkqKalp6WkqKWkqaWlqaWmqKSkqaemq6ioq6moq6mpq6ipq6ioraqprqurramqrKmprKmqrqqrrqqr
        r6ysrqurraqpq6ioq6mprKiorampr6ysraurraursK2ts7Cws7CwsrCvsrCvsrCvtLGwtbKytrOztrS0
        uLe3urm5uLa2tbKytLGxuLS0ube2t7S0uLW1u7m5s7KymZeXmZeX////////////////////////////
        ////////////////////////z8vLxsTExMDBxMLBxMHBw8DBw8HBw8DAwb28wb29xMLCw8DAxcHCxcLC
        w8DAwb6+wr/AxsTExsPDxcLCx8TEycbGysfIzMjKzMrKzMvLzcvKzMnJysfHyMXFycbGysjHzMrJzsvL
        z8zLzsvMzsvLr6y/CQl9AAB5AAB5AAB6AAB6AAB6AAB6AAB7AAB7AAB7AAB8AAB8AAB8AAB8AAB8////
        ////////////////////////////4N/f4N/f3tzd1dPTOTmVAACAAACAAACAAACBAACBAQGBcnGt2NbW
        2dbW2tfX29nZ3Nra3Nna3dnZ2tnY3dvb4d7f3Nnb1tXU0tDPwr+/qqam0tDQwb/Aqaeo////////////
        ////////////AACAAACAAACAAACAAACAAAB/AAB/////////////////////////////////AAB9AAB9
        AAB8AAB8AAB8AAB8AAB7AAB7AAB7AAB7AAB6AAB6AAB6AAB5AAB5AAB1////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        4+Hi4eDg2dfX19XV2tjY29jZ1tPT2NXW3tzd3Nva2NfW2NbW2NbW2NXV19XV1dLT1NLT1dTUx8XGz8zN
        ////////////////////////////////////////////////////2dfX0c/Qz8zN0M3Oz83Oz83Ozs3N
        zcvLzMrKzcvMzszMzcvLy8nKzMnKzMvLysjIysfIy8jJysnIysrKy8nKycfIycjIysfIysTFycTDx8bF
        yMbFycbFysjIx8bHzMvMzMnKycXFxsLCx8TEx8PEx8PE////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////hYSEhYSEenl5dXJxd3R0
        d3V1d3R0d3R0end3fHp6e3l5eXZ2fHl5fnx8f3x8fnx8fXt7fnt6f3p7gHx8gH19gH19gHx8f318gH18
        gH19gH59gn9/hoKChYKChIGBhIGBh4ODh4SFhoSEhYODhoOEh4SDh4WFiIWGiIWFiYaGioiHioeIioeI
        i4mJjImJjImJjImIjYqJjYqKjouLkIyMkI2NkIyMkI2Oko6PkY+PkY6PkY6PlJKSlJGRko6Oko+OlZOT
        l5aWkpCQj4yMk5CQl5WVmZaWmZeXl5SVmJWVm5aWmpWVmZWVmZeWmZaWnJman5ycop6eoZuaoZyZoZ+d
        oZ6dop6doJ6dnpuan5qboJ2do5+eqKKepZ6coJycoJ6eoZ6doJ6eo6CfpKGgpaGhpqOipqOjp6Ojp6Ok
        qKWlp6Skp6SkpqOjp6SkqKWlqKamqaanqqemqqenq6inq6inrKiorampraqprqurrqurrqqqrqurr62t
        rqurrKmprKmpraqpraqqraurr6ussKyssq+vs7CwsrCvsa6usa2ts6+vtLGxtbKytbOyt7a2uLe3t7O0
        tbGxt7Ozure2uLWztbKxuba2u7m5oqCgpaOk////////////////////////////////////////////
        ////z8vLz8vLyMTExMHBwr+/wb6+wb6/wr+/wb29wL69wb+/wb+/wr+/xcHCxcLCwb69vLi4wL6+xMPC
        xcLCxMLCxcLCx8XEycfHycfIycXGycbGycbGyMbGycfHycbGx8TEyMbGy8nJzMnKzMnKzMrKzcvMzMnK
        c3GlAQF4AAB5AAB5AAB5AAB6AAB6AAB6AAB7AAB7AAB7AAB7AAB8AAB8AAB8AAB8////////////////
        ////////////////4N/f4d/f2NXVf3yvAACAAACAAACAAACAAACBAACBQUCZ0tHT2NfX2tbX2tfX2tjX
        2tfX2tfX2dbW29nY3drb3Nja3drb3tzb2tfW19TU0tDQwb/Aqaeo0dDQvb29pKGi////////////Cwpu
        AACBAACAAACAAACAAACAAACA////////////////////////////////////AAB9AAB9AAB9AAB8AAB8
        AAB8AAB2AAB7AAB7AAB7AAB6AAB6AAB6AAB6AAB6////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////5uPj5uPj3tvb29nZ
        3dva3dzc29ja29jZ3tzc3tzb2dfX19XV19XV19TU19TU19PU2NbX1NLStbO0tbO0////////////////
        ////////////////////////////////19XV19XV0tDR0s/Q0c/P0c/P0M7O0M7Oz87OzczMzsvLz8zM
        zcvMzMvLzszMzszMzMrLy8nKysfIy8jJy8rKysjJycfIysjIy8jJy8fIyMbHyMbHyMfHysfJycfIx8bH
        zcvMzszMx8LCw7y7xr++x8LCx8LC////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////lJOTlJOTlJOTjoyNhIKCfHl4d3RzeXd3eHV2
        eXZ2e3l5fHp7e3l5fXp6fXp6fnx8f35+fnx8fnt7f3t8f319fnx8fXt6fXl5fnt7gH18gX5+gX5+g4CB
        hIGBg4GBg4CBhIGBhoSEhYODhIGBhIGBhYKChYKCh4SEh4SEh4SEiYaGi4iJjImKjImKi4iIiYaFi4eH
        jImJjIqKi4mJjoqLj4uNj4yMkI2NkI2Mj4yNj42Oko+Pk5GRlJGSk5CQlJGRlZKTlZOSj42Mj4uLk5CQ
        lpSTl5SVl5SVlpSUlpOTmJWUmpaWl5SUk5CQlpOTmpiYnZmYn5iXnpmYnJiYnZqanpqboJycoZ+eoZ6e
        oZ6doJ6dop6cpJ6co56boJyan5ycoJydop+fop+foZ6dn5ucop6epaKhpqOjpqOkp6Skp6alpqSkpaGi
        o6CgpKGhpKCgpaKipqOip6Sjqaalqqinq6enq6enramorKioq6inq6moraurrKmprKqpraqqrKqqrKmp
        rauqr6yrrquqsK2tsa6usa6usa6usa6us6+vsa6ur6ysr62ssa6us7Gxt7a2uLS0uLSzuLW1uba2ure3
        t7S0tbGyvLi5uLa2paOkpaOk////////////////////////////////////////////////z8vLx8TD
        xMDAwr+/wr6+v7u7v7u7v7y8wsDAw8HAwb69w7/Aw8HBxMHBxMDAwr69wb6+w8HBw8HBw8DBwr+/xMHB
        yMbFyMfGyMfGycXFyMTEx8TEycbGysfHycfHycbGy8jIzcnJzMjJzMnJy8rJzMnJy8nJLi6KAAB4AAB5
        AAB5AAB5AAB6AAB6AAB6AAB6AAB7AAB7AAB7AAB8AAB8AAB8////////////////////////////////
        ////4d/f3drZrKrDCwuDAACAAACAAACAAACAAACAHx6NxMHM2dXW2NXV2dbV2tfX2tfX2dbW2dXV29jY
        3dvc3drb29na2dfX2tfW3dvb4eDh3dzd2NXW0dDQvb29pKGi0tDQt7OzkY6XCwpuAACBAACBAACBAACA
        AACAAACAAACA////////////////////////////////////AAB9AAB9AAB9AAB8AAB8AAB2////AAB7
        AAB7AAB7AAB7AAB6AAB6AAB6////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////5uPj5eLi4d/f3dzb29nZ3Nra3Nrb
        393e4N7e2tbX2NXV2NXV2NTT29bW2tjY2dfW0c7OtbO0////////////////////////////////////
        ////////////////3Nrb3Nrb1dLT09DR0tDQ0dDQ0M/P0M/O0M7OzszNz8zMz8zMzMvLzcvLzMvLy8jJ
        y8jJysnJysjJy8jJzMrKy8nKy8jJysfIysjIy8jJy8jIysfIycfHyMfHysfHzMrKz87OzMrKwru6wbe2
        yL68x8LC////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////lJSUlJSUlJOTlJSUlpWWlZSVjoyMhYODe3p6d3V0fHl5fHt7e3l6
        end3e3d3fHl4fXp6fXp6fXt7f3x8gH5+gH9+fXt6fHl5e3l4fnx7gH19gH5+gX9/gn5+gX5+f3x8gH1+
        gn9/gn9/g4B/hoODiIWFh4WEhoSDh4SEhoOEh4SEh4SEioaHi4iIiIaFh4WFiYaHiYeHiIWFioeGjIqK
        joyMjoyMj4uLkI2NjouMjYmKjouKkI6NkpCQkpCRkpCQlZGRkY6OjouKkY2Nk5GRk5CQlZKSlpOTlZKS
        lZKTlpSUmZaWmJSVlJKSlpSTmpiXmZWVnJeWnpqZnJmZmpeXnZmYnZqanpybnpycoJ6dop+gop6doJua
        n5uan5yboJ2doZ6eop+fop+fop6doZ2doZ6do6Cgo6GhpKGhpaKjpqSkp6SlpaKipKGgpKCgpaGipaOi
        p6SkpqOipqOjp6SjqKWkqqanrKioq6enqaalqqinqqenqqenqqiorKqqrqurrqurraurrKipraqqr6ys
        raqqrampsa6usrCws7GxsK6urKmprqyrsKyssq+vtbKztrOytbKyt7W0uLa2uLa3t7W1qqanm5iZuLa2
        paOkpaOkpaOk////////////////////////////////////////////xsTExsTEw7+/wL29wL29v7u7
        wLy9w8HBxMPCwb++wb28wsC/wb+/wb6+w8DAxcLCwsDAwL69wL69wL29wb6+v729w8DAx8TEycfHycfH
        yMXFyMXEyMXFysfHy8fHycbGysfHysnIysfHysbGyMXFx8XFycfHjoyvAAB4AAB4AAB4AAB5AAB5AAB5
        AAB6AAB6AAB6AAB7AAB7AAB7AAB7AAB8AAB8////////////////////////////////29nZ29nZz83S
        MzOTAAB/AAB/AACAAACAAACADAyFrqvE1dLS19XV2tjX2tfX2NbW19XV2NTU29jZ3dzc29nY2NXV2dbX
        29jY2dbW19TU2tjY397e4N7f3dzb3Nvb0tDQt7OzkY6XFxZ/AACBAACBAACBAACBAACAAACAAACA////
        ////////////////////////////////////AAB9AAB9AAB9AAB9AAB9////AAB7AAB8AAB7AAB7AAB7
        AAB6AAB7////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////6Ofn6Ofn5eTj4N7d3dra3tvc393d3tzd3dvb2tjY2tjX
        2dfX2dXV2tfX2tjX2tbXy8nJy8nJ////////////////////////////////////////////////////
        ////3Nrb1tTU0tHR09LR09DR0M3P0c/P0tDQ0M7Pz83Nz83MzszLzMvLy8rKy8nJy8jIzMrKzMvLzMrK
        zMrKzMvKzcvLzMrLzMrKy8nJysjIysfIysjIysjHzMrKz83N0c/Py8jJw7q5xbq3x767x767////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////lJOTlJOTlJOTlJSUlZWVlZSUlJOUlJOTlJSUjYyMhoODgH9+fXp7e3h5enZ3enh4e3l5
        fXl6fHl5fXp5fnx8gH59gH1+fHp6e3h4fXl5f3x8fnt7fnt7fnt6f3x8gH19gH5+gH19gn5+hYOChoWE
        hYODhIOChYSDhYOCh4SEhoSEhoODhoODiIWFhoSEh4OEh4SFhoSDiYSFioeHi4qJjIqKjYuLjYqKjoyM
        joqLjYmJjYqKj42MkI6Oj42OkY6NkY+OkY+Pj4yMkY6Ok5GRlJKSlZKSlpOTlZKTlJGRlZKTlpSUmJaW
        mJaWmZaWl5WUlZKSmJWUnJmXm5iXmpeXnJiXnpmYm5mXmpiZnJmanpubnJqZnZiXn5mZn5ycoJ2dn5yb
        oZ6doJ6eop2dn5ubn5ycoJ2doZ6doZ6dop+fo5+gpKGhpaOipKKhpqKipaOjpqWkp6Wlp6OjpqKip6Sj
        qKWkqaWmqqenq6iorKioqqanqqinq6enrKmprKqqrKmpq6ioq6iprKmprqurrauqqqemq6insK2ssa6t
        sK6tsK6tr62sr62tr6yssK2ssq+ws7CxtLGxtrSzuLa2ure3vLm5oZ+gm5iZ////////////paOk////
        ////////////////////////////////////////z8zNz8zNx8TFwb+/vru7vru7wL29wb+/wb+/wb69
        wr6+wL28v7y8wb29wb28wr+/w8HBwb++v7y8wL29wr6+vry8vry7xMHBxsPDxcPDxsPDx8XFx8TFycbG
        ycbGyMTFyMbGyMfGyMXFyMXFxsPExsTDx8TEx8TENTSLAAB4AAB4AAB4AAB5AAB5AAB5AAB6AAB6AAB6
        AAB6AAB7AAB7AAB7AAB8AAB8////////////////////////////19XV19XV19XUa2qoAQF/AAB/AAB/
        AACAAACAAACAb26r0dHQ1tXV29fY2tfW2dbV19TV2NbW3dvc3tvc2tfX1tPT19XW2tfX2dbW1dLS1NHR
        2NXV29jZ39zc5uPj5OPj1tTUtbPAJyeIAACCAACBAACBAACBAACBAACBAACB////////////////////
        ////////////////////////AAB9AAB9AAB9AAB9AAB9AAB7AAB8AAB8AAB7AAB7AAB7AAB7AAB7////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////6Ofn4+Li4d7f4uHh4+Hh39zd2tjZ2tjY29jY2tjY2tjY2NbW2tjY19TV
        1tPU0M7P0M7P////////////////////////////////////////////////////19TU19TU0tHR0tHR
        1NLR09DR0s/Q0c/P09HR0tHQ0c/P0M7O0M7OzczLy8nJy8nKzMvLzMrKzMnJzcvLzczMzczLzszNz83N
        z83NzczLysnIysjIy8nJzMvKzszMz8zN0s/PzMnJycC+y8C+xr68xr68////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        lJOTlJOTlJOUlZOTlZOTlJSUlJSUlZSUlZSUlpWWlpWWj42OhYODfXt6end3e3l6fHl6fHl5e3l5e3h4
        e3h4fHt7fHp6fHh5fHh5fXp6fnt7fXp6fXt6fnx8gH5+gH5+gX5+hYKBhoSEg4GBgn9/goB/hIKChYKC
        hoKDh4WFhoSEhoSEh4SFh4SEhYKChYODiYeHioiIiYeHiYaHioeHiYaGjIqKjYyMjoyMjouLjYuLjIuK
        jouLj4uMkIyNkI6Nj42Nj42NkI2Nk4+Pk5GRlJKSlJKSlZKTlJKSlJGSk5GRlJKSl5SVmJaWl5SUlZKS
        l5OSmZWTmpWVmZaWmpaVmZSSmZaVmJWWm5aXm5eWmpeWm5aWnZmZnJqanZqanpubnpqanpqbnpqaoJyc
        n5ydn5ycnpuan52coZ+eoZ2doJyboZ6do6CfpKGhpKKio6ChpKKhpaKipqKjpqKjpqSjpqOip6Skqaam
        qqenq6enq6inq6morKmnq6inqaamqqenq6iorKmpraqprauqrauqrampramqraqprKmorqyrsK2tsK2t
        sa6urqyrraqqsa2ts7Gxr62tsrCwure3w8HBoZ+g////////////////////////////////////////
        ////////////////////////////z8zNz8zNxcPEvru8v7u8vru7vbq6v7u7wb2+wL29v7y8vru7v7y8
        vry7vry7wr+/xMHAwr+/wsC/wr+/wL29vbm5vry7wr+/xMDBxcHCxMHCxcLDxsTDx8XEyMbGycbGyMXF
        x8TEx8XFxsTDxsTCxsPDxsPDrKm5DQx8AAB4AAB4AAB4AAB4AAB5AAB5AAB5AAB6AAB6AAB6AAB7AAB7
        AAB7AAB7////////////////////////////29jY29jY19XUtLLFAQF+AAB/AAB/AAB/AAB/AACAKyuR
        09HR1dPT19TV19XV2dbW2NbW2NbW2dfX2dfW2NXU19TU2NbW2NXV2dbW19TU1NHR1dLS2tfX3NnZ3dna
        3tvb3tzcz87OJSWKAACCAACCAACBAACBAACBAACBAACB////////////////////////////////////
        ////////////AAB9AAB9AAB9AAB9AAB9AAB8AAB8AAB8AAB8AAB7AAB7AAB7////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////5uPj5uPj4d7f4t/g4d/f3NnZ2dfY2tjY2tfY29fZ3dnY29nZ3Nvb1NLSvbu70M7P////////
        ////////////////////////////////////////////////1tTU1tTU09HR09HR1dPT1dTT09HR0c7P
        0M7Oz83MzcrKzsvMz87O0M/O0M3NzcrLzszMzszMzMjJzsvLz83NzszMzsvMzszMzs3MzszLzcrKy8jJ
        y8nKzcvLz83Nz83O09DRzsvLz8bFzcbFxr68////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////lJOTlJOTlZSUlJOT
        lZSUlZWVlZWVlZWVlpaWlpaWlpaWlpaWlpSVlZWVjYyMhYODfHp6eXd3e3l5enh4eXZ2eXd2e3h5enZ3
        eHV1end3fHl5fXp6fnt7fnt8fnx7f3x8gH19gX5/f319f3x8g4CAg4CAgoCAg4CBhYKChYKChYODhIKC
        hoOEhoSEhYKBhIGCh4WFiIeHh4WGiIWGh4WFhoSEioeHjYuLjIuLjYuLjYuLjIqKi4iJjYqKjouMj4yL
        jYuLjouLkI2NkY2NkY+PkI6OjYuMj4yMkpGQk5CQko+Pko+Qk5CRlJKSlJGSlZKSlpKSmJSTmZWUmpaW
        mJSTlpOSl5WVmJaWmZaVmpaVmpaVm5iXm5mZmpeXmZaWm5iZnJmZnJiYnpqan5ycn52cnpybn5ycnpyc
        oZ2boJycn52doZ2dop2eop+gop+foJ2eoJ6eoqCgo6Cho6Cho6Cgo6Gho6Cgo6CgpKGhpqOiqKSkqqam
        qaamqKSjqaamq6moq6moqaamqqanqqinq6qpq6ioq6eorKioq6iorKmpraqqsKyssq+ur6ysrKmpsq+u
        srCvnZqasrCw////w8HB////////////////////////////////////////////////////////////
        ////////////////z8zNxcLDv7y8vrq7vbq6vru6vru6vru7v729wL6+vry7ure3vLq5vbu7v7y8wr6+
        wsC/wsDAwsDAw8DAwL29vbm5wL29xcPDxMHCw8DAw8HBxcPDxMPCxsTDxsPDxsLDxsPDxsTDxcLCxMLB
        xMLCxsLCxsPDYWCdAQF3AAB3AAB4AAB4AAB4AAB5AAB5AAB5AAB6AAB6AAB6AAB6AAB7AAB7AAB7////
        ////////////////////29jY29jY2tfX1tTUMC+RAAB+AAB/AAB/AAB/AAB/GhqKu7nI1NHR09HR1NPS
        1tTU1tTU1dPT09HR0c/P1NHQ2NbV2djY19bV19XV1tTU2NbV2tjX2tjX2dfX2NbW2tjY29jYwb/FERGF
        AACCAACCAACCAACCAACBAACBAACB////////////////////////////////////////////////////
        AAB9AAB+AAB9AAB9AAB9AAB8AAB8AAB8AAB8AAB7AAB7////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////5uPj
        5uPj49/g3tvb29nZ3Nra29ra29nZ3dnZ3dnZ3dra2tjZx8XFvbu7////////////////////////////
        ////////////////////////////////19TU19TU1tTU1dPT1tTU1dLT09DR09DR0M/PzMrKzcnJ0M3N
        0c/Q0c/Q0c/P0M3N0c7O0c/Pz87PzszMzszLzcrLzMrLzMrKzMrKz8vLz8rLzcrLzcrLzszMz8zNz83O
        0tHR0c7OzsnJycXFycXF////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////lZSUlJOTlZSUlZWWlpWVlpWV
        l5aWl5aWlpaWlpaWlpaWl5aWl5aXl5WWlZWVjYyLgoGBe3l5eXd2end3eXd3d3N0d3NzeHV1eXZ2enZ2
        fHl5fHh5fXp5fnp6f3x8fnt8fHl6fHl5f3x8fn18gX5/g4CAgoCBgoCAg39/hICBg4GBhIGBg4CAhIGB
        g4GBhoODiIWFh4WFiIaGiIaHiIWFiYaHioeIioiIjIqLjIqLi4iJioiIjImJjYqJjYmKjoqLj4yMkI2N
        kI2NkI2OjYmKjYmJjouLjouMkI2Nk5GRlJGRko6Oj42Nko+PlZKRl5KSmJSTmJWUmZaWmpeXmpeYmJaV
        mJWVl5WUm5aVm5eWmpmYmZaWmJWVmZaWm5eXmpeXm5iZnZqanZuan5ucn5uboZuaopuYop6doaCgoqCg
        oZ6doZ6eoqCgo6Chop+fop6fo6Gho6Gho6Gho6GhoZ+fnpycoJ2dop6epKKhpqOjpqOjp6OkqKWmqaen
        p6Wlp6OkpqOjpaOip6Wkqqioqaenqaamqqamqqinraqqr6yrsK6tsK2uraursK2trKqpnZqa////////
        ////////////////////////////////////////////////////////////////////////////////
        xsLDxsLDv7y8u7i4u7m5uba3tbK1mJaqq6q0wL6+vby7u7i3u7i4vLq6vLq6vru8v729wb+/w8DAxcPD
        w8PCwL2+wby9w8HBw8LBwr+/w8DBw8LCw8LBwb++wb+/wsDAxMHAxMHBw8HBxMLBxcLCxMDBxMLBs7G7
        EBB9AAB3AAB3AAB4AAB4AAB4AAB4AAB5AAB5AAB5AAB6AAB6AAB6AAB7AAB7AAB7////////////////
        ////////////2tfX1NPSfn2vAAB+AAB+AAB+AAB/AAB/AgKAiom009DQ0tDP0c/O0tDQ0c7O0c7O0s/P
        0c7O09DQ19bW2NfX19bW2NXV19XV2tfX3NnZ2dbW2NbW2tnZ29rZ3NrasK7DHh2KAACCAACCAACCAACC
        AACCAACBAACB////////////////////////////////////////////////////////AAB+AAB+AAB9
        AAB9AAB9AAB9AAB8AAB8AAB8AAB8////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////6ufo6ufo5uTk4+Hh4N7e
        3t3c3dzc3dva3dnZ29jZ3Nrb19XWsrCxsrCx////////////////////////////////////////////
        ////////////////39nX39nX2tbW19XW1tTU09HR09DR1dPT09LS0dDQ1NLS1dTT1NHT0s/Qz83N0c/Q
        1NHS0tDQ0M/Pz87OzszMz8zNz83OzcrLzMrKzszM0M3Oz83Nz83Mz83Nz87O0M/P09LR0c/PyMbFxcHC
        xcHC////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////lZWWlpWVlpWVlpWVlpWWlpWVlpWV
        l5aWlpaWl5aXl5WVlpWVlpWVlpWVlpWVjIqKg4GBend3dXJzeHR0eXZ1dnR0dnJyeXZ2e3h4fHl5fnp7
        fnt8f319fnt8fHh5e3h3fHp5fnt7gH1+gX9/gn9/g39/g3+AhIGBhICAhYKChoSEhIODhIKChoOEiIWF
        iIaGiIaHh4aGh4WGiYaHiYiIioiJi4mJioiIi4iIjImJjYuLjYqKjoqKjYqLjYuMjo2NkI2OkY6Oj4yM
        jYqKjoqKkI2NkpCOlJCOkI2Mj42Nko6Ok4+QlZGRlZGQlZKSmZaWm5eYl5SVlpSUlpOTmJWUmJWUmJWV
        mZeXm5iYmpeWm5iYm5eXmJWVmpaVnpqYnJmZnZmboJuaopuZoJuan5uaoZ2coJ6doJ6eoJ2doZ+eo6Cg
        pKGgpKGhpaKipaKipKGhpaOio6KhoqCfoZ6eop6eoqCgoqGgo6GhpqOjp6SlpaOjpqOjpqOjpqOjpaKh
        p6SkqaenqKemqKWlqaWmqaWlrKiorquqrq2sr6+uraurq6enmZaWdnN0////////////////////////
        ////////////////////////////////////////////////////////////////y8fIy8fIv7y9uLa2
        l5WmamiVLy59JCR6QD+Fp6Wxvbq6v728vry7vLi5vLm5vbq6v7y9v729wsDAxcLDxMLDw8DAwr6/w8DA
        wsHAwb6+wr+/wsDAwcC/wb6+wL69wb+/wr+/wsC/wcC/w8DAxsLCxMLBwsHAv729cW6fAAB3AAB3AAB3
        AAB3AAB4AAB4AAB4AAB5AAB5AAB5AAB6AAB6AAB6AAB6AAB6////////////////////////////zcvL
        0M7Nqqa9BweBAAB+AAB+AAB+AAB/AAB/NzaU0tHQ0c/Oz8zM0MzNz8rLzsvM0tDQ1tPT1dPT1dPT1tPT
        2NXV2dfW2dfX2NbX2dbX2dbW2NbV2dfX2tjY3dravLnJHh6KAACDAACDAACCAACCAACCAACCAACC////
        ////////////////////////////////////////////////////////AAB+AAB+AAB+AAB9AAB9AAB9
        AAB8AAB8AAB8////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////6ufo6Obm5uPk4t/g397d3t3c3tzb3dra
        3Nna3t3d1NHRsrCx////////////////////////////////////////////////////////////////
        493b493b2tbX2NXW19bV1tXU1NLT1NLT1NPS1tTU19TV1dPT1NLS1NLR0M7O0s/Q09HSz83NzszL0c/P
        0tDQ1NHR09HSz83NzsvL0M3O0M7Pz83Oz8zMzszM0c/Q1NPS1tTU0M7OyMTDxcHC////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////lpWVlpWWlpWVlpSVlpSVlZWVlpWWlpWV
        lpWVlpWVlZWVl5aWl5aWlpaWlZSUi4mJgX5+eXZ2d3R0dnNzend3e3h4e3h4fHl6fXp6fXt6f319f3x8
        f3x8fXp6enZ3e3h4fn18gH5+gH19gn9/g4GBhYGChYGChoSEhYODg4CBg4CAhoKDhYKChoSEiYeHiYaH
        h4WGiIaGh4aGiIWGiYaHiYeHi4iIjIqKjYqKjIiJjIiKioiJioiHjIqJjouLj4yMj4yLkoyLk42MlI6M
        kYyLkIyLkoyKko2Mko+Pk5GRk5CQk4+QlpOTlZOSk5GRlJCQlZKSlJGRlZKSl5STmpWWmpaWmZeWmJaV
        mJWWmZWVoJmWn5iXmpWXmpaWnpqZoZybnZubnJmZnJiXnJmZnZqanpubnpubn5ybn5ycoZ6eoZ6eop6e
        op+foqCfpKGgpKGgo6CgoJ6eoZ2coZ6eo6ChpaKipqOjpqOjpqKjpqOjpqOjpqOjp6SkqKamqKalqaam
        p6WlqKWlqaamq6mpraqqraqqq6mpqaamlZGSdnN0iIeH////////////////////////////////////
        ////////////////////////////////////////////////////y8fIxsXFvbq6SkiHAABpAABqAABq
        AABqGBh1Y2GUpqOxvLq6vLm5vru7vry8vLq7vbu7v729wb+/wLy9wb2+w8HBwr/AwLy9v729wb++wb6+
        wLy9wL29wL69wL69wb+/wL6+wL29wL29wr+/w8HAwb6+v729vLq9NTSKAAB2AAB3AAB3AAB3AAB4AAB4
        AAB4AAB4AAB5AAB5AAB5AAB6AAB6AAB6AAB6////////////////////zcvLzcvL0c/PysfMOjqUAAB9
        AAB+AAB+AAB+AAB+AAB/ubjGz8zMzszM0c3O0M3O0dDQ1dPT19XU1tPT1dLS1tPS19TU19bV19TU19PT
        19XV2NbV19TU1tPT1tTV2dbXubbGDg2HAACDAACDAACDAACCAACCAACCAACC////////////////////
        ////////////////////////////raqq////s7CwRUNVCQhoAAB+AAB+AAB9AAB9AAB9AAB9AAB9////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////6ujo6ujo5eLj4t/f4N7e4Nzd39zc3tzd3tzc39vazcjEzcjE
        ////////////////////////////////////////////////////////////////3t3d29jZ19TV19XV
        2NXW2NbW1tPT1NHS1dPU1tTV1dLS09HR1NHS1dLS09HR0tDR0tDQ0M3O0c7O09HR1NHS09HR0tDQ0M3N
        09DQ0tDRzcrLzsrLz8zMzcvL0M3N09DR1tTU0tDQz8vLz8vL////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////lpSVlpSVlZWVlpWVlpWVlpWVlpWVlZWVl5aW
        l5aWl5aWlpaWl5aVlpaVlJOTiomIgH5+end2fHh4fHl5fHp6e3l5end4fHp6f318f3x8f3x8e3d4e3h4
        fXx7gH5+gH5/gX9/gH5+gn5/g4CAgoCAg4GBgX9/gn9/g4CAhYKChYKCh4SFhoSEh4SFh4WFhoWEh4WG
        iIWGh4WFh4WFi4mJi4iJioiJi4qKioiHiIaGiYeHjImJj4uKko2KkoyKlY6LlI2LkYuKkoqHlouIkouL
        kIyNj42NkY6Ok4+Pko+PkpCQko+OlJCPlZGQlZGQlJGRlpKSl5OTl5WUlpOSlJGRlZKTnJaUoZuUoZ2W
        nZiVnJeVnJmYnZubnJqam5mZmpaWmZeWm5iYnJiZnpqan5ybn52cnp2cn56dnpucnpuboJ2dop+fpKGg
        oZ+fn52doJ6doJ2dn5ucop+fpaKip6Ojp6SkpqWkpqSjpqSjpqOjpaKipqKipqOjp6Skp6Wkp6SlqKWm
        qqenqqenqqeoq6iopqSknZuciIeHp6Skm5iY////////////////////////////////////////////
        ////////////////////////////////////y8fIxsXFsK28GBhzAABpAABpAABpAABqAABqAABrLi1+
        g4Kiuri5vry8vry8u7m4ura4ube3uri4u7i4vbm6wL6+wb6/wLy9v728wL28v7y7v7y8wL6+wL29v7y7
        wL29wL29v7y8wLy8wb29wL29wL29xMHAxcPCm5qzBwd5AAB2AAB3AAB3AAB3AAB3AAB4AAB4AAB4AAB5
        AAB5AAB5AAB6AAB6AAB6AAB6////////////////////zcvLz83Oy8jJjo2yAwN+AAB9AAB+AAB+AAB+
        AAB+X1+kzcvLzMrLz83N0s7P09HR09HR09DQ0s/P1NHR1dLS1dPS1dPT1dLS1dLS1dPT1tTU1tPT1dLS
        1dPT2tfYmpi+AQGDAACDAACDAACDAACDAACDAACCAACC////////////////////////////////////
        ////1dLSycbGraqq0c7Os7Cwo6GgbmyFBQV+AAB+AAB+AAB+AAB9AAB9AAB9AAB9////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////6ujo5ePj4uDg4t/f4t3e39zc393d3t3d6OPg2tPM2tPM////////////////
        ////////////////////////////////////////////3t3d3t3d29na2tjY2djX2NbW2dXV2NTU1tTU
        1tTU1tTV1tPT1dLS1NLT1NHS1NLS1tTU1dPT0tDQ09HR1NHR0c7O0c/P0M/P0M3O09LR0c/QzcrL0M3N
        0M7NzcvM0M7O1NLS19bW0tDR0c3N0c3N////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////lpWVlpWVlpWVlZWVlpWWl5aWl5aWl5aWmJaXl5eX
        lpSUlZSUlpWVmJeYlZSUioiJgn+Ae3p7fHt8e3l6end4enh4fHl5fnx8fnx8fXp6fXp6f319gX9/f3x9
        fnx7gHx8f3x8f3x8gH19gn+Agn+Ag4GAhYGBhoODhIODhIKDhIGChYKChIKChoSEiIaGiIaGiIWFiIeH
        ioiIiYeIi4iIioeHiYaGioeIjYiIj4qIkYqHkImHkYuIlI2KkYuKkImIkIqIkY2Mko6OkY6OkIyMkY6N
        j46NkI2Nko6Nk46NlpCPlpGQlZCQko+PkpGPk5GQlZGRk5CRlZOTmpWToJuToKCVoJ6WnJeUmZWWnJma
        nZqZm5qam5iYm5mYmpmZm5iYnJiYnpqbnpubnpycnZycnZubnpqan5ycnpybn5uboJ2doJ2dnp2cnJiY
        nJmYn5ydoqCfo6GgpaOjpaOjpaOjpaKhpKCgop6eoZ2do6Cgp6SkpaOjop+epaKhqKWlqaenqqeoq6io
        raqqraurqqiop6Skm5iYqqenp6OjmZaX////////////////////////////////////////////////
        ////////////////////////////sK28BwdrAABoAABoAABpAABpAABqAABqAABqFBNzSEeJn52uvrq7
        vbu7u7m6ura3uba1uri3vbq6vru7v728v729v729vrq7v7y7wL29v7y9v7u8v7u7v7y8wL29wL29wL29
        v7y8v7y7wL69v729v7y+w8LCV1aWAAB2AAB2AAB2AAB3AAB3AAB3AAB4AAB4AAB4AAB4AAB5AAB5AAB5
        AAB6AAB6////////////////////z8zNz8zNz83NysrKHx6JAAB9AAB9AAB+AAB+AAB+JCOLxsPIzs3N
        0dDQ09DQ1NDR0tDQ0c/P0s/P0tDQ0tDQ09DQ0tDP1NHR1NLR1NHR1NDQ1NHR1NLR09HR2tjXfnywAQGD
        AACDAACDAACDAACDAACDAACDAACD////////////////////////////////////1dLS1dLSycbG0s/P
        0c7O0c/P19TUoqC5AAB/AAB+AAB+AAB+AAB+AAB9AAB9AAB9////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////6OXk6OXk5eTj5OLi5OHh4+Dg4+Dg4N7f6OPg2tPM////////////////////////////////////
        ////////////////////////////3dvb3dvb3Nna3dvb29rZ2NbW2NXV2NXV1tXV1tTU1tTU1tTU19XV
        19XW1NLT1NLS19TU2NXV1dPT09LS09DQ0c/P0tDQ0c/P0c7O09HS09HS0M7P0tDQ0dDPzszL0s/P09HR
        1tTU0tDQ0c3N////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////lZWVlpWWl5aWlpaVmJeXmJeXl5aWlpWWl5aWmJeXmJeX
        lpWVlJOTl5aWlpWUi4mJgX5+eXZ2enZ3e3l5fXx8fXt8fXp7e3l5fXp6fXp7fnx8f3x8f3x8fnt7fnt7
        gH19gX5/gn+Agn9/g4B/g4GBhIODg4GChICAhICBhIGChYKCh4WEiIeGiIWGiIaGiIaGiISFiYSFiYeH
        iYaHiIWFiISEioaGjYiGjYiHj4mHkYqIjoqJjImJjYqKj4yLko6Nj4yMkI2Nko+PkI2NjYqKj4yMkIuL
        ko6OlZKRlZGRk5CQkY6NkI6Nko6PlJGRlpOSlZKRmZWSn5uTn5uSnJiVmZaWmZaWmpeWmpiYm5iYnJmY
        nJmYm5iYnJmZnJmZnJqanJqZnZqanZuboZ6eoZ6en5ycnZqanpycnpubnpucnZqanJmYnZuanpybn56d
        o6Gho6GhoZ6eoZ2doZ2dop6eop+fo6GgpaKio6GhoJ6dpKGgqaanqaanqKWmqKWlqKWlqKWlrKior62s
        rKqqqqenp6OjmZaXqKamo6ChlpSS////////////////////////////////////////////////////
        ////////////CQlrCQlrAABnAABoAABoAABpAABpAABpAABqAABqAABrBARtY2KVoqCwubi6vLq6vbm5
        vLm4vLm5vbq7vbq6vbu6vry8v7y9v729wL69wLy9wLy9v7y9v7y8v728v769v7y8v7y8vry7vLu6uri6
        vbu8w8HArKqxERF4AAB2AAB2AAB2AAB3AAB3AAB3AAB3AAB4AAB4AAB4AAB5AAB5AAB5AAB6AAB6////
        ////////////0tDQ0tDQzMvKysnJd3epAAB9AAB9AAB9AAB9AAB+BgaAhIOvzMvL0c/P09HQ09HR0c/P
        0c7O0s/P0s/Q0M/P0c/Q0c7O0tDQ1dPT1NHR0tDQ0tDQ09HR0s/P0MzObm2mBQWEAACDAACDAACDAACD
        AACDAACDAACD////////////////////////////////////3tvb3tvb2NXV3dra3tzc3Nra4d7ev7vP
        HByLAAB/AAB/AAB+AAB+AAB+AAB+AAB9AAB9AAB8////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////6OXk5uTj
        4+Hh2dfX4+Dg4+Dg4N7f////////////////////////////////////////////////////////////
        ////////////4N3e3Nna29nZ3Nva3NnZ2tbW29bV2dXV1tTU19XV19bV1tTU2NbW19XW09DQ09HR1tTU
        19XV19bW1tTV1NLS0tDQ1NPS1NPT09DQ09DR1tPU1dLS0c/P0tDQz8zM0M3N0M7O1NHRz83Nz83N////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////lpaVmJeXmJeXlJOTlZWVl5aWmpmZmJiYlZWVlJOTmJaWmpqZ
        mJeXmJeXk5KSioiIgH9/enl5e3l6fHp6fHl5end3fHp5fn18f31+f319gH1+gH59f319f3x8f319fn1+
        f319gX5+goB/g4GBg4CAg3+Agn9/g4CAhYKCh4SDhYODhIKChoKDiIOEiISEh4WFiIWFh4ODhoOChoOD
        iISEi4eGj4qJj4uKjImJi4iHi4iIjIqKjYqKi4mIjIqJkY6OkY6Oj4yMjo2MjouLj4yNko+QlJGRlJGQ
        k5CPk46Nk4+Ok5CQlZGQlY2Nlo+PmZSQmpWRmJWUmJaWlpSUl5OTlZOTlpSTmJSUm5aWm5iYnJqbnJma
        mpiYmpiYm5iYnJmZnJqZnZqZnJiZnJmZm5iYnZqZn5ydn52dnZuanJmYnZqanpuboJ+eoJ2doJycn5ub
        oJ2coJ2dop+fop+foqCgpKKio6Cgo6CgpqOjqKWlp6SjpqOjpKKipqOjqKWlqainqqinrKmorKmpqqin
        qKamo6ChlpSSp6Ojo5+flZKS////////////////////////////////////////////////////AABm
        AABmAABnAABnAABoAABoAABoAABpAABpAABqAABqAABqBwduLy9/cnGbvby8vry8vbm5ure3vLi4vLi4
        ure3vLm5v7y9wb6+v729v7y8vLq6vLm6wLy8v728vr28vru6v7y8v7y8vLq6vLu7wL+/xMHAs6+wU1F+
        AAB1AAB1AAB2AAB2AAB2AAB3AAB3AAB3AAB4AAB4AAB4AAB5AAB5AAB5AAB5////////////////zczL
        zczLw8HBxcLDwb7DDQ2BAAB8AAB9AAB9AAB9AAB+RESXy8jIzs3N0M7O0tDQ0c/P0M7O0c/P0c/P0M7O
        0M7P0M3N0c/O09HR0tHQ0c/P0tDQ0c7P0c7OysbLUlGeAQGCAACDAACDAACDAACDAACDAACDAACD////
        ////////////////////////////////3tvc29nZ2tjY3Nra3NrZ3dra3dra1NHWGhqKAAB/AAB/AAB/
        AAB+AAB+AAB+AAB+AAB9AAB8AAB9////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////6Obl6Obl4+Hh2dfX////////
        ////////////////////////////////////////////////////////////////////////4N3e4N3e
        3Nra2tnY2dfX2dbX2tjY3NnZ3NjY2dbX2NfX19bV19TU2NXW2NXW1dLS1dLT19TV1dPT1dTU19XW1tPU
        1NLS1NLR09LR09DR09DQ1NLS09LS0c/P0M3NzszL0tHR19bW2dfXxsXGxsXG////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////lJOTlZWVl5aWmZeXmZmZl5eXlpaWmJaXmZiZmZiYmZiZmZeYmZiX
        mJeXk5GRiYiIgoCAfHh4fHl4fHp5fHp6e3l5fnt7fnx8fXt7enl4e3l5fXp5fnp6fnx8f319gH19gH5+
        gH5+f319gH59gH59gn9+hICAhIKCgoF/g4GAhIGBhIOChYOChoOCiISEiYWEh4SEh4ODiYaFioeHioiI
        iYaGioaGjIiHjImJi4mIi4iHi4mIjIqKj42MjoyLjYuKjouKkIyNkY6OkY+Pko+PlJCQlpCOlI+Nk5GR
        k4+Pl4+NlY2Nk4+Ok5CQlJCRlZKRlZGRlJCQk5GQkpCQlZGSlZKSlpOTl5SUmZaWmZaWm5iYm5iYmZaX
        mZaWmZaWmZWVl5OTmZWVnJiYnZubnpycnZqanJqZnpubnpubnJuanpyboJ2doZ6dn52cn52doZ6fop+f
        oJ6eo6GgpKGgoZ6epKGgpqSjp6SjpqKipaKio6GhpaKjpqSkqKWkqKalqKWlqaamrKmprKqqq6inp6Oj
        o5+flZKSqqippaKjlpOU////////////////////////////////////////AABmAABmAABmAABnAABn
        AABnAABoAABoAABpAABpAABpAABqAABqAABrBARtNDOBhYOjtLK2uLa2t7W0ure2ura2uba2u7i4v7y8
        wr+/wL2+u7m5ure3vbm5vbq6vbq7vbq6u7i4vLq6vbu6wL28vr28vbu7s6+w////AAB1AAB1AAB1AAB2
        AAB2AAB2AAB3AAB3AAB3AAB3AAB4AAB4AAB4AAB5AAB5AAB5////////////zs3Nx8XFxMHBycXFycfH
        VlWcAAB8AAB8AAB9AAB9AAB9Dw+Dqaa8ycfHy8nJz8zNz83Nz87N0M7Oz83NzszMzszMz83M0M7N0c7O
        0M7N0c7O0c7O0MzN0c3N1tHQNjWVAACCAACCAACCAACDAACDAACDAACDAACD////////////////////
        ////////////3tvc3tvc2dbW2tfX2tnZ2tjY29jY3drbycfTMC+UAAB/AAB/AAB/AAB/AAB+AAB+AAB+
        AAB+AAB+AAB9AAB9////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////6Obl////////////////////////////////
        ////////////////////////////////////////////////////////4eDg4eDg3dvb2dfX2dbW2dbX
        29nZ3Nra3Nrb3dvb29nZ2NXV19PT2NXV2tjY2dfX2dbW2NXV1NLS09HR1dPU19XV19XV1dPT0tDP09DQ
        0s7Pz8zM0c/P0tHQz8zMz83N19bV3Nva29rZxsXG////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////mZeXmZmZmpmamZmYmZeXmZaXmZeYmZiYmZiYmZiZmZiZmZiYmZiYmpiZ
        kpKSiYaGf319eXR0e3V1end3eXd3end3eXd3eXd4fHd3fnZ0f3l3f318f3x9fnt8fnt7fnx8f31+f3x8
        f3t7gX19g4B/hYKBg4GAgX9/gH5+goB/hIGCh4ODh4SDhYKBhoODhYODhoODh4SDiYWEiYSEi4aGioeG
        i4iHjIiIioeHiIWFiIaFi4iIiYeHi4eHjYqKj4yNkY2OkY6OkY2OkoyNkY2MkpCPlJCQlJCQk4+PkI2N
        kI6PlZKQl5KPk42NkY6Oko+OlJCQlJGRk5GRko+Pk5CQkpCPlZGRmJSUmZaWmZaWmZaXmpiYmZeWmJWV
        mZaWmpeXmZaWm5iZnZqbnpubnpycnZubm5iYnJuZn5ycn5ycn52doJ6eoqCgoZ+en5ycn5ycoZ6doJ2d
        o5+fpqOipKGho6CfpKGhoqCgo6CgpqKjp6Skp6Wlp6WlqKWlqaalqqamq6enq6ioq6ioqqioqqippaKj
        lpOUqaeno6Cgk5CQ////////////////////////////AABlAABlAABmAABmAABmAABnAABnAABoAABo
        AABoAABpAABpAABqAABqAABqAABrAABrR0eJiIajs7GytbOzt7W1uLa2ure2uri4v7y8wL29vry8vby7
        vLm6ure3uri4ure3trOzt7W0u7m4vru7s7Cwvbu7////////////AAB1AAB1AAB1AAB1AAB2AAB2AAB2
        AAB3AAB3AAB3AAB4AAB4AAB4AAB5AAB5AAB5////zs3Nzs3NyMbGysfHy8nIysjIsa++CQl/AAB8AAB8
        AAB8AAB9AAB9VFOdxsPEysfHzcrLzsvMzMvLzcvLz8zM0M7Nz83N0M3Nz83N0M3N0s/P0c7OzszM0MzM
        0s3NxsHHExOIAACCAACCAACCAACCAACDAACDAACDAACD////////////////////////////////2dfX
        2tfY1tTU19TU2tjY2tnZ2tjY3NjZ2tjZPz6ZAACAAACAAAB/AAB/AAB/AAB/AAB+AAB+AAB+AAB+AAB9
        AAB+////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////4eHg4eHg3dvb29fY29jZ3tva3djY29nZ29na29ra
        2tjY2NXW19XV2tjY3dva29ra29nY2tfX1tTU1NPS1dPT1tTU2NfW2NbX1tLU1NHR0MzMz8vL0tDP09HR
        0tHR0tDQ19TU19TU2tfX2tfX////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////mpmamZmYmZeXmJaWmJeXmJeXmZiYmJiXmZiYmZiZmZiZmZiYmpiYmJeXmpeYlJGS
        ioaGfnx8eHZ2eXZ2eXZ2eXh4e3h4gHZ0gXVxfnh2fHl5fXp7f3t7f3x9f319f3x8gH18f318gHx8gX59
        g4CAg4CAgX9/gn9/g3+Ag4CAgX5/gn9/goCAg4GBhYKCiYWEiYSEiISDiYSEiYeGiYaFiYWFioaGiIWE
        iIWFiYeGiYaGiYWGiYaHi4eHjoqJjYqJjYqKjouMjoyMj4yMkY6OkY+PkY+Pj4yOj4yNlZGPl5OPk5CQ
        kY+PkY+OlJCQlJGSk5GQlJGRlJGRk5CQk5GQlJKRlpKSmJSUmZaWmZeWm5iYm5iYm5mYmpeXm5iYmZeX
        mpeYnJmZnZubnpucnZmZm5iXm5iYnJmanpubn5ydn52doJ6dnpuboJ2cnpubnpyboJ2dop+foJ2coJ2d
        o6GhpKKipaKipqKjpqSkpqOjpaOjpaKiqaWlqqamqKamp6WlqKamrKqpr6ytsK2trKmpqaeno6Cgk5CQ
        rKmppKChk4+P////////////////AABkAABlAABlAABmAABmAABmAABnAABnAABnAABoAABoAABpAABp
        AABpAABqAABqAABrBARtGhp2XlySo6Gst7S0u7m5u7i4uLa2trOzuLa1vLq6vr29vry9vLi5ure3t7W1
        tbKytrOzure3u7m5pKKipKKi////////////////AAB1AAB1AAB1AAB1AAB2AAB2AAB2AAB3AAB3AAB3
        AAB3AAB4AAB4AAB4AAB4////npq3zc3MysrIycfHyMbHx8bFyMXFYGCfAAB8AAB8AAB8AAB8AAB9Dw+D
        trPBzsvLzszMz83Ny8rJysfIzsvM0tDR0tDQ0c/Pz8zN0M3N09DQ0M7OzMrKzsvL09DOl5S1AQGBAACB
        AACCAACCAACCAACCAACCAACDAACD////////////////////////////2dfX2dfX1tPT1tPT19XV29nY
        3Nra29nZ29jY2tjYRUWcAACAAACAAACAAAB/AAB/AAB/AAB/AAB+AAB+AAB+AAB+AAB+AAB+////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////4+Hh4+Hh393d3Nvb3dzc3tvb3dnZ2tjY29nZ2tjY2tfX2NbW2dfX3Nra
        3Nra3NnZ3NnZ29nZ2tjY2dbW2NXV19TV19XU2NbW2dbX2NXV09HQ0s/P1NHR1dLT1NLS1NHS2NXV19TU
        29nY29nY////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////mJaWmJeXmJeXmZeXmZeXmZeXmZmYmZmYmpmZmpmZmpmYmpiZmpmZmpmZm5qZkpGRh4SE
        fXp6eHZ2eXZ3fnVzgXZxe3ZzenZ3e3h4fHl4fHl6f318gX9+gH5+gH59f319f35+gX5+g4B/gn9/gn5/
        gn5/gn9/gX9/g4GBhICAhYGAhYKCh4KCiIODhoODh4SEiIWFiYWFiYaGi4iHioeGiYaGiYaHiYaGiYeG
        h4ODiIODjIeHjYiJioiHjYqKjYqKjoqKjoyLj42Mj4yMkIuLkYyLkY2Mko+Pko+PkpCQkpCPk5CQk5CR
        lJGRlJCQlJGRlJKSlZKRlZKSlpOSmZaWl5aVlZOSmJSVm5eXmpeXmpeXmpiYmpeYmZWWm5eXm5mZnJqa
        nJiYmZSUmpeXnZqbn5ubnpubnZqanpuboJ2cnpycnZmanJmZnpubnpqan5qaoZ2eop+gpKGho6Cho6Cg
        o6CgpKGhoZ6dop6dp6Skp6WlpKKipaKip6SkqaamqqenqqinrKmprqursK2sraurrKmppKChk4+Pqaam
        oZ6eWFZ/CQhmAABkAABkAABlAABlAABlAABmAABmAABmAABnAABnAABoAABoAABoAABpAABpAABqAABq
        AABqAABrAABrFBN0XVySnp2suLW2trOzs7Cwsa6utrOzuba2u7m5v7y8vru8uba2tbOyuLa1vru7wb+/
        qaenqaen////////////////AAB0AAB0AAB0AAB1AAB1AAB1AAB2AAB2AAB2AAB3AAB3AAB3AAB4AAB4
        AAB4AAB4npq3yMbGx8bFyMfHyMbFxcTDxsXFwL7DFBOCAAB7AAB8AAB8AAB8AAB8YWCizszMz8zLzszL
        zMvLy8jJzMrKz8zM0c/O0M7Oz8vMzsvLz83Mz8zMzMjKzMnK1dDNc3CnAQGBAACBAACBAACCAACCAACC
        AACCAACCAACC////////////////////////////y8jI2dbW19TV2dbX2tjY2tjX29jX29jY2tfY2dbW
        amirAACAAACAAACAAACAAACAAAB/AAB/AAB/AAB/AAB+AAB+AAB+AAB+AAB+AAB+////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////4uDg4uDg3tzc3dzc3tzc4Nzb39vb3Nra2tfY29jY29nZ29jY3NnZ3NrZ29nZ29jZ29jZ2tnZ
        29nZ29jY2tfX2NbW2NXV19XV2NbX3dra29rZ1dPU1NHS1dLT1NHR2NXV3dva2dfX29nY////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////mZeXmZeXmZeXmpiYmZmZmpmZmpmZmpqampmZmpiYmZiYm5mam5ubm5qam5qakpGQh4SEfXl5
        enV0e3d3enh3e3h2eXZ2end3fXp6f319gH59gH59gX9/gH9/f319f3t7gH19f31+f318gX59hIGBhIGB
        hYCAhYCAg39/g39/hICAhIGBhIGBhoODiYWFioeGiYaFioWEiYSEh4SEhoODh4SEiYWFiISEi4aGi4iI
        jImJjIqKjIqKi4iJjYmJjoqJj4yKko2Kk4yKko2MkI2NkIyMkYyMko6OkY6Pko+Pk5GQlJGRk5GRko+P
        k4+QlZGRlpOSlZOTlZOTk5GQlJGQk5CQk5CQlZKSlpOTlpSUmJaVl5STl5SUmZeWmJaVko+PmJaWnpuc
        m5iYmpeXnJmZnJmZnJqZm5iYnJeXn5qanZqanZuaoJ2doJ2dn52doJ6eoJ6en5ydoZ2doZ2doJ6dop+f
        paOjpKGgpKGgpaGhpqKip6Wkp6amqKalqaemrKmorKmpraqrrKqprampq6enqaamoZ6eWFZ/CQhmAABj
        AABjAABkAABkAABlAABlAABmAABmAABmAABnAABnAABnAABoAABoAABpAABpAABpAABqAABqAABrAABr
        AABrIyN6YWCSnp2ptbKytLKytLKytbKytbKyuba2vby8vby8tbS0tLKyvru7wb+/qaen////////////
        ////////////AAB0AAB0AAB0AAB1AAB1AAB1AAB2AAB2AAB2AAB3AAB3AAB3AAB3AAB4AAB4KSmIvrvA
        xMHCxsTExsTEx8XFx8XGxsTFaGehAAB7AAB7AAB8AAB8AAB8DQ2Bmpm4zcrLzMrKysnJycjIy8nJzMrK
        zMvLzcvLzsvMzMnJzcrJzcrKy8jJzMrL0MzLUE6aAwOCAACBAACBAACBAACBAACCAACCAACCAACC////
        ////////////////////2NbWy8jI2dbV2NXV19XW19XW19XU2NTV2dbW2tfY2NXWfnyzAgKCAACBAACA
        AACAAACAAACAAAB/AAB7AAB/AAB/AAB+AAB+AAB+AAB+AAB+AAB+////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////4+Hh4N7d
        393d3tzd3dra3tva39zc4N3d39zd3dvc3tzc3dzb3dra3dra3Nva3Nvb3NnZ2NXW1tXU2NfW2tjY2dfX
        2dbW2NXW1tXV2dfX3drb3Nna1tTU0s/Q1NDR3NrZ4d/e3dva3dva////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////mpiYmZmZmpmZmpmampqampqZmpmZnJubnJucnJucm5qam5mZnJqanJqanJuakpCRh4SEf317eXd2
        eXZ2eXZ2e3h4fHl6fXt7fXp6fXp7f3x8fnx8fnt7f3x8gH19fnx7f3x8gX19gH18gX19g39/g4B/gn9+
        gX5+gH19gH5+hIGCiIWFh4SEhYODh4KCiYWEh4aFh4WEh4ODiYWFioaGiIWFh4WFioeGjYmJjIqJiYeH
        i4aFjoiHjoqJj4yJkIyKkIuLkYuKkYeHkYiHkIqKkI2NkI2NkI2MjIqKjYqKko6OlJGRlJGRk5CQko+P
        k4+Qk5CQko+OkY6OkIyNk4+Ok5CPlZOSlpSTlZKRlJGQmJWVl5SUk4+QmJWVnpyclpSUk5CRmZeXnJma
        mpiXnJiXpKCcpJ6cnZqZm5qZnpybnZqbnpubn52dnpqanpman5ycoJ6dop+eop+foZ6epKGgpaOjpaGi
        pKCgpKGgpqOip6SkqKamq6mpq6ipqqenqaamqqenq6ior6urnJqjOjp6AABiAABiAABjAABjAABkAABk
        AABlAABlAABlAABmAABmAABmAABnAABnAABoAABoAABoAABpAABpAABqAABqAABqAABrAABrCgpwLy5+
        bGuWtrS0uLa2uLa1uLa1trS0uLa2vby8tbOztLKy////////////////////////////////////////
        AAB0AAB0AAB0AAB0AAB1AAB1AAB1AAB2AAB2AAB2AAB3AAB3AAB3AAB4AAB4X16bwL6+xcPDxcPEx8TF
        xsTExsTEu7nBGBiEAAB7AAB7AAB7AAB8AAB8LCyNyMbIycfHycfHyMbGycbHzMnJzMrKzcvKzMrKzcnK
        zsrKy8nJycbHzMrKu7jFPjyVAQGAAACBAACBAACBAACBAACBAACCAACCAACC////////////////////
        2NbW2NbW09DQ1NHR1tTU1dPT0tDQ0M/O1NLR1tPT2dbW2dbWiIe3BgaDAACBAACBAACAAACAAACAAACA
        AAB7////AAB/AAB/AAB/AAB+AAB+AAB+AAB+AAB+////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////4+Hh4+Hh4d/f39/f397e393d39zd
        3tvb3tvc397e39zd393d397e3tvc3dra3dva393d3dvb2dbX2NTV2NbW2NfX2NbW2dbW2dbX2NbW2NfW
        2tjY29jZ2tfX1tPU1tPT3drZ393d29jZ29jZ////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        mpmampqampqZmpmZm5qanJqbm5ubm5mam5mZnJqanJubnJubnJubnJubnZyck5GRh4SEfnt7e3p6e3p6
        e3l5e3h5eXZ2fHl5fnx7fnt8fnt7f3x7gHx8fnt7fXp6fnp7gn9+gn9+gX5+gn9+hIB/g39/gn5+g4B/
        goCAhYGChYKChYGChYKBhoSEh4SEh4SEh4SEhYODg4KBh4OCjIWDioaFiYeIiIaGiYaFi4iIjIqKjImJ
        jImJjImJjomIkomGkYmGkYyKj4uLj4uLkIyLi4iIh4SEj4yMkY+Pk5CQlZKSlZGRk5CQko+Pk5GQlJKS
        kpCQkY6Ok5GQlJGRlJGRk5CQlZKRlpOTlpOTlJCRmZeXm5mYlpSUko+Ql5OUmpeYmZeWn5qYpqKeo52c
        m5iYm5mZnJmanJmZnZqanZubnJmZnZuanpycn52doJ6en52dnpycoJycop6eo5+fo6Cgo6Cfo5+fop6f
        paKiqKalqaWlqKWlqaenq6ioqqenq6eohIGYHR1tAABhAABiAABiAABjAABjAABjAABkAABkAABlAABl
        AABmAABmAABmAABnAABnAABoAABoAABoAABpAABpAABpAABqAABqAABrAABrAABrAABsJyd7bmyVn52p
        uLa1wL6+ube3vby8tbOz////////////////////////////////////////////AABzAABzAAB0AAB0
        AAB0AAB1AAB1AAB1AAB2AAB2AAB2AAB3AAB3AAB3AAB3Cgp7mJewxsXFxsXFxsTExsTExsTEx8bGiIau
        BAR7AAB7AAB7AAB7AAB8AgJ9j42xyMbGycbGycbGysjIzcvKzsrKzcnJzMnJzMrJzMnJysfHysfGzcvL
        mZi6HBuJAACAAACAAACAAACBAACBAACBAACBAACBAACB////////////////////2dbX2dbX1tPT1dLR
        1tPU1dPT1NLR0tDQ09HR1tPT19TU19TUnZu+AACBAACBAACBAACBAACBAACAAACAAACA////////AAB/
        AAB/AAB/AAB+AAB+AAB+AAB+AAB+////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////4+Hh4+Hh4N7d4N3e4t/h5OHi4uDg4N7f39zd393d3tvb
        3drb393d39zd3tvb3dvb3dvb3dvb3Nna3dra29fZ19XW2tjX3NnZ2tfY2tjY29nY2dfW2dfX3Nra3drb
        3Nra397d3tzd29jZ////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////mpmZ
        m5qanJqbm5qam5mZm5qanJycnJycnZycnJycnJubnZycnZucnZycm5qakY+QhoSEfHt7e3h5e3d4e3l4
        e3h4e3d4fHl6fnt7fnt7fnx7fHp6f3t8gn59gn99gHx8g39+hYGAhIB/gn19hH59g39+hICAhYKBhYGB
        hYGBhYGBhICBgn+Agn+AhICAhIGAiIKAi4OCiIODhYOEiIWFiYWFi4iHjIiHjYiJi4iJioiIi4iHjomH
        jYmHj4uKj4uLj4uLkY2NjoqKioaGjImIjYuLjouLkY6Nk5CQkpCQk5CQlZOTlpWUlJKRk5GRkpCQk4+Q
        ko+PlJCQlJGQlpOSlZKSlpOUmJWVl5SUl5STmJSUl5OUmJWVmZaVm5eWm5eWmpWWm5iZnZubnpqbnJmZ
        m5mZm5mZnJqanJuanZqanpqboJ2doJ+eoJ2doZqZoZiXoJycoZ+fpaKho6CgoJydop6ep6WlqKSkqaWl
        qKWmqaamqqamp6SmXl2JCQlkAABhAABhAABiAABiAABiAABjAABjAABkAABkAABlAABlAABlAABmAABm
        AABnAABnAABnAABoAABoAABoAABpAABpAABqAABqAABqAABrAABrAABsAABsn52p////wL6+ube3////
        ////////////////////////////////////////////////////AABzAABzAABzAAB0AAB0AAB0AAB1
        AAB1AAB1AAB2AAB2AAB2AAB3AAB3AAB3JSSGu7rAxMPExMPDxMLCxMLCxcHCxcPDKCiJAAB6AAB7AAB7
        AAB7AAB7GBiFwsDEycfHycfHysjHy8nIysfHy8bHy8jJysnJycjHycbFysbGx8XIaWelCAiCAACAAACA
        AACAAACAAACBAACBAACBAACBAACB////////////////////09HR1tPT1NHR1dPS1dPU1dPT1tXU1dPT
        1dLS1tTT1dLS1tPUsK/HCQiFAACBAACBAACBAACBAACBAACAAACAAACA////////AAB/AAB/AAB/AAB/
        AAB+AAB+AAB+AAB+////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////5+bl4+Hi39zc39zc4+Dh5OLi4+Dg4ODg4d/f4d/e4N7d39zc393d4N3d39zd
        3dvb29ra3Nna29fY3dvb3t3e3dnb3dva3dvb2tjZ29jZ3Nna2dfX2dbW3drb4t/g4uHg4uHh4N/g4N/g
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////m5qam5mZ
        m5qanJucnZycnJubnJqanJqanZybnZucnJubnJqanJqanZubm5makY+Qh4WEfHp5eXV2eXZ3e3h4fHp5
        e3p6fHl5fXp6fnt6gn19g35+gX19gHx8gn59gH18f3t7g317hoB9hIB+g39+hYGAhoGBhYGAgn9+gH5+
        gH19hICAg4B/g4B/iIOCioSEh4OCiIOCioSDi4WEi4aEiYaFiYeHiYaGioeHioeIi4iJjIiJjYmIjImJ
        jIqKjoqKjYmJjYmJjYqKjoqKjYqJkY6OkY+Pj42NkI2Nk5CQk5CQlJKSkpCQko+PkpCQkY6Pko6Pk5CQ
        lZKSl5STl5OTlZKSmJaWm5mZm5iXl5SUmZaVmJWVlZKSlpOUm5eYm5iYm5mYnJqZm5eYm5iXnZubmpiZ
        mpeXnpqaoJycn52cn5ycopybopyboJycoZ6eoZ+eoqCfoJ6dn5yco6CfpqOjqaamqaanqKamqKamlJKd
        NjV2AABgAABgAABhAABhAABhAABiAABiAABjAABjAABkAABkAABkAABlAABlAABmAABmAABmAABnAABn
        AABoAABoAABoAABpAABpAABpAABqAABqAABrAABrAABrAABsAABs////////////////////////////
        ////////////////////////////////////AABzAABzAABzAABzAAB0AAB0AAB0AAB1AAB1AAB1AAB2
        AAB2AAB2AAB3AAB3AAB3Xl2awsDBw8PDw8HCwb+/wr+/wsDAmpiyBwd9AAB6AAB6AAB7AAB7AAB7Xl2f
        xsTFxsTEx8TExsTExcPDyMXFysfHysjHycfGyMXFycbGtrTCNzaTAAB/AAB/AACAAACAAACAAACAAACA
        AACBAACAAACA////////////0M7P0M7P09HR09HQ0c/O0s/P09DR09DR1NLS1dPT1tPT1tPT1tPU19XW
        0M7UIyOQAACCAACCAACBAACBAACBAACBAACBAACB////////////AAB/AAB/AAB/AAB/AAB+AAB+AAB+
        AAB+////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        5+bl5+bl4+Hh4d/g4d/f4+Hh4uHh4d7e393d4N7d4t/f4+Hg4uDg4N7e397e3tzb3Nra3Nra3NnZ2tfY
        3Nrb397e393e3tvc3dra29nY29jZ29nZ2dfX2tjY393d4d/e4d7e4d/g397e397e////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////nJucnZycnJub
        m5mZnJqbnJqam5mam5qbm5qbnJuanZybnZybnZucnZucmZeYj46OhIGBenh4enh4enh4end3end2fHl4
        gHx7gn19f3t7f3t6f3x7f318fnt7gXx7gn17gX18gHx8gn19hIB/g4B/gn9/gX5+gX5+gn9/gX9/gX9/
        hYKCiIOCi4SCi4WDiYSDiYKCh4KBhIKBg4KBh4SEiIWFioeHioeIi4eIi4eHiYeGiIaGi4iIjImJjImJ
        j4uLkY2MkIyMkY+PkI+PjImKjIiIjouLkY2Nk5CQkY+Pk5CRkpCQkI2NkIyNkY6Ok5CPlJGRk4+PlJGR
        lpSVmZiYmZaVmJOSl5KSmJWUl5WVmJaWmZaWmJWUmJaVmpmYm5iYmpaVnZqZmJWVl5SUnJqZoJycnpqa
        npubnpycnZybnpuboJ2dnZubnZqaoJ2cnZqanpmaop+eoJ+foqCgp6Wlqaeol5WfREN8AwNgAABgAABg
        AABgAABhAABhAABiAABiAABjAABjAABjAABkAABkAABlAABlAABlAABmAABmAABnAABnAABnAABoAABo
        AABoAABpAABpAABqAABqAABqAABrAABrAABsAABrAABsAABs////////////////////////////////
        ////////////////////////AABzAAByAABzAABzAABzAAB0AAB0AAB0AAB1AAB1AAB1AAB2AAB2AAB2
        AAB3Cgp7mpmxw8PEw8LCwb+/wcDAwcDAwb+/bGqgAgJ7AAB6AAB6AAB7AAB7AwN8oZ+1xcLCxsPDxcPC
        xcPCx8TDycXFycXFyMTEx8TEx8XElZO0GBiIAAB/AAB/AAB/AAB/AACAAACAAACAAACAAACAAACA////
        ////////0M7P0M7Pz83O0dDQ0c/P0c7O0c/P09DR09DR09HQ09HQ1dLT19XW19XWysjQJyaRAACCAACC
        AACCAACBAACBAACBAACBAACB////////////////AAB/AAB/AAB/AAB/AAB/AAB+AAB+AAB+AAB+////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////5ePk5ePk4+Hh4+Li
        5OPj5OPj4+Li4t/g4d7e4N3d4d7e4uDg4eDg4N7e393d3tzb3tzc4N7e3tzc3dvb3drb3drb3t3c3t3c
        3drb3NnZ3dna3Nrb2tjY3NnZ3t3c3Nva3NnZ3tvc397e////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////m5mZnJqbnJqamZiY
        mpmZnJubnZycnZubnp2cnp6dnZycnp2doJ6fnp2dmJeWjo2NhIGBeXd3eXZ2end2enh3e3h4e3h4fXt6
        fnt7fXp6fnx7fnt6gXt6g3x7gHt7f3t7gX9+gH5+gH19gX19gX59gX5+gX5+g39/g4GAg4CAhoGAiISD
        hYOChIGAhYGAg4CAgoCAhIKBh4SDiISDiIaFiIaFiYaGiYaGioeGioiHioeHioeGjImJkIyMj42NkI+P
        j42OjYqLjImJjoyLkY6OkY6Pj4yNkI2OkY6OkI2MkY6NkI2NkI6OkI2NkI2NkI2MkY6Oko+PlpGQlpCP
        lZCPk5GRl5SVl5SUl5SUmJWUmZaVmpeXmZeWmJSVmZaWl5WUlpOTm5iYnpubn5uboJycnZqbmZaXnJiX
        nZqZnJqanZmZnpyaoJ2cnpqan5ubmJaWmZeXop+fqKSlpqSkoJ6ieXeRPDt3BQVhAABgAABgAABhAABh
        AABhAABiAABiAABjAABjAABkAABkAABkAABlAABlAABmAABmAABmAABnAABnAABoAABoAABoAABpAABp
        AABpAABqAABqAABrAABrAABrAABsAABsAABsAABs////////////////////////////////////////
        ////////////AAByAAByAABzAABzAABzAAB0AAB0AAB0AAB1AAB1AAB1AAB2AAB2AAB2AAB3Li6IuLe9
        wcDAwsDAwsDAwb+/wL+/w8HBMDCLAAB6AAB6AAB6AAB6AAB7JiWJwsDBx8PCyMTDx8TDyMTEx8PDx8PD
        xsPDxcPDvr3AY2OhBgaAAAB+AAB/AAB/AAB/AAB/AACAAACAAACAAACA////////////////1NLS09HR
        zczM0dDQ0s/P0c/P0dDP09DR09DR0c7P0M7O09HR1dTU1tPTxsPNOTmYAACCAACCAACCAACCAACCAACB
        AACBAgKB////////////////////////AAB/AAB/AAB/AAB/AAB+AAB+AAB+AAB+////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////5+Xm5eLi5ePj5OPj5ePi5OLi4+Hi4+Li
        5OPk5eLj4+Dh4uDh4d/g4d7e4N3e4N3d4N/f4uHh4uHg397c3dva3NnZ3tzb3t3c3dvb3Nra3drb3tvb
        3dnZ3drZ3Nra29nZ3Nra39zb39zb////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////mZiYmpmZnJubnpydnJqc
        nZybnpycnpycnp2dn52dnZucnJqanZucn52em5mZjoyMgX9/d3V1eXZ2e3h4e3p5e3h3enZ2e3h4fHl4
        gnt4hoB8gHx6fXp6f318gHx7gXx6gH18gX5+gX5+gX5+gH19gH19f3x8gH19g4GAhIOCgn9/g39/hYKC
        hYKChYKChYKBhYKBhoOCh4SEhoODh4SDiIaEiYeGiIWFiIWFioeHi4iIjImJjYuLjIqKjIqJj4yMj42N
        kY+PkY+PkI6PkI2Nj4yMj4yLkIyMj4yLj4yMj42Mj4yLj4uLj4qKkI2Nk4+Pk5CPkI6NkY6OlJGQlpKS
        lpOTl5SUl5SUmZaVmZeWl5WVl5WVmJaWmZeWmpiXnJmYnZqZnpubnZmam5iYmpeXm5iXnZmanZqanJmY
        nZuZoJ2cn5ubnZqamZeWnpuapaGhpaOjoJ6foZ6eop+ekI6XSkh8ICBsAQFgAABgAABhAABhAABiAABi
        AABjAABjAABjAABkAABkAABlAABlAABlAABmAABmAABnAABnAABnAABoAABoAABoAABpAABpAABqAABq
        AABqAABrAABrAABsAABsAABsAABsAABs////////////////////////////////////////////GBdw
        AAByAAByAAByAABzAABzAABzAAB0AAB0AAB0AAB1AAB1AAB1AAB2AAB2AAB2XFuYv729wb+/wL6+wb6+
        wr/AwcDBlJOvAAB5AAB5AAB6AAB6AAB6AAB7X16dxcLCxsLCxsPDxsPDxsTDxsTDx8XFxcPDq6m6Ly6P
        AAB+AAB+AAB+AAB/AAB/AAB/AAB/AAB/AACAAACA////////////1NLS1NLS0M7Oz83N0c/P09LR0dDP
        z87N0M7O0M7O0M3N0M7O0c/P0tDP09HR09DQQUCbAACDAACCAACCAACCAACCAACCAACBAgKBAgKB////
        ////////////////////AAB/AAB/AAB/AAB/AAB/AAB+AAB+AAB+////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////5+Xm5+Xm5uPj5ePj5OLi5OHh5OHi4+Hi4+Li5uTl5uXl5OLi4uDg
        4+Dh4d/g4t/g4d7f4N/f4eDg4uDh4N/f397d393c39zc3t3d3tzc3dvb3dvb3tzc3tvc3dvb3tvb3dvb
        397e39zb////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////npydnJqcnZybnZuanpycn52e
        n52dnpycnZucn52doJ6eoJ6en56en56empiZj4yMg4CAe3h4e3d3end2end3eXR1gnt5hYB8f3p5eXV2
        fHl5gn16hH57f3x7fXt7fnt7gH18f3x8fnt7gH18gHx9gX5+gn9+gn9+g4CAhIKBhICAhICAhYGChYGB
        hoODhoKDhIGBhYGBh4SDh4ODhoODh4SEiYaGi4iIi4iIi4eHioaHioeHjIqKjoqLjoyLkI2OkY6PkI2N
        j42Nj42NjYqJjImIjYqKjIiJj4uLkI2Mj4yMj4uLkI6OkY6OkY6OkY2OkpCPk5CQlZKTlpOTl5STl5WU
        l5SUlZKSlpOTmJaWmZaWmpaWmpiXmZiXmJaWmpiYmpiYmpiYmpeWnJmZnJiZmJWVmJWVnpqaoJ2cnpyc
        mZaWnZuapaOjoqChnZqampeXnpuan5ycoJ2dkI6XZWSHJiZvEBBmAABhAABhAABhAABiAABiAABjAABj
        AABkAABkAABkAABlAABlAABmAABmAABmAABnAABnAABoAABoAABoAABpAABpAABpAABqAABqAABrAABr
        AABrAABsAABsAABsAABsAABt////////////////////////////////////////DQx2AAByAAByAABy
        AABzAABzAABzAAB0AAB0AAB0AAB1AAB1AAB1AAB2AAB2AAB2nJmvvLq6vLm6v7y8wL6/v72+vbu7ZGOc
        AAB5AAB5AAB6AAB6AAB6CAh9kZCvw8HBw8HBxMLCxMPDxcPDxcPDxsTEcG+lCwuBAAB9AAB+AAB+AAB+
        AAB+AAB/AAB/AAB/AAB/AAB/////////////w8HAz8zMzcrKz8vL0M3N0M7Oz83Nz8zMz8zMz8zM0M7O
        1NHR1NLS0s/Q0tDRzczOYF+mAACDAACDAACDAACCAACCAACCAACCAACCAACC////////////////////
        ////////AAB/AAB/AAB/AAB/AAB/AAB+AAB+AAB+////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////6efn6efn5uXl5uTk5OHi4+Dg4+Hg5OLi5OHh5eLi4+Hi4d/f4uDf4+Hh4d/f4d/f4d/f
        4d/e4uDf4d7f4uDh4eDf4N3d39zd4N7f4d/f4N3d4N/e397e39zd39zc3tzc3dna3tva3tva////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////nZuanpycn52eoKCfn5+en56en52d
        oJ+foqChoaGhoaGgoaCfoqGioqGinJqaj42Ngn5+eXV1eHNzfnh2gXp4e3d2eHZ2e3Z1gHh1gHt5f3x7
        f3t7fnp7fnt6fXp5fHh4fXp5fnx8fnt8gHx9g3+AhIKBg4GAhICBhYGChYKChIGBhIGBhoKChYKBhoOC
        hoKChYGChIKBhoODh4SEh4WFiIWFiYaGiYaFioeHjImJjYqJjYuKjoyLjYuMjImKkI6Nj46Oi4mJi4iH
        jImIioiHi4mJkI2NkY6NkY6OkI6NkY6MkI2MkY6OkY6Oko+PlJCQlZKRlpKSlpOTlZOSk4+Pk4+PmZaV
        l5OTlZGQl5SUlpSUlJKSmJSUmZaWmZaWmZaWmpiXmJaVlJGRmZWVnJiYnpuanpubmZWVmpeXn52dn52d
        nJmZmZaWm5iYnZqbnJqanpybm5ibhIOSammJODd2BgZjAgJiAABhAABiAABiAABjAABjAABjAABkAABk
        AABlAABlAABlAABmAABmAABnAABnAABnAABoAABoAABoAABpAABpAABqAABqAABqAABrAABrAABsAABs
        AABsAABtAABsAABt////////////////////////////////////AABxAABxAAByAAByAAByAABzAABz
        AABzAAB0AAB0AAB0AAB1AAB1AAB1AAB2LSyGtrS3vLq5vLq6vLq7vru7vru6vru9ODeNAAB5AAB5AAB5
        AAB6AAB6Hx6Ft7S7wb+/w8LBxcLDxcLCw8DBsKy6HR2HAAB9AAB9AAB9AAB+AAB+AAB+AAB+AAB/AAB/
        AAB/AQF/////uba2wb6+w8HAzcrLzMrKzcrKzcnKzcrKzszMzsvMz8zN0M7O0M7O0tDR1NHT0tDR0c/Q
        0M3NeHauAACDAACDAACDAACDAACCAACCAACCAACCEBCF////////////////////////////////AAB/
        AACAAAB/AAB/AAB/AAB/AAB+AAB+////////////////////////////////////////////////////
        ////////////////////////////////wcC+zs3N1tTV2NXVx8TEq6ip////////////////////////
        ////////////////////////////////////////////////////////////////////////////5OLj
        5+Xl4+Li5eLi5+Tl5uTk5OLi4uDg4+Dh4+Df4d7f4N7e4+Hh4+Hh4uDg4+Dg4uDg4uDf4uDg4d7f4d/g
        4uDh4N3d3tzc393d4N3d4N3e4d7f4N7e3tzc3tvc3dra3dra3trb3trb////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////oKCfn5+en56en56doaCgoKCgoJ6doJ6c
        oZ6dn56en52dn52dn56doJ6dmpiYjYqKgX18e3h3e3l4e3h3enZ1fHV0gHp5gHp5f3t7fXl6fHh4fXl5
        fXp5enh3e3h4fHh5fXl6gH5+gH5+gH19gn9/g4KCgn+Agn+Ag4CAhoKBhoKAhIGAhYGBhoODhoSEhoOE
        hoSEhYKChIKChoODh4WEhoSDhoSFhoSFhYSFhoaGhoSEh4SEiIWGiIeGiIaFi4iIjIqKjImIjIiIi4iJ
        ioiIjIuLj4yMkIuJlo6LlY6Mko6NkY+OlJCQlZGRlZGSlJKSl5WUlJKSj4yMkYyNlZGRk5GQko+Qko+P
        lZGQmZWVmJaVl5SUmJSUmZeWlpSUlpOTmJWVm5eXnZmZnJmYm5iYmpeXmpeXnJmZnJmZm5iYnpqbnpyc
        m5iYnpuaoZ6enZucnpydlJKabm2LRUR7EhJoAABhAABhAABiAABiAABjAABjAABkAABkAABkAABlAABl
        AABmAABmAABmAABnAABnAABoAABoAABoAABpAABpAABpAABqAABqAABrAABrAABrAABsAABsAABsAABt
        AABtAABtAABt////////////////////////Hh18AABxAABxAAByAAByAAByAABzAABzAABzAAB0AAB0
        AAB0AAB1AAB1AAB1AAB2WlmXu7m6vLq7urm5vbq6v7u8wb29qKW0DAx8AAB5AAB5AAB5AAB6AAB6Q0KR
        wL6+wr+/xMHBxMHBw7/Aa2mhAAB8AAB8AAB9AAB9AAB9AAB9AAB+AAB+AAB+AAB+AAB/AQF/sKyxuba2
        wb6+x8XFzMrLzMrLzMrKzMnKzcnJzsvLzcvLz83N0M7OzszMzszN0M7O0M/P0c/P0M3NkI+4BweGAACD
        AACDAACDAACDAACDAACCAACCEBCFEBCF////////////////////////////////AACAAACAAAB/AAB/
        AAB/AAB/AAB+AAB/////////////////////////////////////////////////////////////////
        ////////////zMnKwcC+zs3N1tTV2NXVx8TEq6ip09DQvLm5trOy////////////////////////////
        ////////////////////////////////////////////////////////5OLj5OLj5OHi4+Dh4t/f5eLi
        5+Xm5uTk5OLh4+Dg4t/f4+Li4uHh4+Dh5eTj5eTk5eLj4+Hh4uDg4d/g4d/f4N/f4uDh4uHh4eDf4N7e
        393e393e4N7e4N3e393d3tzc3tvb3tzc3trb////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////n56doaCgoJ+eoZ+eop+eoZ+goJ6fn56eoJ6e
        oJ+foJ+eop+goaCgoaCfmZiYkIuLhH99eHZ3end4fHd2e3d1e3h4fHl5d3R0d3NzeXZ2e3h3fXp5fHl5
        fHh5fHh4fXp6fXp7gH1+gH5+f3x8f3x8gn9/hYCAhYB/hIB/hYKChoSEhoODh4ODhYKChIGChIGBhYOC
        goB/g4B/hoSDg4GDgH+BhIOEiYeHh4SEgoCAhIKCiYaFh4aFiIeHiYeIi4iIiYaGhIKCg4GChoOEjYiI
        loyKk4uJj4qKkY2Nko+Pk5GRko+OkIyMj4yNk5GQjIqJiISFj4uMk5CQkY+OlJCPlpGRl5STlpOTmJST
        mZWVl5STkI6Pjo2NlZOSl5SUlpOTmZWVnpybm5mYmZaWnpubnpubnpubn5ycoJ2dnJqaop6cp6Kfo5+e
        n5ycn52cnpyboJ6diYiVVVOBHh1tAABhAABiAABiAABjAABjAABjAABkAABkAABlAABlAABlAABmAABm
        AABnAABnAABnAABoAABoAABoAABpAABpAABqAABqAABqAABrAABrAABsAABsAABsAABtAABtAABtAABt
        AABuAABu////////////////FRV4AABxAABxAABxAAByAAByAAByAABzAABzAABzAAB0AAB0AAB0AAB1
        AAB1AAB1iIanu7m6vLu7vLu7vru9wL29v728gn+mAAB4AAB5AAB5AAB5AAB5AwN7ZGOdwb6+wb6+wr+/
        kpCuJSWIAAB8AAB8AAB8AAB8AAB9AAB9AAB9AAB+AAB+AAB+AAB+FBOEsKyxw8DAyMTFy8fHysjIy8rK
        y8nJzMrJzMrKy8jJzMrKzcvLzcvLzMnJzcrKz8zM0M7O0tDQ0tDRr67EDAyHAACDAACDAACDAACDAACD
        AACDAACCBweEWVmX////////////////////////////////////AACAAACAAACAAAB/AAB/AAB/AAB/
        AAB/////////////////////////////////////////////////////////////vbq6ysfI1tTUzMnK
        1NLS2tna3Nra4Nzd4N7e3Nra09DQvLm5trOy////////////////////////////////////////////
        ////////////////////////////////////////5OHh5OHh4uHh5OHi5OHh4+Dh5OLi5OPj5OLi5OLi
        5eLj5+Xl5OPj5OHh5uPj5eTk4+Hh4+Dh4uDg4d/f4d/f4N7f4d/f5OHi4+Hi4uDh4d/g393d393d39zd
        4d7e4d/f4N7e393d393d////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////oJ+eoZ+eop+eoaCgoJ+foJ+foZ+foZ+foKCfoZ+goaCg
        oKCgn56foJ6foZ6fmZaWjImKfnt7dnNyeHV0eXZ1d3R0dXNyeHV1fHh4fnt6fHl5fHh4e3h3fHl5fnt7
        fnt7f3x8fnt7fnt7fnt7gH59gn9/g4CAhIKBg4GAg4CAhYKChYKChIGBhoKChoODgoCBhIKBjoqGi4aF
        hYGChoODiIaGh4WEhoODiYaGioeGh4aFh4WFh4aHh4WGh4SFh4WFhoSDhYKCiIWFjIeHjIiHjYqKkI2N
        kI2NjYqKj4qJjYiGh4WFjouLjIqJioeHjImKj4yMko+MlZGPlJCRlZKSlpKSl5SUmJWVk5CQjImKjouM
        lJKSlZOTkY+PlZKSmZeWmZeWmZeWnZubn52cn5ycnpuanJmZnZqaoJybo56coJ2bn5ubnZqanJqanZqa
        npybnpuboJydeXePMjF0ExJoAABiAABiAABjAABjAABkAABkAABkAABlAABlAABmAABmAABmAABnAABn
        AABoAABoAABoAABpAABpAABpAABqAABqAABrAABrAABrAABsAABsAABsAABtAABtAABuAABuAABuAABu
        CQli////////AgJxAABwAABxAABxAAByAAByAAByAABzAABzAABzAAB0AAB0AAB0AAB1AAB1JCSCu7m6
        u7q6urm5u7m5vbu8vbq7vbu6YmKaBAR6AAB4AAB5AAB5AAB5BAR8goGovry8p6W1LCyLAgJ8AAB7AAB8
        AAB8AAB8AAB8AAB9AAB9AAB9AAB9AAB+AAB+NjWRx8TFxsPDyMTEy8fHy8jIysnJysfIysfHycjHycfH
        zMnJzcvKy8jIy8fIzMrJzsvLz8zM0M7O0c/PubjICQmGAACDAACDAACDAACDAACDAACDAACDAACDWVmX
        WVmX////////////////////////////////////AACAAACAAACAAAB/AAB/AAB/AAB/AAB/AAB/////
        ////////////////////////////////////////////xcLCvbq6ysfI1tTU3tzc4N7f3dna2dbW3dra
        4+Li5+bl4N7ezsvLtrOyvLq6vLq6////////////////////////////////////////////////////
        ////////////////////////5eLi5OLh5OPi5OLj5OHi4d/f4N7e4+Hh5eLi5OHi5OHi5OHh4+Dg5OLi
        5eLj5OHj5OHj4+Dg4+Dg4d/f4t/g4t/g4uDg4d/f4d7f4d/g4t/g4N7d393d4N3d4uDg4d/f393e4N3e
        4N3e////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////oaCgoJ+foJ+foZ+goJ+foaCfoqCgoqGgoaCgoZ+goqCgoqGh
        oaCgn56eoZ6fmJWVioeHfnt6e3h3fXt5fHl5e3h4enh4e3l4eXd2e3d3fnt7fnt6fHl4fnp6fnx7fXt6
        fXt6fnx8f319fnt8gH19goB+gn9/g4GBhIKBhIGBhIGBhIGBg4GBh4SDi4aEjIiFiYWEh4SDhYKChYOD
        iIWEiIWEhoSEiIWEiIWFh4SEhYOChIKCiIaFioiHiYaGhYODh4WFioeIjImJj4yLjYqKjYmKj4qJjomI
        ioeHioaHh4SFj42MkI6NjouKko2Mk4+Oko6Pk5CQlZOSl5WVl5SUk5CPkY6OlJGRlpSUlZOTlJKSk5CQ
        lZOTmZiXm5iYmpeXm5mZnJmZnJmZm5iYnJqZnZmZm5iZnJmZnJmZm5mZnJmZm5mYmpiYnJmZnZmZnZqa
        lpOYgYCRVlSBJCNvCAdlAABjAABjAABjAABkAABkAABlAABlAABlAABmAABmAABnAABnAABnAABoAABo
        AABoAABpAABpAABqAABqAABqAABrAABrAABsAABsAABsAABtAABtAABtAABuAABuAABvAABvAABvAQFw
        AABwAABwAABxAABxAABxAAByAAByAAByAABzAABzAABzAAB0AAB0AAB0AQF1V1aUuba3u7e3u7i4uri5
        u7i4u7q5u7m5R0aRAAB4AAB4AAB5AAB5AAB5Cgp9fn2lTk2VAAB6AAB7AAB7AAB7AAB7AAB8AAB8AAB8
        AAB9AAB9AAB9AAB9AgJ/RkWWube+xMLCxcPDycfHysjIyMfHyMbGycbGycfGysjHzMrJzMnJycbHycbH
        ysfHy8fHzMrJzszLzcvLx8TLMzOVAACDAACDAACDAACDAACDAACDAACDAQGDPTyWo6Gj////////////
        ////////////////////////////AACAAACAAACAAACAAAB/AAB/AAB/AAB/AAB/////////////////
        ////////////////tbKzxcLCz83MxcLCzszM2dfX2tjY3tzc393c3dnZ3dnZ3t3c4uDg4+Dh3tvc29jY
        09DQvLq6vLq6////////////////////////////////////////////////////////////////////
        ////5eLi5eLi4+Hg4+Hh4+Hh4+Hh4+Hh4+Hh4+Hh4+Hg4t/g4uDg4t/f4+Dg5OPj4+Li4+Dh5eLi5OHh
        4uDf4+Hh4+Hh4+Hh4uDg4uDg4eDf4N7e4N3e4d/f4N3d4d7e4+Hg4uDf393d4N3e////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////oZ+goJ+foaCfoqCfoqCfoZ+foqCgpKGho6KioqKhoZ+foqCgo6Gg
        o6CgoqCgl5WVjImJf319eHZ3d3Z2eHZ2eHZ2d3R1end2enh3eXZ2end3fHl5fXp6fnt7f3t8fnt7fHl5
        fHp6gH9+gX9/gX5/g4CAhIGBg4B/gX5+gX9+g4CAg4CAg4CBhoKChYKChoODhYKChIKChIGChICBhIGB
        hoKChoOChYGBg4B/g4CAhYODhoSEhoODiIWEiYSEiYWEjYqJjoyMjouMjoqKjoqKj42MiIWFg3+Ah4WF
        jo2MkY6Oko6OkY6OkI2Nj4yMkY+PlJKSlJCQlZKRlpSUlpOTlZKSlZKSlpOTlpOTl5WVmpiXmpeYmpeX
        mZaXmpeXm5iYnJmZmpiXm5mYm5iZm5eYmpiXmZeWmpeXmZeXm5iZnJqanZuanpubnpybnpuam5eYh4WT
        VVOBMTB0GhpsBQVlAABjAABkAABkAABkAABlAABlAABmAABmAABmAABnAABnAABoAABoAABoAABpAABp
        AABpAABqAABqAABrAABrAABrAABsAABsAABtAABtAABtAABuAABuAABuAABvAABvAABvAABwAABwAABw
        AABxAABxAAByAAByAAByAABzAABzAABzAAB0AAB0AAB0AQF1f3ygurW1ure3uLa2uba2u7i5u7i4rKqz
        JCOEAAB4AAB4AAB4AAB5AAB5ExOACQl9AAB6AAB6AAB6AAB7AAB7AAB7AAB8AAB8AAB8AAB8AAB9AAB9
        BQV/X16dvLi8xMHCw8HBxsPEyMXGx8XFx8TEyMXGycbGysfGysfHycbGyMXFycfGycbFyMXEzMnJz8zN
        zcrLzMnLNzaWAACCAACCAACDAACDAACDAACDAACDAACDKSiRo6Gjo6Gj////////////////////////
        ////////////////AACAAACAAACAAACAAAB/AAB/AAB/AAB/AAB/////////////////////w8DAzMrL
        tbKzxcLCz83M1NHR29jZ2tjY2tjX2tfX29jY3Nra39zc3tvb3dra39zd4N3e3NnZ2NXWwr+/wr+/////
        ////////////////////////////////////////////////////////////////////4+Dh4+Dh4N7e
        4d7e4t/f4+Hh5eLi5uPj4+Li4+Hh4uDg4uDg4+Dg4+Dg5eLj4+Li4+Hh4+Dg4d7e397d4+Lh5uTj5OLi
        4+Hh4+Hh4+Lh4uHg4t/f4uHg4N7e4d7e4t/f4d7f4N7e4N7e////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////oqCfoqCfoZ+foqCgoqCgoaCgoqChoqCgo6Ggo6GhpKGhpKKio6GhpKGh
        o6GhlpaViYeHe3l5eHZ2dXRzcW9ud3R0e3h5eHV2eHZ2e3h4fXp6fXp5fnt7fHp6fXt7f319gH5+gH19
        gH1+gH59gn9/g4CAgn9/gX9/gX9/gn5/gn5+goB/gX9+gX9/goCAhoKDhoODhIKBhIKBhIOCg4CBg3+A
        hoOChYKCg4CAgoB/hYKCiYWEioiHjYqKjYuLioeHiYaGjouLjouKjIqJh4SEgH19hoOEjoyMjYqLjYqL
        jIuLiYeHjYqLkIyNj4yLkI2NkpCQkpCPko+PlJGQlZOTlpOTl5SUmJWVmpeXmZeXmZeXmZeXmpaWmpeX
        mpeXmZaWmZWWmZaWm5mYm5mZmpaWmZaWmJaVm5iYnZubnpycnpubnpuanpqan5ycnZucjIqVeniOR0Z8
        DQ1oAQFjAQFjAABkAABkAABlAABlAABlAABmAABmAABnAABnAABnAABoAABoAABpAABpAABpAABqAABq
        AABqAABrAABrAABsAABsAABsAABtAABtAABtAABuAABuAABvAABvAABvAABwAABwAABwAABxAABxAABx
        AAByAAByAAByAABzAABzAABzAAB0AAB0ExN7qaawtrO0t7W1t7S1uba2ubW1ube3mJasISGDAAB4AAB4
        AAB4AAB5AAB5AAB5AAB5AAB6AAB6AAB6AAB7AAB7AAB7AAB7AAB8AAB8AAB8AAB9AQF9c3CkxMLBxcTE
        xcPExcLDx8XFxsTFxcLCxsLDx8PEyMTFpqS5yMXGyMXFycbFycXFycbGzMrKz8zNz8zNycfMWlmjAACC
        AACCAACCAACDAACDAACDAACDAACDAACDoaCzpKKj////////////////////////////////////////
        ////AACAAACAAACAAACAAACAAAB/AAB/AAB/AAB/////////trO0xMLBw8DAzMrL0c/P2NXW2tjY3Nra
        29nZ2tnX29nZ2tfX2tfX29nZ2tfX2tbX29jY3tzb393e3tvc2NXWwL69pqSk////////////////////
        ////////////////////////////////////////////////////5OHi4+Dh4N7f4N/e4+Hg4+Dh5ODg
        5ODg4t/g4N7e4uDg4t/f4+Hh5OLi4+Dg4d/e4d/f4+Hh4uDh4N7e4t/f4+Hi4d/g4uDg5OHh5OHi5ePj
        4+Hh4uDg4uDg4+Dg4+Dg4Nzd4Nzd4Nzd////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////oqCgoqCgoaCgoZ+foZ+goqCho6Gio6Kio6GioqGhpKGipKOipKOipKKio6Gh
        lpSViIaGeHZ1eHR0fHh4eXd2end3eXd3enh3e3h3fHl6fHp6fXp6f3x8gHx9gH19fnx8f319gX19g39/
        gH5+gH19gX5+gn5+g4B/goB/gX5+gH19gX5+gn9/hYODh4SEhoODhIKBg39/g4CAhYKChIGBgn9/hIGA
        h4SDi4iHioeHi4eIi4eHiYWFiYaFjYuKjouLj4yMjoyMhIGBhoODioiIioeHi4iIi4iJhYKDjImIjYyK
        iYeIh4OEjImIkI2NjouLj42Nj42Nko+QlZKSl5WUl5WVmJWVlpSTl5SUlpOTmJWVm5eYmZaXlpSTmJWU
        mpeXmpeYmpiXm5mYm5mYm5iYnJiZnZqanpycnpuanZmZnJqanZubnpybn5ycnJmdfHmQVlWCLi50Dg1o
        AABkAABkAABkAABlAABlAABmAABmAABmAABnAABnAABoAABoAABoAABpAABpAABpAABqAABqAABrAABr
        AABrAABsAABsAABtAABtAABtAABuAABuAABuAABvAABvAABvAABwAABwAABwAABxAABxAAByAAByAABy
        AABzAABzAABzAAB0AAB0UE+QtrOzt7W1uLW1t7S0trS0trS0t7W1nJqsFRV+AAB3AAB4AAB4AAB4AAB5
        AAB5AAB5AAB6AAB6AAB6AAB6AAB7AAB7AAB7AAB8AAB8AAB8AQF8jIqtxcPDxcPDxcLDxsPExsTExsTE
        xcLDxsPCjYqvVFKcISCKS0qal5S0urbBysbGysbHzMnKzMrKzcvL0M7OammpAACCAACCAACCAACCAACC
        AACDAACDAACDBweFhYOwpKKjiISF////////////////////////////////////////////AACAAACA
        AACAAACAAACAAAB/AAB/AAB/AAB/CwuDtrO0xMLB09DQ19XW29ra3Nzb3drc3dnb29nZ2tnY2tnZ2tfY
        2tfY2tjY2tfX2tfX3Nra3drb3NnZ3Nra3NrZz83NpqSkpqSk////////////////////////////////
        ////////////////////////////////5OHi5OHi4N3e4N/f4N/e4uDg4d7e4d7f5ODh4t/f4d/e4uDg
        4N3e4N3e4+Dh4t/f4d7e4t/f4uDg4eDg4d/f4t/f4uDg4N7f4d7f5OHh5uPj5uXk5OPi4+Hh4d7e4uDg
        5ePj5eLi4Nzd////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////oZ+foZ+goqChoqGio6Gio6GhpKOjpKOjpaOjpKKipKKipKOjpqSkpKOioqGglpSU
        h4WEend3eHZ1eXZ2enZ3eXZ2dnR0eXZ2fXl5fHp5fnx8f3x8f3x8fnx8fnt7gH19gX5/f3x9f318gX9+
        gn9/g4CBgn9/goB/gn9+gn9+g4CAhYGBhYOChoOChICAgoCAg4GAg4GAgoB/hIKBh4SEioaGioeHiYWG
        iYaGioiHioiHiYaGjImJjYqLjIqKi4mJiIaFhYODh4SEjImIjouKioeHiYWGi4iHjoyMjIqLi4mIj42N
        j4yNjIqJjYqKkI2MlJGRlJKSlJKSlJGRlpKSlZKSlZOTlpSUmJWVmJaWl5aVl5aVmpiYmZaXmZaWmJWV
        mZaVm5iXnJmYnZqanZuanJmZnJiYnJmZnJqanZqanZqan52coZ+foZ+fmpebeniQSkl/BwdmAABkAABk
        AABlAABlAABlAABmAABmAABnAABnAABnAABoAABoAABpAABpAABpAABqAABqAABqAABrAABrAABsAABs
        AABsAABtAABtAABtAABuAABuAABvAABvAABvAABwAABwAABwAABxAABxAABxAAByAAByAAByAABzAABz
        AABzBgZ2gH+gtbOytLKytbOztrS1t7W1t7S0t7SzgoCiCQl6AAB3AAB4AAB4AAB4AAB5AAB5AAB5AAB5
        AAB6AAB6AAB6AAB7AAB7AAB7AAB7AAB8ExODubi+w8DAxMHBxMHBw8HCxMLDxsTEx8XExMHBWVidAAB/
        AAB/AwOAHR2JTUybop63xcLFzMnJzMrLzs3N0M/OiYi0BQWDAACCAACCAACCAACCAACCAACDAACDAACD
        YF+ktrW0iISFn5yc////////////////////////////////////////////AACAAACAAACAAACAAACA
        AACAAAB/AAB/CwuDkY+z09HR2tfX2tfX2NXV2NbW2dbW2dbX2dfX2dbW2tfY2tjZ29na3drb2dfX19TU
        2tjY3Nrb2dbX2dfX29nYx8XFpqSk////////////////////////////////////////////////////
        ////////////////39zd4+Hh393d4N3e4d7e4N3d393d4t/f5OLi5eTk5+Xm5+Tl4+Dh4d/f4N7e4N3d
        4N3d4uDh4uHh4uHh5OLi4+Hh4N3d4d/f5OLi5OLh5OLh5OLi4+Dg4t/f4+Dg6OXl7Orq5+Xl5+Xl////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////oqGio6Gio6GhpKKhpKOjpaOkpKOjoqGho6KipKKioqGgoqCgo6GhoqCfn52clJKRiIWF
        e3h5dnR0dXJyeHR0end3end3e3l5fnt7fXp6fnt6fXp6fnx8gH19gH59gH5+gH5+gH5+gX5/gn9/gX5+
        gn9+g4B+g4CAg4GAhIKCg4GAhICAg39/hIGBhYKChIGAhIKChoWEiIWFiYaGiIaFiYaGioeIiIWGiIWF
        i4mIjIqJjIqJioiIhoWEhYODiIWFioeHjouKjYqKi4iJi4eHiYaGhoWEi4mIj4yMj4yNjYuKjouLkY2N
        kY+OkY+Pko6PlJCQk5CPlJGQk5CRlJGRk5CQlpSUmJWVl5STlpOTl5SUmJWUmJaVmJaVmJaVmZaWmpeW
        mpeWmpiXnJqZnJmYm5iYmpiYnJqanpuan5ycn52coJ6doJ6doJ6ek5KaY2KIMDB2AgJlAABkAABlAABl
        AABmAABmAABmAABnAABnAABoAABoAABoAABpAABpAABpAABqAABqAABrAABrAABrAABsAABsAABtAABt
        AABtAABuAABuAABuAABvAABvAABvAABwAABwAABxAABxAABxAAByAAByAAByAABzAABzAABzERF6mpmo
        srCvtLKytrS0uLa1t7W1tbOytrSzeXefEhJ9AAB3AAB3AAB4AAB4AAB4AAB5AAB5AAB5AAB6AAB6AAB6
        AAB6AAB7AAB7AAB7NTWPwb6/wb29wr+/w8HBxcTFxMLDwb+/w8HAvry/Hh6IAAB+AAB/AAB/AAB/AAB/
        GRiIRkWYj42yysjJzMrKy8nJmpi3AACBAACBAACCAACCAACCAACCAACCAACCAACDKiqSwb7BtbKyn5yc
        paOj////////////////////////////////////////////AACAAACBAACAAACAAACAAACAAAB/AAB/
        ERGGi4m21tPT19PU2NTV2dbX2tnY2NbW1tPU2NTV2tfX29rZ3dvb29ra19XV1NHR19XV2tnZ2dbV2dbW
        19TUtrS0trS0////////////////////////////////////////////////////////////////3Nra
        39zd5ePj4eDg3tvc4Nvd4N7e4N7e4d7e4eDf4uDg5OLj5uTk5+bl5uTk5OHi5OHi5ePj4+Li4d/g4N3d
        4+Lh4+Lh4+Dg5uPk5+bm5ePi4t7f4+Dh5OHi5OLh4uDg5ePj6OXm5eTk5eTk////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////pKKhpKOjpaOko6GhoZ+fo6GgoqChoJ+foZ6fo6Cgo6CgoZ+goqGgpKKioqGglJKShYGBe3d3
        e3h4eXd3eXZ3e3h4fHl4fnp5fXp6end4fHh4fnt7gX9/gH5+fnx8fXp6f3t7f318gH5+gn9+gn9/goB/
        gX5+gX9+g4GBhIGCgn9/goCAg4GBhYODhoSEhoSEhoOChYOCiYaGiYWGh4SEhYKDh4SEiYeHiIaFgn5+
        hoODjIqJjYqJi4eHiYaGjImJjIqKhYODf319gH5+h4SEjYuKjouLjouLkI6Nko+PkI6OjoyMkI2OkY6O
        kY+OkY+Ok5GRlJGRkpCQkpCPlZSSlJKRk5CQlZORmJWUmJWVmZaWl5WVlpOTlpOTmJWUmZaVmJaWmpiX
        mZeWmZaXnJiYnJmYmZeXnJmZnpyboZ+foJ2en5ycoZ6dop6ekpCaYV+IJiVyAABlAABlAABlAABmAABm
        AABnAABnAABnAABoAABoAABpAABpAABpAABqAABqAABqAABrAABrAABsAABsAABsAABtAABtAABtAABu
        AABuAABvAABvAABvAABwAABwAABwAABxAABxAABxAAByAAByAAByAABzAABzNjaFs7GwtLKxtrOzt7W1
        tbS0sq+vtLKwt7W0g4GjAAB3AAB3AAB3AAB4AAB4AAB4AAB5AAB5AAB5AAB5AAB6ERGAAAB6Hh6FLi6L
        a2mfvbm6wLy9wb/AxMPDxsXFxcPDwb6+wr+/lJKxAAB+AAB+AAB+AAB/AAB/AAB/AAB/AAB/AACALCyP
        Z2aiqaa3uri/GRiJAACBAACBAACBAACCAACCAACCAACCAACCDw+Iram/zMrKxsXEpaOjq6mp////////
        ////////////////////////////////u7i4AgKCAACBAACAAACAAACAAACAAACAAAB/DAuDiIWz1dLT
        2NXW29na3Nvc2NfX1NHQ1tLS2tfY3Nra2tnZ2NbW1tTT1dPS1tTU2dfX29nZ3tvb09DQtrS0////////
        ////////////////////////////////////////////////////////3Nra3Nra3tvc5ePj4uDg3trb
        3dra393d4N7e39zd3dzc3tzc3tvc4N7e5OLj5uTk6ebn6Obn5eTk5uPj5uPk4uDg4N3d4uDf5ePj5uPk
        5uPk6Ofm6Obm5+Tl5uTl5OPj4d/f4d7e4uDg5eTk////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////o6GhoZ+fo6GgoqCgoaCfoqCgo6GhpKKio6KioaGgoqGhpaKipaKipaKiop+elJGSg4KCd3V1eXZ3
        e3h4e3h4fHl4fHh4end3eXd3fXt6f359e3l5fHl4fnt6gH19gH5+gX5+f319f3x8gX19gX5+goCAg4GA
        gX9+gH19gn9/g4CAgn+AgX9+g4B/hYOCh4WFh4WEhoOChoKDhYKChoSEhIOCgn9/iISEjYuKjoyKioiI
        h4SEiISFiIeGgX9/g4GBiISEiYWGi4iIjImKjYqKjoyMj42NjouMjoyLj42MkI6OkI6NkI6OkZCPk5GR
        kI6OkI2Nko+Ok5CPko+PlpSTlpSTlJGRlZKSlpSUlpOTl5OUmJWVl5SUl5SUmJWVmZaWmpaVnJiXmpeX
        mZaWmpeXnZuboJ2eoJ2dn5yboJ2co56eo5+eoqCgoJ6eZWKIQD98HR1wAABlAABmAABmAABmAABnAABn
        AABoAABoAABoAABpAABpAABpAABqAABqAABrAABrAABrAABsAABsAABtAABtAABtAABuAABuAABuAABv
        AABvAABvAABwAABwAABxAABxAABxAAByAAByAAByAABzAgJ0Z2aVsa6usrCvtLOzsrCwsq2us7CwtbOz
        tbOzeHefDw98AAB3AAB3AAB3Cwt7AAB4JyaGIiKFQ0KQYF+aeXejlpWtkI+qvbm4tbG3vru7wb6/wL7A
        wL6+wL6+w8HAw8LCwsDBbm2jAAB9AAB+AAB+AAB+AAB+AAB/AAB/AAB/AAB/AACAAACAFRWHVlWdHh6K
        AACBAACBAACBAACBAACCAACCAACCAACCBgWEhoSwy8nIy8jIwr6/q6mpxsTEvby7qKWl////////////
        ////////raurwb+/u7i4Pj6WAACBAACBAACBAACAAACAAACAAACAAAB/AAB/g4Gy2NbW2tjY2djY1tTU
        1NLR1NLS1tTU19TV1tTU1dPT1tPT1tTT19bV29nZ3t3d3dvbxMDBxMDB////////////////////////
        ////////////////////////////////////////5ePi5ePi3tzc393d39zc3tvb29jY3Nra3dvb3tzc
        3tzc3tzd3tzc3dvc3tvb39zc5OHh5ePk4+Hi5eLi5+bl5OPk4N3e4d7f4uDg4d/f5OLj5+Xm6Ofn5+Xm
        5OLi4+Lh4+Hg4uDg4+Dg4+Dg////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        oqCgoaCfoqCgo6Kio6KhpKKipKOio6CgoqCgpKGhpKKipKKipaOjpqWkoZ6ek5GRhYODenh3fXp5fHt6
        eXd4eHV1fHl5fHp5e3d3fHp5f3x7f3t7gH19gH5+fnx8fXp7fnt8fnt7fXp7gH18gX9+gn5/gn19gX5+
        gH19fnt7gHx9hIGBhYSDhYODhoSEhoOChYOChYOBh4WEhoODhIGBhYOCh4SEiIWFioiIh4SEhYOChoOD
        jImIjouKi4iIjImJioiIjImJjYuLjoyMjouLjoqJjImIjYuLkI2NkY6OkY+OkY+PkI2NkI2NkI2NjouL
        kY6Oko+Pko+PkY2Nk5CQlJKSlpOSlZKSlZOTl5STlpOTlJGRl5SUm5eXmZeWl5WVmZaWnJmZnJqanpuc
        oJ2coZ2doJ2coJycn5ycoJ+eoZ+eoZucoZ2gjo2aZmSLPTx8GhpvAABmAABmAABnAABnAABnAABoAABo
        AABpAABpAABpAABqAABqAABqAABrAABrAABsAABsAABsAABtAABtAABtAABuAABuAABvAABvAABvAABw
        AABwAABwAABxAABxAABxAAByAAByAAByNzaFrKepr6yssK6usK2stLCvtrO0sq+wsq+vs7CwdXOdHBx/
        U1KTTk2SammbhoWll5equLW2qqezuri3uri4uri4u7i5u7i4vLm6vLq7vry8v72+vbu8vbq6vbu7v729
        ube6RUOTAQF9AAB9AAB+AAB+AAB+AAB+AAB/AAB/AAB/AAB/AAB/AACABASBAACAAACAAACBAACBAACB
        AACBAACBAACCAACCAACCVFSgzMnKzsrL0c3NzMnJxsTEvby7qKWlxcLBu7e4uLS1xsTExsTEraurwb+/
        ysfHyMfLTUueAACBAACBAACBAACAAACAAACAAACAAACAERCFeHauz83R1dPT1dLS09DR0s/P0tDQ1NDR
        1NHR09DQ1NLS1tPT2NXV2djY29ra19XVvLq6oZ+h////////////////////////////////////////
        ////////////////////////3dvb4N3d3t3c29ra29jZ29na3dvb3NnZ29nZ3dvb3tzc3tvc4N7e4d7f
        3tvb2tfX3NnZ4t/f5OLi4uHh4uHh4uHh4N7e4N7e3tzd4N7e4+Li4+Dh4d7f4+Hh4t/f4uDg5ePj5+bl
        5eLi5eLi////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////o6Ki
        o6KhpKKipqOjpKGhop+epKKipaSjpaOjpqSkqaalqaalp6Wlp6WloqCglJKSg4GCeHV1e3h4e3h5end3
        fHh4fXp5fHp5fXp6fHl6fHt7fnx7fnp6e3h5e3h3fHh4fXp6gH1+gn+AgX9+f319gn9/gHx9gX5+gX5+
        gn9/g4CAg4GBg4GAg4B/hoOCh4ODhYKBgoB/gn9/gn1+hYCAioeHiIaFh4WEiYaGioaGiIaFiIaFiYeH
        ioeHioeGjImJjIqKjouLioaFiISFjYqKj4yMkIyMj4yMj42NkI6NkY6OjYqLjYmJj4yLj4yLj4uLko6O
        ko+Pk5CRk5GRk5CQko+OlJCQko+OkY6Nl5STmZeXlpSTlZKSmJSVmpiXm5mZm5mZnZybnpuboJycn52c
        n52dn56doJ6eop6do6Cgo6Giop+goZ6gjImYY2GJOzl7EhJtAABmAABnAABnAABoAABoAABoAABpAABp
        AABpAABqAABqAABrAABrAABrAABsAABsAABtAABtAABtAABuAABuAABuAABvAABvAABvAABwAABwAABx
        AABxAABxAAByEBB3iYefqqapsK2tsK6usK6ttLGwtbKzsq+wsK6tsa2tsrCwrKyysbCzt7S0trS1ube4
        ubi3t7W2uLW2t7S0t7S0uLa2ube3ure4uri4vLu7u7m5vbq6wL6+vry8u7m5u7e4npquFxeEAQF9AAB9
        AAB9AAB9AAB+AAB+AAB+AAB+AAB/AAB/AAB/AAB/AACAAACAAACAAACAAACAAACBAACBAACBAACBAACC
        HBuMUVCgxsTKz8zNz8zLzsvLz83Nz87NzMrKxcLBu7e4uLS1xsTExsTEwb+/zMrJ0s7P1NHRxMLNREOa
        AACBAACBAACBAACBAACAAACAAACAAACAAAB/dXSt1NLR1dLS0c7Pz8zM0tDP1dPS1NLR1dLS1dPS1dLS
        1dLT09LS1NLS1tTUysjIoZ+hoZ+h////////////////////////////////////////////////////
        ////3dvb3dvb2dbX3dra3Nra2tfY2tjY3Nra3Nra3Nra3dvc3dvb3dra3tzb4uDg4N7e3drb3dva4d7e
        4+Dg4d/f4N7e393d3tzc3tzb39zc393d4N/f397e393d4d/f4t/g4t/g4+Dh5+Xl5eLi////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////pqOjpKGh
        op+epKKhpKSjpqSkpqSkqKalqaenqKenp6Wlp6SkqKWlqKWloJ2dkY+Pgn+AeXZ2fHp5e3h4e3l4e3l5
        e3l5e3l5fXt6fHl4e3h4fnt7fnt7fHp6fnt7gX5+gX5+f3x8gH19g4KAg4GAgH5+gH1+gX9+gH18gX19
        gX1+g39/g4GAhYGBh4GBg39+hICAh4SDhoODhYKBhYOChIGBgn9/hIGBhoOChYOCh4SEiIWEhoKCiYaF
        ioiHhIKChoKDkI2NjYuLiIWFioiIjYqKjouKi4mJjoqJkoyLkY2NjoyLj42Mj42NkI2NkI2NkY+OkI6O
        kIyNkY6Nko+Oko+PlZKSlJKRlZOSmJSUmJOUmJWVmJeWmpqYm5qZm5iYnJmZn52dn56doJ6eoJ2doJ+e
        op+goqGhoqCfop6cpKGhoqCin52ed3WQOjh7HR1wDAtrAABnAABnAABoAABoAABpAABpAABpAABqAABq
        AABqAABrAABrAABsAABsAABsAABtAABtAABtAABuAABuAABvAABvAABvAABwAABwAABwAABxGxp6Z2WS
        rq2ssK6usrCws7GxsrCvsK6usa2usq+vsa+vsa6usrCvsrCwsrCws7Cwt7S0ube4uba3t7a2t7a1uLW1
        t7Szt7S0t7W1uba2vLm4vbu7ubm5urm5wL29vbu7ube3vbq6i4mqExOCAAB8AAB9AAB9AAB9AAB9AAB+
        AAB+AAB+AAB+AAB/AAB/AAB/AAB/AAB/AACAAACAAACAAACAAACBAACBAACBFBSIYWCkyMfKzMnKy8jI
        ysjIycjHy8nJzcrJzcvLz8zMzszLzcrK0c7OzcvLycbGzcnJ0s7O0s/Q0c/Qx8XLIB+NAACBAACBAACB
        AACBAACAAACAAACAAACABASCb26q1NLS0dDPz83N0c/P09LR1NLS19TU1tPU09DR0tDQ0tDQ1dLS1tTS
        xMHBoZ+h////////////////////////////////////////////////////////////3Nra3dvb2dfX
        2tfY2tjY29nY3Nra3Nna29nZ3Nra3Nna3NnZ3NrZ3t3c397e393d4N7e3t7d3Nra3tvb4N7e4N7e3drb
        3dra3trb3tvb3tvb3tzc3t3d3tzc39zc4d7e4t7f4t/g5OPj5OPj////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////pKKhpKSjpaOj
        p6Wlp6Wlp6WlqKamqKamp6akp6Wkp6SkqKWmqKWmqaanoZ6ek5GQhYKCenh4e3l5fHp6fXt6fHp5e3l5
        fHh4fXl6fHp6e3l4fHp5gH19gX5+f3t8fXp6gYB/gH19fnt8f319gH18gX19gX5+gX9+f3x7f319gX19
        hn59h4B/hYOCh4SDhYKCgn9/gn9+g4GAgX5+gn5+g4B/hYOCh4SEhoOChYKBhoODiYaGhYGCh4SFjoyM
        jImJhYODiIWGjYqKi4iJioeGlJCMmJOQkIuKjYuKjoyLj4yMj4uLj4yMjYuKjoqJj4yMkI+Ok5CQk5CQ
        kY+Ok5CQlpOTl5SUlZGRlpOSmJSUmpeXm5iYmpmZm5qanJqanpybnZubnpucoJ2doZ6eoaCgoZ+eoJ6e
        oqGhoqCgoZ2cpKCflJKcgoCWYmCJODd6HRxxCgprAABoAABoAABoAABpAABpAABpAABqAABqAABrAABr
        AABrAABsAABsAABtAABtAABtAABuAABuAABuAABvAABvAABvAABwAwNxZ2WTp6SnrKqpr66usK6usK6u
        r62tr62ssq6usa6vsK2usK2tsa+vsa+vsa6usrCwtLGytbKztrOzt7W1t7a3uLa3uLe3ube4uri4uri4
        u7i3ure4uLa3vLq6vry8ube3t7S0t7a4a2mfCwuAAAB8AAB8AAB8AAB9AAB9AAB9AAB9AAB+AAB+AAB+
        AAB+AAB/AAB/AAB/AAB/AACAAACAAACAAACAAACAAACBCwuFQD+XaWilk5Gzrau7wr/CyMXFycbGyMXF
        yMXFysfHzMjJzcrLy8nIysjHzcvLz87Nz83NzsvM0M7Oz87OtbLDLi2SAACBAACBAACBAACBAACBAACA
        AACAAACAAgKBdHOt0M3O0M3M0MzN09DQ09LR1dPT09DQ0s/P09HR1NLS19XV09HRtbKytbKy////////
        ////////////////////////////////////////////////3Nra3Nra2dfY2tnZ2tfX2dbW2dfX29nZ
        29nZ29nY3Nna3dra3dva3Nra29na3Nra3dvb3tzc3Nra29jZ3tvc3t3d3tzc3tvb3tzc393d3tvb3dra
        3dzc3t3d393d39zc397d4N7d4N/f4d/g4d/g////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////paOjp6Wlp6WlpaOjpaOj
        qKamqKemqKamqqioqaioqaioqqioqaenq6inq6mooJ2ekY6PgoCAe3l4fHl5e3h4enh3eXd3enl4eXh3
        enh3fHl5f319gH59fnp7f319fXp7fnt7fn19f3x8fnt7gH19f3x7fnt7fnt8gXx8iH99h4F+g4GAhIGB
        hYGBhIGBhYKChoSEhYODgoB/g4GAhIKBhYKBhYKBhYOCh4WEh4SEhYKCh4SFi4mJiIaGh4SEh4ODi4eI
        i4mJjYqIlI+Mk46NjIeIjIqKjouLjYqKjouLjoyMjouMjoyKjoyLjouLkI6OkI2NkY6OkY6Nko2NlI+P
        lZKSlJGRlpOSlZGSl5SVmJaWmJWVnJiZnZqbnJqZm5mZnJmZm5mYnJqZn5ubn52dnpycnpuboJycoZ+f
        oqCho6Cho6GhlZKbgn6TX12INTR5GhpwCgpsAABoAABpAABpAABpAABqAABqAABqAABrAABrAABsAABs
        AABsAABtAABtAABtAABuAABuAABvAABvBQVxR0aIq6mqrKqqraqrr6ytr62trqysraqqr6yssrCwsrGx
        sK6usK2trqysr6yssrCws7Gysa+vsK6utLKxtrW0tra2tbS1trS0uLe3uri4uri4uba3uLW1ube3vbu8
        vLq7ubW2u7i4r662Pj2QAQF7AAB7AAB8AAB8AAB8AAB9AAB9AAB9AAB9AAB+AAB+AAB+AAB+AAB/AAB/
        AAB/AAB/AAB/AACAAACAAACAAACAAACBAACBBweDGxuKODeUaGalmpe3paK5w7/EycbHycbFysbGycbG
        ycjHysjIysnIzMrKzsvLzszMz8zNzczMzcrKq6m/Hx6NAACBAACBAACBAACBAACBAACAAACAAACAAACA
        fnyw0tDQ09DR1dHS1NLR09DQ0c7O0c7O0tDQ0tHR1tPTy8nJtbKy////////////////////////////
        ////////////////////////////////19TV19TV19TV2dfX2NbW2NXV19TV19TU2dbW29jY29na29jZ
        3NnZ3Nra29nZ2tjY2tfX2dbX2tbX29jZ3dvb29ra29ra39zc4N/f3t3d3Nra3NnZ3dra3dvc3tzd3dvb
        3Nra393d4N/f4d/g////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////paOjpaOjqKamqaeoq6mpq6qq
        qqioqaeoqaeoqqinqqinqqenqqeoq6ipq6mqoZ+fko+PgH5+eXd3end4eXZ2eHZ2end3fHl5fHl5fHp5
        fHp5fnx8gX9+gH5+fnt8e3h4fHl4fnt6fnt6fHh4fnp5gXx8gn99gn9+gX19gX59hIGBhYODhYKCh4WE
        hoSDhYOChIKCg4CAg4CAhIGBhIGAhoOCh4SEh4SEiYeGiYaGh4SEiIWFiYWGiYWFioeHi4iHi4eHi4eH
        i4eIjYuLjoqLjImJjImJjIqKjIuLjoyMjYuLj4yMkI2NkI6OkI+Oko2MlIuJk42Mk5GRlpOSmJWUlZKS
        lZOSlZSUl5OTmpeXnpycnZmZnJmZm5iYm5iYm5eYnZianJmZm5mZnJqanpucoJ2doJ6eoJ2cop2cpJ+e
        o5+eop6ej46YfXyUXFqIMjJ5GRlxCAhrAABpAABpAABpAABqAABqAABrAABrAABrAABsAABsAABtAABt
        AABtAABuAABuAABuNzeCoZ6nq6mpqqmprKuqr66ur6ysrKipraqqsK+usbCwsbGxsK+urKqqq6morauq
        sa6usa+wsK6vsq6vtLGxtLOztLOztLKzs7CxtrSzubi4ubi4uba3uLW1ura3uba3urm5vbu8vru8q6m1
        MDCKAAB7AAB7AAB7AAB8AAB8AAB8AAB8AAB9AAB9AAB9AAB9AAB+AAB+AAB+AAB+AAB/AAB/AAB/AAB/
        AACAAACAAACAAACAAACAAACBAACBAACBCAiEHx6NISGNPj2XcW+pnpy4xcPFycbGx8TEx8TEx8TEycbH
        zMnKzczLzczLzcrKzMjJzczLoJ+9Dw6HAACCAACBAACBAACBAACBAACBAACAAACADQ2FdXSt0M/Q0s/P
        0s7O0s/P0c/P0M7O0c/O0c/P0c7Pwr/Al5WVl5WV////////////////////////////////////////
        ////////////////29nZ1tTT1dPT1tPU1tLT1tTU19XV19XV2dbW2dfX2djY2tjZ2tfY3NnZ3NrZ29nZ
        29rZ2tjY2dbX2tjY3NrZ3NnZ29jZ3dvb3tzc3dvb3NnZ3Nvb3dvb3Nra3Nna3dra3dra3tzb4d3e4d3e
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////qaeoq6mpq6qqq6qqqaeoqaenqaen
        qaenq6mqrKqqrKqqraurrKusq6mrq6mqn5ycjYuKfnt8dnV1fHh3fnl4e3Z3eHV1eXd2e3h4f319gH59
        fHl5e3d3fHh4fXp5fXp6fnl5fnh3f3t6f318gX5+gn19gX18g4CAgn9/gX18g39+g39/hIGBhYKCg4GA
        hYKCg4GBgn9/g39/hYKCh4SEiIWEh4SEiYaGjIuLjYuKioaGiIWEioaGh4SEh4WFi4iIjImKjYmJjYuK
        jImJi4eHjYuKjIqLioeIjYqKkY2Nko6OkI6Oko6Nk46MkY2Nk4+PlJGQk5CQlZKSk5GQlJKSl5SUmZiY
        nJqanJmanJqbnJqbnJmZm5mZm5iZmpeYmZeXm5mYm5iYnpqbn52doJ6doZycoZ2cop+foZ2eoZ6foqCf
        oZ6fkI6ZfXyUWViIMDB5GBdxBwdrAABpAABqAABqAABqAABrAABrAABsAABsAABsAABtAABtAABtIB95
        jIqfr62trqurp6Skqaemraurrqusq6eoraursK+vsK+vsK+vrq2sq6ioraursa+vsa6vsK6usa+vtLCx
        s7CwsrGxtLKytbOys7GxtLKyt7a2t7S1uLS2t7W2ure4ube2trW0uLW2t7S1kpCpERB/AAB6AAB7AAB7
        AAB7AAB7AAB8AAB8AAB8AAB9AAB9AAB9AAB9AAB+AAB+AAB+AAB+AAB/AAB/AAB/AAB/AAB/AACAAACA
        AACAAACAAACBAACBAACBAACBAACBAgKDAwODExOIQkGYdHOrk5K0xsPDycXGycXGycbHzMrLzcvLzMjI
        ysbHy8nJzMvLkI+0CAiFAACCAACBAACBAACBAACBAACBAACAAACAAACAenmtzszMzszMzszMzs3M0M7O
        0c/O0M3N0c7PycfIraurraur////////////////////////////////////////////////////zczM
        29nZ1tTU1NLT1tPT2dbV19bV19XV2tfY2dbW2dfX29nY29nZ2tjY2tnZ2tnZ2tjY3Nva3Nra3Nra29ra
        3Nva3Nna3Nnb3Nra2tjY2dbX2tfX2tjZ2tnZ2tjY29fY3NnZ3dvb3dra39vc39vc////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////q6qqqaeoqaenqqioq6ioq6mqrKqqrKur
        rKqrrKqrrKqqrKmpraqqrKqprKqqnpyckIyMhYB+fnh2e3Z1eHZ1end3e3d4end3eXV1end2e3h3fHl5
        f3t7gXt5fXd2fXp5gH59gH19gHx8gH19gn9+gX5+gHx8gHx8gX59g39/gn9/goCAg4GBgoB/gn9/g4B/
        hIGBhYKCg4GAhIGBh4SEiIeHioiHioWDiYSDiIWEiIaGiIaGiYeHiYaFioaGi4iIjIqKjIiHjYmIioiH
        hoKDi4iIj4yMkYyNkIyMkY+OkI+OkI2Nko+OkI6OjouLko+Ok5CQk4+Pl5SUmJaWl5WVl5WWmJaWmpeY
        nZmZnZqam5qZmZeXmpiYm5mYnJmZnZqbnZubnpycnpubn52coqCgoqChoZ6foqGgo5+go6CgpKKiop+i
        kY2ZeHaRVVSFLy55FhZxBgZsAABqAABqAABrAABrAABrAABsAABsAABtHh53c3KTqaanrausrqysqqWn
        qKWlqqiorKmqrKmqrKmqraurrKqqraurr62traurrqysr62tr62tr62tsK2tsK6usa6vsrCwtLGxtLKx
        tLKytbO0tbKztLGxtLKytLOzt7S0t7W0tbOztLGytLCylJKnQD+OFRSBAQF6AAB6AAB7AAB7AAB7AAB8
        AAB8AAB8AAB8AAB9AAB9AAB9AAB9AAB+AAB+AAB+AAB+AAB/AAB/AAB/AAB/AACAAACAAACAAACAAACA
        AACBAACBAACBAACBAACCAACCAgKDAgKDAACCGBeKVVSgkZCzpaS6wr7GxsPGx8TFyMXFysfHy8jJy8nJ
        dXOrBgaEAACCAACCAACBAACBAACBAACBAACBAACAAACAgH+w0M7OzcrKzcrJ0M3N0M7OzszM0c/Py8nJ
        raur////////////////////////////////////////////////////zczMzczM1NHR1tPT09HR1tTT
        2tjX19XV1dPT2NXV19TV2NXW29nY2tjY2dfX2NbX2NbW2NbW2NbW29jZ3tzc3dva29nY29jZ2tjY2tjZ
        2dfX19XV2NXV19XV19XV2dfX2tjY2tnZ3Nra3NnZ39vc////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////qqioq6ioq6mqq6qqq6qrqqiprKmprampraqp
        q6mpq6mprKqrrKqrrKqqrKmqnpqakIuLf3x8eXd3eXd3eXV2eXV1eXV1enZ1eXV1fHh3gHp4fXl4fnt6
        fXp6fXl6fnt7gH59gH19gH19gH18gH5+g4GAhIGAgX9/gX5/gn9/gX19g39+gn5+goB/gn9/gX9+gX5+
        gn5+gn9+hYGBiIKChoGAhIKBhoSEioaGiIWFiIaFiIWEioeHi4iIioeHioeIioeGiYeGi4iIjouLjouL
        ko6NkY6OjIqLjImIkI2MkI6OkI2NkY6Nk5CPkpCPlZGRlpOTlJKSlpOTl5OTmpeXnJmZm5iYmJaWl5WV
        mZaWnZqanZubnZubm5mZm5iZmpiYnZubn56eoJ6foZ+foaCgoJ6fnpydoJ2doZ2doJ6eoJ6en5yej42Z
        eHWRUlGFKyt4FRVxBARrAABqAABrAABrAABsBARtaGaPpaKjp6WlqaeoqaeoqaanqKamqKamqqiorKqq
        rKmqq6ipq6qqrKqrrausraurrauqrKqqrqurrqusraqrrq2tr6ytsa+vsa6vsq+wtLKys7Cwsq6us7Gx
        tLOztbOztbOztLGxtLGxtrOztbO0tLS0paOuhYOkRUSQGhqCBAR7AgJ8AAB7AAB7AAB7AAB8AAB8AAB8
        AAB9AAB9AAB9AAB9AAB+AAB+AAB+AAB+AAB/AAB/AAB/AAB/AAB/AACAAACAAACAAACAAACBAACBAACB
        AACBAACBAACCAACCAACCAACCAACCAACDFBSKPDuXaGelgH6tnZu3r6y+ysfIysjIy8jIbWuoAACCAACC
        AACCAACBAACBAACBAACBAACBAACAERGGiIezzcrLzMjIzcvKzs3MzszMzMnKuri4uri4////////////
        ////////////////////////////////////////1dPT1NPSz8vM08/Q09DQ09HR1dPT1dLS09HR1dPS
        1dPT1dPT2NbW2NbW2NXW2NXV19TU2NbX2dfX2dbV3Nna29jY2NbW1tXU19XV2dfY2tfX2dfX2NbW1tXV
        1tTU2NbV2NfW2dfX2tfY29na29na////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////q6qqq6qrqqipq6mprKmprKqpq6mprKmqraqqraqs
        raurraqrraurraqqq6monJmZjIqJfn18eHZ2enZ2enV1dnJydXJyeXZ2fHp6fHl4e3Z2fHh4f3x7fnt7
        fnt7fnt7f3x8f3x9gH5+gYB/g4CBg4CAgn9+gX5+gn59gH18f3x8gH19gH18gn59gn59gX19g4CAhIGB
        goCAgX9/hIGBhoOCh4SFiIWGiYaGioeGioeGiIWFiIWGiYeGi4mJjYuKjYqKj42Mj42Mj4yMjYqLjImJ
        jYqJkI2MkY6OkY6OkY+OkpGQlJGRlJCQkpCQlZKSmZWWmZaXmZeYl5SUlpOTlJKSlpSTmpeWnJmZmpiY
        m5mZm5aXm5eYm5mZnJqanJqan5ucn52dm5qbnJqanpqan5ycn52eoZ6eoZ6doJ6eoJ+enpyfjoybdXOR
        TkyDJyZ2GRlyBgZtAABrVVWImpefpqOjp6ampqWmp6Slp6WlpqSkqKWmqaenq6qprKqrrKqsrKurrKqr
        rKmqrKqqq6mprKqqrKqqrqqrrqusrqysrqurr6ytr62tsK2usa+wsa6usq+vtLOztbSzt7S1tbO0tbKz
        tLCws7Cws7CxtLGytLGxs7CvtLGxmJWpdXKfSEeRGRmCBAR8AgJ8AAB7AAB8AAB8AAB8AAB8AAB9AAB9
        AAB9AAB9AAB+AAB+AAB+AAB+AAB/AAB/AAB/AAB/AACAAACAAACAAACAAACAAACBAACBAACBAACBAACC
        AACCAACCAACCAACCAACCAACDAACDDw+IIiGOMzKUR0abb2+pl5W2wsDFR0ebAACCAACCAACCAACCAACB
        AACBAACBAACBAACBCQmDmJa4zMjJy8nJzczL0MzNycbHrqurrqur////////////////////////////
        ////////////////////sK6u1dPT09DQ0M3N0s/P0tDQ0M7P0s/Q1NHR09DR09HR1NLS09HS1tPU1tPU
        1dPT19XV2dbW2dfY2NbW19PT19TU2tjY2NbX1NLS1tXU2tjY2NbX2dfY2NfX2dbW2NbW2dfY29nZ29nZ
        29jZ3Nrb3Nrb////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////q6mprKmprKqpq6mprKuqrKqrraqsrqysraurrquqraqq
        rKqqrKqpraqqrKqqnJubioiHfHl4dnNzdnJydnNzeXZ2eHV0eXZ1fXl5fXp5fHl5fHh4fXp6fnp6f3t6
        fnx7gH5+gn+Agn9/gX5+goGAgX9/fnt7fnt6fXp6f3t7gX9+gn9/gX59goB/hIKBhICAg3+AhICAhIGB
        hoKDiISFh4WEiYaFiYaFiISEh4ODiIaFiYeGioaGi4eHjIqKiYiJioiIjoyLjouMjYqKjYqKj4yMjYqK
        jYqLkI2NlJKSk5KSkI2Oko+Pl5SWlpOUlJKTl5WVlpSUlJGRlZKSmJWVmZWWmZWVm5mZm5mZm5eXnZqa
        nJqam5iYnJmZnJqam5qanZuaoJ2dn52en52dn5ycoJ2doJ2eoJ+foZ+fop+goZ+fm5qdiYaWfnuSdHGQ
        XlyJpKKipaKipqKjpaKjpqSkp6WlqaenpqSlp6WlqKWmqaanqqiprKmprKqpq6ioq6mpqqmpq6mprKur
        rKurq6mpq6iorKiprqursK2usK2ur6ytsK6us7Gysa+wsq6vs7CxtLKztbO0trW0trSzsq+wsq6vs7Cw
        sq+vsq+vsbCvtLGyubW3vry8nZ2xdHOhREORFhaCBAR8AgJ8AAB8AAB8AAB8AAB9AAB9AAB9AAB9AAB+
        AAB+AAB+AAB+AAB/AAB/AAB/AAB/AAB/AACAAACAAACAAACAAACBAACBAACBAACBAACBAACCAACCAACC
        AACCAACCAACDAACDAACDAACDAgKEAACDAACDICCONzaWAACCAACCAACCAACCAACCAACBAACBAACBAACB
        AACBDg6Fm5q5y8nJzcrK0M3NzcvLwb29wb29////////////////////////////////////////////
        sK6usK6u0M7O0c7O0c/O0c/Q0dDQ0c/Q0tDQ0s/Q08/Q0tDQ09HR0tDR1dPT1dPT09HR1dPT2NbX2NXV
        1tPT1NPT09HR2NXV19bW1NLT1tTU2dfX2NfX1tXW1tTU2NTV2dfY3Nvb4N/f4N7f3dzc3Nrb////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////q6mprKuqrKqrrausrqurrKqqq6mpq6mpq6mpq6iorKqprqys
        rq2uraurp6WkmJaWiYeGe3d2e3d2eHV1eHV1end2end3end3end2e3d3fXl5fnp6fnt7fnx8fXx8fHl5
        fnx7gH9+fnt7fXp6fnt6f317fXt7f319gn9+g4B/goB/gn9+g359hYB/hYGBhIGBhoKCh4ODhoKCh4OD
        iYaGhYKCg4CAh4SEioeGhoOCh4KDhoSEhYODiYaFjImJjYqKjImJjouLjoyLiYeHjImJkY2Nk5GRk5KR
        kY2NkY2NlJOTlJGRlJCQlpSUmJaVlJKSlZKSl5SVmJaWmJSVnJmZm5mZnJmZnZqam5mampeYnJqanJqa
        nJqanZubnZucnpqbnpubn5ycn5ydn5ydn52doJ6en52doZ+foaCgoZ+foZ6eoZ+hop+ho6CgpKGho6Ch
        pKGhpaOjpqSkpqOkpqSlpqWkpqSkp6SlqKWlp6Skqaamq6ipqaenqqenq6mpraysq6qqqKamp6Ojqaam
        rKqqraurr6ytr62tsK+vr62uraqqrqmqsa6vsq+ws7GxtLOzt7W1t7S1tbKys7Cwsa+vs7Gxs7GxtLOy
        tLOzt7a2uri4uba2uri4mJeucHChQUCRFBSCBAR9CgqAAAB8AAB8AAB9AAB9AAB9AAB9AAB+AAB+AAB+
        AAB+AAB/AAB/AAB/AAB/AACAAACAAACAAACAAACAAACBAACBAACBAACBAACCAACCAACCAACCAACCAACC
        AACDAACDAACDAACDAACDAACDAACDAACDAACDAACCAACCAACCAACCAACCAACBAACBAACBAACBIB+MqKW8
        zMnJzcvM0M7Owb6+nZqb////////////////////////////////////////////0tDQysfIzMrL0M7O
        0tDR0tDR0tDQ09DQ0tDQ0c7O0s/P09HR0tDQ0tDQ1NHR1NPT1NPT1NLT1NLT1NHR1dLS1tTU1dTT1tTT
        2NbW19XV19XV19TV2NbX2NbW1tTU1dPT19bW29va4N7e4N7e3dvc3dvc////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////rausrqurrKqqqqmpqainqqioqqioq6ioqqeoq6qqrayrrq2srq2r
        rKqqqKWlmpeXiYeHe3d3end2enZ2eXd3eXd3eXZ1eXZ2eHV2dXR1d3Z3eHd3eXZ2eHZ2eHZ2eHh2e3l4
        fHp6fnt7f3t7fnp6fXt6fHp7fnx9f3t7hn58iYB9hX9+goB/hoKCh4SEh4SEhoODh4SFiIaGgoB/f3x8
        hICAh4WDhIGBhYKChoKCioaFi4iHioeHjIiIjIqJjYqKi4qJjYuKkI2NkI6PkI6Ok5CPkpCQk5CQlZOT
        kpCPko6PlZKTl5WVlpSUmJSUl5SUlpOTl5OUmJaXmpiYmpeYmJaWmpeXm5eYnJmam5aYm5iYmpmYnJmZ
        npqan5ybnpucnZqbn5ydoJ2eoJ2eoJ2doJ6eoJ6eoJ6eoJ6eoqCgo6Gho6ChpKOjpaSkpaOjo6Cho6Ch
        paKjpaKio6Cgp6Slqaanp6Wlp6WmqKanp6Wlqaamqqipq6mqq6mpqaamqaamqaenqqioq6iprqytr62u
        rausrKqrrKmqrqurr6ytsK2tsK6usrCwtbKzt7S1s7Gxsq6vtLCxtbOztrOztbS0tLOztLKytrO0trOz
        t7W1uri5u7q7uri6lpaubm6haWifOjmPHByFCQl/AAB9AAB9AAB9AAB9AAB+AAB+AAB+AAB+AAB/AAB/
        AAB/AAB/AAB/AACAAACAAACAAACAAACBAACBAACBAACBAACBAACCAACCAACCAACCAACCAACDAACDAACD
        AACDAACDAACDAACDAACDAACDAACCAACCAACCAACCAACCAACBAACBAACBAACBJCSOxMLFy8nJzczMxMLC
        nZqbnZqb////////////////////////////////////0tDQ0tDQz83NzMrKz87O0c7Q0c7P0MzN0s7O
        1NDQ0s/Q0tDQ0tDQ0c7P0s/Q09HR09HR1NHS1NLS09DQ0c7O0s/P1dHS1tPT1dTT1tTU19XU19XV19TV
        2NbW2NbW1dTU1tPT2NbW2djY29ra3Nvb2dfX2dfX////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////qqmpqainqqiorKqqrKqpq6inq6iorKqqrqyrraysraurrqysr62trqys
        qKammZaWh4SFenZ2end2dXNzeXZ1eXZ2c3FydHN0e3l5end3d3R0dnR0e3h3enh3eXh4enh5fHp6fHl5
        eHV1dnR1dnN0fHh5hX59hn57gXt6gX5+g4CAhIKCg4CAg39+gH19g4GBgoB/e3h3fnp6hICBhYKBhoOB
        iISEi4eGioeHioeHi4iHioeHh4WFhIODiYeGj4yMjYqLj4yNlJGRk5GRko+Qk5KSkpCPkY6OlJGSlZKT
        lZKSlZKSlJCRk5CQlZKTlpOUmJSVmJWUmJWVmJSVmZaWmJaWmZWWmpeXm5iYnJmZnZqanZqanJmZnJqa
        npybn5ydnpubnpubn52cop+foZ2en5ycn52co6CgoZ+foqGhpqSkpKKjoqGio6KhpKKho6ChpaKjpqOk
        p6WlpqWlp6amp6Wlp6Slp6Wlp6Wmp6Wmqaemqaenqaanqqioq6enrKmqrKurrKqqq6ipraurrq2traus
        r62tsK+vsa+vsq+wtLKztLKysq6vsa2utLGytrO0t7W1tLKzsq6vsq+utbOyuLa1trS0uLa2ube4t7W2
        ube3u7i4ure4pqOxjoupY2KcNzeOGRmFCgqAAAB9AAB9AAB9AAB+AAB+AAB+AAB+AAB/AAB/AAB/AAB/
        AACAAACAAACAAACAAACAAACBAACBAACBAACBAACCAACCAACCAACCAACCAACCAACDAACDAACDAACDAACD
        AACDAACDAACDAACCAACCAACCAACCAACCAACCAACBAACBAACBWVifv73Czs3NzszMuri5oqCg////////
        ////////////////////////////zs3Nzs3NzszMz83Nzs3N0M3Pz8zNz8vL0s/P09DQ0c3O0c7P09DQ
        09HR0tDQ0s/Q1NHR09LS1NLS0s/PzszL0M3N09DQ1NLS1tTU19TV19TU19TU1NLR1NLR1tXU19bW2dfX
        2dbW1tTU1dPU1tPT2dfX////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////rKqqrKqpq6inrayrrqurr62trq2trqysr62tsK6urayrrKiqq6mpq6qqpqOi
        l5SUhYODfHh2gXt4e3d1eHV1eXZ2eHZ2eHV1e3h3e3h4e3l4enh3e3h4enh4end4enh4fHl5enZ2eHZ2
        e3h4fnt6gX5+g3+Agn9/f3x8f3t7gXx6end2fXt7gH59f3x8gH19gH19g399h4OBh4KCh4SEiIWFi4iI
        jIqKiYaGg4CAhIGCiYeIjIuLjouLjoyMkI6OkY6Oko6PkI6OkI6OkY2Nko6Oko+Pk5GQlJGRlZGSlpOU
        lpOTlZKSlJKRlZSTlpOTl5SUl5WVl5WVlpWVmZeXmpeYmpiYmpiXm5mYnJqZnZubnJqbm5iZmpaWnJmY
        n5ycoZ6eoZ6eoJ2doJ2cop+foJ2eoZ2fop+goZ+foqGho6GhoZ+fo6GhpqSlpaOkpKKipaSkpaSkp6Sl
        pqWlp6Wmp6Wlp6WlqaenqKanqKWlqaamq6mpq6mqq6mpqqeorqusr62trq2trq2usK6vsa+vsK6usK6w
        sa+vsK+ur62tsq+wtbOztrO1tLKzs7Cxsa+vsa+utbKyuLa2uba3t7W1trOztbKzt7W1urm4urm5u7m5
        ure3trO3pqS0i4mrc3GiYmGeMDCNCgqAAAB9AAB+AAB+AAB+AAB+AAB/AAB/AAB/AAB/AAB/AACAAACA
        AACAAACAAACBAACBAACBAACBAACBAACCAACCAACCAACCAACCAACDAACDAACDAACDAACDAACDAACDAACD
        AACDAACCAACCAACCAACCAACCAACBCAiEXV2gvLm/yMbH0M/OxsTEoqCgpKGh////////////////////
        ////////////ysjHz83NzsvLzsvMzszM0M/Pz83NzcvKz83N0c7P0MzNz83O0s/P09DQ0c7Oz83N0c7P
        0tDQ0s/P0s/Q09DQ1NLR1NLS1tTU19TU1tPS1dPT19XV1dPT1NPT19bV2NbV1tTT1dLS09HS0tHR1NHR
        1NHR////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////rayrrqurr62trqyssK2tsK2tsK2ur66trqysrKqqraqprauqr62tsK6uqKalmZWU
        iISDenZ2eXZ2eHZ1eXZ2eXZ2eHV1eHV1end2eXZ2eHV1eHV1end3fXx7fHp6enZ3e3l5fXp6fXp6gH19
        gX5+gH19gn59gXx7f3x7fHl6d3R1fXp6hYOCgn9+hYGAh4OBhoKBhYGCiIWFiYiHioiIiISEiIWFjImJ
        jYuLjIqKjoyKjYuKi4mKjouMj42MjouLjouMkI2NkIyMkY6OkY+Pko+PlJGRlJKTlpOUlpOTlZOTkpCQ
        ko+PlZKSl5WVlpOUlpSUl5SVmJaXmZeXmpeXmZeWm5mYnJiYnJiZnJqanJqZnpmZnpqbnZqbn5ycoJ6d
        n5ycn5ydoZ2eop+goJ6foJ6eoZ+goZ6fn52doZ6epaKjo6KjpKOjpKGho6ChpaOjpqWlpqSlpaOkpqOk
        qKanqKanqKamqaamqKamqaeoqqenq6mprKusraurrauqrausraqrrqurrqytrqytrq2sr66usK+wsK6v
        s7Cxs7Gys7Gys7Gys7GxtLKytbO0trS1t7S1tbSztLGxtrKzuLa3urm5urm6uri5uba3t7a2ube3u7m5
        t7a5vbu8sK63hYSoYWGdQECTDAyBAAB+AAB+AgJ/AAB+AAB/AAB/AAB/AAB/AACAAACAAACAAACAAACA
        AACBAACBAACBAACBAACCAACCAACCAACCAACCAACCAACDAACDAACDAACDAACDAACDAACDAACDAACCAACC
        AACCAACCAACCHh2MkI6yx8PEyMbGy8rLycfIvbq6pKGhxcLCuLW2oJ6e////////r62twLu9yMXFysjH
        0c/Pz8zNzcnKzsvLz83NzszMzcrKzsvL0M3N0c/P0M7P0M3Nz8vM0MzNzszMz83N0c3O0M7O0c/Q1NDS
        1NHR0tHQ1NPS1NHS0s7P0tDQ1dTV19XW19XV19TU09HQ0c7O0s/Q0dDQ0dDQ1NLT1NLT////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////rqyssK2tsK2tsa+vsa+vsK+vr62tsK2tr62sr6ysr62tr62tsK6usa+vp6SklpSThIKB
        dnR0eHV2d3R0d3Nzd3R0eXZ1dnNydnJyeHR0e3l5e3l5e3h4fHl5fHh4fHh3fnx7gX5+f319gH19gHx8
        g4B/gH18dnJzdXFyfXt7goB/g4CBhIGCg4GBgoCAhIGBhoSEh4SEiYaFi4qJjIqKioiIjIqKjoyMjYqK
        jImKjYuLjYyLjIqJjouKjouMj4yNkY6OkY+OkI6Oj42NkY6Pk5KRk5GRk5CRko+PkY6OlpKSlpSUlZKT
        lZKTlpSVlZOUl5SVmJWWmJWVmJWVmZWWmpaWnJqanJuanZqanpubnJqanJmanpqanZqbnJman52eoJ+f
        oJ6eoJ2doZ6foJ+fnpycnpyco6ChpaOko6Giop+gop+fo6Gho6ChpKGjpqOjp6OkpaOkpqSmqaeoqaio
        p6alpqSjqKamqaioqaioqaeoq6mpqqepqqanrqytr62uraurraursK6vsrCxsK6urqyssa6usrCwtLKz
        tbO0tbS0tLOzsrGysa+wsa+vs7Gxt7S0uLe3uLa3uLW3t7S1t7O1t7S1trS0uLW1ure4vLq6vLq7ure5
        vLm6vLu7sa62enijUlGYOTiRCAiBDAyCBQWBAAB/AAB/AAB/AAB/AACAAACAAACAAACAAACBAACBAACB
        AACBAACBAACCAACCAACCAACCAACCAACDAACDAACDAACDAACDAACDAACDAACDAACDAACCAACCAACCPDuW
        sK++ycbHysjIysjIzcvMzMnKyMXGxcLCuLW2oJ6ex8fGwcDAr62twLu9yMXFysnJzcvLzMrKy8nJzcrK
        zcrLzsrLzsvMz83Oz83Nzs3Mz83Nz8zMzcvLzsvLzszMz87N0c/P0s/P0c/P0c7P0MzOzcvMz83N0M7O
        z8zMzsvM0tDQ1NPS1dLT09DR0M3O0tDQ0tHR0c7O0M3O1NLT////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////sa+vsa+vsK6usbCws7GxsK6tr6ysr6ysr6usr6yrsK2tsq+wtLGxs7GxpqSjk5CQhIGBeHZ1
        eXZ2eHZ1dnR0dnNze3d3end3eHV1eHZ1eXZ2fXl4f3x6f3x8gH1+fXp6end3f3x8gH59gn9+f3x8dnNz
        dHFxgH19f319gHx9gH9/e3l6fnt7hIGBg4CAgn9+hIKBh4WFiIaGiYeIiomKioiJjYuKjouLjIqKjImJ
        jYqKj4yNjouMj4yLj42NkI+QkI6OkY6OkI+NjoyMkIyNko+PkpCQlJGRlpOTlJKRlZKSlJKSlJKTlZKS
        lZOTlZKSlpOTmJWVmJWVmpeXmZeXmZiYm5qanJmanJiYnJiYm5mZmpiYnZucn56enpycn5ucn5ydnp2d
        nJqanp2coqGipKKjop+foZ+goqChoZ6eoZ+fo6Ghp6SkqKSjpqSlpKOko6KjpaOlp6WlpaOipaOkqKen
        qKWmqaanq6mqrKqqq6iprKusrKurrqurrqysr62usK2trqysrKqrrqusr6ytsa+us7GxsrCwsrGxs7Gy
        sa+vsK2usq+wtLOztLOytbOztrS1trOztbGyt7S1trO0trS0ura3u7q6vLy8u7m6ure4vLm5vbu7vr28
        vry7srG3iYiqc3KkXFucLS2NKCiMBweBAAB/AAB/AACAAACAAACAAACAAACAAACBAACBAACBAACBAACC
        AACCAACCAACCAACCAACCAACDAACDAACDAACDAACDAACDAACDAACDAACCCAiFbWyoxcTGycbHyMfHy8jH
        y8fIzMrLzszN0c7OzsvMzMrKx8fGwcDAxMHCzcnKz83NzMrLycbGy8nIysnJy8rKzMnJzMrJzczLz83N
        zsvMzMnKzcvKz8zMzszLzcvKzMrKzcvLz83N0c/P0c7OzszMzcvLzcvLz8zMz83M0M7N0M3N0M3N0M7O
        0c/P0c/P0M/P0dDQ0c/Pz8zM0c3O0c3O////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        sK6usbCws7Gxsa+vrqyrrauqrqyrrqusraqrr6yss7CwtbOztLGysK2urqurpKGglJGRgn+AeHV1eXZ2
        eXd3eHZ2eHZ1eXZ2eXZ2fXp5fXp6fXl6fnt7fXp5fHl4fnx7gH19gX5+goGAfHp6eHV1fHl5fHl5fnp6
        gH59end4e3d4gX59f319fXp7fXl5h4SDiYaGh4SFhoSFioiIi4mJjIiIjYqKjIqKjouMjo2NjYuKjImJ
        j4yNj46PkI6Oj42MjoyLj4yMkIyNkIyNkY6OkZGQk5GRk5CQko+OkpCPlJKSlpOTlZKSlJKRlZKRl5SU
        lpOTl5WVmZaWl5WVmJaWm5iZmpiYmpeXm5iYnJmanZycnZqanJmZnJmanJqampeYmpaWnpuboqGhoqCg
        op+fop+goZ6goZ6foaCfo6Gio6GipqKjqKWmpaOjoJ6eoqChpaOkpaOkpaOjpqSkqKamqaaoq6mprKqp
        q6mpqKanq6epraqrrKurqqipq6iorKmpraurrausq6mqrKinrquqr6ytsa6vtLKys7Gys7Cxs7Gxs7Cx
        srCwtLOzt7W2trO0tLKytbOzt7S1t7W2uLW3urm5u7q6urm4uLa2uba3ure4vbq7vbu6ure3uLa3u7m5
        t7S5oJ6zqKW1hIOpZGOfPDySCgqCBgaBAQGABASBAACAAACAAACBAACBAACBAACBAACBAACCAACCAACC
        AACCAACCAACDAACDAACDAACDAACDAACDAACDAACDHx+Ol5e3y8nJysfIycfIycbGy8jHysfIy8nKzMnJ
        zMvL0M7O0tDQz83Nz83Nzs3MzMvKzMnKzsrKzcrJysfIysfHy8nJy8nJzMrJy8jIzMnJzszMzszLzcrK
        zcvKzszMy8rKy8jJzsrKz8zLzsvLzcrKzczLz83Nz83Mz8zM0tDP0tDP0M3NzszN0M7O0M7Oz83N0M3N
        0M7O0M3N0c/O0c/O////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////sa+v
        rqyrrauqraurrqysrqysrqysr66utLGxtLKysrGxsa+vsK6usKytr62top+fjoyLgH59eXZ2enh3eXd2
        eXZ2e3l4fXp6e3h4fHh4fHp5fnx8fXp6fnt7gH19gH19f319fHt6eXd2eXZ2fXt6hIF/gn9+fXp6fXl6
        gX59goCAfXx8goB/h4WFh4SDiISEioiIioeIiYaHjYqKjYqKi4iJjIqKi4qJjImJjImKjYqLjYuKjoyL
        jouLj4yNjYuLj4yMkpCPkpGQkI6Pj42Nko+Pko+Pk5CQk5CQlJGRlZGRl5WUl5SVlZOTmJSVmZaXl5ST
        lZKSmZaXmpiYmpiYm5eYnJmam5mampeXmpaWmpiZmpiYm5iYnJman52en56enZubnpuboZ2eop6fop+g
        op+goZ+goJ+goqCipKKjo6Ggo6GhpKKjpaOkpqWmpKKio6CgpKKip6amp6amqaamqqenqaenqaanqqeo
        qaanqaamqKWlqqeorausrq2trKurqqSkraensK6usa+wsK6vs7Gxs7KytLOztbOztLGxs7GxtLKztbOz
        s7Kxsq+utLGxt7W2trO0t7S1uLa2uLa2uLa2t7S0uLW1ura3u7m5ubi4ubi4u7m6vLm5u7i5u7m6ubi5
        u7m6vLq6rau3iIWqXFubU1KZLy+PJSSMBQWCAACAAACBAQGBAACBAACBAACCAACCAACCAACCAACCAACC
        AACDAACDAACDAACDAACDAACDQUCZsrC/ycfIysjJycjJycjIysrJysjIycfHy8nJy8rKy8nKysjIzMrK
        z83OzczMy8jJy8jJzMnJysjHysjHy8fHysjIysfIysfHysfGzMnJzszLzMrKzcvKz8zMz8zMzcrKzMnK
        zsrKzsrKzcvKzsvLzcvLzMvKzcrLzcrLzszMzszMzsvLzcvLzsvMzcvLzcnK0c7O09HR0M/P0c/O////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////raurrqys
        rqyssa+vr62trauqrqyssa+vs7KytLKysq6vr62traqqqqinq6iooJ2dkI2Nf319eHd3fHp6fHl5e3h4
        e3l4fXp6e3h5end4fHp6f318gX5+fXt6eXd3e3l4fXp6fXl5gHx8gX5+goCAgn5/fHl6dnV1eHd2gH59
        hYKChoODhoODiIWFiIWFiYaHioiIi4iIiIeHiYiIi4eIi4iJi4mIioiGjImIjImJjoyMjYqLjImJjYqK
        kY6OkI2NjoqLj4yMkY+PkI+Pj4yMj4yLkI6NlJGSlpOUl5WWlpSVlZOTlZKSlZKSlZOTl5SVl5SVl5WV
        mJaWmZeXmZeWmZaWmJaXmZiXm5iYnJmZnpydnZucnJmZnJmanpydnpycn52eoJ6fop+hoZ+goZ+gn52e
        n52doaCgo6Gho6Gio6GipaSloqCgoqCgpKGhpKOipKOjpqOkqKWlqKamp6WlpqOjqqenqqioqaenq6ip
        raysrayrrKqqrKmpraqqsa+vsa+vr62usK6usK6vsa+vs7Kxr62tr6uss7GytbS1s7Gysq+vsq6vtbOz
        trO0trO0trO0trOzuLW2t7S1trS0ube3uri4ube3uba3u7i5trW0sa+vtrS1u7m6uri5uba2ure4ure4
        ure3srC2oZ6yop+yhYSqdnWmOjmTKSmOExOHFxaIBQSCAACBAACCAACCAACCAACCAACCAACDAACDAACD
        AACDCAiGcXCpxMLEx8XGx8XGx8XFyMfHysnJyMbHx8XGysjJycjJyMbHycbHycbHzMrKysjIycbFyMfG
        x8XFx8XFysjHy8nIyMbFyMXEysbGycfHysjIy8nJysfIzcrKzsvMzMnJysjIy8jIzMjGzMnIzcvMzcvL
        y8nIycfGy8jJysjJy8nJzMrKzMnKy8nJzMrKy8nJzMjJ0M7O0M/OzMvLzMvL////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////sa+vr62trauq
        qqenraursK2tsrCwtLGytLGyr62sq6iorKqpsK2tsq+vsq+wop+fkY+Pfnx8eHZ0e3l4fXp6end3eHV1
        eXR1e3h5e3l5d3NzeHR0gX9/gX9+gHx8fXl5f3t7gX5+enl5b25ubm1sdXJygH58hIGBhoSEh4WEhYKC
        hYODh4WFh4WFhoODiYaGi4iIi4mJiYiIiYaGioaGioeIioiJioiJi4iIjYqKjoyMjoyMjouLjYmJj4uM
        kI6Oj42MjouKjoyLkY+Oko+Pk4+Qk5GRlZOTk5GQko+Pk5GQl5SUmJSVlZOTlpSVmJWWmJWVlpSTl5SU
        lpSVl5WWmZaWm5iYm5qanZqbnJmanZubnp2dn5ydnZubnJucnZucnpydnpycnpucn5ydoZ+foqCgoZ+f
        oZ+foJ+goqChoqCho6GhpKKipKKjpKKjpKKipqSjpqSlpqOkp6Slqqioqqioq6ipq6mqrKqrq6qqq6mp
        qqenq6iorKqqrq2tsK6urqusrKuqrKysrqysramqr62ts7Gys7Cys7GxsrCws7GxtLKztrS0tbOztrO0
        trOztbKztrOzure3uri4uLa2uLW2uLa2trS0s7Gxt7a2ubi4uLW1t7W1ube2vLm5vLm6vLq7vbq7vbq6
        u7m6vru8vru8rqu1kI6thoOrcG+lWFeeOTiTBASDBweEDQ2GBASDAACCAACCAACDAACDHByMmJe0xcLD
        xsTFxcPEwsHBx8XFyMXGyMXGyMbHyMXGyMXGyMbGycbGycbHysjJysfIycfGycjIyMbHx8XGycfGycbG
        xsPExcLCycbGysjJysjIy8nKzMrKzcvLz83NysjJyMXGysfGysbFycbGysjJysjIysjHzcnJzMnKysnK
        zszMz8zMzcvLzMrJzcvLzMnJy8jIzMnKzMnJzMvL////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////qqenraursK2trqyr
        sbCvtLOysrKysbCwsrCvs7Cxsa+wsa+vs7CxtLKysrCxop+gkY+PgH9+enh3fHd4eXZ2eHZ1eHZ2eHV1
        eHR1fXp6gH59gH59fnx8fXl5e3h4c3FycW5veXZ1fXl5gHx8g4CAhoODhoOChYKChYKDhoODhIGAhYGC
        hoOEh4WEh4WEiIWFiYWGiIWFiIWFiYiHioeHiYaHjIqLjoyMj4yMjYuLjYqKjoqLj4yOj4uLj42LkI6O
        kY+QkpCQkY6PkY6OkY2Ok5GRkpCQkpCPlZKSmJaWl5SVlpWVlpOTlZKTlZKSlpOTlZSVlpSVmJWWmJaW
        mpiYmJaWmJaWm5iZoJ6enpycm5mZm5manZucnZqbnZqbnZubnpucn52doJ6foaCgoZ+foJ+foZ+goZ+g
        o6GhpaOko6GipKGipaKjp6Wlp6ampaOkpqWlqaioqqipqKeoqqqqq6mqq6ipqaenqKSjp6GhqaWmrKur
        rq2trqysrKqpraursK6ur6yurqussrCwsrCxsa+wsa6vsq+vs7GxtLOztrS0tbOztLKys7Gyt7S0uLW1
        uLe3ube3uLe2trS0t7O0ura3uri4t7a2t7S1uLS0uLa1uri5vbq8vLq6u7m6u7i5vLu6vLy7vru8vbu7
        vby8vby8uba5v7y8wL6+sK27ioitcnGlXVyfWVieNzaTBQWECAiFR0aasK28xMHCxMHCxcLDxMHCxcLC
        xcPDxsXFyMfIx8XGyMbGysjIyMbGyMbHysjJycbIysfIysnJycfGxsLCxsPDxsPDx8TEy8fIzcvMzc3M
        y8rJzMnJzMjJysjIzMrJycbGxsPEysbFzsrGzMjHysfIy8jJzMnJzMrKzMrJysnJzcvM0M7O0M/OzMrK
        y8fHzMnJzcrJzMrKzMrKzMrK////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////rqyrsbCvtLOysrGxtLOz
        tLOys7Gxsa+vsa6vtLKytLKzsrGxsa+us7Kxs7GxoZ+fjouMfHt6end1fHl4end3d3R0d3R0end3eXV1
        fHl5fnt7eXd2d3R0fHh5hIB/g4CAgX5/gn+Ag4CAg39+g4GAhYODhYKCg4B/g39/hIGBhICAhYKChoSE
        h4WFiIaGioaHiYaGiIaFioiHiYiIioiIjYqLjoyMjYuLjouMjYqKjImKjYyNj42Oj4yNkI6PkI+PkI2N
        kY6Pk5CRk5CRkY6Ok5KRlJOTko+QkpGRlZOTlJKSlZGRlpOUlpWWlpWVl5WVmpiYmZeXlZOTlI+Qm5eY
        nJqbmZeXmpeXnpucnZucnJubnJqbnZubnZubnZucnJucnZucnpydoZ+go6ChoZ+goaCgo6GhoqChoZ6f
        pKGipaOjpqSkp6Wmqaioqqipp6anpaWkqKamqaenqKSlqKWkp6KhqKOhqqemrKqrrKqrraurrKqqrKqq
        rq2trqytr6ytsK+ur62trqqrsK2usK6usa+vs7CxtbO0tbS0tbO0tLOztLKztbOztLGytbOztbS0tbOz
        trO0t7W2uLa2t7W2uLW2t7S1tbKytrOzuba3ube3ube3uba2ure3u7q7vLu7vLq7vry8vby7vbq7v7y8
        vry8vbq7v7y9vry8t7W6wsC/wb6+rqu5jIqvmZezw8HCxMLCxMLCw8DBxMLDxMLCxMHBw8HCxcTFx8XF
        yMXGycjIyMfHyMbGyMbHyMfIycfIy8jJycfGxMLCw8DBxcPDx8TEycfIzMvKzMvKy8rJysfHyMXGx8XF
        ysjIyMXFxcLEy8fH0s7HzcrFxsTGy8jJy8jJysjIysfHyMbFysfHy8nJzMvLysfHx8TEycfGzMrKzcrL
        zszMzszM////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////srGxtLOztLOysq+wsrCws7Gx
        tbS0tLKzsq+wsq+vs7GxtLOztLK0tbK0srGxoJ6ekIyMfXp5eXZ1d3V0d3JzeHJye3d2fXt6fXx7fnx7
        gX19gX19g4CAgn9/goCBgoCAg4CAgn9/gn9/hIKBhIGAhICBhICAhoOCh4SFhoOEhYKCh4aGiIWHh4OE
        iIaFioeHiIWFhoSFiIaGi4iIjImJi4mJjImJjIqKjYuMjImKjImJjYuLjYyMjImKjouMkY6OkZCPkY+Q
        kY6PkI6Oj4yNkY2OkpCQlJKTlJGRlZKSlZOTlZOTl5WVl5aVlpWUlpKSmJOUmpeXmZeYl5SVmpiXm5qa
        m5mbmZiZm5manJmanJubnZycnJmam5iZnZuboJ6fop+goJ6fn56eo6Kho6GhoZ+eoqCgo6GhpKGipKGi
        paKjqKSmp6anp6Wlp6SlpqSkp6Wkp6Sjp6Oip6Sjqqenq6mqrKqqq6mpqqioqqeprKurra2srausraur
        rKmprqqrrqysr62tsK2usrCxsrGxsrKytLGys7Gxs7Kys7Gxs7Cws7GwtLKytLGys7GxsrCxs7GxtrS1
        trS1trS0tbKytrOytrS0t7W1t7W1trS0trO0t7W2urm5u7i4u7e4u7i4vbq7wL2+vbu7u7i4vbu8v72+
        vru8wL6+wsHAwr/Awr/Awr/AwcDBwsLCw8LCwsDBwsHBw8HCw7/BxMHDw8HCxMLCx8TFyMbHx8bGxsTE
        x8XFyMfHx8XGx8TGxcPEw8HBxcLCx8TFx8bFxcTDxsPDx8XFyMfGycfHyMbHysfHysjIxsPDxMLDycfH
        z8rFzcfCyMXEycbHycjHysjIycbHx8XEycbGycfHx8XGx8XFycfGyMbGy8jIy8jIzszM////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////sq+wsrCws7GxtbSztLKys7CxtbKz
        tLGxs7GwtbKytrOztrS0tLKytbKysa6un5ycjYiIenZ2fHl4fXp5end3e3h3fnt6f3x7fHp6fXt6gH18
        gX59hICAhIGCg4CBg39+g4GAg39/hICAhIGBhoWEiIaGhYKDhYKChoOEhYKDhIGBhYODhYKCh4ODiYWF
        iIaGiIWFiISEiIWFi4iJjYyNjIqKi4mIi4iIjYmJjYqKjIiJjIiJj4yMkpCQkY+PjouMjouMk5CQkY2N
        kIyNkpCRk5KSkY6PkY6Ok5CQlZKSlJOSlJKRlpOUmZeYmZiYmJWVmJWWl5WWl5eXmZiYmZeXmJWWmpeY
        m5manZubnJqanZqan5ydnpydnpucn5ydoJ+foqCgpKGho6Ggop+foZ6fo6Gho6Chop+go6ChpaSkpqSl
        p6WlqKWlqKamp6WlpKKipaOjp6Slqaanqaenqqeoqqioq6iprKqqrKurrKmqrKmprKurraurraqqraqq
        rqytrq2tsK6usK6usK2tsa6vsrCws7Cwsq+ws7KxtLKytLKysrCwsrCwsq+wtbKztrS1tbO0tbOztbOy
        trS0t7a2uLa2trS1tbO0trS0ube3ure4t7S1uLa3vLm6v729vr29vry8vry9vLq7vLm6vry+wL/AwL6+
        wL6/wL6/v7y+wL6/wsDBwsHBwsDBwsDBw8DBxcPExMLCwb/AxMLDxcPExcPExsTFx8TFx8XFxsPExMHC
        w8DBxMHBx8TEx8XGxcPExcLCxcLDx8XFx8XFx8XFx8bGyMbGx8TDxMHBx8XEyMjIycXGzMbEz8rGysfH
        ysfIy8rJysjIyMbGysnJy8jJyMXFycbGysjIycbHysfGycfGycfG////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////tbSztLKys7CxtbOzs7CxsrCvs7GwtLGy
        trOzt7S0trS0trSztrO0trO1rqqrnZqajImJend2d3R0enZ2fXp6fHl5enh3fXp6gHx6gn16gn5+gn9/
        hIGAhYKCg3+AgX9+goCAg4GBhIODhYODhoKDh4KDg4CBg4GBg4GAhIGAhYKBiYWFiIaFh4SFiIWGiYaG
        iYeHiYiIi4mJi4mIioiIioaHjoqKkI2Nj4yNkI2OkY6PkI6OjoyMkIyNk5CQk5CPkI2OkI6OkY+Pko6Q
        kY+PkpCQkY+QkpCRlJKSlJGTl5WWmJWWl5OUlpOTlpSVl5WVmZeXmJaWl5WUmJeXnJmbm5iam5mZm5mZ
        nJqbm5iZnpucoZ6foJ2en5ucoZ+eoqGhoJ2eoJ6eoqGgpqSko6GioJ+eoqCgpKKio6GhpqKjqKanp6an
        pqWkpqSjqKamqaWmqaanqKanqaenqaamqaanq6iprKmqrKqqrKqqq6mpq6moraqrraqpraqqr6yssK6u
        sK2tsa+wsa6usa6usK2usa+vsrGxsrGxs7GytLKztLKztLOytrS1s7KzsrCwsrCwtrO0ube3ube4t7S2
        trS1ube3uba3t7S2trW1uLa2ure3u7m6vry8vru9vLq7u7i4u7m5vry8vbq8vbu8vby9vru8u7i5vLm7
        wL6+wb+/wb/AwsDBwsDBxMLCw8LCwsDBw8DCxMLDxMLDxcPExcLDxcPExcTDxMLCxsPDx8XFxsXFxcTE
        xMDBxMHBxsTDyMbFyMTFxsLDxMPCw8LBxMHBxsLCyMfGysnJycfIy8jIy8nHysfHycbHycjIysjIycfH
        ycfHycbGycXFysfHyMfHyMXFysfHysjIysjI////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////tbOzs7CxsrCvtbGytLKytrKyuLa2t7a3trS0
        t7S0trOztbGytbOzt7W1sq+vn5yci4iIe3h3f3t7fnt6fXt7fXl5fnp5f3t7f3t8gH19g4CBgn+Agn9/
        goCAg4GCg4CBg4GAhIGBhICBg4GAg4CAhoKChoOChoSEhoSEhYSEhoSEiIaGhoSEhoODhoSDiIeHiomJ
        iIeHiYaHjIiJjoyMj46OkI+Qj46OkI2NkI2OjoyMj42NkpCQkpCQj42MkY6Pko+RkY+Pj46NkY+Qko+Q
        kpCQkpCQlJGRlZKTlZKTlpSUlpSUmJSUmJWWl5WWlpSUmJeXmpeYmZeXl5eWmZiYmZaWmpeXnZucoJ2e
        oJydnpycn52en56en52doZ+foaCgoJ6eoJ6eoJ6eo6ChoqGhoZ+fo6Cgp6Wmp6Wmp6amqaenqKamp6Wl
        qKamqKanp6Wlp6WmqKWmqaenqaeoq6mpqqmoqqioraqqraurraqprqqqr6ysr62tsK2usK2usK2tsK6u
        sK6ur6ytsK6vsK6vsK+vtLKysrGxsrGxs7Gxs7GxsrCxtLGytLKzt7W2t7W2trS1t7S1uba3t7W2trS1
        ube4ube4t7S0uLW0u7m5u7q6uLa3uri4vbu7vLm6u7i4u7m5vbq6vLq6ure4ube3vLm5vru8wL2+wb+/
        wL6/w8DBw8PDwsHCwr/Bw8HCwsHBwsDAxMLBwsDAwsHBw8HBx8TFycfHxcPExMLCxMLDxMLCxcLBxcPC
        xsTFxsPDxMDBxcPDx8XGxsTExsTEycXGy8fGxsXFxcTGx8TFx8XFxsTEx8XEyMbGx8TFxsPDyMXEysjH
        yMfGyMbFy8jJysjI////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////tbGytLKytrKyt7O0trO0tLKztrSztrWzt7W1t7a2
        uba2uLa3uba1t7S0rqysnpubjYmJfXp7fHl5fXp6f319f319f319gH19gHx9fnt8gX5+hYKChIGBgX19
        gH19gX5+goB/g4CAhICBhYODhoSEhoOEhIKChYSEhIKCgn9/hICAhIKAhoOCiYaHi4mJiYeIiIaGioiI
        jo2Njo2OjIqKi4iIjImKjYuLjoyMj42Nj42Nj42Mj4yMj4yOj4yMj4yMkI6Ok5CQkpCRk5GRk5CQk5CQ
        k5CRlZKTlpOUl5SUl5WWlpSVlZOUlpOTl5SVlpWVl5WWl5SUmZaWmZaWmpmYm5iZnZqbnpycnp2enpyd
        npucnZycnZubnJiZnpuboqGhpKOkpKOjo6Gio6GipKOkpaSkpaSkpqOlpKCio6CgpaOkp6SlpqSlp6Wm
        p6WmpaKhpaOjqKanqaeoqaeorKmqraqqrKmpq6mpqqmprKmqramqrqurr6yssK6vr62ur6utr6ytrayr
        raqrsK2tsK6ur62tsa+vsrCxtLKztbKztbKztLKztbSztLOztbKzt7S1t7W2ube3ube4t7W2tbKztbKy
        uri3ubi3t7S0uLW2vLq6u7m5u7i4u7m5u7i4uri5u7q6vby7vbu7v7u8v7y9v729v76+v729wL6+wb6/
        w8DAwsDAwb+/wb/AwsDBwr7Awb+/wcDAwsDBxcLDxMHCxcPExsTExcLDwr+/w8C/xsXEx8bFxcPDxcPD
        xsTExcPCx8TEx8TFxMHBwr++xcLCx8PExMHCxMHCxMHBx8PEx8XFx8XFysjIy8nJycfHy8nJzcvMzcvM
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////t7O0trO0tLKzt7W0t7W1t7W1trO0t7S0t7W1uLa1uLW0
        trS0t7S1uLW1rqysm5mZioiIf31+f359fnx7f3x8fXp6e3h4fHl3gH17gX5+gH5+gH59gX5+gn9/goCA
        gX9/goCAhIGCg39/g3+AhIGChIGBg39/g39/gn9/hIGBh4SEiYaHiYaGiIWFiomJjYuLjYuLi4mIiYaG
        iIaGi4mJjIqKjYuLjouLjYyMjYqKjoqLkI2NkI6OkpCQk5CRk5GSk5GSk5CQkpCPk5GRlJKSlJKTlJKS
        lJGRlZKTlZKSlpSUlZSTlZOTlZKTl5SUmJWVl5WVmJaVmZaXmpaYnJqanZyanZucnZqbnZmZnZqan52e
        oZ+foZ+foZ+go6Cho6KioaCgoqCho6Gio6KhpKKio6ChoZ6epKGhpaOjo6GhpqOjpqSkpaOjpaOipqOj
        p6WlqKenqaioq6mpqaenqKamqqenq6moq6qpq6mqraurraqrraqqrq2sr62traqrraurr6ysr6ysr6ys
        r62tsK2usrCwtLOzs7KzsrGxs7Gxs7GytLGytbOztrS1uLa2uLe2trS1uLa2uLe4uLa2uLa1uLW1trS1
        t7a2u7m5u7i5ure4uLa3uri5vru7vry9vry9vru8v729vry8vry8vry7vry7wL6+wcDAwcC/wL+/wb+/
        wb2+wsDBw8DBwb+/wb+/wb+/w8DAw8HBxcPDxsTEw8HBw8DAxcLCxcLDwr/Awb6+wr++wsC/xMLBxsTE
        w8DBwLy8w76/xsPDxMLCxMHCxMLDxcPDyMbGyMbHysjJycfHx8TFycbHy8nKy8nK////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////tLKzt7W0t7W1t7S0tbOztrS0t7W0t7W1t7O0tbKytbOztrW0t7W1
        t7S0ubW2r6ysnJmaiYeHfnt7fXt6fXt6fXp6fXp5f3t7gHx9gH5+f3x9gX1+g4CAg4GAgoCAgn9/gH19
        gHx9gn9/g4GAhIGChYKCh4SEhoSDhYKChYKChoKChoKCiIWFioeHi4mJjIqKjImJjImJioiIioeIi4iI
        i4mJi4eJi4iIjoyLkpCQkY6PkI2Ok5CRko+Qk4+Rk5CRlJKTlJOTlZKSlJGRko+Qko6Ok5GRlZKSlpSU
        lpSVlJKSlZOSl5WVmZaXl5SVmJWWmZaXmJeXmJWVmpaWnJuanp2dnZucnpucn52eoJ+foZ6foZ2fn5yd
        nJqaoJ2eoZ6foZ6foZ6eoqCgo6GhpKGhpKKipKKjpKGipqKjpqWkpqalqKWlp6OjpqSkpqWlp6Wmqaan
        qaenqKamqainrKqqq6qpq6mqq6mrqqmpqqinrKqpq6mprKmpraysrqytsKytsK2sr6yssKytsa+vsrGx
        srGxsbCwsq+ws6+xtbOytbSztbS0tLKys7GxtLKytrW1t7e2trW1uLa2uLe3trO0tLKyuLa2uLa3uLa2
        ube3uba3u7m5vbq7vbq7vbu7vby7vbm6vLm6vry8vLm6vbq7vr29vry7v7y8wL6+wL6/v76+wL+/wL6+
        v729wL6+v72+wL6+wcDAwsDAwcC/wsDAw8DBw7/AwsC/wb6+wb6+xMHBxcLCxMLCwb6+wLy8w8DBxsTE
        xsbFxMPDw8HCxMLCx8XFx8TFxcPDxsTEx8TFycfHy8nK////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////t7S0tbOztrS0t7S0uLS0trS0trO0tbO0t7W2t7W2t7S1uLa2uba2uLW2
        tbS0rKqqm5eXioiHfHl6fHl5fXl5fnp7f3t8fnt8fXx8gH59gH5+gX5/goCAg4GBgn9/f3x8f3x8goCA
        hoOChoOEh4SEhYODhYODhIGBgn9/hIGBiIWFi4iIiYiIioiIjYqKjouLi4mKiomJiYeIioaHiYaHi4mI
        j4yMj42NkI6OkY6Qj42Nj42OkpGSk5GSk5GRko+Pko+PlJGRk5GRkpGRkpCQk4+QlZKTlZKTk5GRlZSU
        l5WVmZaWmZaXmpeXmZiXmJaWmJSUm5iYnZucnJqbmpaXmpeYm5mZnZubn5ydnZucmZaWm5iYoJ2dn52e
        oJ2eoJ2eoZ+foZ+foqCgpKKipaSkpaKjpKGhpaSkp6amqKWlpqSkpaOjpaGiqKWmqqenqainqKenq6ip
        qqioq6mqrKmqqaipqaenq6ioq6mpq6ipraqrraurrausq6qprqursa6vsK2vrqusr62ssrCwsK6vsq6v
        srCwsrCwsa+vsq+vsa+vs7KytLKztLOztrW1trO0trS0tbOztrO0trS0tbOzt7W1uLe3uLW2uLW2uri5
        u7m5u7q6vLq6vLq7vbu7vLq7u7e4vLi6vbq8u7i4vbq6vr29v76+vry8vru8v7u9wL29wb+/v72+v7y9
        wb+/wL6/wL2+wb+/w8HBwsDAwb++wb6+v729wr+/xcPDxMPDwsDAw8HBw8HBwsDAw8HBxMPCw8HBxMHC
        xsPDxsTDxcLCw7/AxMLCxMHCxMHC////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////t7S0uLS0trS0ube3uba3ube3uLe3trW1t7W1uba2uLa2t7W2ube3uLe3t7W1
        rKiom5eYiISFend3fHh4fnl6fnx7fnt7f3x8fnt7gH19goGAgoGBgH19gHx8gX5+gn9/gn+Agn9/hIKB
        hYODg4GCg4CAhYOCh4SEiIaGh4SEhIKChoSEjImJjYyMiYiIiYeHiYaGiYeGiYWFioaGi4mIjYyLjouM
        jYuMkI6OkI6PkI6PkI2NjouLjouLk5CQkY+PkI6Ok5CQk5CRk5GSk5GSkpCQk5GRlJOSlZKSl5SVmJaX
        mZeYmJeXmJaWmJWWmZaXmZaWmJWVmJWVm5iYnpucnZycm5mamZWWm5iYn52eoqGhoJ+fnpucn5ydoZ+f
        oJ2eop+fo6Kho6ChpKChpaOipqWkpaOkpaKjpaOjpqSkp6WmqaanqKWlqKWlqKWlqKamqaenqaanqKWm
        qKamqKamqqenq6mpq6mprKqqq6mpqqioq6mqrqytraqsraqrr62ssK6usK6usa+vsq+wrqurr6yssa6u
        srCwtLOztLKzs7GytLKysrCxsrCwtbKztrO0tbS0tbKztrS1t7a2uLa2ube4ube3ube4ubi5uri5ubi4
        vLu7u7q6u7m5vbu7vLq7vLi5vbq6vbu8vLu7vbq7vrq7vru7wL6+wL6/v72+v729wL29v729wL2+wr/A
        wr/AwcDAwL6/wLy9v729vru7wL6+wsDAw8HBw8HBwcC/wL29wb2+wsDAwsDAwr/AxcHBxsTExsXFxMHB
        w8DAxMHBxMHB////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////ube3uba3ube3t7W1t7W1uLa2ure4ube4uba3uba3ube3ube3ube3ure5vru6rKmp
        mJSUhoODfXp6f3t7fnt7fXt6fHp5fnt7f3x8gX5+gX5+gX1+gH5+gH5+gHx9gX19g4CAgX9/g4B/hYOD
        hoSEhYKDhYKChICBhIGBh4WFiYeGhoSEh4WFiYeHi4iHjIqKioiJiYeGiYaGioeIi4mIjouLjoyMjouL
        jouLjImJjoqLj42NjouLj4qKkpCQkpKRkpCQk5CRk5CRk5CRlJKRk5GSlJGSl5WWlpSVl5SVmJaWmZeY
        mZaXmJaVl5SUl5SUmZeXnJqbnZycm5mZm5manZubnZubnp2dn56enpycn5yeoZ6foZ6foJ+eoZ6eoJ2d
        oZ6fop+gpKGhpaKipaKjo6KipaOjpqSkpqSlp6SkpqSjpaSjpqSjqKWmp6SlqKWlp6WkpqOjp6Okqaem
        qqmpq6qqq6mqq6ioqqioqqmqraqrraqrraurr62sr66usbCwr66uraqqrqyssa+wsa+vsrCwsq+vsq+w
        srCxs7Cxsq+wsq+ws7Gxs7KztrO0t7S0t7W1t7a2uba3t7S1t7W1ubi4t7W1trS0ube4u7m5ubi4urm5
        vLq7vLm6u7m5ure4ure4vLm7vbq7vLq6vLq7vry+vbq7vLm4vbm5vry7wL++wL+/v7y9v7y9wL+/wL6+
        wL6+v7y8vrq6v7y9wb6+wb++wb++w8HAwr+/wb+/wcDAwr+/xMDAxcLCxsTExcPDxMLCxMHB////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////t7W1t7W1uLa2uLa3uLa2uLa2uLW1uba3ube3uLa2ube3uri5ure4uri3uLa2p6Wml5OT
        hoOCfnx7fHl6e3d4fnp6gH19gH59f3t8fnx8gH19gH1+gX1+gH19f318gH19g4GAg4GBgX5/gn9/hoOD
        iYaGiIWGhYKChIGBh4SEi4iJjYuLjIuMjIuLioeIiYeHioiIi4iJi4iIjIqJjYuKjYuLjouLj4yNj42O
        joqKj4yMkI2OkI6PkI6OkY6OkY6OlJGRlZOUk5KSk5GRlZKSlpOUlZKTmJWVmJaXmZiXmZeXmJWVlpOU
        lZKSl5SVmpmZm5mam5qanJqampiYmpaXnJqanZycnZqcoJyeoZ+eoqCgn52en5ycn52doZ+go6CgpKKi
        o6Kio6GhpKGipqKjpaSkpKOipKKio6GhpaKipqKjpqOkp6Wlp6Wlp6SlpqOlp6Wmqqioq6ipqqmpq6mp
        qqanq6mprKurrKmqqqioraurrKurrKurrKyrrKqqr6ytsK+vsK6ur6ytsa6usa+vsa+wsq6wsq+wsrCw
        srCws7GytbKytbKztbO0trS0trO0trO0trW1uLa2tbOztbOzuLe2ube3uba3uLW2uLa3uLa2uLa2ube3
        ube4vLm6vLm6ube3uba3vbu7vbq7ure3u7i4vbq6vbu7vLq7vru8v7u8vry8v7++wL6+wb6+wL29wL6+
        wL6+wL29wL6+wb/Aw8HAwsDAwb+/wb2+w7+/w8DAw8C/xMHBxcLCxcLC////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////uLa3uLa2uLa2t7W2uLa3uba2ubW1ure2uLe2uba2uri3ube3uLW1uba2uba3qaWnlZKTg3+A
        fXp7fXt7fXl5fXp5fXp6f3t7f3t7gHx9f319fnx8gH5+gHx8gX1+gX19g3+AhIGChoODhYODhoSEh4SD
        h4SEioeHioiJioiIi4iJi4mJi4mJjIqKjImKi4iKi4iIjImJjYqLjYuMjYuLjYuMj4yNj4yMj4uMjYqL
        j4yNkI2OkI6NkI+PkpCRk5CRkY6Ok5CPlJGQlJOSlZSUlZOUlZOTl5WWl5WVmJaWmJWVlpOTl5OUmZaW
        mJaWmZeXm5mYm5eYm5iZm5manJmanZqan5ycoJ6eoJ6en56eoZ+foqGgo6KhoqGhoqCgo6Cho6Gio6Kh
        o6Kho6Gho5+ho5+gpKCgpaKipaKipKKjpKKkp6SlqKWmqKWnqKanqKWmqKanqaioqqenqqioq6qqqqmp
        q6mpq6mqqaeoqaanrKqqraqrrqusr6ytrqysr62tsK6vsbCwsa6usa6usK6usa+vsq+vs7Kxs7OytLKz
        tLKztLKzt7S1trS0trS0trO0tbO0tbO0uLa2uLW2uba2uba3t7S1trO0uLa2ubm4ube3uba2ure3uba2
        uba2u7m5vLu7vLm6vLm6u7i6uba3u7e4vbq6vru7vbq6vry8vry8vbq7v729wL+/wL6/vru8vbq7v7y9
        wL6+wb+/wL29wLy9wb6+wr+/wr6+wr+/w7/Aw7/A////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////t7W2uLa3uba2u7e2ure2uLa3uLa1ube2ure3ure3ure4ube4uba3ure4uLW1p6Okko+PgX19e3h4
        fnt6fnt6fXp6fnt7f3x9fXp7f3x8f3t7f3x8gX5+g4CAhICBgn9/g4GBhoODhoSEhYOChoSDh4SEiYaG
        ioiIiIaHiYeHioeHiYaHiIWGh4SEiYaGi4mJi4iKi4eIi4iJjIqLjImKi4iIjImJjouMkI2OjoyMjYuL
        kI2OkY+Qj4yMkIyMk5CPlJGRlJKTlJKSlJGSlJGSlZWVl5aVmZaWl5OUl5WVmZeYmZeXmZaWmpeYmpiZ
        mpiZmpiYmpeYnJiZnZqanZucnpybn5ycn52coJ6eoZ+foZ+fnpycn52eoJ+fop+foqCfo6GhpKKipKKh
        paOjpqKjpaOjo6Kio6GipKChpKGhpKKipqSlqaamp6WmpqOkp6WlqKanqKenq6mpq6mpqqepqaaoq6mq
        rKqqrKqrrKqqq6ipqqeoraussK2usK2usa6usK6ur6ytr6ussK6usK+wsbCwsrGxsrGxsrGxtbKztbOz
        s7GxtbKztbO0tbS0trOztrO0uLW2uLa3uLe3uLa3uLa3uLW2t7S0tbOzuLW2ure4uba3uri4u7q6u7q6
        vLq5u7m5ure4vLm6u7i4ubi3vbq6vLm6u7m5u7i4vLm5vby8vby8vru7vry8wL6+v7y8vry8vbu7v729
        wsDAwsHAwsHAwb6+w7/A////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        u7e2ure2uLa3uLa2uba2ura2ube3uba3uLa2uLa1uLa2ura3ure4uba2t7S0pqOjkY6Of318e3l4fXp7
        f3x8fnp6e3h4e3h4fXp7f319gX59gX1+goGBg4GBhIGBhYKChoSEg4GAg4CBhYOEhYSDhYKChoOFh4WF
        hYSDiIaFiIaGiIeHioiIjIiJjImJiYeIiYaHioeHi4qJjIuLjoqKjoqKjYqKjImJj4yMkY+PkI6Oj4yN
        kY6OkIyOkI2Ok5CRlJGRlJGRlZOTlZSUlJGSlpOUmJaWmJaXlpSVlpSUmJaWmpiYmpiYmZeXmZWXmZaX
        mpeYmpaXnZqanZqanZqanZmanpqbnpucnp2dnZydoJ6fop+foqCgoqGgoqGhoqCgo6Ggo5+goJ6eoqGg
        oqCgoqGgoZ6eoJ2eo6GipqSkpaOjpqSkqKWmqKanqKemqKamqaamqaanqqeoqaanqqeoq6mprKmqq6eo
        q6iprausrqytrqusr6ytr66ur6ytsK2tsK6ur62ur6utsKyur66ur6+vsrCxs7KytLKys7CxtLGxtLGy
        tLKytbKzt7S1trS1uLe2uri5uLe4t7W1trO0t7S0t7a1uLa3uLa3uLe3ube3t7W2uLW2ure3u7m5uri4
        uLW0ubW0u7m4u7m5u7m5vLq6vLm5vbq7vbq6vbu7vbu8vry8vry8vru7vru7vr29wL6+wb+/wb+/wb6+
        wb6+////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////uLa2
        uba2ura2uLW2uLW1uba2uri4uri4vLi5vbm6u7e4u7e3ura3u7e3trS0pKGhko+Pf319fXt6e3h4enh4
        fHl5fnp6fXt6fnt7gH19gX5+f3x8gn9/hIGBg4GAgoCBhIGChIGAg4CAhoODiIWGh4aFiIaGiYeHiYeH
        iIWFiIWFi4mJiomIioiIi4iJjImKi4mIiYeGioeIjYmKjYqKjYuLj46OkI6PkY+PkI6Oj4yOkIyNko+P
        kI+OkpCQlJGSkpCRkpCRk5CRlJOTlJOTlZKTlZOTmJaWmJWVmJaWmJaXmJaXmZeYmpiYm5mZmpmYm5mY
        nJqanZubnJqZnZubnZubnZqanZubn52en52enpudnpubn52coJ2cm5iZlZKTnpubo6GhoZ+foJ6eoZ6f
        op+hoqChpKKipKKipKOjpaOkp6Slp6Wlp6Slp6Slp6Smqaanqqeoqqmpqqepq6ipq6mpq6qqrKqrq6ip
        q6mqrKusrq2srqysrqytrautr6utr62ur66tr62usK6vsK6vsa+xs7Cws7CwtLKzsrGytLKys7Gys7Gy
        tLKyt7W2uLe3uLe3uLW1t7S0trS1trW1uLa2t7W1trO0tLKztbKzuba3ube3ubi4ubi3ura2ura2u7e4
        vbu7u7m6u7i6vLq7vby8u7q6vLq7vru7vrq7vru8vr28vby7vru7wLy9wL6+wL69wL69////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////uLW2uLW1
        uba2ure3u7m5vrq7wLy8vbm7uba2ure4vLq7vLq6vLq6vrq7u7e4p6WlkY+PgH1+gYB/gHx8fXt7e3l5
        fHh4fnp6fnt8fnp7gn9/g4CAhYGChIGBg4CAg3+AhYGChoKDhoSEhoSEhYODh4WFiIWGiIaHiYiIiomI
        i4mIi4mJioeIioaHioeHi4iIjYqKjYmLjYuLjYuLjYuMjYqLj4yMkI2NkY6Oj4yMjYqJkI2Nko+QkpCR
        kpGQk5GRk5CRlJKTlZKSlJKTlZOUl5SUlpOUl5OUl5aXmZiZm5mZm5qZmpiYmZaWm5mZnJqanJqanZub
        np2cnJmZm5mZnZubnp2enZqbnJqbnpycoZ6enZycm5iZn5ydoZ+goJ6eoJ2doZ+eoZ6fo6Gio6GioqCg
        oZ+fo6ChpaGjpqOjpKKipaKjpqSlqKamqainqainqqenqaeoqqmoqqioq6mprKqqq6mpq6mpq6mqrKmq
        rKqqraqrraqrr66urqysr6ytsK6tr62tr6yusa+wsa+vsrCxsrGysrGxsrCxsrCysq+xsq+wtbO0tbS0
        trS0tLKztbKztrOztrOztbOztbO0t7a3uLW2t7W1t7W2ube3uri4uLa3uba3uba2u7i5ura4ube4vLq6
        vbq7u7m5u7m5vLq5vLm5vLq6vbu7vLq5vbq6v7y8v729wL69////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////ure3u7m5vrq7
        vLq6vbu7u7i4u7m5vLu7vLq6vru7v7y8v7y9vLq6vLq6ube2pqSkko+Pfnt7e3p5fHp6fnx8fn19fnp7
        f35+gX6Agn5/gn9/gn+AhIGBg4CAg4CAhH+AhYGBhIGBhYKCiIWGiYaIiIaHiIeHioiIiomJiomJiYaG
        ioaGiYaHi4mJjYqKjImJi4iIiYaHiYaHjImKj42NjoyMjo2Mj4yLj4yMkI2OkpCQkZCQkpCRlJGTlJOT
        lJOSk5KSlZOTlpOTlpOTlZSTlpWUlpSUmJWWmZeYmpmYmpeYmpaXmpeXmpeXm5mZnJqanJqbm5iZnJqb
        nZucnpycnZqanpycnp2doJ6eoqCgoZ6fn5yen52eoJ2en5ydoJ2do6Cgo6Kio6Gio6Chop+gpKGho6Ki
        oqGho6GhpaGjpqOjpqWkqKenqKWlp6WmqKanqqeoqqipq6qqqaamqqeorKmqrKmqrKqqraurraysrqyt
        r6ysr6ytrqytraurr6ytr62urqytsK6usrCwr62usKytsrCxsrGysrCxsrCxsrCxsrCws7GxtLGytbKz
        tLGytbKytbSzt7a2uLW2trS0uLW2uLW2trS1uLa3uba3trS0tbKzuLS1ube2u7m4vLi5u7i5u7i5vLm5
        vLq6u7m5vLm5u7i4vLm5v728v769v769////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////vLq6vbu7u7i4u7m5
        uri3u7m4vry8wb/AwL2+u7i4vLi5vru7vru7vbu7uLW1pKGhkI2NgH19gH59gH19f319fn1+f3x9gX5/
        hIKChIGBgn9/gX5/hH+AhICBhYGCg4CBhIGChYODhYOEh4SGhoSFiIaHiYiIiYeGiISFiIWHiIWGiYeG
        i4iIiYeHioiJi4mJjImKjIqLjoyMjo2Nj4yNjouMj4uMko+PkY2PkI2PkpCRk5GRk5GRk5KSk5GRlZKS
        lZKSlpSTlZSSlJGRlZKTmJWWl5WVl5WVmJWVmZaWmpiYmpeXmpeXmpiZm5mZm5iYnJmZnZqanpqbnJmZ
        nJubnZucn52dn5ucnpucn52eoJ2fnpudnZqan5uboJ6foqChpKKkpaWloqGhop+goqGio6GipKCipKKi
        pKOipaOkpaKjpaKiqKWmqaanqaeoqKanp6Smqaanqqmpqqioq6mqraurrausrKqrraurrqusq6mrraus
        rqysraurrKqqsK2tsK2urqysrqussK2usrCwsrCwsbCwsK+wsrCws7GxtLGytLGytrO0tbO0s7GxtbS0
        t7W2t7W2uLa3uLW2tbKzt7S1uLa3trSztrOzt7S0uLa2ubW1ure3uri4ure3u7i5vLq6vLm5u7m4uLa3
        uba3vbq6vr28vr28////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////u7m5uri3u7m4vLq6v7y9
        v7y9vbq6vbu7vru8vLq7u7m5vrq5wLy8wL6+ure4pKGijouMf3t7f318f319goCAg4KCgX9/gHx9gn+A
        goCBgX5/g3+Ag4CAgH19gHx9goGAhIGChIGChICBhoOEhoSEh4SFiISFh4SEhoOEiIWGh4WFiYiIjIqK
        i4mJjIqLjYuMjYqLjIqLjoyNjYqLjImKjYmKj4yNkY+Pko+Qko+QkY+Pko+Pk5GRlJKSlJGRlJGRlJGR
        lpOUl5aVlpOTlZKSlpOTmJeXmpiYm5eXmpiYmpmZmpmYmpeXmZaXnJmanZqbnJmZm5mZnJqbm5qanpub
        nZubnZucnJqbnZubnZubnpqbnpucoJ2eoJ6enZycnZqboJyeo6GioqGho6GipaSkpaOipKGipKOjpKKi
        pqOjp6Slp6Skp6OjqKWlqaenqaanqaioqqinqaenqqanq6iorKqqrKmpq6iprKqrrausrKmqrausrqus
        r6ytsa+wsK+wsK6usK2usK6usK6usa6vsa+ws7GxsrCxtLGytLOzsrGysa+xtbKztbO0tbOztrS0t7W1
        t7S0trS0trS0trOzuLS1t7a2trW1uLW1ubW1ube2uLa2uba4u7m5u7m5urm4uLa1uba2u7i4vr28////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////vLq6v7y9vbq7vru7v727vbu7
        vru7vbq7vbq6v7y9v76+wb6+wsDAwb6/tbGxop6ejImKf3x8fnx8fXp7fnt7gH5/gH9/f3x8gX5+gX9/
        f3x8gHt8gn9+goB/g4B/gn+AgoCAhIKChYOCh4SEh4SEiISGh4WFhoSEhoSEiYeHioeIi4mJjYuLjImK
        jIqKjoyNjIqKioeHjImJjoyLkI2NkIyNkY6PkY6Pko+Qk5GRk5GRk5GRkY+Qko+QlZKSlpWUlpWVlpSU
        lpOTlpWVlpSUmJWUmpiXmZeYmpiYmZaWmZaXmpiZm5qZm5uanJqampiYmpiYnZqbnZqbmpeZmpiYm5mY
        nZubnpycoJ2eoqChmpiXko2MmZSVoZ6foJ6eoJ6foZ+fpKKhpaCgpqKipqWlpaSko6GipaGipqKipqKi
        qKWlqKWlqKWmqKenqainqKWmqqemqqalq6enqqipq6qprauqrKmqrausrq2tr66ur62usa+wsLCvr66v
        sa6vsa6vsK2ur62ur62usK6vsa6vsrCysa+vrqursq+ws7CxsK2usa6vsbCws7GwtrOztbOzsrCwtLCw
        tbGytrO0t7a1uba2uba3uLe3uLa2t7S0uba3ubi4u7m5u7i4uri3u7i4u7i4////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////vbq7vru7v727vLm5vbu5vbu7vru8v7y8
        wL6+vry8wL2+xcHBwr+/vbu7vbq6s66vnpqaioaGfnp6f3x7f3x8f319gX9+gn9/f319gH5+gX5+gn5+
        g39/gX9/gX9/goCAhIKChYODhoSEh4WFh4WGhIKDh4WFioiJioiJiYiIi4mJi4iJioiIjIqKjIqKjYqL
        jYuLjIuLjYqKj4uMjoyMj42Nj42OkY+QkpCQkpCPj46Nj4yMk5CQlJGRlJKSlJGRlpOSlpSUlZOUlpSU
        lpSTlpSUmJaXmZeYl5WVmJWWmpiYm5uamZiYmJaXmJaXmpiYmZeYmJaXmJeWmpiXm5mZnZycn56en52d
        mJaVmJWUn5ycoZ+gn52dn52doZ+goqCgo6Cho5+gpaKjpqWlpKGho56epKGhpaOjpaOipqOkpaOkpaOk
        pqSkqKamqKamqaalqaamqKanqKinqqmorKqqraysrq2trausrqysrq2trqysraqrrautraytrq2tr62u
        r66ur66ur6yusK6vr62uraqqr6ussrCxsbCws7Gysa+vsa+vsrCxsa6usa+usrGxs6+xtLCxuLW1t7S1
        trW1t7a2uLa2uLW1t7Ozt7S1uLa2uLa3uba3u7i4u7i4////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////vLm5vbu5vbu7wLy8wb69wsHBvb29v76+xcLB
        wb+/vbu7wL28w8C+xMDAwr6+s6+wn5ubioeGfnt7gH59gX5+gH1+fnx8f3x8gXx9gn9/gX5+gn+Ag4CC
        g4GBhIGBhIKDhYSEhIODhYODhYKDhIKChYKDh4SFiIaFioeHiYaHiIWGh4WFiYWGjImJjIuLjoyMj4uM
        jo2NjoyMjouMj4yNkZCPkpGQkY+PkY+OkY+PkpCRk5CRk5CQk5GQlZOTlZSTlZKTlJGSlpOTmJaWmJaX
        lpSUlpOUmJaWmJaWmJWWl5aXmZaWl5WUlpSUlJKTlZOTl5WVmZeWmpiYm5mamZeXm5iYnZycn52enZuc
        npucoJ2en52eoJ6foJ+foZ+goZ+foqCgpKCdpZ+cpKCfpKCho6Cho6Gho6GhpKKipaOkpqSkp6Slp6Sk
        qKWlqKampqSlp6Slqaanqaenqqipq6iprKmqraysrKmpq6enrKqqrKusrausrqytrausr66usK+wsK6u
        r6ysraussK2usrGxs7SzsrGxsa+wsq+ws7GysrCwsrCvtLKxsq+wtLCxtbKztrS0tbOztrO0uLW1uLe3
        uLe2t7S0t7W1t7W2t7S1u7i4////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////wLy8wb69wsHBv7y9w8HBxcPDvru7u7m4wb++xMHB
        w8C/wb29v7u7vrq5vrq5sq6uoJycioeHfXp7fXt8fnt7fnp7f3x9goGAgoCAgX6AgX9/goCBhIGDhIOC
        hIOChYODg4GBgX5/hIGChIKChYKDiYWGhoSFg4GAg4GAhYKCiYWHjYqKjYqKjYqLjo2NjoyNjouLjYqK
        jYqLj42Nj42Nj46OkpCQkpCQk5CRkI6OkI2Nko+QlJKSk5GRlJCSlZKSlpOTl5SUlZOUlZOUlpOUlpOU
        l5SVl5SVl5WVmJWVlpSUl5SUlZOTlZOTl5SUmJWWmJWWmZaXnJqanJqanJqbmpmZmpeYnJmanJqanpyd
        oJ6foJ6fnpycn5mYo5yZpKCbpaGeo56do6Cho6KipKKhpaOjpKKjo6CipKKjpKKjpKKipaSkpKKipaKi
        paKkpqSmqaeoqaioqaanq6qrrKqrq6qqrqytrq2urKusq6mqo6Cir66usK+wsK6ur6ysrqytr62urqys
        rqyssa+vsK+vsa6wsq+ws7KytLKysq+wsK2usa+vsq+ws7CxtbKytLKytbKytbOztrO0tLGxtrS0trS0
        tbKztbKz////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////v7y9w8HBxcPDwLy9wb2+w8HBw8DBwsC/wL29vru6vrq6
        wL29xcHBxsPDwb6+sa2tnJeYiISEfHl5enh5fnx8goGAgX5/gH5/gH+AgoCBgn+Ag4GChYKDhIGChYOC
        hoSFh4SFhYKDhoSFhYSEhIKCh4aEh4SEh4OEiYaHioeIiYeIiomJjImKjo2MjYyLjYuLjouMjoyNjYuM
        jouLj42NkI6PkI2Nj4yMkY6OkpCQk5KSk5GRk5GRk5CQlZKSlZOTlZSUlpWVlpSUlZOSlZOTl5SVl5WV
        lpSVlpOUl5WVlpSVmJWWl5WVlpOTmJWVmpiYmpmZmZeXmZaXmZaWmpeYnJqanJucnpydnp2dnZubnZqa
        oJuaopyboZ2bop2coZ6eoZ+goZ6fo6ChpKOjo6OjoqCgoZ+foqGhoZ+fop+foqCfpKGipaOkp6WmqKam
        qKWlpaOjqKamq6ipq6mqraurrKusq6mqo6Ci////////////////rqytr62urqysrKiprqytrq2urqyt
        sa2tsa+usrGxsa6vsa+wsrGxs7Gxs7CxtbKytLKys7GwtLKztbKztLGxtbOytrOztbKz////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////wLy9wb2+w8HBwsDBwsDAwb6+wr6+wsDAwsDAwr69w72+wb2+
        wby8v7q5v7q6sK6umpmYh4SFgH9/g4CAgX9/gH9/gX9/g4CBgoCBg4CAg4CBg4KChoSEiIWGh4WGhYOD
        hYOEhoOEiYWGhoODhoODiIWGiIWGiIWFiYaHioeHi4mJjIqKiYeHi4mJjYuLjImKjImLjoyNjoyMkI2N
        j4yOjYuMj42OkY6PkpCPkY+QkY6Pk5CQlJKRkY6OkpCQk5KSk5GRlJKTlZOUlZOUlJKTlJKSlZKTl5SV
        lpOVlZOUmJWWmJaWmZaXmpiZmZiXmJWWmJWWmZaXnZubnZubnpucnZubnJqbnZydn52eoJycnpqbn5ub
        npycnpycoJ2eoZ2eoaCgoaCgoZ2dn5ydn52dn52doJ6eoJ+foZ+eo6KhoqGhpKKip6SkpqSlpqWlp6Sl
        qKOkraur////////////////////////////////////////rKiprqytrq2uraqrsKyssK2usK+usa+v
        sa+vsrGxsrGxs7KxtLKys7Cxsq+wsrCws6+wtLCxtLKytrOz////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////wsDBwsDAwb6+xMDBxMPCwsC/v7u7v7y9wsDAwr6+wr6+xMDBx8TE
        yMfGycfHtbKynZubiIaGf319gX5/goB/gX5/gH19gH5+gH9/goGBhIODhYOEhIKCgn+AhIGBhoKDhYKD
        hIKDhoSEhoOEiIWGi4iJiYeHiYeIioeJh4SFhoSEioeHiIWGiYaHi4mJjoyLkJCQkI6Oi4mKjIqKj4uM
        j4yMkY6PkI2Pk5CRkpCQj4yNj4uMko+Qk5CRlJGRlJOUlJKTlJGSko+QkY6Pko+Qk5GSk5CRlZOUlpOV
        l5WVmpiYmZeXlpSVl5SVmJWWmZaXm5qam5qam5mam5manZucnJubnZucnJmanZqbnZucnpucn5ycoJ2d
        n52doJ2en5ycnpucnpubn5ycop6goJ2fnpyboJ2doqCgoqCgpaKipaKkpaSlp6amqKOk////////////
        ////////////////////////////////////////////raqrsKyssK2uraqrsK2tr6ysr6ytsa6vsa+w
        sK+vr62usa+wsbCwsa6vsrCwtLKytrOz////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////xMDBxMPCwsC/wby9wb+/w8LCwb6+xsLDycbIy8fIysbGysfHysfJy8nL
        y8nKtrS1nJqZhYODf3x9f319gX9/goCAgH9/gH9/goCAhIGBg4CAg4CBhoSEhYODhIKChIODhYSEhoSE
        iYaHiIWFh4aGiIaHiIaGiIWFh4WFh4WFhIKCiISEi4mIiIeHiIaFi4eHjImKjIqKjoqLkI2NkI6OkZCQ
        kpGRkY+PkI2OkY2OkpCRkpCQkpGRk5GRk4+RkI2OjoyMkY6Oko+Pko+Qko+QlJKTlZOTlpSUlZKTlZKT
        l5SUl5SUl5SUmJeXl5WWlpSVmJaWmZiYmpiYmpeXm5mZnZqanpubnZubnZubnpuboJ6en52enZycnZyb
        nZybnZubn5uboJydnpucoJydo6Cgo6Gio6Cgo6ChpKGjoKCgoKCg////////////////////////////
        ////////////////////////////////////////raqrsK2tr6ysrqqrr6usraurraurr6yusK2usK6u
        sa6vsrCw////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////wby9wb+/w8LCxcLCyMbFysfHysbHycXHyMXFyMTFx8TFysfJzczMzcvMyMbG
        sq+wmpeYhYODgX5/gX5/gX5/goGBg4OChYSDhISEhIKDhIGBhIGBhYSDhYODhIKChoSEh4SFg3+Af359
        g4GBh4SFiYaHiIaGhYODhoSDiIaFenh5enl4h4WEjIqLjIqLjouMjouMj4yMj46OkI6OkY6OkI6Oj46O
        j42OkI6PkY6OkY+PkY6Pj42NjoyMkY+PkpCQk5CRlJGSk5KSlZOUlZKTlJKTk5GRk5GRlJGRl5SUl5WV
        lZGSk5GRlZSUmZeYmpiYmpiZmpiYnJqbnJqanZucnJubnJqanJmbn5ydnZucnJqam5qZnZubnZqanZub
        npydoJ6eoaCgo6Gio6GhpKGipKKjoKCg////////////////////////////////////////////////
        ////////////////////////////////////rqqrr6usraurraurr6yusK2usK6u////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////xcLCyMbFysfHx8TFyMXHyMXFx8PDxcLByMXFy8fIzMfIycfHxsTEyMTGycTGs7Cw
        mZiYhIKCgX+AgYCAgoGBgoGBgX9/gX5/g4CAhIKChIODg4KDhoODhoKDgHx9fHp6fHp7fnx+hIKDiIWG
        h4SEh4aFh4WFgX9/gX9+iIaGioiIiYiIioiJi4mKjYuLjoyMjYqLjYuLjY2MjY2MjYyMjYuMj42Nj42O
        kY+OkI2NkI2OkI6PkY+PkpCRk5KSlJOTlpSUl5WWlJOTkZCQkY+Qk5CQlZOSlJKSk5CQlZKSmJaXmpiZ
        m5mZmpmZmpmZmpiZm5mam5qanJubmpmZmpeYnJiZnpucnZqbnZmanZqbn52dnpydnpydn5+eoJ+foJ+g
        oJ+foqChnZucnZuc////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////x8TFyMXHyMXFx8TFx8XFycfHzMjIysbGyMTFxsLCycTFzsvMz87Oz87Nx8XGr62ulpOU
        gn+AgX+AgoCAgoGBg4GBgoGBgoCCg4GChIKChYSEgX9/gH1+g4GCf3+AfHx+g4KDhoSEhoSEh4WFiYeH
        iYeHh4OEhoOEh4WFiYaHioeHiomIioiJjImKjoyMjYuMi4mKjIqKjoyMjYyMjo2NjoyMjouLjoqMj42N
        jo2MjouMkI2OkpGRk5KSlJKSlJKSkZCQkY+Qko+Qk5CQko+QlZKRlZOTlpSWmJaXmJeWmJaWmJWWmJaW
        mZeYmZeYmZaXmpeYmZiYmpiZmpiZm5iZmpiYmpmZm5manZucnpycnZybnZucn52dnp2dn52enZuc////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////x8TFx8XFycfHzMrKysjIysbIysbHzMnJzcvLzc3Mzs7NzszMzs3M0M/OxcHDrKiqlpSUg4KC
        g4ODgH9/f3x9gn+Ag4KChIOCgYCBfHp8g4CChoaGg4KDf39/goCBhYKDhYODhoSEh4SEhoKDhYSEiYiI
        ioeHiYeHiYaIioeJi4iIjYqJi4mJi4mJjYuKjYuLjYuLjIqLjYuLjYmKjYqLjYuLjo2NkI2OkY6PkY6P
        kI+PkI6OkI6OkI6OkI2OkY6Pko6Pk5GRlZOUlJKTko+QlJKSlZSUlZKTlpOUmJaWmZeXmZaXmJWWl5aV
        l5aXl5WWmJeXmZeXmZeYmJaXmJaXmpeYm5mam5mZnZmbn5ycn52en5ydn5yd////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////zMrKysjIysbIzszMzsvLzcnKzcrLzcvLzcnLzszN0M7Oy8jIysbHzsrLx8PEr6ytlJGSf3x8gn+A
        g4GBg4CBgoCBfHt8e3l7g4GBhIKBf319gX5/g4GBhIGBhYKChIOChIKChYOEhoWFh4WFiISFioiJi4qK
        iomJi4mKjIqLi4iJioiJjImKjYuLjYuMjImKi4iJi4iJjYuMjoyNj42OjoyNj42OkY+PkY6PjouMjYuM
        j42NjoyMj4yMkY2PkpCRkY+Qk5CQlJKSlJOTlJOTlZOTl5WVmJSWl5SVlpSUlpSVlZOUlJKSkpGRk5KS
        lJKTlpOUlZOTl5WVmZiYnJubm5manZqanJqampmZmpmZ////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        zszMzsvLzcvNzcnLzcnKzs3N0M7O0MzMzsrKzszL0M3O0M3NzsvMz8vMwb6/qqankpCQgX5/hIGBgH9/
        eXl7enl6gH59gH59gH1+f319gX9/gn+Ag4GBhIKChYKDhYODhoSDhIKChYKDiIaHh4aGiYiJi4mKioeI
        iYeHioiIiYeHiYeIioeIiYeIiomKjImKjYqLjIqKjIqKjYyMj42NkI6Oj4yMjImLjYqLkI2LkI2Lj4yM
        kI2Oko+PkpCQk5GRlJKTlZWVlJOTk5GSlJGTlJKSlpOTlZKTlZOTlZOTlJKSk5GSk5GRlZKSlpSVl5WW
        mpiYm5mZm5mZmZeXmZaXl5WVmJeX////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////zcvNzcnL
        zcnKzs3NzszMzcjJzcjJzcrKzsvLzcnKzcnJzcnLzcvM0M7Pz8zNw8DBq6ipkpGRgH+Aenp8enl6f319
        fnx8fn18f35+gHx9gX1/g4GBhYKChYKDhYKDg4GAgn+Ag4KChYODh4SFiIaGiIaFiYeIiIeHiIWFh4WF
        h4WGiIaHioiIi4mKjImKjIqKjYqLjYuMjIqKjYuLjYuKiYeJioeJk4+LlJGLjIqKjouNkI2OkI2OkI6O
        kpCQkpCQkZCRkY6PkY+QkY+Qk5CRk5CQk5GRlJOTlZOTlpOUlZOSl5SUl5WWl5WWl5WUmJWVmJWWmJaX
        mJWWmJaWmJeXmJeX////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////zs3NzszMzcjJ
        ysfJzMjJzcnJzcnKzcvKzsrLzsvMzszMzcrL0M3Oz83Ny8jIvry7p6WljImLfnt7f3x9fnx8f319gX1/
        gn5/gX9/gX9/gH1+g4CBhoOEhYKCgoCAg4GChIKDhIKChoSEiIaGh4SFh4WFiIaGh4WGh4WGiIaGiYeI
        i4mKi4qKjIqKi4iJi4iJi4mJiYeHh4SGioiJkIyKko2HjIiHjImKjoyMj4yNj4yNjoyLjouMj42Nj46O
        jouLkI2Nko+QkY6PkY2OkI6OkZCQlJKSlZKSlJKTlJKTkY+QkZCPlJGRlZKSl5SUl5SUlpSVmJaWl5WU
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////ysfJzMjJzcnJz83O
        z87P0M3NzcnKy8bIzsrM0M7OzcvLy8jIzsvLzsrLzsnKvLm5o6GhjIqKfnt7f35+gH9/f35+fXx8fn19
        gH5/g4CBgoCAgX5/g4CCg4KCgYCAg4KChoSFhICChoSEhYOEhoSEhoWFh4WGh4SFiYaGioiIiIaHiYaH
        ioeHi4iIhoOFh4SFiomJioiJjoeHkYyIjYqIjYqLj42Nj42NjouMjoyMjo2NjYyMjYuLjoyLj4yNjouM
        j42OkY+QkpCQk5CQko+QkpCRkpCQj42MjYuLkY+Pk5CQlZOTlpOTlJKSlZOSl5WUl5WU////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////z83Oz87P0M3NzcrLzMnL
        z8zN0M3OzcvLy8jJzsnJzcvKzcrKzsvLzMnJzcnKvLm5o6GhiomJfXt8fnt8fnx8fXx8fnt8fnx8f31+
        gX9/gH5+gX9/goGBg4GBg4CBhIGChIODhIKChoSEhoWFhoOEh4SFiYaHiYeHiYaHiIeHh4aGhYKDh4SE
        iomIioeIi4iJjouJjYqJjImJjIqLjYqKjYuLjYyLjIqKjoqKjouLjIyMjImKjouLjo2NkI6PkY+PkY+O
        lJGQk5CRk5CRkZCPkI6OkY6Pk5GQk5CQlZGSlZOTlpSUlZSUlJOU////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////zcrLzMnLz8zN0c7P0M3OzcrL
        zcnIzsvLz8zN0c7O0M3N0MzM0MvM0MzN0M7Pvbm6o5+gh4WGe3l6fXt7fXx8fnx8fXt8fXt7fnt8gH5+
        gYCAgoCAhIGCg4GChIKCg4GChYODhYOEhYODhIKChoSFh4aGh4eGhYSEg4CAhIGBiYeGjIiHioeGhoaH
        iIaHioeIiYeHiYeHioiIioeIiIWGioeHjIqKjIqKjIuKjYuLjouMjYuMjoyMjYuLj42NkI2OkY+PkZCQ
        kY+Qko+PkY+Pko+Qk5GRlZSUlZSVlZSUlJOUlJOU////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////0c7P0M3OzcrLy8rIzcvK0MzO0s/R
        0c/Q0M3Oz8vM0s7O09DQ0tDP08/P0c7Nura2nZucg4GCenh5e3l5enh5fHp6f319gH9/gH5+gn9/goCA
        f319f319gX5/g4GCg4KDgoCAg4CAhYKChYKChIKCg4GBg4KChoSEh4SEh4SDhoODh4SFhoSFhoODhoKC
        iISFh4SFh4SFiYaGi4qKjIuKi4qJjYuMjoyNjoyNjYyLjIqKi4mJjYuLjoqMjoyMj42NkI6Oko6QkpCR
        k5GSk5GSk5GSkpGQkpCQkpCQ////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////y8rIzcvK0MzOz8zL0c/Q0M/P0M3M0s7N
        0s7P0s/Q0tDR09HQ0s/N08/P0czOubW0n5ybhYOEfnx8gX5+gX5+gH1+fn19fnx8fXp7fnt8f319goB/
        hYKCg3+Agn9/g3+Ag39/gX5+gH5+f359goGBhYOEh4KCh4KChoODhoSEhIODhoOEhoSEiIaGiYiIi4mK
        ioiJiIeHiIaHi4mKjYuMi4qLjIuLi4iJjImJjYuLjYqLjoqLjYuLjIqKj42OkpCSkY+QkY+QkI+OkI2N
        j4yMj4yM////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////z8zL0c/Q0M/PzszL0M3N0MzO0s7P0s/Q0c/O
        08/O1NDP0s/O0M7P0tDS0c7OuLW1nJqahYKCfXt8fXx8fXp7fnt8fnx8f318gX59gn59gX5+gX5+gn9/
        gn5/gH5+fXx8fnx8gH9+goCAgn9/hYGBhoOEhYOChIOChYSFh4aGiIaGiYeHh4WGhoOEh4WFiYeHioiI
        iYeIiIeIjIqKjYuLi4qJi4qJi4mJjYqKioeIiYeGi4qJjoyMjouLjYuLjo2Mjo2Mj42Nj42N////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////zszL0M3N0MzO0c3O0s7O08/R1tHT08/Pzs3M0M7O
        1NDS0s7O0s/P09DR0c3Ot7O0mpeYgX9/fHp6fXt7fnx8fnx8fXp7fnx8f319fn19f319f35+gH5+gH19
        gX5+gH5+gX5+goB/goCBg4CBhIGBhoOEhYODhIGChIKChIKDgoCAhIGBhYKChoSEiIWGiYaGi4iJi4mJ
        iIeHiYaGiYaGiIaFioiIjImJjYuKjImJjIqKjIqJjoyLj4yNj42N////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////0c3O0s7O08/R0MvN0c3P0c7P0c7P1NLQ087O087Q1dHS
        1dLT1tPT1tTUz8zMtbCymJaWfnx8enl6fHl7fHp6fXx7fXx8fnx8fnx8fnx8gH19gH1+gX5+gn5/gH5+
        gH5+gX+AgoCBg4CAgn9/gX5+hIGChYODg4GBgn9/g3+Ag4CAhoKCh4ODh4SFh4WFh4aFiIWFh4SFh4WF
        ioiIjYuMjouNjImKiomJi4mIjIqJjouLjouL////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////0MvN0c3P0c7P0s7Q1NLS1dPT1tPT1dDR1dHS1NPT1dXV1dPT
        1dLS1dPTzMnLsa2ulZKSfHt7fXt6fnt8fnt8fHh5e3d5fXp6fnx7f3x9gX1+f3x9gH5+gX5/gX5/gH5+
        gH5+f319gn9/hIGAg4GBhIGBhIGBhIKChIGChIKDhIGChYKBhoSEhoSEiIaGiYeHiIaGiIWHioiKioiJ
        iYeIiIWFiYeHjIqKjIqK////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////0s7Q1NLS1dPT1tTU1dLT1NDS0s/Q0s/R1tPU1tTU1dPU1NHS1dLT
        2NbXzMrLr6ytlZGSfHl5e3h5end4fHp6fXt6fnt7f3t8f3x8fX19fnt8f3t8gH5+f3x9fXt7f3x7f3x7
        gX5+g4CAg4GBg4GBhIKDhIKChIGBg4GAhIKChIKChoSEhoSEhYKChoODh4WFiIeHiYaHiYeIiomJjIqK
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////1tTU1dLT09DRz8vM0MvN1NHS1dPT1dLT1dPU1tPU2NXV19XV1dPU1tPV
        ysfJr62tkpCPe3l5fXt6fHp6fHp6fXp5fXp6e3l6fXt7fHp7e3l5fHl5f3x8f3t8fXp6f3t7gX19gX9/
        gYCAgoCAgX9+goCAgX9/g4CAg4GBg4CBgn9/hIKBh4SEh4WFiYeIioiJjIqKjIqK////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////09DRz8vM0MvN0c7O08/Q1tLT1tPT1dHS2NTV2djY19XW19PV19TV1dTU1dLSycfG
        rKmpjYuMenh4fHl5e3l5e3l4enl4enh3end3fXp6fXp6fHp6fHp5fnt7gH19gH5+f31+f319f318f319
        gX5+g4B/hIGBgX5+gH19gn9+g4CAg4GAhYODh4WFioeIioeI////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////0c7O08/Q1tLT1tPT1dLS1dPT1dPT1tPU2NPU19TU1dLS1dLS1tPU1tHT1dLTxcPDqqeo
        j4yNeXd2eHZ1eHZ2end3eXZ2eHV1eXV1eXd3eXd3fXt7gH1+fnx7fXt7fnt8f3x8gH59gX9+gH19f3x9
        f3x8gH18gH18gX9/g4GBgoCAioeI////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////1tPT1dLS1dPT1dLS1tTU2NfW19bU1tPU1tPT1tHT2NXW19TU1dPS1dPT1dPTxcHBp6Oki4iH
        eXZ2eXZ2eHV0eXZ2enh4enl5e3h5fXt7e3p5e3h4fXp7fnp7fnt7fXp6fXp6fnt7fnt6fXp6fnx7goB/
        hYOEg4GCg4GC////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////1dLS1tTU2NfW1dPR1dHR2NTV1tPU1dLT1dLU1NHS1dLR1NHR08/R1dHS1tTUwb+/paGhiYaGe3l5
        e3p6fHl6e3h5fHl5fHl6eXZ3e3h4fHd4fXl5fXt6fXp6fnl6fnp6f3p7f3x8gX9/goCAg4CBg4CB////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        1dPR1dHR2NTV19bW1NLS1NDS1dHT19PT2NXV1NHT09DS1dLT1dHT1tLS19TUwsDApaKiiIWFeXZ3e3l5
        fHp6e3l5enZ2e3Z2fHh4fHp5e3l4fXl6f3t7fnt7f3x8gH19gX9/g4CB////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////19bW
        1NLS1NDS19LT2NXV2NXX1dPT1dHR1tHR1tLS1tPU2NTV2NTV19XU1dLTvbm6oJ2dhIKCenh2eHZ2eXZ2
        eXh3eHZ1eXd2enh3e3h4e3l4fHp5f318gH5/gH5/////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////19LT2NXV
        2NXX1dHT087N1M/P1tLR19XU19TW1NHS1NHR19TV1dTT19PT1dDQuLOznZmag4CAeXZ2eHV1d3V0d3V0
        dnNydXNyd3V0enh3gH5/////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////1dHT087N1M/P
        1tLR1dHS1NLS1tLS1s/R1dHS1tXV19XV2NPT1tHS1tPT1dPTubW1nJmZgX5+d3RzdHJxcW9uc3FwdnR0
        dnR0////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////1tLR1dHS1NLS1tLS
        1tHR1tHS1tPU1NLS08/Q1tPT2NXV19PV1NDQ0s7P0c7PuLS0mZaVeXd2b21scnBvcnBv////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////1tLS1tHR1tHS1tLS09DR
        0s/P08/P1NHR1dLS1NDS1dLT19PU1NLS1NHSzsvLs6+wcnBv////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////1tLS09DR0s/P1tLS1tLU1tLT
        1dLS1NHS1tLS1tLS1tDR1dDR1dPT19XW19XW////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////1tLS1tLU1tLT1tXU1dLT1tLS19LS
        19PT19XT1dPS19XW////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////AAAA////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////1tXU1dLT1tLS19LSzsrK19XT1dPS////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////AAAA////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////19LSzsrK////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////AAAA////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////AAAA////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////
        ////////////////////AAAA
</value>
  </data>
</root>

================================================
FILE: Razor/UI/WelcomeForm.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Configuration;
using System.IO;
using System.Windows.Forms;

namespace Assistant
{
    public class WelcomeForm : System.Windows.Forms.Form
    {
        private System.Windows.Forms.Label label1;
        private System.Windows.Forms.CheckBox patchEncy;
        private System.Windows.Forms.Button okay;
        private System.Windows.Forms.Button quit;
        private System.Windows.Forms.Label selectServerLbl;
        private System.Windows.Forms.ComboBox serverList;
        private System.Windows.Forms.GroupBox groupBox1;
        private System.Windows.Forms.GroupBox groupBox2;
        private System.Windows.Forms.OpenFileDialog openFile;

        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.Container components = null;

        private System.Windows.Forms.Button browse;

        private bool m_PatchEncy = false;
        private string m_ClientPath = "";
        private TextBox uoClient;
        private TextBox dataDir;
        private Button dataBrowse;
        private Label label2;
        private TextBox serverPort;
        private TextBox serverHost;
        private Label portLabel;
        private Label serverHostLbl;
        private Button removeServer;
        private Button saveServer;
        private TextBox serverName;
        private Label serverNameLbl;
        private Button newServer;
        private ComboBox langSel;
        private Label label5;
        private CheckBox showAtStart;
        private string m_DataDir = "";

        public WelcomeForm()
        {
            InitializeComponent();
        }

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (components != null)
                {
                    components.Dispose();
                }
            }

            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            System.ComponentModel.ComponentResourceManager resources =
                new System.ComponentModel.ComponentResourceManager(typeof(WelcomeForm));
            this.label1 = new System.Windows.Forms.Label();
            this.browse = new System.Windows.Forms.Button();
            this.patchEncy = new System.Windows.Forms.CheckBox();
            this.okay = new System.Windows.Forms.Button();
            this.quit = new System.Windows.Forms.Button();
            this.selectServerLbl = new System.Windows.Forms.Label();
            this.serverList = new System.Windows.Forms.ComboBox();
            this.groupBox1 = new System.Windows.Forms.GroupBox();
            this.langSel = new System.Windows.Forms.ComboBox();
            this.label5 = new System.Windows.Forms.Label();
            this.showAtStart = new System.Windows.Forms.CheckBox();
            this.dataDir = new System.Windows.Forms.TextBox();
            this.dataBrowse = new System.Windows.Forms.Button();
            this.uoClient = new System.Windows.Forms.TextBox();
            this.label2 = new System.Windows.Forms.Label();
            this.groupBox2 = new System.Windows.Forms.GroupBox();
            this.newServer = new System.Windows.Forms.Button();
            this.serverName = new System.Windows.Forms.TextBox();
            this.serverNameLbl = new System.Windows.Forms.Label();
            this.serverPort = new System.Windows.Forms.TextBox();
            this.serverHost = new System.Windows.Forms.TextBox();
            this.portLabel = new System.Windows.Forms.Label();
            this.serverHostLbl = new System.Windows.Forms.Label();
            this.removeServer = new System.Windows.Forms.Button();
            this.saveServer = new System.Windows.Forms.Button();
            this.openFile = new System.Windows.Forms.OpenFileDialog();
            this.groupBox1.SuspendLayout();
            this.groupBox2.SuspendLayout();
            this.SuspendLayout();
            // 
            // label1
            // 
            this.label1.Location = new System.Drawing.Point(8, 19);
            this.label1.Name = "label1";
            this.label1.Size = new System.Drawing.Size(101, 19);
            this.label1.TabIndex = 0;
            this.label1.Text = "Load UO Client:";
            this.label1.TextAlign = System.Drawing.ContentAlignment.MiddleLeft;
            // 
            // browse
            // 
            this.browse.Location = new System.Drawing.Point(308, 17);
            this.browse.Name = "browse";
            this.browse.Size = new System.Drawing.Size(64, 24);
            this.browse.TabIndex = 1;
            this.browse.Text = "Browse...";
            this.browse.Click += new System.EventHandler(this.browse_Click);
            // 
            // patchEncy
            // 
            this.patchEncy.Location = new System.Drawing.Point(219, 76);
            this.patchEncy.Name = "patchEncy";
            this.patchEncy.Size = new System.Drawing.Size(152, 20);
            this.patchEncy.TabIndex = 4;
            this.patchEncy.Text = "Patch client encryption";
            this.patchEncy.CheckedChanged += new System.EventHandler(this.patchEncy_CheckedChanged);
            // 
            // okay
            // 
            this.okay.DialogResult = System.Windows.Forms.DialogResult.OK;
            this.okay.Location = new System.Drawing.Point(269, 306);
            this.okay.Name = "okay";
            this.okay.Size = new System.Drawing.Size(122, 43);
            this.okay.TabIndex = 14;
            this.okay.Text = "&Launch";
            this.okay.Click += new System.EventHandler(this.okay_Click);
            // 
            // quit
            // 
            this.quit.DialogResult = System.Windows.Forms.DialogResult.Cancel;
            this.quit.Location = new System.Drawing.Point(12, 323);
            this.quit.Name = "quit";
            this.quit.Size = new System.Drawing.Size(62, 26);
            this.quit.TabIndex = 18;
            this.quit.Text = "&Quit";
            this.quit.Click += new System.EventHandler(this.quit_Click);
            // 
            // selectServerLbl
            // 
            this.selectServerLbl.Location = new System.Drawing.Point(9, 22);
            this.selectServerLbl.Name = "selectServerLbl";
            this.selectServerLbl.Size = new System.Drawing.Size(79, 19);
            this.selectServerLbl.TabIndex = 9;
            this.selectServerLbl.Text = "Select Server:";
            this.selectServerLbl.TextAlign = System.Drawing.ContentAlignment.MiddleLeft;
            // 
            // serverList
            // 
            this.serverList.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.serverList.Font = new System.Drawing.Font("Segoe UI", 9.75F, System.Drawing.FontStyle.Regular,
                System.Drawing.GraphicsUnit.Point, ((byte) (0)));
            this.serverList.Location = new System.Drawing.Point(101, 19);
            this.serverList.Name = "serverList";
            this.serverList.Size = new System.Drawing.Size(269, 25);
            this.serverList.TabIndex = 5;
            this.serverList.SelectedIndexChanged += new System.EventHandler(this.serverList_SelectedIndexChanged);
            // 
            // groupBox1
            // 
            this.groupBox1.Controls.Add(this.langSel);
            this.groupBox1.Controls.Add(this.label5);
            this.groupBox1.Controls.Add(this.showAtStart);
            this.groupBox1.Controls.Add(this.dataDir);
            this.groupBox1.Controls.Add(this.dataBrowse);
            this.groupBox1.Controls.Add(this.uoClient);
            this.groupBox1.Controls.Add(this.browse);
            this.groupBox1.Controls.Add(this.label1);
            this.groupBox1.Controls.Add(this.patchEncy);
            this.groupBox1.Controls.Add(this.label2);
            this.groupBox1.Location = new System.Drawing.Point(12, 12);
            this.groupBox1.Name = "groupBox1";
            this.groupBox1.Size = new System.Drawing.Size(379, 135);
            this.groupBox1.TabIndex = 14;
            this.groupBox1.TabStop = false;
            this.groupBox1.Text = "Client Options";
            // 
            // langSel
            // 
            this.langSel.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
            this.langSel.Location = new System.Drawing.Point(77, 101);
            this.langSel.Name = "langSel";
            this.langSel.Size = new System.Drawing.Size(110, 23);
            this.langSel.TabIndex = 27;
            // 
            // label5
            // 
            this.label5.Location = new System.Drawing.Point(9, 104);
            this.label5.Name = "label5";
            this.label5.Size = new System.Drawing.Size(90, 20);
            this.label5.TabIndex = 28;
            this.label5.Text = "Language:";
            // 
            // showAtStart
            // 
            this.showAtStart.Location = new System.Drawing.Point(11, 76);
            this.showAtStart.Name = "showAtStart";
            this.showAtStart.Size = new System.Drawing.Size(176, 20);
            this.showAtStart.TabIndex = 26;
            this.showAtStart.Text = "Show this when Razor starts";
            this.showAtStart.CheckedChanged += new System.EventHandler(this.showAtStart_CheckedChanged);
            // 
            // dataDir
            // 
            this.dataDir.Location = new System.Drawing.Point(100, 47);
            this.dataDir.Name = "dataDir";
            this.dataDir.ReadOnly = true;
            this.dataDir.Size = new System.Drawing.Size(202, 23);
            this.dataDir.TabIndex = 2;
            // 
            // dataBrowse
            // 
            this.dataBrowse.Location = new System.Drawing.Point(308, 47);
            this.dataBrowse.Name = "dataBrowse";
            this.dataBrowse.Size = new System.Drawing.Size(63, 23);
            this.dataBrowse.TabIndex = 3;
            this.dataBrowse.Text = "Browse...";
            this.dataBrowse.Click += new System.EventHandler(this.dataBrowse_Click);
            // 
            // uoClient
            // 
            this.uoClient.Location = new System.Drawing.Point(100, 18);
            this.uoClient.Name = "uoClient";
            this.uoClient.ReadOnly = true;
            this.uoClient.Size = new System.Drawing.Size(202, 23);
            this.uoClient.TabIndex = 0;
            // 
            // label2
            // 
            this.label2.Location = new System.Drawing.Point(8, 48);
            this.label2.Name = "label2";
            this.label2.Size = new System.Drawing.Size(101, 19);
            this.label2.TabIndex = 25;
            this.label2.Text = "UO Data Folder:";
            this.label2.TextAlign = System.Drawing.ContentAlignment.MiddleLeft;
            // 
            // groupBox2
            // 
            this.groupBox2.Controls.Add(this.newServer);
            this.groupBox2.Controls.Add(this.serverName);
            this.groupBox2.Controls.Add(this.serverNameLbl);
            this.groupBox2.Controls.Add(this.serverPort);
            this.groupBox2.Controls.Add(this.serverHost);
            this.groupBox2.Controls.Add(this.portLabel);
            this.groupBox2.Controls.Add(this.serverHostLbl);
            this.groupBox2.Controls.Add(this.removeServer);
            this.groupBox2.Controls.Add(this.saveServer);
            this.groupBox2.Controls.Add(this.selectServerLbl);
            this.groupBox2.Controls.Add(this.serverList);
            this.groupBox2.Location = new System.Drawing.Point(12, 153);
            this.groupBox2.Name = "groupBox2";
            this.groupBox2.Size = new System.Drawing.Size(379, 147);
            this.groupBox2.TabIndex = 15;
            this.groupBox2.TabStop = false;
            this.groupBox2.Text = "Server";
            // 
            // newServer
            // 
            this.newServer.Location = new System.Drawing.Point(135, 50);
            this.newServer.Name = "newServer";
            this.newServer.Size = new System.Drawing.Size(62, 27);
            this.newServer.TabIndex = 20;
            this.newServer.Text = "New";
            this.newServer.UseVisualStyleBackColor = true;
            this.newServer.Click += new System.EventHandler(this.newServer_Click);
            // 
            // serverName
            // 
            this.serverName.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular,
                System.Drawing.GraphicsUnit.Point, ((byte) (0)));
            this.serverName.Location = new System.Drawing.Point(100, 86);
            this.serverName.Name = "serverName";
            this.serverName.Size = new System.Drawing.Size(270, 23);
            this.serverName.TabIndex = 6;
            this.serverName.TextChanged += new System.EventHandler(this.serverName_TextChanged);
            // 
            // serverNameLbl
            // 
            this.serverNameLbl.AutoSize = true;
            this.serverNameLbl.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular,
                System.Drawing.GraphicsUnit.Point, ((byte) (0)));
            this.serverNameLbl.Location = new System.Drawing.Point(7, 89);
            this.serverNameLbl.Name = "serverNameLbl";
            this.serverNameLbl.Size = new System.Drawing.Size(77, 15);
            this.serverNameLbl.TabIndex = 19;
            this.serverNameLbl.Text = "Server Name:";
            // 
            // serverPort
            // 
            this.serverPort.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular,
                System.Drawing.GraphicsUnit.Point, ((byte) (0)));
            this.serverPort.Location = new System.Drawing.Point(307, 116);
            this.serverPort.Name = "serverPort";
            this.serverPort.Size = new System.Drawing.Size(63, 23);
            this.serverPort.TabIndex = 8;
            this.serverPort.Text = "2593";
            this.serverPort.TextChanged += new System.EventHandler(this.serverPort_TextChanged);
            // 
            // serverHost
            // 
            this.serverHost.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular,
                System.Drawing.GraphicsUnit.Point, ((byte) (0)));
            this.serverHost.Location = new System.Drawing.Point(100, 115);
            this.serverHost.Name = "serverHost";
            this.serverHost.Size = new System.Drawing.Size(163, 23);
            this.serverHost.TabIndex = 7;
            this.serverHost.TextChanged += new System.EventHandler(this.serverHost_TextChanged);
            // 
            // portLabel
            // 
            this.portLabel.AutoSize = true;
            this.portLabel.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular,
                System.Drawing.GraphicsUnit.Point, ((byte) (0)));
            this.portLabel.Location = new System.Drawing.Point(269, 118);
            this.portLabel.Name = "portLabel";
            this.portLabel.Size = new System.Drawing.Size(32, 15);
            this.portLabel.TabIndex = 16;
            this.portLabel.Text = "Port:";
            // 
            // serverHostLbl
            // 
            this.serverHostLbl.AutoSize = true;
            this.serverHostLbl.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular,
                System.Drawing.GraphicsUnit.Point, ((byte) (0)));
            this.serverHostLbl.Location = new System.Drawing.Point(7, 118);
            this.serverHostLbl.Name = "serverHostLbl";
            this.serverHostLbl.Size = new System.Drawing.Size(85, 15);
            this.serverHostLbl.TabIndex = 15;
            this.serverHostLbl.Text = "Server Host/IP:";
            // 
            // removeServer
            // 
            this.removeServer.Location = new System.Drawing.Point(203, 50);
            this.removeServer.Name = "removeServer";
            this.removeServer.Size = new System.Drawing.Size(63, 27);
            this.removeServer.TabIndex = 10;
            this.removeServer.Text = "Remove";
            this.removeServer.UseVisualStyleBackColor = true;
            this.removeServer.Click += new System.EventHandler(this.removeServer_Click);
            // 
            // saveServer
            // 
            this.saveServer.Enabled = false;
            this.saveServer.Location = new System.Drawing.Point(272, 50);
            this.saveServer.Name = "saveServer";
            this.saveServer.Size = new System.Drawing.Size(63, 27);
            this.saveServer.TabIndex = 9;
            this.saveServer.Text = "Save";
            this.saveServer.UseVisualStyleBackColor = true;
            this.saveServer.Click += new System.EventHandler(this.saveServer_Click);
            // 
            // openFile
            // 
            this.openFile.DefaultExt = "exe";
            this.openFile.FileName = "client.exe";
            this.openFile.Filter = "UO Client|client.exe";
            this.openFile.Title = "Select UO Client";
            // 
            // WelcomeForm
            // 
            this.AcceptButton = this.okay;
            this.AutoScaleBaseSize = new System.Drawing.Size(6, 16);
            this.CancelButton = this.quit;
            this.ClientSize = new System.Drawing.Size(401, 358);
            this.Controls.Add(this.groupBox2);
            this.Controls.Add(this.groupBox1);
            this.Controls.Add(this.quit);
            this.Controls.Add(this.okay);
            this.Font = new System.Drawing.Font("Segoe UI", 9F, System.Drawing.FontStyle.Regular,
                System.Drawing.GraphicsUnit.Point, ((byte) (0)));
            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog;
            this.Icon = ((System.Drawing.Icon) (resources.GetObject("$this.Icon")));
            this.MaximizeBox = false;
            this.MinimizeBox = false;
            this.Name = "WelcomeForm";
            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
            this.Text = "Welcome to Razor: UOR Community Edition!";
            this.Closing += new System.ComponentModel.CancelEventHandler(this.WelcomeForm_Closing);
            this.Load += new System.EventHandler(this.WelcomeForm_Load);
            this.groupBox1.ResumeLayout(false);
            this.groupBox1.PerformLayout();
            this.groupBox2.ResumeLayout(false);
            this.groupBox2.PerformLayout();
            this.ResumeLayout(false);
        }

        #endregion

        private class ServerEntry
        {
            public ServerEntry(string addr, int p)
            {
                Address = addr;
                Port = p;
            }

            public string Address;
            public int Port;

            public override string ToString()
            {
                return Address;
            }
        }

        private class LoginCFG_SE : ServerEntry
        {
            public string RealAddress;

            public LoginCFG_SE() : base("Use Last", 0)
            {
                RealAddress = Config.GetAppSetting<string>("LastServer");
                Port = Config.GetAppSetting<int>("LastPort");

                if (string.IsNullOrEmpty(RealAddress) || Port == 0)
                {
                    RealAddress = "";
                    Port = 0;

                    try
                    {
                        string fileName = Ultima.Files.GetFilePath("Login.cfg");
                        if (string.IsNullOrEmpty(fileName))
                            return;
                        string server = null, port = null;

                        if (File.Exists(fileName))
                        {
                            using (FileStream file = new FileStream(fileName, FileMode.Open, FileAccess.Read,
                                FileShare.ReadWrite))
                            using (StreamReader cfg = new StreamReader(file))
                            {
                                string line;
                                while ((line = cfg.ReadLine()) != null)
                                {
                                    line = line.Trim();
                                    if (line != "" && Char.ToUpper(line[0]) == 'L' && line.Length > 12)
                                    {
                                        int comma = line.IndexOf(',');
                                        if (comma > 12)
                                        {
                                            server = line.Substring(12, comma - 12);
                                            port = line.Substring(comma + 1);

                                            break;
                                        }
                                    }
                                }
                            }
                        }

                        if (server != null)
                        {
                            Address = "(Use Last: " + server + ")";
                            RealAddress = server;
                        }

                        if (port != null)
                            Port = Utility.ToInt32(port, 0);
                    }
                    catch
                    {
                        RealAddress = Address = "Use Last";
                        Port = 0;
                    }
                }
            }
        }

        private class ShardEntry
        {
            public string name { get; set; }
            public string type { get; set; }
            public string host { get; set; }
            public int port { get; set; }
        }

        private class Custom_SE : ServerEntry
        {
            public string RealAddress { get; set; }
            public string Name { get; set; }

            public Custom_SE(string name, string addr) : base(name, 0)
            {
                Name = name;
                RealAddress = addr;
            }

            public Custom_SE(string name, string addr, int port)
                : base(name, port)
            {
                Name = name;
                RealAddress = addr;
            }
        }

        private class PathElipsis
        {
            private string m_Path;
            private string m_Show;

            public PathElipsis(string path)
            {
                m_Path = path;
                m_Show = GetPathElipsis(path, 23);
            }

            public string GetPath()
            {
                return m_Path;
            }

            public void SetPath(string value)
            {
                m_Path = value;
                m_Show = GetPathElipsis(m_Path, 23);
            }

            public override string ToString()
            {
                return m_Show;
            }

            private static char[] pathChars = new char[]
            {
                Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar, Path.PathSeparator,
                Path.VolumeSeparatorChar
            };

            public static string GetPathElipsis(string path, int PathMaxLength)
            {
                if (path.Length <= PathMaxLength)
                    return path;

                System.Text.StringBuilder sb = new System.Text.StringBuilder(path);
                int remlen = path.Length - PathMaxLength - 3;

                int ls = path.LastIndexOfAny(pathChars);
                if (ls == -1)
                    ls = 15 + remlen;

                if (ls - remlen < 4)
                    ls = remlen + 4;

                if (ls > remlen && remlen > 0)
                {
                    try
                    {
                        sb.Remove(ls - remlen, remlen);
                        sb.Insert(ls - remlen, "...");
                    }
                    catch
                    {
                    }
                }

                return sb.ToString();
            }
        }

        private void WelcomeForm_Load(object sender, System.EventArgs e)
        {
            Language.LoadControlNames(this);

            this.BringToFront();

            langSel.Items.AddRange(Language.GetPackNames());
            langSel.SelectedItem = Language.Current;

            showAtStart.Checked = Config.GetAppSetting<int>("ShowWelcome") == 1;

            uoClient.Text = Config.GetAppSetting<string>("UOClient");
            dataDir.Text = Config.GetAppSetting<string>("UODataDir");

            IsValidClientAndDataDir();

            patchEncy.Checked = Config.GetAppSetting<int>("ClientEncrypted") != 0;

            LoginCFG_SE lse = new LoginCFG_SE();

            serverList.BeginUpdate();
            
            // Load any custom servers they might have added
            NameValueCollection servers =
                (NameValueCollection) ConfigurationManager.GetSection("Servers");

            foreach (string server in servers.AllKeys)
            {
                string[] serverHostAndPort = servers[server].Split(',');
                string serverHost = serverHostAndPort[0];
                string serverPort = serverHostAndPort[1];

                serverList.Items.Add(new Custom_SE(server, serverHost, Convert.ToInt32(serverPort)));
            }

            serverList.EndUpdate();
            serverList.Refresh();

            // Set it to the last used one, or just set it to default UOR Prod
            try
            {
                serverList.SelectedIndex = Config.GetAppSetting<int>("LastServerId");
            }
            catch
            {
                serverList.SelectedIndex = 0;
            }

            WindowState = FormWindowState.Normal;
            this.BringToFront();
            this.TopMost = true;

            _ShowTimer = new System.Windows.Forms.Timer();
            _ShowTimer.Interval = 250;
            _ShowTimer.Enabled = true;
            _ShowTimer.Tick += new EventHandler(timer_Tick);


            if (Config.GetAppSetting<bool>("ImportProfilesAndMacros"))
            {
                string appDataDir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
                    "Razor");

                if (Directory.Exists(appDataDir))
                {
                    if (MessageBox.Show(Language.GetString(LocString.ImportFromPrevious),
                            "Import Razor Profiles and Macros",
                            MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
                    {
                        Config.ImportProfilesMacros(appDataDir);

                        MessageBox.Show("Import complete", "Import Razor Profiles and Macros", MessageBoxButtons.OK);
                    }
                }

                Config.SetAppSetting("ImportProfilesAndMacros", "false");
            }
        }
        
        private System.Windows.Forms.Timer _ShowTimer;

        private void timer_Tick(object sender, EventArgs e)
        {
            this.TopMost = false;
            this.BringToFront();

            if (_ShowTimer != null)
                _ShowTimer.Stop();
        }

        private void browse_Click(object sender, System.EventArgs e)
        {
            if (openFile.ShowDialog(this) == DialogResult.OK)
            {
                PathElipsis pe = new PathElipsis(openFile.FileName);

                uoClient.Text = pe.GetPath();

                dataDir.Text = m_DataDir = Path.GetDirectoryName(uoClient.Text);

                Config.SetAppSetting("UODataDir", dataDir.Text);
                Config.SetAppSetting("UOClient", uoClient.Text);

                IsValidClientAndDataDir();
            }
        }

        private void serverList_SelectedIndexChanged(object sender, System.EventArgs e)
        {
            if (serverList.SelectedIndex < 0)
            {
                serverName.Enabled = true;
                serverHost.Enabled = true;
                serverPort.Enabled = true;

                return;
            }

            Custom_SE server = (Custom_SE) serverList.SelectedItem;

            serverName.Enabled = !(serverList.SelectedIndex >= 0 && serverList.SelectedIndex <= 2);
            serverHost.Enabled = !(serverList.SelectedIndex >= 0 && serverList.SelectedIndex <= 2);
            serverPort.Enabled = !(serverList.SelectedIndex >= 0 && serverList.SelectedIndex <= 2);
            removeServer.Enabled = !(serverList.SelectedIndex >= 0 && serverList.SelectedIndex <= 2);

            serverName.Text = server.Name;
            serverHost.Text = server.RealAddress;
            serverPort.Text = server.Port.ToString();
            saveServer.Enabled = false;
        }

        private void okay_Click(object sender, System.EventArgs e)
        {
            m_ClientPath = uoClient.Text;

            ServerEntry se = null;

            if (serverList.SelectedItem != null)
            {
                if (serverList.SelectedItem is Custom_SE)
                {
                    int port = ((Custom_SE) serverList.SelectedItem).Port;

                    string addr = ((Custom_SE) serverList.SelectedItem).RealAddress;

                    if (addr == "login.ultimaonline.com")
                    {
                        Config.SetAppSetting("ServerEncrypted", "1");
                    }

                    if (port == 0)
                        port = 2593; // runuo default

                    se = new ServerEntry(addr, port);
                }
            }

            if (se != null && se.Address != null)
            {
                Config.SetAppSetting("LastServer", se.Address);
                Config.SetAppSetting("LastPort", se.Port.ToString());

                Config.SetAppSetting("LastServerId", serverList.SelectedIndex.ToString());
            }

            SaveData();
            this.Close();
        }

        private void quit_Click(object sender, System.EventArgs e)
        {
            SaveData();
            this.Close();
        }

        private void SaveData()
        {
            for (int i = 0; i < serverList.Items.Count; i++)
            {
                for (int j = i + 1; j < serverList.Items.Count; j++)
                {
                    ServerEntry si = (ServerEntry) serverList.Items[i];
                    ServerEntry sj = (ServerEntry) serverList.Items[j];
                    if (si.Address == sj.Address && si.Port == sj.Port)
                        serverList.Items.RemoveAt(j);
                }
            }

            int num = 1;
            for (int i = 0; i < serverList.Items.Count; i++)
            {
                ServerEntry se = (ServerEntry) serverList.Items[i];
                if (se is Custom_SE || se is LoginCFG_SE)
                    continue;

                if (se.Address != "")
                {
                    Config.SetAppSetting($"Server{num}", se.Address);
                    Config.SetAppSetting($"Port{num}", se.Port.ToString());
                    num++;
                }
            }

            Config.SetAppSetting("UOClient", uoClient.Text);
            Config.SetAppSetting("UODataDir", dataDir.Text);
            m_DataDir = dataDir.Text;
        }

        private void showAtStart_CheckedChanged(object sender, System.EventArgs e)
        {
            Config.SetAppSetting("ShowWelcome", (showAtStart.Checked ? 1 : 0).ToString());
        }

        private void langSel_SelectedIndexChanged(object sender, System.EventArgs e)
        {
            string lang = langSel.SelectedItem as string;

            if (lang != null && lang != Language.Current)
            {
                if (!Language.Load(lang))
                {
                    MessageBox.Show("There was an error loading that language.", "Language Load Error",
                        MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    langSel.SelectedItem = Language.Current;
                }
                else
                {
                    Config.SetAppSetting("DefaultLanguage", Language.Current);
                    Language.LoadControlNames(this);
                }
            }
        }

        private void patchEncy_CheckedChanged(object sender, System.EventArgs e)
        {
            if (!patchEncy.Checked)
            {
                if (MessageBox.Show(this, Language.GetString(LocString.NoPatchWarning),
                        Language.GetString(LocString.Confirm), MessageBoxButtons.YesNo, MessageBoxIcon.Question) ==
                    DialogResult.No)
                    patchEncy.Checked = true;
            }

            Config.SetAppSetting("ClientEncrypted", patchEncy.Checked ? "1" : "0");
        }

        private void dataBrowse_Click(object sender, System.EventArgs e)
        {
            FolderBrowserDialog folder = new FolderBrowserDialog();

            folder.Description = "Select a UO Data Directory...";

            if (m_DataDir != null)
                folder.SelectedPath = m_DataDir;

            folder.ShowNewFolderButton = false;
            if (folder.ShowDialog() == DialogResult.OK)
            {
                dataDir.Text = m_DataDir = folder.SelectedPath;
                Config.SetAppSetting("UODataDir", dataDir.Text);

                IsValidClientAndDataDir();

                if (!dataDir.Text.Equals(Path.GetDirectoryName(uoClient.Text)))
                {
                    MessageBox.Show(Language.GetString(LocString.ClientDataMismatch), "Warning", MessageBoxButtons.OK,
                        MessageBoxIcon.Warning);
                }
            }
        }

        private void WelcomeForm_Closing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            SaveData();
        }

        private bool IsValidClientAndDataDir()
        {
            okay.Enabled = false;

            if (string.IsNullOrEmpty(uoClient.Text) || string.IsNullOrEmpty(dataDir.Text))
            {
                return false;
            }


            if (!File.Exists(uoClient.Text) || !Directory.Exists(dataDir.Text))
            {
                return false;
            }

            okay.Enabled = true;
            return true;
        }

        private void saveServer_Click(object sender, EventArgs e)
        {
            if (string.IsNullOrEmpty(serverName.Text) || string.IsNullOrEmpty(serverHost.Text) ||
                string.IsNullOrEmpty(serverPort.Text))
            {
                MessageBox.Show("You must fill out all three fields", "Server Add/Edit", MessageBoxButtons.OK,
                    MessageBoxIcon.Error);
                return;
            }

            if (int.TryParse(serverPort.Text, out _) == false)
            {
                MessageBox.Show("Invalid port", "Server Add/Edit", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }

            Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
            AppSettingsSection servers = (AppSettingsSection) config.GetSection("Servers");

            if (string.IsNullOrEmpty(serverList.Text)) // new entry
            {
                servers.Settings.Add(serverName.Text, $"{serverHost.Text},{serverPort.Text}");
                config.Save(ConfigurationSaveMode.Modified, true);

                ConfigurationManager.RefreshSection("Servers");

                serverList.Items.Add(new Custom_SE(serverName.Text, serverHost.Text, Convert.ToInt32(serverPort.Text)));

                serverList.SelectedIndex = serverList.Items.Count - 1;
            }
            else
            {
                Dictionary<string, string> entries = new Dictionary<string, string>();

                int index = 3;
                foreach (KeyValueConfigurationElement server in servers.Settings)
                {
                    if (serverList.SelectedIndex == index)
                    {
                        entries.Add(serverName.Text, $"{serverHost.Text},{serverPort.Text}");
                    }
                    else
                    {
                        entries.Add(server.Key, server.Value);
                    }

                    index++;
                }

                servers.Settings.Clear();
                serverList.Items.Clear();
                
                foreach (KeyValuePair<string, string> entry in entries)
                {
                    servers.Settings.Add(entry.Key, entry.Value);

                    string[] address = entry.Value.Split(',');

                    serverList.Items.Add(new Custom_SE(entry.Key, address[0], Convert.ToInt32(address[1])));
                }

                config.Save(ConfigurationSaveMode.Modified, true);
                ConfigurationManager.RefreshSection("Servers");
            }

            saveServer.Enabled = false;
        }

        private void newServer_Click(object sender, EventArgs e)
        {
            serverName.Text = string.Empty;
            serverHost.Text = string.Empty;
            serverPort.Text = string.Empty;
            serverList.SelectedIndex = -1;

            saveServer.Enabled = true;
        }

        private void serverName_TextChanged(object sender, EventArgs e)
        {
            saveServer.Enabled = true;
        }

        private void serverHost_TextChanged(object sender, EventArgs e)
        {
            saveServer.Enabled = true;
        }

        private void serverPort_TextChanged(object sender, EventArgs e)
        {
            saveServer.Enabled = true;
        }

        private void removeServer_Click(object sender, EventArgs e)
        {
            if (serverList.SelectedIndex < 0)
                return;

            Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
            AppSettingsSection servers = (AppSettingsSection) config.GetSection("Servers");

            Dictionary<string, string> entries = new Dictionary<string, string>();

            int index = 0;
            foreach (KeyValueConfigurationElement server in servers.Settings)
            {
                if (serverList.SelectedIndex != index + 3)
                {
                    entries.Add(server.Key, server.Value);
                }

                index++;
            }

            servers.Settings.Clear();
            serverList.Items.Clear();
            
            foreach (KeyValuePair<string, string> entry in entries)
            {
                servers.Settings.Add(entry.Key, entry.Value);

                string[] address = entry.Value.Split(',');

                serverList.Items.Add(new Custom_SE(entry.Key, address[0], Convert.ToInt32(address[1])));
            }

            config.Save(ConfigurationSaveMode.Modified, true);
            ConfigurationManager.RefreshSection("Servers");

            serverName.Text = string.Empty;
            serverHost.Text = string.Empty;
            serverPort.Text = string.Empty;
        }
    }
}

================================================
FILE: Razor/UI/WelcomeForm.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <metadata name="openFile.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
    <value>17, 17</value>
  </metadata>
  <assembly alias="System.Drawing" name="System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
  <data name="$this.Icon" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
    <value>
        AAABAAEAICAAAAAAAACoCAAAFgAAACgAAAAgAAAAQAAAAAEACAAAAAAAAAQAAAAAAAAAAAAAAAEAAAAB
        AAAAAAAAAACAAACAAAAAgIAAgAAAAIAAgACAgAAAwMDAAMDcwADwyqYABAQEAAgICAAMDAwAERERABYW
        FgAcHBwAIiIiACkpKQBVVVUATU1NAEJCQgA5OTkAgHz/AFBQ/wCTANYA/+zMAMbW7wDW5+cAkKmtAAAA
        MwAAAGYAAACZAAAAzAAAMwAAADMzAAAzZgAAM5kAADPMAAAz/wAAZgAAAGYzAABmZgAAZpkAAGbMAABm
        /wAAmQAAAJkzAACZZgAAmZkAAJnMAACZ/wAAzAAAAMwzAADMZgAAzJkAAMzMAADM/wAA/2YAAP+ZAAD/
        zAAzAAAAMwAzADMAZgAzAJkAMwDMADMA/wAzMwAAMzMzADMzZgAzM5kAMzPMADMz/wAzZgAAM2YzADNm
        ZgAzZpkAM2bMADNm/wAzmQAAM5kzADOZZgAzmZkAM5nMADOZ/wAzzAAAM8wzADPMZgAzzJkAM8zMADPM
        /wAz/zMAM/9mADP/mQAz/8wAM///AGYAAABmADMAZgBmAGYAmQBmAMwAZgD/AGYzAABmMzMAZjNmAGYz
        mQBmM8wAZjP/AGZmAABmZjMAZmZmAGZmmQBmZswAZpkAAGaZMwBmmWYAZpmZAGaZzABmmf8AZswAAGbM
        MwBmzJkAZszMAGbM/wBm/wAAZv8zAGb/mQBm/8wAzAD/AP8AzACZmQAAmTOZAJkAmQCZAMwAmQAAAJkz
        MwCZAGYAmTPMAJkA/wCZZgAAmWYzAJkzZgCZZpkAmWbMAJkz/wCZmTMAmZlmAJmZmQCZmcwAmZn/AJnM
        AACZzDMAZsxmAJnMmQCZzMwAmcz/AJn/AACZ/zMAmcxmAJn/mQCZ/8wAmf//AMwAAACZADMAzABmAMwA
        mQDMAMwAmTMAAMwzMwDMM2YAzDOZAMwzzADMM/8AzGYAAMxmMwCZZmYAzGaZAMxmzACZZv8AzJkAAMyZ
        MwDMmWYAzJmZAMyZzADMmf8AzMwAAMzMMwDMzGYAzMyZAMzMzADMzP8AzP8AAMz/MwCZ/2YAzP+ZAMz/
        zADM//8AzAAzAP8AZgD/AJkAzDMAAP8zMwD/M2YA/zOZAP8zzAD/M/8A/2YAAP9mMwDMZmYA/2aZAP9m
        zADMZv8A/5kAAP+ZMwD/mWYA/5mZAP+ZzAD/mf8A/8wAAP/MMwD/zGYA/8yZAP/MzAD/zP8A//8zAMz/
        ZgD//5kA///MAGZm/wBm/2YAZv//AP9mZgD/Zv8A//9mACEApQBfX18Ad3d3AIaGhgCWlpYAy8vLALKy
        sgDX19cA3d3dAOPj4wDq6uoA8fHxAPj4+ADw+/8ApKCgAICAgAAAAP8AAP8AAAD//wD/AAAA/wD/AP//
        AAD///8ACgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoK
        CgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCrcKCgoKCgoKCgoKCgoK
        CgoKCgoKCgoKCgoKCgoKCgoK+QoKCgoKCgoKCgrSCgoKCgoKCgoKCgoKCgoKCgoKCgr5+QoKCgoKCgr5
        sQoKCgoKCgoKCgoKCgoKCgoKCgoKCvn5CgoKCgoKsbEKCgoKCgoKCgoKCgoKCgoKCgoKCgoK+ZQKCgoK
        CuPjCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgr5sQoKCgpHsQoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgpq
        Cgr5QbEKCgqxtwoKCgoKCgr5CgoK+QoKCgoKCgoKCuP5lPmUCgoKCrGxt7f5+fkKCvkK+fkKCgoKCgoK
        CgoKFkH5lAoK+QoK+bcKCgr5t7cK+fn5CgoKCgoKCgoKCrdB+fkKCgoK0rext7EKCvn5Crf5+QoKCgoK
        CgoKCgqx+UdBCgoKCgq3+fkKt5QK+fkK0vn5CgoKCgoKCgoKCgq3+UGUCgoKCvmxtwoKsbcK+QqUCvn5
        +QoKCgoKCgoKCgr5F0f5CgoKCmqxCgoKavn5+eP5arexagoKCgoKCgoKCgqU+Wrj+QoKt7cKRmlq+Qq3
        lJQXF+MWCgoKCgoKCgoKCvn5+flq4/kKCuvs7O0KCgoKCgoKCgoKCgoKCgoKCgoKCkfjCgoWRxaSku3s
        7OwKCgoKCgoKCgoKCgoKCgoKCgoK+fkKCgr5bpKS7e3t7eztCgoKCgoKCgoKCgoKCgoKCgr5+ZQKCgqS
        kpLt7e3t7e3tCgoKCgoKCgoKCgoKCgoKCgr54woK7++SkpLt7e3t7Ozs7fcKCgoKCgoKCgoKCrHjFkEX
        FhZpku/3kpLt7e3s7Ozs7JIKCgoKCgoKCgoKR/n5+fn5+fkg7e+SkpLt7Ozs7Ozs7ZIKCgoKCgoKCgpH
        QUFBQUcXahbt95KS7e3s7Ozs7Oztkvf3CgoKCgoKCgoKCgrs6+wKCpKS7e3t7Ozs7Ozt7ZL39+/vCgoK
        CgoKCgoKCuzr6uzs7ZLt7ezs7Ozs7ZKS9+/v7+/vCgoKCgoKCgrr7JLrbeyS7ezs7Ozs7ZKS9/fv7wcH
        BwcKCgoKCgoK7BLs7/fs7Ozs7Ozs7O2S9+/v7+8HBwcHBwoKCgoKCgoSbe8H7+zt7Ovs7O2Skvfv7+8H
        BwcHBwcHCgoKCgoK7ezv7++S7O3v9+zs9/fv7+8HBwcHBwcH8fAKCgoKCuwS6+ztkvfv7+8HB/f3B7y8
        vPDw8PDwvPP/8/////////////////f////3/v//8/n///Pz///z5///88////sc/u/4PAaf+GziP/Dw
        ZH/h8SR/8PGVH/h5wA/8GQgP/AYf//5gD//+cAP//jgB//8wAD/4AAAf+AAAD/gAAAP/jAAB/4AAAP8A
        AAD+AAAA/gAAAPwAAAD4AAAA
</value>
  </data>
</root>

================================================
FILE: Razor/UltimaSDK/ASCIIFont.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System.Drawing;
using System.Drawing.Imaging;
using System.IO;

// ascii text support written by arul
namespace Ultima
{
    public sealed class ASCIIFont
    {
        public byte Header { get; private set; }
        public byte[] Unk { get; set; }
        public Bitmap[] Characters { get; set; }
        public int Height { get; set; }


        public ASCIIFont(byte header)
        {
            Header = header;
            Height = 0;
            Unk = new byte[224];
            Characters = new Bitmap[224];
        }

        /// <summary>
        /// Gets Bitmap of given character
        /// </summary>
        /// <param name="character"></param>
        /// <returns></returns>
        public Bitmap GetBitmap(char character)
        {
            return Characters[(((((int) character) - 0x20) & 0x7FFFFFFF) % 224)];
        }

        public int GetWidth(string text)
        {
            if (text == null || text.Length == 0)
            {
                return 0;
            }

            int width = 0;

            for (int i = 0; i < text.Length; ++i)
            {
                width += GetBitmap(text[i]).Width;
            }

            return width;
        }

        public void ReplaceCharacter(int character, Bitmap import)
        {
            Characters[character] = import;
            Height = import.Height;
        }

        public static ASCIIFont GetFixed(int font)
        {
            if (font < 0 || font > 9)
            {
                return ASCIIText.Fonts[3];
            }

            return ASCIIText.Fonts[font];
        }
    }

    public static class ASCIIText
    {
        public static ASCIIFont[] Fonts = new ASCIIFont[10];

        static ASCIIText()
        {
            Initialize();
        }

        /// <summary>
        /// Reads fonts.mul
        /// </summary>
        public static unsafe void Initialize()
        {
            string path = Files.GetFilePath("fonts.mul");

            if (path != null)
            {
                using (FileStream reader = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read))
                {
                    byte[] buffer = new byte[(int) reader.Length];
                    reader.Read(buffer, 0, (int) reader.Length);
                    fixed (byte* bin = buffer)
                    {
                        byte* read = bin;
                        for (int i = 0; i < 10; ++i)
                        {
                            byte header = *read++;
                            Fonts[i] = new ASCIIFont(header);

                            for (int k = 0; k < 224; ++k)
                            {
                                byte width = *read++;
                                byte height = *read++;
                                byte unk = *read++; // delimeter?

                                if (width > 0 && height > 0)
                                {
                                    if (height > Fonts[i].Height && k < 96)
                                        Fonts[i].Height = height;

                                    Bitmap bmp = new Bitmap(width, height);
                                    BitmapData bd = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height),
                                        ImageLockMode.WriteOnly, PixelFormat.Format16bppArgb1555);
                                    ushort* line = (ushort*) bd.Scan0;
                                    int delta = bd.Stride >> 1;

                                    for (int y = 0; y < height; ++y, line += delta)
                                    {
                                        ushort* cur = line;
                                        for (int x = 0; x < width; ++x)
                                        {
                                            ushort pixel = (ushort) (*read++ | (*read++ << 8));
                                            if (pixel == 0)
                                                cur[x] = pixel;
                                            else
                                                cur[x] = (ushort) (pixel ^ 0x8000);
                                        }
                                    }

                                    bmp.UnlockBits(bd);
                                    Fonts[i].Characters[k] = bmp;
                                    Fonts[i].Unk[k] = unk;
                                }
                            }
                        }
                    }
                }
            }
        }

        public static unsafe void Save(string FileName)
        {
            using (FileStream fs = new FileStream(FileName, FileMode.Create, FileAccess.Write, FileShare.Write))
            {
                using (BinaryWriter bin = new BinaryWriter(fs))
                {
                    for (int i = 0; i < 10; ++i)
                    {
                        bin.Write(Fonts[i].Header);
                        for (int k = 0; k < 224; ++k)
                        {
                            bin.Write((byte) Fonts[i].Characters[k].Width);
                            bin.Write((byte) Fonts[i].Characters[k].Height);
                            bin.Write(Fonts[i].Unk[k]);
                            Bitmap bmp = Fonts[i].Characters[k];
                            BitmapData bd = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height),
                                ImageLockMode.ReadOnly, PixelFormat.Format16bppArgb1555);
                            ushort* line = (ushort*) bd.Scan0;
                            int delta = bd.Stride >> 1;
                            for (int y = 0; y < bmp.Height; ++y, line += delta)
                            {
                                ushort* cur = line;
                                for (int x = 0; x < bmp.Width; ++x)
                                {
                                    if (cur[x] == 0)
                                        bin.Write(cur[x]);
                                    else
                                        bin.Write((ushort) (cur[x] ^ 0x8000));
                                }
                            }

                            bmp.UnlockBits(bd);
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Draws Text with font in Bitmap and returns
        /// </summary>
        /// <param name="fontId"></param>
        /// <param name="text"></param>
        /// <returns></returns>
        public static Bitmap DrawText(int fontId, string text)
        {
            ASCIIFont font = ASCIIFont.GetFixed(fontId);
            Bitmap result = new Bitmap(font.GetWidth(text) + 2, font.Height + 2);

            int dx = 2;
            int dy = font.Height + 2;
            using (Graphics graph = Graphics.FromImage(result))
            {
                for (int i = 0; i < text.Length; ++i)
                {
                    Bitmap bmp = font.GetBitmap(text[i]);
                    graph.DrawImage(bmp, dx, dy - bmp.Height);
                    dx += bmp.Width;
                }
            }

            return result;
        }
    }
}

================================================
FILE: Razor/UltimaSDK/AnimationEdit.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;

//using System.Windows.Media.Imaging;

namespace Ultima
{
    public sealed class AnimationEdit
    {
        private static FileIndex m_FileIndex = new FileIndex("Anim.idx", "Anim.mul", 6);
        private static FileIndex m_FileIndex2 = new FileIndex("Anim2.idx", "Anim2.mul", -1);
        private static FileIndex m_FileIndex3 = new FileIndex("Anim3.idx", "Anim3.mul", -1);
        private static FileIndex m_FileIndex4 = new FileIndex("Anim4.idx", "Anim4.mul", -1);
        private static FileIndex m_FileIndex5 = new FileIndex("Anim5.idx", "Anim5.mul", -1);

        private static AnimIdx[] animcache;
        private static AnimIdx[] animcache2;
        private static AnimIdx[] animcache3;
        private static AnimIdx[] animcache4;
        private static AnimIdx[] animcache5;

        static AnimationEdit()
        {
            if (m_FileIndex.IdxLength > 0)
                animcache = new AnimIdx[m_FileIndex.IdxLength / 12];
            if (m_FileIndex2.IdxLength > 0)
                animcache2 = new AnimIdx[m_FileIndex2.IdxLength / 12];
            if (m_FileIndex3.IdxLength > 0)
                animcache3 = new AnimIdx[m_FileIndex3.IdxLength / 12];
            if (m_FileIndex4.IdxLength > 0)
                animcache4 = new AnimIdx[m_FileIndex4.IdxLength / 12];
            if (m_FileIndex5.IdxLength > 0)
                animcache5 = new AnimIdx[m_FileIndex5.IdxLength / 12];
        }

        /// <summary>
        /// Rereads AnimX files
        /// </summary>
        public static void Reload()
        {
            m_FileIndex = new FileIndex("Anim.idx", "Anim.mul", 6);
            m_FileIndex2 = new FileIndex("Anim2.idx", "Anim2.mul", -1);
            m_FileIndex3 = new FileIndex("Anim3.idx", "Anim3.mul", -1);
            m_FileIndex4 = new FileIndex("Anim4.idx", "Anim4.mul", -1);
            m_FileIndex5 = new FileIndex("Anim5.idx", "Anim5.mul", -1);
            if (m_FileIndex.IdxLength > 0)
                animcache = new AnimIdx[m_FileIndex.IdxLength / 12];
            if (m_FileIndex2.IdxLength > 0)
                animcache = new AnimIdx[m_FileIndex2.IdxLength / 12];
            if (m_FileIndex3.IdxLength > 0)
                animcache = new AnimIdx[m_FileIndex3.IdxLength / 12];
            if (m_FileIndex4.IdxLength > 0)
                animcache = new AnimIdx[m_FileIndex4.IdxLength / 12];
            if (m_FileIndex5.IdxLength > 0)
                animcache = new AnimIdx[m_FileIndex5.IdxLength / 12];
        }

        private static void GetFileIndex(int body, int fileType, int action, int direction, out FileIndex fileIndex,
            out int index)
        {
            switch (fileType)
            {
                default:
                case 1:
                    fileIndex = m_FileIndex;
                    if (body < 200)
                        index = body * 110;
                    else if (body < 400)
                        index = 22000 + ((body - 200) * 65);
                    else
                        index = 35000 + ((body - 400) * 175);
                    break;
                case 2:
                    fileIndex = m_FileIndex2;
                    if (body < 200)
                        index = body * 110;
                    else
                        index = 22000 + ((body - 200) * 65);
                    break;
                case 3:
                    fileIndex = m_FileIndex3;
                    if (body < 300)
                        index = body * 65;
                    else if (body < 400)
                        index = 33000 + ((body - 300) * 110);
                    else
                        index = 35000 + ((body - 400) * 175);
                    break;
                case 4:
                    fileIndex = m_FileIndex4;
                    if (body < 200)
                        index = body * 110;
                    else if (body < 400)
                        index = 22000 + ((body - 200) * 65);
                    else
                        index = 35000 + ((body - 400) * 175);
                    break;
                case 5:
                    fileIndex = m_FileIndex5;
                    if ((body < 200) && (body != 34)) // looks strange, though it works.
                        index = body * 110;
                    else if (body < 400)
                        index = 22000 + ((body - 200) * 65);
                    else
                        index = 35000 + ((body - 400) * 175);
                    break;
            }

            index += action * 5;

            if (direction <= 4)
                index += direction;
            else
                index += direction - (direction - 4) * 2;
        }

        private static AnimIdx[] GetCache(int filetype)
        {
            switch (filetype)
            {
                case 1:
                    return animcache;
                case 2:
                    return animcache2;
                case 3:
                    return animcache3;
                case 4:
                    return animcache4;
                case 5:
                    return animcache5;
                default:
                    return animcache;
            }
        }

        public static AnimIdx GetAnimation(int filetype, int body, int action, int dir)
        {
            AnimIdx[] cache = GetCache(filetype);
            FileIndex fileIndex;
            int index;
            GetFileIndex(body, filetype, action, dir, out fileIndex, out index);

            if (cache != null)
            {
                if (cache[index] != null)
                    return cache[index];
            }

            return cache[index] = new AnimIdx(index, fileIndex, filetype);
        }

        public static bool IsActionDefinied(int filetype, int body, int action)
        {
            AnimIdx[] cache = GetCache(filetype);
            FileIndex fileIndex;
            int index;
            GetFileIndex(body, filetype, action, 0, out fileIndex, out index);

            if (cache != null)
            {
                if (cache[index] != null)
                {
                    if ((cache[index].Frames != null) && (cache[index].Frames.Count > 0))
                        return true;
                    else
                        return false;
                }
            }

            int AnimCount = Animations.GetAnimLength(body, filetype);
            if (AnimCount < action)
                return false;

            int length, extra;
            bool patched;
            bool valid = fileIndex.Valid(index, out length, out extra, out patched);
            if ((!valid) || (length < 1))
                return false;
            return true;
        }

        public static void LoadFromVD(int filetype, int body, BinaryReader bin)
        {
            AnimIdx[] cache = GetCache(filetype);
            FileIndex fileIndex;
            int index;
            GetFileIndex(body, filetype, 0, 0, out fileIndex, out index);
            int animlength = Animations.GetAnimLength(body, filetype) * 5;
            Entry3D[] entries = new Entry3D[animlength];

            for (int i = 0; i < animlength; ++i)
            {
                entries[i].lookup = bin.ReadInt32();
                entries[i].length = bin.ReadInt32();
                entries[i].extra = bin.ReadInt32();
            }

            foreach (Entry3D entry in entries)
            {
                if ((entry.lookup > 0) && (entry.lookup < bin.BaseStream.Length) && (entry.length > 0))
                {
                    bin.BaseStream.Seek(entry.lookup, SeekOrigin.Begin);
                    cache[index] = new AnimIdx(bin, entry.extra);
                }

                ++index;
            }
        }

        public static void ExportToVD(int filetype, int body, string file)
        {
            AnimIdx[] cache = GetCache(filetype);
            FileIndex fileIndex;
            int index;
            GetFileIndex(body, filetype, 0, 0, out fileIndex, out index);
            using (FileStream fs = new FileStream(file, FileMode.Create, FileAccess.Write, FileShare.Write))
            {
                using (BinaryWriter bin = new BinaryWriter(fs))
                {
                    bin.Write((short) 6);
                    int animlength = Animations.GetAnimLength(body, filetype);
                    int currtype = animlength == 22 ? 0 : animlength == 13 ? 1 : 2;
                    bin.Write((short) currtype);
                    long indexpos = bin.BaseStream.Position;
                    long animpos = bin.BaseStream.Position + 12 * animlength * 5;
                    for (int i = index; i < index + animlength * 5; i++)
                    {
                        AnimIdx anim;
                        if (cache != null)
                        {
                            if (cache[i] != null)
                                anim = cache[i];
                            else
                                anim = cache[i] = new AnimIdx(i, fileIndex, filetype);
                        }
                        else
                            anim = cache[i] = new AnimIdx(i, fileIndex, filetype);

                        if (anim == null)
                        {
                            bin.BaseStream.Seek(indexpos, SeekOrigin.Begin);
                            bin.Write((int) -1);
                            bin.Write((int) -1);
                            bin.Write((int) -1);
                            indexpos = bin.BaseStream.Position;
                        }
                        else
                            anim.ExportToVD(bin, ref indexpos, ref animpos);
                    }
                }
            }
        }

        public static void Save(int filetype, string path)
        {
            string filename;
            AnimIdx[] cache;
            FileIndex fileindex;
            switch (filetype)
            {
                case 1:
                    filename = "anim";
                    cache = animcache;
                    fileindex = m_FileIndex;
                    break;
                case 2:
                    filename = "anim2";
                    cache = animcache2;
                    fileindex = m_FileIndex2;
                    break;
                case 3:
                    filename = "anim3";
                    cache = animcache3;
                    fileindex = m_FileIndex3;
                    break;
                case 4:
                    filename = "anim4";
                    cache = animcache4;
                    fileindex = m_FileIndex4;
                    break;
                case 5:
                    filename = "anim5";
                    cache = animcache5;
                    fileindex = m_FileIndex5;
                    break;
                default:
                    filename = "anim";
                    cache = animcache;
                    fileindex = m_FileIndex;
                    break;
            }

            string idx = Path.Combine(path, filename + ".idx");
            string mul = Path.Combine(path, filename + ".mul");
            using (FileStream fsidx = new FileStream(idx, FileMode.Create, FileAccess.Write, FileShare.Write),
                fsmul = new FileStream(mul, FileMode.Create, FileAccess.Write, FileShare.Write))
            {
                using (BinaryWriter binidx = new BinaryWriter(fsidx),
                    binmul = new BinaryWriter(fsmul))
                {
                    for (int idxc = 0; idxc < cache.Length; ++idxc)
                    {
                        AnimIdx anim;
                        if (cache != null)
                        {
                            if (cache[idxc] != null)
                                anim = cache[idxc];
                            else
                                anim = cache[idxc] = new AnimIdx(idxc, fileindex, filetype);
                        }
                        else
                            anim = cache[idxc] = new AnimIdx(idxc, fileindex, filetype);

                        if (anim == null)
                        {
                            binidx.Write((int) -1);
                            binidx.Write((int) -1);
                            binidx.Write((int) -1);
                        }
                        else
                            anim.Save(binmul, binidx);
                    }
                }
            }
        }
    }

    public sealed class AnimIdx
    {
        public int idxextra;
        public ushort[] Palette { get; private set; }
        public List<FrameEdit> Frames { get; private set; }

        public AnimIdx(int index, FileIndex fileIndex, int filetype)
        {
            Palette = new ushort[0x100];
            int length, extra;
            bool patched;
            Stream stream = fileIndex.Seek(index, out length, out extra, out patched);
            if ((stream == null) || (length < 1))
                return;

            idxextra = extra;
            using (BinaryReader bin = new BinaryReader(stream))
            {
                for (int i = 0; i < 0x100; ++i)
                    Palette[i] = (ushort) (bin.ReadUInt16() ^ 0x8000);

                int start = (int) bin.BaseStream.Position;
                int frameCount = bin.ReadInt32();

                int[] lookups = new int[frameCount];

                for (int i = 0; i < frameCount; ++i)
                    lookups[i] = start + bin.ReadInt32();

                Frames = new List<FrameEdit>();

                for (int i = 0; i < frameCount; ++i)
                {
                    stream.Seek(lookups[i], SeekOrigin.Begin);
                    Frames.Add(new FrameEdit(bin));
                }
            }

            stream.Close();
        }

        public AnimIdx(BinaryReader bin, int extra)
        {
            Palette = new ushort[0x100];
            idxextra = extra;
            for (int i = 0; i < 0x100; ++i)
                Palette[i] = (ushort) (bin.ReadUInt16() ^ 0x8000);

            int start = (int) bin.BaseStream.Position;
            int frameCount = bin.ReadInt32();

            int[] lookups = new int[frameCount];

            for (int i = 0; i < frameCount; ++i)
                lookups[i] = start + bin.ReadInt32();

            Frames = new List<FrameEdit>();

            for (int i = 0; i < frameCount; ++i)
            {
                bin.BaseStream.Seek(lookups[i], SeekOrigin.Begin);
                Frames.Add(new FrameEdit(bin));
            }
        }

        public unsafe Bitmap[] GetFrames()
        {
            if ((Frames == null) || (Frames.Count == 0))
                return null;
            Bitmap[] bits = new Bitmap[Frames.Count];
            for (int i = 0; i < bits.Length; ++i)
            {
                FrameEdit frame = Frames[i];
                int width = frame.width;
                int height = frame.height;
                if (height == 0 || width == 0)
                    continue;
                Bitmap bmp = new Bitmap(width, height, PixelFormat.Format16bppArgb1555);
                BitmapData bd = bmp.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.WriteOnly,
                    PixelFormat.Format16bppArgb1555);
                ushort* line = (ushort*) bd.Scan0;
                int delta = bd.Stride >> 1;

                int xBase = frame.Center.X - 0x200;
                int yBase = frame.Center.Y + height - 0x200;

                line += xBase;
                line += yBase * delta;
                for (int j = 0; j < frame.RawData.Length; ++j)
                {
                    FrameEdit.Raw raw = frame.RawData[j];

                    ushort* cur = line + (((raw.offy) * delta) + ((raw.offx) & 0x3FF));
                    ushort* end = cur + (raw.run);

                    int ii = 0;
                    while (cur < end)
                    {
                        *cur++ = Palette[raw.data[ii++]];
                    }
                }

                bmp.UnlockBits(bd);
                bits[i] = bmp;
            }

            return bits;
        }

        public void AddFrame(Bitmap bit)
        {
            if (Frames == null)
                Frames = new List<FrameEdit>();
            Frames.Add(new FrameEdit(bit, Palette, 0, 0));
        }

        public void ReplaceFrame(Bitmap bit, int index)
        {
            if ((Frames == null) || (Frames.Count == 0))
                return;
            if (index > Frames.Count)
                return;
            Frames[index] = new FrameEdit(bit, Palette, ((FrameEdit) Frames[index]).Center.X,
                ((FrameEdit) Frames[index]).Center.Y);
        }

        public void RemoveFrame(int index)
        {
            if (Frames == null)
                return;
            if (index > Frames.Count)
                return;
            Frames.RemoveAt(index);
        }

        public void ClearFrames()
        {
            if (Frames == null)
                return;
            Frames.Clear();
        }

#if false
		//Soulblighter Modification
		public void GetGifPalette(Bitmap bit)
		{
			using (MemoryStream imageStreamSource = new MemoryStream())
			{
				System.Drawing.ImageConverter ic = new System.Drawing.ImageConverter();
				byte[] btImage = (byte[])ic.ConvertTo(bit, typeof(byte[]));
				imageStreamSource.Write(btImage, 0, btImage.Length);
				GifBitmapDecoder decoder =
 new GifBitmapDecoder(imageStreamSource, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
				BitmapPalette pal = decoder.Palette;
				int i;
				for (i = 0; i < 0x100; i++)
				{
					this.Palette[i] = 0;
				}
				try
				{
					i = 0;
					while (i < 0x100)//&& i < pal.Colors.Count)
					{

						int Red = pal.Colors[i].R / 8;
						int Green = pal.Colors[i].G / 8;
						int Blue = pal.Colors[i].B / 8;
						int contaFinal = (((0x400 * Red) + (0x20 * Green)) + Blue) + 0x8000;
						if (contaFinal == 0x8000)
							contaFinal = 0x8001;
						this.Palette[i] = (ushort)contaFinal;
						i++;
					}
				}
				catch (System.IndexOutOfRangeException)
				{ }
				catch (System.ArgumentOutOfRangeException)
				{ }
				for (i = 0; i < 0x100; i++)
				{
					if (this.Palette[i] < 0x8000)
						this.Palette[i] = 0x8000;
				}
			}
		}
#endif

        public unsafe void GetImagePalette(Bitmap bit)
        {
            int count = 0;
            Bitmap bmp = new Bitmap(bit);
            BitmapData bd = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly,
                PixelFormat.Format16bppArgb1555);
            ushort* line = (ushort*) bd.Scan0;
            int delta = bd.Stride >> 1;
            ushort* cur = line;
            int i = 0;
            while (i < 0x100)
            {
                this.Palette[i] = 0;
                i++;
            }

            int y = 0;
            while (y < bmp.Height)
            {
                cur = line;
                for (int x = 0; x < bmp.Width; x++)
                {
                    ushort c = cur[x];
                    if (c != 0)
                    {
                        bool found = false;
                        i = 0;
                        while (i < this.Palette.Length)
                        {
                            if (this.Palette[i] == c)
                            {
                                found = true;
                                break;
                            }

                            i++;
                        }

                        if (!found)
                            this.Palette[count++] = c;
                        if (count >= 0x100)
                            break;
                    }
                }

                for (i = 0; i < 0x100; i++)
                {
                    if (this.Palette[i] < 0x8000)
                        this.Palette[i] = 0x8000;
                }

                if (count >= 0x100)
                    break;
                y++;
                line += delta;
            }
        }

        public void PaletteConversor(int seletor)
        {
            int i;
            for (i = 0; i < 0x100; i++)
            {
                int BlueTemp = (this.Palette[i] - 0x8000) / 0x20;
                BlueTemp *= 0x20;
                BlueTemp = (this.Palette[i] - 0x8000) - BlueTemp;
                int GreenTemp = (this.Palette[i] - 0x8000) / 0x400;
                GreenTemp *= 0x400;
                GreenTemp = ((this.Palette[i] - 0x8000) - GreenTemp) - BlueTemp;
                GreenTemp /= 0x20;
                int RedTemp = (this.Palette[i] - 0x8000) / 0x400;
                int contaFinal = 0;
                switch (seletor)
                {
                    case 1:
                        contaFinal = (((0x400 * RedTemp) + (0x20 * GreenTemp)) + BlueTemp) + 0x8000;
                        break;
                    case 2:
                        contaFinal = (((0x400 * RedTemp) + (0x20 * BlueTemp)) + GreenTemp) + 0x8000;
                        break;
                    case 3:
                        contaFinal = (((0x400 * GreenTemp) + (0x20 * RedTemp)) + BlueTemp) + 0x8000;
                        break;
                    case 4:
                        contaFinal = (((0x400 * GreenTemp) + (0x20 * BlueTemp)) + RedTemp) + 0x8000;
                        break;
                    case 5:
                        contaFinal = (((0x400 * BlueTemp) + (0x20 * GreenTemp)) + RedTemp) + 0x8000;
                        break;
                    case 6:
                        contaFinal = (((0x400 * BlueTemp) + (0x20 * RedTemp)) + GreenTemp) + 0x8000;
                        break;
                }

                if (contaFinal == 0x8000)
                    contaFinal = 0x8001;
                this.Palette[i] = (ushort) contaFinal;
            }

            for (i = 0; i < 0x100; i++)
            {
                if (this.Palette[i] < 0x8000)
                    this.Palette[i] = 0x8000;
            }
        }

        public void PaletteReductor(int Redp, int Greenp, int Bluep)
        {
            int i;
            Redp /= 8;
            Greenp /= 8;
            Bluep /= 8;
            for (i = 0; i < 0x100; i++)
            {
                int BlueTemp = (this.Palette[i] - 0x8000) / 0x20;
                BlueTemp *= 0x20;
                BlueTemp = (this.Palette[i] - 0x8000) - BlueTemp;
                int GreenTemp = (this.Palette[i] - 0x8000) / 0x400;
                GreenTemp *= 0x400;
                GreenTemp = ((this.Palette[i] - 0x8000) - GreenTemp) - BlueTemp;
                GreenTemp /= 0x20;
                int RedTemp = (this.Palette[i] - 0x8000) / 0x400;
                RedTemp += Redp;
                GreenTemp += Greenp;
                BlueTemp += Bluep;
                if (RedTemp < 0)
                    RedTemp = 0;
                if (RedTemp > 0x1f)
                    RedTemp = 0x1f;
                if (GreenTemp < 0)
                    GreenTemp = 0;
                if (GreenTemp > 0x1f)
                    GreenTemp = 0x1f;
                if (BlueTemp < 0)
                    BlueTemp = 0;
                if (BlueTemp > 0x1f)
                    BlueTemp = 0x1f;
                int contaFinal = (((0x400 * RedTemp) + (0x20 * GreenTemp)) + BlueTemp) + 0x8000;
                if (contaFinal == 0x8000)
                    contaFinal = 0x8001;
                this.Palette[i] = (ushort) contaFinal;
            }

            for (i = 0; i < 0x100; i++)
            {
                if (this.Palette[i] < 0x8000)
                    this.Palette[i] = 0x8000;
            }
        }
        //End of Soulblighter Modification


        public unsafe void ExportPalette(string filename, int type)
        {
            switch (type)
            {
                case 0:
                    using (StreamWriter Tex =
                        new StreamWriter(new FileStream(filename, FileMode.Create, FileAccess.ReadWrite)))
                    {
                        for (int i = 0; i < 0x100; ++i)
                        {
                            Tex.WriteLine(Palette[i]);
                        }
                    }

                    break;
                case 1:
                {
                    Bitmap bmp = new Bitmap(0x100, 20, PixelFormat.Format16bppArgb1555);
                    BitmapData bd = bmp.LockBits(new Rectangle(0, 0, 0x100, 20), ImageLockMode.WriteOnly,
                        PixelFormat.Format16bppArgb1555);
                    ushort* line = (ushort*) bd.Scan0;
                    int delta = bd.Stride >> 1;
                    for (int y = 0; y < bd.Height; ++y, line += delta)
                    {
                        ushort* cur = line;
                        for (int i = 0; i < 0x100; ++i)
                        {
                            *cur++ = Palette[i];
                        }
                    }

                    bmp.UnlockBits(bd);
                    Bitmap b = new Bitmap(bmp);
                    b.Save(filename, ImageFormat.Bmp);
                    b.Dispose();
                    bmp.Dispose();
                    break;
                }

                case 2:
                {
                    Bitmap bmp = new Bitmap(0x100, 20, PixelFormat.Format16bppArgb1555);
                    BitmapData bd = bmp.LockBits(new Rectangle(0, 0, 0x100, 20), ImageLockMode.WriteOnly,
                        PixelFormat.Format16bppArgb1555);
                    ushort* line = (ushort*) bd.Scan0;
                    int delta = bd.Stride >> 1;
                    for (int y = 0; y < bd.Height; ++y, line += delta)
                    {
                        ushort* cur = line;
                        for (int i = 0; i < 0x100; ++i)
                        {
                            *cur++ = Palette[i];
                        }
                    }

                    bmp.UnlockBits(bd);
                    Bitmap b = new Bitmap(bmp);
                    b.Save(filename, ImageFormat.Tiff);
                    b.Dispose();
                    bmp.Dispose();
                    break;
                }
            }
        }

        public void ReplacePalette(ushort[] palette)
        {
            Palette = palette;
        }

        public void Save(BinaryWriter bin, BinaryWriter idx)
        {
            if ((Frames == null) || (Frames.Count == 0))
            {
                idx.Write((int) -1);
                idx.Write((int) -1);
                idx.Write((int) -1);
                return;
            }

            long start = bin.BaseStream.Position;
            idx.Write((int) start);

            for (int i = 0; i < 0x100; ++i)
                bin.Write((ushort) (Palette[i] ^ 0x8000));
            long startpos = bin.BaseStream.Position;
            bin.Write((int) Frames.Count);
            long seek = bin.BaseStream.Position;
            long curr = bin.BaseStream.Position + 4 * Frames.Count;
            foreach (FrameEdit frame in Frames)
            {
                bin.BaseStream.Seek(seek, SeekOrigin.Begin);
                bin.Write((int) (curr - startpos));
                seek = bin.BaseStream.Position;
                bin.BaseStream.Seek(curr, SeekOrigin.Begin);
                frame.Save(bin);
                curr = bin.BaseStream.Position;
            }

            start = bin.BaseStream.Position - start;
            idx.Write((int) start);
            idx.Write((int) idxextra);
        }

        public void ExportToVD(BinaryWriter bin, ref long indexpos, ref long animpos)
        {
            bin.BaseStream.Seek(indexpos, SeekOrigin.Begin);
            if ((Frames == null) || (Frames.Count == 0))
            {
                bin.Write((int) -1);
                bin.Write((int) -1);
                bin.Write((int) -1);
                indexpos = bin.BaseStream.Position;
                return;
            }

            bin.Write((int) animpos);
            indexpos = bin.BaseStream.Position;
            bin.BaseStream.Seek(animpos, SeekOrigin.Begin);

            for (int i = 0; i < 0x100; ++i)
                bin.Write((ushort) (Palette[i] ^ 0x8000));
            long startpos = (int) bin.BaseStream.Position;
            bin.Write((int) Frames.Count);
            long seek = (int) bin.BaseStream.Position;
            long curr = bin.BaseStream.Position + 4 * Frames.Count;
            foreach (FrameEdit frame in Frames)
            {
                bin.BaseStream.Seek(seek, SeekOrigin.Begin);
                bin.Write((int) (curr - startpos));
                seek = bin.BaseStream.Position;
                bin.BaseStream.Seek(curr, SeekOrigin.Begin);
                frame.Save(bin);
                curr = bin.BaseStream.Position;
            }

            long length = bin.BaseStream.Position - animpos;
            animpos = bin.BaseStream.Position;
            bin.BaseStream.Seek(indexpos, SeekOrigin.Begin);
            bin.Write((int) length);
            bin.Write((int) idxextra);
            indexpos = bin.BaseStream.Position;
        }
    }

    public sealed class FrameEdit
    {
        private const int DoubleXor = (0x200 << 22) | (0x200 << 12);

        public struct Raw
        {
            public int run;
            public int offx;
            public int offy;
            public byte[] data;
        }

        public Raw[] RawData { get; private set; }
        public Point Center { get; set; }
        public int width;
        public int height;

        public FrameEdit(BinaryReader bin)
        {
            int xCenter = bin.ReadInt16();
            int yCenter = bin.ReadInt16();

            width = bin.ReadUInt16();
            height = bin.ReadUInt16();
            if (height == 0 || width == 0)
                return;
            int header;

            List<Raw> tmp = new List<Raw>();
            while ((header = bin.ReadInt32()) != 0x7FFF7FFF)
            {
                Raw raw = new Raw();
                header ^= DoubleXor;
                raw.run = (header & 0xFFF);
                raw.offy = ((header >> 12) & 0x3FF);
                raw.offx = ((header >> 22) & 0x3FF);

                int i = 0;
                raw.data = new byte[raw.run];
                while (i < raw.run)
                {
                    raw.data[i++] = bin.ReadByte();
                }

                tmp.Add(raw);
            }

            RawData = tmp.ToArray();
            Center = new Point(xCenter, yCenter);
        }

        public unsafe FrameEdit(Bitmap bit, ushort[] palette, int centerx, int centery)
        {
            Center = new Point(centerx, centery);
            width = bit.Width;
            height = bit.Height;
            BitmapData bd = bit.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadOnly,
                PixelFormat.Format16bppArgb1555);
            ushort* line = (ushort*) bd.Scan0;
            int delta = bd.Stride >> 1;
            List<Raw> tmp = new List<Raw>();

            int X = 0;
            for (int Y = 0; Y < bit.Height; ++Y, line += delta)
            {
                ushort* cur = line;
                int i = 0;
                int j = 0;
                X = 0;
                while (i < bit.Width)
                {
                    i = X;
                    for (i = X; i <= bit.Width; ++i)
                    {
                        //first pixel set
                        if (i < bit.Width)
                        {
                            if (cur[i] != 0)
                                break;
                        }
                    }

                    if (i < bit.Width)
                    {
                        for (j = (i + 1); j < bit.Width; ++j)
                        {
                            //next non set pixel
                            if (cur[j] == 0)
                                break;
                        }

                        Raw raw = new Raw();
                        raw.run = j - i;
                        raw.offx = j - raw.run - centerx;
                        raw.offx += 512;
                        raw.offy = Y - centery - bit.Height;
                        raw.offy += 512;

                        int r = 0;
                        raw.data = new byte[raw.run];
                        while (r < raw.run)
                        {
                            ushort col = (ushort) (cur[r + i]);
                            raw.data[r++] = GetPaletteIndex(palette, col);
                        }

                        tmp.Add(raw);
                        X = j + 1;
                        i = X;
                    }
                }
            }

            RawData = tmp.ToArray();
            bit.UnlockBits(bd);
        }

        public void ChangeCenter(int x, int y)
        {
            for (int i = 0; i < RawData.Length; i++)
            {
                RawData[i].offx += Center.X;
                RawData[i].offx -= x;
                RawData[i].offy += Center.Y;
                RawData[i].offy -= y;
            }

            Center = new Point(x, y);
        }

        private static byte GetPaletteIndex(ushort[] palette, ushort col)
        {
            for (int i = 0; i < palette.Length; i++)
            {
                if (palette[i] == col)
                    return (byte) i;
            }

            return (byte) 0;
        }

        public void Save(BinaryWriter bin)
        {
            bin.Write((short) Center.X);
            bin.Write((short) Center.Y);
            bin.Write((ushort) width);
            bin.Write((ushort) height);
            if (RawData != null)
            {
                for (int j = 0; j < RawData.Length; j++)
                {
                    int newHeader = RawData[j].run | (RawData[j].offy << 12) | (RawData[j].offx << 22);
                    newHeader ^= DoubleXor;
                    bin.Write((int) newHeader);
                    foreach (byte b in RawData[j].data)
                        bin.Write(b);
                }
            }

            bin.Write((int) 0x7FFF7FFF);
        }
    }
}

================================================
FILE: Razor/UltimaSDK/Animations.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;

namespace Ultima
{
    /// <summary>
    /// Contains translation tables used for mapping body values to file subsets.
    /// <seealso cref="Animations" />
    /// </summary>
    public sealed class BodyConverter
    {
        public static int[] Table1 { get; private set; }
        public static int[] Table2 { get; private set; }
        public static int[] Table3 { get; private set; }
        public static int[] Table4 { get; private set; }

        private BodyConverter()
        {
        }

        static BodyConverter()
        {
            Initialize();
        }

        /// <summary>
        /// Fills bodyconv.def Tables
        /// </summary>
        public static void Initialize()
        {
            string path = Files.GetFilePath("bodyconv.def");

            if (path == null)
                return;

            List<int> list1 = new List<int>(),
                list2 = new List<int>(),
                list3 = new List<int>(),
                list4 = new List<int>();
            int max1 = 0, max2 = 0, max3 = 0, max4 = 0;

            using (StreamReader ip = new StreamReader(path))
            {
                string line;

                while ((line = ip.ReadLine()) != null)
                {
                    if ((line = line.Trim()).Length == 0 || line.StartsWith("#"))
                        continue;

                    try
                    {
                        string[] split = line.Split('\t');

                        int original = System.Convert.ToInt32(split[0]);
                        int anim2 = System.Convert.ToInt32(split[1]);
                        int anim3;
                        int anim4;
                        int anim5;

                        try
                        {
                            anim3 = System.Convert.ToInt32(split[2]);
                        }
                        catch
                        {
                            anim3 = -1;
                        }

                        try
                        {
                            anim4 = System.Convert.ToInt32(split[3]);
                        }
                        catch
                        {
                            anim4 = -1;
                        }

                        try
                        {
                            anim5 = System.Convert.ToInt32(split[4]);
                        }
                        catch
                        {
                            anim5 = -1;
                        }

                        if (anim2 != -1)
                        {
                            if (anim2 == 68)
                                anim2 = 122;

                            if (original > max1)
                                max1 = original;

                            list1.Add(original);
                            list1.Add(anim2);
                        }

                        if (anim3 != -1)
                        {
                            if (original > max2)
                                max2 = original;

                            list2.Add(original);
                            list2.Add(anim3);
                        }

                        if (anim4 != -1)
                        {
                            if (original > max3)
                                max3 = original;

                            list3.Add(original);
                            list3.Add(anim4);
                        }

                        if (anim5 != -1)
                        {
                            if (original > max4)
                                max4 = original;

                            list4.Add(original);
                            list4.Add(anim5);
                        }
                    }
                    catch
                    {
                    }
                }
            }

            Table1 = new int[max1 + 1];

            for (int i = 0; i < Table1.Length; ++i)
                Table1[i] = -1;

            for (int i = 0; i < list1.Count; i += 2)
                Table1[list1[i]] = list1[i + 1];

            Table2 = new int[max2 + 1];

            for (int i = 0; i < Table2.Length; ++i)
                Table2[i] = -1;

            for (int i = 0; i < list2.Count; i += 2)
                Table2[list2[i]] = list2[i + 1];

            Table3 = new int[max3 + 1];

            for (int i = 0; i < Table3.Length; ++i)
                Table3[i] = -1;

            for (int i = 0; i < list3.Count; i += 2)
                Table3[list3[i]] = list3[i + 1];

            Table4 = new int[max4 + 1];

            for (int i = 0; i < Table4.Length; ++i)
                Table4[i] = -1;

            for (int i = 0; i < list4.Count; i += 2)
                Table4[list4[i]] = list4[i + 1];
        }

        /// <summary>
        /// Checks to see if <paramref name="body" /> is contained within the mapping table.
        /// </summary>
        /// <returns>True if it is, false if not.</returns>
        public static bool Contains(int body)
        {
            if (Table1 != null && body >= 0 && body < Table1.Length && Table1[body] != -1)
                return true;

            if (Table2 != null && body >= 0 && body < Table2.Length && Table2[body] != -1)
                return true;

            if (Table3 != null && body >= 0 && body < Table3.Length && Table3[body] != -1)
                return true;

            if (Table4 != null && body >= 0 && body < Table4.Length && Table4[body] != -1)
                return true;

            return false;
        }

        /// <summary>
        /// Attempts to convert <paramref name="body" /> to a body index relative to a file subset, specified by the return value.
        /// </summary>
        /// <returns>A value indicating a file subset:
        /// <list type="table">
        /// <listheader>
        /// <term>Return Value</term>
        /// <description>File Subset</description>
        /// </listheader>
        /// <item>
        /// <term>1</term>
        /// <description>Anim.mul, Anim.idx (Standard)</description>
        /// </item>
        /// <item>
        /// <term>2</term>
        /// <description>Anim2.mul, Anim2.idx (LBR)</description>
        /// </item>
        /// <item>
        /// <term>3</term>
        /// <description>Anim3.mul, Anim3.idx (AOS)</description>
        /// </item>
        /// <item>
        /// <term>4</term>
        /// <description>Anim4.mul, Anim4.idx (SE)</description>
        /// </item>
        /// <item>
        /// <term>5</term>
        /// <description>Anim5.mul, Anim5.idx (ML)</description>
        /// </item>
        /// </list>
        /// </returns>
        public static int Convert(ref int body)
        {
            if (Table1 != null && body >= 0 && body < Table1.Length)
            {
                int val = Table1[body];

                if (val != -1)
                {
                    body = val;
                    return 2;
                }
            }

            if (Table2 != null && body >= 0 && body < Table2.Length)
            {
                int val = Table2[body];

                if (val != -1)
                {
                    body = val;
                    return 3;
                }
            }

            if (Table3 != null && body >= 0 && body < Table3.Length)
            {
                int val = Table3[body];

                if (val != -1)
                {
                    body = val;
                    return 4;
                }
            }

            if (Table4 != null && body >= 0 && body < Table4.Length)
            {
                int val = Table4[body];

                if (val != -1)
                {
                    body = val;
                    return 5;
                }
            }

            return 1;
        }

        /// <summary>
        /// Converts backward
        /// </summary>
        /// <param name="FileType"></param>
        /// <param name="index"></param>
        /// <returns></returns>
        public static int GetTrueBody(int FileType, int index)
        {
            switch (FileType)
            {
                default:
                case 1:
                    return index;
                case 2:
                    if (Table1 != null && index >= 0)
                    {
                        for (int i = 0; i < Table1.Length; ++i)
                        {
                            if (Table1[i] == index)
                                return i;
                        }
                    }

                    break;
                case 3:
                    if (Table2 != null && index >= 0)
                    {
                        for (int i = 0; i < Table2.Length; ++i)
                        {
                            if (Table2[i] == index)
                                return i;
                        }
                    }

                    break;
                case 4:
                    if (Table3 != null && index >= 0)
                    {
                        for (int i = 0; i < Table3.Length; ++i)
                        {
                            if (Table3[i] == index)
                                return i;
                        }
                    }

                    break;
                case 5:
                    if (Table4 != null && index >= 0)
                    {
                        for (int i = 0; i < Table4.Length; ++i)
                        {
                            if (Table4[i] == index)
                                return i;
                        }
                    }

                    break;
            }

            return -1;
        }
    }

    public sealed class Animations
    {
        private static FileIndex m_FileIndex = new FileIndex("Anim.idx", "Anim.mul", 0x40000, 6);
        //public static FileIndex FileIndex{ get{ return m_FileIndex; } }

        private static FileIndex m_FileIndex2 = new FileIndex("Anim2.idx", "Anim2.mul", 0x10000, -1);
        //public static FileIndex FileIndex2{ get{ return m_FileIndex2; } }

        private static FileIndex m_FileIndex3 = new FileIndex("Anim3.idx", "Anim3.mul", 0x20000, -1);
        //public static FileIndex FileIndex3{ get{ return m_FileIndex3; } }

        private static FileIndex m_FileIndex4 = new FileIndex("Anim4.idx", "Anim4.mul", 0x20000, -1);
        //public static FileIndex FileIndex4{ get{ return m_FileIndex4; } }

        private static FileIndex m_FileIndex5 = new FileIndex("Anim5.idx", "Anim5.mul", 0x20000, -1);
        //public static FileIndex FileIndex5 { get { return m_FileIndex5; } }

        private static byte[] m_StreamBuffer;
        private static MemoryStream m_MemoryStream;

        /// <summary>
        /// Rereads AnimX files and bodyconv, body.def
        /// </summary>
        public static void Reload()
        {
            m_FileIndex = new FileIndex("Anim.idx", "Anim.mul", 0x40000, 6);
            m_FileIndex2 = new FileIndex("Anim2.idx", "Anim2.mul", 0x10000, -1);
            m_FileIndex3 = new FileIndex("Anim3.idx", "Anim3.mul", 0x20000, -1);
            m_FileIndex4 = new FileIndex("Anim4.idx", "Anim4.mul", 0x20000, -1);
            m_FileIndex5 = new FileIndex("Anim5.idx", "Anim5.mul", 0x20000, -1);

            BodyConverter.Initialize();
            BodyTable.Initialize();
        }

        /// <summary>
        /// Returns Framelist
        /// </summary>
        /// <param name="body"></param>
        /// <param name="action"></param>
        /// <param name="direction"></param>
        /// <param name="hue"></param>
        /// <param name="preserveHue">No Hue override <see cref="bodydev"/></param>
        /// <param name="FirstFrame"></param>
        /// <returns></returns>
        public static Frame[] GetAnimation(int body, int action, int direction, ref int hue, bool preserveHue,
            bool FirstFrame)
        {
            if (preserveHue)
                Translate(ref body);
            else
                Translate(ref body, ref hue);

            int fileType = BodyConverter.Convert(ref body);

            FileIndex fileIndex;
            int index;
            GetFileIndex(body, action, direction, fileType, out fileIndex, out index);

            int length, extra;
            bool patched;
            Stream stream = fileIndex.Seek(index, out length, out extra, out patched);

            if (stream == null)
                return null;
            if (m_StreamBuffer == null || m_StreamBuffer.Length < length)
                m_StreamBuffer = new byte[length];
            stream.Read(m_StreamBuffer, 0, length);
            m_MemoryStream = new MemoryStream(m_StreamBuffer, false);

            bool flip = direction > 4;
            Frame[] frames;
            using (BinaryReader bin = new BinaryReader(m_MemoryStream))
            {
                ushort[] palette = new ushort[0x100];

                for (int i = 0; i < 0x100; ++i)
                    palette[i] = (ushort) (bin.ReadUInt16() ^ 0x8000);

                int start = (int) bin.BaseStream.Position;
                int frameCount = bin.ReadInt32();

                int[] lookups = new int[frameCount];

                for (int i = 0; i < frameCount; ++i)
                    lookups[i] = start + bin.ReadInt32();

                bool onlyHueGrayPixels = (hue & 0x8000) != 0;

                hue = (hue & 0x3FFF) - 1;

                Hue hueObject;

                if (hue >= 0 && hue < Hues.List.Length)
                    hueObject = Hues.List[hue];
                else
                    hueObject = null;

                if (FirstFrame)
                    frameCount = 1;
                frames = new Frame[frameCount];

                for (int i = 0; i < frameCount; ++i)
                {
                    bin.BaseStream.Seek(lookups[i], SeekOrigin.Begin);
                    frames[i] = new Frame(palette, bin, flip);

                    if (hueObject != null)
                    {
                        if (frames[i] != null)
                        {
                            if (frames[i].Bitmap != null)
                                hueObject.ApplyTo(frames[i].Bitmap, onlyHueGrayPixels);
                        }
                    }
                }

                bin.Close();
            }

            m_MemoryStream.Close();
            return frames;
        }

        public static Frame[] GetAnimation(int body, int action, int direction, int fileType)
        {
            FileIndex fileIndex;
            int index;
            GetFileIndex(body, action, direction, fileType, out fileIndex, out index);

            int length, extra;
            bool patched;

            Stream stream = fileIndex.Seek(index, out length, out extra, out patched);

            if (stream == null)
                return null;


            bool flip = direction > 4;

            using (BinaryReader bin = new BinaryReader(stream))
            {
                ushort[] palette = new ushort[0x100];

                for (int i = 0; i < 0x100; ++i)
                    palette[i] = (ushort) (bin.ReadUInt16() ^ 0x8000);

                int start = (int) bin.BaseStream.Position;
                int frameCount = bin.ReadInt32();

                int[] lookups = new int[frameCount];

                for (int i = 0; i < frameCount; ++i)
                    lookups[i] = start + bin.ReadInt32();

                Frame[] frames = new Frame[frameCount];

                for (int i = 0; i < frameCount; ++i)
                {
                    bin.BaseStream.Seek(lookups[i], SeekOrigin.Begin);
                    frames[i] = new Frame(palette, bin, flip);
                }

                return frames;
            }
        }

        private static int[] m_Table;

        /// <summary>
        /// Translates body (body.def)
        /// </summary>
        /// <param name="body"></param>
        public static void Translate(ref int body)
        {
            if (m_Table == null)
                LoadTable();
            if (body <= 0 || body >= m_Table.Length)
            {
                body = 0;
                return;
            }

            body = m_Table[body] & 0x7FFF;
        }

        /// <summary>
        /// Translates body and hue (body.def)
        /// </summary>
        /// <param name="body"></param>
        /// <param name="hue"></param>
        public static void Translate(ref int body, ref int hue)
        {
            if (m_Table == null)
                LoadTable();
            if (body <= 0 || body >= m_Table.Length)
            {
                body = 0;
                return;
            }

            int table = m_Table[body];

            if ((table & (1 << 31)) != 0)
            {
                body = table & 0x7FFF;

                int vhue = (hue & 0x3FFF) - 1;

                if (vhue < 0 || vhue >= Hues.List.Length)
                    hue = (table >> 15) & 0xFFFF;
            }
        }

        private static void LoadTable()
        {
            int count = 400 + ((m_FileIndex.Index.Length - 35000) / 175);

            m_Table = new int[count];

            for (int i = 0; i < count; ++i)
            {
                object o = BodyTable.m_Entries[i];

                if (o == null || BodyConverter.Contains(i))
                {
                    m_Table[i] = i;
                }
                else
                {
                    BodyTableEntry bte = (BodyTableEntry) o;

                    m_Table[i] = bte.OldID | (1 << 31) | ((bte.NewHue & 0xFFFF) << 15);
                }
            }
        }

        /// <summary>
        /// Is Body with action and direction definied
        /// </summary>
        /// <param name="body"></param>
        /// <param name="action"></param>
        /// <param name="direction"></param>
        /// <returns></returns>
        public static bool IsActionDefined(int body, int action, int direction)
        {
            Translate(ref body);
            int fileType = BodyConverter.Convert(ref body);
            FileIndex fileIndex;
            int index;
            GetFileIndex(body, action, direction, fileType, out fileIndex, out index);

            int length, extra;
            bool patched;
            bool valid = fileIndex.Valid(index, out length, out extra, out patched);
            if ((!valid) || (length < 1))
                return false;
            return true;
        }

        /// <summary>
        /// Is Animation in given animfile definied
        /// </summary>
        /// <param name="body"></param>
        /// <param name="action"></param>
        /// <param name="dir"></param>
        /// <param name="fileType"></param>
        /// <returns></returns>
        public static bool IsAnimDefinied(int body, int action, int dir, int fileType)
        {
            FileIndex fileIndex;
            int index;
            GetFileIndex(body, action, dir, fileType, out fileIndex, out index);

            int length, extra;
            bool patched;
            Stream stream = fileIndex.Seek(index, out length, out extra, out patched);
            bool def = true;
            if ((stream == null) || (length == 0))
                def = false;
            if (stream != null)
                stream.Close();
            return def;
        }

        /// <summary>
        /// Returns Animationcount in given animfile
        /// </summary>
        /// <param name="fileType"></param>
        /// <returns></returns>
        public static int GetAnimCount(int fileType)
        {
            int count;
            switch (fileType)
            {
                default:
                case 1:
                    count = 400 + (int) (m_FileIndex.IdxLength - 35000 * 12) / (12 * 175);
                    break;
                case 2:
                    count = 200 + (int) (m_FileIndex2.IdxLength - 22000 * 12) / (12 * 65);
                    break;
                case 3:
                    count = 400 + (int) (m_FileIndex3.IdxLength - 35000 * 12) / (12 * 175);
                    break;
                case 4:
                    count = 400 + (int) (m_FileIndex4.IdxLength - 35000 * 12) / (12 * 175);
                    break;
                case 5:
                    count = 400 + (int) (m_FileIndex5.IdxLength - 35000 * 12) / (12 * 175);
                    break;
            }

            return count;
        }

        /// <summary>
        /// Actioncount of given Body in given anim file
        /// </summary>
        /// <param name="body"></param>
        /// <param name="fileType"></param>
        /// <returns></returns>
        public static int GetAnimLength(int body, int fileType)
        {
            int length = 0;
            switch (fileType)
            {
                default:
                case 1:
                    if (body < 200)
                        length = 22; //high
                    else if (body < 400)
                        length = 13; //low
                    else
                        length = 35; //people
                    break;
                case 2:
                    if (body < 200)
                        length = 22; //high
                    else
                        length = 13; //low
                    break;
                case 3:
                    if (body < 300)
                        length = 13;
                    else if (body < 400)
                        length = 22;
                    else
                        length = 35;
                    break;
                case 4:
                    if (body < 200)
                        length = 22;
                    else if (body < 400)
                        length = 13;
                    else
                        length = 35;
                    break;
                case 5:
                    if (body < 200)
                        length = 22;
                    else if (body < 400)
                        length = 13;
                    else
                        length = 35;
                    break;
            }

            return length;
        }

        /// <summary>
        /// Gets Fileseek index based on fileType,body,action,direction
        /// </summary>
        /// <param name="body"></param>
        /// <param name="action"></param>
        /// <param name="direction"></param>
        /// <param name="fileType">animX</param>
        /// <param name="fileIndex"></param>
        /// <param name="index"></param>
        private static void GetFileIndex(int body, int action, int direction, int fileType, out FileIndex fileIndex,
            out int index)
        {
            switch (fileType)
            {
                default:
                case 1:
                    fileIndex = m_FileIndex;
                    if (body < 200)
                        index = body * 110;
                    else if (body < 400)
                        index = 22000 + ((body - 200) * 65);
                    else
                        index = 35000 + ((body - 400) * 175);

                    break;
                case 2:
                    fileIndex = m_FileIndex2;
                    if (body < 200)
                        index = body * 110;
                    else
                        index = 22000 + ((body - 200) * 65);

                    break;
                case 3:
                    fileIndex = m_FileIndex3;
                    if (body < 300)
                        index = body * 65;
                    else if (body < 400)
                        index = 33000 + ((body - 300) * 110);
                    else
                        index = 35000 + ((body - 400) * 175);

                    break;
                case 4:
                    fileIndex = m_FileIndex4;
                    if (body < 200)
                        index = body * 110;
                    else if (body < 400)
                        index = 22000 + ((body - 200) * 65);
                    else
                        index = 35000 + ((body - 400) * 175);

                    break;
                case 5:
                    fileIndex = m_FileIndex5;
                    if ((body < 200) && (body != 34)) // looks strange, though it works.
                        index = body * 110;
                    else if (body < 400)
                        index = 22000 + ((body - 200) * 65);
                    else
                        index = 35000 + ((body - 400) * 175);

                    break;
            }

            index += action * 5;

            if (direction <= 4)
                index += direction;
            else
                index += direction - (direction - 4) * 2;
        }

        /// <summary>
        /// Returns Filename body is in
        /// </summary>
        /// <param name="body"></param>
        /// <returns>anim{0}.mul</returns>
        public static string GetFileName(int body)
        {
            Translate(ref body);
            int fileType = BodyConverter.Convert(ref body);

            if (fileType == 1)
                return "anim.mul";
            else
                return $"anim{fileType}.mul";
        }
    }

    public sealed class Frame
    {
        public Point Center { get; set; }
        public Bitmap Bitmap { get; set; }

        private const int DoubleXor = (0x200 << 22) | (0x200 << 12);

        public static readonly Frame Empty = new Frame();
        //public static readonly Frame[] EmptyFrames = new Frame[1] { Empty };

        private Frame()
        {
            Bitmap = new Bitmap(1, 1);
        }

        public unsafe Frame(ushort[] palette, BinaryReader bin, bool flip)
        {
            int xCenter = bin.ReadInt16();
            int yCenter = bin.ReadInt16();

            int width = bin.ReadUInt16();
            int height = bin.ReadUInt16();
            if (height == 0 || width == 0)
                return;
            Bitmap bmp = new Bitmap(width, height, PixelFormat.Format16bppArgb1555);
            BitmapData bd = bmp.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.WriteOnly,
                PixelFormat.Format16bppArgb1555);
            ushort* line = (ushort*) bd.Scan0;
            int delta = bd.Stride >> 1;

            int header;

            int xBase = xCenter - 0x200;
            int yBase = (yCenter + height) - 0x200;

            if (!flip)
            {
                line += xBase;
                line += yBase * delta;

                while ((header = bin.ReadInt32()) != 0x7FFF7FFF)
                {
                    header ^= DoubleXor;

                    ushort* cur = line + ((((header >> 12) & 0x3FF) * delta) + ((header >> 22) & 0x3FF));
                    ushort* end = cur + (header & 0xFFF);
                    while (cur < end)
                        *cur++ = palette[bin.ReadByte()];
                }
            }
            else
            {
                line -= xBase - width + 1;
                line += yBase * delta;

                while ((header = bin.ReadInt32()) != 0x7FFF7FFF)
                {
                    header ^= DoubleXor;

                    ushort* cur = line + ((((header >> 12) & 0x3FF) * delta) - ((header >> 22) & 0x3FF));
                    ushort* end = cur - (header & 0xFFF);

                    while (cur > end)
                        *cur-- = palette[bin.ReadByte()];
                }

                xCenter = width - xCenter;
            }

            bmp.UnlockBits(bd);

            Center = new Point(xCenter, yCenter);
            Bitmap = bmp;
        }
    }

    public sealed class BodyTableEntry
    {
        public int OldID { get; set; }
        public int NewID { get; set; }
        public int NewHue { get; set; }

        public BodyTableEntry(int oldID, int newID, int newHue)
        {
            OldID = oldID;
            NewID = newID;
            NewHue = newHue;
        }
    }

    public sealed class BodyTable
    {
        public static Hashtable m_Entries;

        static BodyTable()
        {
            Initialize();
        }

        public static void Initialize()
        {
            m_Entries = new Hashtable();

            string filePath = Files.GetFilePath("body.def");

            if (filePath == null)
                return;

            using (StreamReader def = new StreamReader(filePath))
            {
                string line;

                while ((line = def.ReadLine()) != null)
                {
                    if ((line = line.Trim()).Length == 0 || line.StartsWith("#"))
                        continue;

                    try
                    {
                        int index1 = line.IndexOf("{");
                        int index2 = line.IndexOf("}");

                        string param1 = line.Substring(0, index1);
                        string param2 = line.Substring(index1 + 1, index2 - index1 - 1);
                        string param3 = line.Substring(index2 + 1);

                        int indexOf = param2.IndexOf(',');

                        if (indexOf > -1)
                            param2 = param2.Substring(0, indexOf).Trim();

                        int iParam1 = Convert.ToInt32(param1.Trim());
                        int iParam2 = Convert.ToInt32(param2.Trim());
                        int iParam3 = Convert.ToInt32(param3.Trim());

                        m_Entries[iParam1] = new BodyTableEntry(iParam2, iParam1, iParam3);
                    }
                    catch
                    {
                    }
                }
            }
        }
    }
}

================================================
FILE: Razor/UltimaSDK/Animdata.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System.Collections;
using System.IO;

namespace Ultima
{
    public sealed class Animdata
    {
        private static int[] m_Header;
        private static byte[] m_Unknown;

        public static Hashtable AnimData { get; set; }

        static Animdata()
        {
            Initialize();
        }

        /// <summary>
        /// Reads animdata.mul and fills <see cref="AnimData"/>
        /// </summary>
        public static void Initialize()
        {
            AnimData = new Hashtable();
            string path = Files.GetFilePath("animdata.mul");
            if (path != null)
            {
                using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read))
                {
                    using (BinaryReader bin = new BinaryReader(fs))
                    {
                        unsafe
                        {
                            int id = 0;
                            int h = 0;
                            byte unk;
                            byte fcount;
                            byte finter;
                            byte fstart;
                            sbyte[] fdata;
                            m_Header = new int[bin.BaseStream.Length / (4 + 8 * (64 + 4))];
                            while (h < m_Header.Length /*bin.BaseStream.Length != bin.BaseStream.Position*/)
                            {
                                m_Header[h++] = bin.ReadInt32(); // chunk header
                                // Read 8 tiles
                                byte[] buffer = bin.ReadBytes(544);
                                fixed (byte* buf = buffer)
                                {
                                    byte* data = buf;
                                    for (int i = 0; i < 8; ++i, ++id)
                                    {
                                        fdata = new sbyte[64];
                                        for (int j = 0; j < 64; ++j)
                                            fdata[j] = (sbyte) *data++;
                                        unk = *data++;
                                        fcount = *data++;
                                        finter = *data++;
                                        fstart = *data++;
                                        if (fcount > 0)
                                            AnimData[id] = new Data(fdata, unk, fcount, finter, fstart);
                                    }
                                }
                            }

                            int remaining = (int) (bin.BaseStream.Length - bin.BaseStream.Position);
                            if (remaining > 0)
                                m_Unknown = bin.ReadBytes(remaining);
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Gets Animation <see cref="Data"/>
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public static Data GetAnimData(int id)
        {
            if (AnimData.Contains(id))
                return ((Data) AnimData[id]);
            else
                return null;
        }

        public static void Save(string path)
        {
            string FileName = Path.Combine(path, "animdata.mul");
            using (FileStream fs = new FileStream(FileName, FileMode.Create, FileAccess.Write, FileShare.Write))
            {
                using (BinaryWriter bin = new BinaryWriter(fs))
                {
                    int id = 0;
                    int h = 0;
                    while (id < m_Header.Length * 8)
                    {
                        bin.Write(m_Header[h++]);
                        for (int i = 0; i < 8; ++i, ++id)
                        {
                            Data data = GetAnimData(id);
                            for (int j = 0; j < 64; ++j)
                            {
                                if (data != null)
                                    bin.Write(data.FrameData[j]);
                                else
                                    bin.Write((sbyte) 0);
                            }

                            if (data != null)
                            {
                                bin.Write(data.Unknown);
                                bin.Write(data.FrameCount);
                                bin.Write(data.FrameInterval);
                                bin.Write(data.FrameStart);
                            }
                            else
                            {
                                bin.Write((byte) 0);
                                bin.Write((byte) 0);
                                bin.Write((byte) 0);
                                bin.Write((byte) 0);
                            }
                        }
                    }

                    if (m_Unknown != null)
                        bin.Write(m_Unknown);
                }
            }
        }

        public class Data
        {
            public sbyte[] FrameData { get; set; }
            public byte Unknown { get; private set; }
            public byte FrameCount { get; set; }
            public byte FrameInterval { get; set; }
            public byte FrameStart { get; set; }

            public Data(sbyte[] frame, byte unk, byte fcount, byte finter, byte fstart)
            {
                FrameData = frame;
                Unknown = unk;
                FrameCount = fcount;
                FrameInterval = finter;
                FrameStart = fstart;
            }
        }
    }
}

================================================
FILE: Razor/UltimaSDK/Art.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System.Collections;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Security.Cryptography;
using System.Collections.Generic;

namespace Ultima
{
    public sealed class Art
    {
        private static FileIndex m_FileIndex = new FileIndex("Artidx.mul", "Art.mul", "artLegacyMUL.uop",
            0x10000 /*0x13FDC*/, 4, ".tga", 0x13FDC, false);

        private static Bitmap[] m_Cache;
        private static bool[] m_Removed;
        private static Hashtable m_patched = new Hashtable();
        public static bool Modified = false;

        private static byte[] m_StreamBuffer;
        private static byte[] Validbuffer;


        struct CheckSums
        {
            public byte[] checksum;
            public int pos;
            public int length;
            public int index;
        }

        private static List<CheckSums> checksumsLand;
        private static List<CheckSums> checksumsStatic;

        static Art()
        {
            m_Cache = new Bitmap[GetIdxLength()];
            m_Removed = new bool[GetIdxLength()];
        }

        public static int GetMaxItemID()
        {
            if (GetIdxLength() == 0xC000)
                return 0x7FFF;

            if (GetIdxLength() == 0x13FDC)
                return 0xFFDB;

            return 0x3FFF;
        }

        public static bool IsUOAHS()
        {
            return (GetIdxLength() == 0x13FDC);
        }

        public static ushort GetLegalItemID(int itemID, bool checkmaxid = true)
        {
            if (itemID < 0)
                return 0;

            if (checkmaxid)
            {
                int max = GetMaxItemID();
                if (itemID > max)
                    return 0;
            }

            return (ushort) itemID;
        }

        public static int GetIdxLength()
        {
            return (int) (m_FileIndex.IdxLength / 12);
        }

        /// <summary>
        /// ReReads Art.mul
        /// </summary>
        public static void Reload()
        {
            m_FileIndex = new FileIndex("Artidx.mul", "Art.mul", "artLegacyMUL.uop", 0x10000 /*0x13FDC*/, 4, ".tga",
                0x13FDC, false);
            m_Cache = new Bitmap[GetIdxLength()];
            m_Removed = new bool[GetIdxLength()];
            m_patched.Clear();
            Modified = false;
        }

        /// <summary>
        /// Sets bmp of index in <see cref="m_Cache"/> of Static
        /// </summary>
        /// <param name="index"></param>
        /// <param name="bmp"></param>
        public static void ReplaceStatic(int index, Bitmap bmp)
        {
            index = Art.GetLegalItemID(index);
            index += 0x4000;

            m_Cache[index] = bmp;
            m_Removed[index] = false;
            if (m_patched.Contains(index))
                m_patched.Remove(index);
            Modified = true;
        }

        /// <summary>
        /// Sets bmp of index in <see cref="m_Cache"/> of Land
        /// </summary>
        /// <param name="index"></param>
        /// <param name="bmp"></param>
        public static void ReplaceLand(int index, Bitmap bmp)
        {
            index &= 0x3FFF;
            m_Cache[index] = bmp;
            m_Removed[index] = false;
            if (m_patched.Contains(index))
                m_patched.Remove(index);
            Modified = true;
        }

        /// <summary>
        /// Removes Static index <see cref="m_Removed"/>
        /// </summary>
        /// <param name="index"></param>
        public static void RemoveStatic(int index)
        {
            index = Art.GetLegalItemID(index);
            index += 0x4000;

            m_Removed[index] = true;
            Modified = true;
        }

        /// <summary>
        /// Removes Land index <see cref="m_Removed"/>
        /// </summary>
        /// <param name="index"></param>
        public static void RemoveLand(int index)
        {
            index &= 0x3FFF;
            m_Removed[index] = true;
            Modified = true;
        }

        /// <summary>
        /// Tests if Static is definied (width and hight check)
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public static unsafe bool IsValidStatic(int index)
        {
            index = GetLegalItemID(index);
            index += 0x4000;

            if (m_Removed[index])
                return false;
            if (m_Cache[index] != null)
                return true;

            int length, extra;
            bool patched;
            Stream stream = m_FileIndex.Seek(index, out length, out extra, out patched);

            if (stream == null)
                return false;

            if (Validbuffer == null)
                Validbuffer = new byte[4];
            stream.Seek(4, SeekOrigin.Current);
            stream.Read(Validbuffer, 0, 4);
            fixed (byte* b = Validbuffer)
            {
                short* dat = (short*) b;
                if (*dat++ <= 0 || *dat <= 0)
                    return false;
                return true;
            }
        }

        /// <summary>
        /// Tests if LandTile is definied
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public static bool IsValidLand(int index)
        {
            index &= 0x3FFF;
            if (m_Removed[index])
                return false;
            if (m_Cache[index] != null)
                return true;

            int length, extra;
            bool patched;

            return m_FileIndex.Valid(index, out length, out extra, out patched);
        }

        /// <summary>
        /// Returns Bitmap of LandTile (with Cache)
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public static Bitmap GetLand(int index)
        {
            bool patched;
            return GetLand(index, out patched);
        }

        /// <summary>
        /// Returns Bitmap of LandTile (with Cache) and verdata bool
        /// </summary>
        /// <param name="index"></param>
        /// <param name="patched"></param>
        /// <returns></returns>
        public static Bitmap GetLand(int index, out bool patched)
        {
            index &= 0x3FFF;
            if (m_patched.Contains(index))
                patched = (bool) m_patched[index];
            else
                patched = false;

            if (m_Removed[index])
                return null;
            if (m_Cache[index] != null)
                return m_Cache[index];

            int length, extra;
            Stream stream = m_FileIndex.Seek(index, out length, out extra, out patched);
            if (stream == null)
                return null;
            if (patched)
                m_patched[index] = true;

            if (Files.CacheData)
                return m_Cache[index] = LoadLand(stream, length);
            else
                return LoadLand(stream, length);
        }

        public static byte[] GetRawLand(int index)
        {
            index &= 0x3FFF;

            int length, extra;
            bool patched;
            Stream stream = m_FileIndex.Seek(index, out length, out extra, out patched);
            if (stream == null)
                return null;
            byte[] buffer = new byte[length];
            stream.Read(buffer, 0, length);
            stream.Close();
            return buffer;
        }

        /// <summary>
        /// Returns Bitmap of Static (with Cache)
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public static Bitmap GetStatic(int index, bool checkmaxid = true)
        {
            bool patched;
            return GetStatic(index, out patched, checkmaxid);
        }

        /// <summary>
        /// Returns Bitmap of Static (with Cache) and verdata bool
        /// </summary>
        /// <param name="index"></param>
        /// <param name="patched"></param>
        /// <returns></returns>
        public static Bitmap GetStatic(int index, out bool patched, bool checkmaxid = true)
        {
            index = GetLegalItemID(index, checkmaxid);
            index += 0x4000;

            if (m_patched.Contains(index))
                patched = (bool) m_patched[index];
            else
                patched = false;

            if (m_Removed[index])
                return null;
            if (m_Cache[index] != null)
                return m_Cache[index];

            int length, extra;
            Stream stream = m_FileIndex.Seek(index, out length, out extra, out patched);
            if (stream == null)
                return null;
            if (patched)
                m_patched[index] = true;

            if (Files.CacheData)
                return m_Cache[index] = LoadStatic(stream, length);
            else
                return LoadStatic(stream, length);
        }

        public static byte[] GetRawStatic(int index)
        {
            index = GetLegalItemID(index);
            index += 0x4000;

            int length, extra;
            bool patched;
            Stream stream = m_FileIndex.Seek(index, out length, out extra, out patched);
            if (stream == null)
                return null;
            byte[] buffer = new byte[length];
            stream.Read(buffer, 0, length);
            stream.Close();
            return buffer;
        }

        public unsafe static void Measure(Bitmap bmp, out int xMin, out int yMin, out int xMax, out int yMax)
        {
            xMin = yMin = 0;
            xMax = yMax = -1;

            if (bmp == null || bmp.Width <= 0 || bmp.Height <= 0)
                return;

            BitmapData bd = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly,
                PixelFormat.Format16bppArgb1555);

            int delta = (bd.Stride >> 1) - bd.Width;
            int lineDelta = bd.Stride >> 1;

            ushort* pBuffer = (ushort*) bd.Scan0;
            ushort* pLineEnd = pBuffer + bd.Width;
            ushort* pEnd = pBuffer + (bd.Height * lineDelta);

            bool foundPixel = false;

            int x = 0, y = 0;

            while (pBuffer < pEnd)
            {
                while (pBuffer < pLineEnd)
                {
                    ushort c = *pBuffer++;

                    if ((c & 0x8000) != 0)
                    {
                        if (!foundPixel)
                        {
                            foundPixel = true;
                            xMin = xMax = x;
                            yMin = yMax = y;
                        }
                        else
                        {
                            if (x < xMin)
                                xMin = x;

                            if (y < yMin)
                                yMin = y;

                            if (x > xMax)
                                xMax = x;

                            if (y > yMax)
                                yMax = y;
                        }
                    }

                    ++x;
                }

                pBuffer += delta;
                pLineEnd += lineDelta;
                ++y;
                x = 0;
            }

            bmp.UnlockBits(bd);
        }

        private static unsafe Bitmap LoadStatic(Stream stream, int length)
        {
            Bitmap bmp;
            if (m_StreamBuffer == null || m_StreamBuffer.Length < length)
                m_StreamBuffer = new byte[length];
            stream.Read(m_StreamBuffer, 0, length);
            stream.Close();

            fixed (byte* data = m_StreamBuffer)
            {
                ushort* bindata = (ushort*) data;
                int count = 2;
                //bin.ReadInt32();
                int width = bindata[count++];
                int height = bindata[count++];

                if (width <= 0 || height <= 0)
                    return null;

                int[] lookups = new int[height];

                int start = (height + 4);

                for (int i = 0; i < height; ++i)
                    lookups[i] = (int) (start + (bindata[count++]));

                bmp = new Bitmap(width, height, PixelFormat.Format16bppArgb1555);
                BitmapData bd = bmp.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.WriteOnly,
                    PixelFormat.Format16bppArgb1555);


                ushort* line = (ushort*) bd.Scan0;
                int delta = bd.Stride >> 1;


                for (int y = 0; y < height; ++y, line += delta)
                {
                    count = lookups[y];

                    ushort* cur = line;
                    ushort* end;
                    int xOffset, xRun;

                    while (((xOffset = bindata[count++]) + (xRun = bindata[count++])) != 0)
                    {
                        if (xOffset > delta)
                            break;
                        cur += xOffset;
                        if (xOffset + xRun > delta)
                            break;
                        end = cur + xRun;

                        while (cur < end)
                            *cur++ = (ushort) (bindata[count++] ^ 0x8000);
                    }
                }

                bmp.UnlockBits(bd);
            }

            return bmp;
        }

        private static unsafe Bitmap LoadLand(Stream stream, int length)
        {
            Bitmap bmp = new Bitmap(44, 44, PixelFormat.Format16bppArgb1555);
            BitmapData bd = bmp.LockBits(new Rectangle(0, 0, 44, 44), ImageLockMode.WriteOnly,
                PixelFormat.Format16bppArgb1555);
            if (m_StreamBuffer == null || m_StreamBuffer.Length < length)
                m_StreamBuffer = new byte[length];
            stream.Read(m_StreamBuffer, 0, length);
            stream.Close();
            fixed (byte* bindata = m_StreamBuffer)
            {
                ushort* bdata = (ushort*) bindata;
                int xOffset = 21;
                int xRun = 2;

                ushort* line = (ushort*) bd.Scan0;
                int delta = bd.Stride >> 1;

                for (int y = 0; y < 22; ++y, --xOffset, xRun += 2, line += delta)
                {
                    ushort* cur = line + xOffset;
                    ushort* end = cur + xRun;

                    while (cur < end)
                        *cur++ = (ushort) (*bdata++ | 0x8000);
                }

                xOffset = 0;
                xRun = 44;

                for (int y = 0; y < 22; ++y, ++xOffset, xRun -= 2, line += delta)
                {
                    ushort* cur = line + xOffset;
                    ushort* end = cur + xRun;

                    while (cur < end)
                        *cur++ = (ushort) (*bdata++ | 0x8000);
                }
            }

            bmp.UnlockBits(bd);
            return bmp;
        }


        /// <summary>
        /// Saves mul
        /// </summary>
        /// <param name="path"></param>
        public static unsafe void Save(string path)
        {
            checksumsLand = new List<CheckSums>();
            checksumsStatic = new List<CheckSums>();
            string idx = Path.Combine(path, "artidx.mul");
            string mul = Path.Combine(path, "art.mul");
            using (FileStream fsidx = new FileStream(idx, FileMode.Create, FileAccess.Write, FileShare.Write),
                fsmul = new FileStream(mul, FileMode.Create, FileAccess.Write, FileShare.Write))
            {
                MemoryStream memidx = new MemoryStream();
                MemoryStream memmul = new MemoryStream();
                SHA256Managed sha = new SHA256Managed();
                //StreamWriter Tex = new StreamWriter(new FileStream("d:/artlog.txt", FileMode.Create, FileAccess.ReadWrite));

                using (BinaryWriter binidx = new BinaryWriter(memidx),
                    binmul = new BinaryWriter(memmul))
                {
                    for (int index = 0; index < GetIdxLength(); index++)
                    {
                        Files.FireFileSaveEvent();
                        if (m_Cache[index] == null)
                        {
                            if (index < 0x4000)
                                m_Cache[index] = GetLand(index);
                            else
                                m_Cache[index] = GetStatic(index - 0x4000, false);
                        }

                        Bitmap bmp = m_Cache[index];
                        if ((bmp == null) || (m_Removed[index]))
                        {
                            binidx.Write((int) -1); // lookup
                            binidx.Write((int) 0); // length
                            binidx.Write((int) -1); // extra
                            //Tex.WriteLine(System.String.Format("0x{0:X4} : 0x{1:X4} 0x{2:X4}", index, (int)-1, (int)-1));
                        }
                        else if (index < 0x4000)
                        {
                            MemoryStream ms = new MemoryStream();
                            bmp.Save(ms, ImageFormat.Bmp);
                            byte[] checksum = sha.ComputeHash(ms.ToArray());
                            CheckSums sum;
                            if (compareSaveImagesLand(checksum, out sum))
                            {
                                binidx.Write((int) sum.pos); //lookup
                                binidx.Write((int) sum.length);
                                binidx.Write((int) 0);
                                //Tex.WriteLine(System.String.Format("0x{0:X4} : 0x{1:X4} 0x{2:X4}", index, (int)sum.pos, (int)sum.length));
                                //Tex.WriteLine(System.String.Format("0x{0:X4} -> 0x{1:X4}", sum.index, index));
                                continue;
                            }

                            //land
                            BitmapData bd = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height),
                                ImageLockMode.ReadOnly, PixelFormat.Format16bppArgb1555);
                            ushort* line = (ushort*) bd.Scan0;
                            int delta = bd.Stride >> 1;
                            binidx.Write((int) binmul.BaseStream.Position); //lookup
                            int length = (int) binmul.BaseStream.Position;
                            int x = 22;
                            int y = 0;
                            int linewidth = 2;
                            for (int m = 0; m < 22; ++m, ++y, line += delta, linewidth += 2)
                            {
                                --x;
                                ushort* cur = line;
                                for (int n = 0; n < linewidth; ++n)
                                    binmul.Write((ushort) (cur[x + n] ^ 0x8000));
                            }

                            x = 0;
                            linewidth = 44;
                            y = 22;
                            line = (ushort*) bd.Scan0;
                            line += delta * 22;
                            for (int m = 0; m < 22; m++, y++, line += delta, ++x, linewidth -= 2)
                            {
                                ushort* cur = line;
                                for (int n = 0; n < linewidth; n++)
                                    binmul.Write((ushort) (cur[x + n] ^ 0x8000));
                            }

                            int start = length;
                            length = (int) binmul.BaseStream.Position - length;
                            binidx.Write(length);
                            binidx.Write((int) 0);
                            bmp.UnlockBits(bd);
                            CheckSums s = new CheckSums()
                                {pos = start, length = length, checksum = checksum, index = index};
                            //Tex.WriteLine(System.String.Format("0x{0:X4} : 0x{1:X4} 0x{2:X4}", index, start, length));
                            checksumsLand.Add(s);
                        }
                        else
                        {
                            MemoryStream ms = new MemoryStream();
                            bmp.Save(ms, ImageFormat.Bmp);
                            byte[] checksum = sha.ComputeHash(ms.ToArray());
                            CheckSums sum;
                            if (compareSaveImagesStatic(checksum, out sum))
                            {
                                binidx.Write((int) sum.pos); //lookup
                                binidx.Write((int) sum.length);
                                binidx.Write((int) 0);
                                //Tex.WriteLine(System.String.Format("0x{0:X4} -> 0x{1:X4}", sum.index, index));
                                //Tex.WriteLine(System.String.Format("0x{0:X4} : 0x{1:X4} 0x{2:X4}", index, sum.pos, sum.length));
                                continue;
                            }

                            // art
                            BitmapData bd = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height),
                                ImageLockMode.ReadOnly, PixelFormat.Format16bppArgb1555);
                            ushort* line = (ushort*) bd.Scan0;
                            int delta = bd.Stride >> 1;
                            binidx.Write((int) binmul.BaseStream.Position); //lookup
                            int length = (int) binmul.BaseStream.Position;
                            binmul.Write((int) 1234); // header
                            binmul.Write((short) bmp.Width);
                            binmul.Write((short) bmp.Height);
                            int lookup = (int) binmul.BaseStream.Position;
                            int streamloc = lookup + bmp.Height * 2;
                            int width = 0;
                            for (int i = 0; i < bmp.Height; ++i) // fill lookup
                                binmul.Write(width);
                            int X = 0;
                            for (int Y = 0; Y < bmp.Height; ++Y, line += delta)
                            {
                                ushort* cur = line;
                                width = (int) (binmul.BaseStream.Position - streamloc) / 2;
                                binmul.BaseStream.Seek(lookup + Y * 2, SeekOrigin.Begin);
                                binmul.Write(width);
                                binmul.BaseStream.Seek(streamloc + width * 2, SeekOrigin.Begin);
                                int i = 0;
                                int j = 0;
                                X = 0;
                                while (i < bmp.Width)
                                {
                                    i = X;
                                    for (i = X; i <= bmp.Width; ++i)
                                    {
                                        //first pixel set
                                        if (i < bmp.Width)
                                        {
                                            if (cur[i] != 0)
                                                break;
                                        }
                                    }

                                    if (i < bmp.Width)
                                    {
                                        for (j = (i + 1); j < bmp.Width; ++j)
                                        {
                                            //next non set pixel
                                            if (cur[j] == 0)
                                                break;
                                        }

                                        binmul.Write((short) (i - X)); //xoffset
                                        binmul.Write((short) (j - i)); //run
                                        for (int p = i; p < j; ++p)
                                            binmul.Write((ushort) (cur[p] ^ 0x8000));
                                        X = j;
                                    }
                                }

                                binmul.Write((short) 0); //xOffset
                                binmul.Write((short) 0); //Run
                            }

                            int start = length;
                            length = (int) binmul.BaseStream.Position - length;
                            binidx.Write(length);
                            binidx.Write((int) 0);
                            bmp.UnlockBits(bd);
                            CheckSums s = new CheckSums()
                                {pos = start, length = length, checksum = checksum, index = index};
                            //Tex.WriteLine(System.String.Format("0x{0:X4} : 0x{1:X4} 0x{2:X4}", index, start, length));
                            checksumsStatic.Add(s);
                        }
                    }

                    memidx.WriteTo(fsidx);
                    memmul.WriteTo(fsmul);
                }
            }
        }

        private static bool compareSaveImagesLand(byte[] newchecksum, out CheckSums sum)
        {
            sum = new CheckSums();
            for (int i = 0; i < checksumsLand.Count; ++i)
            {
                byte[] cmp = checksumsLand[i].checksum;
                if (((cmp == null) || (newchecksum == null))
                    || (cmp.Length != newchecksum.Length))
                {
                    return false;
                }

                bool valid = true;
                for (int j = 0; j < cmp.Length; ++j)
                {
                    if (cmp[j] != newchecksum[j])
                    {
                        valid = false;
                        break;
                    }
                }

                if (valid)
                {
                    sum = checksumsLand[i];
                    return true;
                }
            }

            return false;
        }

        private static bool compareSaveImagesStatic(byte[] newchecksum, out CheckSums sum)
        {
            sum = new CheckSums();
            for (int i = 0; i < checksumsStatic.Count; ++i)
            {
                byte[] cmp = checksumsStatic[i].checksum;
                if (((cmp == null) || (newchecksum == null))
                    || (cmp.Length != newchecksum.Length))
                {
                    return false;
                }

                bool valid = true;
                for (int j = 0; j < cmp.Length; ++j)
                {
                    if (cmp[j] != newchecksum[j])
                    {
                        valid = false;
                        break;
                    }
                }

                if (valid)
                {
                    sum = checksumsStatic[i];
                    return true;
                }
            }

            return false;
        }
    }
}

================================================
FILE: Razor/UltimaSDK/BwtDecompress.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2024 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion
using System;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;

namespace Ultima
{
    internal static class BwtDecompress
    {
        public static byte[] Decompress(byte[] buffer)
        {
            byte[] output = null;

            using (var reader = new BinaryReader(new MemoryStream(buffer)))
            {
                var header = reader.ReadUInt32();
                var len = 0u;

                var firstChar = reader.ReadByte();

                Span<ushort> table = new ushort[256 * 256];
                table = BuildTable(table, firstChar);

                var list = new byte[reader.BaseStream.Length - 4];
                var i = 0;
                while (reader.BaseStream.Position < reader.BaseStream.Length)
                {
                    var currentValue = firstChar;
                    var value = table[currentValue];
                    if (currentValue > 0)
                    {
                        do
                        {
                            table[currentValue] = table[currentValue - 1];
                        } while (--currentValue > 0);
                    }

                    table[0] = value;

                    list[i++] = (byte) value;
                    firstChar = reader.ReadByte();
                }

                output = InternalDecompress(list, len);
            }

            return output;
        }

        /// 
        static void MergeSort(Span<ushort> span)
        {
            if (span.Length <= 1)
                return;

            var list = span.ToArray().ToList();
            list.Sort();

            int mid = span.Length / 2;
            var left = span.Slice(0, mid);
            var right = span.Slice(mid);

            MergeSort(left);
            MergeSort(right);

            Merge(span, left, right);
        }

        static void Merge(Span<ushort> destination, Span<ushort> left, Span<ushort> right)
        {
            int i = 0, j = 0, k = 0;

            while (i < left.Length && j < right.Length)
            {
                if (left[i] <= right[j])
                {
                    destination[k++] = left[i++];
                }
                else
                {
                    destination[k++] = right[j++];
                }
            }

            while (i < left.Length)
            {
                destination[k++] = left[i++];
            }

            while (j < right.Length)
            {
                destination[k++] = right[j++];
            }
        }

        /// 

        static Span<ushort> BuildTable(Span<ushort> table, byte startValue)
        {
            int index = 0;
            byte firstByte = startValue;
            byte secondByte = 0;
            for (int i = 0; i < 256 * 256; i++)
            {
                var val = (ushort) (firstByte + (secondByte << 8));
                table[index++] = val;

                firstByte++;
                if (firstByte == 0)
                {
                    secondByte++;
                }
            }

            var list = table.ToArray().ToList();
            list.Sort();
            return list.ToArray();
        }

        static byte[] InternalDecompress(Span<byte> input, uint len)
        {
            Span<char> symbolTable = stackalloc char[256];
            Span<char> frequency = stackalloc char[256];
            Span<int> partialInput = stackalloc int[256 * 3];
            partialInput.Clear();

            for (var i = 0; i < 256; i++)
                symbolTable[i] = (char) i;

            input.Slice(0, 1024).CopyTo(MemoryMarshal.AsBytes(partialInput));

            var sum = 0;
            for (var i = 0; i < 256; i++)
                sum += partialInput[i];

            if (len == 0)
            {
                len = (uint) sum;
            }

            if (sum != len)
                return Array.Empty<byte>();

            var output = new byte[len];

            var count = 0;
            var nonZeroCount = 0;

            for (var i = 0; i < 256; i++)
            {
                if (partialInput[i] != 0)
                    nonZeroCount++;
            }

            Frequency(partialInput, frequency);

            for (int i = 0, m = 0; i < nonZeroCount; ++i)
            {
                var freq = (byte) frequency[i];
                symbolTable[input[m + 1024]] = (char) freq;
                partialInput[freq + 256] = m + 1;
                m += partialInput[freq];
                partialInput[freq + 512] = m;
            }

            var val = (byte) symbolTable[0];

            if (len != 0)
            {
                do
                {
                    ref var firstValRef = ref partialInput[val + 256];
                    output[count] = val;

                    if (firstValRef >= partialInput[val + 512])
                    {
                        if (nonZeroCount-- > 0)
                        {
                            ShiftLeft(symbolTable, nonZeroCount);
                            val = (byte) symbolTable[0];
                        }
                    }
                    else
                    {
                        var idx = (char) input[firstValRef + 1024];
                        firstValRef++;

                        if (idx != 0)
                        {
                            ShiftLeft(symbolTable, idx);
                            symbolTable[(byte) idx] = (char) val;
                            val = (byte) symbolTable[0];
                        }
                    }

                    count++;
                } while (count < len);
            }

            return output;
        }

        static void Frequency(Span<int> input, Span<char> output)
        {
            Span<int> tmp = stackalloc int[256];
            input.Slice(0, tmp.Length).CopyTo(tmp);

            for (var i = 0; i < 256; i++)
            {
                uint value = 0;
                byte index = 0;

                for (var j = 0; j < 256; j++)
                {
                    if (tmp[j] > value)
                    {
                        index = (byte) j;
                        value = (uint) tmp[j];
                    }
                }

                if (value == 0)
                    break;

                output[i] = (char) index;
                tmp[index] = 0;
            }
        }

        static void ShiftLeft(Span<char> input, int max)
        {
            for (var i = 0; i < max; ++i)
                input[i] = input[i + 1];
        }
    }
}

================================================
FILE: Razor/UltimaSDK/CalibrationInfo.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.IO;

namespace Ultima
{
    public sealed class CalibrationInfo
    {
        public byte[] Mask { get; private set; }
        public byte[] Vals { get; private set; }
        public byte[] DetX { get; private set; }
        public byte[] DetY { get; private set; }
        public byte[] DetZ { get; private set; }
        public byte[] DetF { get; private set; }

        public CalibrationInfo(byte[] mask, byte[] vals, byte[] detx, byte[] dety, byte[] detz, byte[] detf)
        {
            Mask = mask;
            Vals = vals;
            DetX = detx;
            DetY = dety;
            DetZ = detz;
            DetF = detf;
        }

        private static byte[] ReadBytes(StreamReader ip)
        {
            string line = ip.ReadLine();

            if (line == null)
                return null;

            byte[] buffer = new byte[(line.Length + 2) / 3];
            int index = 0;

            for (int i = 0; (i + 1) < line.Length; i += 3)
            {
                char ch = line[i + 0];
                char cl = line[i + 1];

                if (ch >= '0' && ch <= '9')
                    ch -= '0';
                else if (ch >= 'a' && ch <= 'f')
                    ch -= (char) ('a' - 10);
                else if (ch >= 'A' && ch <= 'F')
                    ch -= (char) ('A' - 10);
                else
                    return null;

                if (cl >= '0' && cl <= '9')
                    cl -= '0';
                else if (cl >= 'a' && cl <= 'f')
                    cl -= (char) ('a' - 10);
                else if (cl >= 'A' && cl <= 'F')
                    cl -= (char) ('A' - 10);
                else
                    return null;

                buffer[index++] = (byte) ((ch << 4) | cl);
            }

            return buffer;
        }

        private static CalibrationInfo[] m_DefaultList = new CalibrationInfo[]
        {
            new CalibrationInfo( //Post 7.0.4.0 (Andreew)
                new byte[]
                {
                    0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF,
                    0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF
                },
                new byte[]
                {
                    0xFF, 0xD0, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x8B, 0x0D, 0x00, 0x00, 0x00, 0x00, 0x8B, 0x11, 0x8B,
                    0x82, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xD0, 0x5B, 0x83, 0x00, 0x00, 0x00, 0x00, 0x00, 0xEC
                },
                new byte[] {0x22, 0x04, 0xFF, 0xFF, 0xFF, 0x04, 0x0C}, //x
                new byte[] {0x22, 0x04, 0xFF, 0xFF, 0xFF, 0x04, 0x08}, //y
                new byte[] {0x22, 0x04, 0xFF, 0xFF, 0xFF, 0x04, 0x04}, //z
                new byte[] {0x22, 0x04, 0xFF, 0xFF, 0xFF, 0x04, 0x10}), //f
            new CalibrationInfo( /* (arul) 6.0.9.x+ : Calibrates both  */
                new byte[]
                {
                    0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF,
                    0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF
                },
                new byte[]
                {
                    0xFF, 0xD0, 0xE8, 0x00, 0x00, 0x00, 0x00, 0x8B, 0x0D, 0x00, 0x00, 0x00, 0x00, 0x8B, 0x11, 0x8B,
                    0x82, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xD0, 0x5E, 0xE9, 0x00, 0x00, 0x00, 0x00, 0x8B, 0x0D
                },
                new byte[] {0x1F, 0x04, 0xFF, 0xFF, 0xFF, 0x04, 0x0C},
                new byte[] {0x1F, 0x04, 0xFF, 0xFF, 0xFF, 0x04, 0x08},
                new byte[] {0x1F, 0x04, 0xFF, 0xFF, 0xFF, 0x04, 0x04},
                new byte[] {0x1F, 0x04, 0xFF, 0xFF, 0xFF, 0x04, 0x10}),
            new CalibrationInfo( /* Facet */
                new byte[] {0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
                new byte[] {0xA0, 0x00, 0x00, 0x00, 0x00, 0x84, 0xC0, 0x0F, 0x85, 0x00, 0x00, 0x00, 0x00, 0x8B, 0x0D},
                new byte[0],
                new byte[0],
                new byte[0],
                new byte[] {0x01, 0x04, 0xFF, 0xFF, 0xFF, 0x01}
            ),
            new CalibrationInfo( /* Location */
                new byte[]
                {
                    0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0x00, 0x00,
                    0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x00
                },
                new byte[]
                {
                    0x8B, 0x15, 0x00, 0x00, 0x00, 0x00, 0x83, 0xC4, 0x10, 0x66, 0x89, 0x5A, 0x00, 0xA1, 0x00, 0x00,
                    0x00, 0x00, 0x66, 0x89, 0x78, 0x00, 0x8B, 0x0D, 0x00, 0x00, 0x00, 0x00, 0x66, 0x89, 0x71, 0x00
                },
                new byte[] {0x02, 0x04, 0x04, 0x0C, 0x01, 0x02},
                new byte[] {0x0E, 0x04, 0x04, 0x15, 0x01, 0x02},
                new byte[] {0x18, 0x04, 0x04, 0x1F, 0x01, 0x02},
                new byte[0]
            ),
            new CalibrationInfo( /* UO3D Only, calibrates both */
                new byte[]
                {
                    0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF,
                    0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
                    0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00
                },
                new byte[]
                {
                    0xA1, 0x00, 0x00, 0x00, 0x00, 0x68, 0x40, 0x2E, 0x04, 0x01, 0x0F, 0xBF, 0x50, 0x00, 0x0F, 0xBF,
                    0x48, 0x00, 0x52, 0x51, 0x0F, 0xBF, 0x50, 0x00, 0x52, 0x8D, 0x85, 0xE4, 0xFD, 0xFF, 0xFF, 0x68,
                    0x00, 0x00, 0x00, 0x00, 0x50, 0xE8, 0x07, 0x44, 0x10, 0x00, 0x8A, 0x0D, 0x00, 0x00, 0x00, 0x00
                },
                new byte[] {0x01, 0x04, 0x04, 0x17, 0x01, 0x02},
                new byte[] {0x01, 0x04, 0x04, 0x11, 0x01, 0x02},
                new byte[] {0x01, 0x04, 0x04, 0x0D, 0x01, 0x02},
                new byte[] {0x2C, 0x04, 0xFF, 0xFF, 0xFF, 0x01}
            )
        };

        public static CalibrationInfo[] DefaultList
        {
            get { return m_DefaultList; }
            set { m_DefaultList = value; }
        }

        public static CalibrationInfo[] GetList()
        {
            List<CalibrationInfo> list = new List<CalibrationInfo>();

            string path = Path.GetDirectoryName(Environment.GetCommandLineArgs()[0]);
            path = Path.Combine(path, "calibration.cfg");

            if (File.Exists(path))
            {
                using (StreamReader ip = new StreamReader(path))
                {
                    string line;

                    while ((line = ip.ReadLine()) != null)
                    {
                        line = line.Trim();

                        if (line.Equals("Begin", StringComparison.OrdinalIgnoreCase))
                        {
                            byte[] mask, vals, detx, dety, detz, detf;

                            if ((mask = ReadBytes(ip)) == null)
                                continue;

                            if ((vals = ReadBytes(ip)) == null)
                                continue;

                            if ((detx = ReadBytes(ip)) == null)
                                continue;

                            if ((dety = ReadBytes(ip)) == null)
                                continue;

                            if ((detz = ReadBytes(ip)) == null)
                                continue;

                            if ((detf = ReadBytes(ip)) == null)
                                continue;

                            list.Add(new CalibrationInfo(mask, vals, detx, dety, detz, detf));
                        }
                    }
                }
            }

            list.AddRange(DefaultList);

            return list.ToArray();
        }
    }
}

================================================
FILE: Razor/UltimaSDK/Client.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.IO;

namespace Ultima
{
    /// <summary>
    /// Provides methods to interact with the Ultima Online client.
    /// </summary>
    public sealed class Client
    {
        private const int WM_CHAR = 0x102;

        private static ClientWindowHandle m_Handle = ClientWindowHandle.Invalid;

        private static WindowProcessStream m_ProcStream;
        private static LocationPointer m_LocationPointer;

        private static bool m_Is_Iris2 = false;

        private Client()
        {
        }

        /// <summary>
        /// Gets a <see cref="ProcessStream" /> instance which can be used to read the memory. Null is returned if the Client is not running.
        /// </summary>
        public static ProcessStream ProcessStream
        {
            get
            {
                if (m_ProcStream == null || m_ProcStream.Window != Handle)
                {
                    if (Running)
                        m_ProcStream = new WindowProcessStream(Handle);
                    else
                        m_ProcStream = null;
                }

                return m_ProcStream;
            }
        }

        /// <summary>
        /// Reads the current <paramref name="x" />, <paramref name="y" />, and <paramref name="z" /> from memory based on a <see cref="Calibrate">calibrated memory location</see>.
        /// <seealso cref="Calibrate" />
        /// <seealso cref="ProcessStream" />
        /// <returns>True if the location was found, false if not</returns>
        /// </summary>
        public static bool FindLocation(ref int x, ref int y, ref int z, ref int facet)
        {
            LocationPointer lp = LocationPointer;
            ProcessStream pc = ProcessStream;

            if (pc == null || lp == null)
                return false;

            pc.BeginAccess();

            if (lp.PointerX > 0)
            {
                pc.Seek(lp.PointerX, SeekOrigin.Begin);
                x = Read(pc, lp.SizeX);
            }

            if (lp.PointerY > 0)
            {
                pc.Seek(lp.PointerY, SeekOrigin.Begin);
                y = Read(pc, lp.SizeY);
            }

            if (lp.PointerZ > 0)
            {
                pc.Seek(lp.PointerZ, SeekOrigin.Begin);
                z = Read(pc, lp.SizeZ);
            }

            if (lp.PointerF > 0)
            {
                pc.Seek(lp.PointerF, SeekOrigin.Begin);
                facet = Read(pc, lp.SizeF);
            }

            pc.EndAccess();

            return true;
        }

        public static int Read(ProcessStream pc, int bytes)
        {
            byte[] buffer = new byte[bytes];

            pc.Read(buffer, 0, bytes);

            switch (bytes)
            {
                case 1: return (sbyte) buffer[0];
                case 2: return (short) (buffer[0] | (buffer[1] << 8));
                case 4: return (int) (buffer[0] | (buffer[1] << 8) | (buffer[2] << 16) | (buffer[3] << 24));
            }

            int val = 0;
            int bits = 0;

            for (int i = 0; i < buffer.Length; ++i)
            {
                val |= buffer[i] << bits;
                bits += 8;
            }

            return val;
        }

        public static int Search(ProcessStream pc, byte[] mask, byte[] vals)
        {
            if (mask.Length != vals.Length)
                throw new Exception();

            const int chunkSize = 4096;
            int readSize = chunkSize + mask.Length;

            pc.BeginAccess();

            byte[] read = new byte[readSize];

            for (int i = 0;; ++i)
            {
                pc.Seek(0x400000 + (i * chunkSize), SeekOrigin.Begin);
                int count = pc.Read(read, 0, readSize);

                if (count != readSize)
                    break;

                for (int j = 0; j < chunkSize; ++j)
                {
                    bool ok = true;

                    for (int k = 0; ok && k < mask.Length; ++k)
                        ok = ((read[j + k] & mask[k]) == vals[k]);

                    if (ok)
                    {
                        pc.EndAccess();
                        return 0x400000 + (i * chunkSize) + j;
                    }
                }
            }

            pc.EndAccess();
            return 0;
        }

        public static int Search(ProcessStream pc, byte[] buffer)
        {
            const int chunkSize = 4096;
            int readSize = chunkSize + buffer.Length;

            pc.BeginAccess();

            byte[] read = new byte[readSize];

            for (int i = 0;; ++i)
            {
                pc.Seek(0x400000 + (i * chunkSize), SeekOrigin.Begin);
                int count = pc.Read(read, 0, readSize);

                if (count != readSize)
                    break;

                for (int j = 0; j < chunkSize; ++j)
                {
                    bool ok = true;

                    for (int k = 0; ok && k < buffer.Length; ++k)
                        ok = (buffer[k] == read[j + k]);

                    if (ok)
                    {
                        pc.EndAccess();
                        return 0x400000 + (i * chunkSize) + j;
                    }
                }
            }

            pc.EndAccess();
            return 0;
        }

        /// <summary>
        /// Attempts to calibrate the <see cref="FindLocation" /> method based on an input <paramref name="x" />, <paramref name="y" />, and <paramref name="z" />.
        /// <seealso cref="FindLocation" />
        /// <seealso cref="ProcessStream" />
        /// </summary>
        /// <returns>The calibrated memory location -or- 0 if it could not be found.</returns>
        public static void Calibrate(int x, int y, int z)
        {
            m_LocationPointer = null;

            ProcessStream pc = ProcessStream;

            if (pc == null)
                return;

            byte[] buffer = new byte[12];

            buffer[0] = (byte) z;
            buffer[1] = (byte) (z >> 8);
            buffer[2] = (byte) (z >> 16);
            buffer[3] = (byte) (z >> 24);

            buffer[4] = (byte) y;
            buffer[5] = (byte) (y >> 8);
            buffer[6] = (byte) (y >> 16);
            buffer[7] = (byte) (y >> 24);

            buffer[8] = (byte) x;
            buffer[9] = (byte) (x >> 8);
            buffer[10] = (byte) (x >> 16);
            buffer[11] = (byte) (x >> 24);

            int ptr = Search(pc, buffer);

            if (ptr == 0)
                return;

            m_LocationPointer = new LocationPointer(ptr + 8, ptr + 4, ptr, 0, 4, 4, 4, 0);
        }

        /// <summary>
        /// Attempts to automatically calibrate the <see cref="FindLocation" /> method.
        /// </summary>
        /// <returns>The calibrated memory location -or- 0 if it could not be found.</returns>
        public static void Calibrate()
        {
            Calibrate(CalibrationInfo.GetList());
        }

        /// <summary>
        /// Attempts to automatically calibrate the <see cref="FindLocation" /> method.
        /// </summary>
        /// <returns>The calibrated memory location -or- 0 if it could not be found.</returns>
        public static void Calibrate(CalibrationInfo[] info)
        {
            m_LocationPointer = null;

            ProcessStream pc = ProcessStream;

            if (pc == null)
                return;

            int ptrX = 0, sizeX = 0;
            int ptrY = 0, sizeY = 0;
            int ptrZ = 0, sizeZ = 0;
            int ptrF = 0, sizeF = 0;

            for (int i = 0; i < info.Length; ++i)
            {
                CalibrationInfo ci = info[i];

                int ptr = Search(pc, ci.Mask, ci.Vals);

                if (ptr == 0)
                    continue;

                if (ptrX == 0 && ci.DetX.Length > 0)
                    GetCoordDetails(pc, ptr, ci.DetX, out ptrX, out sizeX);

                if (ptrY == 0 && ci.DetY.Length > 0)
                    GetCoordDetails(pc, ptr, ci.DetY, out ptrY, out sizeY);

                if (ptrZ == 0 && ci.DetZ.Length > 0)
                    GetCoordDetails(pc, ptr, ci.DetZ, out ptrZ, out sizeZ);

                if (ptrF == 0 && ci.DetF.Length > 0)
                    GetCoordDetails(pc, ptr, ci.DetF, out ptrF, out sizeF);

                if (ptrX != 0 && ptrY != 0 && ptrZ != 0 && ptrF != 0)
                    break;
            }

            if (ptrX != 0 || ptrY != 0 || ptrZ != 0 || ptrF != 0)
                m_LocationPointer = new LocationPointer(ptrX, ptrY, ptrZ, ptrF, sizeX, sizeY, sizeZ, sizeF);
        }

        private static void GetCoordDetails(ProcessStream pc, int ptr, byte[] dets, out int coordPointer,
            out int coordSize)
        {
            pc.Seek(ptr + dets[0], SeekOrigin.Begin);
            coordPointer = Read(pc, dets[1]);

            if (dets[2] < 0xFF)
            {
                pc.Seek(coordPointer, SeekOrigin.Begin);
                coordPointer = Read(pc, dets[2]);
            }

            if (dets[3] < 0xFF)
            {
                pc.Seek(ptr + dets[3], SeekOrigin.Begin);
                coordPointer += Read(pc, dets[4]);
            }

            /*
             * arul:
             *	The variable 'dets[6]' represents an offset into the struct that holds an info about players current location.
             *	Added not to break functionality with the older clients (I hope).
             * 
             * The struct looks as follows: 
             * 
             *  DWORD fLoggedIn; 
             *	DWORD Z;
             *  DWORD Y;
             *	DWORD X;
             *	DWORD Facet;  
             *  
             */
            if (dets.Length == 7 && dets[6] < 0xFF)
            {
                coordPointer += dets[6];
            }

            coordSize = dets[5];
        }

        /// <summary>
        /// Gets or sets the memory location currently used for the <see cref="FindLocation" /> method.
        /// <seealso cref="FindLocation" />
        /// <seealso cref="Calibrate" />
        /// </summary>
        public static LocationPointer LocationPointer
        {
            get { return m_LocationPointer; }
            set { m_LocationPointer = value; }
        }

        /// <summary>
        /// Gets the current window handle. A value of <c>ClientHandle.Invalid</c> is returned if the Client is not currently running.
        /// <seealso cref="Running" />
        /// </summary>
        public static ClientWindowHandle Handle
        {
            get
            {
                if (NativeMethods.IsWindow(m_Handle) == 0)
                    m_Handle = FindHandle();

                return m_Handle;
            }
        }

        /// <summary>
        /// Whether or not the Client is currently running.
        /// <seealso cref="ClientHandle" />
        /// </summary>
        public static bool Running
        {
            get { return (!Handle.IsInvalid); }
        }

        /// <summary>
        /// Is Client Iris2
        /// </summary>
        public static bool Is_Iris2
        {
            get { return m_Is_Iris2; }
            set { m_Is_Iris2 = value; }
        }

        private static void SendChar(ClientWindowHandle hWnd, char c)
        {
            int value = (int) c;
            int lParam = 1 | ((NativeMethods.OemKeyScan(value) & 0xFF) << 16) | (0x3 << 30);

            NativeMethods.PostMessage(hWnd, WM_CHAR, value, lParam);
        }

        /// <summary>
        /// Brings the Client window to the foreground.
        /// </summary>
        /// <returns>True if the Client is running, false if not.</returns>
        public static bool BringToTop()
        {
            ClientWindowHandle hWnd = Handle;

            if (!hWnd.IsInvalid)
            {
                NativeMethods.SetForegroundWindow(hWnd);

                return true;
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// Sends a <see cref="String" /> of characters (<paramref name="text" />) to the Client. The string is followed by a carriage return and line feed.
        /// </summary>
        /// <returns>True if the Client is running, false if not.</returns>
        public static bool SendText(string text)
        {
            ClientWindowHandle hWnd = Handle;

            if (!hWnd.IsInvalid)
            {
                for (int i = 0; i < text.Length; ++i)
                    SendChar(hWnd, text[i]);

                SendChar(hWnd, '\r');
                SendChar(hWnd, '\n');

                return true;
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// Sends a formatted <see cref="String" /> of characters to the Client. The string is followed by a carriage return and line feed. The format functionality is the same as <see cref="String.Format">String.Format</see>.
        /// </summary>
        /// <returns>True if the Client is running, false if not.</returns>
        public static bool SendText(string format, params object[] args)
        {
            return SendText(String.Format(format, args));
        }


        private static ClientWindowHandle FindHandle()
        {
            ClientWindowHandle hWnd;

            if (NativeMethods.IsWindow(hWnd = NativeMethods.FindWindowA("Ultima Online", null)) != 0)
                return hWnd;

            if (NativeMethods.IsWindow(hWnd = NativeMethods.FindWindowA("Ultima Online Third Dawn", null)) != 0)
                return hWnd;
            if (NativeMethods.IsWindow(hWnd = NativeMethods.FindWindowA("OgreGLWindow", null)) != 0)
            {
                m_Is_Iris2 = true;
                return hWnd;
            }


            return ClientWindowHandle.Invalid;
        }
    }
}

================================================
FILE: Razor/UltimaSDK/ClientHandles.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using Microsoft.Win32.SafeHandles;

namespace Ultima
{
    public class ClientWindowHandle : CriticalHandleZeroOrMinusOneIsInvalid
    {
        public static ClientWindowHandle Invalid = new ClientWindowHandle(new IntPtr(-1));

        public ClientWindowHandle()
        {
        }

        public ClientWindowHandle(IntPtr value)
        {
            handle = value;
        }

        protected override bool ReleaseHandle()
        {
            if (!this.IsClosed)
                return ReleaseHandle();
            return true;
        }
    }

    public class ClientProcessHandle : CriticalHandleZeroOrMinusOneIsInvalid
    {
        public static ClientProcessHandle Invalid = new ClientProcessHandle(new IntPtr(-1));

        public ClientProcessHandle()
            : base()
        {
        }

        public ClientProcessHandle(IntPtr value)
            : base()
        {
            handle = value;
        }

        protected override bool ReleaseHandle()
        {
            return NativeMethods.CloseHandle(this) == 0;
        }
    }
}

================================================
FILE: Razor/UltimaSDK/FileIndex.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.InteropServices;

namespace Ultima
{
    public sealed class FileIndex
    {
        public Entry3D[] Index { get; private set; }
        public Stream Stream { get; private set; }
        public long IdxLength { get; private set; }
        private string MulPath;

        public Stream Seek(int index, out int length, out int extra, out bool patched)
        {
            if (index < 0 || index >= Index.Length)
            {
                length = extra = 0;
                patched = false;
                return null;
            }

            Entry3D e = Index[index];

            if (e.lookup < 0)
            {
                length = extra = 0;
                patched = false;
                return null;
            }

            length = e.length & 0x7FFFFFFF;
            extra = e.extra;

            if ((e.length & (1 << 31)) != 0)
            {
                patched = true;
                Verdata.Seek(e.lookup);
                return Verdata.Stream;
            }

            if (e.length < 0)
            {
                length = extra = 0;
                patched = false;
                return null;
            }

            if ((Stream == null) || (!Stream.CanRead) || (!Stream.CanSeek))
            {
                if (MulPath == null)
                    Stream = null;
                else
                    Stream = new FileStream(MulPath, FileMode.Open, FileAccess.Read, FileShare.Read);
            }

            if (Stream == null)
            {
                length = extra = 0;
                patched = false;
                return null;
            }
            else if (Stream.Length < e.lookup)
            {
                length = extra = 0;
                patched = false;
                return null;
            }

            patched = false;

            Stream.Seek(e.lookup, SeekOrigin.Begin);
            return Stream;
        }

        public bool Valid(int index, out int length, out int extra, out bool patched)
        {
            if (index < 0 || index >= Index.Length)
            {
                length = extra = 0;
                patched = false;
                return false;
            }

            Entry3D e = Index[index];

            if (e.lookup < 0)
            {
                length = extra = 0;
                patched = false;
                return false;
            }

            length = e.length & 0x7FFFFFFF;
            extra = e.extra;

            if ((e.length & (1 << 31)) != 0)
            {
                patched = true;
                return true;
            }

            if (e.length < 0)
            {
                length = extra = 0;
                patched = false;
                return false;
            }

            if ((MulPath == null) || !File.Exists(MulPath))
            {
                length = extra = 0;
                patched = false;
                return false;
            }

            if ((Stream == null) || (!Stream.CanRead) || (!Stream.CanSeek))
            {
                Stream = new FileStream(MulPath, FileMode.Open, FileAccess.Read, FileShare.Read);
            }

            if (Stream.Length < e.lookup)
            {
                length = extra = 0;
                patched = false;
                return false;
            }

            patched = false;

            return true;
        }

        public FileIndex(string idxFile, string mulFile, int length, int file) : this(idxFile, mulFile, null, length,
            file, ".dat", -1, false)
        {
        }

        public FileIndex(string idxFile, string mulFile, string uopFile, int length, int file, string uopEntryExtension,
            int idxLength, bool hasExtra)
        {
            Index = new Entry3D[length];

            string idxPath = null;
            MulPath = null;
            string uopPath = null;

            if (Files.MulPath == null)
                Files.LoadMulPath();

            if (Files.MulPath.Count > 0)
            {
                idxPath = Files.MulPath[idxFile.ToLower()];
                MulPath = Files.MulPath[mulFile.ToLower()];

                if (!String.IsNullOrEmpty(uopFile) && Files.MulPath.ContainsKey(uopFile.ToLower()))
                    uopPath = Files.MulPath[uopFile.ToLower()];

                if (String.IsNullOrEmpty(idxPath))
                {
                    idxPath = null;
                }
                else
                {
                    if (String.IsNullOrEmpty(Path.GetDirectoryName(idxPath)))
                        idxPath = Path.Combine(Files.RootDir, idxPath);

                    if (!File.Exists(idxPath))
                        idxPath = null;
                }

                if (String.IsNullOrEmpty(MulPath))
                {
                    MulPath = null;
                }
                else
                {
                    if (String.IsNullOrEmpty(Path.GetDirectoryName(MulPath)))
                        MulPath = Path.Combine(Files.RootDir, MulPath);

                    if (!File.Exists(MulPath))
                        MulPath = null;
                }

                if (String.IsNullOrEmpty(uopPath))
                {
                    uopPath = null;
                }
                else
                {
                    if (String.IsNullOrEmpty(Path.GetDirectoryName(uopPath)))
                        uopPath = Path.Combine(Files.RootDir, uopPath);

                    if (!File.Exists(uopPath))
                        uopPath = null;
                    else
                        MulPath = uopPath;
                }
            }

            /* UOP files support code, written by Wyatt (c) www.ruosi.org
             * idxLength variable was added for compatibility with legacy code for art (see art.cs)
             * At the moment the only UOP file having entries with extra field is gumpartlegacy.uop,
             * and it's two dwords in the beginning of the entry.
             * It's possible that UOP can include some entries with unknown hash: not really unknown for me, but
             * not useful for reading legacy entries. That's why i removed unknown hash exception throwing from this code
             */
            if (MulPath != null && MulPath.EndsWith(".uop"))
            {
                using (FileStream index = new FileStream(MulPath, FileMode.Open, FileAccess.Read, FileShare.Read))
                {
                    Stream = new FileStream(MulPath, FileMode.Open, FileAccess.Read, FileShare.Read);

                    FileInfo fi = new FileInfo(MulPath);
                    string uopPattern = fi.Name.Replace(fi.Extension, "").ToLowerInvariant();

                    using (BinaryReader br = new BinaryReader(Stream))
                    {
                        br.BaseStream.Seek(0, SeekOrigin.Begin);

                        if (br.ReadInt32() != 0x50594D)
                            throw new ArgumentException("Bad UOP file.");

                        br.ReadInt64(); // version + signature
                        long nextBlock = br.ReadInt64();
                        br.ReadInt32(); // block capacity
                        int count = br.ReadInt32();

                        if (idxLength > 0)
                            IdxLength = idxLength * 12;

                        Dictionary<ulong, int> hashes = new Dictionary<ulong, int>();

                        for (int i = 0; i < length; i++)
                        {
                            string entryName = $"build/{uopPattern}/{i:D8}{uopEntryExtension}";
                            ulong hash = HashFileName(entryName);

                            if (!hashes.ContainsKey(hash))
                                hashes.Add(hash, i);
                        }

                        br.BaseStream.Seek(nextBlock, SeekOrigin.Begin);

                        do
                        {
                            int filesCount = br.ReadInt32();
                            nextBlock = br.ReadInt64();

                            for (int i = 0; i < filesCount; i++)
                            {
                                long offset = br.ReadInt64();
                                int headerLength = br.ReadInt32();
                                int compressedLength = br.ReadInt32();
                                int decompressedLength = br.ReadInt32();
                                ulong hash = br.ReadUInt64();
                                br.ReadUInt32(); // Adler32
                                short flag = br.ReadInt16();

                                int entryLength = flag == 1 ? compressedLength : decompressedLength;

                                if (offset == 0)
                                    continue;

                                int idx;
                                if (hashes.TryGetValue(hash, out idx))
                                {
                                    if (idx < 0 || idx > Index.Length)
                                        throw new IndexOutOfRangeException(
                                            "hashes dictionary and files collection have different count of entries!");

                                    Index[idx].lookup = (int) (offset + headerLength);
                                    Index[idx].length = entryLength;

                                    if (hasExtra)
                                    {
                                        long curPos = br.BaseStream.Position;

                                        br.BaseStream.Seek(offset + headerLength, SeekOrigin.Begin);

                                        byte[] extra = br.ReadBytes(8);

                                        short extra1 =
                                            (short) ((extra[3] << 24) | (extra[2] << 16) | (extra[1] << 8) | extra[0]);
                                        short extra2 =
                                            (short) ((extra[7] << 24) | (extra[6] << 16) | (extra[5] << 8) | extra[4]);

                                        Index[idx].lookup += 8;
                                        Index[idx].extra = extra1 << 16 | extra2;

                                        br.BaseStream.Seek(curPos, SeekOrigin.Begin);
                                    }
                                }
                            }
                        } while (br.BaseStream.Seek(nextBlock, SeekOrigin.Begin) != 0);
                    }
                }
            }
            else if ((idxPath != null) && (MulPath != null))
            {
                using (FileStream index = new FileStream(idxPath, FileMode.Open, FileAccess.Read, FileShare.Read))
                {
                    Stream = new FileStream(MulPath, FileMode.Open, FileAccess.Read, FileShare.Read);
                    int count = (int) (index.Length / 12);
                    IdxLength = index.Length;
                    GCHandle gc = GCHandle.Alloc(Index, GCHandleType.Pinned);
                    byte[] buffer = new byte[index.Length];
                    index.Read(buffer, 0, (int) index.Length);
                    Marshal.Copy(buffer, 0, gc.AddrOfPinnedObject(), (int) Math.Min(IdxLength, length * 12));
                    gc.Free();
                    for (int i = count; i < length; ++i)
                    {
                        Index[i].lookup = -1;
                        Index[i].length = -1;
                        Index[i].extra = -1;
                    }
                }
            }
            else
            {
                Stream = null;
                return;
            }

            Entry5D[] patches = Verdata.Patches;

            if (file > -1)
            {
                for (int i = 0; i < patches.Length; ++i)
                {
                    Entry5D patch = patches[i];

                    if (patch.file == file && patch.index >= 0 && patch.index < length)
                    {
                        Index[patch.index].lookup = patch.lookup;
                        Index[patch.index].length = patch.length | (1 << 31);
                        Index[patch.index].extra = patch.extra;
                    }
                }
            }
        }

        public FileIndex(string idxFile, string mulFile, int file)
        {
            string idxPath = null;
            MulPath = null;
            if (Files.MulPath == null)
                Files.LoadMulPath();
            if (Files.MulPath.Count > 0)
            {
                idxPath = Files.MulPath[idxFile.ToLower()];
                MulPath = Files.MulPath[mulFile.ToLower()];
                if (String.IsNullOrEmpty(idxPath))
                    idxPath = null;
                else
                {
                    if (String.IsNullOrEmpty(Path.GetDirectoryName(idxPath)))
                        idxPath = Path.Combine(Files.RootDir, idxPath);
                    if (!File.Exists(idxPath))
                        idxPath = null;
                }

                if (String.IsNullOrEmpty(MulPath))
                    MulPath = null;
                else
                {
                    if (String.IsNullOrEmpty(Path.GetDirectoryName(MulPath)))
                        MulPath = Path.Combine(Files.RootDir, MulPath);
                    if (!File.Exists(MulPath))
                        MulPath = null;
                }
            }

            if ((idxPath != null) && (MulPath != null))
            {
                using (FileStream index = new FileStream(idxPath, FileMode.Open, FileAccess.Read, FileShare.Read))
                {
                    Stream = new FileStream(MulPath, FileMode.Open, FileAccess.Read, FileShare.Read);
                    int count = (int) (index.Length / 12);
                    IdxLength = index.Length;
                    Index = new Entry3D[count];
                    GCHandle gc = GCHandle.Alloc(Index, GCHandleType.Pinned);
                    byte[] buffer = new byte[index.Length];
                    index.Read(buffer, 0, (int) index.Length);
                    Marshal.Copy(buffer, 0, gc.AddrOfPinnedObject(), (int) index.Length);
                    gc.Free();
                }
            }
            else
            {
                Stream = null;
                Index = new Entry3D[1];
                return;
            }

            Entry5D[] patches = Verdata.Patches;

            if (file > -1)
            {
                for (int i = 0; i < patches.Length; ++i)
                {
                    Entry5D patch = patches[i];

                    if (patch.file == file && patch.index >= 0 && patch.index < Index.Length)
                    {
                        Index[patch.index].lookup = patch.lookup;
                        Index[patch.index].length = patch.length | (1 << 31);
                        Index[patch.index].extra = patch.extra;
                    }
                }
            }
        }

        /// <summary>
        /// Method for calculating entry hash by it's name.
        /// Taken from Mythic.Package.dll
        /// </summary>
        /// <param name="s"></param>
        /// <returns></returns>
        public static ulong HashFileName(string s)
        {
            uint eax, ecx, edx, ebx, esi, edi;

            eax = ecx = edx = ebx = esi = edi = 0;
            ebx = edi = esi = (uint) s.Length + 0xDEADBEEF;

            int i = 0;

            for (i = 0; i + 12 < s.Length; i += 12)
            {
                edi = (uint) ((s[i + 7] << 24) | (s[i + 6] << 16) | (s[i + 5] << 8) | s[i + 4]) + edi;
                esi = (uint) ((s[i + 11] << 24) | (s[i + 10] << 16) | (s[i + 9] << 8) | s[i + 8]) + esi;
                edx = (uint) ((s[i + 3] << 24) | (s[i + 2] << 16) | (s[i + 1] << 8) | s[i]) - esi;

                edx = (edx + ebx) ^ (esi >> 28) ^ (esi << 4);
                esi += edi;
                edi = (edi - edx) ^ (edx >> 26) ^ (edx << 6);
                edx += esi;
                esi = (esi - edi) ^ (edi >> 24) ^ (edi << 8);
                edi += edx;
                ebx = (edx - esi) ^ (esi >> 16) ^ (esi << 16);
                esi += edi;
                edi = (edi - ebx) ^ (ebx >> 13) ^ (ebx << 19);
                ebx += esi;
                esi = (esi - edi) ^ (edi >> 28) ^ (edi << 4);
                edi += ebx;
            }

            if (s.Length - i > 0)
            {
                switch (s.Length - i)
                {
                    case 12:
                        esi += (uint) s[i + 11] << 24;
                        goto case 11;
                    case 11:
                        esi += (uint) s[i + 10] << 16;
                        goto case 10;
                    case 10:
                        esi += (uint) s[i + 9] << 8;
                        goto case 9;
                    case 9:
                        esi += (uint) s[i + 8];
                        goto case 8;
                    case 8:
                        edi += (uint) s[i + 7] << 24;
                        goto case 7;
                    case 7:
                        edi += (uint) s[i + 6] << 16;
                        goto case 6;
                    case 6:
                        edi += (uint) s[i + 5] << 8;
                        goto case 5;
                    case 5:
                        edi += (uint) s[i + 4];
                        goto case 4;
                    case 4:
                        ebx += (uint) s[i + 3] << 24;
                        goto case 3;
                    case 3:
                        ebx += (uint) s[i + 2] << 16;
                        goto case 2;
                    case 2:
                        ebx += (uint) s[i + 1] << 8;
                        goto case 1;
                    case 1:
                        ebx += (uint) s[i];
                        break;
                }

                esi = (esi ^ edi) - ((edi >> 18) ^ (edi << 14));
                ecx = (esi ^ ebx) - ((esi >> 21) ^ (esi << 11));
                edi = (edi ^ ecx) - ((ecx >> 7) ^ (ecx << 25));
                esi = (esi ^ edi) - ((edi >> 16) ^ (edi << 16));
                edx = (esi ^ ecx) - ((esi >> 28) ^ (esi << 4));
                edi = (edi ^ edx) - ((edx >> 18) ^ (edx << 14));
                eax = (esi ^ edi) - ((edi >> 8) ^ (edi << 24));

                return ((ulong) edi << 32) | eax;
            }

            return ((ulong) esi << 32) | eax;
        }
    }

    [StructLayout(System.Runtime.InteropServices.LayoutKind.Sequential, Pack = 1)]
    public struct Entry3D
    {
        public int lookup;
        public int length;
        public int extra;
    }
}

================================================
FILE: Razor/UltimaSDK/Files.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.Configuration;
using System.IO;
using Assistant;
using Microsoft.Win32;

namespace Ultima
{
    public sealed class Files
    {
        public delegate void FileSaveHandler();

        public static event FileSaveHandler FileSaveEvent;

        public static void FireFileSaveEvent()
        {
            if (FileSaveEvent != null)
                FileSaveEvent();
        }

        private static bool m_CacheData = true;
        private static bool m_UseHashFile = false;
        private static Dictionary<string, string> m_MulPath;
        private static string m_Directory;
        private static string m_RootDir;

        /// <summary>
        /// Should loaded Data be cached
        /// </summary>
        public static bool CacheData
        {
            get { return m_CacheData; }
            set { m_CacheData = value; }
        }

        /// <summary>
        /// Should a Hashfile be used to speed up loading
        /// </summary>
        public static bool UseHashFile
        {
            get { return m_UseHashFile; }
            set { m_UseHashFile = value; }
        }

        /// <summary>
        /// Contains the path infos
        /// </summary>
        public static Dictionary<string, string> MulPath
        {
            get { return m_MulPath; }
            set { m_MulPath = value; }
        }

        /// <summary>
        /// Gets a list of paths to the Client's data files.
        /// </summary>
        public static string Directory
        {
            get { return m_Directory; }
        }

        /// <summary>
        /// Contains the rootDir (so relative values are possible for <see cref="MulPath"/>
        /// </summary>
        public static string RootDir
        {
            get { return m_RootDir; }
            set { m_RootDir = value; }
        }

        private static string[] m_Files = new string[]
        {
            "anim.idx",
            "anim.mul",
            "anim2.idx",
            "anim2.mul",
            "anim3.idx",
            "anim3.mul",
            "anim4.idx",
            "anim4.mul",
            "anim5.idx",
            "anim5.mul",
            "animdata.mul",
            "art.mul",
            "artidx.mul",
            "artlegacymul.uop",
            "body.def",
            "bodyconv.def",
            "client.exe",
            "cliloc.custom1",
            "cliloc.custom2",
            "cliloc.deu",
            "cliloc.enu",
            "equipconv.def",
            "facet00.mul",
            "facet01.mul",
            "facet02.mul",
            "facet03.mul",
            "facet04.mul",
            "facet05.mul",
            "fonts.mul",
            "gump.def",
            "gumpart.mul",
            "gumpidx.mul",
            "gumpartlegacymul.uop",
            "hues.mul",
            "light.mul",
            "lightidx.mul",
            "map0.mul",
            "map1.mul",
            "map2.mul",
            "map3.mul",
            "map4.mul",
            "map5.mul",
            "map0legacymul.uop",
            "map1legacymul.uop",
            "map2legacymul.uop",
            "map3legacymul.uop",
            "map4legacymul.uop",
            "map5legacymul.uop",
            "mapdif0.mul",
            "mapdif1.mul",
            "mapdif2.mul",
            "mapdif3.mul",
            "mapdif4.mul",
            "mapdifl0.mul",
            "mapdifl1.mul",
            "mapdifl2.mul",
            "mapdifl3.mul",
            "mapdifl4.mul",
            "mobtypes.txt",
            "multi.idx",
            "multi.mul",
            "multimap.rle",
            "radarcol.mul",
            "skillgrp.mul",
            "skills.idx",
            "skills.mul",
            "sound.def",
            "sound.mul",
            "soundidx.mul",
            "soundlegacymul.uop",
            "speech.mul",
            "stadif0.mul",
            "stadif1.mul",
            "stadif2.mul",
            "stadif3.mul",
            "stadif4.mul",
            "stadifi0.mul",
            "stadifi1.mul",
            "stadifi2.mul",
            "stadifi3.mul",
            "stadifi4.mul",
            "stadifl0.mul",
            "stadifl1.mul",
            "stadifl2.mul",
            "stadifl3.mul",
            "stadifl4.mul",
            "staidx0.mul",
            "staidx1.mul",
            "staidx2.mul",
            "staidx3.mul",
            "staidx4.mul",
            "staidx5.mul",
            "statics0.mul",
            "statics1.mul",
            "statics2.mul",
            "statics3.mul",
            "statics4.mul",
            "statics5.mul",
            "texidx.mul",
            "texmaps.mul",
            "tiledata.mul",
            "unifont.mul",
            "unifont1.mul",
            "unifont2.mul",
            "unifont3.mul",
            "unifont4.mul",
            "unifont5.mul",
            "unifont6.mul",
            "unifont7.mul",
            "unifont8.mul",
            "unifont9.mul",
            "unifont10.mul",
            "unifont11.mul",
            "unifont12.mul",
            "uotd.exe",
            "verdata.mul"
        };


        /// <summary>
        /// ReReads Registry Client dir
        /// </summary>
        public static void ReLoadDirectory()
        {
            m_Directory = LoadDirectory();
        }

        /// <summary>
        /// Fills <see cref="MulPath"/> with <see cref="Files.Directory"/>
        /// </summary>
        public static void LoadMulPath()
        {
            m_MulPath = new Dictionary<string, string>();
            m_RootDir = Directory;
            if (m_RootDir == null)
                m_RootDir = "";
            foreach (string file in m_Files)
            {
                string filePath = Path.Combine(m_RootDir, file);
                if (File.Exists(filePath))
                    m_MulPath[file] = file;
                else if (File.Exists(Path.Combine(m_RootDir, char.ToUpper(file[0]) + file.Substring(1))))
                    m_MulPath[file] = Path.Combine(m_RootDir, char.ToUpper(file[0]) + file.Substring(1));
                else
                    m_MulPath[file] = "";
            }
        }

        /// <summary>
        /// ReSets <see cref="MulPath"/> with given path
        /// </summary>
        /// <param name="path"></param>
        public static void SetMulPath(string path)
        {
            m_RootDir = path;
            foreach (string file in m_Files)
            {
                string filePath;
                if (!String.IsNullOrEmpty(m_MulPath[file])) //file was set
                {
                    if (String.IsNullOrEmpty(Path.GetDirectoryName(m_MulPath[file]))) //and relative
                    {
                        filePath = Path.Combine(m_RootDir, m_MulPath[file]);
                        if (File.Exists(filePath)) // exists in new Root?
                        {
                            m_MulPath[file] = filePath;
                            continue;
                        }
                    }
                    else // absolut dir ignore
                        continue;
                }

                filePath = Path.Combine(m_RootDir, file); //file was not set, or relative and non existent
                if (File.Exists(filePath))
                    m_MulPath[file] = file;
                else
                    m_MulPath[file] = "";
            }
        }

        /// <summary>
        /// Sets <see cref="MulPath"/> key to path
        /// </summary>
        /// <param name="path"></param>
        /// <param name="key"></param>
        public static void SetMulPath(string path, string key)
        {
            MulPath[key] = path;
        }

        /// <summary>
        /// Looks up a given <paramref name="file" /> in <see cref="Files.MulPath"/>
        /// </summary>
        /// <returns>The absolute path to <paramref name="file" /> -or- <c>null</c> if <paramref name="file" /> was not found.</returns>
        public static string GetFilePath(string file)
        {
            if (MulPath.Count > 0)
            {
                string path = "";
                if (MulPath.ContainsKey(file.ToLower()))
                    path = MulPath[file.ToLower()];
                if (String.IsNullOrEmpty(path))
                    return null;
                if (String.IsNullOrEmpty(Path.GetDirectoryName(path)))
                    path = Path.Combine(m_RootDir, path);
                if (File.Exists(path))
                    return path;
            }

            return null;
        }

        internal static string GetFilePath(string format, params object[] args)
        {
            return GetFilePath(String.Format(format, args));
        }

        static readonly string[] knownRegkeys = new string[]
        {
            @"Origin Worlds Online\Ultima Online\1.0",
            @"Origin Worlds Online\Ultima Online Third Dawn\1.0",
            @"EA GAMES\Ultima Online Samurai Empire",
            @"EA GAMES\Ultima Online Samurai Empire\1.0",
            @"EA GAMES\Ultima Online Samurai Empire\1.00.0000",
            @"EA GAMES\Ultima Online: Samurai Empire\1.0",
            @"EA GAMES\Ultima Online: Samurai Empire\1.00.0000",
            @"EA Games\Ultima Online: Mondain's Legacy",
            @"EA Games\Ultima Online: Mondain's Legacy\1.0",
            @"EA Games\Ultima Online: Mondain's Legacy\1.00.0000",
            @"Origin Worlds Online\Ultima Online Samurai Empire BETA\2d\1.0",
            @"Origin Worlds Online\Ultima Online Samurai Empire BETA\3d\1.0",
            @"Origin Worlds Online\Ultima Online Samurai Empire\2d\1.0",
            @"Origin Worlds Online\Ultima Online Samurai Empire\3d\1.0",
            @"Origin Worlds Online\Ultima Online\KR Legacy Beta",
            @"Electronic Arts\EA Games\Ultima Online Stygian Abyss Classic",
            @"Electronic Arts\EA Games\Ultima Online Classic",
        };

        static readonly string[] knownRegPathkeys = new string[]
        {
            "ExePath",
            "Install Dir",
            "InstallDir"
        };

        private static string LoadDirectory()
        {
            string dir = Config.GetAppSetting<string>("UODataDir");

            // If they're using the ClassicUO client, pull the UO data dir from the plugin
            if (!Assistant.Client.IsOSI)
            {
                dir = Assistant.Client.Instance.GetUoFilePath();
            }


            if (string.IsNullOrEmpty(dir) || !System.IO.Directory.Exists(dir)
            ) // If the path in the config looks bad, try the registry as a fallback
            {
                for (int i = knownRegkeys.Length - 1; i >= 0; i--)
                {
                    string exePath;

                    if (Environment.Is64BitOperatingSystem)
                        exePath = GetPath($@"Wow6432Node\{knownRegkeys[i]}");
                    else
                        exePath = GetPath(knownRegkeys[i]);

                    if (exePath != null)
                    {
                        dir = exePath;
                        break;
                    }
                }
            }

            return dir;
        }

        private static string GetPath(string regkey)
        {
            try
            {
                RegistryKey key = Registry.LocalMachine.OpenSubKey($@"SOFTWARE\{regkey}");

                if (key == null)
                {
                    key = Registry.CurrentUser.OpenSubKey($@"SOFTWARE\{regkey}");

                    if (key == null)
                        return null;
                }

                string path = null;
                foreach (string pathkey in knownRegPathkeys)
                {
                    path = key.GetValue(pathkey) as string;

                    if ((path == null) || (path.Length <= 0))
                        continue;

                    if (pathkey == "InstallDir")
                        path = path + @"\";

                    if (!System.IO.Directory.Exists(path) && !File.Exists(path))
                        continue;

                    break;
                }

                if (path == null)
                    return null;

                if (!System.IO.Directory.Exists(path))
                    path = Path.GetDirectoryName(path);

                if ((path == null) || (!System.IO.Directory.Exists(path)))
                    return null;

                return path;
            }
            catch
            {
                return null;
            }
        }

        /// <summary>
        /// Compares given MD5 hash with hash of given file
        /// </summary>
        /// <param name="file"></param>
        /// <param name="hash"></param>
        /// <returns></returns>
        public static bool CompareMD5(string file, string hash)
        {
            if (file == null)
                return false;
            System.IO.FileStream FileCheck = System.IO.File.OpenRead(file);
            using (System.Security.Cryptography.MD5 md5 = new System.Security.Cryptography.MD5CryptoServiceProvider())
            {
                byte[] md5Hash = md5.ComputeHash(FileCheck);
                FileCheck.Close();
                string md5string = BitConverter.ToString(md5Hash).Replace("-", "").ToLower();
                if (md5string == hash)
                    return true;
                else
                    return false;
            }
        }

        /// <summary>
        /// Returns MD5 hash from given file
        /// </summary>
        /// <param name="file"></param>
        /// <returns></returns>
        public static byte[] GetMD5(string file)
        {
            if (file == null)
                return null;
            System.IO.FileStream FileCheck = System.IO.File.OpenRead(file);
            using (System.Security.Cryptography.MD5 md5 = new System.Security.Cryptography.MD5CryptoServiceProvider())
            {
                byte[] md5Hash = md5.ComputeHash(FileCheck);
                FileCheck.Close();
                return md5Hash;
            }
        }

        /// <summary>
        /// Compares MD5 hash from given mul file with hash in responsible hash-file
        /// </summary>
        /// <param name="what"></param>
        /// <returns></returns>
        public static bool CompareHashFile(string what, string path)
        {
            string FileName = Path.Combine(path, $"UOFiddler{what}.hash");
            if (File.Exists(FileName))
            {
                try
                {
                    using (BinaryReader bin =
                        new BinaryReader(new FileStream(FileName, FileMode.Open, FileAccess.Read, FileShare.Read)))
                    {
                        int length = bin.ReadInt32();
                        byte[] buffer = new byte[length];
                        bin.Read(buffer, 0, length);
                        string hashold = BitConverter.ToString(buffer).Replace("-", "").ToLower();
                        return Files.CompareMD5(Files.GetFilePath($"{what}.mul"), hashold);
                    }
                }
                catch
                {
                    return false;
                }
            }

            return false;
        }

        /// <summary>
        /// Checks if map1.mul exists and sets <see cref="Ultima.Map"/>
        /// </summary>
        public static void CheckForNewMapSize()
        {
            if (Files.GetFilePath("map1.mul") != null)
            {
                if (Ultima.Map.Trammel.Width == 7168)
                    Ultima.Map.Trammel = new Ultima.Map(1, 1, 7168, 4096);
                else
                    Ultima.Map.Trammel = new Ultima.Map(1, 1, 6144, 4096);
            }
            else
            {
                if (Ultima.Map.Trammel.Width == 7168)
                    Ultima.Map.Trammel = new Ultima.Map(0, 1, 7168, 4096);
                else
                    Ultima.Map.Trammel = new Ultima.Map(0, 1, 6144, 4096);
            }
        }
    }
}

================================================
FILE: Razor/UltimaSDK/Gumps.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;

namespace Ultima
{
    public sealed class Gumps
    {
        private static FileIndex m_FileIndex = new FileIndex("Gumpidx.mul", "Gumpart.mul", "gumpartLegacyMUL.uop",
            0xFFFF, 12, ".tga", -1, true);

        private static Bitmap[] m_Cache;
        private static bool[] m_Removed;
        private static Hashtable m_patched = new Hashtable();

        private static byte[] m_PixelBuffer;
        private static byte[] m_StreamBuffer;
        private static byte[] m_ColorTable;

        static Gumps()
        {
            if (m_FileIndex != null)
            {
                m_Cache = new Bitmap[m_FileIndex.Index.Length];
                m_Removed = new bool[m_FileIndex.Index.Length];
            }
            else
            {
                m_Cache = new Bitmap[0xFFFF];
                m_Removed = new bool[0xFFFF];
            }
        }

        /// <summary>
        /// ReReads gumpart
        /// </summary>
        public static void Reload()
        {
            try
            {
                m_FileIndex = new FileIndex("Gumpidx.mul", "Gumpart.mul", "gumpartLegacyMUL.uop", 12, -1, ".tga", -1,
                    true);
                m_Cache = new Bitmap[m_FileIndex.Index.Length];
                m_Removed = new bool[m_FileIndex.Index.Length];
            }
            catch
            {
                m_FileIndex = null;
                m_Cache = new Bitmap[0xFFFF];
                m_Removed = new bool[0xFFFF];
            }

            m_PixelBuffer = null;
            m_StreamBuffer = null;
            m_ColorTable = null;
            m_patched.Clear();
        }

        public static int GetCount()
        {
            return m_Cache.Length;
        }

        /// <summary>
        /// Replaces Gump <see cref="m_Cache"/>
        /// </summary>
        /// <param name="index"></param>
        /// <param name="bmp"></param>
        public static void ReplaceGump(int index, Bitmap bmp)
        {
            m_Cache[index] = bmp;
            m_Removed[index] = false;
            if (m_patched.Contains(index))
                m_patched.Remove(index);
        }

        /// <summary>
        /// Removes Gumpindex <see cref="m_Removed"/>
        /// </summary>
        /// <param name="index"></param>
        public static void RemoveGump(int index)
        {
            m_Removed[index] = true;
        }

        /// <summary>
        /// Tests if index is definied
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public static bool IsValidIndex(int index)
        {
            if (m_FileIndex == null)
                return false;
            if (index > m_Cache.Length - 1)
                return false;
            if (m_Removed[index])
                return false;
            if (m_Cache[index] != null)
                return true;
            int length, extra;
            bool patched;

            if (!m_FileIndex.Valid(index, out length, out extra, out patched))
                return false;
            if (extra == -1)
                return false;
            int width = (extra >> 16) & 0xFFFF;
            int height = extra & 0xFFFF;

            if (width <= 0 || height <= 0)
                return false;

            return true;
        }

        public static byte[] GetRawGump(int index, out int width, out int height)
        {
            width = -1;
            height = -1;
            int length, extra;
            bool patched;
            Stream stream = m_FileIndex.Seek(index, out length, out extra, out patched);
            if (stream == null)
                return null;
            if (extra == -1)
                return null;
            width = (extra >> 16) & 0xFFFF;
            height = extra & 0xFFFF;
            if (width <= 0 || height <= 0)
                return null;
            byte[] buffer = new byte[length];
            stream.Read(buffer, 0, length);
            stream.Close();
            return buffer;
        }

        /// <summary>
        /// Returns Bitmap of index and applies Hue
        /// </summary>
        /// <param name="index"></param>
        /// <param name="hue"></param>
        /// <param name="onlyHueGrayPixels"></param>
        /// <returns></returns>
        public unsafe static Bitmap GetGump(int index, Hue hue, bool onlyHueGrayPixels, out bool patched)
        {
            int length, extra;
            Stream stream = m_FileIndex.Seek(index, out length, out extra, out patched);

            if (stream == null)
                return null;
            if (extra == -1)
            {
                stream.Close();
                return null;
            }

            int width = (extra >> 16) & 0xFFFF;
            int height = extra & 0xFFFF;

            if (width <= 0 || height <= 0)
            {
                stream.Close();
                return null;
            }

            int bytesPerLine = width << 1;
            int bytesPerStride = (bytesPerLine + 3) & ~3;
            int bytesForImage = height * bytesPerStride;

            int pixelsPerStride = (width + 1) & ~1;
            int pixelsPerStrideDelta = pixelsPerStride - width;

            byte[] pixelBuffer = m_PixelBuffer;

            if (pixelBuffer == null || pixelBuffer.Length < bytesForImage)
                m_PixelBuffer = pixelBuffer = new byte[(bytesForImage + 2047) & ~2047];

            byte[] streamBuffer = m_StreamBuffer;

            if (streamBuffer == null || streamBuffer.Length < length)
                m_StreamBuffer = streamBuffer = new byte[(length + 2047) & ~2047];

            byte[] colorTable = m_ColorTable;

            if (colorTable == null)
                m_ColorTable = colorTable = new byte[128];

            stream.Read(streamBuffer, 0, length);

            fixed (short* psHueColors = hue.Colors)
            {
                fixed (byte* pbStream = streamBuffer)
                {
                    fixed (byte* pbPixels = pixelBuffer)
                    {
                        fixed (byte* pbColorTable = colorTable)
                        {
                            ushort* pHueColors = (ushort*) psHueColors;
                            ushort* pHueColorsEnd = pHueColors + 32;

                            ushort* pColorTable = (ushort*) pbColorTable;

                            ushort* pColorTableOpaque = pColorTable;

                            while (pHueColors < pHueColorsEnd)
                                *pColorTableOpaque++ = *pHueColors++;

                            ushort* pPixelDataStart = (ushort*) pbPixels;

                            int* pLookup = (int*) pbStream;
                            int* pLookupEnd = pLookup + height;
                            int* pPixelRleStart = pLookup;
                            int* pPixelRle;

                            ushort* pPixel = pPixelDataStart;
                            ushort* pRleEnd = pPixel;
                            ushort* pPixelEnd = pPixel + width;

                            ushort color, count;

                            if (onlyHueGrayPixels)
                            {
                                while (pLookup < pLookupEnd)
                                {
                                    pPixelRle = pPixelRleStart + *pLookup++;
                                    pRleEnd = pPixel;

                                    while (pPixel < pPixelEnd)
                                    {
                                        color = *(ushort*) pPixelRle;
                                        count = *(1 + (ushort*) pPixelRle);
                                        ++pPixelRle;

                                        pRleEnd += count;

                                        if (color != 0 && (color & 0x1F) == ((color >> 5) & 0x1F) &&
                                            (color & 0x1F) == ((color >> 10) & 0x1F))
                                            color = pColorTable[color >> 10];
                                        else if (color != 0)
                                            color ^= 0x8000;

                                        while (pPixel < pRleEnd)
                                            *pPixel++ = color;
                                    }

                                    pPixel += pixelsPerStrideDelta;
                                    pPixelEnd += pixelsPerStride;
                                }
                            }
                            else
                            {
                                while (pLookup < pLookupEnd)
                                {
                                    pPixelRle = pPixelRleStart + *pLookup++;
                                    pRleEnd = pPixel;

                                    while (pPixel < pPixelEnd)
                                    {
                                        color = *(ushort*) pPixelRle;
                                        count = *(1 + (ushort*) pPixelRle);
                                        ++pPixelRle;

                                        pRleEnd += count;

                                        if (color != 0)
                                            color = pColorTable[color >> 10];

                                        while (pPixel < pRleEnd)
                                            *pPixel++ = color;
                                    }

                                    pPixel += pixelsPerStrideDelta;
                                    pPixelEnd += pixelsPerStride;
                                }
                            }

                            stream.Close();
                            return new Bitmap(width, height, bytesPerStride, PixelFormat.Format16bppArgb1555,
                                (IntPtr) pPixelDataStart);
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Returns Bitmap of index
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public unsafe static Bitmap GetGump(int index)
        {
            bool patched;
            return GetGump(index, out patched);
        }

        /// <summary>
        /// Returns Bitmap of index and if verdata patched
        /// </summary>
        /// <param name="index"></param>
        /// <param name="patched"></param>
        /// <returns></returns>
        public unsafe static Bitmap GetGump(int index, out bool patched)
        {
            if (m_patched.Contains(index))
                patched = (bool) m_patched[index];
            else
                patched = false;
            if (index > m_Cache.Length - 1)
                return null;
            if (m_Removed[index])
                return null;
            if (m_Cache[index] != null)
                return m_Cache[index];
            int length, extra;
            Stream stream = m_FileIndex.Seek(index, out length, out extra, out patched);
            if (stream == null)
                return null;
            if (extra == -1)
            {
                stream.Close();
                return null;
            }

            if (patched)
                m_patched[index] = true;

            int width = (extra >> 16) & 0xFFFF;
            int height = extra & 0xFFFF;

            if (width <= 0 || height <= 0)
                return null;
            Bitmap bmp = new Bitmap(width, height, PixelFormat.Format16bppArgb1555);
            BitmapData bd = bmp.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.WriteOnly,
                PixelFormat.Format16bppArgb1555);

            if (m_StreamBuffer == null || m_StreamBuffer.Length < length)
                m_StreamBuffer = new byte[length];
            stream.Read(m_StreamBuffer, 0, length);

            fixed (byte* data = m_StreamBuffer)
            {
                int* lookup = (int*) data;
                ushort* dat = (ushort*) data;

                ushort* line = (ushort*) bd.Scan0;
                int delta = bd.Stride >> 1;
                int count = 0;
                for (int y = 0; y < height; ++y, line += delta)
                {
                    count = (*lookup++ * 2);

                    ushort* cur = line;
                    ushort* end = line + bd.Width;

                    while (cur < end)
                    {
                        ushort color = dat[count++];
                        ushort* next = cur + dat[count++];

                        if (color == 0)
                            cur = next;
                        else
                        {
                            color ^= 0x8000;
                            while (cur < next)
                                *cur++ = color;
                        }
                    }
                }
            }

            bmp.UnlockBits(bd);
            if (Files.CacheData)
                return m_Cache[index] = bmp;
            else
                return bmp;
        }

        public static unsafe void Save(string path)
        {
            string idx = Path.Combine(path, "Gumpidx.mul");
            string mul = Path.Combine(path, "Gumpart.mul");
            using (FileStream fsidx = new FileStream(idx, FileMode.Create, FileAccess.Write, FileShare.Write),
                fsmul = new FileStream(mul, FileMode.Create, FileAccess.Write, FileShare.Write))
            {
                using (BinaryWriter binidx = new BinaryWriter(fsidx),
                    binmul = new BinaryWriter(fsmul))
                {
                    for (int index = 0; index < m_Cache.Length; index++)
                    {
                        if (m_Cache[index] == null)
                            m_Cache[index] = GetGump(index);

                        Bitmap bmp = m_Cache[index];
                        if ((bmp == null) || (m_Removed[index]))
                        {
                            binidx.Write((int) -1); // lookup
                            binidx.Write((int) -1); // length
                            binidx.Write((int) -1); // extra
                        }
                        else
                        {
                            BitmapData bd = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height),
                                ImageLockMode.ReadOnly, PixelFormat.Format16bppArgb1555);
                            ushort* line = (ushort*) bd.Scan0;
                            int delta = bd.Stride >> 1;

                            binidx.Write((int) fsmul.Position); //lookup
                            int length = (int) fsmul.Position;
                            int fill = 0;
                            for (int i = 0; i < bmp.Height; ++i)
                            {
                                binmul.Write(fill);
                            }

                            for (int Y = 0; Y < bmp.Height; ++Y, line += delta)
                            {
                                ushort* cur = line;

                                int X = 0;
                                int current = (int) fsmul.Position;
                                fsmul.Seek(length + Y * 4, SeekOrigin.Begin);
                                int offset = (current - length) / 4;
                                binmul.Write(offset);
                                fsmul.Seek(length + offset * 4, SeekOrigin.Begin);

                                while (X < bd.Width)
                                {
                                    int Run = 1;
                                    ushort c = cur[X];
                                    while ((X + Run) < bd.Width)
                                    {
                                        if (c != cur[X + Run])
                                            break;
                                        ++Run;
                                    }

                                    if (c == 0)
                                        binmul.Write(c);
                                    else
                                        binmul.Write((ushort) (c ^ 0x8000));
                                    binmul.Write((short) Run);
                                    X += Run;
                                }
                            }

                            length = (int) fsmul.Position - length;
                            binidx.Write(length);
                            binidx.Write((int) (bmp.Width << 16) + bmp.Height);
                            bmp.UnlockBits(bd);
                        }
                    }
                }
            }
        }
    }
}

================================================
FILE: Razor/UltimaSDK/Hues.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Runtime.InteropServices;
using System.Text;

namespace Ultima
{
    public sealed class Hues
    {
        private static int[] m_Header;

        public static Hue[] List { get; private set; }

        static Hues()
        {
            Initialize();
        }

        /// <summary>
        /// Reads hues.mul and fills <see cref="List"/>
        /// </summary>
        public static void Initialize()
        {
            string path = Files.GetFilePath("hues.mul");
            int index = 0;

            List = new Hue[3000];

            if (path != null)
            {
                using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read))
                {
                    int blockCount = (int) fs.Length / 708;

                    if (blockCount > 375)
                        blockCount = 375;
                    m_Header = new int[blockCount];
                    unsafe
                    {
                        int structsize = Marshal.SizeOf(typeof(HueDataMul));
                        byte[] buffer = new byte[blockCount * (4 + 8 * structsize)];
                        GCHandle gc = GCHandle.Alloc(buffer, GCHandleType.Pinned);
                        try
                        {
                            fs.Read(buffer, 0, buffer.Length);
                            long currpos = 0;

                            for (int i = 0; i < blockCount; ++i)
                            {
                                IntPtr ptrheader = new IntPtr((long) gc.AddrOfPinnedObject() + currpos);
                                currpos += 4;
                                m_Header[i] = (int) Marshal.PtrToStructure(ptrheader, typeof(int));

                                for (int j = 0; j < 8; ++j, ++index)
                                {
                                    IntPtr ptr = new IntPtr((long) gc.AddrOfPinnedObject() + currpos);
                                    currpos += structsize;
                                    HueDataMul cur = (HueDataMul) Marshal.PtrToStructure(ptr, typeof(HueDataMul));
                                    List[index] = new Hue(index, cur);
                                }
                            }
                        }
                        finally
                        {
                            gc.Free();
                        }
                    }
                }
            }

            for (; index < List.Length; ++index)
                List[index] = new Hue(index);
        }

        public static void Save(string path)
        {
            string mul = Path.Combine(path, "hues.mul");
            using (FileStream fsmul = new FileStream(mul, FileMode.Create, FileAccess.Write, FileShare.Write))
            {
                using (BinaryWriter binmul = new BinaryWriter(fsmul))
                {
                    int index = 0;
                    for (int i = 0; i < m_Header.Length; ++i)
                    {
                        binmul.Write(m_Header[i]);
                        for (int j = 0; j < 8; ++j, ++index)
                        {
                            for (int c = 0; c < 32; ++c)
                                binmul.Write((short) (List[index].Colors[c] ^ 0x8000));

                            binmul.Write((short) (List[index].TableStart ^ 0x8000));
                            binmul.Write((short) (List[index].TableEnd ^ 0x8000));
                            byte[] b = new byte[20];
                            if (List[index].Name != null)
                            {
                                byte[] bb = Encoding.Default.GetBytes(List[index].Name);
                                if (bb.Length > 20)
                                    Array.Resize(ref bb, 20);
                                bb.CopyTo(b, 0);
                            }

                            binmul.Write(b);
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Returns <see cref="Hue"/>
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public static Hue GetHue(int index)
        {
            index &= 0x3FFF;

            if (index >= 0 && index < 3000)
                return List[index];

            return List[0];
        }

        /// <summary>
        /// Converts RGB value to Huecolor
        /// </summary>
        /// <param name="c"></param>
        /// <returns></returns>
        public static short ColorToHue(Color c)
        {
            ushort origred = c.R;
            ushort origgreen = c.G;
            ushort origblue = c.B;
            const double scale = 31.0 / 255;
            ushort newred = (ushort) (origred * scale);
            if (newred == 0 && origred != 0)
                newred = 1;
            ushort newgreen = (ushort) (origgreen * scale);
            if (newgreen == 0 && origgreen != 0)
                newgreen = 1;
            ushort newblue = (ushort) (origblue * scale);
            if (newblue == 0 && origblue != 0)
                newblue = 1;

            return (short) ((newred << 10) | (newgreen << 5) | (newblue));
        }

        /// <summary>
        /// Converts Huecolor to RGBColor
        /// </summary>
        /// <param name="hue"></param>
        /// <returns></returns>
        public static Color HueToColor(short hue)
        {
            const int scale = 255 / 31;
            return Color.FromArgb(
                (((hue & 0x7c00) >> 10) * scale),
                (((hue & 0x3e0) >> 5) * scale),
                ((hue & 0x1f) * scale)
            );
        }

        public static int HueToColorR(short hue)
        {
            return (((hue & 0x7c00) >> 10) * (255 / 31));
        }

        public static int HueToColorG(short hue)
        {
            return (((hue & 0x3e0) >> 5) * (255 / 31));
        }

        public static int HueToColorB(short hue)
        {
            return ((hue & 0x1f) * (255 / 31));
        }

        public unsafe static void ApplyTo(Bitmap bmp, short[] Colors, bool onlyHueGrayPixels)
        {
            BitmapData bd = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadWrite,
                PixelFormat.Format16bppArgb1555);

            int stride = bd.Stride >> 1;
            int width = bd.Width;
            int height = bd.Height;
            int delta = stride - width;

            ushort* pBuffer = (ushort*) bd.Scan0;
            ushort* pLineEnd = pBuffer + width;
            ushort* pImageEnd = pBuffer + (stride * height);

            if (onlyHueGrayPixels)
            {
                int c;
                int r;
                int g;
                int b;

                while (pBuffer < pImageEnd)
                {
                    while (pBuffer < pLineEnd)
                    {
                        c = *pBuffer;
                        if (c != 0)
                        {
                            r = (c >> 10) & 0x1F;
                            g = (c >> 5) & 0x1F;
                            b = c & 0x1F;
                            if (r == g && r == b)
                                *pBuffer = (ushort) Colors[(c >> 10) & 0x1F];
                        }

                        ++pBuffer;
                    }

                    pBuffer += delta;
                    pLineEnd += stride;
                }
            }
            else
            {
                while (pBuffer < pImageEnd)
                {
                    while (pBuffer < pLineEnd)
                    {
                        if (*pBuffer != 0)
                            *pBuffer = (ushort) Colors[(*pBuffer >> 10) & 0x1F];
                        ++pBuffer;
                    }

                    pBuffer += delta;
                    pLineEnd += stride;
                }
            }

            bmp.UnlockBits(bd);
        }
    }

    public sealed class Hue
    {
        public int Index { get; private set; }
        public short[] Colors { get; set; }
        public string Name { get; set; }
        public short TableStart { get; set; }
        public short TableEnd { get; set; }

        public Hue(int index)
        {
            Name = "Null";
            Index = index;
            Colors = new short[32];
            TableStart = 0;
            TableEnd = 0;
        }

        public Color GetColor(int index)
        {
            return Hues.HueToColor(Colors[index]);
        }

        private static byte[] m_StringBuffer = new byte[20];
        private static byte[] m_Buffer = new byte[88];

        public Hue(int index, BinaryReader bin)
        {
            Index = index;
            Colors = new short[32];

            m_Buffer = bin.ReadBytes(88);
            unsafe
            {
                fixed (byte* buffer = m_Buffer)
                {
                    ushort* buf = (ushort*) buffer;
                    for (int i = 0; i < 32; ++i)
                        Colors[i] = (short) (*buf++ | 0x8000);
                    TableStart = (short) (*buf++ | 0x8000);
                    TableEnd = (short) (*buf++ | 0x8000);
                    byte* sbuf = (byte*) buf;
                    int count;
                    for (count = 0; count < 20 && *sbuf != 0; ++count)
                        m_StringBuffer[count] = *sbuf++;
                    Name = Encoding.Default.GetString(m_StringBuffer, 0, count);
                    Name = Name.Replace("\n", " ");
                }
            }
        }

        public Hue(int index, HueDataMul mulstruct)
        {
            Index = index;
            Colors = new short[32];
            unsafe
            {
                for (int i = 0; i < 32; ++i)
                    Colors[i] = (short) (mulstruct.colors[i] | 0x8000);
                TableStart = (short) (mulstruct.tablestart | 0x8000);
                TableEnd = (short) (mulstruct.tableend | 0x8000);
                Name = NativeMethods.ReadNameString(mulstruct.name, 20);
                Name = Name.Replace("\n", " ");
            }
        }

        /// <summary>
        /// Applies Hue to Bitmap
        /// </summary>
        /// <param name="bmp"></param>
        /// <param name="onlyHueGrayPixels"></param>
        public unsafe void ApplyTo(Bitmap bmp, bool onlyHueGrayPixels)
        {
            BitmapData bd = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadWrite,
                PixelFormat.Format16bppArgb1555);

            int stride = bd.Stride >> 1;
            int width = bd.Width;
            int height = bd.Height;
            int delta = stride - width;

            ushort* pBuffer = (ushort*) bd.Scan0;
            ushort* pLineEnd = pBuffer + width;
            ushort* pImageEnd = pBuffer + (stride * height);

            if (onlyHueGrayPixels)
            {
                int c;
                int r;
                int g;
                int b;

                while (pBuffer < pImageEnd)
                {
                    while (pBuffer < pLineEnd)
                    {
                        c = *pBuffer;
                        if (c != 0)
                        {
                            r = (c >> 10) & 0x1F;
                            g = (c >> 5) & 0x1F;
                            b = c & 0x1F;
                            if (r == g && r == b)
                                *pBuffer = (ushort) Colors[(c >> 10) & 0x1F];
                        }

                        ++pBuffer;
                    }

                    pBuffer += delta;
                    pLineEnd += stride;
                }
            }
            else
            {
                while (pBuffer < pImageEnd)
                {
                    while (pBuffer < pLineEnd)
                    {
                        if (*pBuffer != 0)
                            *pBuffer = (ushort) Colors[(*pBuffer >> 10) & 0x1F];
                        ++pBuffer;
                    }

                    pBuffer += delta;
                    pLineEnd += stride;
                }
            }

            bmp.UnlockBits(bd);
        }

        public void Export(string FileName)
        {
            using (StreamWriter Tex = new StreamWriter(new FileStream(FileName, FileMode.Create, FileAccess.ReadWrite),
                System.Text.Encoding.GetEncoding(1252)))
            {
                Tex.WriteLine(Name);
                Tex.WriteLine(((short) (TableStart ^ 0x8000)).ToString());
                Tex.WriteLine(((short) (TableEnd ^ 0x8000)).ToString());
                for (int i = 0; i < Colors.Length; ++i)
                {
                    Tex.WriteLine(((short) (Colors[i] ^ 0x8000)).ToString());
                }
            }
        }

        public void Import(string FileName)
        {
            if (!File.Exists(FileName))
                return;
            using (StreamReader sr = new StreamReader(FileName))
            {
                string line;
                int i = -3;
                while ((line = sr.ReadLine()) != null)
                {
                    line = line.Trim();
                    try
                    {
                        if (i >= Colors.Length)
                            break;
                        if (i == -3)
                            Name = line;
                        else if (i == -2)
                            TableStart = (short) (ushort.Parse(line) | 0x8000);
                        else if (i == -1)
                            TableEnd = (short) (ushort.Parse(line) | 0x8000);
                        else
                        {
                            Colors[i] = (short) (ushort.Parse(line) | 0x8000);
                        }

                        ++i;
                    }
                    catch
                    {
                    }
                }
            }
        }
    }

    [StructLayout(System.Runtime.InteropServices.LayoutKind.Sequential, Pack = 1)]
    public unsafe struct HueDataMul
    {
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
        public ushort[] colors;

        public ushort tablestart;
        public ushort tableend;

        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 20)]
        public byte[] name;
    }
}

================================================
FILE: Razor/UltimaSDK/Light.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System.Drawing;
using System.Drawing.Imaging;
using System.IO;

namespace Ultima
{
    public sealed class Light
    {
        private static FileIndex m_FileIndex = new FileIndex("lightidx.mul", "light.mul", 100, -1);
        private static Bitmap[] m_Cache = new Bitmap[100];
        private static bool[] m_Removed = new bool[100];
        private static byte[] m_StreamBuffer;

        /// <summary>
        /// ReReads light.mul
        /// </summary>
        public static void Reload()
        {
            m_FileIndex = new FileIndex("lightidx.mul", "light.mul", 100, -1);
            m_Cache = new Bitmap[100];
            m_Removed = new bool[100];
        }

        /// <summary>
        /// Gets count of definied lights
        /// </summary>
        /// <returns></returns>
        public static int GetCount()
        {
            string idxPath = Files.GetFilePath("lightidx.mul");
            if (idxPath == null)
                return 0;
            using (FileStream index = new FileStream(idxPath, FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                return (int) (index.Length / 12);
            }
        }

        /// <summary>
        /// Tests if given index is valid
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public static bool TestLight(int index)
        {
            if (m_Removed[index])
                return false;
            if (m_Cache[index] != null)
                return true;

            int length, extra;
            bool patched;

            Stream stream = m_FileIndex.Seek(index, out length, out extra, out patched);

            if (stream == null)
                return false;
            stream.Close();
            int width = (extra & 0xFFFF);
            int height = ((extra >> 16) & 0xFFFF);
            if ((width > 0) && (height > 0))
                return true;

            return false;
        }

        /// <summary>
        /// Removes Light <see cref="m_Removed"/>
        /// </summary>
        /// <param name="index"></param>
        public static void Remove(int index)
        {
            m_Removed[index] = true;
        }

        /// <summary>
        /// Replaces Light
        /// </summary>
        /// <param name="index"></param>
        /// <param name="bmp"></param>
        public static void Replace(int index, Bitmap bmp)
        {
            m_Cache[index] = bmp;
            m_Removed[index] = false;
        }

        public unsafe static byte[] GetRawLight(int index, out int width, out int height)
        {
            width = 0;
            height = 0;
            if (m_Removed[index])
                return null;
            int length, extra;
            bool patched;

            Stream stream = m_FileIndex.Seek(index, out length, out extra, out patched);

            if (stream == null)
                return null;

            width = (extra & 0xFFFF);
            height = ((extra >> 16) & 0xFFFF);
            byte[] buffer = new byte[length];
            stream.Read(buffer, 0, length);
            stream.Close();
            return buffer;
        }

        /// <summary>
        /// Returns Bitmap of given index
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public unsafe static Bitmap GetLight(int index)
        {
            if (m_Removed[index])
                return null;
            if (m_Cache[index] != null)
                return m_Cache[index];

            int length, extra;
            bool patched;

            Stream stream = m_FileIndex.Seek(index, out length, out extra, out patched);

            if (stream == null)
                return null;

            int width = (extra & 0xFFFF);
            int height = ((extra >> 16) & 0xFFFF);

            if (m_StreamBuffer == null || m_StreamBuffer.Length < length)
                m_StreamBuffer = new byte[length];
            stream.Read(m_StreamBuffer, 0, length);

            Bitmap bmp = new Bitmap(width, height, PixelFormat.Format16bppArgb1555);
            BitmapData bd = bmp.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.WriteOnly,
                PixelFormat.Format16bppArgb1555);

            ushort* line = (ushort*) bd.Scan0;
            int delta = bd.Stride >> 1;

            fixed (byte* data = m_StreamBuffer)
            {
                sbyte* bindat = (sbyte*) data;
                for (int y = 0; y < height; ++y, line += delta)
                {
                    ushort* cur = line;
                    ushort* end = cur + width;

                    while (cur < end)
                    {
                        sbyte value = *bindat++;
                        *cur++ = (ushort) (((0x1f + value) << 10) + ((0x1F + value) << 5) + (0x1F + value));
                    }
                }
            }

            bmp.UnlockBits(bd);
            stream.Close();
            if (!Files.CacheData)
                return m_Cache[index] = bmp;
            else
                return bmp;
        }

        public unsafe static void Save(string path)
        {
            string idx = Path.Combine(path, "lightidx.mul");
            string mul = Path.Combine(path, "light.mul");
            using (FileStream fsidx = new FileStream(idx, FileMode.Create, FileAccess.Write, FileShare.Write),
                fsmul = new FileStream(mul, FileMode.Create, FileAccess.Write, FileShare.Write))
            {
                using (BinaryWriter binidx = new BinaryWriter(fsidx),
                    binmul = new BinaryWriter(fsmul))
                {
                    for (int index = 0; index < m_Cache.Length; index++)
                    {
                        if (m_Cache[index] == null)
                            m_Cache[index] = GetLight(index);
                        Bitmap bmp = m_Cache[index];

                        if ((bmp == null) || (m_Removed[index]))
                        {
                            binidx.Write((int) -1); // lookup
                            binidx.Write((int) -1); // length
                            binidx.Write((int) -1); // extra
                        }
                        else
                        {
                            BitmapData bd = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height),
                                ImageLockMode.ReadOnly, PixelFormat.Format16bppArgb1555);
                            ushort* line = (ushort*) bd.Scan0;
                            int delta = bd.Stride >> 1;

                            binidx.Write((int) fsmul.Position); //lookup
                            int length = (int) fsmul.Position;

                            for (int Y = 0; Y < bmp.Height; ++Y, line += delta)
                            {
                                ushort* cur = line;
                                ushort* end = cur + bmp.Width;
                                while (cur < end)
                                {
                                    sbyte value = (sbyte) (((*cur++ >> 10) & 0xffff) - 0x1f);
                                    if (value > 0) // wtf? but it works...
                                        --value;
                                    binmul.Write(value);
                                }
                            }

                            length = (int) fsmul.Position - length;
                            binidx.Write(length);
                            binidx.Write((int) (bmp.Width << 16) + bmp.Height);
                            bmp.UnlockBits(bd);
                        }
                    }
                }
            }
        }
    }
}

================================================
FILE: Razor/UltimaSDK/LocationPointer.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

namespace Ultima
{
    public sealed class LocationPointer
    {
        public int PointerX { get; set; }
        public int PointerY { get; set; }
        public int PointerZ { get; set; }
        public int PointerF { get; set; }
        public int SizeX { get; set; }
        public int SizeY { get; set; }
        public int SizeZ { get; set; }
        public int SizeF { get; set; }

        public LocationPointer(int ptrX, int ptrY, int ptrZ, int ptrF, int sizeX, int sizeY, int sizeZ, int sizeF)
        {
            PointerX = ptrX;
            PointerY = ptrY;
            PointerZ = ptrZ;
            PointerF = ptrF;
            SizeX = sizeX;
            SizeY = sizeY;
            SizeZ = sizeZ;
            SizeF = sizeF;
        }
    }
}

================================================
FILE: Razor/UltimaSDK/Map.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;

namespace Ultima
{
    public sealed class Map
    {
        private TileMatrix m_Tiles;
        private int m_FileIndex, m_MapID;
        private int m_Width, m_Height;
        private string m_path;

        private static bool m_UseDiff;

        public static bool UseDiff
        {
            get { return m_UseDiff; }
            set
            {
                m_UseDiff = value;
                Reload();
            }
        }

        public static Map Felucca = new Map(0, 0, 7168, 4096);
        public static Map Trammel = new Map(1, 1, 7168, 4096);
        public static readonly Map Ilshenar = new Map(2, 2, 2304, 1600);
        public static readonly Map Malas = new Map(3, 3, 2560, 2048);
        public static readonly Map Tokuno = new Map(4, 4, 1448, 1448);
        public static readonly Map TerMur = new Map(5, 5, 1280, 4096);
        public static Map Custom;

        public static void StartUpSetDiff(bool value)
        {
            m_UseDiff = value;
        }

        public Map(int fileIndex, int mapID, int width, int height)
        {
            m_FileIndex = fileIndex;
            m_MapID = mapID;
            m_path = null;

            m_Tiles = new TileMatrix(m_FileIndex, m_MapID, width, height, m_path);
            m_Width = m_Tiles.Width;
            m_Height = m_Tiles.Height;
        }

        public Map(string path, int fileIndex, int mapID, int width, int height)
        {
            m_FileIndex = fileIndex;
            m_MapID = mapID;
            m_Width = width;
            m_Height = height;
            m_path = path;
        }

        /// <summary>
        /// Sets cache-vars to null
        /// </summary>
        public static void Reload()
        {
            Felucca.Tiles.Dispose();
            Trammel.Tiles.Dispose();
            Ilshenar.Tiles.Dispose();
            Malas.Tiles.Dispose();
            Tokuno.Tiles.Dispose();
            TerMur.Tiles.Dispose();
            Felucca.Tiles.StaticIndexInit = false;
            Trammel.Tiles.StaticIndexInit = false;
            Ilshenar.Tiles.StaticIndexInit = false;
            Malas.Tiles.StaticIndexInit = false;
            Tokuno.Tiles.StaticIndexInit = false;
            TerMur.Tiles.StaticIndexInit = false;
            Felucca.m_Cache =
                Trammel.m_Cache = Ilshenar.m_Cache = Malas.m_Cache = Tokuno.m_Cache = TerMur.m_Cache = null;
            Felucca.m_Tiles =
                Trammel.m_Tiles = Ilshenar.m_Tiles = Malas.m_Tiles = Tokuno.m_Tiles = TerMur.m_Tiles = null;
            Felucca.m_Cache_NoStatics = Trammel.m_Cache_NoStatics = Ilshenar.m_Cache_NoStatics =
                Malas.m_Cache_NoStatics = Tokuno.m_Cache_NoStatics = TerMur.m_Cache_NoStatics = null;
            Felucca.m_Cache_NoPatch = Trammel.m_Cache_NoPatch = Ilshenar.m_Cache_NoPatch =
                Malas.m_Cache_NoPatch = Tokuno.m_Cache_NoPatch = TerMur.m_Cache_NoPatch = null;
            Felucca.m_Cache_NoStatics_NoPatch = Trammel.m_Cache_NoStatics_NoPatch = Ilshenar.m_Cache_NoStatics_NoPatch =
                Malas.m_Cache_NoStatics_NoPatch =
                    Tokuno.m_Cache_NoStatics_NoPatch = TerMur.m_Cache_NoStatics_NoPatch = null;
        }

        public void ResetCache()
        {
            m_Cache = null;
            m_Cache_NoPatch = null;
            m_Cache_NoStatics = null;
            m_Cache_NoStatics_NoPatch = null;
            IsCached_Default = false;
            IsCached_NoStatics = false;
            IsCached_NoPatch = false;
            IsCached_NoStatics_NoPatch = false;
        }

        public bool LoadedMatrix
        {
            get { return (m_Tiles != null); }
        }

        public TileMatrix Tiles
        {
            get
            {
                if (m_Tiles == null)
                    m_Tiles = new TileMatrix(m_FileIndex, m_MapID, m_Width, m_Height, m_path);

                return m_Tiles;
            }
        }

        public int Width
        {
            get { return m_Width; }
            set { m_Width = value; }
        }

        public int Height
        {
            get { return m_Height; }
        }

        public int FileIndex
        {
            get { return m_FileIndex; }
        }

        /// <summary>
        /// Returns Bitmap with Statics
        /// </summary>
        /// <param name="x">8x8 Block</param>
        /// <param name="y">8x8 Block</param>
        /// <param name="width">8x8 Block</param>
        /// <param name="height">8x8 Block</param>
        /// <returns></returns>
        public Bitmap GetImage(int x, int y, int width, int height)
        {
            return GetImage(x, y, width, height, true);
        }

        /// <summary>
        /// Returns Bitmap
        /// </summary>
        /// <param name="x">8x8 Block</param>
        /// <param name="y">8x8 Block</param>
        /// <param name="width">8x8 Block</param>
        /// <param name="height">8x8 Block</param>
        /// <param name="statics">8x8 Block</param>
        /// <returns></returns>
        public Bitmap GetImage(int x, int y, int width, int height, bool statics)
        {
            Bitmap bmp = new Bitmap(width << 3, height << 3, PixelFormat.Format32bppRgb);

            GetImage(x, y, width, height, bmp, statics);

            return bmp;
        }

        private bool IsCached_Default;
        private bool IsCached_NoStatics;
        private bool IsCached_NoPatch;
        private bool IsCached_NoStatics_NoPatch;

        private int[][][] m_Cache;
        private int[][][] m_Cache_NoStatics;
        private int[][][] m_Cache_NoPatch;
        private int[][][] m_Cache_NoStatics_NoPatch;
        private int[] m_Black;

        public bool IsCached(bool statics)
        {
            if (Map.UseDiff)
            {
                if (!statics)
                    return IsCached_NoStatics;
                else
                    return IsCached_Default;
            }
            else
            {
                if (!statics)
                    return IsCached_NoStatics_NoPatch;
                else
                    return IsCached_NoPatch;
            }
        }

        public void PreloadRenderedBlock(int x, int y, bool statics)
        {
            TileMatrix matrix = this.Tiles;

            if (x < 0 || y < 0 || x >= matrix.BlockWidth || y >= matrix.BlockHeight)
            {
                if (m_Black == null)
                    m_Black = new int[64];
                return;
            }

            int[][][] cache;
            if (Map.UseDiff)
            {
                if (statics)
                    IsCached_Default = true;
                else
                    IsCached_NoStatics = true;
                cache = (statics ? m_Cache : m_Cache_NoStatics);
            }
            else
            {
                if (statics)
                    IsCached_NoPatch = true;
                else
                    IsCached_NoStatics_NoPatch = true;
                cache = (statics ? m_Cache_NoPatch : m_Cache_NoStatics_NoPatch);
            }

            if (cache == null)
            {
                if (Map.UseDiff)
                {
                    if (statics)
                        m_Cache = cache = new int[m_Tiles.BlockHeight][][];
                    else
                        m_Cache_NoStatics = cache = new int[m_Tiles.BlockHeight][][];
                }
                else
                {
                    if (statics)
                        m_Cache_NoPatch = cache = new int[m_Tiles.BlockHeight][][];
                    else
                        m_Cache_NoStatics_NoPatch = cache = new int[m_Tiles.BlockHeight][][];
                }
            }

            if (cache[y] == null)
                cache[y] = new int[m_Tiles.BlockWidth][];

            if (cache[y][x] == null)
                cache[y][x] = RenderBlock(x, y, statics, Map.UseDiff);

            m_Tiles.CloseStreams();
        }

        public int[] GetRenderedBlock(int x, int y, bool statics)
        {
            TileMatrix matrix = this.Tiles;

            if (x < 0 || y < 0 || x >= matrix.BlockWidth || y >= matrix.BlockHeight)
            {
                if (m_Black == null)
                    m_Black = new int[64];

                return m_Black;
            }

            int[][][] cache;
            if (Map.UseDiff)
                cache = (statics ? m_Cache : m_Cache_NoStatics);
            else
                cache = (statics ? m_Cache_NoPatch : m_Cache_NoStatics_NoPatch);

            if (cache == null)
            {
                if (Map.UseDiff)
                {
                    if (statics)
                        m_Cache = cache = new int[m_Tiles.BlockHeight][][];
                    else
                        m_Cache_NoStatics = cache = new int[m_Tiles.BlockHeight][][];
                }
                else
                {
                    if (statics)
                        m_Cache_NoPatch = cache = new int[m_Tiles.BlockHeight][][];
                    else
                        m_Cache_NoStatics_NoPatch = cache = new int[m_Tiles.BlockHeight][][];
                }
            }

            if (cache[y] == null)
                cache[y] = new int[m_Tiles.BlockWidth][];

            int[] data = cache[y][x];

            if (data == null)
                cache[y][x] = data = RenderBlock(x, y, statics, Map.UseDiff);

            return data;
        }

        public static Int32 u16Tou32(Int16 color)
        {
            Int32 red = (Int32) (((color >> 0xA) & 0x1F) * 8.225806f);
            Int32 green = (Int32) (((color >> 0x5) & 0x1F) * 8.225806f);
            Int32 blue = (Int32) ((color & 0x1F) * 8.225806f);

            if (red < 0)
                red = 0;
            else if (red > 0xFF)
                red = 0xFF;

            if (green < 0)
                green = 0;
            else if (green > 0xFF)
                green = 255;

            if (blue < 0)
                blue = 0;
            else if (blue > 0xFF)
                blue = 0xFF;

            return ((red << 0x10) | (green << 0x8) | blue);
        }

        private unsafe int[] RenderBlock(int x, int y, bool drawStatics, bool diff)
        {
            int[] data = new int[64];

            Tile[] tiles = m_Tiles.GetLandBlock(x, y, diff);

            fixed (short* pColors = RadarCol.Colors)
            {
                fixed (int* pHeight = TileData.HeightTable)
                {
                    fixed (Tile* ptTiles = tiles)
                    {
                        Tile* pTiles = ptTiles;

                        fixed (int* pData = data)
                        {
                            int* pvData = pData;

                            if (drawStatics)
                            {
                                HuedTile[][][] statics = drawStatics ? m_Tiles.GetStaticBlock(x, y, diff) : null;

                                for (int k = 0, v = 0; k < 8; ++k, v += 8)
                                {
                                    for (int p = 0; p < 8; ++p)
                                    {
                                        int highTop = -255;
                                        int highZ = -255;
                                        int highID = 0;
                                        int highHue = 0;
                                        int z, top;
                                        bool highstatic = false;

                                        HuedTile[] curStatics = statics[p][k];

                                        if (curStatics.Length > 0)
                                        {
                                            fixed (HuedTile* phtStatics = curStatics)
                                            {
                                                HuedTile* pStatics = phtStatics;
                                                HuedTile* pStaticsEnd = pStatics + curStatics.Length;

                                                while (pStatics < pStaticsEnd)
                                                {
                                                    z = pStatics->m_Z;
                                                    top = z + pHeight[pStatics->ID];

                                                    if (top > highTop || (z > highZ && top >= highTop))
                                                    {
                                                        highTop = top;
                                                        highZ = z;
                                                        highID = pStatics->ID;
                                                        highHue = pStatics->Hue;
                                                        highstatic = true;
                                                    }

                                                    ++pStatics;
                                                }
                                            }
                                        }

                                        StaticTile[] pending = m_Tiles.GetPendingStatics(x, y);
                                        if (pending != null)
                                        {
                                            foreach (StaticTile penS in pending)
                                            {
                                                if (penS.m_X == p)
                                                {
                                                    if (penS.m_Y == k)
                                                    {
                                                        z = penS.m_Z;
                                                        top = z + pHeight[penS.m_ID];

                                                        if (top > highTop || (z > highZ && top >= highTop))
                                                        {
                                                            highTop = top;
                                                            highZ = z;
                                                            highID = penS.m_ID;
                                                            highHue = penS.m_Hue;
                                                            highstatic = true;
                                                        }
                                                    }
                                                }
                                            }
                                        }

                                        top = pTiles->m_Z;

                                        if (top > highTop)
                                        {
                                            highID = pTiles->m_ID;
                                            highHue = 0;
                                            highstatic = false;
                                        }

                                        if (highHue == 0)
                                        {
                                            try
                                            {
                                                if (highstatic)
                                                    *pvData++ = u16Tou32(pColors[highID + 0x4000]);
                                                else
                                                    *pvData++ = u16Tou32(pColors[highID]);
                                            }
                                            catch
                                            {
                                            }
                                        }
                                        else
                                            *pvData++ = u16Tou32(Hues.GetHue(highHue - 1)
                                                .Colors[(pColors[highID + 0x4000] >> 10) & 0x1F]);

                                        ++pTiles;
                                    }
                                }
                            }
                            else
                            {
                                Tile* pEnd = pTiles + 64;

                                while (pTiles < pEnd)
                                    *pvData++ = u16Tou32(pColors[(pTiles++)->m_ID]);
                            }
                        }
                    }
                }
            }

            return data;
        }

        /// <summary>
        /// Draws in given Bitmap with Statics
        /// </summary>
        /// <param name="x">8x8 Block</param>
        /// <param name="y">8x8 Block</param>
        /// <param name="width">8x8 Block</param>
        /// <param name="height">8x8 Block</param>
        /// <param name="bmp">8x8 Block</param>
        public unsafe void GetImage(int x, int y, int width, int height, Bitmap bmp)
        {
            GetImage(x, y, width, height, bmp, true);
        }

        /// <summary>
        /// Draws in given Bitmap
        /// </summary>
        /// <param name="x">8x8 Block</param>
        /// <param name="y">8x8 Block</param>
        /// <param name="width">8x8 Block</param>
        /// <param name="height">8x8 Block</param>
        /// <param name="bmp"></param>
        /// <param name="statics"></param>
        public unsafe void GetImage(int x, int y, int width, int height, Bitmap bmp, bool statics)
        {
            BitmapData bd = bmp.LockBits(new Rectangle(0, 0, width << 3, height << 3), ImageLockMode.WriteOnly,
                PixelFormat.Format32bppRgb);
            int stride = bd.Stride;
            int blockStride = stride << 3;

            byte* pStart = (byte*) bd.Scan0;

            for (int oy = 0, by = y; oy < height; ++oy, ++by, pStart += blockStride)
            {
                int* pRow0 = (int*) (pStart + (0 * stride));
                int* pRow1 = (int*) (pStart + (1 * stride));
                int* pRow2 = (int*) (pStart + (2 * stride));
                int* pRow3 = (int*) (pStart + (3 * stride));
                int* pRow4 = (int*) (pStart + (4 * stride));
                int* pRow5 = (int*) (pStart + (5 * stride));
                int* pRow6 = (int*) (pStart + (6 * stride));
                int* pRow7 = (int*) (pStart + (7 * stride));

                for (int ox = 0, bx = x; ox < width; ++ox, ++bx)
                {
                    int[] data = GetRenderedBlock(bx, by, statics);

                    fixed (int* pData = data)
                    {
                        int* pvData = (int*) pData;

                        *pRow0++ = *pvData++;
                        *pRow0++ = *pvData++;
                        *pRow0++ = *pvData++;
                        *pRow0++ = *pvData++;


                        *pRow0++ = *pvData++;
                        *pRow0++ = *pvData++;
                        *pRow0++ = *pvData++;
                        *pRow0++ = *pvData++;

                        *pRow1++ = *pvData++;
                        *pRow1++ = *pvData++;
                        *pRow1++ = *pvData++;
                        *pRow1++ = *pvData++;
                        *pRow1++ = *pvData++;
                        *pRow1++ = *pvData++;
                        *pRow1++ = *pvData++;
                        *pRow1++ = *pvData++;

                        *pRow2++ = *pvData++;
                        *pRow2++ = *pvData++;
                        *pRow2++ = *pvData++;
                        *pRow2++ = *pvData++;
                        *pRow2++ = *pvData++;
                        *pRow2++ = *pvData++;
                        *pRow2++ = *pvData++;
                        *pRow2++ = *pvData++;

                        *pRow3++ = *pvData++;
                        *pRow3++ = *pvData++;
                        *pRow3++ = *pvData++;
                        *pRow3++ = *pvData++;
                        *pRow3++ = *pvData++;
                        *pRow3++ = *pvData++;
                        *pRow3++ = *pvData++;
                        *pRow3++ = *pvData++;

                        *pRow4++ = *pvData++;
                        *pRow4++ = *pvData++;
                        *pRow4++ = *pvData++;
                        *pRow4++ = *pvData++;
                        *pRow4++ = *pvData++;
                        *pRow4++ = *pvData++;
                        *pRow4++ = *pvData++;
                        *pRow4++ = *pvData++;
                        *pRow5++ = *pvData++;
                        *pRow5++ = *pvData++;
                        *pRow5++ = *pvData++;
                        *pRow5++ = *pvData++;
                        *pRow5++ = *pvData++;
                        *pRow5++ = *pvData++;
                        *pRow5++ = *pvData++;
                        *pRow5++ = *pvData++;

                        *pRow6++ = *pvData++;
                        *pRow6++ = *pvData++;
                        *pRow6++ = *pvData++;
                        *pRow6++ = *pvData++;
                        *pRow6++ = *pvData++;
                        *pRow6++ = *pvData++;
                        *pRow6++ = *pvData++;
                        *pRow6++ = *pvData++;

                        *pRow7++ = *pvData++;
                        *pRow7++ = *pvData++;
                        *pRow7++ = *pvData++;
                        *pRow7++ = *pvData++;
                        *pRow7++ = *pvData++;
                        *pRow7++ = *pvData++;
                        *pRow7++ = *pvData++;
                        *pRow7++ = *pvData++;
                    }
                }
            }

            bmp.UnlockBits(bd);
            m_Tiles.CloseStreams();
        }

        public static void DefragStatics(string path, Map map, int width, int height, bool remove)
        {
            string indexPath = Files.GetFilePath("staidx{0}.mul", map.FileIndex);
            FileStream m_Index;
            BinaryReader m_IndexReader;
            if (indexPath != null)
            {
                m_Index = new FileStream(indexPath, FileMode.Open, FileAccess.Read, FileShare.Read);
                m_IndexReader = new BinaryReader(m_Index);
            }
            else
                return;

            string staticsPath = Files.GetFilePath("statics{0}.mul", map.FileIndex);

            FileStream m_Statics;
            BinaryReader m_StaticsReader;
            if (staticsPath != null)
            {
                m_Statics = new FileStream(staticsPath, FileMode.Open, FileAccess.Read, FileShare.Read);
                m_StaticsReader = new BinaryReader(m_Statics);
            }
            else
                return;


            int blockx = width >> 3;
            int blocky = height >> 3;

            string idx = Path.Combine(path, $"staidx{map.FileIndex}.mul");
            string mul = Path.Combine(path, $"statics{map.FileIndex}.mul");
            using (FileStream fsidx = new FileStream(idx, FileMode.Create, FileAccess.Write, FileShare.Write),
                fsmul = new FileStream(mul, FileMode.Create, FileAccess.Write, FileShare.Write))
            {
                MemoryStream memidx = new MemoryStream();
                MemoryStream memmul = new MemoryStream();
                using (BinaryWriter binidx = new BinaryWriter(memidx),
                    binmul = new BinaryWriter(memmul))
                {
                    for (int x = 0; x < blockx; ++x)
                    {
                        for (int y = 0; y < blocky; ++y)
                        {
                            try
                            {
                                m_IndexReader.BaseStream.Seek(((x * blocky) + y) * 12, SeekOrigin.Begin);
                                int lookup = m_IndexReader.ReadInt32();
                                int length = m_IndexReader.ReadInt32();
                                int extra = m_IndexReader.ReadInt32();

                                if (((lookup < 0 || length <= 0)
                                     && (!map.Tiles.PendingStatic(x, y)))
                                    || (map.Tiles.IsStaticBlockRemoved(x, y)))
                                {
                                    binidx.Write((int) -1); // lookup
                                    binidx.Write((int) -1); // length
                                    binidx.Write((int) -1); // extra
                                }
                                else
                                {
                                    if ((lookup >= 0) && (length > 0))
                                        m_Statics.Seek(lookup, SeekOrigin.Begin);

                                    int fsmullength = (int) binmul.BaseStream.Position;
                                    int count = length / 7;
                                    if (!remove) //without duplicate remove
                                    {
                                        bool firstitem = true;
                                        for (int i = 0; i < count; ++i)
                                        {
                                            ushort graphic = m_StaticsReader.ReadUInt16();
                                            byte sx = m_StaticsReader.ReadByte();
                                            byte sy = m_StaticsReader.ReadByte();
                                            sbyte sz = m_StaticsReader.ReadSByte();
                                            short shue = m_StaticsReader.ReadInt16();
                                            if ((graphic >= 0) && (graphic <= Art.GetMaxItemID()))
                                            {
                                                if (shue < 0)
                                                    shue = 0;
                                                if (firstitem)
                                                {
                                                    binidx.Write((int) binmul.BaseStream.Position); //lookup
                                                    firstitem = false;
                                                }

                                                binmul.Write(graphic);
                                                binmul.Write(sx);
                                                binmul.Write(sy);
                                                binmul.Write(sz);
                                                binmul.Write(shue);
                                            }
                                        }

                                        StaticTile[] tilelist = map.Tiles.GetPendingStatics(x, y);
                                        if (tilelist != null)
                                        {
                                            for (int i = 0; i < tilelist.Length; ++i)
                                            {
                                                if ((tilelist[i].m_ID >= 0) && (tilelist[i].m_ID <= Art.GetMaxItemID()))
                                                {
                                                    if (tilelist[i].m_Hue < 0)
                                                        tilelist[i].m_Hue = 0;
                                                    if (firstitem)
                                                    {
                                                        binidx.Write((int) binmul.BaseStream.Position); //lookup
                                                        firstitem = false;
                                                    }

                                                    binmul.Write(tilelist[i].m_ID);
                                                    binmul.Write(tilelist[i].m_X);
                                                    binmul.Write(tilelist[i].m_Y);
                                                    binmul.Write(tilelist[i].m_Z);
                                                    binmul.Write(tilelist[i].m_Hue);
                                                }
                                            }
                                        }
                                    }
                                    else //with duplicate remove
                                    {
                                        StaticTile[] tilelist = new StaticTile[count];
                                        int j = 0;
                                        for (int i = 0; i < count; ++i)
                                        {
                                            StaticTile tile = new StaticTile();
                                            tile.m_ID = m_StaticsReader.ReadUInt16();
                                            tile.m_X = m_StaticsReader.ReadByte();
                                            tile.m_Y = m_StaticsReader.ReadByte();
                                            tile.m_Z = m_StaticsReader.ReadSByte();
                                            tile.m_Hue = m_StaticsReader.ReadInt16();

                                            if ((tile.m_ID >= 0) && (tile.m_ID <= Art.GetMaxItemID()))
                                            {
                                                if (tile.m_Hue < 0)
                                                    tile.m_Hue = 0;
                                                bool first = true;
                                                for (int k = 0; k < j; ++k)
                                                {
                                                    if ((tilelist[k].m_ID == tile.m_ID)
                                                        && ((tilelist[k].m_X == tile.m_X) &&
                                                            (tilelist[k].m_Y == tile.m_Y))
                                                        && (tilelist[k].m_Z == tile.m_Z)
                                                        && (tilelist[k].m_Hue == tile.m_Hue))
                                                    {
                                                        first = false;
                                                        break;
                                                    }
                                                }

                                                if (first)
                                                {
                                                    tilelist[j] = tile;
                                                    j++;
                                                }
                                            }
                                        }

                                        if (map.Tiles.PendingStatic(x, y))
                                        {
                                            StaticTile[] pending = map.Tiles.GetPendingStatics(x, y);
                                            StaticTile[] old = tilelist;
                                            tilelist = new StaticTile[old.Length + pending.Length];
                                            old.CopyTo(tilelist, 0);
                                            for (int i = 0; i < pending.Length; ++i)
                                            {
                                                if ((pending[i].m_ID >= 0) && (pending[i].m_ID <= Art.GetMaxItemID()))
                                                {
                                                    if (pending[i].m_Hue < 0)
                                                        pending[i].m_Hue = 0;
                                                    bool first = true;
                                                    for (int k = 0; k < j; ++k)
                                                    {
                                                        if ((tilelist[k].m_ID == pending[i].m_ID)
                                                            && ((tilelist[k].m_X == pending[i].m_X) &&
                                                                (tilelist[k].m_Y == pending[i].m_Y))
                                                            && (tilelist[k].m_Z == pending[i].m_Z)
                                                            && (tilelist[k].m_Hue == pending[i].m_Hue))
                                                        {
                                                            first = false;
                                                            break;
                                                        }
                                                    }

                                                    if (first)
                                                        tilelist[j++] = pending[i];
                                                }
                                            }
                                        }

                                        if (j > 0)
                                        {
                                            binidx.Write((int) binmul.BaseStream.Position); //lookup
                                            for (int i = 0; i < j; ++i)
                                            {
                                                binmul.Write(tilelist[i].m_ID);
                                                binmul.Write(tilelist[i].m_X);
                                                binmul.Write(tilelist[i].m_Y);
                                                binmul.Write(tilelist[i].m_Z);
                                                binmul.Write(tilelist[i].m_Hue);
                                            }
                                        }
                                    }

                                    fsmullength = (int) binmul.BaseStream.Position - fsmullength;
                                    if (fsmullength > 0)
                                    {
                                        binidx.Write(fsmullength); //length
                                        if (extra == -1)
                                            extra = 0;
                                        binidx.Write(extra); //extra
                                    }
                                    else
                                    {
                                        binidx.Write((int) -1); //lookup
                                        binidx.Write((int) -1); //length
                                        binidx.Write((int) -1); //extra
                                    }
                                }
                            }
                            catch // fill the rest
                            {
                                binidx.BaseStream.Seek(((x * blocky) + y) * 12, SeekOrigin.Begin);
                                for (; x < blockx; ++x)
                                {
                                    for (; y < blocky; ++y)
                                    {
                                        binidx.Write((int) -1); //lookup
                                        binidx.Write((int) -1); //length
                                        binidx.Write((int) -1); //extra
                                    }

                                    y = 0;
                                }
                            }
                        }
                    }

                    memidx.WriteTo(fsidx);
                    memmul.WriteTo(fsmul);
                }
            }

            m_IndexReader.Close();
            m_StaticsReader.Close();
        }

        public static void RewriteMap(string path, int map, int width, int height)
        {
            string mapPath = Files.GetFilePath("map{0}.mul", map);
            FileStream m_map;
            BinaryReader m_mapReader;
            if (mapPath != null)
            {
                m_map = new FileStream(mapPath, FileMode.Open, FileAccess.Read, FileShare.Read);
                m_mapReader = new BinaryReader(m_map);
            }
            else
                return;

            int blockx = width >> 3;
            int blocky = height >> 3;

            string mul = Path.Combine(path, $"map{map}.mul");
            using (FileStream fsmul = new FileStream(mul, FileMode.Create, FileAccess.Write, FileShare.Write))
            {
                MemoryStream memmul = new MemoryStream();
                using (BinaryWriter binmul = new BinaryWriter(memmul))
                {
                    for (int x = 0; x < blockx; ++x)
                    {
                        for (int y = 0; y < blocky; ++y)
                        {
                            try
                            {
                                m_mapReader.BaseStream.Seek(((x * blocky) + y) * 196, SeekOrigin.Begin);
                                int header = m_mapReader.ReadInt32();
                                binmul.Write(header);
                                for (int i = 0; i < 64; ++i)
                                {
                                    short tileid = m_mapReader.ReadInt16();
                                    sbyte z = m_mapReader.ReadSByte();
                                    if ((tileid < 0) || (tileid >= 0x4000))
                                        tileid = 0;
                                    if (z < -128)
                                        z = -128;
                                    if (z > 127)
                                        z = 127;
                                    binmul.Write(tileid);
                                    binmul.Write(z);
                                }
                            }
                            catch //fill rest
                            {
                                binmul.BaseStream.Seek(((x * blocky) + y) * 196, SeekOrigin.Begin);
                                for (; x < blockx; ++x)
                                {
                                    for (; y < blocky; ++y)
                                    {
                                        binmul.Write((int) 0);
                                        for (int i = 0; i < 64; ++i)
                                        {
                                            binmul.Write((short) 0);
                                            binmul.Write((sbyte) 0);
                                        }
                                    }

                                    y = 0;
                                }
                            }
                        }
                    }

                    memmul.WriteTo(fsmul);
                }
            }

            m_mapReader.Close();
        }

        public void ReportInvisStatics(string reportfile)
        {
            reportfile = Path.Combine(reportfile, $"staticReport-{m_MapID}.csv");
            using (StreamWriter Tex =
                new StreamWriter(new FileStream(reportfile, FileMode.Create, FileAccess.ReadWrite),
                    System.Text.Encoding.GetEncoding(1252)))
            {
                Tex.WriteLine("x;y;z;Static");
                for (int x = 0; x < m_Width; ++x)
                {
                    for (int y = 0; y < m_Height; ++y)
                    {
                        Tile currtile = Tiles.GetLandTile(x, y);
                        foreach (HuedTile currstatic in Tiles.GetStaticTiles(x, y))
                        {
                            if (currstatic.Z < currtile.Z)
                            {
                                if (TileData.ItemTable[currstatic.ID].Height + currstatic.Z < currtile.Z)
                                    Tex.WriteLine($"{x};{y};{currstatic.Z};0x{currstatic.ID:X}");
                            }
                        }
                    }
                }
            }
        }

        public void ReportInvalidMapIDs(string reportfile)
        {
            reportfile = Path.Combine(reportfile, $"ReportInvalidMapIDs-{m_MapID}.csv");
            using (StreamWriter Tex =
                new StreamWriter(new FileStream(reportfile, FileMode.Create, FileAccess.ReadWrite),
                    System.Text.Encoding.GetEncoding(1252)))
            {
                Tex.WriteLine("x;y;z;Static;LandTile");
                for (int x = 0; x < m_Width; ++x)
                {
                    for (int y = 0; y < m_Height; ++y)
                    {
                        Tile currtile = Tiles.GetLandTile(x, y);
                        if (!Art.IsValidLand(currtile.ID))
                            Tex.WriteLine($"{x};{y};{currtile.Z};0;0x{currtile.ID:X}");
                        foreach (HuedTile currstatic in Tiles.GetStaticTiles(x, y))
                        {
                            if (!Art.IsValidStatic(currstatic.ID))
                                Tex.WriteLine($"{x};{y};{currstatic.Z};0x{currstatic.ID:X};0");
                        }
                    }
                }
            }
        }
    }
}

================================================
FILE: Razor/UltimaSDK/MultiMap.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System;

namespace Ultima
{
    public sealed class MultiMap
    {
        private static byte[] m_StreamBuffer;

        static MultiMap()
        {
        }

        /// <summary>
        /// Returns Bitmap
        /// </summary>
        /// <returns></returns>
        public static unsafe Bitmap GetMultiMap()
        {
            string path = Files.GetFilePath("Multimap.rle");
            if (path != null)
            {
                using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read))
                {
                    using (BinaryReader bin = new BinaryReader(fs))
                    {
                        int width, height;
                        byte pixel;
                        int count;
                        int x, i;
                        x = 0;
                        ushort c = 0;
                        width = bin.ReadInt32();
                        height = bin.ReadInt32();
                        Bitmap multimap = new Bitmap(width, height, PixelFormat.Format16bppArgb1555);
                        BitmapData bd = multimap.LockBits(new Rectangle(0, 0, multimap.Width, multimap.Height),
                            ImageLockMode.WriteOnly, PixelFormat.Format16bppArgb1555);
                        ushort* line = (ushort*) bd.Scan0;
                        int delta = bd.Stride >> 1;

                        ushort* cur = line;
                        int len = (int) (bin.BaseStream.Length - bin.BaseStream.Position);
                        if (m_StreamBuffer == null || m_StreamBuffer.Length < len)
                            m_StreamBuffer = new byte[len];
                        bin.Read(m_StreamBuffer, 0, len);
                        int j = 0;
                        while (j != len)
                        {
                            pixel = m_StreamBuffer[j++];
                            count = (pixel & 0x7f);

                            if ((pixel & 0x80) != 0)
                                c = 0x8000; //Color.Black;
                            else
                                c = 0xffff; //Color.White;
                            for (i = 0; i < count; ++i)
                            {
                                cur[x++] = c;
                                if (x >= width)
                                {
                                    cur += delta;
                                    x = 0;
                                }
                            }
                        }

                        multimap.UnlockBits(bd);
                        return multimap;
                    }
                }
            }

            return null;
        }

        /// <summary>
        /// Saves Bitmap to rle Format
        /// </summary>
        /// <param name="image"></param>
        /// <param name="bin"></param>
        public static unsafe void SaveMultiMap(Bitmap image, BinaryWriter bin)
        {
            bin.Write(2560); // width
            bin.Write(2048); // height
            byte data = 1;
            byte mask = 0x0;
            ushort curcolor = 0;
            BitmapData bd = image.LockBits(new Rectangle(0, 0, image.Width, image.Height), ImageLockMode.ReadOnly,
                PixelFormat.Format16bppArgb1555);
            ushort* line = (ushort*) bd.Scan0;
            int delta = bd.Stride >> 1;
            ushort* cur = line;
            curcolor = cur[0]; //init
            for (int y = 0; y < image.Height; ++y, line += delta)
            {
                cur = line;
                for (int x = 0; x < image.Width; ++x)
                {
                    ushort c = cur[x];

                    if (c == curcolor)
                    {
                        ++data;
                        if (data == 0x7f)
                        {
                            if (curcolor == 0xffff)
                                mask = 0x0;
                            else
                                mask = 0x80;
                            data |= mask;
                            bin.Write(data);
                            data = 1;
                        }
                    }
                    else
                    {
                        if (curcolor == 0xffff)
                            mask = 0x0;
                        else
                            mask = 0x80;
                        data |= mask;
                        bin.Write(data);
                        curcolor = c;
                        data = 1;
                    }
                }
            }

            if (curcolor == 0xffff)
                mask = 0x0;
            else
                mask = 0x80;
            data |= mask;
            bin.Write(data);
            image.UnlockBits(bd);
        }

        /// <summary>
        /// reads facet0*.mul into Bitmap
        /// </summary>
        /// <param name="id">facet id</param>
        /// <returns>Bitmap</returns>
        public static unsafe Bitmap GetFacetImage(int id)
        {
            Bitmap bmp;
            string path = Files.GetFilePath($"facet0{id}.mul");
            if (path != null)
            {
                using (BinaryReader reader =
                    new BinaryReader(new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read)))
                {
                    int width = reader.ReadInt16();
                    int height = reader.ReadInt16();

                    bmp = new Bitmap(width, height);
                    BitmapData bd = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.WriteOnly,
                        PixelFormat.Format16bppArgb1555);
                    ushort* line = (ushort*) bd.Scan0;
                    int delta = bd.Stride >> 1;

                    for (int y = 0; y < height; y++, line += delta)
                    {
                        int colorsCount = reader.ReadInt32() / 3;
                        ushort* endline = line + delta;
                        ushort* cur = line;
                        ushort* end;
                        for (int c = 0; c < colorsCount; c++)
                        {
                            byte count = reader.ReadByte();
                            short color = reader.ReadInt16();
                            end = cur + count;
                            while (cur < end)
                            {
                                if (cur > endline)
                                    break;
                                *cur++ = (ushort) (color ^ 0x8000);
                            }
                        }
                    }

                    bmp.UnlockBits(bd);
                }

                return bmp;
            }

            return null;
        }

        /// <summary>
        /// Stores Image into facet.mul format
        /// </summary>
        /// <param name="path"></param>
        /// <param name="sourceBitmap"></param>
        public static unsafe void SaveFacetImage(string path, Bitmap sourceBitmap)
        {
            int width = sourceBitmap.Width;
            int height = sourceBitmap.Height;

            using (BinaryWriter writer =
                new BinaryWriter(new FileStream(path, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite)))
            {
                writer.Write((short) width);
                writer.Write((short) height);
                BitmapData bd = sourceBitmap.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadOnly,
                    PixelFormat.Format16bppArgb1555);
                ushort* line = (ushort*) bd.Scan0;
                int delta = bd.Stride >> 1;
                for (int y = 0; y < height; y++, line += delta)
                {
                    long pos = writer.BaseStream.Position;
                    writer.Write(0); //bytes count for current line

                    int colorsAtLine = 0;
                    int colorsCount = 0;
                    int x = 0;

                    while (x < width)
                    {
                        ushort hue = line[x];
                        while (x < width && colorsCount < byte.MaxValue && hue == line[x])
                        {
                            ++colorsCount;
                            ++x;
                        }

                        writer.Write((byte) colorsCount);
                        writer.Write((ushort) (hue ^ 0x8000));

                        colorsAtLine++;
                        colorsCount = 0;
                    }

                    long currpos = writer.BaseStream.Position;
                    writer.BaseStream.Seek(pos, SeekOrigin.Begin);
                    writer.Write(colorsAtLine * 3); //byte count
                    writer.BaseStream.Seek(currpos, SeekOrigin.Begin);
                }
            }
        }
    }
}

================================================
FILE: Razor/UltimaSDK/Multis.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Text.RegularExpressions;

namespace Ultima
{
    public sealed class Multis
    {
        private static MultiComponentList[] m_Components = new MultiComponentList[0x2000];
        private static FileIndex m_FileIndex = new FileIndex("Multi.idx", "Multi.mul", 0x2000, 14);

        public enum ImportType
        {
            TXT,
            UOA,
            UOAB,
            WSC,
            MULTICACHE,
            UOADESIGN
        }

        public static bool PostHSFormat { get; set; }

        /// <summary>
        /// ReReads multi.mul
        /// </summary>
        public static void Reload()
        {
            m_FileIndex = new FileIndex("Multi.idx", "Multi.mul", 0x2000, 14);
            m_Components = new MultiComponentList[0x2000];
        }

        /// <summary>
        /// Gets <see cref="MultiComponentList"/> of multi
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public static MultiComponentList GetComponents(int index)
        {
            MultiComponentList mcl;

            index &= 0x1FFF;

            if (index >= 0 && index < m_Components.Length)
            {
                mcl = m_Components[index];

                if (mcl == null)
                    m_Components[index] = mcl = Load(index);
            }
            else
                mcl = MultiComponentList.Empty;

            return mcl;
        }

        public static MultiComponentList Load(int index)
        {
            try
            {
                int length, extra;
                bool patched;
                Stream stream = m_FileIndex.Seek(index, out length, out extra, out patched);

                if (stream == null)
                    return MultiComponentList.Empty;

                if (PostHSFormat || Art.IsUOAHS())
                    return new MultiComponentList(new BinaryReader(stream), length / 16);
                else
                    return new MultiComponentList(new BinaryReader(stream), length / 12);
            }
            catch
            {
                return MultiComponentList.Empty;
            }
        }

        public static void Remove(int index)
        {
            m_Components[index] = MultiComponentList.Empty;
        }

        public static void Add(int index, MultiComponentList comp)
        {
            m_Components[index] = comp;
        }

        public static MultiComponentList ImportFromFile(int index, string FileName, Multis.ImportType type)
        {
            try
            {
                return m_Components[index] = new MultiComponentList(FileName, type);
            }
            catch
            {
                return m_Components[index] = MultiComponentList.Empty;
            }
        }

        public static MultiComponentList LoadFromFile(string FileName, Multis.ImportType type)
        {
            try
            {
                return new MultiComponentList(FileName, type);
            }
            catch
            {
                return MultiComponentList.Empty;
            }
        }

        public static List<MultiComponentList> LoadFromCache(string FileName)
        {
            List<MultiComponentList> multilist = new List<MultiComponentList>();
            using (StreamReader ip = new StreamReader(FileName))
            {
                string line;
                while ((line = ip.ReadLine()) != null)
                {
                    string[] split = Regex.Split(line, @"\s+");
                    if (split.Length == 7)
                    {
                        int count = Convert.ToInt32(split[2]);
                        multilist.Add(new MultiComponentList(ip, count));
                    }
                }
            }

            return multilist;
        }

        public static string ReadUOAString(BinaryReader bin)
        {
            byte flag = bin.ReadByte();

            if (flag == 0)
                return null;
            else
                return bin.ReadString();
        }

        public static List<Object[]> LoadFromDesigner(string FileName)
        {
            List<Object[]> multilist = new List<Object[]>();
            string root = Path.GetFileNameWithoutExtension(FileName);
            string idx = $"{root}.idx";
            string bin = $"{root}.bin";
            if ((!File.Exists(idx)) || (!File.Exists(bin)))
                return multilist;
            using (FileStream idxfs = new FileStream(idx, FileMode.Open, FileAccess.Read, FileShare.Read),
                binfs = new FileStream(bin, FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                using (BinaryReader idxbin = new BinaryReader(idxfs),
                    binbin = new BinaryReader(binfs))
                {
                    int count = idxbin.ReadInt32();
                    int version = idxbin.ReadInt32();

                    for (int i = 0; i < count; ++i)
                    {
                        Object[] data = new Object[2];
                        switch (version)
                        {
                            case 0:
                                data[0] = ReadUOAString(idxbin);
                                List<MultiComponentList.MultiTileEntry> arr =
                                    new List<MultiComponentList.MultiTileEntry>();
                                data[0] += "-" + ReadUOAString(idxbin);
                                data[0] += "-" + ReadUOAString(idxbin);
                                int width = idxbin.ReadInt32();
                                int height = idxbin.ReadInt32();
                                int uwidth = idxbin.ReadInt32();
                                int uheight = idxbin.ReadInt32();
                                long filepos = idxbin.ReadInt64();
                                int reccount = idxbin.ReadInt32();

                                binbin.BaseStream.Seek(filepos, SeekOrigin.Begin);
                                int index, x, y, z, level, hue;
                                for (int j = 0; j < reccount; ++j)
                                {
                                    index = x = y = z = level = hue = 0;
                                    int compVersion = binbin.ReadInt32();
                                    switch (compVersion)
                                    {
                                        case 0:
                                            index = binbin.ReadInt32();
                                            x = binbin.ReadInt32();
                                            y = binbin.ReadInt32();
                                            z = binbin.ReadInt32();
                                            level = binbin.ReadInt32();
                                            break;

                                        case 1:
                                            index = binbin.ReadInt32();
                                            x = binbin.ReadInt32();
                                            y = binbin.ReadInt32();
                                            z = binbin.ReadInt32();
                                            level = binbin.ReadInt32();
                                            hue = binbin.ReadInt32();
                                            break;
                                    }

                                    MultiComponentList.MultiTileEntry
                                        tempitem = new MultiComponentList.MultiTileEntry();
                                    tempitem.m_ItemID = (ushort) index;
                                    tempitem.m_Flags = 1;
                                    tempitem.m_OffsetX = (short) x;
                                    tempitem.m_OffsetY = (short) y;
                                    tempitem.m_OffsetZ = (short) z;
                                    tempitem.m_Unk1 = 0;
                                    arr.Add(tempitem);
                                }

                                data[1] = new MultiComponentList(arr);
                                break;
                        }

                        multilist.Add(data);
                    }
                }

                return multilist;
            }
        }

        public static List<MultiComponentList.MultiTileEntry> RebuildTiles(MultiComponentList.MultiTileEntry[] tiles)
        {
            List<MultiComponentList.MultiTileEntry> newtiles = new List<MultiComponentList.MultiTileEntry>();
            newtiles.AddRange(tiles);

            if (newtiles[0].m_OffsetX == 0 && newtiles[0].m_OffsetY == 0 && newtiles[0].m_OffsetZ == 0
            ) // found a centeritem
            {
                if (newtiles[0].m_ItemID != 0x1) // its a "good" one
                {
                    for (int j = newtiles.Count - 1; j >= 0; --j) // remove all invis items
                    {
                        if (newtiles[j].m_ItemID == 0x1)
                            newtiles.RemoveAt(j);
                    }

                    return newtiles;
                }
                else // a bad one
                {
                    for (int i = 1; i < newtiles.Count; ++i) // do we have a better one?
                    {
                        if (newtiles[i].m_OffsetX == 0 && newtiles[i].m_OffsetY == 0
                                                       && newtiles[i].m_ItemID != 0x1 && newtiles[i].m_OffsetZ == 0)
                        {
                            MultiComponentList.MultiTileEntry centeritem = newtiles[i];
                            newtiles.RemoveAt(i); // jep so save it
                            for (int j = newtiles.Count - 1; j >= 0; --j) // and remove all invis
                            {
                                if (newtiles[j].m_ItemID == 0x1)
                                    newtiles.RemoveAt(j);
                            }

                            newtiles.Insert(0, centeritem);
                            return newtiles;
                        }
                    }

                    for (int j = newtiles.Count - 1; j >= 1; --j) // nothing found so remove all invis exept the first
                    {
                        if (newtiles[j].m_ItemID == 0x1)
                            newtiles.RemoveAt(j);
                    }

                    return newtiles;
                }
            }

            for (int i = 0; i < newtiles.Count; ++i) // is there a good one
            {
                if (newtiles[i].m_OffsetX == 0 && newtiles[i].m_OffsetY == 0
                                               && newtiles[i].m_ItemID != 0x1 && newtiles[i].m_OffsetZ == 0)
                {
                    MultiComponentList.MultiTileEntry centeritem = newtiles[i];
                    newtiles.RemoveAt(i); // store it
                    for (int j = newtiles.Count - 1; j >= 0; --j) // remove all invis
                    {
                        if (newtiles[j].m_ItemID == 0x1)
                            newtiles.RemoveAt(j);
                    }

                    newtiles.Insert(0, centeritem);
                    return newtiles;
                }
            }

            for (int j = newtiles.Count - 1; j >= 0; --j) // nothing found so remove all invis
            {
                if (newtiles[j].m_ItemID == 0x1)
                    newtiles.RemoveAt(j);
            }

            MultiComponentList.MultiTileEntry invisitem = new MultiComponentList.MultiTileEntry();
            invisitem.m_ItemID = 0x1; // and create a new invis
            invisitem.m_OffsetX = 0;
            invisitem.m_OffsetY = 0;
            invisitem.m_OffsetZ = 0;
            invisitem.m_Flags = 0;
            invisitem.m_Unk1 = 0;
            newtiles.Insert(0, invisitem);
            return newtiles;
        }

        public static void Save(string path)
        {
            bool isUOAHS = PostHSFormat || Art.IsUOAHS();
            string idx = Path.Combine(path, "multi.idx");
            string mul = Path.Combine(path, "multi.mul");
            using (FileStream fsidx = new FileStream(idx, FileMode.Create, FileAccess.Write, FileShare.Write),
                fsmul = new FileStream(mul, FileMode.Create, FileAccess.Write, FileShare.Write))
            {
                using (BinaryWriter binidx = new BinaryWriter(fsidx),
                    binmul = new BinaryWriter(fsmul))
                {
                    for (int index = 0; index < 0x2000; ++index)
                    {
                        MultiComponentList comp = GetComponents(index);

                        if (comp == MultiComponentList.Empty)
                        {
                            binidx.Write((int) -1); // lookup
                            binidx.Write((int) -1); // length
                            binidx.Write((int) -1); // extra
                        }
                        else
                        {
                            List<MultiComponentList.MultiTileEntry> tiles = RebuildTiles(comp.SortedTiles);
                            binidx.Write((int) fsmul.Position); //lookup
                            if (isUOAHS)
                                binidx.Write((int) (tiles.Count * 16)); //length
                            else
                                binidx.Write((int) (tiles.Count * 12)); //length
                            binidx.Write((int) -1); //extra
                            for (int i = 0; i < tiles.Count; ++i)
                            {
                                binmul.Write((ushort) tiles[i].m_ItemID);
                                binmul.Write((short) tiles[i].m_OffsetX);
                                binmul.Write((short) tiles[i].m_OffsetY);
                                binmul.Write((short) tiles[i].m_OffsetZ);
                                binmul.Write((int) tiles[i].m_Flags);
                                if (isUOAHS)
                                    binmul.Write((int) tiles[i].m_Unk1);
                            }
                        }
                    }
                }
            }
        }
    }

    public sealed class MultiComponentList
    {
        private Point m_Min, m_Max, m_Center;
        private int m_Width, m_Height, m_maxHeight, m_Surface;
        private MTile[][][] m_Tiles;
        private MultiTileEntry[] m_SortedTiles;

        public static readonly MultiComponentList Empty = new MultiComponentList();

        public Point Min
        {
            get { return m_Min; }
        }

        public Point Max
        {
            get { return m_Max; }
        }

        public Point Center
        {
            get { return m_Center; }
        }

        public int Width
        {
            get { return m_Width; }
        }

        public int Height
        {
            get { return m_Height; }
        }

        public MTile[][][] Tiles
        {
            get { return m_Tiles; }
        }

        public int maxHeight
        {
            get { return m_maxHeight; }
        }

        public MultiTileEntry[] SortedTiles
        {
            get { return m_SortedTiles; }
        }

        public int Surface
        {
            get { return m_Surface; }
        }


        public struct MultiTileEntry
        {
            public ushort m_ItemID;
            public short m_OffsetX, m_OffsetY, m_OffsetZ;
            public int m_Flags;
            public int m_Unk1;
        }

        /// <summary>
        /// Returns Bitmap of Multi
        /// </summary>
        /// <returns></returns>
        public Bitmap GetImage()
        {
            return GetImage(300);
        }

        /// <summary>
        /// Returns Bitmap of Multi to maxheight
        /// </summary>
        /// <param name="maxheight"></param>
        /// <returns></returns>
        public Bitmap GetImage(int maxheight)
        {
            if (m_Width == 0 || m_Height == 0)
                return null;

            int xMin = 1000, yMin = 1000;
            int xMax = -1000, yMax = -1000;

            for (int x = 0; x < m_Width; ++x)
            {
                for (int y = 0; y < m_Height; ++y)
                {
                    MTile[] tiles = m_Tiles[x][y];

                    for (int i = 0; i < tiles.Length; ++i)
                    {
                        Bitmap bmp = Art.GetStatic(tiles[i].ID);

                        if (bmp == null)
                            continue;

                        int px = (x - y) * 22;
                        int py = (x + y) * 22;

                        px -= (bmp.Width / 2);
                        py -= tiles[i].Z << 2;
                        py -= bmp.Height;

                        if (px < xMin)
                            xMin = px;

                        if (py < yMin)
                            yMin = py;

                        px += bmp.Width;
                        py += bmp.Height;

                        if (px > xMax)
                            xMax = px;

                        if (py > yMax)
                            yMax = py;
                    }
                }
            }

            Bitmap canvas = new Bitmap(xMax - xMin, yMax - yMin);
            Graphics gfx = Graphics.FromImage(canvas);
            gfx.Clear(Color.White);
            for (int x = 0; x < m_Width; ++x)
            {
                for (int y = 0; y < m_Height; ++y)
                {
                    MTile[] tiles = m_Tiles[x][y];

                    for (int i = 0; i < tiles.Length; ++i)
                    {
                        Bitmap bmp = Art.GetStatic(tiles[i].ID);

                        if (bmp == null)
                            continue;
                        if ((tiles[i].Z) > maxheight)
                            continue;
                        int px = (x - y) * 22;
                        int py = (x + y) * 22;

                        px -= (bmp.Width / 2);
                        py -= tiles[i].Z << 2;
                        py -= bmp.Height;
                        px -= xMin;
                        py -= yMin;

                        gfx.DrawImageUnscaled(bmp, px, py, bmp.Width, bmp.Height);
                    }

                    int tx = (x - y) * 22;
                    int ty = (x + y) * 22;
                    tx -= xMin;
                    ty -= yMin;
                }
            }

            gfx.Dispose();

            return canvas;
        }

        public MultiComponentList(BinaryReader reader, int count)
        {
            bool useNewMultiFormat = Multis.PostHSFormat || Art.IsUOAHS();
            m_Min = m_Max = Point.Empty;
            m_SortedTiles = new MultiTileEntry[count];
            for (int i = 0; i < count; ++i)
            {
                m_SortedTiles[i].m_ItemID = Art.GetLegalItemID(reader.ReadUInt16());
                m_SortedTiles[i].m_OffsetX = reader.ReadInt16();
                m_SortedTiles[i].m_OffsetY = reader.ReadInt16();
                m_SortedTiles[i].m_OffsetZ = reader.ReadInt16();
                m_SortedTiles[i].m_Flags = reader.ReadInt32();
                if (useNewMultiFormat)
                    m_SortedTiles[i].m_Unk1 = reader.ReadInt32();
                else
                    m_SortedTiles[i].m_Unk1 = 0;

                MultiTileEntry e = m_SortedTiles[i];

                if (e.m_OffsetX < m_Min.X)
                    m_Min.X = e.m_OffsetX;

                if (e.m_OffsetY < m_Min.Y)
                    m_Min.Y = e.m_OffsetY;

                if (e.m_OffsetX > m_Max.X)
                    m_Max.X = e.m_OffsetX;

                if (e.m_OffsetY > m_Max.Y)
                    m_Max.Y = e.m_OffsetY;

                if (e.m_OffsetZ > m_maxHeight)
                    m_maxHeight = e.m_OffsetZ;
            }

            ConvertList();
            reader.Close();
        }

        public MultiComponentList(string FileName, Multis.ImportType Type)
        {
            m_Min = m_Max = Point.Empty;
            int itemcount;
            switch (Type)
            {
                case Multis.ImportType.TXT:
                    itemcount = 0;
                    using (StreamReader ip = new StreamReader(FileName))
                    {
                        string line;
                        while ((line = ip.ReadLine()) != null)
                        {
                            itemcount++;
                        }
                    }

                    m_SortedTiles = new MultiTileEntry[itemcount];
                    itemcount = 0;
                    m_Min.X = 10000;
                    m_Min.Y = 10000;
                    using (StreamReader ip = new StreamReader(FileName))
                    {
                        string line;
                        while ((line = ip.ReadLine()) != null)
                        {
                            string[] split = line.Split(' ');

                            string tmp = split[0];
                            tmp = tmp.Replace("0x", "");

                            m_SortedTiles[itemcount].m_ItemID =
                                ushort.Parse(tmp, System.Globalization.NumberStyles.HexNumber);
                            m_SortedTiles[itemcount].m_OffsetX = Convert.ToInt16(split[1]);
                            m_SortedTiles[itemcount].m_OffsetY = Convert.ToInt16(split[2]);
                            m_SortedTiles[itemcount].m_OffsetZ = Convert.ToInt16(split[3]);
                            m_SortedTiles[itemcount].m_Flags = Convert.ToInt32(split[4]);
                            m_SortedTiles[itemcount].m_Unk1 = 0;

                            MultiTileEntry e = m_SortedTiles[itemcount];

                            if (e.m_OffsetX < m_Min.X)
                                m_Min.X = e.m_OffsetX;

                            if (e.m_OffsetY < m_Min.Y)
                                m_Min.Y = e.m_OffsetY;

                            if (e.m_OffsetX > m_Max.X)
                                m_Max.X = e.m_OffsetX;

                            if (e.m_OffsetY > m_Max.Y)
                                m_Max.Y = e.m_OffsetY;

                            if (e.m_OffsetZ > m_maxHeight)
                                m_maxHeight = e.m_OffsetZ;

                            itemcount++;
                        }

                        int centerx = m_Max.X - (int) (Math.Round((m_Max.X - m_Min.X) / 2.0));
                        int centery = m_Max.Y - (int) (Math.Round((m_Max.Y - m_Min.Y) / 2.0));

                        m_Min = m_Max = Point.Empty;
                        int i = 0;
                        for (; i < m_SortedTiles.Length; i++)
                        {
                            m_SortedTiles[i].m_OffsetX -= (short) centerx;
                            m_SortedTiles[i].m_OffsetY -= (short) centery;
                            if (m_SortedTiles[i].m_OffsetX < m_Min.X)
                                m_Min.X = m_SortedTiles[i].m_OffsetX;
                            if (m_SortedTiles[i].m_OffsetX > m_Max.X)
                                m_Max.X = m_SortedTiles[i].m_OffsetX;

                            if (m_SortedTiles[i].m_OffsetY < m_Min.Y)
                                m_Min.Y = m_SortedTiles[i].m_OffsetY;
                            if (m_SortedTiles[i].m_OffsetY > m_Max.Y)
                                m_Max.Y = m_SortedTiles[i].m_OffsetY;
                        }
                    }

                    break;
                case Multis.ImportType.UOA:
                    itemcount = 0;

                    using (StreamReader ip = new StreamReader(FileName))
                    {
                        string line;
                        while ((line = ip.ReadLine()) != null)
                        {
                            ++itemcount;
                            if (itemcount == 4)
                            {
                                string[] split = line.Split(' ');
                                itemcount = Convert.ToInt32(split[0]);
                                break;
                            }
                        }
                    }

                    m_SortedTiles = new MultiTileEntry[itemcount];
                    itemcount = 0;
                    m_Min.X = 10000;
                    m_Min.Y = 10000;
                    using (StreamReader ip = new StreamReader(FileName))
                    {
                        string line;
                        int i = -1;
                        while ((line = ip.ReadLine()) != null)
                        {
                            ++i;
                            if (i < 4)
                                continue;
                            string[] split = line.Split(' ');

                            m_SortedTiles[itemcount].m_ItemID = Convert.ToUInt16(split[0]);
                            m_SortedTiles[itemcount].m_OffsetX = Convert.ToInt16(split[1]);
                            m_SortedTiles[itemcount].m_OffsetY = Convert.ToInt16(split[2]);
                            m_SortedTiles[itemcount].m_OffsetZ = Convert.ToInt16(split[3]);
                            m_SortedTiles[itemcount].m_Flags = Convert.ToInt32(split[4]);
                            m_SortedTiles[itemcount].m_Unk1 = 0;

                            MultiTileEntry e = m_SortedTiles[itemcount];

                            if (e.m_OffsetX < m_Min.X)
                                m_Min.X = e.m_OffsetX;

                            if (e.m_OffsetY < m_Min.Y)
                                m_Min.Y = e.m_OffsetY;

                            if (e.m_OffsetX > m_Max.X)
                                m_Max.X = e.m_OffsetX;

                            if (e.m_OffsetY > m_Max.Y)
                                m_Max.Y = e.m_OffsetY;

                            if (e.m_OffsetZ > m_maxHeight)
                                m_maxHeight = e.m_OffsetZ;

                            ++itemcount;
                        }

                        int centerx = m_Max.X - (int) (Math.Round((m_Max.X - m_Min.X) / 2.0));
                        int centery = m_Max.Y - (int) (Math.Round((m_Max.Y - m_Min.Y) / 2.0));

                        m_Min = m_Max = Point.Empty;
                        i = 0;
                        for (; i < m_SortedTiles.Length; ++i)
                        {
                            m_SortedTiles[i].m_OffsetX -= (short) centerx;
                            m_SortedTiles[i].m_OffsetY -= (short) centery;
                            if (m_SortedTiles[i].m_OffsetX < m_Min.X)
                                m_Min.X = m_SortedTiles[i].m_OffsetX;
                            if (m_SortedTiles[i].m_OffsetX > m_Max.X)
                                m_Max.X = m_SortedTiles[i].m_OffsetX;

                            if (m_SortedTiles[i].m_OffsetY < m_Min.Y)
                                m_Min.Y = m_SortedTiles[i].m_OffsetY;
                            if (m_SortedTiles[i].m_OffsetY > m_Max.Y)
                                m_Max.Y = m_SortedTiles[i].m_OffsetY;
                        }
                    }

                    break;
                case Multis.ImportType.UOAB:
                    using (FileStream fs = new FileStream(FileName, FileMode.Open, FileAccess.Read, FileShare.Read))
                    using (BinaryReader reader = new BinaryReader(fs))
                    {
                        if (reader.ReadInt16() != 1) //Version check
                            return;
                        string tmp;
                        tmp = Multis.ReadUOAString(reader); //Name
                        tmp = Multis.ReadUOAString(reader); //Category
                        tmp = Multis.ReadUOAString(reader); //Subsection
                        int width = reader.ReadInt32();
                        int height = reader.ReadInt32();
                        int uwidth = reader.ReadInt32();
                        int uheight = reader.ReadInt32();

                        int count = reader.ReadInt32();
                        itemcount = count;
                        m_SortedTiles = new MultiTileEntry[itemcount];
                        itemcount = 0;
                        m_Min.X = 10000;
                        m_Min.Y = 10000;
                        for (; itemcount < count; ++itemcount)
                        {
                            m_SortedTiles[itemcount].m_ItemID = (ushort) reader.ReadInt16();
                            m_SortedTiles[itemcount].m_OffsetX = reader.ReadInt16();
                            m_SortedTiles[itemcount].m_OffsetY = reader.ReadInt16();
                            m_SortedTiles[itemcount].m_OffsetZ = reader.ReadInt16();
                            reader.ReadInt16(); // level
                            m_SortedTiles[itemcount].m_Flags = 1;
                            reader.ReadInt16(); // hue
                            m_SortedTiles[itemcount].m_Unk1 = 0;

                            MultiTileEntry e = m_SortedTiles[itemcount];

                            if (e.m_OffsetX < m_Min.X)
                                m_Min.X = e.m_OffsetX;

                            if (e.m_OffsetY < m_Min.Y)
                                m_Min.Y = e.m_OffsetY;

                            if (e.m_OffsetX > m_Max.X)
                                m_Max.X = e.m_OffsetX;

                            if (e.m_OffsetY > m_Max.Y)
                                m_Max.Y = e.m_OffsetY;

                            if (e.m_OffsetZ > m_maxHeight)
                                m_maxHeight = e.m_OffsetZ;
                        }

                        int centerx = m_Max.X - (int) (Math.Round((m_Max.X - m_Min.X) / 2.0));
                        int centery = m_Max.Y - (int) (Math.Round((m_Max.Y - m_Min.Y) / 2.0));

                        m_Min = m_Max = Point.Empty;
                        itemcount = 0;
                        for (; itemcount < m_SortedTiles.Length; ++itemcount)
                        {
                            m_SortedTiles[itemcount].m_OffsetX -= (short) centerx;
                            m_SortedTiles[itemcount].m_OffsetY -= (short) centery;
                            if (m_SortedTiles[itemcount].m_OffsetX < m_Min.X)
                                m_Min.X = m_SortedTiles[itemcount].m_OffsetX;
                            if (m_SortedTiles[itemcount].m_OffsetX > m_Max.X)
                                m_Max.X = m_SortedTiles[itemcount].m_OffsetX;

                            if (m_SortedTiles[itemcount].m_OffsetY < m_Min.Y)
                                m_Min.Y = m_SortedTiles[itemcount].m_OffsetY;
                            if (m_SortedTiles[itemcount].m_OffsetY > m_Max.Y)
                                m_Max.Y = m_SortedTiles[itemcount].m_OffsetY;
                        }
                    }

                    break;

                case Multis.ImportType.WSC:
                    itemcount = 0;
                    using (StreamReader ip = new StreamReader(FileName))
                    {
                        string line;
                        while ((line = ip.ReadLine()) != null)
                        {
                            line = line.Trim();
                            if (line.StartsWith("SECTION WORLDITEM"))
                                ++itemcount;
                        }
                    }

                    m_SortedTiles = new MultiTileEntry[itemcount];
                    itemcount = 0;
                    m_Min.X = 10000;
                    m_Min.Y = 10000;
                    using (StreamReader ip = new StreamReader(FileName))
                    {
                        string line;
                        MultiTileEntry tempitem = new MultiTileEntry();
                        tempitem.m_ItemID = 0xFFFF;
                        tempitem.m_Flags = 1;
                        tempitem.m_Unk1 = 0;
                        while ((line = ip.ReadLine()) != null)
                        {
                            line = line.Trim();
                            if (line.StartsWith("SECTION WORLDITEM"))
                            {
                                if (tempitem.m_ItemID != 0xFFFF)
                                {
                                    m_SortedTiles[itemcount] = tempitem;
                                    ++itemcount;
                                }

                                tempitem.m_ItemID = 0xFFFF;
                            }
                            else if (line.StartsWith("ID"))
                            {
                                line = line.Remove(0, 2);
                                line = line.Trim();
                                tempitem.m_ItemID = Convert.ToUInt16(line);
                            }
                            else if (line.StartsWith("X"))
                            {
                                line = line.Remove(0, 1);
                                line = line.Trim();
                                tempitem.m_OffsetX = Convert.ToInt16(line);
                                if (tempitem.m_OffsetX < m_Min.X)
                                    m_Min.X = tempitem.m_OffsetX;
                                if (tempitem.m_OffsetX > m_Max.X)
                                    m_Max.X = tempitem.m_OffsetX;
                            }
                            else if (line.StartsWith("Y"))
                            {
                                line = line.Remove(0, 1);
                                line = line.Trim();
                                tempitem.m_OffsetY = Convert.ToInt16(line);
                                if (tempitem.m_OffsetY < m_Min.Y)
                                    m_Min.Y = tempitem.m_OffsetY;
                                if (tempitem.m_OffsetY > m_Max.Y)
                                    m_Max.Y = tempitem.m_OffsetY;
                            }
                            else if (line.StartsWith("Z"))
                            {
                                line = line.Remove(0, 1);
                                line = line.Trim();
                                tempitem.m_OffsetZ = Convert.ToInt16(line);
                                if (tempitem.m_OffsetZ > m_maxHeight)
                                    m_maxHeight = tempitem.m_OffsetZ;
                            }
                        }

                        if (tempitem.m_ItemID != 0xFFFF)
                            m_SortedTiles[itemcount] = tempitem;

                        int centerx = m_Max.X - (int) (Math.Round((m_Max.X - m_Min.X) / 2.0));
                        int centery = m_Max.Y - (int) (Math.Round((m_Max.Y - m_Min.Y) / 2.0));

                        m_Min = m_Max = Point.Empty;
                        int i = 0;
                        for (; i < m_SortedTiles.Length; i++)
                        {
                            m_SortedTiles[i].m_OffsetX -= (short) centerx;
                            m_SortedTiles[i].m_OffsetY -= (short) centery;
                            if (m_SortedTiles[i].m_OffsetX < m_Min.X)
                                m_Min.X = m_SortedTiles[i].m_OffsetX;
                            if (m_SortedTiles[i].m_OffsetX > m_Max.X)
                                m_Max.X = m_SortedTiles[i].m_OffsetX;

                            if (m_SortedTiles[i].m_OffsetY < m_Min.Y)
                                m_Min.Y = m_SortedTiles[i].m_OffsetY;
                            if (m_SortedTiles[i].m_OffsetY > m_Max.Y)
                                m_Max.Y = m_SortedTiles[i].m_OffsetY;
                        }
                    }

                    break;
            }

            ConvertList();
        }

        public MultiComponentList(List<MultiTileEntry> arr)
        {
            m_Min = m_Max = Point.Empty;
            int itemcount = arr.Count;
            m_SortedTiles = new MultiTileEntry[itemcount];
            m_Min.X = 10000;
            m_Min.Y = 10000;
            int i = 0;
            foreach (MultiTileEntry entry in arr)
            {
                if (entry.m_OffsetX < m_Min.X)
                    m_Min.X = entry.m_OffsetX;

                if (entry.m_OffsetY < m_Min.Y)
                    m_Min.Y = entry.m_OffsetY;

                if (entry.m_OffsetX > m_Max.X)
                    m_Max.X = entry.m_OffsetX;

                if (entry.m_OffsetY > m_Max.Y)
                    m_Max.Y = entry.m_OffsetY;

                if (entry.m_OffsetZ > m_maxHeight)
                    m_maxHeight = entry.m_OffsetZ;
                m_SortedTiles[i] = entry;

                ++i;
            }

            arr.Clear();
            int centerx = m_Max.X - (int) (Math.Round((m_Max.X - m_Min.X) / 2.0));
            int centery = m_Max.Y - (int) (Math.Round((m_Max.Y - m_Min.Y) / 2.0));

            m_Min = m_Max = Point.Empty;
            for (i = 0; i < m_SortedTiles.Length; ++i)
            {
                m_SortedTiles[i].m_OffsetX -= (short) centerx;
                m_SortedTiles[i].m_OffsetY -= (short) centery;
                if (m_SortedTiles[i].m_OffsetX < m_Min.X)
                    m_Min.X = m_SortedTiles[i].m_OffsetX;
                if (m_SortedTiles[i].m_OffsetX > m_Max.X)
                    m_Max.X = m_SortedTiles[i].m_OffsetX;

                if (m_SortedTiles[i].m_OffsetY < m_Min.Y)
                    m_Min.Y = m_SortedTiles[i].m_OffsetY;
                if (m_SortedTiles[i].m_OffsetY > m_Max.Y)
                    m_Max.Y = m_SortedTiles[i].m_OffsetY;
            }

            ConvertList();
        }

        public MultiComponentList(StreamReader stream, int count)
        {
            string line;
            int itemcount = 0;
            m_Min = m_Max = Point.Empty;
            m_SortedTiles = new MultiTileEntry[count];
            m_Min.X = 10000;
            m_Min.Y = 10000;

            while ((line = stream.ReadLine()) != null)
            {
                string[] split = Regex.Split(line, @"\s+");
                m_SortedTiles[itemcount].m_ItemID = Convert.ToUInt16(split[0]);
                m_SortedTiles[itemcount].m_Flags = Convert.ToInt32(split[1]);
                m_SortedTiles[itemcount].m_OffsetX = Convert.ToInt16(split[2]);
                m_SortedTiles[itemcount].m_OffsetY = Convert.ToInt16(split[3]);
                m_SortedTiles[itemcount].m_OffsetZ = Convert.ToInt16(split[4]);
                m_SortedTiles[itemcount].m_Unk1 = 0;

                MultiTileEntry e = m_SortedTiles[itemcount];

                if (e.m_OffsetX < m_Min.X)
                    m_Min.X = e.m_OffsetX;
                if (e.m_OffsetY < m_Min.Y)
                    m_Min.Y = e.m_OffsetY;
                if (e.m_OffsetX > m_Max.X)
                    m_Max.X = e.m_OffsetX;
                if (e.m_OffsetY > m_Max.Y)
                    m_Max.Y = e.m_OffsetY;
                if (e.m_OffsetZ > m_maxHeight)
                    m_maxHeight = e.m_OffsetZ;

                ++itemcount;
                if (itemcount == count)
                    break;
            }

            int centerx = m_Max.X - (int) (Math.Round((m_Max.X - m_Min.X) / 2.0));
            int centery = m_Max.Y - (int) (Math.Round((m_Max.Y - m_Min.Y) / 2.0));

            m_Min = m_Max = Point.Empty;
            int i = 0;
            for (; i < m_SortedTiles.Length; i++)
            {
                m_SortedTiles[i].m_OffsetX -= (short) centerx;
                m_SortedTiles[i].m_OffsetY -= (short) centery;
                if (m_SortedTiles[i].m_OffsetX < m_Min.X)
                    m_Min.X = m_SortedTiles[i].m_OffsetX;
                if (m_SortedTiles[i].m_OffsetX > m_Max.X)
                    m_Max.X = m_SortedTiles[i].m_OffsetX;

                if (m_SortedTiles[i].m_OffsetY < m_Min.Y)
                    m_Min.Y = m_SortedTiles[i].m_OffsetY;
                if (m_SortedTiles[i].m_OffsetY > m_Max.Y)
                    m_Max.Y = m_SortedTiles[i].m_OffsetY;
            }

            ConvertList();
        }

        private void ConvertList()
        {
            m_Center = new Point(-m_Min.X, -m_Min.Y);
            m_Width = (m_Max.X - m_Min.X) + 1;
            m_Height = (m_Max.Y - m_Min.Y) + 1;

            MTileList[][] tiles = new MTileList[m_Width][];
            m_Tiles = new MTile[m_Width][][];

            for (int x = 0; x < m_Width; ++x)
            {
                tiles[x] = new MTileList[m_Height];
                m_Tiles[x] = new MTile[m_Height][];

                for (int y = 0; y < m_Height; ++y)
                    tiles[x][y] = new MTileList();
            }

            for (int i = 0; i < m_SortedTiles.Length; ++i)
            {
                int xOffset = m_SortedTiles[i].m_OffsetX + m_Center.X;
                int yOffset = m_SortedTiles[i].m_OffsetY + m_Center.Y;

                tiles[xOffset][yOffset].Add((ushort) (m_SortedTiles[i].m_ItemID), (sbyte) m_SortedTiles[i].m_OffsetZ,
                    (sbyte) m_SortedTiles[i].m_Flags, m_SortedTiles[i].m_Unk1);
            }

            m_Surface = 0;

            for (int x = 0; x < m_Width; ++x)
            {
                for (int y = 0; y < m_Height; ++y)
                {
                    m_Tiles[x][y] = tiles[x][y].ToArray();
                    for (int i = 0; i < m_Tiles[x][y].Length; ++i)
                        m_Tiles[x][y][i].Solver = i;
                    if (m_Tiles[x][y].Length > 1)
                        Array.Sort(m_Tiles[x][y]);
                    if (m_Tiles[x][y].Length > 0)
                        ++m_Surface;
                }
            }
        }

        public MultiComponentList(MTileList[][] newtiles, int count, int width, int height)
        {
            m_Min = m_Max = Point.Empty;
            m_SortedTiles = new MultiTileEntry[count];
            m_Center = new Point((int) (Math.Round((width / 2.0))) - 1, (int) (Math.Round((height / 2.0))) - 1);
            if (m_Center.X < 0)
                m_Center.X = width / 2;
            if (m_Center.Y < 0)
                m_Center.Y = height / 2;
            m_maxHeight = -128;

            int counter = 0;
            for (int x = 0; x < width; ++x)
            {
                for (int y = 0; y < height; ++y)
                {
                    MTile[] tiles = newtiles[x][y].ToArray();
                    for (int i = 0; i < tiles.Length; ++i)
                    {
                        m_SortedTiles[counter].m_ItemID = (ushort) (tiles[i].ID);
                        m_SortedTiles[counter].m_OffsetX = (short) (x - m_Center.X);
                        m_SortedTiles[counter].m_OffsetY = (short) (y - m_Center.Y);
                        m_SortedTiles[counter].m_OffsetZ = (short) (tiles[i].Z);
                        m_SortedTiles[counter].m_Flags = (int) tiles[i].Flag;
                        m_SortedTiles[counter].m_Unk1 = 0;

                        if (m_SortedTiles[counter].m_OffsetX < m_Min.X)
                            m_Min.X = m_SortedTiles[counter].m_OffsetX;
                        if (m_SortedTiles[counter].m_OffsetX > m_Max.X)
                            m_Max.X = m_SortedTiles[counter].m_OffsetX;
                        if (m_SortedTiles[counter].m_OffsetY < m_Min.Y)
                            m_Min.Y = m_SortedTiles[counter].m_OffsetY;
                        if (m_SortedTiles[counter].m_OffsetY > m_Max.Y)
                            m_Max.Y = m_SortedTiles[counter].m_OffsetY;
                        if (m_SortedTiles[counter].m_OffsetZ > m_maxHeight)
                            m_maxHeight = m_SortedTiles[counter].m_OffsetZ;
                        ++counter;
                    }
                }
            }

            ConvertList();
        }

        private MultiComponentList()
        {
            m_Tiles = new MTile[0][][];
        }

        public void ExportToTextFile(string FileName)
        {
            using (StreamWriter Tex = new StreamWriter(new FileStream(FileName, FileMode.Create, FileAccess.ReadWrite),
                System.Text.Encoding.GetEncoding(1252)))
            {
                for (int i = 0; i < m_SortedTiles.Length; ++i)
                {
                    Tex.WriteLine(
                        $"0x{m_SortedTiles[i].m_ItemID:X} {m_SortedTiles[i].m_OffsetX} {m_SortedTiles[i].m_OffsetY} {m_SortedTiles[i].m_OffsetZ} {m_SortedTiles[i].m_Flags}");
                }
            }
        }

        public void ExportToWscFile(string FileName)
        {
            using (StreamWriter Tex = new StreamWriter(new FileStream(FileName, FileMode.Create, FileAccess.ReadWrite),
                System.Text.Encoding.GetEncoding(1252)))
            {
                for (int i = 0; i < m_SortedTiles.Length; ++i)
                {
                    Tex.WriteLine($"SECTION WORLDITEM {i}");
                    Tex.WriteLine("{");
                    Tex.WriteLine($"\tID\t{m_SortedTiles[i].m_ItemID}");
                    Tex.WriteLine($"\tX\t{m_SortedTiles[i].m_OffsetX}");
                    Tex.WriteLine($"\tY\t{m_SortedTiles[i].m_OffsetY}");
                    Tex.WriteLine($"\tZ\t{m_SortedTiles[i].m_OffsetZ}");
                    Tex.WriteLine("\tColor\t0");
                    Tex.WriteLine("}");
                }
            }
        }

        public void ExportToUOAFile(string FileName)
        {
            using (StreamWriter Tex = new StreamWriter(new FileStream(FileName, FileMode.Create, FileAccess.ReadWrite),
                System.Text.Encoding.GetEncoding(1252)))
            {
                Tex.WriteLine("6 version");
                Tex.WriteLine("1 template id");
                Tex.WriteLine("-1 item version");
                Tex.WriteLine($"{m_SortedTiles.Length} num components");
                for (int i = 0; i < m_SortedTiles.Length; ++i)
                {
                    Tex.WriteLine(
                        $"{m_SortedTiles[i].m_ItemID} {m_SortedTiles[i].m_OffsetX} {m_SortedTiles[i].m_OffsetY} {m_SortedTiles[i].m_OffsetZ} {m_SortedTiles[i].m_Flags}");
                }
            }
        }
    }
}

================================================
FILE: Razor/UltimaSDK/NativeMethods.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;

namespace Ultima
{
    public static class NativeMethods
    {
        [DllImport("User32")]
        public static extern int IsWindow(ClientWindowHandle window);

        [DllImport("User32")]
        public static extern int GetWindowThreadProcessId(ClientWindowHandle window, ref ClientProcessHandle processID);

        [DllImport("Kernel32")]
        public unsafe static extern int _lread(SafeFileHandle hFile, void* lpBuffer, int wBytes);

        [DllImport("Kernel32")]
        public static extern ClientProcessHandle OpenProcess(int desiredAccess, int inheritClientHandle,
            ClientProcessHandle processID);

        [DllImport("Kernel32")]
        public static extern int CloseHandle(ClientProcessHandle handle);

        [DllImport("Kernel32")]
        public static unsafe extern int ReadProcessMemory(ClientProcessHandle process, int baseAddress, void* buffer,
            int size, ref int op);

        [DllImport("Kernel32")]
        public static unsafe extern int WriteProcessMemory(ClientProcessHandle process, int baseAddress, void* buffer,
            int size, int nullMe);

        [DllImport("User32")]
        public static extern int SetForegroundWindow(ClientWindowHandle hWnd);

        [DllImport("User32")]
        public static extern int SendMessage(ClientWindowHandle hWnd, int wMsg, int wParam, int lParam);

        [DllImport("User32")]
        public static extern bool PostMessage(ClientWindowHandle hWnd, int wMsg, int wParam, int lParam);

        [DllImport("User32")]
        public static extern int OemKeyScan(int wOemChar);

        [DllImport("user32")]
        public static extern ClientWindowHandle FindWindowA(string lpClassName, string lpWindowName);

        /// <summary>
        /// Swaps from Big to LittleEndian and vise versa
        /// </summary>
        /// <param name="x"></param>
        /// <returns></returns>
        public static short SwapEndian(short x)
        {
            ushort y = (ushort) x;
            return (short) ((y >> 8) | (y << 8));
        }

        private static byte[] m_StringBuffer;

        public unsafe static string ReadNameString(byte* buffer, int len)
        {
            if ((m_StringBuffer == null) || (m_StringBuffer.Length < len))
                m_StringBuffer = new byte[20];
            int count;
            for (count = 0; count < len && *buffer != 0; ++count)
                m_StringBuffer[count] = *buffer++;

            return System.Text.Encoding.Default.GetString(m_StringBuffer, 0, count);
        }

        public unsafe static string ReadNameString(byte[] buffer, int len)
        {
            int count;
            for (count = 0; count < 20 && buffer[count] != 0; ++count) ;
            return System.Text.Encoding.Default.GetString(buffer, 0, count);
        }
    }
}

================================================
FILE: Razor/UltimaSDK/ProcessStream.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.IO;

namespace Ultima
{
    public unsafe abstract class ProcessStream : Stream
    {
        private const int ProcessAllAccess = 0x1F0FFF;

        protected bool m_Open;
        protected ClientProcessHandle m_Process;

        protected int m_Position;

        public abstract ClientProcessHandle ProcessID { get; }

        public ProcessStream()
        {
        }

        public virtual bool BeginAccess()
        {
            if (m_Open)
                return false;

            m_Process = NativeMethods.OpenProcess(ProcessAllAccess, 0, ProcessID);
            m_Open = true;

            return true;
        }

        public virtual void EndAccess()
        {
            if (!m_Open)
                return;

            m_Process.Close();
            m_Open = false;
        }

        public override void Flush()
        {
        }

        public override int Read(byte[] buffer, int offset, int count)
        {
            bool end = !BeginAccess();

            int res = 0;

            fixed (byte* p = buffer)
                NativeMethods.ReadProcessMemory(m_Process, m_Position, p + offset, count, ref res);

            m_Position += count;

            if (end)
                EndAccess();

            return res;
        }

        public override void Write(byte[] buffer, int offset, int count)
        {
            bool end = !BeginAccess();

            fixed (byte* p = buffer)
                NativeMethods.WriteProcessMemory(m_Process, m_Position, p + offset, count, 0);

            m_Position += count;

            if (end)
                EndAccess();
        }

        public override bool CanRead
        {
            get { return true; }
        }

        public override bool CanWrite
        {
            get { return true; }
        }

        public override bool CanSeek
        {
            get { return true; }
        }

        public override long Length
        {
            get { throw new NotSupportedException(); }
        }

        public override long Position
        {
            get { return m_Position; }
            set { m_Position = (int) value; }
        }

        public override void SetLength(long value)
        {
            throw new NotSupportedException();
        }

        public override long Seek(long offset, SeekOrigin origin)
        {
            switch (origin)
            {
                case SeekOrigin.Begin:
                    m_Position = (int) offset;
                    break;
                case SeekOrigin.Current:
                    m_Position += (int) offset;
                    break;
                case SeekOrigin.End: throw new NotSupportedException();
            }

            return m_Position;
        }
    }
}

================================================
FILE: Razor/UltimaSDK/RadarCol.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.IO;
using System.Runtime.InteropServices;

namespace Ultima
{
    public sealed class RadarCol
    {
        static RadarCol()
        {
            Initialize();
        }

        private static short[] m_Colors;

        public static short[] Colors
        {
            get { return m_Colors; }
        }

        public static short GetItemColor(int index)
        {
            if (index + 0x4000 < m_Colors.Length)
                return m_Colors[index + 0x4000];
            return 0;
        }

        public static short GetLandColor(int index)
        {
            if (index < m_Colors.Length)
                return m_Colors[index];
            return 0;
        }

        public static void SetItemColor(int index, short value)
        {
            m_Colors[index + 0x4000] = value;
        }

        public static void SetLandColor(int index, short value)
        {
            m_Colors[index] = value;
        }

        public static void Initialize()
        {
            string path = Files.GetFilePath("radarcol.mul");
            if (path != null)
            {
                using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read))
                {
                    m_Colors = new short[fs.Length / 2];
                    GCHandle gc = GCHandle.Alloc(m_Colors, GCHandleType.Pinned);
                    byte[] buffer = new byte[(int) fs.Length];
                    fs.Read(buffer, 0, (int) fs.Length);
                    Marshal.Copy(buffer, 0, gc.AddrOfPinnedObject(), (int) fs.Length);
                    gc.Free();
                }
            }
            else
                m_Colors = new short[0x8000];
        }

        public static void Save(string FileName)
        {
            using (FileStream fs = new FileStream(FileName, FileMode.Create, FileAccess.Write, FileShare.Write))
            {
                using (BinaryWriter bin = new BinaryWriter(fs))
                {
                    for (int i = 0; i < m_Colors.Length; ++i)
                    {
                        bin.Write(m_Colors[i]);
                    }
                }
            }
        }

        public static void ExportToCSV(string FileName)
        {
            using (StreamWriter Tex = new StreamWriter(new FileStream(FileName, FileMode.Create, FileAccess.ReadWrite),
                System.Text.Encoding.GetEncoding(1252)))
            {
                Tex.WriteLine("ID;Color");

                for (int i = 0; i < m_Colors.Length; ++i)
                {
                    Tex.WriteLine($"0x{i:X4};{m_Colors[i]}");
                }
            }
        }

        public static void ImportFromCSV(string FileName)
        {
            if (!File.Exists(FileName))
                return;
            using (StreamReader sr = new StreamReader(FileName))
            {
                string line;
                int count = 0;
                while ((line = sr.ReadLine()) != null)
                {
                    if ((line = line.Trim()).Length == 0 || line.StartsWith("#"))
                        continue;
                    if (line.StartsWith("ID;"))
                        continue;
                    ++count;
                }

                m_Colors = new short[count];
            }

            using (StreamReader sr = new StreamReader(FileName))
            {
                string line;
                while ((line = sr.ReadLine()) != null)
                {
                    if ((line = line.Trim()).Length == 0 || line.StartsWith("#"))
                        continue;
                    if (line.StartsWith("ID;"))
                        continue;
                    try
                    {
                        string[] split = line.Split(';');
                        if (split.Length < 2)
                            continue;

                        int id = ConvertStringToInt(split[0]);
                        int color = ConvertStringToInt(split[1]);
                        m_Colors[id] = (short) color;
                    }
                    catch
                    {
                    }
                }
            }
        }

        private static int ConvertStringToInt(string text)
        {
            int result;
            if (text.Contains("0x"))
            {
                string convert = text.Replace("0x", "");
                int.TryParse(convert, System.Globalization.NumberStyles.HexNumber, null, out result);
            }
            else
                int.TryParse(text, System.Globalization.NumberStyles.Integer, null, out result);

            return result;
        }
    }
}

================================================
FILE: Razor/UltimaSDK/SkillGroups.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;

namespace Ultima
{
    public sealed class SkillGroup
    {
        public string Name { get; set; }

        public SkillGroup(string name)
        {
            Name = name;
        }
    }

    public sealed class SkillGroups
    {
        public static List<SkillGroup> List { get; private set; }
        public static List<int> SkillList { get; private set; }
        private static bool unicode = false;

        static SkillGroups()
        {
            Initialize();
        }

        public static void Initialize()
        {
            string path = Files.GetFilePath("skillgrp.mul");

            List = new List<SkillGroup>();
            SkillList = new List<int>();

            if (path != null)
            {
                using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read))
                {
                    using (BinaryReader bin = new BinaryReader(fs))
                    {
                        int start = 4;
                        int strlen = 17;
                        int count = bin.ReadInt32();
                        if (count == -1)
                        {
                            unicode = true;
                            count = bin.ReadInt32();
                            start *= 2;
                            strlen *= 2;
                        }

                        List.Add(new SkillGroup("Misc"));
                        for (int i = 0; i < count - 1; ++i)
                        {
                            int strbuild;
                            fs.Seek((long) (start + (i * strlen)), SeekOrigin.Begin);
                            StringBuilder builder2 = new StringBuilder(17);
                            if (unicode)
                            {
                                while ((strbuild = bin.ReadInt16()) != 0)
                                    builder2.Append((char) strbuild);
                            }
                            else
                            {
                                while ((strbuild = bin.ReadByte()) != 0)
                                    builder2.Append((char) strbuild);
                            }

                            List.Add(new SkillGroup(builder2.ToString()));
                        }

                        fs.Seek((long) (start + ((count - 1) * strlen)), SeekOrigin.Begin);
                        try
                        {
                            while (bin.BaseStream.Length != bin.BaseStream.Position)
                                SkillList.Add(bin.ReadInt32());
                        }
                        catch // just for safety
                        {
                        }
                    }
                }
            }
        }

        public static void Save(string path)
        {
            string mul = Path.Combine(path, "skillgrp.mul");
            using (FileStream fs = new FileStream(mul, FileMode.Create, FileAccess.Write, FileShare.Write))
            {
                using (BinaryWriter bin = new BinaryWriter(fs))
                {
                    if (unicode)
                        bin.Write((int) -1);
                    bin.Write((int) List.Count);

                    foreach (SkillGroup group in List)
                    {
                        if (group.Name == "Misc")
                            continue;
                        byte[] name;
                        if (unicode)
                            name = new byte[34];
                        else
                            name = new byte[17];
                        if (group.Name != null)
                        {
                            if (unicode)
                            {
                                byte[] bb = Encoding.Unicode.GetBytes(group.Name);
                                if (bb.Length > 34)
                                    Array.Resize(ref bb, 34);
                                bb.CopyTo(name, 0);
                            }
                            else
                            {
                                byte[] bb = Encoding.Default.GetBytes(group.Name);
                                if (bb.Length > 17)
                                    Array.Resize(ref bb, 17);
                                bb.CopyTo(name, 0);
                            }
                        }

                        bin.Write(name);
                    }

                    foreach (int group in SkillList)
                        bin.Write(group);
                }
            }
        }
    }
}

================================================
FILE: Razor/UltimaSDK/Skills.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using Assistant;

namespace Ultima
{
    public sealed class Skills
    {
        private static FileIndex _fileIndex = new FileIndex("skills.idx", "skills.mul", 16);
        public static Dictionary<string, SkillInfo> SkillsByName { get; private set; }
        public static Dictionary<int, SkillInfo> SkillsByIndex { get; private set; }

        public static int StealthIndex { get; private set; }
        public static int MageryIndex { get; private set; }

        public static void Initialize()
        {
            Load();
        }
        
        public Skills()
        {
        }

        /// <summary>
        /// ReReads skills.mul
        /// </summary>
        private static void Load()
        {
            _fileIndex = new FileIndex("skills.idx", "skills.mul", 16);

            SkillsByIndex = new Dictionary<int, SkillInfo>();
            SkillsByName = new Dictionary<string, SkillInfo>(StringComparer.OrdinalIgnoreCase);

            for (int i = 0; i < _fileIndex.Index.Length; ++i)
            {
                SkillInfo info = GetSkill(i);

                if (info == null)
                    break;

                SkillsByIndex.Add(i, info);
                SkillsByName.Add(info.Name.Replace(" ", string.Empty), info);
                
                switch (info.Name)
                {
                    case "Magery":
                        MageryIndex = i;
                        break;
                    case "Stealth":
                        StealthIndex = i;
                        break;
                    case "Item Identification":
                        SkillsByName.Add("itemid", info);
                        break;
                    case "Evaluating Intelligence":
                        SkillsByName.Add("evalint", info);
                        break;
                    case "Forensic Evaluation":
                        SkillsByName.Add("forensiceval", info);
                        SkillsByName.Add("forensic", info);
                        break;
                    case "Provocation":
                        SkillsByName.Add("provo", info);
                        break;
                    case "Spirit Speak":
                        SkillsByName.Add("spirit", info);
                        break;
                    case "Taste Identification":
                        SkillsByName.Add("tasteid", info);
                        break;
                }
            }
        }

        public static List<int> GetUsableSkillIndexes()
        {
            if (SkillsByIndex == null)
            {
                Load();
            }

            List<int> indexes = new List<int>();

            foreach (KeyValuePair<int, SkillInfo> keyValuePair in SkillsByIndex)
            {
                if (keyValuePair.Value.IsAction)
                {
                    indexes.Add(keyValuePair.Key);
                }
            }

            return indexes;
        }

        public static List<string> GetUsableSkillNames()
        {
            if (SkillsByName == null)
            {
                Load();
            }

            List<string> names = new List<string>();

            foreach (KeyValuePair<string, SkillInfo> keyValuePair in SkillsByName)
            {
                if (keyValuePair.Value.IsAction)
                {
                    names.Add(keyValuePair.Key);
                }
            }

            return names;
        }

        public static string GetSkillDisplayName(int index)
        {
            if (SkillsByIndex.TryGetValue(index, out SkillInfo skill))
            {
                return skill.DisplayName;
            }

            return string.Empty;
        }

        public static int TotalSkills()
        {
            return SkillsByIndex.Count;
        }

        /// <summary>
        /// Returns <see cref="SkillInfo"/> of index
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        private static SkillInfo GetSkill(int index)
        {
            Stream stream = _fileIndex.Seek(index, out int length, out int extra, out bool patched);
            
            if (stream != null)
            {
                if (length == 0)
                    return null;

                using (BinaryReader bin = new BinaryReader(stream))
                {
                    bool action = bin.ReadBoolean();
                    string name = ReadNameString(bin, length - 1);
                    string displayName = Language.GetSkillCliloc(index);
                    return new SkillInfo(index, name, displayName, action, extra);
                }
            }

            return null;
        }

        private static readonly byte[] StringBuffer = new byte[1024];

        private static string ReadNameString(BinaryReader bin, int length)
        {
            bin.Read(StringBuffer, 0, length);
            int count;
            for (count = 0; count < length && StringBuffer[count] != 0; ++count) ;

            return Encoding.Default.GetString(StringBuffer, 0, count);
        }

        public static void Save(string path)
        {
            string idx = Path.Combine(path, "skills.idx");
            string mul = Path.Combine(path, "skills.mul");

            using (FileStream fsSkillsIndex = new FileStream(idx, FileMode.Create, FileAccess.Write, FileShare.Write), fsSkillsMul = new FileStream(mul, FileMode.Create, FileAccess.Write, FileShare.Write))
            {
                using (BinaryWriter binSkillsIndex = new BinaryWriter(fsSkillsIndex), binSkillsMul = new BinaryWriter(fsSkillsMul))
                {
                    for (int i = 0; i < _fileIndex.Index.Length; ++i)
                    {
                        if (SkillsByIndex.TryGetValue(i, out SkillInfo skill))
                        {
                            binSkillsIndex.Write((int)fsSkillsMul.Position); //lookup
                            int length = (int)fsSkillsMul.Position;
                            binSkillsMul.Write(skill.IsAction);

                            byte[] namebytes = Encoding.Default.GetBytes(skill.Name);
                            binSkillsMul.Write(namebytes);
                            binSkillsMul.Write((byte)0); //nullterminated

                            length = (int)fsSkillsMul.Position - length;
                            binSkillsIndex.Write(length);
                            binSkillsIndex.Write(skill.Extra);
                        }
                        else
                        {
                            binSkillsIndex.Write((int)-1); // lookup
                            binSkillsIndex.Write((int)0); // length
                            binSkillsIndex.Write((int)0); // extra
                        }
                    }
                }
            }
        }
    }

    public sealed class SkillInfo
    {
        public int Index { get; set; }
        public bool IsAction { get; set; }

        public string Name { get; set; }
        public string DisplayName { get; set; }

        public int Extra { get; private set; }


        public SkillInfo(int nr, string name, string displayName, bool action, int extra)
        {
            Index = nr;
            Name = name;
            DisplayName = displayName;
            IsAction = action;
            Extra = extra;
        }
    }
}

================================================
FILE: Razor/UltimaSDK/Sound.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;

namespace Ultima
{
    public sealed class UOSound
    {
        public string Name;
        public int ID;
        public byte[] buffer;

        public UOSound(string name, int id, byte[] buff)
        {
            Name = name;
            ID = id;
            buffer = buff;
        }
    };

    public static class Sounds
    {
        private static Dictionary<int, int> m_Translations;
        private static FileIndex m_FileIndex;
        private static UOSound[] m_Cache;
        private static bool[] m_Removed;

        static Sounds()
        {
            Initialize();
        }

        /// <summary>
        /// Reads Sounds and def
        /// </summary>
        public static void Initialize()
        {
            m_Cache = new UOSound[0xFFF];
            m_Removed = new bool[0xFFF];
            m_FileIndex = new FileIndex("soundidx.mul", "sound.mul", "soundLegacyMUL.uop", 0xFFF, 8, ".dat", -1, false);
            Regex reg = new Regex(@"(\d{1,3}) \x7B(\d{1,3})\x7D (\d{1,3})", RegexOptions.Compiled);

            m_Translations = new Dictionary<int, int>();

            string line;
            string path = Files.GetFilePath("Sound.def");
            if (path == null)
                return;
            using (StreamReader reader = new StreamReader(path))
            {
                while ((line = reader.ReadLine()) != null)
                {
                    if (((line = line.Trim()).Length != 0) && !line.StartsWith("#"))
                    {
                        Match match = reg.Match(line);

                        if (match.Success)
                            m_Translations.Add(int.Parse(match.Groups[1].Value), int.Parse(match.Groups[2].Value));
                    }
                }
            }
        }

        /// <summary>
        /// Returns <see cref="UOSound"/> of ID
        /// </summary>
        /// <param name="soundID"></param>
        /// <returns></returns>
        public static UOSound GetSound(int soundID)
        {
            bool translated;
            return GetSound(soundID, out translated);
        }

        /// <summary>
        /// Returns <see cref="UOSound"/> of ID with bool translated in .def
        /// </summary>
        /// <param name="soundID"></param>
        /// <param name="translated"></param>
        /// <returns></returns>
        public static UOSound GetSound(int soundID, out bool translated)
        {
            translated = false;
            if (soundID < 0)
                return null;
            if (m_Cache[soundID] != null)
                return m_Cache[soundID];

            int length, extra;
            bool patched;
            Stream stream = m_FileIndex.Seek(soundID, out length, out extra, out patched);

            if ((m_FileIndex.Index[soundID].lookup < 0) || (length <= 0))
            {
                if (!m_Translations.TryGetValue(soundID, out soundID))
                    return null;

                translated = true;
                stream = m_FileIndex.Seek(soundID, out length, out extra, out patched);
            }

            if (stream == null)
                return null;

            length -= 32;
            int[] waveHeader = WaveHeader(length);

            byte[] stringBuffer = new byte[32];
            byte[] buffer = new byte[length];

            stream.Read(stringBuffer, 0, 32);
            stream.Read(buffer, 0, length);
            stream.Close();

            byte[] resultBuffer = new byte[buffer.Length + (waveHeader.Length << 2)];

            Buffer.BlockCopy(waveHeader, 0, resultBuffer, 0, (waveHeader.Length << 2));
            Buffer.BlockCopy(buffer, 0, resultBuffer, (waveHeader.Length << 2), buffer.Length);

            string
                str = Encoding.ASCII
                    .GetString(stringBuffer); // seems that the null terminator's not being properly recognized :/
            if (str.IndexOf('\0') > 0)
                str = str.Substring(0, str.IndexOf('\0'));
            UOSound sound = new UOSound(str, soundID, resultBuffer);

            if (Files.CacheData)
            {
                if (!translated) // no .def definition
                    m_Cache[soundID] = sound;
            }

            return sound;
        }

        private static int[] WaveHeader(int length)
        {
            /* ====================
             * = WAVE File layout =
             * ====================
             * char[4] = 'RIFF' \
             * int - chunk size |- Riff Header
             * char[4] = 'WAVE' /
             * char[4] = 'fmt ' \
             * int - chunk size |
             * short - format	|
             * short - channels	|
             * int - samples p/s|- Format header
             * int - avg bytes	|
             * short - align	|
             * short - bits p/s /
             * char[4] - data	\
             * int - chunk size | - Data header
             * short[..] - data /
             * ====================
             * */
            return new int[]
            {
                0x46464952, (length + 36), 0x45564157, 0x20746D66, 0x10, 0x010001, 0x5622, 0xAC44, 0x100002, 0x61746164,
                length
            };
        }

        /// <summary>
        /// Returns Soundname and tests if valid
        /// </summary>
        /// <param name="soundID"></param>
        /// <returns></returns>
        public static bool IsValidSound(int soundID, out string name)
        {
            name = "";
            if (soundID < 0)
                return false;
            int length, extra;
            bool patched;
            Stream stream = m_FileIndex.Seek(soundID, out length, out extra, out patched);

            if ((m_FileIndex.Index[soundID].lookup < 0) || (length <= 0))
            {
                if (!m_Translations.TryGetValue(soundID, out soundID))
                    return false;

                stream = m_FileIndex.Seek(soundID, out length, out extra, out patched);
            }

            if (stream == null)
                return false;

            byte[] stringBuffer = new byte[32];
            stream.Read(stringBuffer, 0, 32);
            stream.Close();
            name = Encoding.ASCII
                .GetString(stringBuffer); // seems that the null terminator's not being properly recognized :/
            if (name.IndexOf('\0') > 0)
                name = name.Substring(0, name.IndexOf('\0'));
            return true;
        }

        /// <summary>
        /// Returns length of SoundID
        /// </summary>
        /// <param name="soundID"></param>
        /// <returns></returns>
        public static double GetSoundLength(int soundID)
        {
            if (soundID < 0)
                return 0;
            double len;
            if (m_Cache[soundID] != null)
            {
                len = (double) m_Cache[soundID].buffer.Length;
                len -= 44; //wavheaderlength
            }
            else
            {
                int length, extra;
                bool patched;
                Stream stream = m_FileIndex.Seek(soundID, out length, out extra, out patched);
                if ((m_FileIndex.Index[soundID].lookup < 0) || (length <= 0))
                {
                    if (!m_Translations.TryGetValue(soundID, out soundID))
                        return 0;

                    stream = m_FileIndex.Seek(soundID, out length, out extra, out patched);
                }

                if (stream == null)
                    return 0;
                stream.Close();
                length -= 32; //mulheaderlength
                len = (double) length;
            }

            len /= 0x5622; // Sample Rate
            len /= 2;
            return len;
        }

        public static void Add(int id, string name, string file)
        {
            using (FileStream wav = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                byte[] resultBuffer = new byte[wav.Length];
                wav.Seek(0, SeekOrigin.Begin);
                wav.Read(resultBuffer, 0, (int) wav.Length);

                m_Cache[id] = new UOSound(name, id, resultBuffer);
                m_Removed[id] = false;
            }
        }

        public static void Remove(int id)
        {
            m_Removed[id] = true;
            m_Cache[id] = null;
        }

        public static void Save(string path)
        {
            string idx = Path.Combine(path, "soundidx.mul");
            string mul = Path.Combine(path, "sound.mul");
            int Headerlength = 44;
            using (FileStream fsidx = new FileStream(idx, FileMode.Create, FileAccess.Write, FileShare.Write),
                fsmul = new FileStream(mul, FileMode.Create, FileAccess.Write, FileShare.Write))
            {
                using (BinaryWriter binidx = new BinaryWriter(fsidx),
                    binmul = new BinaryWriter(fsmul))
                {
                    for (int i = 0; i < m_Cache.Length; ++i)
                    {
                        UOSound sound = m_Cache[i];
                        if ((sound == null) && (!m_Removed[i]))
                        {
                            bool trans;
                            sound = GetSound(i, out trans);
                            if (!trans)
                                m_Cache[i] = sound;
                            else
                                sound = null;
                        }

                        if ((sound == null) || (m_Removed[i]))
                        {
                            binidx.Write((int) -1); // lookup
                            binidx.Write((int) -1); // length
                            binidx.Write((int) -1); // extra
                        }
                        else
                        {
                            binidx.Write((int) fsmul.Position); //lookup
                            int length = (int) fsmul.Position;

                            byte[] b = new byte[32];
                            if (sound.Name != null)
                            {
                                byte[] bb = Encoding.Default.GetBytes(sound.Name);
                                if (bb.Length > 32)
                                    Array.Resize(ref bb, 32);
                                bb.CopyTo(b, 0);
                            }

                            binmul.Write(b);
                            using (MemoryStream m = new MemoryStream(sound.buffer))
                            {
                                m.Seek(Headerlength, SeekOrigin.Begin);
                                byte[] resultBuffer = new byte[m.Length - Headerlength];
                                m.Read(resultBuffer, 0, (int) m.Length - Headerlength);
                                binmul.Write(resultBuffer);
                            }

                            length = (int) fsmul.Position - length;
                            binidx.Write(length);
                            binidx.Write(i + 1);
                        }
                    }
                }
            }
        }

        public static void SaveSoundListToCSV(string FileName)
        {
            using (StreamWriter Tex = new StreamWriter(new FileStream(FileName, FileMode.Create, FileAccess.ReadWrite),
                System.Text.Encoding.GetEncoding(1252)))
            {
                Tex.WriteLine("ID;Name;Length");
                string name = "";
                for (int i = 1; i <= 0xFFF; ++i)
                {
                    if (IsValidSound(i - 1, out name))
                    {
                        Tex.Write($"0x{i:X3}");
                        Tex.Write($";{name}");
                        Tex.WriteLine($";{GetSoundLength(i - 1):f}");
                    }
                }
            }
        }
    }
}

================================================
FILE: Razor/UltimaSDK/SpeechList.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Runtime.InteropServices;
using System.Text;

namespace Ultima
{
    public sealed class SpeechList
    {
        public static List<SpeechEntry> Entries { get; set; }

        private static byte[] m_Buffer = new byte[128];

        static SpeechList()
        {
            Initialize();
        }

        /// <summary>
        /// Loads speech.mul in <see cref="SpeechList.Entries"/>
        /// </summary>
        public static void Initialize()
        {
            string path = Files.GetFilePath("speech.mul");
            if (path == null)
            {
                Entries = new List<SpeechEntry>(0);
                return;
            }

            Entries = new List<SpeechEntry>();
            using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                byte[] buffer = new byte[fs.Length];
                unsafe
                {
                    int order = 0;
                    fs.Read(buffer, 0, buffer.Length);
                    fixed (byte* data = buffer)
                    {
                        byte* bindat = (byte*) data;
                        byte* bindatend = bindat + buffer.Length;

                        while (bindat != bindatend)
                        {
                            short id = (short) ((*bindat++ >> 8) | (*bindat++)); //Swapped Endian
                            short length = (short) ((*bindat++ >> 8) | (*bindat++));
                            if (length > 128)
                                length = 128;
                            for (int i = 0; i < length; ++i)
                                m_Buffer[i] = *bindat++;
                            string keyword = Encoding.UTF8.GetString(m_Buffer, 0, length);
                            Entries.Add(new SpeechEntry(id, keyword, order));
                            ++order;
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Saves speech.mul to <see cref="FileName"/>
        /// </summary>
        /// <param name="FileName"></param>
        public static void SaveSpeechList(string FileName)
        {
            Entries.Sort(new OrderComparer());
            using (FileStream fs = new FileStream(FileName, FileMode.Create, FileAccess.Write, FileShare.Write))
            {
                using (BinaryWriter bin = new BinaryWriter(fs))
                {
                    foreach (SpeechEntry entry in Entries)
                    {
                        bin.Write(NativeMethods.SwapEndian(entry.ID));
                        byte[] utf8String = Encoding.UTF8.GetBytes(entry.KeyWord);
                        short length = (short) utf8String.Length;
                        bin.Write(NativeMethods.SwapEndian(length));
                        bin.Write(utf8String);
                    }
                }
            }
        }

        public static void ExportToCSV(string FileName)
        {
            using (StreamWriter Tex = new StreamWriter(new FileStream(FileName, FileMode.Create, FileAccess.ReadWrite),
                System.Text.Encoding.Unicode))
            {
                Tex.WriteLine("Order;ID;KeyWord");
                foreach (SpeechEntry entry in Entries)
                {
                    Tex.WriteLine($"{entry.Order};{entry.ID};{entry.KeyWord}");
                }
            }
        }

        public static void ImportFromCSV(string FileName)
        {
            Entries = new List<SpeechEntry>(0);
            if (!File.Exists(FileName))
                return;
            using (StreamReader sr = new StreamReader(FileName))
            {
                string line;
                while ((line = sr.ReadLine()) != null)
                {
                    if ((line = line.Trim()).Length == 0 || line.StartsWith("#"))
                        continue;
                    if ((line.Contains("Order")) && (line.Contains("KeyWord")))
                        continue;
                    try
                    {
                        string[] split = line.Split(';');
                        if (split.Length < 3)
                            continue;

                        int order = ConvertStringToInt(split[0]);
                        int id = ConvertStringToInt(split[1]);
                        string word = split[2];
                        word = word.Replace("\"", "");
                        Entries.Add(new SpeechEntry((short) id, word, order));
                    }
                    catch
                    {
                    }
                }
            }
        }

        public static int ConvertStringToInt(string text)
        {
            int result;
            if (text.Contains("0x"))
            {
                string convert = text.Replace("0x", "");
                int.TryParse(convert, System.Globalization.NumberStyles.HexNumber, null, out result);
            }
            else
                int.TryParse(text, System.Globalization.NumberStyles.Integer, null, out result);

            return result;
        }

        #region SortComparer

        public class IDComparer : IComparer<SpeechEntry>
        {
            private bool m_desc;

            public IDComparer(bool desc)
            {
                m_desc = desc;
            }

            public int Compare(SpeechEntry objA, SpeechEntry objB)
            {
                if (objA.ID == objB.ID)
                    return 0;
                else if (m_desc)
                    return (objA.ID < objB.ID) ? 1 : -1;
                else
                    return (objA.ID < objB.ID) ? -1 : 1;
            }
        }

        public class KeyWordComparer : IComparer<SpeechEntry>
        {
            private bool m_desc;

            public KeyWordComparer(bool desc)
            {
                m_desc = desc;
            }

            public int Compare(SpeechEntry objA, SpeechEntry objB)
            {
                if (m_desc)
                    return String.Compare(objB.KeyWord, objA.KeyWord);
                else
                    return String.Compare(objA.KeyWord, objB.KeyWord);
            }
        }

        public class OrderComparer : IComparer<SpeechEntry>
        {
            public int Compare(SpeechEntry objA, SpeechEntry objB)
            {
                if (objA.Order == objB.Order)
                    return 0;
                else
                    return (objA.Order < objB.Order) ? -1 : 1;
            }
        }

        #endregion
    }

    public sealed class SpeechEntry
    {
        public short ID { get; set; }
        public string KeyWord { get; set; }

        [Browsable(false)] public int Order { get; private set; }

        public SpeechEntry(short id, string keyword, int order)
        {
            ID = id;
            KeyWord = keyword;
            Order = order;
        }
    }

    [StructLayout(System.Runtime.InteropServices.LayoutKind.Sequential, Pack = 1)]
    public unsafe struct SpeechMul
    {
        public short id;
        public short length;
        public byte[] keyword;
    }
}

================================================
FILE: Razor/UltimaSDK/StackDataReader.cs
================================================
#region license

// Copyright (c) 2024, andreakarasho
// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
// 3. All advertising materials mentioning features or use of this software
//    must display the following acknowledgement:
//    This product includes software developed by andreakarasho - https://github.com/andreakarasho
// 4. Neither the name of the copyright holder nor the
//    names of its contributors may be used to endorse or promote products
//    derived from this software without specific prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#endregion
using System;
using System.Buffers.Binary;
using System.Runtime.InteropServices;
using System.Text;

namespace Ultima
{
    unsafe ref struct StackDataReader
    {
        private readonly ReadOnlySpan<byte> _data;
        public StackDataReader(ReadOnlySpan<byte> data)
        {
            _data = data;
            Length = data.Length;
            Position = 0;
        }

        public int Position { get; private set; }
        public long Length { get; }
        public int Remaining => (int)(Length - Position);

        public byte this[int index] => _data[0];

        public ReadOnlySpan<byte> Buffer => _data;


        public ref byte GetPinnableReference()
        {
            return ref MemoryMarshal.GetReference(_data);
        }

        public void Release()
        {
            // do nothing right now.
        }

        public void Seek(long p)
        {
            Position = (int)p;
        }

        public void Skip(int count)
        {
            Position += count;
        }

        public byte ReadUInt8()
        {
            if (Position + 1 > Length)
            {
                return 0;
            }

            return _data[Position++];
        }

        public sbyte ReadInt8()
        {
            if (Position + 1 > Length)
            {
                return 0;
            }

            return (sbyte)_data[Position++];
        }

        public bool ReadBool() => ReadUInt8() != 0;

        public ushort ReadUInt16LE()
        {
            if (Position + 2 > Length)
            {
                return 0;
            }

            BinaryPrimitives.TryReadUInt16LittleEndian(_data.Slice(Position), out ushort v);

            Skip(2);

            return v;
        }

        public short ReadInt16LE()
        {
            if (Position + 2 > Length)
            {
                return 0;
            }

            BinaryPrimitives.TryReadInt16LittleEndian(_data.Slice(Position), out short v);

            Skip(2);

            return v;
        }

        public uint ReadUInt32LE()
        {
            if (Position + 4 > Length)
            {
                return 0;
            }

            BinaryPrimitives.TryReadUInt32LittleEndian(_data.Slice(Position), out uint v);

            Skip(4);

            return v;
        }

        public int ReadInt32LE()
        {
            if (Position + 4 > Length)
            {
                return 0;
            }

            int v = BinaryPrimitives.ReadInt32LittleEndian(_data.Slice(Position));

            Skip(4);

            return v;
        }

        public ulong ReadUInt64LE()
        {
            if (Position + 8 > Length)
            {
                return 0;
            }

            BinaryPrimitives.TryReadUInt64LittleEndian(_data.Slice(Position), out ulong v);

            Skip(8);

            return v;
        }

        public long ReadInt64LE()
        {
            if (Position + 8 > Length)
            {
                return 0;
            }

            BinaryPrimitives.TryReadInt64LittleEndian(_data.Slice(Position), out long v);

            Skip(8);

            return v;
        }





        public ushort ReadUInt16BE()
        {
            if (Position + 2 > Length)
            {
                return 0;
            }

            BinaryPrimitives.TryReadUInt16BigEndian(_data.Slice(Position), out ushort v);

            Skip(2);

            return v;
        }

        public short ReadInt16BE()
        {
            if (Position + 2 > Length)
            {
                return 0;
            }

            BinaryPrimitives.TryReadInt16BigEndian(_data.Slice(Position), out short v);

            Skip(2);

            return v;
        }

        public uint ReadUInt32BE()
        {
            if (Position + 4 > Length)
            {
                return 0;
            }

            BinaryPrimitives.TryReadUInt32BigEndian(_data.Slice(Position), out uint v);

            Skip(4);

            return v;
        }

        public int ReadInt32BE()
        {
            if (Position + 4 > Length)
            {
                return 0;
            }

            BinaryPrimitives.TryReadInt32BigEndian(_data.Slice(Position), out int v);

            Skip(4);

            return v;
        }

        public ulong ReadUInt64BE()
        {
            if (Position + 8 > Length)
            {
                return 0;
            }

            BinaryPrimitives.TryReadUInt64BigEndian(_data.Slice(Position), out ulong v);

            Skip(8);

            return v;
        }

        public long ReadInt64BE()
        {
            if (Position + 8 > Length)
            {
                return 0;
            }

            BinaryPrimitives.TryReadInt64BigEndian(_data.Slice(Position), out long v);

            Skip(8);

            return v;
        }

        private string ReadRawString(int length, int sizeT, bool safe)
        {
            if (length == 0 || Position + sizeT > Length)
            {
                return string.Empty;
            }

            bool fixedLength = length > 0;
            int remaining = Remaining;
            int size;

            if (fixedLength)
            {
                size = length * sizeT;

                if (size > remaining)
                {
                    size = remaining;
                }
            }
            else
            {
                size = remaining - (remaining & (sizeT - 1));
            }

            ReadOnlySpan<byte> slice = _data.Slice(Position, size);

            int index = GetIndexOfZero(slice, sizeT);
            size = index < 0 ? size : index;

            string result;

            if (size <= 0)
            {
                result = String.Empty;
            }
            else
            {
                result = StringHelper.Cp1252ToString(slice.Slice(0, size));

                if (safe)
                {
                    Span<char> buff = stackalloc char[256];
                    ReadOnlySpan<char> chars = result.AsSpan();

                    ValueStringBuilder sb = new ValueStringBuilder(buff);

                    bool hasDoneAnyReplacements = false;
                    int last = 0;
                    for (int i = 0; i < chars.Length; i++)
                    {
                        if (!StringHelper.IsSafeChar(chars[i]))
                        {
                            hasDoneAnyReplacements = true;
                            sb.Append(chars.Slice(last, i - last));
                            last = i + 1; // Skip the unsafe char
                        }
                    }

                    if (hasDoneAnyReplacements)
                    {
                        // append the rest of the string
                        if (last < chars.Length)
                        {
                            sb.Append(chars.Slice(last, chars.Length - last));
                        }

                        result = sb.ToString();
                    }

                    sb.Dispose();
                }
            }

            Position += Math.Max(size + (!fixedLength && index >= 0 ? sizeT : 0), length * sizeT);

            return result;
        }

        public string ReadASCII(bool safe = false)
        {
            return ReadRawString(-1, 1, safe);
            //return ReadString(StringHelper.Cp1252Encoding, -1, 1, safe);
        }

        public string ReadASCII(int length, bool safe = false)
        {
            return ReadRawString(length, 1, safe);

            //return ReadString(StringHelper.Cp1252Encoding, length, 1, safe);
        }

        public string ReadUnicodeBE(bool safe = false)
        {
            return ReadString(Encoding.BigEndianUnicode, -1, 2, safe);
        }

        public string ReadUnicodeBE(int length, bool safe = false)
        {
            return ReadString(Encoding.BigEndianUnicode, length, 2, safe);
        }

        public string ReadUnicodeLE(bool safe = false)
        {
            return ReadString(Encoding.Unicode, -1, 2, safe);
        }

        public string ReadUnicodeLE(int length, bool safe = false)
        {
            return ReadString(Encoding.Unicode, length, 2, safe);
        }

        public string ReadUTF8(bool safe = false)
        {
            return ReadString(Encoding.UTF8, -1, 1, safe);
        }

        public string ReadUTF8(int length, bool safe = false)
        {
            return ReadString(Encoding.UTF8, length, 1, safe);
        }

        public void Read(Span<byte> data, int offset, int count)
        {
            _data.Slice(Position + offset, count).CopyTo(data);
        }

        // from modernuo <3
        private string ReadString(Encoding encoding, int length, int sizeT, bool safe)
        {
            if (length == 0 || Position + sizeT > Length)
            {
                return string.Empty;
            }

            bool fixedLength = length > 0;
            int remaining = Remaining;
            int size;

            if (fixedLength)
            {
                size = length * sizeT;

                if (size > remaining)
                {
                    size = remaining;
                }
            }
            else
            {
                size = remaining - (remaining & (sizeT - 1));
            }

            ReadOnlySpan<byte> slice = _data.Slice(Position, size);

            int index = GetIndexOfZero(slice, sizeT);
            size = index < 0 ? size : index;

            string result;

            fixed (byte* ptr = slice)
            {
                result = encoding.GetString(ptr, size);
            }

            if (safe)
            {
                Span<char> buff = stackalloc char[256];
                ReadOnlySpan<char> chars = result.AsSpan();

                ValueStringBuilder sb = new ValueStringBuilder(buff);

                bool hasDoneAnyReplacements = false;
                int last = 0;
                for (int i = 0; i < chars.Length; i++)
                {
                    if (!StringHelper.IsSafeChar(chars[i]))
                    {
                        hasDoneAnyReplacements = true;
                        sb.Append(chars.Slice(last, i - last));
                        last = i + 1; // Skip the unsafe char
                    }
                }

                if (hasDoneAnyReplacements)
                {
                    // append the rest of the string
                    if (last < chars.Length)
                    {
                        sb.Append(chars.Slice(last, chars.Length - last));
                    }

                    result = sb.ToString();
                }

                sb.Dispose();
            }

            Position += Math.Max(size + (!fixedLength && index >= 0 ? sizeT : 0), length * sizeT);

            return result;
        }

        private static int GetIndexOfZero(ReadOnlySpan<byte> span, int sizeT)
        {
            switch (sizeT)
            {
                case 2: return MemoryMarshal.Cast<byte, char>(span).IndexOf('\0') * 2;
                case 4: return MemoryMarshal.Cast<byte, uint>(span).IndexOf((uint)0) * 4;
                default: return span.IndexOf((byte)0);
            }
        }
    }
}


================================================
FILE: Razor/UltimaSDK/StringEntry.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Text.RegularExpressions;

namespace Ultima
{
    public sealed class StringEntry
    {
        [Flags]
        public enum CliLocFlag
        {
            Original = 0x0,
            Custom = 0x1,
            Modified = 0x2
        }

        private string m_Text;

        public int Number { get; private set; }

        public string Text
        {
            get { return m_Text; }
            set
            {
                if (value == null)
                    m_Text = "";
                else
                    m_Text = value;
            }
        }

        public CliLocFlag Flag { get; set; }

        public StringEntry(int number, string text, byte flag)
        {
            Number = number;
            m_Text = text;
            Flag = (CliLocFlag) flag;
        }

        public StringEntry(int number, string text, CliLocFlag flag)
        {
            Number = number;
            m_Text = text;
            Flag = flag;
        }

        // Razor
        private static Regex m_RegEx = new Regex(@"~(\d+)[_\w]+~",
            RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.Singleline | RegexOptions.CultureInvariant);

        private string m_FmtTxt;
        private static object[] m_Args = new object[] {"", "", "", "", "", "", "", "", "", "", ""};

        public string Format(params object[] args)
        {
            if (m_FmtTxt == null)
                m_FmtTxt = m_RegEx.Replace(m_Text, @"{$1}");
            for (int i = 0; i < args.Length && i < 10; i++)
                m_Args[i + 1] = args[i];
            return String.Format(m_FmtTxt, m_Args);
        }

        public string SplitFormat(string argstr)
        {
            if (m_FmtTxt == null)
                m_FmtTxt = m_RegEx.Replace(m_Text, @"{$1}");
            string[] args = argstr.Split('\t'); // adds an extra on to the args array
            for (int i = 0; i < args.Length && i < 10; i++)
                m_Args[i + 1] = args[i];
            return String.Format(m_FmtTxt, m_Args);
            /*
            {
                 StringBuilder sb = new StringBuilder();
                 sb.Append( m_FmtTxt );
                 for(int i=0;i<args.Length;i++)
                 {
                      sb.Append( "|" );
                      sb.Append( args[i] == null ? "-null-" : args[i] );
                 }
                 throw new Exception( sb.ToString() );
            }*/
        }
    }
}

================================================
FILE: Razor/UltimaSDK/StringHelper.cs
================================================
#region license

// Copyright (c) 2021, andreakarasho
// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
// 3. All advertising materials mentioning features or use of this software
//    must display the following acknowledgement:
//    This product includes software developed by andreakarasho - https://github.com/andreakarasho
// 4. Neither the name of the copyright holder nor the
//    names of its contributors may be used to endorse or promote products
//    derived from this software without specific prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#endregion

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;

namespace Ultima
{
    internal static class StringHelper
    {
        private static readonly char[] _dots = { '.', ',', ';', '!' };

        public static IEnumerable<byte> StringToCp1252Bytes(string s, int length = -1)
        {
            length = length > 0 ? Math.Min(length, s.Length) : s.Length;

            for (int i = 0; i < length; i += char.IsSurrogatePair(s, i) ? 2 : 1)
            {
                yield return UnicodeToCp1252(char.ConvertToUtf32(s, i));
            }
        }

        public static string Cp1252ToString(ReadOnlySpan<byte> strCp1252)
        {
            var sb = new ValueStringBuilder(strCp1252.Length);

            for (int i = 0; i < strCp1252.Length; ++i)
            {
                sb.Append(char.ConvertFromUtf32(Cp1252ToUnicode(strCp1252[i])));
            }

            var str = sb.ToString();

            sb.Dispose();

            return str;
        }

        /// <summary>
        /// Converts a unicode code point into a cp1252 code point
        /// </summary>
        private static byte UnicodeToCp1252(int codepoint)
        {
            if (codepoint >= 0x80 && codepoint <= 0x9f)
                return (byte)'?';
            else if (codepoint <= 0xff)
                return (byte)codepoint;
            else
            {
                switch (codepoint)
                {
                    case 0x20AC: return 128; //€
                    case 0x201A: return 130; //‚
                    case 0x0192: return 131; //ƒ
                    case 0x201E: return 132; //„
                    case 0x2026: return 133; //…
                    case 0x2020: return 134; //†
                    case 0x2021: return 135; //‡
                    case 0x02C6: return 136; //ˆ
                    case 0x2030: return 137; //‰
                    case 0x0160: return 138; //Š
                    case 0x2039: return 139; //‹
                    case 0x0152: return 140; //Œ
                    case 0x017D: return 142; //Ž
                    case 0x2018: return 145; //‘
                    case 0x2019: return 146; //’
                    case 0x201C: return 147; //“
                    case 0x201D: return 148; //”
                    case 0x2022: return 149; //•
                    case 0x2013: return 150; //–
                    case 0x2014: return 151; //—
                    case 0x02DC: return 152; //˜
                    case 0x2122: return 153; //™
                    case 0x0161: return 154; //š
                    case 0x203A: return 155; //›
                    case 0x0153: return 156; //œ
                    case 0x017E: return 158; //ž
                    case 0x0178: return 159; //Ÿ
                    default: return (byte)'?';
                }
            }
        }

        /// <summary>
        /// Converts a cp1252 code point into a unicode code point
        /// </summary>
        private static int Cp1252ToUnicode(byte codepoint)
        {
            switch (codepoint)
            {
                case 128: return 0x20AC; //€
                case 130: return 0x201A; //‚
                case 131: return 0x0192; //ƒ
                case 132: return 0x201E; //„
                case 133: return 0x2026; //…
                case 134: return 0x2020; //†
                case 135: return 0x2021; //‡
                case 136: return 0x02C6; //ˆ
                case 137: return 0x2030; //‰
                case 138: return 0x0160; //Š
                case 139: return 0x2039; //‹
                case 140: return 0x0152; //Œ
                case 142: return 0x017D; //Ž
                case 145: return 0x2018; //‘
                case 146: return 0x2019; //’
                case 147: return 0x201C; //“
                case 148: return 0x201D; //”
                case 149: return 0x2022; //•
                case 150: return 0x2013; //–
                case 151: return 0x2014; //—
                case 152: return 0x02DC; //˜
                case 153: return 0x2122; //™
                case 154: return 0x0161; //š
                case 155: return 0x203A; //›
                case 156: return 0x0153; //œ
                case 158: return 0x017E; //ž
                case 159: return 0x0178; //Ÿ
                default: return codepoint;
            }
        }

        public static string CapitalizeFirstCharacter(string str)
        {
            if (string.IsNullOrEmpty(str))
            {
                return string.Empty;
            }

            if (str.Length == 1)
            {
                return char.ToUpper(str[0]).ToString();
            }

            return char.ToUpper(str[0]) + str.Substring(1);
        }


        public static string CapitalizeAllWords(string str)
        {
            if (string.IsNullOrEmpty(str))
            {
                return string.Empty;
            }

            Span<char> span = stackalloc char[str.Length];
            ValueStringBuilder sb = new ValueStringBuilder(span);
            bool capitalizeNext = true;

            for (int i = 0; i < str.Length; i++)
            {
                sb.Append(capitalizeNext ? char.ToUpper(str[i]) : str[i]);

                if (!char.IsWhiteSpace(str[i]))
                {
                    capitalizeNext = i + 1 < str.Length && char.IsWhiteSpace(str[i + 1]);
                }
            }

            string ss = sb.ToString();

            sb.Dispose();

            return ss;
        }

        public static string CapitalizeWordsByLimitator(string str)
        {
            if (string.IsNullOrEmpty(str))
            {
                return string.Empty;
            }

            Span<char> span = stackalloc char[str.Length];
            ValueStringBuilder sb = new ValueStringBuilder(span);

            bool capitalizeNext = true;

            for (int i = 0; i < str.Length; i++)
            {
                sb.Append(capitalizeNext ? char.ToUpper(str[i]) : str[i]);
                capitalizeNext = false;

                for (int j = 0; j < _dots.Length; j++)
                {
                    if (str[i] == _dots[j])
                    {
                        capitalizeNext = true;

                        break;
                    }
                }
            }

            string ss = sb.ToString();

            sb.Dispose();

            return ss;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool IsSafeChar(int c)
        {
            return c >= 0x20 && c < 0xFFFE;
        }

        public static void AddSpaceBeforeCapital(string[] str, bool checkAcronyms = true)
        {
            for (int i = 0; i < str.Length; i++)
            {
                str[i] = AddSpaceBeforeCapital(str[i], checkAcronyms);
            }
        }

        public static string AddSpaceBeforeCapital(string str, bool checkAcronyms = true)
        {
            if (string.IsNullOrWhiteSpace(str))
            {
                return "";
            }

            ValueStringBuilder sb = new ValueStringBuilder(str.Length * 2);
            sb.Append(str[0]);

            for (int i = 1, len = str.Length - 1; i <= len; i++)
            {
                if (char.IsUpper(str[i]))
                {
                    if (str[i - 1] != ' ' && !char.IsUpper(str[i - 1]) || checkAcronyms && char.IsUpper(str[i - 1]) && i < len && !char.IsUpper(str[i + 1]))
                    {
                        sb.Append(' ');
                    }
                }

                sb.Append(str[i]);
            }

            string s = sb.ToString();

            sb.Dispose();

            return s;
        }

        public static string RemoveUpperLowerChars(string str, bool removelower = true)
        {
            if (string.IsNullOrWhiteSpace(str))
            {
                return "";
            }

            Span<char> span = stackalloc char[str.Length];
            ValueStringBuilder sb = new ValueStringBuilder(span);

            for (int i = 0; i < str.Length; i++)
            {
                if (char.IsUpper(str[i]) == removelower || str[i] == ' ')
                {
                    sb.Append(str[i]);
                }
            }

            string ss = sb.ToString();

            sb.Dispose();

            return ss;
        }

        public static string IntToAbbreviatedString(int num)
        {
            if (num > 999999)
            {
                return string.Format("{0}M+", num / 1000000);
            }

            if (num > 999)
            {
                return string.Format("{0}K+", num / 1000);
            }

            return num.ToString();
        }


        public static string GetPluralAdjustedString(string str, bool plural = false)
        {
            if (str.Contains("%"))
            {
                string[] parts = str.Split(new[] { '%' }, System.StringSplitOptions.RemoveEmptyEntries);

                if (parts.Length < 2)
                {
                    return str;
                }

                Span<char> span = stackalloc char[str.Length];
                ValueStringBuilder sb = new ValueStringBuilder(span);

                sb.Append(parts[0]);

                if (parts[1].Contains("/"))
                {
                    string[] pluralparts = parts[1].Split('/');

                    if (plural)
                    {
                        sb.Append(pluralparts[0]);
                    }
                    else if (pluralparts.Length > 1)
                    {
                        sb.Append(pluralparts[1]);
                    }
                }
                else if (plural)
                {
                    sb.Append(parts[1]);
                }

                if (parts.Length == 3)
                {
                    sb.Append(parts[2]);
                }

                string ss = sb.ToString();

                sb.Dispose();

                return ss;
            }

            return str;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static unsafe bool UnsafeCompare(char* buffer, string str, int length)
        {
            for (int i = 0; i < length && i < str.Length; ++i)
            {
                if (buffer[i] != str[i])
                {
                    return false;
                }
            }

            return true;
        }
    }
}

================================================
FILE: Razor/UltimaSDK/StringList.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using Assistant;

namespace Ultima
{
    public sealed class StringList
    {
        private int m_Header1;
        private short m_Header2;

        public List<StringEntry> Entries { get; set; }
        public string Language { get; private set; }

        private Dictionary<int, string> m_StringTable;
        private Dictionary<int, StringEntry> m_EntryTable;

        private static byte[] m_Buffer = new byte[1024];

        /// <summary>
        /// Initialize <see cref="StringList"/> of Language
        /// </summary>
        /// <param name="language"></param>
        public StringList(string language)
        {
            Language = language;
            LoadEntry(Files.GetFilePath($"cliloc.{language}"));
        }

        /// <summary>
        /// Initialize <see cref="StringList"/> of Language from path
        /// </summary>
        /// <param name="language"></param>
        /// <param name="path"></param>
        public StringList(string language, string path)
        {
            Language = language;
            
            LoadEntry(path);
        }

        private void LoadEntry(string path)
        {
            if (Engine.ClientVersion.Major >= 7 && Engine.ClientVersion.Build >= 105)
            {
                LoadNewEntryFormat(path);
            }
            else
            {
                LoadOldEntryFormat(path);
            }
        }

        private void LoadOldEntryFormat(string path)
        {
            if (path == null)
            {
                Entries = new List<StringEntry>(0);
                return;
            }

            Entries = new List<StringEntry>();
            m_StringTable = new Dictionary<int, string>();
            m_EntryTable = new Dictionary<int, StringEntry>();

            using (BinaryReader bin =
                new BinaryReader(new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read)))
            {
                m_Header1 = bin.ReadInt32();
                m_Header2 = bin.ReadInt16();

                while (bin.BaseStream.Length != bin.BaseStream.Position)
                {
                    int number = bin.ReadInt32();
                    byte flag = bin.ReadByte();
                    int length = bin.ReadInt16();

                    if (length > m_Buffer.Length)
                        m_Buffer = new byte[(length + 1023) & ~1023];

                    bin.Read(m_Buffer, 0, length);
                    string text = Encoding.UTF8.GetString(m_Buffer, 0, length);

                    StringEntry se = new StringEntry(number, text, flag);
                    Entries.Add(se);

                    m_StringTable[number] = text;
                    m_EntryTable[number] = se;
                }
            }
        }
        
        // Based on the implementation from Karasho @ ClassicUO
        private void LoadNewEntryFormat(string path)
        {
            if (path == null)
            {
                Entries = new List<StringEntry>(0);
                return;
            }

            Entries = new List<StringEntry>();
            m_StringTable = new Dictionary<int, string>();
            m_EntryTable = new Dictionary<int, StringEntry>();

            using (var fileStream = new FileStream(path, FileMode.Open, FileAccess.Read))
            {
                int bytesRead;
                var totalRead = 0;
                var buf = new byte[fileStream.Length];
                while ((bytesRead = fileStream.Read(buf, totalRead, Math.Min(4096, buf.Length - totalRead))) > 0)
                    totalRead += bytesRead;

                var output = buf[3] == 0x8E ? BwtDecompress.Decompress(buf) : buf;

                var reader = new StackDataReader(output);
                m_Header1 = reader.ReadInt32LE();
                m_Header2 = reader.ReadInt16LE();

                while (reader.Remaining > 0)
                {
                    var number = reader.ReadInt32LE();
                    var flag = reader.ReadUInt8();
                    var length = reader.ReadInt16LE();
                    var text = string.Intern(reader.ReadUTF8(length));

                    m_StringTable[number] = text;
                    StringEntry se = new StringEntry(number, text, flag);
                    Entries.Add(se);
                    m_EntryTable[number] = se;
                }
            }
        }

        /// <summary>
        /// Saves <see cref="SaveStringList"/> to FileName
        /// </summary>
        /// <param name="FileName"></param>
        public void SaveStringList(string FileName)
        {
            using (FileStream fs = new FileStream(FileName, FileMode.Create, FileAccess.Write, FileShare.Write))
            {
                using (BinaryWriter bin = new BinaryWriter(fs))
                {
                    bin.Write(m_Header1);
                    bin.Write(m_Header2);
                    Entries.Sort(new StringList.NumberComparer(false));
                    foreach (StringEntry entry in Entries)
                    {
                        bin.Write(entry.Number);
                        bin.Write((byte) entry.Flag);
                        byte[] utf8String = Encoding.UTF8.GetBytes(entry.Text);
                        ushort length = (ushort) utf8String.Length;
                        bin.Write(length);
                        bin.Write(utf8String);
                    }
                }
            }
        }

        public string GetString(int number)
        {
            if (m_StringTable == null || !m_StringTable.ContainsKey(number))
                return null;

            return m_StringTable[number];
        }

        public StringEntry GetEntry(int number)
        {
            if (m_EntryTable == null || !m_EntryTable.ContainsKey(number))
                return null;

            return m_EntryTable[number];
        }

        #region SortComparer

        public class NumberComparer : IComparer<StringEntry>
        {
            private bool m_desc;

            public NumberComparer(bool desc)
            {
                m_desc = desc;
            }

            public int Compare(StringEntry objA, StringEntry objB)
            {
                if (objA.Number == objB.Number)
                    return 0;
                else if (m_desc)
                    return (objA.Number < objB.Number) ? 1 : -1;
                else
                    return (objA.Number < objB.Number) ? -1 : 1;
            }
        }

        public class FlagComparer : IComparer<StringEntry>
        {
            private bool m_desc;

            public FlagComparer(bool desc)
            {
                m_desc = desc;
            }

            public int Compare(StringEntry objA, StringEntry objB)
            {
                if ((byte) objA.Flag == (byte) objB.Flag)
                {
                    if (objA.Number == objB.Number)
                        return 0;
                    else if (m_desc)
                        return (objA.Number < objB.Number) ? 1 : -1;
                    else
                        return (objA.Number < objB.Number) ? -1 : 1;
                }
                else if (m_desc)
                    return ((byte) objA.Flag < (byte) objB.Flag) ? 1 : -1;
                else
                    return ((byte) objA.Flag < (byte) objB.Flag) ? -1 : 1;
            }
        }

        public class TextComparer : IComparer<StringEntry>
        {
            private bool m_desc;

            public TextComparer(bool desc)
            {
                m_desc = desc;
            }

            public int Compare(StringEntry objA, StringEntry objB)
            {
                if (m_desc)
                    return String.Compare(objB.Text, objA.Text);
                else
                    return String.Compare(objA.Text, objB.Text);
            }
        }

        #endregion
    }
}

================================================
FILE: Razor/UltimaSDK/Textures.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System.Collections;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Security.Cryptography;
using System.Collections.Generic;

namespace Ultima
{
    public sealed class Textures
    {
        private static FileIndex m_FileIndex = new FileIndex("Texidx.mul", "Texmaps.mul", 0x4000, 10);
        private static Bitmap[] m_Cache = new Bitmap[0x4000];
        private static bool[] m_Removed = new bool[0x4000];
        private static Hashtable m_patched = new Hashtable();

        private static byte[] m_StreamBuffer;

        struct CheckSums
        {
            public byte[] checksum;
            public int pos;
            public int length;
            public int index;
        }

        private static List<CheckSums> checksums;

        /// <summary>
        /// ReReads texmaps
        /// </summary>
        public static void Reload()
        {
            m_FileIndex = new FileIndex("Texidx.mul", "Texmaps.mul", 0x4000, 10);
            m_Cache = new Bitmap[0x4000];
            m_Removed = new bool[0x4000];
            m_patched.Clear();
        }

        public static int GetIdxLength()
        {
            return (int) (m_FileIndex.IdxLength / 12);
        }

        /// <summary>
        /// Removes Texture <see cref="m_Removed"/>
        /// </summary>
        /// <param name="index"></param>
        public static void Remove(int index)
        {
            m_Removed[index] = true;
        }

        /// <summary>
        /// Replaces Texture
        /// </summary>
        /// <param name="index"></param>
        /// <param name="bmp"></param>
        public static void Replace(int index, Bitmap bmp)
        {
            m_Cache[index] = bmp;
            m_Removed[index] = false;
            if (m_patched.Contains(index))
                m_patched.Remove(index);
        }

        /// <summary>
        /// Tests if index is valid Texture
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public static bool TestTexture(int index)
        {
            int length, extra;
            bool patched;
            if (m_Removed[index])
                return false;
            if (m_Cache[index] != null)
                return true;
            bool valid = m_FileIndex.Valid(index, out length, out extra, out patched);
            if ((!valid) || (length == 0))
                return false;
            return true;
        }

        /// <summary>
        /// Returns Bitmap of Texture
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public unsafe static Bitmap GetTexture(int index)
        {
            bool patched;
            return GetTexture(index, out patched);
        }

        /// <summary>
        /// Returns Bitmap of Texture with verdata bool
        /// </summary>
        /// <param name="index"></param>
        /// <param name="patched"></param>
        /// <returns></returns>
        public unsafe static Bitmap GetTexture(int index, out bool patched)
        {
            if (m_patched.Contains(index))
                patched = (bool) m_patched[index];
            else
                patched = false;
            if (m_Removed[index])
                return null;
            if (m_Cache[index] != null)
                return m_Cache[index];

            int length, extra;
            Stream stream = m_FileIndex.Seek(index, out length, out extra, out patched);
            if (stream == null)
                return null;
            if (length == 0)
                return null;
            if (patched)
                m_patched[index] = true;

            int size = extra == 0 ? 64 : 128;

            Bitmap bmp = new Bitmap(size, size, PixelFormat.Format16bppArgb1555);
            BitmapData bd = bmp.LockBits(new Rectangle(0, 0, size, size), ImageLockMode.WriteOnly,
                PixelFormat.Format16bppArgb1555);

            ushort* line = (ushort*) bd.Scan0;
            int delta = bd.Stride >> 1;

            int max = size * size * 2;

            if (m_StreamBuffer == null || m_StreamBuffer.Length < max)
                m_StreamBuffer = new byte[max];
            stream.Read(m_StreamBuffer, 0, max);

            fixed (byte* data = m_StreamBuffer)
            {
                ushort* bindat = (ushort*) data;
                for (int y = 0; y < size; ++y, line += delta)
                {
                    ushort* cur = line;
                    ushort* end = cur + size;

                    while (cur < end)
                        *cur++ = (ushort) (*bindat++ ^ 0x8000);
                }
            }

            bmp.UnlockBits(bd);

            stream.Close();
            if (!Files.CacheData)
                return m_Cache[index] = bmp;
            else
                return bmp;
        }

        public unsafe static void Save(string path)
        {
            string idx = Path.Combine(path, "texidx.mul");
            string mul = Path.Combine(path, "texmaps.mul");
            checksums = new List<CheckSums>();
            using (FileStream fsidx = new FileStream(idx, FileMode.Create, FileAccess.Write, FileShare.Write),
                fsmul = new FileStream(mul, FileMode.Create, FileAccess.Write, FileShare.Write))
            {
                MemoryStream memidx = new MemoryStream();
                MemoryStream memmul = new MemoryStream();
                using (BinaryWriter binidx = new BinaryWriter(memidx),
                    binmul = new BinaryWriter(memmul))
                {
                    SHA256Managed sha = new SHA256Managed();
                    //StreamWriter Tex = new StreamWriter(new FileStream("d:/texlog.txt", FileMode.Create, FileAccess.ReadWrite));
                    for (int index = 0; index < GetIdxLength(); ++index)
                    {
                        if (m_Cache[index] == null)
                            m_Cache[index] = GetTexture(index);

                        Bitmap bmp = m_Cache[index];
                        if ((bmp == null) || (m_Removed[index]))
                        {
                            binidx.Write((int) -1); // lookup
                            binidx.Write((int) 0); // length
                            binidx.Write((int) -1); // extra
                        }
                        else
                        {
                            MemoryStream ms = new MemoryStream();
                            bmp.Save(ms, ImageFormat.Bmp);
                            byte[] checksum = sha.ComputeHash(ms.ToArray());
                            CheckSums sum;
                            if (compareSaveImages(checksum, out sum))
                            {
                                binidx.Write((int) sum.pos); //lookup
                                binidx.Write((int) sum.length);
                                binidx.Write((int) 0);
                                //Tex.WriteLine(System.String.Format("0x{0:X4} : 0x{1:X4} 0x{2:X4}", index, (int)sum.pos, (int)sum.length));
                                //Tex.WriteLine(System.String.Format("0x{0:X4} -> 0x{1:X4}", sum.index, index));
                                continue;
                            }

                            BitmapData bd = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height),
                                ImageLockMode.ReadOnly, PixelFormat.Format16bppArgb1555);
                            ushort* line = (ushort*) bd.Scan0;
                            int delta = bd.Stride >> 1;

                            binidx.Write((int) binmul.BaseStream.Position); //lookup
                            int length = (int) binmul.BaseStream.Position;

                            for (int Y = 0; Y < bmp.Height; ++Y, line += delta)
                            {
                                ushort* cur = line;
                                for (int X = 0; X < bmp.Width; ++X)
                                {
                                    binmul.Write((ushort) (cur[X] ^ 0x8000));
                                }
                            }

                            int start = length;
                            length = (int) binmul.BaseStream.Position - length;
                            binidx.Write(length);
                            binidx.Write((int) (bmp.Width == 64 ? 0 : 1));
                            bmp.UnlockBits(bd);
                            CheckSums s = new CheckSums()
                                {pos = start, length = length, checksum = checksum, index = index};
                            //Tex.WriteLine(System.String.Format("0x{0:X4} : 0x{1:X4} 0x{2:X4}", index, start, length));
                            checksums.Add(s);
                        }
                    }

                    memidx.WriteTo(fsidx);
                    memmul.WriteTo(fsmul);
                }
            }
        }

        private static bool compareSaveImages(byte[] newchecksum, out CheckSums sum)
        {
            sum = new CheckSums();
            for (int i = 0; i < checksums.Count; ++i)
            {
                byte[] cmp = checksums[i].checksum;
                if (((cmp == null) || (newchecksum == null))
                    || (cmp.Length != newchecksum.Length))
                {
                    return false;
                }

                bool valid = true;
                for (int j = 0; j < cmp.Length; ++j)
                {
                    if (cmp[j] != newchecksum[j])
                    {
                        valid = false;
                        break;
                    }
                }

                if (valid)
                {
                    sum = checksums[i];
                    return true;
                }
            }

            return false;
        }
    }
}

================================================
FILE: Razor/UltimaSDK/TileData.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.IO;
using System.Runtime.InteropServices;
using System.Text;

namespace Ultima
{
    /// <summary>
    /// Represents land tile data.
    /// <seealso cref="ItemData" />
    /// <seealso cref="LandData" />
    /// </summary>
    public struct LandData
    {
        private string m_Name;
        private short m_TexID;
        private TileFlag m_Flags;
        private int m_Unk1;

        public LandData(string name, int TexID, TileFlag flags, int unk1)
        {
            m_Name = name;
            m_TexID = (short) TexID;
            m_Flags = flags;
            m_Unk1 = unk1;
        }

        public unsafe LandData(NewLandTileDataMul mulstruct)
        {
            m_TexID = mulstruct.texID;
            m_Flags = (TileFlag) mulstruct.flags;
            m_Unk1 = mulstruct.unk1;
            m_Name = TileData.ReadNameString(mulstruct.name);
        }

        public unsafe LandData(OldLandTileDataMul mulstruct)
        {
            m_TexID = mulstruct.texID;
            m_Flags = (TileFlag) mulstruct.flags;
            m_Unk1 = 0;
            m_Name = TileData.ReadNameString(mulstruct.name);
        }

        /// <summary>
        /// Gets the name of this land tile.
        /// </summary>
        public string Name
        {
            get { return m_Name; }
            set { m_Name = value; }
        }

        /// <summary>
        /// Gets the Texture ID of this land tile.
        /// </summary>
        public short TextureID
        {
            get { return m_TexID; }
            set { m_TexID = value; }
        }

        /// <summary>
        /// Gets a bitfield representing the 32 individual flags of this land tile.
        /// </summary>
        public TileFlag Flags
        {
            get { return m_Flags; }
            set { m_Flags = value; }
        }

        /// <summary>
        /// Gets a new UOHSA Unknown Int
        /// </summary>
        public int Unk1
        {
            get { return m_Unk1; }
            set { m_Unk1 = value; }
        }

        public void ReadData(string[] split)
        {
            int i = 1;
            m_Name = split[i++];
            m_TexID = (short) TileData.ConvertStringToInt(split[i++]);
            m_Unk1 = TileData.ConvertStringToInt(split[i++]);
            m_Flags = 0;
            int temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.Background;
            temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.Weapon;
            temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.Transparent;
            temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.Translucent;
            temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.Wall;
            temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.Damaging;
            temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.Impassable;
            temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.Wet;
            temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.Unknown1;
            temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.Surface;
            temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.Bridge;
            temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.Generic;
            temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.Window;
            temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.NoShoot;
            temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.ArticleA;
            temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.ArticleAn;
            temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.Internal;
            temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.Foliage;
            temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.PartialHue;
            temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.Unknown2;
            temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.Map;
            temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.Container;
            temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.Wearable;
            temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.LightSource;
            temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.Animation;
            temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.HoverOver;
            temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.Unknown3;
            temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.Armor;
            temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.Roof;
            temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.Door;
            temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.StairBack;
            temp = System.Convert.ToByte(split[i++]);
            if (temp != 0)
                m_Flags |= TileFlag.StairRight;
        }
    }

    /// <summary>
    /// Represents item tile data.
    /// <seealso cref="TileData" />
    /// <seealso cref="LandData" />
    /// </summary>
    public struct ItemData
    {
        internal string m_Name;
        internal TileFlag m_Flags;
        internal int m_Unk1;
        internal byte m_Weight;
        internal byte m_Quality;
        internal byte m_Quantity;
        internal byte m_Value;
        internal byte m_Height;
        internal short m_Animation;
        internal byte m_Hue;
        internal byte m_StackOffset;
        internal short m_MiscData;
        internal byte m_Unk2;
        internal byte m_Unk3;

        public ItemData(string name, TileFlag flags, int unk1, int weight, int quality, int quantity, int value,
            int height, int anim, int hue, int stackingoffset, int MiscData, int unk2, int unk3)
        {
            m_Name = name;
            m_Flags = flags;
            m_Unk1 = unk1;
            m_Weight = (byte) weight;
            m_Quality = (byte) quality;
            m_Quantity = (byte) quantity;
            m_Value = (byte) value;
            m_Height = (byte) height;
            m_Animation = (short) anim;
            m_Hue = (byte) hue;
            m_StackOffset = (byte) stackingoffset;
            m_MiscData = (short) MiscData;
            m_Unk2 = (byte) unk2;
            m_Unk3 = (byte) unk3;
        }

        public unsafe ItemData(NewItemTileDataMul mulstruct)
        {
            m_Name = TileData.ReadNameString(mulstruct.name);
            m_Flags = (TileFlag) mulstruct.flags;
            m_Unk1 = mulstruct.unk1;
            m_Weight = mulstruct.weight;
            m_Quality = mulstruct.quality;
            m_Quantity = mulstruct.quantity;
            m_Value = mulstruct.value;
            m_Height = mulstruct.height;
            m_Animation = mulstruct.anim;
            m_Hue = mulstruct.hue;
            m_StackOffset = mulstruct.stackingoffset;
            m_MiscData = mulstruct.miscdata;
            m_Unk2 = mulstruct.unk2;
            m_Unk3 = mulstruct.unk3;
        }

        public unsafe ItemData(OldItemTileDataMul mulstruct)
        {
            m_Name = TileData.ReadNameString(mulstruct.name);
            m_Flags = (TileFlag) mulstruct.flags;
            m_Unk1 = 0;
            m_Weight = mulstruct.weight;
            m_Quality = mulstruct.quality;
            m_Quantity = mulstruct.quantity;
            m_Value = mulstruct.value;
            m_Height = mulstruct.height;
            m_Animation = mulstruct.anim;
            m_Hue = mulstruct.hue;
            m_StackOffset = mulstruct.stackingoffset;
            m_MiscData = mulstruct.miscdata;
            m_Unk2 = mulstruct.unk2;
            m_Unk3 = mulstruct.unk3;
        }

        /// <summary>
        /// Gets the name of this item.
        /// </summary>
        public string Name
        {
            get { return m_Name; }
            set { m_Name = value; }
        }

        /// <summary>
        /// Gets the animation body index of this item.
        /// <seealso cref="Animations" />
        /// </summary>
        public short Animation
        {
            get { return m_Animation; }
            set { m_Animation = value; }
        }

        /// <summary>
        /// Gets a bitfield representing the 32 individual flags of this item.
        /// <seealso cref="TileFlag" />
        /// </summary>
        public TileFlag Flags
        {
            get { return m_Flags; }
            set { m_Flags = value; }
        }

        /// <summary>
        /// Gets an unknown new UOAHS int
        /// </summary>
        public int Unk1
        {
            get { return m_Unk1; }
            set { m_Unk1 = value; }
        }

        /// <summary>
        /// Whether or not this item is flagged as '<see cref="TileFlag.Background" />'.
        /// <seealso cref="TileFlag" />
        /// </summary>
        public bool Background
        {
            get { return ((m_Flags & TileFlag.Background) != 0); }
        }

        /// <summary>
        /// Whether or not this item is flagged as '<see cref="TileFlag.Bridge" />'.
        /// <seealso cref="TileFlag" />
        /// </summary>
        public bool Bridge
        {
            get { return ((m_Flags & TileFlag.Bridge) != 0); }
        }

        /// <summary>
        /// Whether or not this item is flagged as '<see cref="TileFlag.Impassable" />'.
        /// <seealso cref="TileFlag" />
        /// </summary>
        public bool Impassable
        {
            get { return ((m_Flags & TileFlag.Impassable) != 0); }
        }

        /// <summary>
        /// Whether or not this item is flagged as '<see cref="TileFlag.Surface" />'.
        /// <seealso cref="TileFlag" />
        /// </summary>
        public bool Surface
        {
            get { return ((m_Flags & TileFlag.Surface) != 0); }
        }

        /// <summary>
        /// Gets the weight of this item.
        /// </summary>
        public byte Weight
        {
            get { return m_Weight; }
            set { m_Weight = value; }
        }

        /// <summary>
        /// Gets the 'quality' of this item. For wearable items, this will be the layer.
        /// </summary>
        public byte Quality
        {
            get { return m_Quality; }
            set { m_Quality = value; }
        }

        /// <summary>
        /// Gets the 'quantity' of this item.
        /// </summary>
        public byte Quantity
        {
            get { return m_Quantity; }
            set { m_Quantity = value; }
        }

        /// <summary>
        /// Gets the 'value' of this item.
        /// </summary>
        public byte Value
        {
            get { return m_Value; }
            set { m_Value = value; }
        }

        /// <summary>
        /// Gets the Hue of this item.
        /// </summary>
        public byte Hue
        {
            get { return m_Hue; }
            set { m_Hue = value; }
        }

        /// <summary>
        /// Gets the stackingoffset of this item. (If flag Generic)
        /// </summary>
        public byte StackingOffset
        {
            get { return m_StackOffset; }
            set { m_StackOffset = value; }
        }

        /// <summary>
        /// Gets the height of this item.
        /// </summary>
        public byte Height
        {
            get { return m_Height; }
            set { m_Height = value; }
        }

        /// <summary>
        /// Gets the MiscData of this item. (old UO Demo weapontemplate definition) (Unk1)
        /// </summary>
        public short MiscData
        {
            get { return m_MiscData; }
            set { m_MiscData = value; }
        }

        /// <summary>
        /// Gets the unk2 of this item.
        /// </summary>
        public byte Unk2
        {
            get { return m_Unk2; }
            set { m_Unk2 = value; }
        }

        /// <summary>
        /// Gets the unk3 of this item.
        /// </summary>
        public byte Unk3
        {
            get { return m_Unk3; }
            set { m_Unk3 = value; }
        }

        /// <summary>
        /// Gets the 'calculated height' of this item. For <see cref="Bridge">bridges</see>, this will be: <c>(<see cref="Height" /> / 2)</c>.
        /// </summary>
        public int CalcHeight
        {
            get
            {
                if ((m_Flags & TileFlag.Bridge) != 0)
                    return m_Height / 2;
                else
                    return m_Height;
            }
        }

        /// <summary>
        /// Whether or not this item is wearable as '<see cref="TileFlag.Wearable" />'.
        /// <seealso cref="TileFlag" />
        /// </summary>
        public bool Wearable
        {
            get { return ((m_Flags & TileFlag.Wearable) != 0); }
        }

        public void ReadData(string[] split)
        {
            m_Name = split[1];
            m_Weight = System.Convert.ToByte(split[2]);
            m_Quality = System.Convert.ToByte(split[3]);
            m_Animation = (short) TileData.ConvertStringToInt(split[4]);
            m_Height = System.Convert.ToByte(split[5]);
            m_Hue = System.Convert.ToByte(split[6]);
            m_Quantity = System.Convert.ToByte(split[7]);
            m_StackOffset = System.Convert.ToByte(split[8]);
            m_MiscData = System.Convert.ToInt16(split[9]);
            m_Unk1 = System.Convert.ToInt32(split[10]);
            m_Unk2 = System.Convert.ToByte(split[11]);
            m_Unk3 = System.Convert.ToByte(split[12]);

            m_Flags = 0;
            int temp = System.Convert.ToByte(split[13]);
            if (temp != 0)
                m_Flags |= TileFlag.Background;
            temp = System.Convert.ToByte(split[14]);
            if (temp != 0)
                m_Flags |= TileFlag.Weapon;
            temp = System.Convert.ToByte(split[15]);
            if (temp != 0)
                m_Flags |= TileFlag.Transparent;
            temp = System.Convert.ToByte(split[16]);
            if (temp != 0)
                m_Flags |= TileFlag.Translucent;
            temp = System.Convert.ToByte(split[17]);
            if (temp != 0)
                m_Flags |= TileFlag.Wall;
            temp = System.Convert.ToByte(split[18]);
            if (temp != 0)
                m_Flags |= TileFlag.Damaging;
            temp = System.Convert.ToByte(split[19]);
            if (temp != 0)
                m_Flags |= TileFlag.Impassable;
            temp = System.Convert.ToByte(split[20]);
            if (temp != 0)
                m_Flags |= TileFlag.Wet;
            temp = System.Convert.ToByte(split[21]);
            if (temp != 0)
                m_Flags |= TileFlag.Unknown1;
            temp = System.Convert.ToByte(split[22]);
            if (temp != 0)
                m_Flags |= TileFlag.Surface;
            temp = System.Convert.ToByte(split[23]);
            if (temp != 0)
                m_Flags |= TileFlag.Bridge;
            temp = System.Convert.ToByte(split[24]);
            if (temp != 0)
                m_Flags |= TileFlag.Generic;
            temp = System.Convert.ToByte(split[25]);
            if (temp != 0)
                m_Flags |= TileFlag.Window;
            temp = System.Convert.ToByte(split[26]);
            if (temp != 0)
                m_Flags |= TileFlag.NoShoot;
            temp = System.Convert.ToByte(split[27]);
            if (temp != 0)
                m_Flags |= TileFlag.ArticleA;
            temp = System.Convert.ToByte(split[28]);
            if (temp != 0)
                m_Flags |= TileFlag.ArticleAn;
            temp = System.Convert.ToByte(split[29]);
            if (temp != 0)
                m_Flags |= TileFlag.Internal;
            temp = System.Convert.ToByte(split[30]);
            if (temp != 0)
                m_Flags |= TileFlag.Foliage;
            temp = System.Convert.ToByte(split[31]);
            if (temp != 0)
                m_Flags |= TileFlag.PartialHue;
            temp = System.Convert.ToByte(split[32]);
            if (temp != 0)
                m_Flags |= TileFlag.Unknown2;
            temp = System.Convert.ToByte(split[33]);
            if (temp != 0)
                m_Flags |= TileFlag.Map;
            temp = System.Convert.ToByte(split[34]);
            if (temp != 0)
                m_Flags |= TileFlag.Container;
            temp = System.Convert.ToByte(split[35]);
            if (temp != 0)
                m_Flags |= TileFlag.Wearable;
            temp = System.Convert.ToByte(split[36]);
            if (temp != 0)
                m_Flags |= TileFlag.LightSource;
            temp = System.Convert.ToByte(split[37]);
            if (temp != 0)
                m_Flags |= TileFlag.Animation;
            temp = System.Convert.ToByte(split[38]);
            if (temp != 0)
                m_Flags |= TileFlag.HoverOver;
            temp = System.Convert.ToByte(split[39]);
            if (temp != 0)
                m_Flags |= TileFlag.Unknown3;
            temp = System.Convert.ToByte(split[40]);
            if (temp != 0)
                m_Flags |= TileFlag.Armor;
            temp = System.Convert.ToByte(split[41]);
            if (temp != 0)
                m_Flags |= TileFlag.Roof;
            temp = System.Convert.ToByte(split[42]);
            if (temp != 0)
                m_Flags |= TileFlag.Door;
            temp = System.Convert.ToByte(split[43]);
            if (temp != 0)
                m_Flags |= TileFlag.StairBack;
            temp = System.Convert.ToByte(split[44]);
            if (temp != 0)
                m_Flags |= TileFlag.StairRight;
        }
    }

    /// <summary>
    /// An enumeration of 32 different tile flags.
    /// <seealso cref="ItemData" />
    /// <seealso cref="LandData" />
    /// </summary>
    [Flags]
    public enum TileFlag
    {
        /// <summary>
        /// Nothing is flagged.
        /// </summary>
        None = 0x00000000,

        /// <summary>
        /// Not yet documented.
        /// </summary>
        Background = 0x00000001,

        /// <summary>
        /// Not yet documented.
        /// </summary>
        Weapon = 0x00000002,

        /// <summary>
        /// Not yet documented.
        /// </summary>
        Transparent = 0x00000004,

        /// <summary>
        /// The tile is rendered with partial alpha-transparency.
        /// </summary>
        Translucent = 0x00000008,

        /// <summary>
        /// The tile is a wall.
        /// </summary>
        Wall = 0x00000010,

        /// <summary>
        /// The tile can cause damage when moved over.
        /// </summary>
        Damaging = 0x00000020,

        /// <summary>
        /// The tile may not be moved over or through.
        /// </summary>
        Impassable = 0x00000040,

        /// <summary>
        /// Not yet documented.
        /// </summary>
        Wet = 0x00000080,

        /// <summary>
        /// Unknown.
        /// </summary>
        Unknown1 = 0x00000100,

        /// <summary>
        /// The tile is a surface. It may be moved over, but not through.
        /// </summary>
        Surface = 0x00000200,

        /// <summary>
        /// The tile is a stair, ramp, or ladder.
        /// </summary>
        Bridge = 0x00000400,

        /// <summary>
        /// The tile is stackable
        /// </summary>
        Generic = 0x00000800,

        /// <summary>
        /// The tile is a window. Like <see cref="TileFlag.NoShoot" />, tiles with this flag block line of sight.
        /// </summary>
        Window = 0x00001000,

        /// <summary>
        /// The tile blocks line of sight.
        /// </summary>
        NoShoot = 0x00002000,

        /// <summary>
        /// For single-amount tiles, the string "a " should be prepended to the tile name.
        /// </summary>
        ArticleA = 0x00004000,

        /// <summary>
        /// For single-amount tiles, the string "an " should be prepended to the tile name.
        /// </summary>
        ArticleAn = 0x00008000,

        /// <summary>
        /// Not yet documented.
        /// </summary>
        Internal = 0x00010000,

        /// <summary>
        /// The tile becomes translucent when walked behind. Boat masts also have this flag.
        /// </summary>
        Foliage = 0x00020000,

        /// <summary>
        /// Only gray pixels will be hued
        /// </summary>
        PartialHue = 0x00040000,

        /// <summary>
        /// Unknown.
        /// </summary>
        Unknown2 = 0x00080000,

        /// <summary>
        /// The tile is a map--in the cartography sense. Unknown usage.
        /// </summary>
        Map = 0x00100000,

        /// <summary>
        /// The tile is a container.
        /// </summary>
        Container = 0x00200000,

        /// <summary>
        /// The tile may be equiped.
        /// </summary>
        Wearable = 0x00400000,

        /// <summary>
        /// The tile gives off light.
        /// </summary>
        LightSource = 0x00800000,

        /// <summary>
        /// The tile is animated.
        /// </summary>
        Animation = 0x01000000,

        /// <summary>
        /// Gargoyles can fly over
        /// </summary>
        HoverOver = 0x02000000,

        /// <summary>
        /// Unknown.
        /// </summary>
        Unknown3 = 0x04000000,

        /// <summary>
        /// Not yet documented.
        /// </summary>
        Armor = 0x08000000,

        /// <summary>
        /// The tile is a slanted roof.
        /// </summary>
        Roof = 0x10000000,

        /// <summary>
        /// The tile is a door. Tiles with this flag can be moved through by ghosts and GMs.
        /// </summary>
        Door = 0x20000000,

        /// <summary>
        /// Not yet documented.
        /// </summary>
        StairBack = 0x40000000,

        /// <summary>
        /// Not yet documented.
        /// </summary>
        StairRight = unchecked((int) 0x80000000)
    }

    /// <summary>
    /// Contains lists of <see cref="LandData">land</see> and <see cref="ItemData">item</see> tile data.
    /// <seealso cref="LandData" />
    /// <seealso cref="ItemData" />
    /// </summary>
    public sealed class TileData
    {
        private static LandData[] m_LandData;
        private static ItemData[] m_ItemData;
        private static int[] m_HeightTable;

        /// <summary>
        /// Gets the list of <see cref="LandData">land tile data</see>.
        /// </summary>
        public static LandData[] LandTable
        {
            get { return m_LandData; }
            set { m_LandData = value; }
        }

        /// <summary>
        /// Gets the list of <see cref="ItemData">item tile data</see>.
        /// </summary>
        public static ItemData[] ItemTable
        {
            get { return m_ItemData; }
            set { m_ItemData = value; }
        }

        public static int[] HeightTable
        {
            get { return m_HeightTable; }
        }

        private static byte[] m_StringBuffer = new byte[20];

        private static string ReadNameString(BinaryReader bin)
        {
            bin.Read(m_StringBuffer, 0, 20);

            int count;

            for (count = 0; count < 20 && m_StringBuffer[count] != 0; ++count) ;

            return Encoding.Default.GetString(m_StringBuffer, 0, count);
        }

        public unsafe static string ReadNameString(byte* buffer)
        {
            int count;
            for (count = 0; count < 20 && *buffer != 0; ++count)
                m_StringBuffer[count] = *buffer++;

            return Encoding.Default.GetString(m_StringBuffer, 0, count);
        }

        private TileData()
        {
        }

        private static int[] landheader;
        private static int[] itemheader;

        static TileData()
        {
            Initialize();
        }

        public unsafe static void Initialize()
        {
            string filePath = Files.GetFilePath("tiledata.mul");

            if (filePath != null)
            {
                using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read))
                {
                    bool useNeWTileDataFormat = Art.IsUOAHS();
                    landheader = new int[512];
                    int j = 0;
                    m_LandData = new LandData[0x4000];

                    byte[] buffer = new byte[fs.Length];
                    GCHandle gc = GCHandle.Alloc(buffer, GCHandleType.Pinned);
                    long currpos = 0;
                    try
                    {
                        fs.Read(buffer, 0, buffer.Length);
                        for (int i = 0; i < 0x4000; i += 32)
                        {
                            IntPtr ptrheader = new IntPtr((long) gc.AddrOfPinnedObject() + currpos);
                            currpos += 4;
                            landheader[j++] = (int) Marshal.PtrToStructure(ptrheader, typeof(int));
                            for (int count = 0; count < 32; ++count)
                            {
                                IntPtr ptr = new IntPtr((long) gc.AddrOfPinnedObject() + currpos);
                                if (useNeWTileDataFormat)
                                {
                                    currpos += sizeof(NewLandTileDataMul);
                                    NewLandTileDataMul cur =
                                        (NewLandTileDataMul) Marshal.PtrToStructure(ptr, typeof(NewLandTileDataMul));
                                    m_LandData[i + count] = new LandData(cur);
                                }
                                else
                                {
                                    currpos += sizeof(OldLandTileDataMul);
                                    OldLandTileDataMul cur =
                                        (OldLandTileDataMul) Marshal.PtrToStructure(ptr, typeof(OldLandTileDataMul));
                                    m_LandData[i + count] = new LandData(cur);
                                }
                            }
                        }

                        long remaining = buffer.Length - currpos;
                        int structsize = useNeWTileDataFormat ? sizeof(NewItemTileDataMul) : sizeof(OldItemTileDataMul);
                        itemheader = new int[(remaining / ((structsize * 32) + 4))];
                        int itemlength = itemheader.Length * 32;

                        m_ItemData = new ItemData[itemlength];
                        m_HeightTable = new int[itemlength];

                        j = 0;
                        for (int i = 0; i < itemlength; i += 32)
                        {
                            IntPtr ptrheader = new IntPtr((long) gc.AddrOfPinnedObject() + currpos);
                            currpos += 4;
                            itemheader[j++] = (int) Marshal.PtrToStructure(ptrheader, typeof(int));
                            for (int count = 0; count < 32; ++count)
                            {
                                IntPtr ptr = new IntPtr((long) gc.AddrOfPinnedObject() + currpos);
                                if (useNeWTileDataFormat)
                                {
                                    currpos += sizeof(NewItemTileDataMul);
                                    NewItemTileDataMul cur =
                                        (NewItemTileDataMul) Marshal.PtrToStructure(ptr, typeof(NewItemTileDataMul));
                                    m_ItemData[i + count] = new ItemData(cur);
                                    m_HeightTable[i + count] = cur.height;
                                }
                                else
                                {
                                    currpos += sizeof(OldItemTileDataMul);
                                    OldItemTileDataMul cur =
                                        (OldItemTileDataMul) Marshal.PtrToStructure(ptr, typeof(OldItemTileDataMul));
                                    m_ItemData[i + count] = new ItemData(cur);
                                    m_HeightTable[i + count] = cur.height;
                                }
                            }
                        }
                    }
                    finally
                    {
                        gc.Free();
                    }
                }
            }
        }

        /// <summary>
        /// Saves <see cref="LandData"/> and <see cref="ItemData"/> to tiledata.mul
        /// </summary>
        /// <param name="FileName"></param>
        public static void SaveTileData(string FileName)
        {
            using (FileStream fs = new FileStream(FileName, FileMode.Create, FileAccess.Write, FileShare.Write))
            {
                using (BinaryWriter bin = new BinaryWriter(fs))
                {
                    int j = 0;
                    bool useNewTileDataFormat = Art.IsUOAHS();
                    for (int i = 0; i < 0x4000; ++i)
                    {
                        if ((i & 0x1F) == 0)
                            bin.Write(landheader[j++]); //header

                        bin.Write((int) m_LandData[i].Flags);
                        if (useNewTileDataFormat)
                            bin.Write((int) m_LandData[i].Unk1);

                        bin.Write(m_LandData[i].TextureID);
                        byte[] b = new byte[20];
                        if (m_LandData[i].Name != null)
                        {
                            byte[] bb = Encoding.Default.GetBytes(m_LandData[i].Name);
                            if (bb.Length > 20)
                                Array.Resize(ref bb, 20);
                            bb.CopyTo(b, 0);
                        }

                        bin.Write(b);
                    }

                    j = 0;
                    for (int i = 0; i < m_ItemData.Length; ++i)
                    {
                        if ((i & 0x1F) == 0)
                            bin.Write(itemheader[j++]); // header

                        bin.Write((int) m_ItemData[i].Flags);
                        if (useNewTileDataFormat)
                            bin.Write((int) m_ItemData[i].Unk1);

                        bin.Write(m_ItemData[i].Weight);
                        bin.Write(m_ItemData[i].Quality);
                        bin.Write(m_ItemData[i].MiscData);
                        bin.Write(m_ItemData[i].Unk2);
                        bin.Write(m_ItemData[i].Quantity);
                        bin.Write(m_ItemData[i].Animation);
                        bin.Write(m_ItemData[i].Unk3);
                        bin.Write(m_ItemData[i].Hue);
                        bin.Write(m_ItemData[i].StackingOffset); //unk4
                        bin.Write(m_ItemData[i].Value); //unk5
                        bin.Write(m_ItemData[i].Height);
                        byte[] b = new byte[20];
                        if (m_ItemData[i].Name != null)
                        {
                            byte[] bb = Encoding.Default.GetBytes(m_ItemData[i].Name);
                            if (bb.Length > 20)
                                Array.Resize(ref bb, 20);
                            bb.CopyTo(b, 0);
                        }

                        bin.Write(b);
                    }
                }
            }
        }

        /// <summary>
        /// Exports <see cref="ItemData"/> to csv file
        /// </summary>
        /// <param name="FileName"></param>
        public static void ExportItemDataToCSV(string FileName)
        {
            using (StreamWriter Tex = new StreamWriter(new FileStream(FileName, FileMode.Create, FileAccess.ReadWrite),
                System.Text.Encoding.GetEncoding(1252)))
            {
                Tex.Write(
                    "ID;Name;Weight/Quantity;Layer/Quality;Gump/AnimID;Height;Hue;Class/Quantity;StackingOffset;MiscData;Unknown1;Unknown2;Unknown3");
                Tex.Write(";Background;Weapon;Transparent;Translucent;Wall;Damage;Impassible;Wet;Unknow1");
                Tex.Write(";Surface;Bridge;Generic;Window;NoShoot;PrefixA;PrefixAn;Internal;Foliage;PartialHue");
                Tex.Write(";Unknow2;Map;Container/Height;Wearable;Lightsource;Animation;HoverOver");
                Tex.WriteLine(";Unknow3;Armor;Roof;Door;StairBack;StairRight");

                for (int i = 0; i < m_ItemData.Length; ++i)
                {
                    ItemData tile = m_ItemData[i];
                    Tex.Write($"0x{i:X4}");
                    Tex.Write($";{tile.Name}");
                    Tex.Write(";" + tile.Weight);
                    Tex.Write(";" + tile.Quality);
                    Tex.Write($";0x{tile.Animation:X4}");
                    Tex.Write(";" + tile.Height);
                    Tex.Write(";" + tile.Hue);
                    Tex.Write(";" + tile.Quantity);
                    Tex.Write(";" + tile.StackingOffset);
                    Tex.Write(";" + tile.MiscData);
                    Tex.Write(";" + tile.Unk1);
                    Tex.Write(";" + tile.Unk2);
                    Tex.Write(";" + tile.Unk3);

                    Tex.Write(";" + (((tile.Flags & TileFlag.Background) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Weapon) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Transparent) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Translucent) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Wall) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Damaging) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Impassable) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Wet) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Unknown1) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Surface) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Bridge) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Generic) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Window) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.NoShoot) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.ArticleA) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.ArticleAn) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Internal) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Foliage) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.PartialHue) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Unknown2) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Map) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Container) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Wearable) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.LightSource) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Animation) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.HoverOver) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Unknown3) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Armor) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Roof) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Door) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.StairBack) != 0) ? "1" : "0"));
                    Tex.WriteLine(";" + (((tile.Flags & TileFlag.StairRight) != 0) ? "1" : "0"));
                }
            }
        }

        /// <summary>
        /// Exports <see cref="LandData"/> to csv file
        /// </summary>
        /// <param name="FileName"></param>
        public static void ExportLandDataToCSV(string FileName)
        {
            using (StreamWriter Tex = new StreamWriter(new FileStream(FileName, FileMode.Create, FileAccess.ReadWrite)))
            {
                Tex.Write("ID;Name;TextureID;HSAUnk1");
                Tex.Write(";Background;Weapon;Transparent;Translucent;Wall;Damage;Impassible;Wet;Unknow1");
                Tex.Write(";Surface;Bridge;Generic;Window;NoShoot;PrefixA;PrefixAn;Internal;Foliage;PartialHue");
                Tex.Write(";Unknow2;Map;Container/Height;Wearable;Lightsource;Animation;HoverOver");
                Tex.WriteLine(";Unknow3;Armor;Roof;Door;StairBack;StairRight");

                for (int i = 0; i < m_LandData.Length; ++i)
                {
                    LandData tile = m_LandData[i];
                    Tex.Write($"0x{i:X4}");
                    Tex.Write(";" + tile.Name);
                    Tex.Write(";" + $"0x{tile.TextureID:X4}");
                    Tex.Write(";" + tile.Unk1);

                    Tex.Write(";" + (((tile.Flags & TileFlag.Background) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Weapon) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Transparent) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Translucent) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Wall) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Damaging) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Impassable) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Wet) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Unknown1) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Surface) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Bridge) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Generic) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Window) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.NoShoot) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.ArticleA) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.ArticleAn) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Internal) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Foliage) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.PartialHue) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Unknown2) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Map) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Container) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Wearable) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.LightSource) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Animation) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.HoverOver) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Unknown3) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Armor) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Roof) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.Door) != 0) ? "1" : "0"));
                    Tex.Write(";" + (((tile.Flags & TileFlag.StairBack) != 0) ? "1" : "0"));
                    Tex.WriteLine(";" + (((tile.Flags & TileFlag.StairRight) != 0) ? "1" : "0"));
                }
            }
        }

        public static int ConvertStringToInt(string text)
        {
            int result;
            if (text.Contains("0x"))
            {
                string convert = text.Replace("0x", "");
                int.TryParse(convert, System.Globalization.NumberStyles.HexNumber, null, out result);
            }
            else
                int.TryParse(text, System.Globalization.NumberStyles.Integer, null, out result);

            return result;
        }

        public static void ImportItemDataFromCSV(string FileName)
        {
            if (!File.Exists(FileName))
                return;
            using (StreamReader sr = new StreamReader(FileName))
            {
                string line;
                while ((line = sr.ReadLine()) != null)
                {
                    if ((line = line.Trim()).Length == 0 || line.StartsWith("#"))
                        continue;
                    if (line.StartsWith("ID;"))
                        continue;
                    try
                    {
                        string[] split = line.Split(';');
                        if (split.Length < 45)
                            continue;

                        int id = ConvertStringToInt(split[0]);
                        m_ItemData[id].ReadData(split);
                    }
                    catch
                    {
                    }
                }
            }
        }

        public static void ImportLandDataFromCSV(string FileName)
        {
            if (!File.Exists(FileName))
                return;
            using (StreamReader sr = new StreamReader(FileName))
            {
                string line;
                while ((line = sr.ReadLine()) != null)
                {
                    if ((line = line.Trim()).Length == 0 || line.StartsWith("#"))
                        continue;
                    if (line.StartsWith("ID;"))
                        continue;
                    try
                    {
                        string[] split = line.Split(';');
                        if (split.Length < 36)
                            continue;

                        int id = ConvertStringToInt(split[0]);
                        m_LandData[id].ReadData(split);
                    }
                    catch
                    {
                    }
                }
            }
        }
    }

    [StructLayout(System.Runtime.InteropServices.LayoutKind.Sequential, Pack = 1)]
    public unsafe struct OldLandTileDataMul
    {
        public int flags;
        public short texID;
        public fixed byte name[20];
    }

    [StructLayout(System.Runtime.InteropServices.LayoutKind.Sequential, Pack = 1)]
    public unsafe struct NewLandTileDataMul
    {
        public int flags;
        public int unk1;
        public short texID;
        public fixed byte name[20];
    }

    [StructLayout(System.Runtime.InteropServices.LayoutKind.Sequential, Pack = 1)]
    public unsafe struct OldItemTileDataMul
    {
        public int flags;
        public byte weight;
        public byte quality;
        public short miscdata;
        public byte unk2;
        public byte quantity;
        public short anim;
        public byte unk3;
        public byte hue;
        public byte stackingoffset;
        public byte value;
        public byte height;
        public fixed byte name[20];
    }

    [StructLayout(System.Runtime.InteropServices.LayoutKind.Sequential, Pack = 1)]
    public unsafe struct NewItemTileDataMul
    {
        public int flags;
        public int unk1;
        public byte weight;
        public byte quality;
        public short miscdata;
        public byte unk2;
        public byte quantity;
        public short anim;
        public byte unk3;
        public byte hue;
        public byte stackingoffset;
        public byte value;
        public byte height;
        public fixed byte name[20];
    }
}

================================================
FILE: Razor/UltimaSDK/TileList.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System.Collections.Generic;

namespace Ultima
{
    public sealed class HuedTileList
    {
        private List<HuedTile> m_Tiles;

        public HuedTileList()
        {
            m_Tiles = new List<HuedTile>();
        }

        public int Count
        {
            get { return m_Tiles.Count; }
        }

        public void Add(ushort id, short hue, sbyte z)
        {
            m_Tiles.Add(new HuedTile(id, hue, z));
        }

        public HuedTile[] ToArray()
        {
            HuedTile[] tiles = new HuedTile[Count];

            if (m_Tiles.Count > 0)
                m_Tiles.CopyTo(tiles);
            m_Tiles.Clear();

            return tiles;
        }
    }

    public sealed class TileList
    {
        private List<Tile> m_Tiles;

        public TileList()
        {
            m_Tiles = new List<Tile>();
        }

        public int Count
        {
            get { return m_Tiles.Count; }
        }

        public void Add(ushort id, sbyte z)
        {
            m_Tiles.Add(new Tile(id, z));
        }

        public void Add(ushort id, sbyte z, sbyte flag)
        {
            m_Tiles.Add(new Tile(id, z, flag));
        }

        public Tile[] ToArray()
        {
            Tile[] tiles = new Tile[Count];
            if (m_Tiles.Count > 0)
                m_Tiles.CopyTo(tiles);
            m_Tiles.Clear();

            return tiles;
        }

        public Tile Get(int i)
        {
            return m_Tiles[i];
        }
    }

    public sealed class MTileList
    {
        private List<MTile> m_Tiles;

        public MTileList()
        {
            m_Tiles = new List<MTile>();
        }

        public int Count
        {
            get { return m_Tiles.Count; }
        }

        public void Add(ushort id, sbyte z)
        {
            m_Tiles.Add(new MTile(id, z));
        }

        public void Add(ushort id, sbyte z, sbyte flag)
        {
            m_Tiles.Add(new MTile(id, z, flag));
        }

        public void Add(ushort id, sbyte z, sbyte flag, int unk1)
        {
            m_Tiles.Add(new MTile(id, z, flag, unk1));
        }

        public MTile[] ToArray()
        {
            MTile[] tiles = new MTile[Count];

            if (m_Tiles.Count > 0)
                m_Tiles.CopyTo(tiles);
            m_Tiles.Clear();

            return tiles;
        }

        public MTile Get(int i)
        {
            return m_Tiles[i];
        }

        public void Set(int i, ushort id, sbyte z)
        {
            if (i < Count)
                m_Tiles[i].Set(id, z);
        }

        public void Set(int i, ushort id, sbyte z, sbyte flag)
        {
            if (i < Count)
                m_Tiles[i].Set(id, z, flag);
        }

        public void Set(int i, ushort id, sbyte z, sbyte flag, int unk1)
        {
            if (i < Count)
                m_Tiles[i].Set(id, z, flag, unk1);
        }

        public void Remove(int i)
        {
            if (i < Count)
                m_Tiles.RemoveAt(i);
        }
    }
}

================================================
FILE: Razor/UltimaSDK/TileMatrix.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.InteropServices;

namespace Ultima
{
    public sealed class TileMatrix
    {
        private HuedTile[][][][][] m_StaticTiles;
        private Tile[][][] m_LandTiles;
        private bool[][] m_RemovedStaticBlock;
        private List<StaticTile>[][] m_StaticTiles_ToAdd;

        public static Tile[] InvalidLandBlock { get; private set; }
        public static HuedTile[][][] EmptyStaticBlock { get; private set; }

        private FileStream m_Map;
        private BinaryReader m_UOPReader;
        private FileStream m_Statics;
        private Entry3D[] m_StaticIndex;

        public Entry3D[] StaticIndex
        {
            get
            {
                if (!StaticIndexInit) InitStatics();
                return m_StaticIndex;
            }
        }

        public bool StaticIndexInit;

        public TileMatrixPatch Patch { get; private set; }

        public int BlockWidth { get; private set; }

        public int BlockHeight { get; private set; }

        public int Width { get; private set; }

        public int Height { get; private set; }

        private string mapPath;
        private string indexPath;
        private string staticsPath;

        public void CloseStreams()
        {
            if (m_Map != null)
                m_Map.Close();

            if (m_UOPReader != null)
                m_UOPReader.Close();

            if (m_Statics != null)
                m_Statics.Close();
        }

        public TileMatrix(int fileIndex, int mapID, int width, int height, string path)
        {
            Width = width;
            Height = height;
            BlockWidth = width >> 3;
            BlockHeight = height >> 3;


            if (path == null)
            {
                mapPath = Files.GetFilePath("map{0}.mul", fileIndex);

                if (String.IsNullOrEmpty(mapPath) || !File.Exists(mapPath))
                    mapPath = Files.GetFilePath("map{0}LegacyMUL.uop", fileIndex);

                if (mapPath != null && mapPath.EndsWith(".uop"))
                    IsUOPFormat = true;

                // For shards that use Fel and Tram before the split
                if (String.IsNullOrEmpty(mapPath) || (!File.Exists(mapPath) && fileIndex == 1))
                {
                    fileIndex = 0;
                    mapPath = Files.GetFilePath("map{0}.mul", fileIndex);
                }
            }
            else
            {
                mapPath = Path.Combine(path, $"map{fileIndex}.mul");

                if (!File.Exists(mapPath))
                    mapPath = Path.Combine(path, $"map{fileIndex}LegacyMUL.uop");

                if (!File.Exists(mapPath))
                    mapPath = null;
                else if (mapPath != null && mapPath.EndsWith(".uop"))
                    IsUOPFormat = true;
            }

            if (mapPath != null && fileIndex == 0)
            {
                FileInfo fi = new FileInfo(mapPath);
                if (fi.Length < 89915392)
                {
                    // Old map size.
                    Width = 6144;
                }
            }

            if (path == null)
                indexPath = Files.GetFilePath("staidx{0}.mul", fileIndex);
            else
            {
                indexPath = Path.Combine(path, $"staidx{fileIndex}.mul");
                if (!File.Exists(indexPath))
                    indexPath = null;
            }

            if (path == null)
                staticsPath = Files.GetFilePath("statics{0}.mul", fileIndex);
            else
            {
                staticsPath = Path.Combine(path, $"statics{fileIndex}.mul");
                if (!File.Exists(staticsPath))
                    staticsPath = null;
            }

            EmptyStaticBlock = new HuedTile[8][][];

            for (int i = 0; i < 8; ++i)
            {
                EmptyStaticBlock[i] = new HuedTile[8][];

                for (int j = 0; j < 8; ++j)
                {
                    EmptyStaticBlock[i][j] = new HuedTile[0];
                }
            }

            InvalidLandBlock = new Tile[196];

            m_LandTiles = new Tile[BlockWidth][][];
            m_StaticTiles = new HuedTile[BlockWidth][][][][];

            Patch = new TileMatrixPatch(this, mapID, path);
        }


        public void SetStaticBlock(int x, int y, HuedTile[][][] value)
        {
            if (x < 0 || y < 0 || x >= BlockWidth || y >= BlockHeight)
                return;

            if (m_StaticTiles[x] == null)
                m_StaticTiles[x] = new HuedTile[BlockHeight][][][];

            m_StaticTiles[x][y] = value;
        }

        public HuedTile[][][] GetStaticBlock(int x, int y)
        {
            return GetStaticBlock(x, y, true);
        }

        public HuedTile[][][] GetStaticBlock(int x, int y, bool patch)
        {
            if (x < 0 || y < 0 || x >= BlockWidth || y >= BlockHeight)
                return EmptyStaticBlock;

            if (m_StaticTiles[x] == null)
                m_StaticTiles[x] = new HuedTile[BlockHeight][][][];

            HuedTile[][][] tiles = m_StaticTiles[x][y];

            if (tiles == null)
                tiles = m_StaticTiles[x][y] = ReadStaticBlock(x, y);

            if ((Map.UseDiff) && (patch))
            {
                if (Patch.StaticBlocksCount > 0)
                {
                    if (Patch.StaticBlocks[x] != null)
                    {
                        if (Patch.StaticBlocks[x][y] != null)
                            tiles = Patch.StaticBlocks[x][y];
                    }
                }
            }

            return tiles;
        }

        public HuedTile[] GetStaticTiles(int x, int y, bool patch)
        {
            return GetStaticBlock(x >> 3, y >> 3, patch)[x & 0x7][y & 0x7];
        }

        public HuedTile[] GetStaticTiles(int x, int y)
        {
            return GetStaticBlock(x >> 3, y >> 3)[x & 0x7][y & 0x7];
        }

        public void SetLandBlock(int x, int y, Tile[] value)
        {
            if (x < 0 || y < 0 || x >= BlockWidth || y >= BlockHeight)
                return;

            if (m_LandTiles[x] == null)
                m_LandTiles[x] = new Tile[BlockHeight][];

            m_LandTiles[x][y] = value;
        }

        public Tile[] GetLandBlock(int x, int y)
        {
            return GetLandBlock(x, y, true);
        }

        public Tile[] GetLandBlock(int x, int y, bool patch)
        {
            if (x < 0 || y < 0 || x >= BlockWidth || y >= BlockHeight)
                return InvalidLandBlock;

            if (m_LandTiles[x] == null)
                m_LandTiles[x] = new Tile[BlockHeight][];

            Tile[] tiles = m_LandTiles[x][y];

            if (tiles == null)
                tiles = m_LandTiles[x][y] = ReadLandBlock(x, y);

            if ((Map.UseDiff) && (patch))
            {
                if (Patch.LandBlocksCount > 0)
                {
                    if (Patch.LandBlocks[x] != null)
                    {
                        if (Patch.LandBlocks[x][y] != null)
                            tiles = Patch.LandBlocks[x][y];
                    }
                }
            }

            return tiles;
        }

        public Tile GetLandTile(int x, int y, bool patch)
        {
            return GetLandBlock(x >> 3, y >> 3, patch)[((y & 0x7) << 3) + (x & 0x7)];
        }

        public Tile GetLandTile(int x, int y)
        {
            return GetLandBlock(x >> 3, y >> 3)[((y & 0x7) << 3) + (x & 0x7)];
        }


        private unsafe void InitStatics()
        {
            m_StaticIndex = new Entry3D[BlockHeight * BlockWidth];
            if (indexPath == null)
                return;
            using (FileStream index = new FileStream(indexPath, FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                m_Statics = new FileStream(staticsPath, FileMode.Open, FileAccess.Read, FileShare.Read);
                int count = (int) (index.Length / 12);
                GCHandle gc = GCHandle.Alloc(m_StaticIndex, GCHandleType.Pinned);
                byte[] buffer = new byte[index.Length];
                index.Read(buffer, 0, (int) index.Length);
                Marshal.Copy(buffer, 0, gc.AddrOfPinnedObject(),
                    (int) Math.Min(index.Length, BlockHeight * BlockWidth * 12));
                gc.Free();
                for (int i = (int) Math.Min(index.Length, BlockHeight * BlockWidth); i < BlockHeight * BlockWidth; ++i)
                {
                    m_StaticIndex[i].lookup = -1;
                    m_StaticIndex[i].length = -1;
                    m_StaticIndex[i].extra = -1;
                }

                StaticIndexInit = true;
            }
        }

        private static HuedTileList[][] m_Lists;
        private static byte[] m_Buffer;

        private unsafe HuedTile[][][] ReadStaticBlock(int x, int y)
        {
            try
            {
                if (!StaticIndexInit)
                    InitStatics();
                if (m_Statics == null || !m_Statics.CanRead || !m_Statics.CanSeek)
                {
                    if (staticsPath == null)
                        m_Statics = null;
                    else
                        m_Statics = new FileStream(staticsPath, FileMode.Open, FileAccess.Read, FileShare.Read);
                }

                if (m_Statics == null)
                    return EmptyStaticBlock;

                int lookup = m_StaticIndex[(x * BlockHeight) + y].lookup;
                int length = m_StaticIndex[(x * BlockHeight) + y].length;

                if (lookup < 0 || length <= 0)
                    return EmptyStaticBlock;
                else
                {
                    int count = length / 7;

                    m_Statics.Seek(lookup, SeekOrigin.Begin);

                    if (m_Buffer == null || m_Buffer.Length < length)
                        m_Buffer = new byte[length];

                    GCHandle gc = GCHandle.Alloc(m_Buffer, GCHandleType.Pinned);
                    try
                    {
                        m_Statics.Read(m_Buffer, 0, length);

                        if (m_Lists == null)
                        {
                            m_Lists = new HuedTileList[8][];

                            for (int i = 0; i < 8; ++i)
                            {
                                m_Lists[i] = new HuedTileList[8];

                                for (int j = 0; j < 8; ++j)
                                    m_Lists[i][j] = new HuedTileList();
                            }
                        }

                        HuedTileList[][] lists = m_Lists;

                        for (int i = 0; i < count; ++i)
                        {
                            IntPtr ptr = new IntPtr((long) gc.AddrOfPinnedObject() + i * sizeof(StaticTile));
                            StaticTile cur = (StaticTile) Marshal.PtrToStructure(ptr, typeof(StaticTile));
                            lists[cur.m_X & 0x7][cur.m_Y & 0x7].Add(Art.GetLegalItemID(cur.m_ID), cur.m_Hue, cur.m_Z);
                        }

                        HuedTile[][][] tiles = new HuedTile[8][][];

                        for (int i = 0; i < 8; ++i)
                        {
                            tiles[i] = new HuedTile[8][];

                            for (int j = 0; j < 8; ++j)
                                tiles[i][j] = lists[i][j].ToArray();
                        }

                        return tiles;
                    }
                    finally
                    {
                        gc.Free();
                    }
                }
            }
            finally
            {
                //if (m_Statics != null)
                //    m_Statics.Close();
            }
        }

        /* UOP map files support code, written by Wyatt (c) www.ruosi.org
         * It's not possible if some entry has unknown hash. Throwed exception
         * means that EA changed maps UOPs again.
         */

        #region UOP

        public bool IsUOPFormat { get; set; }
        public bool IsUOPAlreadyRead { get; set; }

        private struct UOPFile
        {
            public long Offset;
            public int Length;

            public UOPFile(long offset, int length)
            {
                Offset = offset;
                Length = length;
            }
        }

        private UOPFile[] UOPFiles { get; set; }

        private long UOPLength
        {
            get { return m_Map.Length; }
        }

        private void ReadUOPFiles(string pattern)
        {
            m_UOPReader = new BinaryReader(m_Map);

            m_UOPReader.BaseStream.Seek(0, SeekOrigin.Begin);

            if (m_UOPReader.ReadInt32() != 0x50594D)
                throw new ArgumentException("Bad UOP file.");

            m_UOPReader.ReadInt64(); // version + signature
            long nextBlock = m_UOPReader.ReadInt64();
            m_UOPReader.ReadInt32(); // block capacity
            int count = m_UOPReader.ReadInt32();

            UOPFiles = new UOPFile[count];

            Dictionary<ulong, int> hashes = new Dictionary<ulong, int>();

            for (int i = 0; i < count; i++)
            {
                string file = $"build/{pattern}/{i:D8}.dat";
                ulong hash = FileIndex.HashFileName(file);

                if (!hashes.ContainsKey(hash))
                    hashes.Add(hash, i);
            }

            m_UOPReader.BaseStream.Seek(nextBlock, SeekOrigin.Begin);

            do
            {
                int filesCount = m_UOPReader.ReadInt32();
                nextBlock = m_UOPReader.ReadInt64();

                for (int i = 0; i < filesCount; i++)
                {
                    long offset = m_UOPReader.ReadInt64();
                    int headerLength = m_UOPReader.ReadInt32();
                    int compressedLength = m_UOPReader.ReadInt32();
                    int decompressedLength = m_UOPReader.ReadInt32();
                    ulong hash = m_UOPReader.ReadUInt64();
                    m_UOPReader.ReadUInt32(); // Adler32
                    short flag = m_UOPReader.ReadInt16();

                    int length = flag == 1 ? compressedLength : decompressedLength;

                    if (offset == 0)
                        continue;

                    int idx;
                    if (hashes.TryGetValue(hash, out idx))
                    {
                        if (idx < 0 || idx > UOPFiles.Length)
                            throw new IndexOutOfRangeException(
                                "hashes dictionary and files collection have different count of entries!");

                        UOPFiles[idx] = new UOPFile(offset + headerLength, length);
                    }
                    else
                    {
                        throw new ArgumentException(
                            $"File with hash 0x{hash:X8} was not found in hashes dictionary! EA Mythic changed UOP format!");
                    }
                }
            } while (m_UOPReader.BaseStream.Seek(nextBlock, SeekOrigin.Begin) != 0);
        }

        private long CalculateOffsetFromUOP(long offset)
        {
            long pos = 0;

            foreach (UOPFile t in UOPFiles)
            {
                long currPos = pos + t.Length;

                if (offset < currPos)
                    return t.Offset + (offset - pos);

                pos = currPos;
            }

            return UOPLength;
        }

        #endregion

        private unsafe Tile[] ReadLandBlock(int x, int y)
        {
            if (m_Map == null || !m_Map.CanRead || !m_Map.CanSeek)
            {
                if (mapPath == null)
                    m_Map = null;
                else
                    m_Map = new FileStream(mapPath, FileMode.Open, FileAccess.Read, FileShare.Read);

                if (IsUOPFormat && mapPath != null && !IsUOPAlreadyRead)
                {
                    FileInfo fi = new FileInfo(mapPath);
                    string uopPattern = fi.Name.Replace(fi.Extension, "").ToLowerInvariant();

                    ReadUOPFiles(uopPattern);
                    IsUOPAlreadyRead = true;
                }
            }

            Tile[] tiles = new Tile[64];
            if (m_Map != null)
            {
                long offset = ((x * BlockHeight) + y) * 196 + 4;

                if (IsUOPFormat)
                    offset = CalculateOffsetFromUOP(offset);

                m_Map.Seek(offset, SeekOrigin.Begin);

                GCHandle gc = GCHandle.Alloc(tiles, GCHandleType.Pinned);
                try
                {
                    if (m_Buffer == null || m_Buffer.Length < 192)
                        m_Buffer = new byte[192];

                    m_Map.Read(m_Buffer, 0, 192);

                    Marshal.Copy(m_Buffer, 0, gc.AddrOfPinnedObject(), 192);
                }
                finally
                {
                    gc.Free();
                }

                //m_Map.Close();
            }

            return tiles;
        }

        public void RemoveStaticBlock(int blockx, int blocky)
        {
            if (m_RemovedStaticBlock == null)
                m_RemovedStaticBlock = new bool[BlockWidth][];
            if (m_RemovedStaticBlock[blockx] == null)
                m_RemovedStaticBlock[blockx] = new bool[BlockHeight];
            m_RemovedStaticBlock[blockx][blocky] = true;
            if (m_StaticTiles[blockx] == null)
                m_StaticTiles[blockx] = new HuedTile[BlockHeight][][][];
            m_StaticTiles[blockx][blocky] = EmptyStaticBlock;
        }

        public bool IsStaticBlockRemoved(int blockx, int blocky)
        {
            if (m_RemovedStaticBlock == null)
                return false;
            if (m_RemovedStaticBlock[blockx] == null)
                return false;
            return m_RemovedStaticBlock[blockx][blocky];
        }

        public bool PendingStatic(int blockx, int blocky)
        {
            if (m_StaticTiles_ToAdd == null)
                return false;
            if (m_StaticTiles_ToAdd[blocky] == null)
                return false;
            if (m_StaticTiles_ToAdd[blocky][blockx] == null)
                return false;
            return true;
        }

        public void AddPendingStatic(int blockx, int blocky, StaticTile toadd)
        {
            if (m_StaticTiles_ToAdd == null)
                m_StaticTiles_ToAdd = new List<StaticTile>[BlockHeight][];
            if (m_StaticTiles_ToAdd[blocky] == null)
                m_StaticTiles_ToAdd[blocky] = new List<StaticTile>[BlockWidth];
            if (m_StaticTiles_ToAdd[blocky][blockx] == null)
                m_StaticTiles_ToAdd[blocky][blockx] = new List<StaticTile>();
            m_StaticTiles_ToAdd[blocky][blockx].Add(toadd);
        }

        public StaticTile[] GetPendingStatics(int blockx, int blocky)
        {
            if (m_StaticTiles_ToAdd == null)
                return null;
            if (m_StaticTiles_ToAdd[blocky] == null)
                return null;
            if (m_StaticTiles_ToAdd[blocky][blockx] == null)
                return null;

            return m_StaticTiles_ToAdd[blocky][blockx].ToArray();
        }

        public void Dispose()
        {
            if (m_Map != null)
                m_Map.Close();

            if (m_UOPReader != null)
                m_UOPReader.Close();

            if (m_Statics != null)
                m_Statics.Close();
        }
    }

    [System.Runtime.InteropServices.StructLayout(System.Runtime.InteropServices.LayoutKind.Sequential, Pack = 1)]
    public struct StaticTile
    {
        public ushort m_ID;
        public byte m_X;
        public byte m_Y;
        public sbyte m_Z;
        public short m_Hue;
    }

    [System.Runtime.InteropServices.StructLayout(System.Runtime.InteropServices.LayoutKind.Sequential, Pack = 1)]
    public struct HuedTile
    {
        internal sbyte m_Z;
        internal ushort m_ID;
        internal int m_Hue;

        public ushort ID
        {
            get { return m_ID; }
            set { m_ID = value; }
        }

        public int Hue
        {
            get { return m_Hue; }
            set { m_Hue = value; }
        }

        public int Z
        {
            get { return m_Z; }
            set { m_Z = (sbyte) value; }
        }

        public HuedTile(ushort id, short hue, sbyte z)
        {
            m_ID = id;
            m_Hue = hue;
            m_Z = z;
        }

        public void Set(ushort id, short hue, sbyte z)
        {
            m_ID = id;
            m_Hue = hue;
            m_Z = z;
        }
    }

    public struct MTile : IComparable
    {
        internal ushort m_ID;
        internal sbyte m_Z;
        internal sbyte m_Flag;
        internal int m_Unk1;
        internal int m_Solver;

        public ushort ID
        {
            get { return m_ID; }
        }

        public int Z
        {
            get { return m_Z; }
            set { m_Z = (sbyte) value; }
        }

        public int Flag
        {
            get { return m_Flag; }
            set { m_Flag = (sbyte) value; }
        }

        public int Unk1
        {
            get { return m_Unk1; }
            set { m_Unk1 = value; }
        }

        public int Solver
        {
            get { return m_Solver; }
            set { m_Solver = value; }
        }

        public MTile(ushort id, sbyte z)
        {
            m_ID = Art.GetLegalItemID(id);
            m_Z = z;
            m_Flag = 1;
            m_Solver = 0;
            m_Unk1 = 0;
        }

        public MTile(ushort id, sbyte z, sbyte flag)
        {
            m_ID = Art.GetLegalItemID(id);
            m_Z = z;
            m_Flag = flag;
            m_Solver = 0;
            m_Unk1 = 0;
        }

        public MTile(ushort id, sbyte z, sbyte flag, int unk1)
        {
            m_ID = Art.GetLegalItemID(id);
            m_Z = z;
            m_Flag = flag;
            m_Solver = 0;
            m_Unk1 = unk1;
        }

        public void Set(ushort id, sbyte z)
        {
            m_ID = Art.GetLegalItemID(id);
            m_Z = z;
        }

        public void Set(ushort id, sbyte z, sbyte flag)
        {
            m_ID = Art.GetLegalItemID(id);
            m_Z = z;
            m_Flag = flag;
        }

        public void Set(ushort id, sbyte z, sbyte flag, int unk1)
        {
            m_ID = Art.GetLegalItemID(id);
            m_Z = z;
            m_Flag = flag;
            m_Unk1 = unk1;
        }

        public int CompareTo(object x)
        {
            if (x == null)
                return 1;

            if (!(x is MTile))
                throw new ArgumentNullException();

            MTile a = (MTile) x;

            ItemData ourData = TileData.ItemTable[m_ID];
            ItemData theirData = TileData.ItemTable[a.ID];

            int ourTreshold = 0;
            if (ourData.Height > 0)
                ++ourTreshold;
            if (!ourData.Background)
                ++ourTreshold;
            int ourZ = Z;
            int theirTreshold = 0;
            if (theirData.Height > 0)
                ++theirTreshold;
            if (!theirData.Background)
                ++theirTreshold;
            int theirZ = a.Z;

            ourZ += ourTreshold;
            theirZ += theirTreshold;
            int res = ourZ - theirZ;
            if (res == 0)
                res = ourTreshold - theirTreshold;
            if (res == 0)
                res = m_Solver - a.Solver;
            return res;
        }
    }

    [System.Runtime.InteropServices.StructLayout(System.Runtime.InteropServices.LayoutKind.Sequential, Pack = 1)]
    public struct Tile : IComparable
    {
        internal ushort m_ID;
        internal sbyte m_Z;

        public ushort ID
        {
            get { return m_ID; }
        }

        public int Z
        {
            get { return m_Z; }
            set { m_Z = (sbyte) value; }
        }

        public Tile(ushort id, sbyte z)
        {
            m_ID = id;
            m_Z = z;
        }

        public Tile(ushort id, sbyte z, sbyte flag)
        {
            m_ID = id;
            m_Z = z;
        }

        public void Set(ushort id, sbyte z)
        {
            m_ID = id;
            m_Z = z;
        }

        public void Set(ushort id, sbyte z, sbyte flag)
        {
            m_ID = id;
            m_Z = z;
        }

        public int CompareTo(object x)
        {
            if (x == null)
                return 1;

            if (!(x is Tile))
                throw new ArgumentNullException();

            Tile a = (Tile) x;

            if (m_Z > a.m_Z)
                return 1;
            else if (a.m_Z > m_Z)
                return -1;

            ItemData ourData = TileData.ItemTable[m_ID];
            ItemData theirData = TileData.ItemTable[a.m_ID];

            if (ourData.Height > theirData.Height)
                return 1;
            else if (theirData.Height > ourData.Height)
                return -1;

            if (ourData.Background && !theirData.Background)
                return -1;
            else if (theirData.Background && !ourData.Background)
                return 1;

            return 0;
        }
    }
}

================================================
FILE: Razor/UltimaSDK/TileMatrixPatch.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.IO;
using System.Runtime.InteropServices;

namespace Ultima
{
    public sealed class TileMatrixPatch
    {
        public int LandBlocksCount { get; private set; }
        public int StaticBlocksCount { get; private set; }

        public Tile[][][] LandBlocks { get; private set; }
        public HuedTile[][][][][] StaticBlocks { get; private set; }

        private int BlockWidth;
        private int BlockHeight;

        private static byte[] m_Buffer;
        private static StaticTile[] m_TileBuffer = new StaticTile[128];

        public bool IsLandBlockPatched(int x, int y)
        {
            if (x < 0 || y < 0 || x >= BlockWidth || y >= BlockHeight)
                return false;
            if (LandBlocks[x] == null)
                return false;
            if (LandBlocks[x][y] == null)
                return false;
            return true;
        }

        public Tile[] GetLandBlock(int x, int y)
        {
            if (x < 0 || y < 0 || x >= BlockWidth || y >= BlockHeight)
                return TileMatrix.InvalidLandBlock;
            if (LandBlocks[x] == null)
                return TileMatrix.InvalidLandBlock;
            return LandBlocks[x][y];
        }

        public Tile GetLandTile(int x, int y)
        {
            return GetLandBlock(x >> 3, y >> 3)[((y & 0x7) << 3) + (x & 0x7)];
        }

        public bool IsStaticBlockPatched(int x, int y)
        {
            if (x < 0 || y < 0 || x >= BlockWidth || y >= BlockHeight)
                return false;
            if (StaticBlocks[x] == null)
                return false;
            if (StaticBlocks[x][y] == null)
                return false;
            return true;
        }

        public HuedTile[][][] GetStaticBlock(int x, int y)
        {
            if (x < 0 || y < 0 || x >= BlockWidth || y >= BlockHeight)
                return TileMatrix.EmptyStaticBlock;
            if (StaticBlocks[x] == null)
                return TileMatrix.EmptyStaticBlock;
            return StaticBlocks[x][y];
        }

        public HuedTile[] GetStaticTiles(int x, int y)
        {
            return GetStaticBlock(x >> 3, y >> 3)[x & 0x7][y & 0x7];
        }

        public TileMatrixPatch(TileMatrix matrix, int index, string path)
        {
            BlockWidth = matrix.BlockWidth;
            BlockHeight = matrix.BlockWidth;

            LandBlocksCount = StaticBlocksCount = 0;
            string mapDataPath, mapIndexPath;
            if (path == null)
            {
                mapDataPath = Files.GetFilePath("mapdif{0}.mul", index);
                mapIndexPath = Files.GetFilePath("mapdifl{0}.mul", index);
            }
            else
            {
                mapDataPath = Path.Combine(path, $"mapdif{index}.mul");
                if (!File.Exists(mapDataPath))
                    mapDataPath = null;
                mapIndexPath = Path.Combine(path, $"mapdifl{index}.mul");
                if (!File.Exists(mapIndexPath))
                    mapIndexPath = null;
            }

            if (mapDataPath != null && mapIndexPath != null)
            {
                LandBlocks = new Tile[matrix.BlockWidth][][];
                LandBlocksCount = PatchLand(matrix, mapDataPath, mapIndexPath);
            }

            string staDataPath, staIndexPath, staLookupPath;
            if (path == null)
            {
                staDataPath = Files.GetFilePath("stadif{0}.mul", index);
                staIndexPath = Files.GetFilePath("stadifl{0}.mul", index);
                staLookupPath = Files.GetFilePath("stadifi{0}.mul", index);
            }
            else
            {
                staDataPath = Path.Combine(path, $"stadif{index}.mul");
                if (!File.Exists(staDataPath))
                    staDataPath = null;
                staIndexPath = Path.Combine(path, $"stadifl{index}.mul");
                if (!File.Exists(staIndexPath))
                    staIndexPath = null;
                staLookupPath = Path.Combine(path, $"stadifi{index}.mul");
                if (!File.Exists(staLookupPath))
                    staLookupPath = null;
            }

            if (staDataPath != null && staIndexPath != null && staLookupPath != null)
            {
                StaticBlocks = new HuedTile[matrix.BlockWidth][][][][];
                StaticBlocksCount = PatchStatics(matrix, staDataPath, staIndexPath, staLookupPath);
            }
        }

        private unsafe int PatchLand(TileMatrix matrix, string dataPath, string indexPath)
        {
            using (FileStream fsData = new FileStream(dataPath, FileMode.Open, FileAccess.Read, FileShare.Read),
                fsIndex = new FileStream(indexPath, FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                using (BinaryReader indexReader = new BinaryReader(fsIndex))
                {
                    int count = (int) (indexReader.BaseStream.Length / 4);

                    for (int i = 0; i < count; ++i)
                    {
                        int blockID = indexReader.ReadInt32();
                        int x = blockID / matrix.BlockHeight;
                        int y = blockID % matrix.BlockHeight;

                        fsData.Seek(4, SeekOrigin.Current);

                        Tile[] tiles = new Tile[64];

                        GCHandle gc = GCHandle.Alloc(tiles, GCHandleType.Pinned);
                        try
                        {
                            if (m_Buffer == null || m_Buffer.Length < 192)
                                m_Buffer = new byte[192];

                            fsData.Read(m_Buffer, 0, 192);

                            Marshal.Copy(m_Buffer, 0, gc.AddrOfPinnedObject(), 192);
                        }
                        finally
                        {
                            gc.Free();
                        }

                        if (LandBlocks[x] == null)
                            LandBlocks[x] = new Tile[matrix.BlockHeight][];
                        LandBlocks[x][y] = tiles;
                    }

                    return count;
                }
            }
        }

        private unsafe int PatchStatics(TileMatrix matrix, string dataPath, string indexPath, string lookupPath)
        {
            using (FileStream fsData = new FileStream(dataPath, FileMode.Open, FileAccess.Read, FileShare.Read),
                fsIndex = new FileStream(indexPath, FileMode.Open, FileAccess.Read, FileShare.Read),
                fsLookup = new FileStream(lookupPath, FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                using (BinaryReader indexReader = new BinaryReader(fsIndex),
                    lookupReader = new BinaryReader(fsLookup))
                {
                    int count = Math.Min((int) (indexReader.BaseStream.Length / 4),
                        (int) (lookupReader.BaseStream.Length / 12));

                    HuedTileList[][] lists = new HuedTileList[8][];

                    for (int x = 0; x < 8; ++x)
                    {
                        lists[x] = new HuedTileList[8];

                        for (int y = 0; y < 8; ++y)
                            lists[x][y] = new HuedTileList();
                    }

                    for (int i = 0; i < count; ++i)
                    {
                        int blockID = indexReader.ReadInt32();
                        int blockX = blockID / matrix.BlockHeight;
                        int blockY = blockID % matrix.BlockHeight;

                        int offset = lookupReader.ReadInt32();
                        int length = lookupReader.ReadInt32();
                        lookupReader.ReadInt32(); // Extra

                        if (offset < 0 || length <= 0)
                        {
                            if (StaticBlocks[blockX] == null)
                                StaticBlocks[blockX] = new HuedTile[matrix.BlockHeight][][][];

                            StaticBlocks[blockX][blockY] = TileMatrix.EmptyStaticBlock;
                            continue;
                        }

                        fsData.Seek(offset, SeekOrigin.Begin);

                        int tileCount = length / 7;

                        if (m_TileBuffer.Length < tileCount)
                            m_TileBuffer = new StaticTile[tileCount];

                        StaticTile[] staTiles = m_TileBuffer;

                        GCHandle gc = GCHandle.Alloc(staTiles, GCHandleType.Pinned);
                        try
                        {
                            if (m_Buffer == null || m_Buffer.Length < length)
                                m_Buffer = new byte[length];

                            fsData.Read(m_Buffer, 0, length);

                            Marshal.Copy(m_Buffer, 0, gc.AddrOfPinnedObject(), length);

                            for (int j = 0; j < tileCount; ++j)
                            {
                                StaticTile cur = staTiles[j];
                                lists[cur.m_X & 0x7][cur.m_Y & 0x7]
                                    .Add(Art.GetLegalItemID(cur.m_ID), cur.m_Hue, cur.m_Z);
                            }

                            HuedTile[][][] tiles = new HuedTile[8][][];

                            for (int x = 0; x < 8; ++x)
                            {
                                tiles[x] = new HuedTile[8][];

                                for (int y = 0; y < 8; ++y)
                                    tiles[x][y] = lists[x][y].ToArray();
                            }

                            if (StaticBlocks[blockX] == null)
                                StaticBlocks[blockX] = new HuedTile[matrix.BlockHeight][][][];

                            StaticBlocks[blockX][blockY] = tiles;
                        }
                        finally
                        {
                            gc.Free();
                        }
                    }

                    return count;
                }
            }
        }
    }
}

================================================
FILE: Razor/UltimaSDK/UnicodeFont.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;

namespace Ultima
{
    public sealed class UnicodeFont
    {
        public UnicodeChar[] Chars { get; set; }

        public UnicodeFont()
        {
            Chars = new UnicodeChar[0x10000];
        }

        /// <summary>
        /// Returns width of text
        /// </summary>
        /// <param name="text"></param>
        /// <returns></returns>
        public int GetWidth(string text)
        {
            if (text == null || text.Length == 0)
                return 0;
            int width = 0;
            for (int i = 0; i < text.Length; ++i)
            {
                int c = (int) text[i] % 0x10000;
                width += Chars[c].Width;
                width += Chars[c].XOffset;
            }

            return width;
        }

        /// <summary>
        /// Returns max height of text
        /// </summary>
        /// <param name="text"></param>
        /// <returns></returns>
        public int GetHeight(string text)
        {
            if (text == null || text.Length == 0)
                return 0;
            int height = 0;
            for (int i = 0; i < text.Length; ++i)
            {
                int c = (int) text[i] % 0x10000;
                height = Math.Max(height, Chars[c].Height + Chars[c].YOffset);
            }

            return height;
        }
    }

    public sealed class UnicodeChar
    {
        public byte[] Bytes { get; set; }
        public sbyte XOffset { get; set; }
        public sbyte YOffset { get; set; }
        public int Height { get; set; }
        public int Width { get; set; }

        public UnicodeChar()
        {
        }

        /// <summary>
        /// Gets Bitmap of Char
        /// </summary>
        /// <returns></returns>
        public Bitmap GetImage()
        {
            return GetImage(false);
        }

        /// <summary>
        /// Gets Bitmap of Char with Background -1
        /// </summary>
        /// <param name="fill"></param>
        /// <returns></returns>
        public unsafe Bitmap GetImage(bool fill)
        {
            if ((Width == 0) || (Height == 0))
                return null;
            Bitmap bmp = new Bitmap(Width, Height, PixelFormat.Format16bppArgb1555);
            BitmapData bd = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.WriteOnly,
                PixelFormat.Format16bppArgb1555);
            ushort* line = (ushort*) bd.Scan0;
            int delta = bd.Stride >> 1;
            for (int y = 0; y < Height; ++y, line += delta)
            {
                ushort* cur = line;
                for (int x = 0; x < Width; ++x)
                {
                    if (IsPixelSet(Bytes, Width, x, y))
                        cur[x] = 0x8000;
                    else if (fill)
                        cur[x] = 0xffff;
                }
            }

            bmp.UnlockBits(bd);
            return bmp;
        }

        private static bool IsPixelSet(byte[] data, int width, int x, int y)
        {
            int offset = x / 8 + y * ((width + 7) / 8);
            if (offset > data.Length)
                return false;
            return (data[offset] & (1 << (7 - (x % 8)))) != 0;
        }

        /// <summary>
        /// Resets Buffer with Bitmap
        /// </summary>
        /// <param name="bmp"></param>
        public unsafe void SetBuffer(Bitmap bmp)
        {
            Bytes = new byte[bmp.Height * (((bmp.Width - 1) / 8) + 1)];
            BitmapData bd = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.WriteOnly,
                PixelFormat.Format16bppArgb1555);
            ushort* line = (ushort*) bd.Scan0;
            //int delta = bd.Stride >> 1;
            for (int y = 0; y < bmp.Height; ++y)
            {
                ushort* cur = line;
                for (int x = 0; x < bmp.Width; ++x)
                {
                    if (cur[x] == 0x8000)
                    {
                        int offset = x / 8 + y * ((bmp.Width + 7) / 8);
                        Bytes[offset] |= (byte) (1 << (7 - (x % 8)));
                    }
                }
            }

            bmp.UnlockBits(bd);
        }
    }

    public static class UnicodeFonts
    {
        private static string[] m_files = new string[]
        {
            "unifont.mul",
            "unifont1.mul",
            "unifont2.mul",
            "unifont3.mul",
            "unifont4.mul",
            "unifont5.mul",
            "unifont6.mul",
            "unifont7.mul",
            "unifont8.mul",
            "unifont9.mul",
            "unifont10.mul",
            "unifont11.mul",
            "unifont12.mul"
        };

        public static UnicodeFont[] Fonts = new UnicodeFont[13];

        static UnicodeFonts()
        {
            Initialize();
        }

        /// <summary>
        /// Reads unifont*.mul
        /// </summary>
        public static void Initialize()
        {
            for (int i = 0; i < m_files.Length; i++)
            {
                string filePath = Files.GetFilePath(m_files[i]);
                if (filePath == null)
                    continue;
                Fonts[i] = new UnicodeFont();
                using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read))
                {
                    using (BinaryReader bin = new BinaryReader(fs))
                    {
                        for (int c = 0; c < 0x10000; ++c)
                        {
                            Fonts[i].Chars[c] = new UnicodeChar();
                            fs.Seek((long) ((c) * 4), SeekOrigin.Begin);
                            int num2 = bin.ReadInt32();
                            if ((num2 >= fs.Length) || (num2 <= 0))
                                continue;
                            fs.Seek((long) num2, SeekOrigin.Begin);
                            sbyte xOffset = bin.ReadSByte();
                            sbyte yOffset = bin.ReadSByte();
                            int Width = bin.ReadByte();
                            int Height = bin.ReadByte();
                            Fonts[i].Chars[c].XOffset = xOffset;
                            Fonts[i].Chars[c].YOffset = yOffset;
                            Fonts[i].Chars[c].Width = Width;
                            Fonts[i].Chars[c].Height = Height;
                            if (!((Width == 0) || (Height == 0)))
                                Fonts[i].Chars[c].Bytes = bin.ReadBytes(Height * (((Width - 1) / 8) + 1));
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Draws Text with font in Bitmap and returns
        /// </summary>
        /// <param name="fontId"></param>
        /// <param name="text"></param>
        /// <returns></returns>
        public static Bitmap WriteText(int fontId, string text)
        {
            Bitmap result = new Bitmap(Fonts[fontId].GetWidth(text) + 2, Fonts[fontId].GetHeight(text) + 2);

            int dx = 2;
            int dy = 2;
            using (Graphics graph = Graphics.FromImage(result))
            {
                for (int i = 0; i < text.Length; ++i)
                {
                    int c = (int) text[i] % 0x10000;
                    Bitmap bmp = Fonts[fontId].Chars[c].GetImage();
                    dx += Fonts[fontId].Chars[c].XOffset;
                    graph.DrawImage(bmp, dx, dy + Fonts[fontId].Chars[c].YOffset);
                    dx += bmp.Width;
                }
            }

            return result;
        }

        /// <summary>
        /// Saves Font and returns string Filename
        /// </summary>
        /// <param name="path"></param>
        /// <param name="filetype"></param>
        /// <returns></returns>
        public static string Save(string path, int filetype)
        {
            string FileName = Path.Combine(path, m_files[filetype]);
            using (FileStream fs = new FileStream(FileName, FileMode.Create, FileAccess.Write, FileShare.Write))
            {
                using (BinaryWriter bin = new BinaryWriter(fs))
                {
                    fs.Seek(0x10000 * 4, SeekOrigin.Begin);
                    bin.Write(0);
                    // Set first data
                    for (int c = 0; c < 0x10000; ++c)
                    {
                        if (Fonts[filetype].Chars[c].Bytes == null)
                            continue;
                        fs.Seek((long) ((c) * 4), SeekOrigin.Begin);
                        bin.Write((int) fs.Length);
                        fs.Seek(fs.Length, SeekOrigin.Begin);
                        bin.Write(Fonts[filetype].Chars[c].XOffset);
                        bin.Write(Fonts[filetype].Chars[c].YOffset);
                        bin.Write((byte) Fonts[filetype].Chars[c].Width);
                        bin.Write((byte) Fonts[filetype].Chars[c].Height);
                        bin.Write(Fonts[filetype].Chars[c].Bytes);
                    }
                }
            }

            return FileName;
        }
    }
}

================================================
FILE: Razor/UltimaSDK/ValueStringBuilder.cs
================================================
using System;
using System.Buffers;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

namespace Ultima
{
    // https://github.com/Thealexbarney/LibHac/blob/master/src/LibHac/FsSystem/ValueStringBuilder.cs
    internal ref struct ValueStringBuilder
    {
        private char[] _arrayToReturnToPool;
        private Span<char> _chars;
        private int _pos;


        // If this ctor is used, you cannot pass in stackalloc ROS for append/replace.
        public ValueStringBuilder(ReadOnlySpan<char> initialString) : this(initialString.Length)
        {
            Append(initialString);
        }

        public ValueStringBuilder(ReadOnlySpan<char> initialString, Span<char> initialBuffer) : this(initialBuffer)
        {
            Append(initialString);
        }

        public ValueStringBuilder(Span<char> initialBuffer)
        {
            _arrayToReturnToPool = null;
            _chars = initialBuffer;
            _pos = 0;
        }

        public ValueStringBuilder(int initialCapacity)
        {
            _arrayToReturnToPool = ArrayPool<char>.Shared.Rent(initialCapacity);
            _chars = _arrayToReturnToPool;
            _pos = 0;
        }

        public int Length
        {
            get => _pos;
            set
            {
                Debug.Assert(value >= 0);
                Debug.Assert(value <= _chars.Length);
                _pos = value;
            }
        }

        public int Capacity => _chars.Length;

        public void EnsureCapacity(int capacity)
        {
            if (capacity > _chars.Length)
                Grow(capacity - _chars.Length);
        }

        /// <summary>
        /// Get a pinnable reference to the builder.
        /// Does not ensure there is a null char after <see cref="Length"/>
        /// This overload is pattern matched in the C# 7.3+ compiler so you can omit
        /// the explicit method call, and write eg "fixed (char* c = builder)"
        /// </summary>
        public ref char GetPinnableReference()
        {
            return ref MemoryMarshal.GetReference(_chars);
        }

        /// <summary>
        /// Get a pinnable reference to the builder.
        /// </summary>
        /// <param name="terminate">Ensures that the builder has a null char after <see cref="Length"/></param>
        public ref char GetPinnableReference(bool terminate)
        {
            if (terminate)
            {
                EnsureCapacity(Length + 1);
                _chars[Length] = '\0';
            }
            return ref MemoryMarshal.GetReference(_chars);
        }

        public ref char this[int index]
        {
            get
            {
                Debug.Assert(index < _pos);
                return ref _chars[index];
            }
        }

        public override string ToString()
        {
            string s = _chars.Slice(0, _pos).ToString();
            Dispose();
            return s;
        }

        /// <summary>Returns the underlying storage of the builder.</summary>
        public Span<char> RawChars => _chars;

        /// <summary>
        /// Returns a span around the contents of the builder.
        /// </summary>
        /// <param name="terminate">Ensures that the builder has a null char after <see cref="Length"/></param>
        public ReadOnlySpan<char> AsSpan(bool terminate)
        {
            if (terminate)
            {
                EnsureCapacity(Length + 1);
                _chars[Length] = '\0';
            }
            return _chars.Slice(0, _pos);
        }

        public ReadOnlySpan<char> AsSpan() => _chars.Slice(0, _pos);
        public ReadOnlySpan<char> AsSpan(int start) => _chars.Slice(start, _pos - start);
        public ReadOnlySpan<char> AsSpan(int start, int length) => _chars.Slice(start, length);

        public bool TryCopyTo(Span<char> destination, out int charsWritten)
        {
            if (_chars.Slice(0, _pos).TryCopyTo(destination))
            {
                charsWritten = _pos;
                Dispose();
                return true;
            }
            else
            {
                charsWritten = 0;
                Dispose();
                return false;
            }
        }

        public void Insert(int index, char value, int count)
        {
            if (_pos > _chars.Length - count)
            {
                Grow(count);
            }

            int remaining = _pos - index;
            _chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count));
            _chars.Slice(index, count).Fill(value);
            _pos += count;
        }

        public void Insert(int index, ReadOnlySpan<char> s)
        {
            int count = s.Length;

            if (_pos > (_chars.Length - count))
            {
                Grow(count);
            }

            int remaining = _pos - index;
            _chars.Slice(index, remaining).CopyTo(_chars.Slice(index + count));
            s.CopyTo(_chars.Slice(index));
            _pos += count;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void Append(char c)
        {
            int pos = _pos;
            if ((uint)pos < (uint)_chars.Length)
            {
                _chars[pos] = c;
                _pos = pos + 1;
            }
            else
            {
                GrowAndAppend(c);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void Append(string s)
        {
            int pos = _pos;
            if (s.Length == 1 && (uint)pos < (uint)_chars.Length) // very common case, e.g. appending strings from NumberFormatInfo like separators, percent symbols, etc.
            {
                _chars[pos] = s[0];
                _pos = pos + 1;
            }
            else
            {
                AppendSlow(s);
            }
        }

        private void AppendSlow(string s)
        {
            int pos = _pos;
            if (pos > _chars.Length - s.Length)
            {
                Grow(s.Length);
            }

            s.AsSpan().CopyTo(_chars.Slice(pos));
            _pos += s.Length;
        }

        public void Append(char c, int count)
        {
            if (_pos > _chars.Length - count)
            {
                Grow(count);
            }

            Span<char> dst = _chars.Slice(_pos, count);
            for (int i = 0; i < dst.Length; i++)
            {
                dst[i] = c;
            }
            _pos += count;
        }

        public void Append(ReadOnlySpan<char> value)
        {
            int pos = _pos;
            if (pos > _chars.Length - value.Length)
            {
                Grow(value.Length);
            }

            value.CopyTo(_chars.Slice(_pos));
            _pos += value.Length;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public Span<char> AppendSpan(int length)
        {
            int origPos = _pos;
            if (origPos > _chars.Length - length)
            {
                Grow(length);
            }

            _pos = origPos + length;
            return _chars.Slice(origPos, length);
        }

        public void Replace(ReadOnlySpan<char> oldChars, ReadOnlySpan<char> newChars)
        {
            Replace(oldChars, newChars, 0, _pos);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void Replace(ReadOnlySpan<char> oldChars, ReadOnlySpan<char> newChars, int startIndex, int count)
        {
            var slice = _chars.Slice(startIndex, count);

            var indexOf = slice.IndexOf(oldChars);

            if (indexOf == -1)
            {
                return;
            }

            if (newChars.Length > oldChars.Length)
            {
                int i = 0;

                for (; i < oldChars.Length; ++i)
                {
                    slice[indexOf + i] = newChars[i];
                }

                Insert(indexOf + i, newChars.Slice(i));
            }
            else if (newChars.Length < oldChars.Length)
            {
                int i = 0;

                for (; i < newChars.Length; ++i)
                {
                    slice[indexOf + i] = newChars[i];
                }

                Remove(indexOf + i, oldChars.Length - i);
            }
            else
            {
                newChars.CopyTo(slice.Slice(0, oldChars.Length));
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void Replace(char oldChar, char newChar)
        {
            var slice = _chars;

            var indexOf = slice.IndexOf(oldChar);
            if (indexOf == -1)
            {
                return;
            }

            slice[indexOf] = newChar;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void Remove(int startIndex, int length)
        {
            if (length < 0)
            {
                throw new ArgumentOutOfRangeException(nameof(length));
            }

            if (startIndex < 0)
            {
                throw new ArgumentOutOfRangeException(nameof(startIndex));
            }

            if (length > _pos - startIndex)
            {
                throw new ArgumentOutOfRangeException(nameof(length));
            }

            if (startIndex == 0)
            {
                _chars = _chars.Slice(length);
            }
            else if (startIndex + length == _pos)
            {
                _chars = _chars.Slice(0, startIndex);
            }
            else
            {
                // Somewhere in the middle, this will be slow
                _chars.Slice(startIndex + length).CopyTo(_chars.Slice(startIndex));
            }

            _pos -= length;
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private void GrowAndAppend(char c)
        {
            Grow(1);
            Append(c);
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private void Grow(int requiredAdditionalCapacity)
        {
            Debug.Assert(requiredAdditionalCapacity > 0);

            char[] poolArray = ArrayPool<char>.Shared.Rent(Math.Max(_pos + requiredAdditionalCapacity, _chars.Length * 2));

            _chars.CopyTo(poolArray);

            char[] toReturn = _arrayToReturnToPool;
            _chars = _arrayToReturnToPool = poolArray;
            if (toReturn != null)
            {
                ArrayPool<char>.Shared.Return(toReturn);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void Dispose()
        {
            char[] toReturn = _arrayToReturnToPool;
            this = default; // for safety, to avoid using pooled array if this instance is erroneously appended to again
            if (toReturn != null)
            {
                ArrayPool<char>.Shared.Return(toReturn);
            }
        }
    }
}

================================================
FILE: Razor/UltimaSDK/Verdata.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

using System.IO;

// FileIDs
//0 - map0.mul
//1 - staidx0.mul
//2 - statics0.mul
//3 - artidx.mul
//4 - art.mul
//5 - anim.idx
//6 - anim.mul
//7 - soundidx.mul
//8 - sound.mul
//9 - texidx.mul
//10 - texmaps.mul
//11 - gumpidx.mul
//12 - gumpart.mul
//13 - multi.idx
//14 - multi.mul
//15 - skills.idx
//16 - skills.mul
//30 - tiledata.mul
//31 - animdata.mul

namespace Ultima
{
    public sealed class Verdata
    {
        public static Stream Stream { get; private set; }
        public static Entry5D[] Patches { get; private set; }

        private static string path;

        static Verdata()
        {
            Initialize();
        }

        public static void Initialize()
        {
            path = Files.GetFilePath("verdata.mul");

            if (path == null)
            {
                Patches = new Entry5D[0];
                Stream = Stream.Null;
            }
            else
            {
                using (Stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read))
                {
                    using (BinaryReader bin = new BinaryReader(Stream))
                    {
                        Patches = new Entry5D[bin.ReadInt32()];

                        for (int i = 0; i < Patches.Length; ++i)
                        {
                            Patches[i].file = bin.ReadInt32();
                            Patches[i].index = bin.ReadInt32();
                            Patches[i].lookup = bin.ReadInt32();
                            Patches[i].length = bin.ReadInt32();
                            Patches[i].extra = bin.ReadInt32();
                        }
                    }
                }

                Stream.Close();
            }
        }

        public static void Seek(int lookup)
        {
            if (Stream == null || !Stream.CanRead || !Stream.CanSeek)
            {
                if (path != null)
                    Stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
            }

            Stream.Seek(lookup, SeekOrigin.Begin);
        }
    }

    public struct Entry5D
    {
        public int file;
        public int index;
        public int lookup;
        public int length;
        public int extra;
    }
}

================================================
FILE: Razor/UltimaSDK/WindowProcessStream.cs
================================================
#region license
// Razor: An Ultima Online Assistant
// Copyright (c) 2022 Razor Development Community on GitHub <https://github.com/markdwags/Razor>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
#endregion

namespace Ultima
{
    public class WindowProcessStream : ProcessStream
    {
        private ClientWindowHandle m_Window;
        private ClientProcessHandle m_ProcessID;

        public ClientWindowHandle Window
        {
            get { return m_Window; }
            set { m_Window = value; }
        }

        public WindowProcessStream(ClientWindowHandle window)
        {
            m_Window = window;
            m_ProcessID = ClientProcessHandle.Invalid;
        }

        public override ClientProcessHandle ProcessID
        {
            get
            {
                if (NativeMethods.IsWindow(m_Window) != 0 && !m_ProcessID.IsInvalid)
                    return m_ProcessID;

                NativeMethods.GetWindowThreadProcessId(m_Window, ref m_ProcessID);

                return m_ProcessID;
            }
        }
    }
}

================================================
FILE: Razor/app.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <configSections>
    <section name="Servers" type="System.Configuration.AppSettingsSection, System.Configuration, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"/>
  </configSections>

  <startup>
    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2"/>
  </startup>

  <appSettings>
    <add key="UODataDir" value="D:\Games\UO"/>
    <add key="UOClient" value="D:\Games\UO\client.exe"/>
    <add key="LastPort" value="2593"/>
    <add key="LastProfile" value="default"/>
    <add key="LastServer" value="login.server.com"/>
    <add key="LastServerId" value="0"/>
    <add key="ClientEncrypted" value="1"/>
    <add key="ServerEncrypted" value="0"/>
    <add key="ShowWelcome" value="1"/>
    <add key="UId" value="21613fcd"/>
    <add key="MaxOrganizerAgents" value="20"/>
    <add key="MaxBuyAgents" value="10"/>
    <add key="MaxRestockAgents" value="10"/>
    <add key="ImportProfilesAndMacros" value="true"/>
    <add key="BackupPath" value=".\Backup"/>
  </appSettings>

  <Servers>
    <add key="Custom Server" value="server.someserver.com,2593"/>
  </Servers>

</configuration>


================================================
FILE: Razor/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="System.Buffers" version="4.5.1" targetFramework="net472" />
  <package id="System.Memory" version="4.5.5" targetFramework="net472" />
  <package id="System.Numerics.Vectors" version="4.5.0" targetFramework="net472" />
  <package id="System.Runtime.CompilerServices.Unsafe" version="4.5.3" targetFramework="net472" />
</packages>

================================================
FILE: Razor.sln
================================================
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 17
VisualStudioVersion = 17.0.31903.59
MinimumVisualStudioVersion = 10.0.40219.1
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Razor", "Razor\Razor.csproj", "{B24E4FB1-4936-4544-9E88-F3FF9B04FDBA}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Crypt", "Crypt\Crypt.vcxproj", "{B32A4D9E-3AF1-4C75-989D-D62C4E8F08B1}"
	ProjectSection(ProjectDependencies) = postProject
		{F308E8D5-2B4F-40AD-9BF7-9A8F5DDA420D} = {F308E8D5-2B4F-40AD-9BF7-9A8F5DDA420D}
	EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Loader", "Loader\Loader.vcxproj", "{F308E8D5-2B4F-40AD-9BF7-9A8F5DDA420D}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{44ADAD77-7431-41DE-871C-F122478D39B2}"
	ProjectSection(SolutionItems) = preProject
		CODE_OF_CONDUCT.md = CODE_OF_CONDUCT.md
		CONTRIBUTING.md = CONTRIBUTING.md
		INSTALL.md = INSTALL.md
		LICENSE.md = LICENSE.md
		etc\Language\Razor_lang.enu = etc\Language\Razor_lang.enu
		README.md = README.md
	EndProjectSection
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Platform", "Platform\Platform.vcxproj", "{DB18390C-8AD4-4E69-8A5A-171260F7D74A}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FastColoredTextBox", "FastColoredTextBox\FastColoredTextBox.csproj", "{6DD14A85-CCFC-4774-BD26-0F5772512319}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Any CPU = Debug|Any CPU
		Debug|x64 = Debug|x64
		Debug|x86 = Debug|x86
		Release|Any CPU = Release|Any CPU
		Release|x64 = Release|x64
		Release|x86 = Release|x86
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{B24E4FB1-4936-4544-9E88-F3FF9B04FDBA}.Debug|Any CPU.ActiveCfg = Debug|x86
		{B24E4FB1-4936-4544-9E88-F3FF9B04FDBA}.Debug|Any CPU.Build.0 = Debug|x86
		{B24E4FB1-4936-4544-9E88-F3FF9B04FDBA}.Debug|x64.ActiveCfg = Debug|x64
		{B24E4FB1-4936-4544-9E88-F3FF9B04FDBA}.Debug|x64.Build.0 = Debug|x64
		{B24E4FB1-4936-4544-9E88-F3FF9B04FDBA}.Debug|x86.ActiveCfg = Debug|x86
		{B24E4FB1-4936-4544-9E88-F3FF9B04FDBA}.Debug|x86.Build.0 = Debug|x86
		{B24E4FB1-4936-4544-9E88-F3FF9B04FDBA}.Release|Any CPU.ActiveCfg = Release|x86
		{B24E4FB1-4936-4544-9E88-F3FF9B04FDBA}.Release|Any CPU.Build.0 = Release|x86
		{B24E4FB1-4936-4544-9E88-F3FF9B04FDBA}.Release|x64.ActiveCfg = Release|x64
		{B24E4FB1-4936-4544-9E88-F3FF9B04FDBA}.Release|x64.Build.0 = Release|x64
		{B24E4FB1-4936-4544-9E88-F3FF9B04FDBA}.Release|x86.ActiveCfg = Release|x86
		{B24E4FB1-4936-4544-9E88-F3FF9B04FDBA}.Release|x86.Build.0 = Release|x86
		{B32A4D9E-3AF1-4C75-989D-D62C4E8F08B1}.Debug|Any CPU.ActiveCfg = Debug|Win32
		{B32A4D9E-3AF1-4C75-989D-D62C4E8F08B1}.Debug|Any CPU.Build.0 = Debug|Win32
		{B32A4D9E-3AF1-4C75-989D-D62C4E8F08B1}.Debug|x64.ActiveCfg = Debug|Win32
		{B32A4D9E-3AF1-4C75-989D-D62C4E8F08B1}.Debug|x86.ActiveCfg = Debug|Win32
		{B32A4D9E-3AF1-4C75-989D-D62C4E8F08B1}.Debug|x86.Build.0 = Debug|Win32
		{B32A4D9E-3AF1-4C75-989D-D62C4E8F08B1}.Release|Any CPU.ActiveCfg = Release|Win32
		{B32A4D9E-3AF1-4C75-989D-D62C4E8F08B1}.Release|Any CPU.Build.0 = Release|Win32
		{B32A4D9E-3AF1-4C75-989D-D62C4E8F08B1}.Release|x64.ActiveCfg = Release|Win32
		{B32A4D9E-3AF1-4C75-989D-D62C4E8F08B1}.Release|x86.ActiveCfg = Release|Win32
		{B32A4D9E-3AF1-4C75-989D-D62C4E8F08B1}.Release|x86.Build.0 = Release|Win32
		{F308E8D5-2B4F-40AD-9BF7-9A8F5DDA420D}.Debug|Any CPU.ActiveCfg = Debug|Win32
		{F308E8D5-2B4F-40AD-9BF7-9A8F5DDA420D}.Debug|Any CPU.Build.0 = Debug|Win32
		{F308E8D5-2B4F-40AD-9BF7-9A8F5DDA420D}.Debug|x64.ActiveCfg = Debug|Win32
		{F308E8D5-2B4F-40AD-9BF7-9A8F5DDA420D}.Debug|x86.ActiveCfg = Debug|Win32
		{F308E8D5-2B4F-40AD-9BF7-9A8F5DDA420D}.Debug|x86.Build.0 = Debug|Win32
		{F308E8D5-2B4F-40AD-9BF7-9A8F5DDA420D}.Release|Any CPU.ActiveCfg = Release|Win32
		{F308E8D5-2B4F-40AD-9BF7-9A8F5DDA420D}.Release|Any CPU.Build.0 = Release|Win32
		{F308E8D5-2B4F-40AD-9BF7-9A8F5DDA420D}.Release|x64.ActiveCfg = Release|Win32
		{F308E8D5-2B4F-40AD-9BF7-9A8F5DDA420D}.Release|x86.ActiveCfg = Release|Win32
		{F308E8D5-2B4F-40AD-9BF7-9A8F5DDA420D}.Release|x86.Build.0 = Release|Win32
		{DB18390C-8AD4-4E69-8A5A-171260F7D74A}.Debug|Any CPU.ActiveCfg = Debug|x64
		{DB18390C-8AD4-4E69-8A5A-171260F7D74A}.Debug|Any CPU.Build.0 = Debug|x64
		{DB18390C-8AD4-4E69-8A5A-171260F7D74A}.Debug|x64.ActiveCfg = Debug|x64
		{DB18390C-8AD4-4E69-8A5A-171260F7D74A}.Debug|x86.ActiveCfg = Debug|x64
		{DB18390C-8AD4-4E69-8A5A-171260F7D74A}.Debug|x86.Build.0 = Debug|x64
		{DB18390C-8AD4-4E69-8A5A-171260F7D74A}.Release|Any CPU.ActiveCfg = Release|x64
		{DB18390C-8AD4-4E69-8A5A-171260F7D74A}.Release|Any CPU.Build.0 = Release|x64
		{DB18390C-8AD4-4E69-8A5A-171260F7D74A}.Release|x64.ActiveCfg = Release|x64
		{DB18390C-8AD4-4E69-8A5A-171260F7D74A}.Release|x86.ActiveCfg = Release|Win32
		{DB18390C-8AD4-4E69-8A5A-171260F7D74A}.Release|x86.Build.0 = Release|Win32
		{6DD14A85-CCFC-4774-BD26-0F5772512319}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{6DD14A85-CCFC-4774-BD26-0F5772512319}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{6DD14A85-CCFC-4774-BD26-0F5772512319}.Debug|x64.ActiveCfg = Debug|x64
		{6DD14A85-CCFC-4774-BD26-0F5772512319}.Debug|x64.Build.0 = Debug|x64
		{6DD14A85-CCFC-4774-BD26-0F5772512319}.Debug|x86.ActiveCfg = Debug|Any CPU
		{6DD14A85-CCFC-4774-BD26-0F5772512319}.Debug|x86.Build.0 = Debug|Any CPU
		{6DD14A85-CCFC-4774-BD26-0F5772512319}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{6DD14A85-CCFC-4774-BD26-0F5772512319}.Release|Any CPU.Build.0 = Release|Any CPU
		{6DD14A85-CCFC-4774-BD26-0F5772512319}.Release|x64.ActiveCfg = Release|x64
		{6DD14A85-CCFC-4774-BD26-0F5772512319}.Release|x64.Build.0 = Release|x64
		{6DD14A85-CCFC-4774-BD26-0F5772512319}.Release|x86.ActiveCfg = Release|Any CPU
		{6DD14A85-CCFC-4774-BD26-0F5772512319}.Release|x86.Build.0 = Release|Any CPU
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
	GlobalSection(ExtensibilityGlobals) = postSolution
		SolutionGuid = {185AA9DC-62C1-4770-80D5-82AA7648EE75}
	EndGlobalSection
EndGlobal


================================================
FILE: etc/Language/Razor_lang.CHS
================================================
// Razor Simplified Chinese/CHS Language Pack
// Last modified Date: 2007-7-19
// Based on English language file.
// Translated by Cloud, E-mail: linhongjun@hotmail.com, Blog: http://blog.plaync.jp/linhongjun/55934
// Special thanks to: haojz(TLF Forum), DontdroptheSOAD(RunUO Forum),Thraxus(RunUO Forum).
// If Razor can not load skillnames with this language file, please replace "Cliloc.chs" with "Cliloc.enu" under UO installation directory. Becuase there's no corresponding entry in localization file of Simplified Chinese(). Make sure you have made a copy of original file before doing this.
// Ϊȷƿȷʾ,"Cliloc.enu"滻UOװĿ¼µ"Cliloc.chs",Ҳ˵ɾԭʼ"Cliloc.chs"ļ,Ȼ"Cliloc.enu"Ϊ"Cliloc.chs".ǰϵͳΪ.ڷİ汾"Cliloc.cht",ĻҲԽ滻,ĺɶȺܸ.ųӰ,ǿƼʹ.滻ǰҪԭʼļ.
// Special string used in the game such as LastTarget, LastObject will not be translated in order to match with UO.
// LastTarget,LastObjectָз,UOеһ.
// UseOnceʾһԵĴ,ر,ʱ뿼.
// Ϊĵ˵,Ϊļ:
::Encoding=GB2312
::CliLoc=CHS

[controls]
WelcomeForm::Text=ӭʹRazor - UOҵ!
WelcomeForm::groupBox3=UOװ·(ĬΪԶ)
WelcomeForm::dataBrowse=...
WelcomeForm::label5=:
WelcomeForm::groupBox2=
WelcomeForm::label3=:
WelcomeForm::label4=˿:
WelcomeForm::groupBox1=ͻѡ(ĬΪԶ)
WelcomeForm::useEnc=ʹOSI
WelcomeForm::makeDef=浱ǰֵΪĬ
WelcomeForm::browse=...
WelcomeForm::label1=ؿͻ:
WelcomeForm::patchEncy=ܿͻ(OSIѡ)
WelcomeForm::showAtStart=ʱʾ
WelcomeForm::quit=˳(&Q)
WelcomeForm::okay=(&O)

MainForm::Text=Razor v{0}
MainForm::generalTab=һ
MainForm::btnMap=UOλϵͳ
MainForm::label10=:
MainForm::systray=ϵͳ֪ͨ
MainForm::taskbar=
MainForm::smartCPU=ܻCPUʹ
MainForm::label7=:
MainForm::label11=ʾ:
MainForm::groupBox4=õ(ProfilesĿ¼)
MainForm::delProfile=ɾ
MainForm::newProfile=½(&N)...
MainForm::showWelcome=ʾӭ(Ӱû)
MainForm::alwaysTop=ܶʾ
MainForm::groupBox1=
MainForm::opacityLabel=͸: 100%
MainForm::moreMoreOptTab=ѡ
MainForm::blockHealPoison=ֹĿжʱ
MainForm::potionEquip=ʹҩˮʱԶ/װ
MainForm::label17=RazorϢʾ:
MainForm::QueueActions=ԶлĿʱ
MainForm::spellUnequip=ʩʱԶ˫װ
MainForm::autoOpenDoors=Զ(ʱ)
MainForm::alwaysStealth=ʾDZв
MainForm::autoFriend=ŶӳԱΪ
MainForm::chkStealth=DZв
MainForm::rememberPwds=ס(Ƽ)
MainForm::showtargtext=ʱʾĿ״̬
MainForm::preAOSstatbar=ʹPre-AOS״̬
MainForm::logPackets=ݰ¼(Ƽ)
MainForm::rangeCheckLT=LastTargetָ
MainForm::actionStatusMsg=ʾ״̬Ϣ
MainForm::label5=Ŀ궯ӳ:
MainForm::label9=ĬϷȼ:
MainForm::label8=
MainForm::label6=ms
MainForm::label18=x
MainForm::gameSize=ǿϷڴС:
MainForm::smartLT=ܻLastTargetָ
MainForm::moreOptTab=ѡ
MainForm::smoothWalk=ƽ
MainForm::negotiate=ЭϷ
MainForm::setLTHilight=
MainForm::lthilight=ʾLastTarget
MainForm::filterSnoop=͵Ϣ
MainForm::incomingCorpse=ʾʬ(Ƽ)
MainForm::incomingMob=ʾ/(Ƽ)
MainForm::setHarmHue=
MainForm::setNeuHue=
MainForm::lblHarmHue=к
MainForm::lblNeuHue=
MainForm::lblBeneHue=
MainForm::setBeneHue=
MainForm::setSpeechHue=
MainForm::setWarnHue=
MainForm::setMsgHue=
MainForm::setExHue=
MainForm::autoStackRes=Զڽ¶ѻ//ԭľ
MainForm::queueTargets=лLastTargetTargetSelfָ
MainForm::spamFilter=ظϵͳϢ
MainForm::label4=
MainForm::openCorpses=µʬ
MainForm::showNotoHue=ʾǰɫɫڱ(,,,,)
MainForm::lblWarnHue=Ϣɫ
MainForm::lblMsgHue=RazorϢɫ
MainForm::lblExHue=ɫ
MainForm::blockDis=սģʽֹ
MainForm::chkForceSpellHue=ǿħɫ:
MainForm::chkForceSpeechHue=ǿıɫ
MainForm::label3=ʽ:

MainForm::displayTab=ʾ/
MainForm::warnCount=ֵʱ:
MainForm::excludePouches=ԶԶС
MainForm::highlightSpellReags=ʩʱħҩ(ʾ)
MainForm::titlebarImages=ͼηʽʾԴ
MainForm::checkNewConts=Զ
MainForm::groupBox3=ʾ
MainForm::showInBar=UOʾϢ:
MainForm::groupBox2=Դ
MainForm::counters::0=(ʽ)
MainForm::counters::1=
MainForm::delCounter=ɾ/༭
MainForm::addCounter=...
MainForm::recount=¼
MainForm::dressTab=װ/
MainForm::groupBox6=װ/Ʒ
MainForm::clearDress=б
MainForm::dressDelSel=Ƴ
MainForm::undressBag=Ű
MainForm::undressList=ȥ
MainForm::dressUseCur=ӵǰ
MainForm::targItem=(Ŀ)
MainForm::dressNow=װ
MainForm::groupBox5=װ/ѡ
MainForm::removeDress=Ƴ
MainForm::addDress=...
MainForm::undressConflicts=Զ³ͻƷ
MainForm::skillsTab=
MainForm::dispDelta=ʾ״̬ĸı
MainForm::skillCopyAll=
MainForm::skillCopySel=ѡ
MainForm::label1=ܺ:
MainForm::setlocks=ü:
MainForm::resetDelta=λ+/-
MainForm::skillList::0=
MainForm::skillList::1=ֵ
MainForm::skillList::2=
MainForm::skillList::3=+/-
MainForm::skillList::4=
MainForm::skillList::5=
MainForm::agentsTab=
MainForm::hotkeysTab=ȼ
MainForm::dohotkey=ִѡȼ
MainForm::groupBox8=ȼ
MainForm::chkPass=UO
MainForm::label2=:
MainForm::unsetHK=ȡ
MainForm::setHK=
MainForm::chkCtrl=Ctrl
MainForm::chkAlt=Alt
MainForm::chkShift=Shift
MainForm::macrosTab=
MainForm::macroActGroup=
MainForm::loopMacro=ѭ
MainForm::recMacro=¼
MainForm::playMacro=
MainForm::delMacro=Ƴ
MainForm::newMacro=½...
MainForm::screenshotTab=ͼ
MainForm::label12=ͼʽ:
MainForm::capNow=ͼ
MainForm::radioUO=UO
MainForm::radioFull=ȫĻ
MainForm::screenAutoCap=ʱԶͼ
MainForm::setScnPath=...
MainForm::dispTime=ͼȡʱ
MainForm::videoTab=Ƶ
MainForm::recFolder=...
MainForm::label13=Ƶļ:
MainForm::groupBox7=PacketVideo¼
MainForm::vidRec=ʼ¼PacketVideo
MainForm::groupBox10=AVIӰ¼
MainForm::flipVidVert=ֱ
MainForm::flipVidHoriz=ˮƽ
MainForm::recAVI=ʼ¼AVIӰ...
MainForm::label16=:
MainForm::label15=FPS:
MainForm::label19=ת:
MainForm::groupBox9=PacketVideoط
MainForm::rpvTime=00:00/00:00
MainForm::label14=ٶ:
MainForm::vidClose=ر
MainForm::vidPlayStop=ֹͣ
MainForm::vidPlay=
MainForm::vidOpen=...
MainForm::statusTab=״̬
MainForm::forumsLink=Razor
MainForm::homeLink=Razorҳ
MainForm::userGuideLink=Razorûֲ

HueEntry::Text=ѡɫ
HueEntry::cancel=ȡ
HueEntry::okay=ȷ(&O)
HueEntry::preview=Ԥ
HueEntry::inGame=Ϸѡ
HueEntry::label1=ɫ:

AddCounter::Text=һ
AddCounter::delete=ɾ
AddCounter::target=Ŀ
AddCounter::cancel=ȡ
AddCounter::Add=ȷ(&O)
AddCounter::label4=ɫ(κ:-1):
AddCounter::label3=ƷID:
AddCounter::label2=ʽ:
AddCounter::label1=:

MacroInsertWait::Text=ȴ/ͣ...
MacroInsertWait::radioMenu=ȴɷIJ˵/Ի
MacroInsertWait::cancel=ȡ(&C)
MacroInsertWait::radioStat=ȴ
MacroInsertWait::radioTarg=ȴĿ
MacroInsertWait::radioGump=ȴԻ
MacroInsertWait::label1=ms
MacroInsertWait::radioPause=ͣȴ:
MacroInsertWait::insert=(&I)

MacroInsertIf::Text=If...
MacroInsertIf::label1=If:
MacroInsertIf::cancel=ȡ(&C)
MacroInsertIf::insert=(&I)

InputBox::cancel=ȡ
InputBox::ok=ȷ(&O)

[strings]
1001=״̬
1002=ʫ
1003=
1004=è
1005=
1006=
1007=
1008=ħʧ
1009=
1010=ʾ
1011=¼
1012=AOS
1013=ѡ(AOS)
1014=ôѡ(AOS)
1015=ѣ(Pre-AOS)
1016=ý(Pre-AOS)
1017={0}
1018=AOSȡ.
1019=жװ
1020=ж˫װ
1021=жװ
1022=жװ
1023=жñ
1024=ж
1025=ñԼ
1026=ñLastTarget
1027=ʹñ(޼ʱ)
1028=ʹHeal
1029=ʹCure
1030=ʹRefresh
1031=ʹNight Sight
1032=ʹExplosion
1033=ʹStrength
1034=ʹAgility
1035=δֱ
1036=δָƷ{0}!
1037=˫({0})
1038=ѡĿ
1039=תΪ˫
1040=ΪöѡһµĿ.
1041=:ظõʱ:\n{0}
1042=꾯:޷ҵƷ(Χ).
1043={1} - {0}
1044=תΪ
1045=꾯:δװκƷ.
1046=װ{0} (L:{1})
1047=϶{0} (@{1})
1048=תΪλ
1049=϶()@({0},{1},{2})
1050=ԻӦ({0})
1051=رնԻ
1052=˵Ӧ{0}
1053=:ҪĿ,ǷδĿ!(ҪһWaitForTarget(ȴĿ)ָ?)
1054=Ŀѡ
1055=תΪLastTarget
1056=ѡĿ
1057=ѡĿλ({0},{1})
1058=LastTarget
1059=TargetSelf
1060=LastTarget
1061=ָﷸ()
1062=ָ()
1063=ָͨ()
1064=ָ
1065=ָ
1066=ָ
1067=˵"{0}"
1068=ʹü{0}
1069=ʹħ{0}
1070=ʹ{0}
1071=װ:{0}
1072=ж:{0}
1073=װ{0}
1074=ȴ˵()
1075=ȴ˵(#{0})
1076=༭...
1077=ȴԻ()
1078=ȴԻ(#{0})
1079=WaitForTarget
1080=ͣ{0:#.00}
1081=ȴ{0} {1} {2}
1082='{0}'...
1083=>ֹͣǰ
1084=:{0}
1085=ź'{0}'...
1086='{0}'.
1087=Razor޷ʼ.:
1088=:޷ҵͻ˴ھ.\nԭ:ͻδʼ(Razor޷,ȷͻ).
1089=:޷ҵͻ˽ID\nԭ:ͻδʼ(Razor޷ͻ˹ҹ,ͨڿͻδʱı,ȷͻ).
1090=:޷ϵͳҹ.\nԭ:ڲڴ.
1091=:޷ȡRazorڴ.\nԭ:ϵͳЧ.
1092=:Crypt.dllѱԶ.\nԭ:汾(Crypt.dllļ,°װRazor,ʹԭʼ汾Crypt.dllļ).
1093=:޷Winsock.\nԭ:ڲ,ϵͳ,(°װRazor).
1094=:Ч͵.\nԭ:ƥDLLļ汾(°װRazor).
1095=:޷ӿͻ˸ưȻϢ.\nRazorԲʹЩϢ,һЩܽ޷.Razor?\n\nԭ:Ŀͻ˰汾Razor汾(뾡Razor5.0.0ϰ汾ȷ).
1096=ļ{0}Ѿ{4}{5:F1},{3:F1}({1}{2:F1}).
1097=ЧԴ.
1098=ЧƷID.
1099=Чɫ.
1100=ѡһƷ.
1101='{0}'!\nøõѾ𻵲޷ʹ.
1102={0}ڸøõ޷ҵ.
1103=counters.xmlļѾ𻵲޷ʹ.
1104=ΪԶѡڹر״̬,ڱ´еİԱԸ.
1105=:{0}{1}!
1106=ѡʹõɫ.
1107=ͼ
1108=òֵ:\n{char} - ɫ\n{shard} - վ\n{str}/{hp}/{hpmax} - ״̬\n{dex}/{stam}/{stammax} - ״̬\n{int}/{mana}/{manamax} - ״̬\n{weight}/{maxweight} - Ϣ\n{gold} - Ǯ\n{AR} - װ/ ֿ\n{tithe} - ˰״̬\n{followers}/{followersmax} - ֵ\n{bandage} - ʱ\n{statbar}/{mediumstatbar}/{largestatbar} - ״̬(С//)\n{crimtime} - Ϊﷸʱ\n{stealthsteps} - DZв\n{physresist} - ֿ\n{coldresist} - 俹\n{fireresist} - ׿\n{energyresist} - \n{poisonresist} - \n{luck} - ֵ\n{damage} - ˺ֵ Min-Max(Сֵ-ֵ)\nɫ - HTML16ƴ:'~#rrggbb'('~#~'ɫ)\nߴӼбʹ{Format}ʽ
1109=汾:{0}\nڴʹ:{1}\n:{2} ({3}/s)\n:{4} ({5}/s)\nʱ:{6}\n:0x{7:X8}\n:0x{8:X8}\nƷ:{9}\n:{10}\n\n:Cloud (linhongjun@hotmail.com)\nʱ:2007/07/19\nע:ijЩϢִ޷ʾ(ħ,),ı༭Razor\Language\µRazor_lang.chsļĶϸ˵.
1110=趨:
1111=趨:½
1112=趨:
1113=ȷҪƳ"{0}"?\n⽫Ӱиõ.
1114=ڼظõ"{0}"?
1115=ȡõʱ.
1116=㲻ɾĬϵĸõ.
1117=µĸõ:
1118=޷µĸõ!\nԭ:øõѴ.\n\nھͼظøõ?
1119=µб:
1120=ɾб?
1121={0:X}(ƷΧ)
1122=бɾƷ?
1123=ѡһжб'{0}'еƷ.
1124=жƷŰ.
1125=Ʒδҵ,ѡЧƷ.
1126=Ѿ'{0}'.\nҪΪ'{1}'?
1127=ݳɹ.
1128=!\n¼ݰܻήRazor.¼ļ,RazorԶƳ.\n\nRazorݼ¼ļܻϢ,ЩļӦøκ㲻ε.\n\nȷҪݰ¼?\n(ᱣĸõ)
1129=ѡĿתΪ
1130=µĺ:
1131=ưЧַ.
1132=ͬѴ.
1133=úڼ¼ǰᱻ.\nȷҪ¼ǵú?
1134=ȷҪɾ'{0}'?\n(⽫Dz)
1135=ͣ/ȴ...
1136=LastTarget
1137=
1138=
1139=Ƴ
1140=ʼ¼
1141=ļ'{0}'δҵ.
1142=ȷ?
1143=:{0}ļ{1}޷ɾ:\n{2}
1144=Ľ´RazorʱЧ.
1145=øѡᵼRazorڸõ.\nѾ,Ȼпܻȡ.\nȷҪøù?
1146=ָһЧĶ˿.
1147=Զ(Ѿڶ).
1148=ж{0}...{1}ʣ.
1149={0}ж{1:F1}.
1150=UseOnce
1151=(Ŀ)...
1152=(Ŀ)...
1153=Ƴ(Ŀ)...
1154=б
1155=ָһƷ.
1156=ָһ.
1157=ָһƷƳ.
1158=Ʒ.
1159=ƷƳ.
1160={0}ƷѾӵUseOnce.
1161=UseOnceѿ!
1162=ʹ'{0}'.({1}ƷUseOnce)
1163=ijUseOnceƷд,һ.
1164=:ԶԼ۸{1}gp{0}Ʒ.
1165=Ƴ
1166=óɹ.
1167=
1168=(Խ)
1169=()
1170=ð
1171=
1172=
1173=
1174=
1175=δ.
1176=Razor޷ҵı.
1177={0}ƷҪƶ.(ҪһЩʱ)
1178=޷ҵκοƶƷ.
1179=ƷѴб.
1180=Զ
1181=Լ۸{1}gp{0}Ʒ.
1182=޷беһЩƷ,Ϊû㹻ĽǮ.
1183=:
1184=ͻ˳ȼΪ{0}
1185=ǰʱ:{0}
1186=λõǰ{0},λ'{1}'
1187=ж°δֻ򳬳Χ,ʹñ.
1188={0}Ʒڶнж.
1189={0}Ʒڶнװ.
1190={0}Ʒװ.
1191={0}Ʒδ.(Χ)
1192=:Spells.defļδҵ,ħʽıʾ.
1193=DZв:{0}
1194=ڼ¼DZв.
1195=Ŀ
1196=μս
1197=Ŀ.
1198=ָһµLastTarget
1199=LastTarget.
1200=Ŀ.
1201=δҵ֮ĿĻ֮.
1202=мTargetSelf.
1203=мLastTarget.
1204=µĿ,ȡRazorõĿ.
1205=Ŀ{0}
1206=
1207=ȷҪɾ?
1208=ѡһļͼ.
1209=ȼ

1210=Ʒ
1211=Ŀ
1212=
1213=
1214=
1215=ħ
1216=
1217=
1251=1st
1252=2nd
1253=3rd
1254=4th
1255=5th
1256=6th
1257=7th
1258=8th
1260=ʦ
1270=ʿ
1271=ҩˮ
1272=
1290=ʿ
1300=
1301=
1302=
1303=Ҫ
1304=Razorб
1305=ʹƷ
1306=װ֮ǰжһЩװ.
1307=װ/жƷ
1308=װ/жƷ
1309=µǰʹ֮Ʒ
1310=δװκƷ.
1311=>/Razorȼ
1312=ȼ( {0} )
1313=ȼѽ( {0} )
1314=ȼ
1315=ȼѽ
1316=:{0}
1317=(Ŀ)...
1318=Ŀ곬Χ,LastTargetָᱻִ!
1319=:{0}
1320=͵Ϣ
1321=Ч
1322="If"
1323="Else"
1324="End If"
1325=
1326=
1327=ڲ
1328=
1329=ָһָԼʹ.
1330=ĿЧ.
1331=,Ѽ{0}Ʒ{1}.
1332=ȡǰĿ
1333=⵽°汾.\n\nRazorվ°?
1334=¼
1335=
1336=:ǰĿ겻㽫Ŀָ.LastTargetָЧ.
1337=ͬͻ
1338=ֹ.
1339=ʼRazor"PacketVideo"¼
1340=ֹͣ"PacketVideo"¼/
1341=ʼ¼ʱ.\nѾ¼.
1342=ļڴ˰汾.ȷѰװ°汾Razor.
1343=Ӱļ.\nܲ,Ѿ޸.\nļ޷.
1344=ȡļʱ.ļ𻵻.
1345=:
1346=Ŀ¼޷ɾ.ȷĿ¼Ϊ.
1347=޷Ŀ¼.ȷȷȻ³.
1348=޷ƶļ.ȷЧ.
1349=
// 1350 to 1359 reserved (max length 15!)
1350=ֹͣ
1351=
1352=Ϸ?
1353=
1354=?
1355=ˣ
1356=ɵ?
1357=̫!
1358=군
1359=!
1360=ָһҲ뵽б.
1361=ָһҲӺбƳ.
1362=.
1363=Ƴ.
1364=⹹
1365="For Loop"
1366="End For"
1367=ظ:
1368=Ļ
1369=LastSpell(ħ)
1370=LastSkill()
1371=LastObject(Ŀ)
1372=AllNames(ʾ/)
1373=UseOnce
1374=ָж
1375=ָ
1376=ָ
1377=ָﷸ
1378=ָﷸ
1379=:Ϸųʱ!еƷ뵽.
1380=RazorͿͻȷЧ.
1381=dzϷ,ȻµȷЧ.
1382=Ϸ{0}...{1}ʣ.
1383=...
1384=Ѿ{0}{1},{2}.
1385=Ѿ{0}{1},{2}.
1386=Ѿ{0}{1},{2}.
1387=Դ
1388=Ʊֹ(Ŀж)!
1389=ϷŶ
1390=ֹͣ
1391=>/Լ
1392=NextTarget
1393=ò
1394=ӵUseOnce
1395=LastTarget
1396=༭ʱ...
1397=㵱ǰδκƷ.
1398=
1399=
1400=Э̵:
1401=Ա.
1402=
1403=Դ
1404=LastTarget
1405=ΧڼLastTarget
1406=Զ
1407=ʩʱжװ
1408=Զʹҩˮ,װ
1409=жʱֹ
1410=ѭ
1411=UseOnce
1412=
1413=۴
1414=
1415=ҩˮȼ
1416=Ŀ
1417=/״̬ʾ
// up to 1465: reserved
1466=Բ
1467=ԱǰϷ.\nѡԷ,ѡǩ½.\n\n鿴ֹб,ڰ״̬ǩ.
1468=ע
1469=Ӻ
1470=Ƴ
1471=>/Լ
1472=ʹѽܵĿͻ,Ӧý"".ùܽʹҪͻ˼ܵķ(OSI/EAٷ).\n㲻ȷ,벻Ҫѡ.\n\nȷҪرտͻ˽?
1473=
1474=ʾ/صͼ
1475=̫Զ.
1476=ϷŶ!Ժ.
1477=лս/ƽģʽ
1478=ͶԻ
1479=ָϷڴСЧ,³.
1480=()
1481=( {0})
1482=(UseOnce #{0})
1483=()
1484=( {0} )
1485=ָķַ޷,ȷϵַǷȷ.
1486=Ŷ:
1487=Ŷ:ܾ
1488=Ŀ
1489=жĿ
1490=(Razor)
1491=Ӵ˴
1492=ʼ...
1493=ڼµĸõ...
1494=ڼؿͻ...
1495=ȴͻ...
1496=ǵ!
1497=ӭʹRazor!
1498=2Dͻ(Զ)
1499=3Dͻ(Զ)
1500=(Զ)
1501=͸: {0}%
1502=ָöijʱʱ():
1503=δָ
1504=ijʱ
1505=
1506=Ч.
1507=ԱƷ
1508={0} ״̬
1509=ʳñʩħƻ
1510=ָ
1511=ָ
1512=ָͨ
1513=ָ
1514=ָ
1515=ָ
1516=ָж
1517=ָ
1518=ָͨ
1519=ָ
1520=ָﷸ
1521=:õ'{0}'ڱRazorʹ!\nԸõ޸,ôѾ.ÿһRazorʹö(ͬ)õ.


================================================
FILE: etc/Language/Razor_lang.PTB
================================================
// Razor Portuguese Brazil/PTB Language Pack - By Thiago X
// Last Modified 01/01/04
::CliLoc=ENU

[controls]
WelcomeForm::Text=Bem-Vindo ao razor!
WelcomeForm::label5=Lingua do Razor
WelcomeForm::groupBox3=Perfil
WelcomeForm::newProfile=Novo...
WelcomeForm::label2=Carregar Perfil:
WelcomeForm::groupBox2=Servidor
WelcomeForm::label3=Servidor:
WelcomeForm::label4=Porta:
WelcomeForm::groupBox1=Opcoes do Client
WelcomeForm::makeDef=Fazer essas opcoes como padrao
WelcomeForm::browse=Navegador...
WelcomeForm::label1=Carregar Client:
WelcomeForm::patchEncy=Fazer patch na encriptacao do Client
WelcomeForm::showAtStart=Mostrar isso quando o razor iniciar.
WelcomeForm::quit=&Sair
WelcomeForm::okay=&Ok
MainForm::Text=Razor v{0} (Beta)
MainForm::generalTab=Geral
MainForm::label7=Indioma:
MainForm::logPackets=Abilitar LOGs
MainForm::rememberPwds=Lembrar Senhas 
MainForm::systray=System Tray
MainForm::taskbar=TaskBar
MainForm::label11=Mostrar na:
MainForm::groupBox4=Perfis
MainForm::delProfile=Deletar
MainForm::newProfile=&Novo...
MainForm::showWelcome=Mostrar tela de Bem-Vindo
MainForm::alwaysTop=Usar modo de Sempre no Topo
MainForm::groupBox1=Filtros
MainForm::opacityLabel=Opaco: 100%
MainForm::moreOptTab=Opcoes
MainForm::incomingCorpse=Mostrar nomes de Corpos
MainForm::incomingMob=Mostrar nome de Pessoas/Criaturas
MainForm::setHarmHue=Setar
MainForm::setNeuHue=Setar
MainForm::lblHarmHue=Dano
MainForm::lblNeuHue=Neutra
MainForm::lblBeneHue=Beneficial
MainForm::setBeneHue=Setar
MainForm::setSpeechHue=Setar
MainForm::setWarnHue=Setar
MainForm::setMsgHue=Setar
MainForm::setExHue=Setar
MainForm::autoStackRes=Sempre Jogar Minerios/Peixes no chao
MainForm::queueTargets=Colocar LastTarget e TargetSelf na Fila
MainForm::actionStatusMsg=Mostrar msg de Itens na "fila"
MainForm::spamFilter=Filtrar Spam (Experimental)
MainForm::label4=tiles
MainForm::openCorpses=Abrir corpos em
MainForm::showNotoHue=Mostrar cor de estado na barra de Ttulo
MainForm::lblWarnHue=Msg de aviso
MainForm::lblMsgHue=Msg de sistema
MainForm::lblExHue=Cor da busca
MainForm::chkStealth=Contar passos de Stealth
MainForm::label6=ms
MainForm::label5=Tempo:
MainForm::QueueActions=Tempo para efetuar acoes
MainForm::chkForceSpellHue=Cores das Magias:
MainForm::chkForceSpeechHue=Sobrepor cor da fala
MainForm::label3=Magias:
MainForm::displayTab=Mostrar/Contadores
MainForm::highlightSpellReags=Grifar reagentes requeridos
MainForm::titlebarImages=Mostrar Imagem nos contadores
MainForm::sortCounters=Manter contadores Atualizados
MainForm::checkNewConts=Sempre proucurar novos containers
MainForm::warnCount=Avisar quando contador estiver:
MainForm::groupBox3=Barra de Titulo
MainForm::showInBar=Mostrar isso na barra de titulo:
MainForm::groupBox2=Contadores
MainForm::delCounter=Del/Editar
MainForm::addCounter=Novo
MainForm::recount=Recontar
MainForm::dressTab=(Des)Verstir
MainForm::groupBox6=(Des)Vestir Itens
MainForm::dressDelSel=Remover
MainForm::undressBag=Mudar bag de desvestir
MainForm::undressList=Desvestir agora
MainForm::dressUseCur=Adic. Atual
MainForm::targItem=Adic. (Alvo)
MainForm::dressNow=Vestir Agora
MainForm::groupBox5=Selecao de (Des)Vestir
MainForm::removeDress=Remover
MainForm::addDress=Novo...
MainForm::undressConflicts=Mover itens em conflito (automatico)
MainForm::skillsTab=Skills
MainForm::dispDelta=Atualizar
MainForm::skillCopyAll=Copiar Todos
MainForm::skillCopySel=Copiar Selec.
MainForm::label1=Soma:
MainForm::setlocks=Mudar Todos:
MainForm::resetDelta=Resetar  +/-
MainForm::screenshotTab=Screen Shots
MainForm::capNow=Tirar Foto
MainForm::radioUO=Apenas UO
MainForm::radioFull=Tela Toda
MainForm::screenAutoCap=Capturar Foto de Mortes
MainForm::setScnPath=...
MainForm::dispTime=Incluir data nas Fotos
MainForm::hotkeysTab=Atalhos
MainForm::dohotkey=Executar Selec.
MainForm::groupBox8=Atalho
MainForm::chkPass=Passar para o UO
MainForm::label2=Key:
MainForm::unsetHK=Tirar
MainForm::setHK=Setar
MainForm::chkCtrl=Ctrl
MainForm::chkAlt=Alt
MainForm::chkShift=Shift
MainForm::macrosTab=Macros
MainForm::macroActGroup=Acoes
MainForm::loopMacro=Intinito
MainForm::recMacro=Gravar
MainForm::playMacro=Reproduzir
MainForm::delMacro=Remover
MainForm::newMacro=Novo...
MainForm::agentsTab=Agentes
MainForm::statusTab=Ajuda && Status
MainForm::visitForums=Forum de Ajuda && Suporte
MainForm::visitHome=HomePage do Razor
MainForm::visitGuide=Guia do Usuario - Razor
MainForm::spellUnequip=Desequipar Maos Antes de Castar
MainForm::rangeCheckLT=Distancia Ultimo alvo:
MainForm::moreMoreOptTab=Mais Opcoes
HueEntry::Text=Selecione uma Cor
HueEntry::cancel=Cancelar
HueEntry::okay=&Ok
HueEntry::preview=Proximo
HueEntry::inGame=Selecinar no jogo
HueEntry::label1=Cor:
AddCounter::Text=Editor de Contador
AddCounter::delete=Deletar
AddCounter::target=Alvo 
AddCounter::cancel=Cancelar
AddCounter::Add=&Ok
AddCounter::label4=Cor (Qq: -1):
AddCounter::label3=Item ID:
AddCounter::label2=Formato:
AddCounter::label1=Nome:
MacroInsertWait::Text=Inserir Esperar/Pausar...
MacroInsertWait::radioMenu=Espear por Menus de Estilo Antigo/Dialogos
MacroInsertWait::cancel=&Cancelar
MacroInsertWait::radioStat=Esperar por 
MacroInsertWait::radioTarg=Esperar por Alvo
MacroInsertWait::radioGump=Esperar por GUMP
MacroInsertWait::label1=milliseconds
MacroInsertWait::radioPause=Pausar por:
MacroInsertWait::insert=&Inserir

[strings]
1001=Status de Morto
1002=Musica de Bardo
1003=Sons de Cachorro
1004=Sons de Gato
1005=Son de Cavalo
1006=Sons de Ovelha
1007=Sons de Spirt Speak
1008=Sons de Errar Magia
1009=Estacoes
1010=Mostrar Contadores
1011=Recontar Contadores
1012=Limpar Habilidade Aos
1013=Setar habilidade Primaria (AOS)
1014=Setar Habilidade Secundaria (AOS)
1015=Setar Stun (Pre-AOS)
1016=Setar Disarm (Pre-AOS)
1017=Setando Habilidade {0}
1018=Habilidades do AOS Resetadas.
1019=Desvestir Tudo
1020=Desvestir ambas as Maos
1021=Desvestir mao esquerda
1022=Desvestir mao direita
1023=Desvestir chapeu
1024=Desvestir Joias
1025=Curar-se Com Bandagem
1026=Bandagem do LastTarget
1027=Usar Bandagem (Sem Timer)
1028=Beber Heal
1029=Beber Cura
1030=Beber Refresh
1031=Beber Night Sight
1032=Beber Explosao
1033=Beber Strength
1034=Beber Agility
1035=Bandagem nao encontrada.
1036=Item do tipo {0} nao encontrado!
1037=Dois clicks ({0})
1038=Escolher Novo
1039=Converter para 2Clicks por tipo
1040=Selecione um novo alvo para esta acao.
1041=WARNING: Exception while loading profile property:\n{0}
1042=Macro Warning: Cannot find that item (Out of Range).
1043=Lift {1} - {0}
1044=Convert to Lift by Type
1045=Macro Warning: Not holding anything.
1046=Equip to {0}
1047=Drop to {0} (@{1})
1048=Convert to Relative Location
1049=Drop (Relative) @({0},{1},{2})
1050=GumpResponse (Button {0})
1051=Fechar Gump
1052=MenuResponse {0}
1053=Warning: Macro requested target, but no target sent from server! (Do you need a 'WaitForTarget'?)
1054=Alvo Absoluto
1055=Converter para Ultimo Alvo
1056=Target by Type {0}
1057=Target RelLoc ({0},{1},{2})
1058=Ultimo Alvo
1059=Alvo - Voce Mesmo
1060=Setar ultimo alvo
1061=Alvo - Assassino Aleatorio
1062=Alvo - Criminoso Aleatorio
1063=Alvo - Neutro Aleatorio
1064=Alvo - Inimigo Aleatorio
1065=Alvo - Amigo Aleatorio
1066=Alvo - Nao-Inimigo Aleatio
1067=Dizer "{0}"
1068=UseSkill {0}
1069=Castar Magia {0}
1070=SetAbility {0}
1071=Vestir: {0}
1072=Desvestir: {0}
1073=Unequip Layer {0}
1074=Wait for Menu (Any)
1075=Wait for Menu (#{0})
1076=Edit...
1077=Wait For Gump (Any)
1078=Wait for Gump (#{0})
1079=Wait for Target
1080=Pausa {0:#.00}sec
1081=Esperar por {0} {1} {2}
1082=Carregando '{0}'...
1083=> Para Macro atual
1084=Reproduzir macro: {0}
1085=Reproduzindo '{0}'...
1086=Macro '{0}' terminado.
1087=O razor nao foi possivel inicializar.  Erro Codigo:\n
1088=Descricao: Nao foi possivel achar a janela do client.\nPossivel Causa: O client nao foi iniciado.
1089=Descricao: Nao foi possivel encontrar ThreadID\nPossivel Causa: O client nao foi iniciado.
1090=Descricao: Nao foi possivel criar hook de janela.\nPossivel Causa: Erro interno.
1091=Descricao: O razor nao conseguiu acessar a memoria compartilhada.\nPossivel Causa: Erro ou permissoes invalidas.
1092=Descricao: Crypt.dll foi desabilidado.\nPossivel Causa: Falta de .NETFRAMEWORK ou Versao invalida.
1093=Descricao: Nao foi possivel patchear o client.\nPossivel Causa: Erro interno, Erro do Windows, ou versao imcompativel.
1094=
1095=Warning: Nao foi possivel copiar encriptacao para o client.\nO razor talvez consiga rodar sem essas informacoes, mas talvez todas as opcoes nao funcionem corretamente.  Voce gostaria de executa-lo mesmo assim?\n\nPossivel Causa: O seu client nao  compativel com essa versao do razor.
1096=sua skill {0} foi mudada em {1}{2:F1}, agora e {3:F1}.
1097=Abreviacao invalida.
1098=ItemID Invalida.
1099=Cor Invalida.
1100=Selecione um item para Contar.
1101=Erro carregando '{0}'!\nEsse perfil esta corrompido ou nao pode ser usado.
1102=A propriedade {0} nao foi encontrada nesse perfil.
1103=Seu counters.xml esta corrompido e nao pode ser usado.
1104=A opcao de busca por containers esta desabilidata, Voce tera que abrir todos os containers para os contadores funcionarem.
1105=AVISO: {0} esta agora em {1}!
1106=Selecione a cor que voce quer usar.
1107=Tirar foto agora
//1108=Valores possiveis:\n{char} - Nome do Char\n{shard} - Nome do Shard\n{str}/{hp}/{hpmax} - Status de Vida\n{dex}/{stam}/{stammax} - Status de Dex\n{int}/{mana}/{manamax} - Status de Int\n{weight}/{maxweight} - Informacao do Peso\n{gold} - Ouro total no personagem\n{AR} - Valor da Armadura / Resistencia fisica\n{tithe} - Tithing points\n{bandage} - Tempo de Bandagens\n{statbar}/{mediumstatbar}/{largestatbar} - Status bar\n{crimtime} - Quanto tempo send criminoso\n{stealthsteps} - Passos de Stealth contagem de cor - Codigo de Cor HTML hex: '~#rrggbb' ('~#~' para terminar)\nou um {Format} para a lista de contadroes.
1109=Razor Versao {0}\nMemoria Usada: {1}\nEnviado: {2} ({3}/s)\nRecv: {4} ({5}/s)\nConectado por {6}\n\nSerial do Personagem: 0x{7:X8}\nSerial da Mochila: 0x{8:X8}\n\nItens Rastreados: {9}\nPersonagens Rastreados: {10}\n
1110=Setar Tranca: Cima
1111=Setar Tranca: Baixo
1112=Setar Tranca: Fechada
1113=Tem certeza que deseja remover o contador "{0}"?\nIsso afeta todos os perfis.
1114=Carregar Perfil "{0}" agora?
1115=Aconteceu um erro carregando aquele perfil.
1116=Voce nao pode deletar o perfil padrao.
1117=Entre um nome para o novo perfil: 
1118=Voce nao pode criar um novo perfil!\n Um perfil come sse nome ja existe.\n\nDeseja carregar aquele perfila agora?
1119=Entre um nome para a nova lista de (DES)Vestiver:
1120=Deletar essa lista de (Des)Vestir?
1121={0:X} (Item muito longe)
1122=Deletar esse item da lista de (Des)Vestir?
1123=Selecione uma bag para colocar a lista de '{0}' dentro.
1124=(Des)Vestir bag setada.
1125=Item nao encontrado ou item invalido selecionado.
1126=Essa combinacao de chaves ja esta ligada com '{0}'.\nmudar isso para '{1}'?
1127=Arquivos salvos com sucesso.
1128=AVISO!\nPacotes de LOGs vao reduzir a performace do razor. Arquivos de LOG serao extremamente grandes e o razor nao ira remove-los automaticamente.\n\nIsso tambem ira salvar informacoes pessoais (senhas e etc) e podera cair em maos erradas.\n\nTem certeza que voce deseja habilitar isso?\n(Isso nao vai ser salvo em seu perfil de usuario)
1129=Converter selecionado para TIPO
1130=Entre um nome para o novo macro: 
1131=Aquele nome contem caracteres invalidos.
1132=Um macro com aquele nome ja existe.
1133=Este macro sera apagado depois de gravado.\nTem certeza que deseja gravar POR CIMA deste macro?
1134=Tem certeza que voce deseja apagar PERMANENTEMENTE '{0}'?\n(Isso nao pode ser desfeito)
1135=Inserir Pausa/Esperar...
1136=Inserir Ultimo Alvo...
1137=Mover para Cima
1138=Mover para Baixo
1139=Remove Action
1140=Comecar gravar aqui
1141=O arquivo '{0}' nao foi encontrado.
1142=Voce tem certeza
1143=AVISO: Os seguinte(s) {0} arquivo{1} nao pode(m) ser deletados:\n{2}
1144=Essa mudanca vai ser habilitada a proxima vez que voce iniciar o razor.
1145=Habilitando essa opcao vai fazer com que as senhas sejam salvas como parte de seu perfil.\nEles serao encriptados, mas qualquer pessoa com acesso ao seu arquivo xml podera usa-lo.\nTem certeza que voce deseja habilitar esta opcao?
1146=Voce precisa espeficicar uma porta valida.
1147=Ignorando acoes requisitadas (Ja na fila).
1148=Colocando acoes requisitadas na fila {0}... {1} restante.
1149=Terminado {0} acoes na fila em {1:F1} segundos.
1150=Use Once Agente
1151=Adic. (Alvo)...
1152=Adic. Container (Alvo)...
1153=Remover (Alvo)...
1154=Limpar Lista
1155=Selecione um item para adicionar
1156=Selecione um container.
1157=Selecione um item para remover.
1158=Item adicionado.
1159=Item remivido.
1160={0} iten(s) adicionados para o agente Use Once.
1161=A fila do UseOnce esta vazia!
1162=Usando '{0}'.  ({1} iten(s) restante na fila do UseOnce)
1163=Aqui exite um problema com os UseOnce itens, tentando o proximo.
1164=Agente de Vendas: Vendendo automaticamente {0} item(s) por {1}gp.
1165=Remover
1166=Container setado com sucesso.
1167=Limpar
1168=(Aperte para desativar)
1169=(Aperta para Ativar)
1170=Selecione a Mochila
1171=Limpar Mochila
1172=Agente Organizador
1173=Organizer
1174=Organizar agora
1175=Container nao setado.
1176=Razor nao pode encontrar sua mochila.
1177=Agente organizador na fila {0} item(s) para serem movidos. (Isso pode demorar uns momentos)
1178=Agente organizador nao encontrou nenhum item para mover.
1179=Aquele item ja esta na lista.
1180=AutoSearchExemptions
1181=Agente de Compras comprou {0} item(s) por {1}gp.
1182=O angente de comprar nao conseguiu comprar alguns itens por que voce nao tem dinheiro.
1183=Entre uma quantia:
1184=Prioridade de Processamento do Client {0}
1185=A hora atual e: {0}
1186=Voce esta na {0} em '{1}'
1187=Mochila para Desvestir nao foi encotnrada ou eta muito longe, usando sua mochila.
1188={0} item(s) na fila para semrem desequipados.
1189={0} item(s) na fila para serem equipados.
1190={0} item(s) ja estao equipados.
1191={0} item(s) nao foram encontrados. (Ou muito longes)
1192=AVISO: Spells.def nao foi encontrado, o formato das magias nao serao mostrados.
1193=Passos em Stealth: {0}
1194=Agora Contando Passos em Stealth.
1195=Limpar fila de Alvos
1196=Atacar ultimo combatente
1197=Alvo na fila limpo.
1198=Selecione um novo 'Last Target'
1199=Last Target setado.
1200=Novo alvo setado.
1201=No one matching that was found on your screen.
1202=Fila para si mesmo.
1203=Fila para ultimo alvo.
1204=O Servidor enviou um novo alvo, cancelando o alvo do razor.
1205=Alvo por tipo {0}
1206=Scavenger
1207=Tem certeza que voce deseja deletar isso?
1208=Selecione uma pasta para guardar as Fotos tiradas pelo razor.
1209=Atalhos
1210=Itens
1211=Alvos
1212=Agentes
1213=Vestir
1214=Macros
1215=Magias
1216=Skills
1217=Variados
// 1219 - 1250 reserved
1251=1st
1252=2nd
1253=3rd
1254=4th
1255=5th
1256=6th
1257=7th
1258=8th
// 1259 not used
1260=Necromancy
// 1261 - 1269 not used
1270=Chivalry
1271=Pocoes
1272=Special Moves
// 1273 - 1299 reserved
1373=UseOnce
1301=Sell
1302=Buy
1303=Dado Requerido
1304=Lista de Comandos do Razor
1305=Usar Wand de Identificacao
1306=Voce precisa desarmar alguma coisa antes de armar isso.
1307=(Des)Vestir mao direita
1308=(Des)vestir mao esquerda
1309=Jogar o que estiver segurando.

1311=> Habilitar/Desabilitar Atalhos
1312=Atalhos habilitados (Pressione {0} para desabilitar)
1313=Atalhos desabilitados(Pressione {0} para habilitar)
1314=Atalhos Abilitados
1315=Atalhos desabilitados
1316=Ande: {0}
1317=Adicionar tipo (Target)...
1318=Alvo muito longe, ao no executada!
1319=Vender Maximo: {0}

================================================
FILE: etc/Language/Razor_lang.bg
================================================
// Razor English/ENU Language Pack
// Last Modified 12/16/03
::CliLoc=enu

[controls]
WelcomeForm::Text=   Razor!
WelcomeForm::label5=   Razor:
WelcomeForm::groupBox3=
WelcomeForm::newProfile=...
WelcomeForm::label2= :
WelcomeForm::groupBox2=
WelcomeForm::label3=:
WelcomeForm::label4=:
WelcomeForm::groupBox1=  
WelcomeForm::makeDef=    
WelcomeForm::browse=...
WelcomeForm::label1= :
WelcomeForm::patchEncy=Patch   
WelcomeForm::showAtStart=     Razor
WelcomeForm::quit=&
WelcomeForm::okay=&
MainForm::generalTab=
MainForm::label7=:
MainForm::logPackets=   
MainForm::rememberPwds=  
MainForm::systray= tray 
MainForm::taskbar=Taskbar
MainForm::label11=:
MainForm::groupBox4=
MainForm::delProfile=
MainForm::newProfile=&...
MainForm::showWelcome= Welcome 
MainForm::alwaysTop= -  
MainForm::groupBox1=
MainForm::opacityLabel= : 100%
MainForm::moreOptTab= 
MainForm::incomingCorpse=   /  
MainForm::incomingMob=     /
MainForm::setHarmHue=
MainForm::setNeuHue=
MainForm::lblHarmHue=
MainForm::lblNeuHue=
MainForm::lblBeneHue=
MainForm::setBeneHue=
MainForm::setSpeechHue=
MainForm::setWarnHue=
MainForm::setMsgHue=
MainForm::setExHue=
MainForm::autoStackRes=. stack-  Ore/Fish/Logs  .
MainForm::queueTargets=Queue-  LastTarget  TargetSelf
MainForm::actionStatusMsg= Action-Queue   
MainForm::spamFilter=   ()
MainForm::label4=
MainForm::openCorpses=   
MainForm::showNotoHue= "noto hue"  {char}  TitleBar-
MainForm::lblWarnHue= 
MainForm::lblMsgHue= 
MainForm::lblExHue=Search Exemption 
MainForm::chkStealth=   stealth
MainForm::label6=.
MainForm::label5= delay:
MainForm::QueueActions=Auto-Queue    Delay 
MainForm::chkForceSpellHue=   . :
MainForm::chkForceSpeechHue=   
MainForm::label3=  . :
MainForm::displayTab=/
MainForm::highlightSpellReags=   
MainForm::titlebarImages=    
MainForm::sortCounters=  ./.
MainForm::checkNewConts=.    
MainForm::warnCount=    :
MainForm::groupBox3=  Titlebar
MainForm::showInBar=    Titlebar-:
MainForm::groupBox2=
MainForm::delCounter=/
MainForm::addCounter=...
MainForm::recount=
MainForm::dressTab=
MainForm::groupBox6= 
MainForm::dressDelSel=
MainForm::undressBag=   
MainForm::undressList= 
MainForm::dressUseCur= 
MainForm::targItem= ()
MainForm::dressNow= 
MainForm::groupBox5=  
MainForm::removeDress=
MainForm::addDress=...
MainForm::undressConflicts=.  "" 
MainForm::skillsTab=
MainForm::dispDelta= 
MainForm::skillCopyAll= 
MainForm::skillCopySel= 
MainForm::label1= :
MainForm::setlocks=  :
MainForm::resetDelta=  +/-
MainForm::screenshotTab=
MainForm::capNow= 
MainForm::radioUO=  
MainForm::radioFull= 
MainForm::screenAutoCap=.   
MainForm::setScnPath=...
MainForm::dispTime= 
MainForm::hotkeysTab= 
MainForm::dohotkey= 
MainForm::groupBox8= 
MainForm::chkPass=   
MainForm::label2=:
MainForm::unsetHK=
MainForm::setHK=
MainForm::chkCtrl=Ctrl
MainForm::chkAlt=Alt
MainForm::chkShift=Shift
MainForm::macrosTab=
MainForm::macroActGroup=
MainForm::loopMacro=
MainForm::recMacro=
MainForm::playMacro=
MainForm::delMacro=
MainForm::newMacro=...
MainForm::agentsTab=
MainForm::statusTab= && 
MainForm::visitForums= &&  
MainForm::visitHome=Razor 
MainForm::visitGuide=Razor 
HueEntry::Text= 
HueEntry::cancel=
HueEntry::okay=&
HueEntry::preview=
HueEntry::inGame=  
HueEntry::label1=  :
AddCounter::Text=  
AddCounter::delete=
AddCounter::target= 
AddCounter::cancel=
AddCounter::Add=&
AddCounter::label4= ( .: -1):
AddCounter::label3= ID:
AddCounter::label2=:
AddCounter::label1=:
MacroInsertWait::Text= 
MacroInsertWait::radioMenu=     
MacroInsertWait::cancel=&
MacroInsertWait::radioStat=  
MacroInsertWait::radioTarg=  
MacroInsertWait::radioGump=  gump
MacroInsertWait::label1=
MacroInsertWait::radioPause= :
MacroInsertWait::insert=&


[strings]
1001= - 
1002=  
1003= 
1004= 
1005= 
1006= 
1007=Spirit Speak 
1008=    
1009=
1010= 
1011=  
1012= AOS 
1013=   (AOS)
1014=   (AOS)
1015=/ Stun (Pre-AOS)
1016=/ Disarm/ (Pre-AOS)
1017=   {0}
1018=AOS  .
1019= 
1020=  
1021=  
1022=  
1023= 
1024= 
1025=  
1026= LastTarget
1027= ( )
1028= Heal
1029= Cure
1030= Refresh
1031= Night Sight
1032="" Explosion
1033= Strength
1034= Agility
1035= 
1036=   : {0}!
1037=Double Click ({0})
1038= 
1039=  DClick  .
1040=    .
1041=:     :\n{0}
1042= :    ! ( ).
1043= {1} - {0}
1044=  ""  
1045= :   .
1046=  {0}
1047=  {0} (@{1})
1048=   
1049= () @({0},{1},{2})
1050=Gump  ( {0})
1051= Gump
1052=  {0}
1053=:   ,       ! (    'WaitForTarget')
1054= 
1055=  LastTarget
1056=   {0}
1057=  ({0},{1},{2})
1058=Last Target
1059=Target Self
1060= Last Target
1061=   (red)
1062=   (gray)
1063=   (blue)
1064=   (orange)
1065=   (green)
1066=  - (hmm..:)
1067= "{0}"
1068=  {0}
1069=  {0}
1070=  {0}
1071=: {0}
1072=: {0}
1073= Layer {0}
1074=   (Any)
1075=   (#{0})
1076=...
1077=  Gump (Any)
1078=  Gump (#{0})
1079=  
1080= {0:#.00}sec
1081=  {0} {1} {2}
1082= '{0}'...
1083=>  
1084=: {0}
1085=  '{0}'...
1086= '{0}' .
1087=Razor   .   :\n
1088=Description: Could not find the client Window Handle.\nPossible Cause: The Client may not have initialized properly.
1089=Description: Could not find the Client's ThreadID\nPossible Cause: The Client may not have initialized Properly.
1090=Description: Could not create Windows Hooks.\nPossible Cause: Internal error.
1091=Description: Could not create or access Razor shared memory.\nPossible Cause: Windows Error or invalid permissions.
1092=Description: Crypt.dll has disabled itself.\nPossible Cause: Version mismatch.
1093=Description: Could not patch the client's Winsock functions.\nPossible Cause: Internal error, Windows Error, or Incompatible Version.
1094=
1095=:     /    .\nRazor      ,       .        ?\n\n :           Razor.
1096= {0}   {1}{2:F1},    {3:F1}.
1097= .
1098=  ID.
1099= .
1100=   .
1101=   '{0}'!\n    .
1102= {0}     .
1103= counters.xml    .
1104=   . .    ,        be .
1105=: {0}   {1}!
1106= ,   .
1107=  !
//1108=:\n{char} - \n{shard} - \n{str}/{hp}/{hpmax} -  \n{dex}/{stam}/{stammax} -  \n{int}/{mana}/{manamax} - \n{weight}/{maxweight} -  \n{gold} -    \n{AR} -  \n{tithe} - Tithing \n{bandage} -     \n{statbar}/{mediumstatbar}/{largestatbar} -  \n{crimtime} -    \n{stealthsteps} - Stealth  |   r - HTML  : '~#rrggbb' ('~#~'  )\n {Format}    
1109=Razor Version: {0}\n  : {1}\n: {2} ({3}/s)\n: {4} ({5}/s)\n  {6}\n\n  : 0x{7:X8}\n  : 0x{8:X8}\n\n : {9}\n  Mobs: {10}\n
1110=: 
1111=: 
1112=
1113=  ,     ? "{0}"?\n      .
1114=  "{0}" ?
1115=    .
1116=    .
1117=   : 
1118=    !\n :    .\n\n      ? 
1119=    :
1120=   ?
1121={0:X} (  )
1122=     ?
1123=     '{0}' .
1124=    .
1125=   ,   .
1126=      '{0}'.\n  '{1}'?
1127=  .
1128=!\n  .    ,  Razor     !\n\nRazor-                 .\n\n  ,     ?\n(      .)
1129=  
1130=   : 
1131= .
1132=   .
1133=     .\n ,   ?
1134=   '{0}'?\n(   )
1135= ...
1136= LastTarget
1137= 
1138= 
1139= 
1140=   
1141= '{0}'   .
1142=  ?
1143=:  {0} {1}    !:\n{2}
1144=         Razor.
1145=          .\n   ,          ,        .\n     ?
1146=    .
1147=  ( queued).
1148=Queuing   {0}... {1} .
1149= {0} queued  {1:F1} .
1150=  
1151= ()...
1152=  ()...
1153= ()...
1154= 
1155=   .
1156= .
1157= ,   .
1158=  .
1159=  .
1160={0} ()    .
1161=Queue     !
1162= '{0}'.  ({1} () ())
1163=       ,   .
1164= :  {0} ()  {1}.
1165=
1166=   .
1167=
1168=()
1169=()
1170= " "
1171= " "
1172=
1173=
1174= !
1175=   .
1176=Razor     .
1177=  {0} ()  . (   .)
1178=     .
1179=    .
1180=.  - Exemptions ()
1181=   {0} ()  {1}.
1182=    ,    .
1183= :
1184=   - {0}
1185= : {0}
1186=   {0}  '{1}'
1187=       ,    .
1188={0} () ()  .
1189={0} () ()  .
1190={0} ()  ().
1191={0} ()  / (). ( )
1192=: Spells.def   ,         .
1193=Stealth : {0}
1194= stealth .
1195=  Target Queue
1196=   (AttackLast)
1197=Target queue .
1198=  'Last Target'
1199=Last Target .
1200=  .
1201=   .
1202=  queue target self.
1203=  queue last target.
1204=   ,   Razor .
1205=   {0}
1206=.  (scavenger)
1207=  ,     ?
1208=   .
1209= 
1210=
1211=
1212=
1213=
1214=
1215=
1216=
1217=
// 1219 - 1250 reserved
1251=1
1252=2
1253=3
1254=4
1255=5
1256=6
1257=7
1258=8
// 1259 not used
1260=
// 1261 - 1269 not used
1270= - 
1271=
1272=
// 1273 - 1299 reserved
1373= 
1301=
1302=
1303=  
1304=Razor  
1305=   
1306=  ,     .
1307=/  
1308=/  
1309=  .

1311=> /  
1312=   ( {0}  )
1313=   ( {0}  )
1314=  
1315=  
1316= : {0}


================================================
FILE: etc/Language/Razor_lang.cht
================================================
// Razor Traditional Chinese/CHT Language Pack
// Last modified Date: 2007-7-19
// Based on Simplified Chinese language file.
// Translated by Cloud, E-mail: linhongjun@hotmail.com, Blog: http://blog.plaync.jp/linhongjun/55934
// If Razor can not load skillnames with this language file, please replace "Cliloc.chs" with "Cliloc.enu" under UO installation directory. Becuase there's no corresponding entry in localization file of simplified chinese. Make sure you have made a copy of original file before doing this.
// TOޯW٥iHT,Х"Cliloc.enu"UOw˥ؿU"Cliloc.chs",]NORl"Cliloc.chs",MW"Cliloc.enu""Cliloc.chs".eOA@~tΥ²餤.t~c餤媩"Cliloc.cht",pG㪺ܤ]iHi,̭Ƨ׫ܰ.pGưoӤ譱]vT,jP˨ϥ.eаȥnƥl.
// Special string used in the game such as LastTarget, LastObject will not be translated in order to match with UO.
// LastTarget,LastObjectoON|i½Ķ,ɶqOPUO]w@P.
// UseOnceȶȪܤ@ʪNz,LSONq,Ȯɤ@½ĶҼ{.
// This CHT language pack is converted by tool. Please contact me for any problem or suggestion.
// cyqLuഫMiyչӦ,py½ĶWPΰDp,HK.
// HWɻ,HUy󤺮e:
::Encoding=BIG5
::CliLoc=CHT

[controls]
WelcomeForm::Text=wϥRazor - UOaQb!
WelcomeForm::groupBox3=UOw˸|(w]۰ʰ)
WelcomeForm::dataBrowse=s...
WelcomeForm::label5=y:
WelcomeForm::groupBox2=A
WelcomeForm::label3=A:
WelcomeForm::label4=f:
WelcomeForm::groupBox1=Ȥݳ]w(w]۰ʰ)
WelcomeForm::useEnc=ϥOSI[K
WelcomeForm::makeDef=OseȬw]tm
WelcomeForm::browse=s...
WelcomeForm::label1=[Ȥ:
WelcomeForm::patchEncy=ѱKȤ(DOSI)
WelcomeForm::showAtStart=Ұʮܥ
WelcomeForm::quit=(&Q)
WelcomeForm::okay=Ұ(&O)

MainForm::Text=Razor v{0}
MainForm::generalTab=@
MainForm::btnMap=}UOwt
MainForm::label10=ˬds:
MainForm::systray=tγqϰ
MainForm::taskbar=
MainForm::smartCPU=}ҴCPUϥ
MainForm::label7=y:
MainForm::label11=ܩ:
MainForm::groupBox4=ӤHtmɮ(OsProfilesؿU)
MainForm::delProfile=R
MainForm::newProfile=إ(&N)...
MainForm::showWelcome=wɭ(|vTҦΤ)
MainForm::alwaysTop=}Ҵ೻
MainForm::groupBox1=Lo
MainForm::opacityLabel=z: 100%
MainForm::moreMoreOptTab=h]w
MainForm::blockHealPoison=bؼФrɶiv
MainForm::potionEquip=ϥĤɦ۰ʸѰ/s˳
MainForm::label17=RazorT:
MainForm::QueueActions=۰ʶCƥؼЩɰʧ@
MainForm::spellUnequip=Ikɦ۰ʸѰ˳
MainForm::autoOpenDoors=۰ʶ}(ɤK)
MainForm::alwaysStealth=`OܼB
MainForm::autoFriend=Nζn
MainForm::chkStealth=pB
MainForm::rememberPwds=OKX()
MainForm::showtargtext=ܥؼЪA
MainForm::preAOSstatbar=ϥPre-AOSA
MainForm::logPackets=}Ҹƥ]O()
MainForm::rangeCheckLT=LastTargetOZ˴
MainForm::actionStatusMsg=ܰʧ@CAT
MainForm::label5=ؼаʧ@:
MainForm::label9=w]Cuv:
MainForm::label8=B
MainForm::label6=ms
MainForm::label18=x
MainForm::gameSize=jCjp:
MainForm::smartLT=}ҴLastTargetO
MainForm::moreOptTab=]w
MainForm::smoothWalk=Ʀ樫
MainForm::negotiate=PAӹCS
MainForm::setLTHilight=]w
MainForm::lthilight=GLastTarget
MainForm::filterSnoop=LosT
MainForm::incomingCorpse=ܫW()
MainForm::incomingMob=ܤHW/ͪW()
MainForm::setHarmHue=]w
MainForm::setNeuHue=]w
MainForm::lblHarmHue=`
MainForm::lblNeuHue=
MainForm::lblBeneHue=q
MainForm::setBeneHue=]w
MainForm::setSpeechHue=]w
MainForm::setWarnHue=]w
MainForm::setMsgHue=]w
MainForm::setExHue=]w
MainForm::autoStackRes=۰ʩ}Unq//
MainForm::queueTargets=CLastTargetMTargetSelfO
MainForm::spamFilter=LoƨtΰT
MainForm::label4=B
MainForm::openCorpses=}s
MainForm::showNotoHue=ܷe⪺CD(,,,,)
MainForm::lblWarnHue=ĵiTC
MainForm::lblMsgHue=RazorTC
MainForm::lblExHue=jѰC
MainForm::blockDis=ԪҦU
MainForm::chkForceSpellHue=j]kGyC:
MainForm::chkForceSpeechHue=jy奻C
MainForm::label3=Gy榡:

MainForm::displayTab=/p
MainForm::warnCount=pƾCpUƭȮĵi:
MainForm::excludePouches=û۰ʷjp]
MainForm::highlightSpellReags=IkɰG]kħ(D)
MainForm::titlebarImages=DHϧΤ覡ܸ귽
MainForm::checkNewConts=۰ʷjse
MainForm::groupBox3=ܼD
MainForm::showInBar=UODܦpUT:
MainForm::groupBox2=귽pƾ
MainForm::counters::0=W(榡)
MainForm::counters::1=ƶq
MainForm::delCounter=R/s
MainForm::addCounter=sW...
MainForm::recount=sp
MainForm::dressTab=˳/
MainForm::groupBox6=˳/۪~
MainForm::clearDress=MŦC
MainForm::dressDelSel=
MainForm::undressBag=窫s]
MainForm::undressList=h窫
MainForm::dressUseCur=K[e
MainForm::targItem=K[(ؼ)
MainForm::dressNow=˳
MainForm::groupBox5=˳/窫
MainForm::removeDress=
MainForm::addDress=K[...
MainForm::undressConflicts=۰ʲUĬ𪫫~
MainForm::skillsTab=ޯ
MainForm::dispDelta=ܧޯPA
MainForm::skillCopyAll=ƻs
MainForm::skillCopySel=ƻsҿ
MainForm::label1=򥻧ޯM:
MainForm::setlocks=]wޯ:
MainForm::resetDelta=m+/-
MainForm::skillList::0=ޯW
MainForm::skillList::1=ƭ
MainForm::skillList::2=
MainForm::skillList::3=+/-
MainForm::skillList::4=W
MainForm::skillList::5=w
MainForm::agentsTab=Nz
MainForm::hotkeysTab=
MainForm::dohotkey=ҿ
MainForm::groupBox8=
MainForm::chkPass=ǰeUO
MainForm::label2=:
MainForm::unsetHK=]w
MainForm::setHK=]w
MainForm::chkCtrl=Ctrl
MainForm::chkAlt=Alt
MainForm::chkShift=Shift
MainForm::macrosTab=
MainForm::macroActGroup=ʧ@
MainForm::loopMacro=`
MainForm::recMacro=O
MainForm::playMacro=
MainForm::delMacro=
MainForm::newMacro=إ...
MainForm::screenshotTab=^
MainForm::label12=Ϲ:
MainForm::capNow=ߧY^
MainForm::radioUO=ȭUO
MainForm::radioFull=ù
MainForm::screenAutoCap=`ɦ۰^
MainForm::setScnPath=...
MainForm::dispTime=Ϲ]tIɶ
MainForm::videoTab=W
MainForm::recFolder=...
MainForm::label13=WOsƧ:
MainForm::groupBox7=PacketVideoO
MainForm::vidRec=}lOPacketVideo
MainForm::groupBox10=AVIvO
MainForm::flipVidVert=
MainForm::flipVidHoriz=
MainForm::recAVI=}lOAVIv...
MainForm::label16=ѪR:
MainForm::label15=FPS:
MainForm::label19=½:
MainForm::groupBox9=PacketVideo^
MainForm::rpvTime=00:00/00:00
MainForm::label14=t:
MainForm::vidClose=
MainForm::vidPlayStop=
MainForm::vidPlay=
MainForm::vidOpen=}...
MainForm::statusTab=UPA
MainForm::forumsLink=RazorQװ
MainForm::homeLink=RazorD
MainForm::userGuideLink=RazorΤU

HueEntry::Text=C
HueEntry::cancel=
HueEntry::okay=Tw(&O)
HueEntry::preview=w
HueEntry::inGame=C
HueEntry::label1=CNX:

AddCounter::Text=K[@ӭpƾ
AddCounter::delete=R
AddCounter::target=ؼ
AddCounter::cancel=
AddCounter::Add=Tw(&O)
AddCounter::label4=C(:-1):
AddCounter::label3=~ID:
AddCounter::label2=榡:
AddCounter::label1=W:

MacroInsertWait::Text=J/Ȱ...
MacroInsertWait::radioMenu=­檺/ܮ
MacroInsertWait::cancel=(&C)
MacroInsertWait::radioStat=
MacroInsertWait::radioTarg=ݥؼ
MacroInsertWait::radioGump=ݹܮ
MacroInsertWait::label1=ms
MacroInsertWait::radioPause=Ȱ:
MacroInsertWait::insert=J(&I)

MacroInsertIf::Text=JIf...
MacroInsertIf::label1=If:
MacroInsertIf::cancel=(&C)
MacroInsertIf::insert=J(&I)

InputBox::cancel=
InputBox::ok=Tw(&O)

[strings]
1001=`A
1002=uC֤H
1003=sn
1004=ߥsn
1005=sn
1006=ϥsn
1007=Fyn
1008=]kn
1009=Ѯ
1010=ܭpƾ
1011=sp
1012=MAOSO
1013=}ҭO(AOS)
1014=}ҦO(AOS)
1015=}ҷwt(Pre-AOS)
1016=}ҸѰZ(Pre-AOS)
1017=]wO{0}
1018=AOSOw.
1019=UҦ˳
1020=U˳
1021=U˳
1022=Uk˳
1023=UUl
1024=U
1025=^avۤv
1026=^aLastTarget
1027=ϥ^a(Lp)
1028=ϥHeal
1029=ϥCure
1030=ϥRefresh
1031=ϥNight Sight
1032=ϥExplosion
1033=ϥStrength
1034=ϥAgility
1035=o{^a
1036=o{w~{0}!
1037=({0})
1038=swؼ
1039=ഫ
1040=Ӱʧ@ܤ@ӷsؼ.
1041=ĵi:[ӤHtmɮݩʮɵoͷN~:\n{0}
1042=ĵi:Lk쪫~(WXd).
1043=_{1} - {0}
1044=ഫ_
1045=ĵi:˳ƥ󪫫~.
1046=˳ƨ{0} (L:{1})
1047=ʨ{0} (@{1})
1048=ഫ۹m
1049=(۹)@({0},{1},{2})
1050=ܮT({0})
1051=ܮ
1052=T{0}
1053=ĵi:ݭnؼ,OAoeؼ!(Aݭn@WaitForTarget(ݥؼ)O?)
1054=ؼп
1055=ഫLastTarget
1056=ھܥؼ
1057=sܥؼЦm({0},{1})
1058=LastTarget
1059=TargetSelf
1060=]wLastTarget
1061=VHo(W)
1062=VHäH(ǦW)
1063=VHqH(ŦW)
1064=VHĤH
1065=VHͤH
1066=VHDͤH
1067="{0}"
1068=ϥΧޯ{0}
1069=ϥ]k{0}
1070=ϥίO{0}
1071=˳:{0}
1072=U:{0}
1073=Ѱ˳{0}
1074=ݵ(N)
1075=ݵ(#{0})
1076=s...
1077=ݹܮ(N)
1078=ݹܮ(#{0})
1079=WaitForTarget
1080=Ȱ{0:#.00}
1081={0} {1} {2}
1082=['{0}'...
1083=>e
1084=:{0}
1085=񥨶'{0}'...
1086='{0}'w.
1087=RazorLkl.~NX:
1088=yz:LkȤݵfy`.\n]:Ȥݥ`l(RazorLkЫبDf,нTOȤݥ`Ұ).
1089=yz:LkȤݶi{ID\n]:Ȥݥ`l(RazorҰʫLkPȤݱ_,oq`OѩȤݦbҰʹL{ɪYҾɭP,нTOȤݥ`Ұ).
1090=yz:LkЫبtα_.\n]:f~.
1091=yz:LkЫةŪRazor@ɰO.\n]:tο~εLij\i.
1092=yz:Crypt.dllwQ۰ʸT.\n]:(Crypt.dllla,ЭswRazor,åBϥέlCrypt.dll).
1093=yz:LkץWinsock\.\n]:~,tο~,ۮeʰD(ЭswRazor{).
1094=yz:LİѼƳQǰe[.\n]:ǰtDLL󪩥(ЭswRazor{).
1095=ĵi:LkqȤݽƻs]שΥ[KT.\nRazoriHϥγoǰTӹB,@ǥ\NLk`B@.AQ~ҰRazor?\n\n]:AȤݪPRazorݮe(кɧ֧sRazor5.0.0ΥHWHTOiH`u@).
1096=Aޯ{0}wgF{4}{5:F1},{bO{3:F1}({1}{2:F1}).
1097=LY.
1098=LĪ~ID.
1099=LC.
1100=ܤ@Ӫ~ӭp.
1101=['{0}'~!\nӭӤHtmɮפwglaåBLkϥ.
1102=ݩ{0}bӭӤHtmɮפLk.
1103=Acounters.xmlwglaåBLkϥ.
1104=]A۰ʮej]wBA,A{bs}Ҧ]HKpƾiHs.
1105=ĵi:{0}ƶq{bO{1}!
1106=ܧAQϥΪC.
1107=ߧY^
1108=iΰѼƩέ:\n{char} - W\n{shard} - W\n{str}/{hp}/{hpmax} - dA\n{dex}/{stam}/{stammax} - ӱA\n{int}/{mana}/{manamax} - OA\n{weight}/{maxweight} - tT\n{gold} - \n{AR} - ˥/ O\n{tithe} - |A\n{followers}/{followersmax} - Hqƶq̤j\n{bandage} - ^ap\n{statbar}/{mediumstatbar}/{largestatbar} - A(p//j)\n{crimtime} - oǮɶ\n{stealthsteps} - Bƭpƾ\n{physresist} - z\n{coldresist} - BNܩ\n{fireresist} - ܩ\n{energyresist} - qܩ\n{poisonresist} - rܩ\n{luck} - B\n{damage} - ˮ` Min-Max(̤p-̤j)\nC - HTML16iNX:'~#rrggbb'(J'~#~'CNX)\nΪ̱qpƾCϥ{Format}榡
1109={:{0}\nsϥ:{1}\noe:{2} ({3}/s)\n:{4} ({5}/s)\nsɶ:{6}\naǸ:0x{7:X8}\nI]Ǹ:0x{8:X8}\nܪ~:{9}\nܥͪ:{10}\n\nc餤:Cloud (linhongjun@hotmail.com)\nsɶ:2007/03/11\n`Nƶ:pYǰTX{~εLk(p]kW,ޯW),ХΤ奻sn󥴶}Razor\Language\URazor_lang.chs\ŪԲӻ.
1110=]wޯ:W
1111=]wޯ:U
1112=]wޯ:w
1113=AT{npƾ"{0}"?\noN|vTҦӤHtmɮ.
1114={b[ӤHtmɮ"{0}"?
1115=ŪӤHtmɮ׮ɵoͿ~.
1116=AiHRw]ӤHtmɮ.
1117=JsӤHtmɮתW:
1118=LkЫطsӤHtmɮ!\n]:ӭӤHtmɮפwsb.\n\nAQ{bN[ӭӤHtmɮ׶?
1119=Js窫CW:
1120=RӦ窫C?
1121={0:X}(~WXd)
1122=q窫CRӪ~?
1123=ܤ@ӥ]ΨӨUC'{0}'~.
1124=]wU~s].
1125=~,οܤFLĪ~.
1126=զXwgsb'{0}'.\nݭnאּ'{1}'?
1127=Ʀ\Os.
1128=ĵi!\nOƥ]i|CRazorʯ.O|vWj,ORazor|۰ʲ.\n\nRazorưOi|]tӤHTҦpKX,åBoǤӵAHH.\n\nAT{n}Ҹƥ]O?\n(oӤ|OsAӤHtmɮפ)
1129=Nܪؼഫ
1130=JsW:
1131=ӦW٥]tLĦr.
1132=PWwsb.
1133=ӥbOeN|QM.\nAT{nNOл\ӥ?
1134=AT{nä[R'{0}'?\n(oNOifާ@)
1135=JȰ/...
1136=J]wLastTarget
1137=W
1138=U
1139=ʧ@
1140=}lO
1141='{0}'.
1142=AT{?
1143=ĵi:HU{0}{1}LkQR:\n{2}
1144=N|bUҰRazorɥͮ.
1145=}Ҹӳ]wN|ɭPRazorOsAKXӤHtmɮפ.\nޱKXwgQ[K,LHMi.\nAT{n}Ҹӥ\?
1146=Aw@ӦĪf.
1147=ʧ@ШD(wgB󶤦C).
1148=Cʧ@ШD{0}...{1}Ѿl.
1149={0}ӶCʧ@{1:F1}.
1150=UseOnceNz
1151=K[(ؼ)...
1152=K[e(ؼ)...
1153=(ؼ)...
1154=MŦC
1155=V@Ӫ~HK[.
1156=V@Ӯe.
1157=V@Ӫ~H.
1158=~wK[.
1159=~w.
1160={0}Ӫ~wgK[UseOnceNz.
1161=UseOnceCw!
1162=ϥ'{0}'.({1}Ӫ~dUseOnceC)
1163=AYUseOnce~sbD,դU@.
1164=cNz:۰ʥH{1}gpc{0}Ӫ~.
1165=
1166=e]w\.
1167=M
1168=(HT)
1169=(H})
1170=]w]
1171=M]
1172=zNz
1173=z
1174={bz
1175=e]w.
1176=RazorLkAI].
1177=zNzo{{0}Ӫ~ݭn.(oݭn@Ǯɶ)
1178=zNzLkiHʪ~.
1179=Ӫ~wBC.
1180=۰ʷjѰ
1181=ʶRNzH{1}gpʶR{0}Ӫ~.
1182=ʶRNzLkʶRAC@Ǫ~,]AS.
1183=Jƶq:
1184=Ȥݵ{uv]w{0}
1185=eɶO:{0}
1186=AҳBme{0},'{1}'
1187=U]o{ζWXd,ϥέI]N.
1188={0}Ӫ~B󶤦CNQU.
1189={0}Ӫ~B󶤦CNQ˳.
1190={0}Ӫ~w˳.
1191={0}Ӫ~o{.(WXd)
1192=ĵi:Spells.def󥼧,]kGy榡奻N|.
1193=B:{0}
1194={bOB.
1195=MؼжC
1196=̫ѥ[԰
1197=ؼжCwM.
1198=V@ӷsLastTarget
1199=LastTargetw]w.
1200=sؼФw]w.
1201=ŦX󤧥ؼЩù.
1202=C[JTargetSelf.
1203=C[JLastTarget.
1204=Aoesؼ,Razor]wؼ.
1205=]wؼ{0}
1206=MD
1207=AT{nRoӶ?
1208=ܤ@ӸƧxs^.
1209=

1210=~
1211=ؼ
1212=Nz
1213=窫
1214=
1215=]k
1216=ޯ
1217=
1251=1st
1252=2nd
1253=3rd
1254=4th
1255=5th
1256=6th
1257=7th
1258=8th
1260=Ův
1270=Mh
1271=Ĥ
1272=S
1290=Zh
1300=Ԫ
1301=
1302=R
1303=ݭnJ
1304=RazorOC
1305=ϥΤ⤤~
1306=bA˳ƤeAU@Ǹ˳.
1307=˳/Uk⪫~
1308=˳/U⪫~
1309=UeϥΤ~
1310=A˳ƥ󪫫~.
1311=>}/TRazor
1312=w}( {0} T)
1313=wT( {0} })
1314=w}
1315=wT
1316=樫:{0}
1317=K[(ؼ)...
1318=ШDؼжWXd,LastTargetO|Q!
1319=̤jƶq:{0}
1320=sT
1321=I]
1322=J"If"
1323=J"Else"
1324=J"End If"
1325=]wƶq
1326=ɵ
1327={bɵ
1328=ɵNz
1329=V@ӮeӸɵΫVۤvӨϥλȦ.
1330=ؼЮeL.
1331=ɵ,w[JC{0}~{1}.
1332=eؼ
1333={n󪺷s.\n\nAQXRazoräUs{?
1334=s[
1335=Os
1336=ĵi:eؼФ\ANؼЫVa.LastTargetON|ͮ.
1337=sPBȤ
1338=UQ.
1339=}lRazor"PacketVideo"s
1340="PacketVideo"s/
1341=}lsɵoͿ~.\nN~wgQO.
1342=Ӥ󤣾AΩ󦹪{.T{Aww˳̷sRazor.
1343=Ӽvwla.\niण,ΤwgQק.\nӤLk.
1344=ŪɵoͿ~.ӤiwlaΤ.
1345=JOW:
1346=ؿLkQR.TOӥؿ.
1347=LkЫإؿ.TOAJOTMAs.
1348=Lkʥ.TOAJOOĪ.
1349=n
// 1350 to 1359 reserved (max length 15!)
1350=w
1351=
1352=C?
1353=QF
1354=QzF?
1355=QAF
1356=QFF?
1357=өBF!
1358=AJF
1359=!
1360=V@Ӫaå[JnͦC.
1361=V@ӪañqnͦC.
1362=nͤwK[.
1363=nͤw.
1364=Scy
1365=J"For Loop"
1366=J"End For"
1367=JƦ:
1368=MŲMDҪws
1369=LastSpell(̫]kGy)
1370=LastSkill(̫ޯ)
1371=LastObject(̫ؼ)
1372=AllNames(ܩҦH/ͪW)
1373=UseOnce
1374=VHĹH
1375=VHäH
1376=VHLoH
1377=VHoǤH
1378=VHo
1379=ĵi:W!⤤~JI].
1380=AsҰRazorMȤݨӽTOͮ.
1381=AnXC,M᭫snJ~TOͮ.
1382=ШDC{0}...{1}Ѿl.
1383=ɵШDi椤...
1384=AOqwgF{0}{1},{bO{2}.
1385=AӱwgF{0}{1},{bO{2}.
1386=AOwgF{0}{1},{bO{2}.
1387=ŧO
1388=vQ(ؼФwr)!
1389=Mũ񶤦C
1390={b
1391=>v/v¡ۤv
1392=NextTarget
1393=]wɵ]
1394=K[UseOnce
1395=LastTarget
1396=sW...
1397=Ae󪫫~.
1398=\
1399=\
1400=PAӪS:
1401=ҦSʳQ\.
1402=ѮLo
1403=ŧOLo
1404=LastTarget
1405=d˴LastTarget
1406=۰ʶ}
1407=Ikɨ˳
1408=۰ʨϥĤ,˳
1409=rɪv
1410=`
1411=UseOnceNz
1412=ɵNz
1413=PNz
1414=ʶRNz
1415=Ĥ
1416=Hؼ
1417=d/A
// up to 1465: reserved
1466=SʤQA\
1467=ӯSʳQeCAT.\nAiHܩAҤ\S,iHb]wҤUi]w.\n\ndݳQTSʦC,ЦbUPAҤU]w.
1468=J
1469=K[n
1470=n
1471=>gAv¡/vۤv
1472=pGAbϥΤwѱKȤ,AӸT"[K"\.ӥ\ȭϥΦbݭnȤݥ[KA(ҦpOSI/EAxA).\npGATwӦp,ФnܸӶ.\n\nATwnȤݸѱK?
1473=U
1474=/æaϵ
1475=Zӻ.
1476=񶤦Cw!еy.
1477=԰/MҦ
1478=ܮ
1479=wCjpL,Эs.
1480=(MDҥ])
1481=(ɵNz] {0})
1482=(UseOnceNz #{0})
1483=(cNz])
1484=(zNz {0} ])
1485=AwAa}LkѪR,нT{a}JO_T.
1486=ζ:ܽ
1487=ζ:ڵܽ
1488=͵ؼ
1489=Ĺؼ
1490=(Razorn)
1491=qBi
1492=lƤ...
1493=b[̷sӤHtmɮ...
1494=b[Ȥ...
1495=ݫȤݱҰʤ...
1496=Oo٧U!
1497=wϥRazor!
1498=2DȤ(۰ʰ)
1499=3DȤ(۰ʰ)
1500=(۰ʰ)
1501=z: {0}%
1502=ЫwӰʧ@Wɮɶ():
1503=w
1504=W
1505=JW
1506=L.
1507=u~
1508={0} A
1509=γQI]īG
1510=V̪
1511=V̪äH
1512=V̪񴶳qH
1513=V̪ĤH
1514=V̪ͤH
1515=V̪DͤH
1516=V̪ĹHΪ
1517=V̪iäHΪ
1518=V̪񴶳qHΪ
1519=V̪ǸoHΪ
1520=V̪o
1521=ĵi:tmɮ'{0}'bQ䥦Razor{i{ҨϥΤ!\npGAɮ׶iFק,i०wgla.ijAbC@Razor{i{ϥοWߪ(ΤP)ӤHtmɮ.


================================================
FILE: etc/Language/Razor_lang.deu
================================================
// Razor English/DEU Language Pack
// Last modified $Date: 2006/01/17 22:02:20 $
::CliLoc=DEU

[controls]
WelcomeForm::Text=Willkommen bei Razor!
WelcomeForm::groupBox3=UO Data Ordner
WelcomeForm::dataBrowse=Suchen...
WelcomeForm::label5=Sprache:
WelcomeForm::groupBox2=Server
WelcomeForm::label3=Server:
WelcomeForm::label4=Port:
WelcomeForm::groupBox1=Client Optionen
WelcomeForm::useEnc=Benutze OSI Verschluesselung
WelcomeForm::makeDef=Zu Standardeinstellungen machen
WelcomeForm::browse=Suchen...
WelcomeForm::label1=Welchen Client laden?:
WelcomeForm::patchEncy=Client Verschluesselung patchen
WelcomeForm::showAtStart=Startanzeige
WelcomeForm::quit=&Beenden
WelcomeForm::okay=&Okay

MainForm::Text=Razor v{0}
MainForm::generalTab=Allgemein
MainForm::label10=Updatepruefung:
MainForm::systray=System Tray
MainForm::taskbar=Taskbar
MainForm::smartCPU=Nutze intelligente CPU-Auslastung
MainForm::label7=Sprache:
MainForm::label11=Anzeigen in:
MainForm::groupBox4=Profile
MainForm::delProfile=Loeschen
MainForm::newProfile=&Neu...
MainForm::showWelcome=Willkommens-Nachricht anzeigen?
MainForm::alwaysTop=Nutze intelligentes "Immer im Vordergrund"
MainForm::groupBox1=Filter
MainForm::opacityLabel=Sichtbarkeit: 100%
MainForm::moreMoreOptTab=Mehr Optionen
MainForm::blockHealPoison=Heilen blockieren wenn Ziel vergiftet
MainForm::potionEquip=Auto-freimachen Haende fuer Traenke
MainForm::label17=Razor Meldungen:
MainForm::QueueActions=Auto-Warteschl. fuer Aktionen 
MainForm::spellUnequip=autom.es Haendefreimachen zum Zaubern
MainForm::autoOpenDoors=Tueren autom. oeffnen
MainForm::alwaysStealth=Immer Unsichtbar Laufen 
MainForm::autoFriend=Partymitglieder sind 'Freunde'
MainForm::chkStealth=Unsichtbare Laufschritte zaehlen
MainForm::rememberPwds=Passwort merken 
MainForm::showtargtext=Zielzustand mit Einzelklick anzeigen
MainForm::preAOSstatbar=altes Vor-AOS-Statusfenster benutzen
MainForm::logPackets=Paketspeicherung aktivieren
MainForm::rangeCheckLT=Entfernung zu 'letztes Ziel' ueberpruefen:
MainForm::actionStatusMsg=Aktions-Warteschl. Meldungen anzeigen
MainForm::label5=Gegenstandsverzoegerung:
MainForm::label9=Standard Client-CPU-Prioritaet:
MainForm::label8=tiles
MainForm::label6=ms
MainForm::label18=x
MainForm::gameSize=Fenstergroesse erzwingen:
MainForm::smartLT=Benutze intelligentes 'letztes Ziel'
MainForm::moreOptTab=Optionen
MainForm::negotiate=Funktionen mit Server aushandeln
MainForm::setLTHilight=Setze
MainForm::lthilight='letztes Ziel' Hervorhebung:
MainForm::filterSnoop=Schnueffler-Text filtern
MainForm::incomingCorpse=Neue Leichennamen anzeigen
MainForm::incomingMob=Sich naehernde Spieler/Monster anzeigen
MainForm::setHarmHue=Setze
MainForm::setNeuHue=Setze
MainForm::lblHarmHue=Boese
MainForm::lblNeuHue=Neutral
MainForm::lblBeneHue=Gut
MainForm::setBeneHue=Setze
MainForm::setSpeechHue=Setze
MainForm::setWarnHue=Setze
MainForm::setMsgHue=Setze
MainForm::setExHue=Setze
MainForm::autoStackRes=Auto-Stapeln von Fisch und Erz vor Spielfigur
MainForm::queueTargets=Warteschl. 'Selbstziel' und 'Letztes Ziel'
MainForm::spamFilter=Systemmeldungsspam filtern
MainForm::label4=tiles
MainForm::openCorpses=oeffne Leichen Umkreis:
MainForm::showNotoHue=Status des Spielers im Fensterbalken
MainForm::lblWarnHue=Warnungsmeldungen
MainForm::lblMsgHue=Razormeldungen
MainForm::lblExHue=Such-Ausnahme
MainForm::blockDis=Absatteln im Kampf blocken
MainForm::chkForceSpellHue=Zauberworte:
MainForm::chkForceSpeechHue=Gesprochener Text
MainForm::label3=Zauber-Format:
MainForm::displayTab=Anzeige/Zaehler
MainForm::warnCount=Warnen wenn Zaehler unter Wert faellt:
MainForm::excludePouches=Beutel nie autom. durchsuchen
MainForm::highlightSpellReags=Reagenzien beim Zaubern zeigen
MainForm::titlebarImages=Zaehler mit Bildchen anzeigen
MainForm::checkNewConts=Neue Behaelter autom. durchsuchen
MainForm::groupBox3=Fensterbalkenanzeige
MainForm::showInBar=Dies im UO-Fensterbalken anzeigen:
MainForm::groupBox2=Zaehler
MainForm::delCounter=Loeschen/Bearbeiten
MainForm::addCounter=Hinzufuegen...
MainForm::recount=Neu zaehlen
MainForm::dressTab=Bewaffnen/Ankleiden
MainForm::groupBox6=Bewaffnen/Ankleiden mit diesen Gegenstaenden
MainForm::clearDress=Liste leeren
MainForm::dressDelSel=Entfernen
MainForm::undressBag=Kleiderbeutel aendern
MainForm::undressList=Entkleiden
MainForm::dressUseCur=Derzeitigen Behaelter hinzufuegen
MainForm::targItem=Hinzufuegen (Ziel)
MainForm::dressNow=Ankleiden
MainForm::groupBox5=Bewaffnen/Ankleiden Auswahl
MainForm::removeDress=Entfernen
MainForm::addDress=Hinzufuegen...
MainForm::undressConflicts=autom. kollidierende Gegenstaende entfernen
MainForm::skillsTab=Faehigkeiten
MainForm::dispDelta=Faehigkeits- und Statistikaenderungen anzeigen
MainForm::skillCopyAll=Alle kopieren
MainForm::skillCopySel=Ausgewaehlte kopieren
MainForm::label1=Basis Gesamt:
MainForm::setlocks=Alle Schloesser setzen:
MainForm::resetDelta=Zuruecksetzen  +/-
MainForm::agentsTab=Agenten
MainForm::hotkeysTab=Funktionstasten
MainForm::dohotkey=Auswahl ausfuehren
MainForm::groupBox8=Funktionstaste
MainForm::chkPass=An UO uebertragen
MainForm::label2=Taste:
MainForm::unsetHK=Loeschen
MainForm::setHK=Setze
MainForm::chkCtrl=Strg
MainForm::chkAlt=Alt
MainForm::chkShift=Shift
MainForm::macrosTab=Makros
MainForm::macroActGroup=Aktionen
MainForm::loopMacro=Wiederholung
MainForm::recMacro=Aufnehmen
MainForm::playMacro=Wiedergeben
MainForm::delMacro=Entfernen
MainForm::newMacro=Neu...
MainForm::screenshotTab=Bildschirmfotos
MainForm::label12=Bildformat:
MainForm::capNow=Jetzt ein Bildschirmfoto machen
MainForm::radioUO=Nur das UO Fenster
MainForm::radioFull=Gesamter Bildschirm
MainForm::screenAutoCap=autom.es Bildschirmfoto bei Tod
MainForm::setScnPath=...
MainForm::dispTime=Zeit-/Datumsstempel aktivieren
MainForm::videoTab=Videoaufnahme
MainForm::recFolder=...
MainForm::label13=Aufnahme-Ordner:
MainForm::groupBox7=PacketVideo Aufnahme
MainForm::vidRec=PacketVideo Aufnehmen
MainForm::groupBox10=AVI Video Aufnahme
MainForm::flipVidVert=Vetikal
MainForm::flipVidHoriz=Horizontal
MainForm::recAVI=Record AVI Video...
MainForm::label16=Aufloesung:
MainForm::label15=Bilder pro Sekunde:
MainForm::label19=Drehen:
MainForm::groupBox9=PacketVideo Wiedergabe
MainForm::label14=Geschicklichkeit:
MainForm::vidClose=Schliessen
MainForm::vidPlayStop=Stop
MainForm::vidPlay=Wiedergabe
MainForm::vidOpen=oeffnen...
MainForm::statusTab=Hilfe && Status
MainForm::forumsLink=Razor Diskussionsforum
MainForm::homeLink=Razor Website
MainForm::userGuideLink=Razor Gebrauchsanweisung (engl.)

HueEntry::Text=Einfaerbung auswaehlen
HueEntry::cancel=Abbrechen
HueEntry::okay=&Okay
HueEntry::preview=Vorschau
HueEntry::inGame=im Spiel auswaehlen
HueEntry::label1=Farbe Nummer:

AddCounter::Text=Zaehler hinzufuegen
AddCounter::delete=Loeschen
AddCounter::target=Ziel 
AddCounter::cancel=Abbrechen
AddCounter::Add=&Okay
AddCounter::label4=Farbe (Egal: -1):
AddCounter::label3=Gegenstands ID:
AddCounter::label2=Format:
AddCounter::label1=Name:

MacroInsertWait::Text=Warten/Pause einfuegen...
MacroInsertWait::radioMenu=Warte auf altes Menue/Dialog
MacroInsertWait::cancel=&Abbrechen
MacroInsertWait::radioStat=Warte auf 
MacroInsertWait::radioTarg=Warte auf Ziel
MacroInsertWait::radioGump=Warte auf Fenster
MacroInsertWait::label1=Millisekunden
MacroInsertWait::radioPause=Pausieren fuer:
MacroInsertWait::insert=&Einfuegen

MacroInsertIf::Text=Einfuegen 'Wenn'...
MacroInsertIf::label1=Wenn:
MacroInsertIf::cancel=&Abbrechen
MacroInsertIf::insert=&Einfuegen

[strings]
1001=Tod Graufaerbung
1002=Bardenmusik
1003=Hundegeraeusche
1004=Katzengeraeusche
1005=Pferdegeraeusche
1006=Schafgeraeusche
1007=Geistersprachegeraeusche
1008=Zauberfehlschlaggeraeusche
1009=Wetter
1010=Zaehler anzeigen
1011=Zaehler neu zaehlen
1012=AOS Faehigkeiten abschalten
1013=Erste Faehigkeit setzen (AOS)
1014=Zweite Faehigkeit setzen (AOS)
1015=Betaeubungsschlag an/aus (Pre-AOS)
1016=Entwaffnen an/aus (Pre-AOS)
1017=Faehigkeit gesetzt auf {0}
1018=AOS Faehigkeiten deaktiviert.
1019=Alles Entkleiden
1020=Beide Haende leeren
1021=Linke Hand leeren
1022=Rechte hand leeren
1023=Hut entkleiden
1024=Schmuck entkleiden
1025=Selbstbandagieren
1026=Bandage an 'letztes Ziel' benutzen
1027=Benutze Bandage (keine Zeitbegrenzung)
1028=Heiltrank trinken
1029=Entgiftungstrank trinken
1030=Erfrischungstrank trinken
1031=Nachtsichttrank trinken
1032=Explosionstrank benutzen
1033=Staerketrank trinken
1034=Geschicklichkeitstrank trinken
1035=Keine Bandagen gefunden!
1036=Keinen Gegenstand des Typs {0} gefunden!
1037=Doppelklick ({0})
1038=Ziel neu bestimmen
1039=Zu Doppelklick-Typ konvertieren
1040=Neues Ziel fuer diese Aktion auswaehlen.
1041=WARNUNG: Ausnahmefehler beim Laden dieser Einstellung:\n{0}
1042=Makro-Warnung: Der Gegenstand ist ausser Reichweite!
1043=Aufheben {1} - {0}
1044=Konvertiere zu Aufheben nach Typ
1045=Makro-Warnung: Du hast nichts in den Haenden!
1046=Wohin ankleiden/bewaffnen {0} (L:{1})
1047=Wohin ablegen {0} (@{1})
1048=Konvertiere zu relativer Position
1049=Ablegen (relativ) @({0},{1},{2})
1050=Dialogantwort (Knopf {0})
1051=Dialog schliessen
1052=Menueantwort {0}
1053=Warnung: Das Makro hat nach einem Ziel verlangt, aber der Server hat keins uebertragen! (Brauchst Du ein 'AufZielWarten'?)
1054=Konkretes Ziel
1055=Zu 'letztes Ziel' konvertieren
1056=Zu 'Ziel nach Typ' konvertieren
1057=Relative Position anvisieren ({0},{1})
1058=Letztes Ziel
1059=Selbstziel
1060=Setze Letztes Ziel
1061=Ziel auf zufaelligen roten Spieler
1062=Ziel auf zufaelligen grauen Spieler
1063=Ziel auf zufaelligen blauen Spieler
1064=Ziel auf zufaelligen Feind
1065=Ziel auf zufaelligen Freund
1066=Ziel auf zufaelligen Aggressor
1067=Sprich "{0}"
1068=BenutzeFaehigkeit {0}
1069=BenutzeZauber {0}
1070=SetzeFaehigkeit {0}
1071=Ankleiden: {0}
1072=Entkleiden: {0}
1073=Ebene abruesten {0}
1074=Auf Menue warten (Egal)
1075=Auf Menue warten (#{0})
1076=Bearbeiten...
1077=Auf Dialogabfrage warten (Egal)
1078=Auf Dialogabfrage warten (#{0})
1079=Warte auf Ziel
1080=Pause {0:#.00}sek
1081=Warte auf {0} {1} {2}
1082=Laedt '{0}'...
1083=> Laufendes Makro anhalten
1084=Wiedergabe: {0}
1085=Makro laeuft '{0}'...
1086=Makro '{0}' beendet.
1087=Razor konnte das nicht durchfuehren.  Fehlermeldung:\n
1088=Beschreibung: Could not find the client Window Handle.\nPossible Cause: The Client may not have initialized properly.
1089=Beschreibung: Could not find the Client's ThreadID\nPossible Cause: The Client may not have initialized Properly.
1090=Beschreibung: Could not create Windows Hooks.\nPossible Cause: Internal error.
1091=Beschreibung: Could not create or access Razor shared memory.\nPossible Cause: Windows Error or invalid permissions.
1092=Beschreibung: Crypt.dll has disabled itself.\nPossible Cause: Version mismatch.
1093=Beschreibung: Could not patch the client's Winsock functions.\nPossible Cause: Internal error, Windows Error, or Incompatible Version.
1094=Beschreibung: An invalid parameter was passed to the loade.\nPossible Cause: Mismatched DLL versions.
1095=Warnung: Could not copy packet lengths and/or encryption information from the client.\nRazor may be able to run without this information, though some features may not function correctly.  Would you like to start Razor anyway?\n\nPossible Cause: Your client version may not be compatible with this version of Razor.
1096=Deine Faehigkeit in {0} hat sich um {4}{5:F1} geaendert, sie ist jetzt bei {3:F1} ({1}{2:F1}).
1097=Nicht erlaubte Abkuerzung.
1098=Nicht erlaubte Gegenstands ID.
1099=Nicht erlaubte Farbe.
1100=Waehle einen Gegenstand aus, der gezaehlt werden soll.
1101=Fehler beim Laden von '{0}'!\nDieses Benutzerprofil ist fehlerhaft und nicht mehr benutzbar.
1102=Die Eigenschaft {0} wurde in diesem Profil nicht gefunden.
1103=Deine counters.xml Datei ist fehlerhaft und unbenutzbar.
1104=Da Du 'autom.es Durchsuchen' deaktiviert hast, musst Du jetzt alle Behaelter oeffnen, damit sie katalogisiert werden koennen.
1105=ACHTUNG: Die Anzahl von {0} ist jetzt bei {1}!
1106=Waehle die Farbe aus, die Du dafuer benutzen moechtest.
1107=Jetzt Bildschirmfoto machen
1108=Moegliche Werte:\n{char} - Figurname\n{shard} - Servername\n{str}/{hp}/{hpmax} - Gesundheitsstatus\n{dex}/{stam}/{stammax} - Geschicklichkeitsstatus\n{int}/{mana}/{manamax} - Intelligenzstatus\n{weight}/{maxweight} - Gewicht\n{gold} - Goldvermoegen der Spielfigur\n{AR} - Ruestungsklasse / Koerperliche Resistenz\n{tithe} - Zehntelpunkte\n{followers}/{followersmax} - Gefolgsleute\n{bandage} - Bandagencountdown\n{statbar}/{mediumstatbar}/{largestatbar} - Statusanzeige\n{crimtime} - Wie lange du schon 'kriminell' bist\n{stealthsteps} - Zaehler fuer Unsichtbare Schritte\n{physresist} - Koerperliche Resistenz\n{coldresist} - Kaelteresistenz\n{fireresist} - Feuerresistenz\n{energyresist} - Energieresistenz\n{poisonresist} - Giftresistenz\n{luck} - Glueck\n{damage} - Schaden Min./Max.\nFarbe - HTML hex color code: '~#rrggbb' ('~#~' zum beenden des codes)\nOder ein {Format} aus der Liste der Zaehler
1109=Razor Version: {0}\nArbeitsspeichernutzung: {1}\nSenden: {2} ({3}/s)\nEmpfangen: {4} ({5}/s)\nVerbunden seit {6}\n\nSpielfigurnummer: 0x{7:X8}\nGepaecknummer: 0x{8:X8}\n\nGegenstaendeueberwachung: {9}\nMonsterueberwachung: {10}\n
1110=Setze Schloss: RAUF
1111=Setze Schloss: RUNTER
1112=Setze Schloss: GESCHLOSSEN
1113=Bist Du sicher, dass Du den Zaehler "{0}" entfernen willst?\nDies hat Auswirkung auf alle Profile.
1114=Lade jetzt das Profil "{0}"?
1115=Beim Laden des Profils ist ein Fehler aufgetreten.
1116=Das Standardprofil kann nicht geloescht werden.
1117=Gib einen neuen Namen fuer das Profil ein: 
1118=Kann kein neues Profil erstellen!\n Grund: Dieser Profilname existiert bereits.\n\nMoechtest Du dieses Profil jetzt laden?
1119=Gib einen Namen fuer die neue Bekleidungsliste ein:
1120=Diese Bekleidungsliste loeschen?
1121={0:X} (Gegenstand ausser Reichweite)
1122=Diesen Gegenstand aus der Bekleidungsliste entfernen?
1123=Klicke auf einen Behaelter, in den die Bekleidungsliste '{0}' entkleidet werden soll.
1124=Entkleidungsbehaelter gesetzt.
1125=Gegenstand nicht gefunden oder nicht erlaubter Gegenstand ausgewaehlt.
1126=Diese Tastenkombination ist bereits dafuer in Benutzung: '{0}'.\nIn '{1}' aendern?
1127=Daten erfolgreich gespeichert.
1128=WARNUNG!\nPaketspeicherung kann die Geschicklichkeit von Razor reduzieren. Log Dateien koennen auch sehr schnell sehr gross werden\n, und Razor loescht diese nicht selbstaendig.\n\nRazor's Paketspeicherung kann sensible Daten wie z.B. Passwoerter enthalten\, und sollte daher nicht an unvertrauenswuerdige Personen gegeben werden.\n\nBist Du sicher, dass Du Paketspeicherung aktivieren willst?\n(Dies wird nicht in Deinem Benutzerprofil gespeichert)
1129=Konvertiere zu Auswahl nach TYP
1130=Gib einen neuen Namen fuer das Makro ein: 
1131=Dieser Name enthaelt nicht erlaubte Zeichen.
1132=Ein Makro mit diesem Namen existiert bereits.
1133=Das Makro wird beim Aufnehmen ueberschrieben.\nBist Du sicher, dass Du dieses Makro ueberschreiben willst?
1134=Bist Du sicher, dass du '{0}' PERMANENT loeschen willst?\n(Dies kann nicht rueckgaengig gemacht werden)
1135=Pause/Warten einfuegen...
1136=Setze 'letztes Ziel' einfuegen
1137=Nach oben verschieben
1138=Nach unten verschieben
1139=Aktion entfernen
1140=Aufnahme hier starten
1141=Die Datei '{0}' wurde nicht gefunden.
1142=Bist Du sicher?
1143=Warnung: {0} Datei{1} konnte nicht geloescht werden:\n{2}
1144=Diese aenderung wird erst nach einem Neustart von Razor wirksam.
1145=Die Aktivierung dieser Option veranlasst Razor zur Speicherung Deines Passworts als Teil des Profils.\nObwohl Passwoerter verschluesselt sind, kann jemand es entschluesseln, falls er/sie Zugriff zu den XML-Dateien Deines Profils erlangt.\nBist Du sicher, dass Du diese Option einschalten moechtest?
1146=Du musst einen gueltigen Port eingeben.
1147=Aktionsbefehl ignoriert (zur Warteschl. hinzugefuegt).
1148=Aktion in Warteschl. {0}... {1} uebrig.
1149={0} Aktionen aus der Warteschl. in {1:F1} Sekunden abgearbeitet.
1150=Einmal-Benutzen Agent
1151=Hinzufuegen (Ziel)...
1152=Hinzufuegen Behaelter (Ziel)...
1153=Entfernen (Ziel)...
1154=Liste leeren
1155=Klicke auf einen Gegenstand, der hinzugefuegt werden soll.
1156=Klicke auf einen Behaelter.
1157=Klicke auf einen Gegenstand, der entfernt werden soll.
1158=Gegenstand hinzugefuegt.
1159=Gegenstand entfernt.
1160={0} Gegenstaend(e) wurden zum Einmal-Benutzen Agent hinzugefuegt.
1161=Die Einmal-Benutzen Warteschl. ist leer!
1162=Benutze '{0}'.  ({1} Gegenstaend(e) aus der Einmal-Benutzen Warteschl.)
1163=Es gab ein Problem mit einem Gegenstand in der Einmal-Benutzen Warteschl., versuche den Naechsten.
1164=VerkaufenAgent: autom.es Verkaufen von {0} Gegenstaend(en) fuer {1}gold.
1165=Entfernen
1166=Behaelter erfolgreich gesetzt.
1167=Leeren
1168=(Ausschalten)
1169=(Einschalten)
1170=Setze 'Ziel Beutel'
1171=Entferne 'Ziel Beutel'
1172=OrganisierAgent
1173=Organisierer
1174=Organisiere Jetzt
1175=Behaelter nicht gesetzt.
1176=Razor konnte Dein Gepaeck nicht finden.
1177=OrganisierAgent hat {0} zu bewegende Gegenstaend(e) in die Warteschl. gesetzt. (Dies kann einen Moment dauern)
1178=OrganisierAgent hat keine zu bewegenden Gegenstaend(e) gefunden.
1179=Dieser Gegenstand ist bereits in der Liste.
1180=AutoSucheAusnahmen
1181=KaufAgent hat {0} Gegenstaend(e) fuer {1} gold gekauft.
1182=Der KaufAgent hat einige Gegenstaende wegen Goldmangels nicht kaufen koennen.
1183=Gib die Anzahl ein:
1184=Client CPU-Auslastungsprioritaet auf {0} gesetzt.
1185=Die Uhrzeit ist: {0}
1186=Du bist bei den Koordinaten {0} in '{1}'
1187=Entkleidungsbeutel wurde nicht gefunden. Stattdessen wurde Dein Gepaeck verwendet um die Sachen zu verstauen.
1188={0} Gegenstaend(e) zur Entkleidung in Warteschl. aufgenommen.
1189={0} Gegenstaend(e) zur Bekleidung in Warteschl. aufgenommen.
1190={0} Gegenstaend(e) sind bereits ausgeruestet.
1191={0} Gegendstaend(e) wurden nicht gefunden. (Ausser Reichweite)
1192=Warnung: Spells.def nicht gefunden, Zauberformat-Text wird nicht angezeigt!
1193=Unsichtbare Schritte: {0}
1194=Zaehle unsichtbare Schritte.
1195=Ziel-Warteschl. leeren
1196=Letzten Gegner anvisieren
1197=Ziel-Wareschlange geleert.
1198=Visiere neues 'letztes Ziel' an
1199='Letztes Ziel' gesetzt.
1200=Neues Ziel gesetzt.
1201=Es wurde niemand dieser Art auf Deinem Bildschirm gefunden.
1202=Selbstziel in Warteschl. aufgenommen.
1203='Letztes Ziel' in Warteschl. aufgenommen.
1204=Server hat neues Ziel gesendet, Razor Ziel abgebrochen.
1205=Ziel nach TYP {0}
1206=Sammler
1207=Bist Du sicher, dass Du dies loeschen willst?
1208=Waehle einen Ordner zum Speichern der Bildschirmfotos.
1209=Funktionstasten

1210=Gegenstaende
1211=Ziele
1212=Agenten
1213=Kleidung
1214=Makros
1215=Zaubersprueche
1216=Faehigkeiten
1217=Verschiedenes
1251=Erste(s)
1252=Zweite(s)
1253=Dritte(s)
1254=Vierte(s)
1255=Fuenfte(s)
1256=Sechste(s)
1257=Siebente(s)
1258=Achte(s)
1260=Necromancy
1270=Chivalry
1271=Traenke
1272=Spezial Faehigkeiten
1290=Bushido
1300=Ninjitsu
1301=Verkaufen
1302=Kaufen
1303=Eingabe erforderlich
1304=Razor Befehlsliste
1305=Benutze Gegenstand in der Hand
1306=Du musst etwas ablegen bevor Du es ausruesten kannst.
1307=Ausruesten/Ablegen Rechte Hand
1308=Ausruesten/Ablegen Linke Hand
1309=Lass gehaltenen Gegenstand fallen
1310=Spellweaving
1311=> Razor Funktionstasten an/aus
1312=Funktionstasten an (Druecke {0} zum Ausschalten)
1313=Funktionstasten aus (Druecke {0} zum Anschalten)
1314=Funktionstasten aktiviert
1315=Funktionstasten deaktiviert
1316=Laufen: {0}
1317=Typ hinzufuegen (Ziel)...
1318=Das angeforderte Ziel ist ausser Reichweite. Aktion abgebrochen!
1319=Max Verkaufen: {0}
1320=Schnueffler Meldungen
1321=Gepaeckgeraeusche
1322=Einfuegen "Wenn" Abfrage
1323=Einfuegen "Oder"
1324=Einfuegen "Ende wenn"
1325=Setze Anzahl
1326=Auffuellen
1327=Jetzt auffuellen
1328=AuffuellAgent
1329=Klicke auf einen Behaelter von dem aus aufgefuellt werden soll,\n oder klicke auf Dich selbst um Deine Bank-Kiste zu benutzen.
1330=Dieser Behaelter ist unzulaessig.
1331=Auffuellen fertig, {0} Gegenstaende{1} in Warteschl.
1332=Derzeitiges Ziel aufheben
1333=Eine neuere Version von Razor ist auf der Website verfuegbar.\n\nMoechtest Du jetzt die Website besuchen um die neue Version herunterzuladen?
1334=Neu laden
1335=Speichern
1336=Warnung: Das derzeitige Ziel erlaubt keine Zielerfassung des Bodens.  Letztes Ziel nicht ausgefuehrt.
1337=Client synchronisieren
1338=Absatteln blockiert.
1339=Razor "PacketVideo" Aufnahme starten
1340=Razor "PacketVideo" Aufnahme/Wiedergabe anhalten
1341=Es gab bei der Aufnamhe einen Fehler.\nDer Ausnahmefehler wurde im Log notiert.
1342=Diese Datei ist nicht mit dieser Version von Razor kompatibel.  Lade die neueste Version von Razor herunter.
1343=Diese Video-Datei ist beschaedigt.\nSie ist entweder unvollstaendig oder wurde bearbeitet.\nDie Datei kann nicht wiedergegeben werden.
1344=Es gab ein Problem beim Lesen der Datei. Sie ist entweder beschaedigt oder unvollstaendig.
1345=Gib einen Kategorie-Namen ein:
1346=Der Ordner konnte nicht geloescht werden.  Stelle sicher, dass er leer ist.
1347=Der Ordner konnte nicht erstellt werden.  Stelle sicher, dass der verwendete Name zulaessig ist und versuch es noch einmal.
1348=Konnte Makro-Datei nicht verschieben.  Stelle sicher, dass die eingegebene Kategorie zulaessig ist.
1349=Freunde
// 1350 to 1359 reserved (max length 15!)
1350=Beendet
1351=Ende
1352=Game Over?
1353=ker-pwned
1354=Got corp por?
1355=bamboozled
1356=pwned?
1357=Jesus <3s you
1358=Kal Vas Pwned
1359=SMACKDOWN
1360=Klicke auf einen Spieler um ihn zur Freundesliste hinzuzufuegen.
1361=Klicke auf einen Spieler um ihn aus der Freundesliste zu entfernen.
1362=Freund hinzugefuegt.
1363=Freund entfernt.
1364=Spezielle Konstrukte
1365=Einfuegen "FOR Wiederholungsschleife"
1366=Einfuegen "FOR Ende"
1367=Gib die Anzahl der Wiederholungen ein:
1368=Sammlerpuffer leeren
1369=Letzter Zauber
1370=Letzte Faehigkeit
1371=Letzter Gegenstand
1372=Alle Namen
1373=Einmal-Benutzen
1374=Visiere zufaelligen feindlichen Mensch an
1375=Visiere zufaelligen grauen Mensch an
1376=Visiere zufaelligen unschuldigen Mensch an
1377=Visiere zufaelligen kriminellen Mensch an
1378=Visiere zufaelligen Kriminellen an
1379=WARNUNG: Ziehen/Fallenlassen Zeitueberschreitung! Gehaltener Gegenstand wurde im Gepaeck abgelegt.
1380=Du musst Razor und den Client neu starten um diese aenderung wirksam werden zu lassen.
1381=Du musst ausloggen und Dich neu einloggen um diese Einstellung zu aktivieren.
1382=Ziehen/Fallenlassen Anforderung in Warteschleife aufgenommen {0}... {1} uebrig.
1383=Auffuellen-Anforderung in Bearbeitung....
1384=Deine Staerke hat sich um {0}{1} geaendert, sie ist jetzt bei {2}.
1385=Deine Geschicklichkeit hat sich um {0}{1} geaendert, sie ist jetzt bei {2}.
1386=Deine Intelligenz hat sich um {0}{1} geaendert, sie ist jetzt bei {2}.
1387=Lichtstaerke
1388=Heilung blockiert (das Ziel ist vergiftet)!
1389=Ziehen/Fallenlassen Warteschl. leeren
1390=Jetzt anhalten
1391=>Selbst Heilen/Entgiften
1392=Naechstes Ziel
1393=Setze Auffuellen-Ziel-Behaelter
1394=Zu Einmal-Benutzen hinzufuegen
1395=Letztes Ziel angreifen
1396=Zeitlimit editieren...
1397=Du haeltst nichts in Haenden.
1398=NICHT gestattet
1399=Gestattet
1400=Funktionen mit Server ausgehandelt:
1401=Alle Funktionen erlaubt.
1402=Wetter filter
1403=Lichtstaerke filter
1404=Intelligentes 'Letztes Ziel'
1405=Entfernungsueberwachung 'Letztes Ziel'
1406=oeffne Tueren autom.
1407=Vorm Zaubern Haende freimachen
1408=Auto-Trankbenutzung
1409=Heilung blockieren wenn vergiftet
1410=Wiederhole Makros
1411=Einmal-BenutzenAgent
1412=AuffuellenAgent
1413=VerkaufenAgent
1414=KaufenAgent
1415=Trank Funktionstasten
1416=Zufaellige Ziele
// 1417 to 1465 reserved
1466=Funktion vom Server nicht zugelassen
1467=Diese Funktion ist von diesem Server nicht zugelassen.\nDu kannst in den 'Optionen' die zu ignorierenden Funktionen ueberpruefen.\n\nUm eine Liste der nicht-erlaubten Funktionen zu sehen, ueberpruefe "Hilfe & Status".
1468=Kommentar einfuegen
1469=Freund hinzufuegen
1470=Freund entfernen
1471=>Mini-Selbstheilung/-entgiftung
1472=Du solltest die Patch-Verschluesselung nur deaktivieren, wenn Dein Client diese Funktion bereits deaktiviert hat.Diese Option sollte ausgeschaltet bleiben, selbst auf Server mit Patch-Verschluesselung (z.B. OSI/EA offizielle Server).\nWenn Du Dir nicht sicher bist, schalte diese Option NICHT ab!\n\nBist Du sicher, dass Du Client-seitige Patch-Verschluesselung deaktivieren willst?
1473=Absatteln
1474=Zeige/Verstecke Kartenuebersicht
1475=Das ist zu weit weg.
1476=Ziehen/Fallenlassen Warteschl. voll. Bitte warten.


================================================
FILE: etc/Language/Razor_lang.enu
================================================
// Razor English/ENU Language Pack
// Last modified $Date: 2006/01/17 22:02:20 $
::CliLoc=ENU

[controls]
WelcomeForm::Text=Welcome to Razor!
WelcomeForm::dataBrowse=Browse...
WelcomeForm::label5=Language:
WelcomeForm::groupBox2=Server
WelcomeForm::selectServerLbl=Select Server:
WelcomeForm::serverHostLbl=Server Host/IP:
WelcomeForm::serverNameLbl=Server Name:
WelcomeForm::portLabel=Port:
WelcomeForm::groupBox1=Client Options
WelcomeForm::browse=Browse...
WelcomeForm::label1=Load UO Client:
WelcomeForm::patchEncy=Patch client encryption
WelcomeForm::showAtStart=Show this when Razor starts
WelcomeForm::quit=&Quit
WelcomeForm::okay=&Launch UO

MainForm::Text=Razor v{0}
MainForm::generalTab=General
MainForm::btnMap=UOPS
MainForm::systray=System Tray
MainForm::taskbar=Taskbar
MainForm::smartCPU=Use smart CPU usage reduction
MainForm::label7=Language:
MainForm::label11=Show in:
MainForm::groupBox4=Profiles
MainForm::delProfile=Delete
MainForm::newProfile=&New...
MainForm::showWelcome=Show Welcome Screen
MainForm::alwaysTop=Use Smart Always on Top
MainForm::groupBox1=Filters
MainForm::opacityLabel=Opacity: 100%
MainForm::label9=Default Client Priority:
MainForm::moreOptTab=Options
MainForm::preAOSstatbar=Use Pre-AOS status window
MainForm::negotiate=Negotiate features with server
MainForm::setLTHilight=Set
MainForm::lthilight=Last Target Highlight:
MainForm::filterSnoop=Filter snooping messages
MainForm::incomingCorpse=Show New/Incoming Corpses
MainForm::incomingMob=Show Incoming People/Creatures
MainForm::setHarmHue=Set
MainForm::setNeuHue=Set
MainForm::lblHarmHue=Harmful
MainForm::lblNeuHue=Neutral
MainForm::lblBeneHue=Beneficial
MainForm::setBeneHue=Set
MainForm::setSpeechHue=Set
MainForm::setWarnHue=Set
MainForm::setMsgHue=Set
MainForm::setExHue=Set
MainForm::autoStackRes=Auto-Stack Ore/Fish/Logs at Feet
MainForm::queueTargets=Queue LastTarget and TargetSelf
MainForm::spamFilter=Filter repeating system messages
MainForm::label4=tiles
MainForm::openCorpses=Open new corpses within
MainForm::lblWarnHue=Warning Message Hue
MainForm::lblMsgHue=Razor Message Hue
MainForm::lblExHue=Search Exemption Hue
MainForm::blockDis=Block dismount in war mode
MainForm::chkForceSpellHue=Override Spell Hues:
MainForm::chkForceSpeechHue=Override Speech Hue
MainForm::label3=Spell Format:
MainForm::moreMoreOptTab=More Options
MainForm::label10=Health Format:
MainForm::showHealthOH=Show health above people/creatures
MainForm::blockHealPoison=Block heal if target is poisoned
MainForm::potionEquip=Auto Unequip for potions
MainForm::reequipHandsPotion=Re-equip
MainForm::label17=Razor messages:
MainForm::QueueActions=Auto-Queue Object Delay actions
MainForm::spellUnequip=Auto Unequip hands before casting
MainForm::autoOpenDoors=Auto-open doors
MainForm::alwaysStealth=Always show stealth steps
MainForm::autoFriend=Treat party members as 'Friends'
MainForm::chkStealth=Count stealth steps
MainForm::rememberPwds=Remember passwords
MainForm::showtargtext=Show target flag on single click
MainForm::logPackets=Enable packet logging
MainForm::rangeCheckLT=Range check Last Target:
MainForm::actionStatusMsg=Show Action-Queue status messages
MainForm::label5=Object delay:
MainForm::label8=tiles
MainForm::label6=ms
MainForm::label18=x
MainForm::smartLT=Use Smart Last Target
MainForm::gameSize=Force Game Size:
MainForm::chkPartyOverhead=Show mana/stam above party members
MainForm::displayTab=Display/Counters
MainForm::showNotoHue=Show noto hue on {char} in TitleBar
MainForm::warnCount=Warn when below:
MainForm::excludePouches=Never auto-search pouches
MainForm::highlightSpellReags=Highlight Spell Reagents on Cast
MainForm::titlebarImages=Show Images with Counters
MainForm::checkNewConts=Auto search new containers
MainForm::groupBox3=Title Bar Display
MainForm::showInBar=Show in UO title bar:
MainForm::groupBox2=Counters
MainForm::counters::0=Name (Format)
MainForm::counters::1=Count
MainForm::delCounter=Del/Edit
MainForm::addCounter=Add...
MainForm::recount=Recount
MainForm::dressTab=Arm/Dress
MainForm::groupBox6=Arm/Dress Items
MainForm::clearDress=Clear List
MainForm::dressDelSel=Remove
MainForm::undressBag=Change Undress Bag
MainForm::undressList=Undress
MainForm::dressUseCur=Add Current
MainForm::targItem=Add (Target)
MainForm::dressNow=Dress
MainForm::groupBox5=Arm/Dress Selection
MainForm::removeDress=Remove
MainForm::addDress=Add...
MainForm::undressConflicts=Auto-move conflicts
MainForm::skillsTab=Skills
MainForm::dispDelta=Show skill/stat changes
MainForm::skillCopyAll=Copy All
MainForm::skillCopySel=Copy Selected
MainForm::label1=Base Total:
MainForm::setlocks=Set all locks:
MainForm::resetDelta=Reset  +/-
MainForm::skillList::0=Skill Name
MainForm::skillList::1=Value
MainForm::skillList::2=Base
MainForm::skillList::3=+/-
MainForm::skillList::4=Cap
MainForm::skillList::5=Lock
MainForm::agentsTab=Agents
MainForm::hotkeysTab=Hot Keys
MainForm::dohotkey=Execute Selected
MainForm::groupBox8=Hot Key
MainForm::chkPass=Pass to UO
MainForm::label2=Key:
MainForm::unsetHK=Unset
MainForm::setHK=Set
MainForm::chkCtrl=Ctrl
MainForm::chkAlt=Alt
MainForm::chkShift=Shift
MainForm::macrosTab=Macros
MainForm::macroActGroup=Actions
MainForm::loopMacro=Loop
MainForm::recMacro=Record
MainForm::playMacro=Play
MainForm::delMacro=Remove
MainForm::newMacro=New...
MainForm::screenshotTab=Screen Shots
MainForm::label12=Image Format:
MainForm::capNow=Take Screen Shot Now
MainForm::radioUO=UO Only
MainForm::radioFull=Full Screen
MainForm::screenAutoCap=Auto Death Screen Capture
MainForm::setScnPath=...
MainForm::dispTime=Include Timestamp on images
MainForm::statusTab=Help && Status
MainForm::mleLink=Free Desktop Wallpapers
MainForm::forumsLink=Razor Discussion Forum
MainForm::homeLink=Razor Homepage
MainForm::userGuideLink=Razor User Guide
MainForm::dataDir=Open Data Directory
MainForm::showTargetMessagesOverChar=Show Target Self/Last/Clear Overhead
MainForm::showOverheadMessages=Enabled
MainForm::goldPerDisplay=Enable Gold Per Sec/Min/Hour Counters
MainForm::stealthOverhead=Overhead
MainForm::trackIncomingGold=Enable gold per sec/min/hour tracker
MainForm::objectDelay=Object Delay:
MainForm::showBuffDebuffOverhead=Show Buff/Debuff Overhead
MainForm::lblBuffDebuff=Format:
MainForm::blockOpenCorpsesTwice=Block opening corpses twice
MainForm::trackDps=Enable damage tracker
MainForm::filterSystemMessages=Filter repeating system messages
MainForm::filterRazorMessages=Filter repeating Razor messages
MainForm::filterOverheadMessages=Filter repeating overhead messages
MainForm::overrideSpellFormat=Override spell format
MainForm::buyAgentIgnoreGold=Buy Agents ignore player gold

HueEntry::Text=Select a Hue
HueEntry::cancel=Cancel
HueEntry::okay=&OK
HueEntry::preview=Preview
HueEntry::inGame=Select in Game
HueEntry::label1=Hue Number:

AddCounter::Text=Add a Counter
AddCounter::delete=Delete
AddCounter::target=Target
AddCounter::cancel=Cancel
AddCounter::Add=&OK
AddCounter::label4=Color (Any: -1):
AddCounter::label3=Item ID:
AddCounter::label2=Format:
AddCounter::label1=Name:

MacroInsertWait::Text=Insert Wait/Pause...
MacroInsertWait::radioMenu=Wait for old-style Menu/Dialog
MacroInsertWait::cancel=&Cancel
MacroInsertWait::radioStat=Wait for
MacroInsertWait::radioTarg=Wait for Target
MacroInsertWait::radioGump=Wait for Gump
MacroInsertWait::label1=milliseconds
MacroInsertWait::radioPause=Pause for:
MacroInsertWait::insert=&Insert

MacroInsertIf::Text=Insert If...
MacroInsertIf::label1=If:
MacroInsertIf::cancel=&Cancel
MacroInsertIf::insert=&Insert

InputBox::cancel=Cancel
InputBox::ok=&OK

[strings]
1001=Death Status
1002=Bards' Music
1003=Dog Sounds
1004=Cat Sounds
1005=Horse Sounds
1006=Sheep Sounds
1007=Spirit Speak Sound
1008=Spell Fizzle Sound
1009=Weather
1010=Display Counters
1011=Recount Counters
1012=Clear AOS Ability
1013=Set Primary Ability (AOS)
1014=Set Secondary Ability (AOS)
1015=Toggle Stun (Pre-AOS)
1016=Toggle Disarm (Pre-AOS)
1017=Setting ability {0}
1018=AOS Abilities cleared.
1019=Undress All
1020=Undress Both Hands
1021=Undress Left Hand
1022=Undress Right Hand
1023=Undress Hat
1024=Undress Jewelry
1025=Bandage Self
1026=Bandage LastTarget
1027=Use Bandage (No Timer)
1028=Drink Heal
1029=Drink Cure
1030=Drink Refresh
1031=Drink Night Sight
1032=Drink Explosion
1033=Drink Strength
1034=Drink Agility
1035=No bandages found
1036=No item of type {0} found!
1037=Double Click ({0})
1038=Re-Target
1039=Convert to DClick by Type
1040=Select a new target this Action.
1041=WARNING: Exception while loading profile property:\n{0}
1042=Macro Warning: Cannot find that item (Out of Range).
1043=Lift {1} - {0}
1044=Convert to Lift by Type
1045=Macro Warning: Not holding anything.
1046=Equip to {0} (L:{1})
1047=Drop to {0} (@{1})
1048=Convert to Relative Location
1049=Drop (Relative) @({0},{1},{2})
1050=GumpResponse (Button {0})
1051=Close Gump
1052=MenuResponse {0}
1053=Warning: Macro requested target, but no target sent from server! (Do you need a 'WaitForTarget'?)
1054=Absolute Target
1055=Convert to LastTarget
1056=Convert to Target by Type
1057=Target RelLoc ({0},{1})
1058=Last Target
1059=Target Self
1060=Set Last Target
1061=Target Random Murderer
1062=Target Random Grey
1063=Target Random Innocent
1064=Target Random Enemy
1065=Target Random Friendly
1066=Target Random Non-Friendly
1067=Say "{0}"
1068=UseSkill {0}
1069=CastSpell {0}
1070=SetAbility {0}
1071=Dress: {0}
1072=Undress: {0}
1073=Unequip Layer {0}
1074=Wait for Menu (Any)
1075=Wait for Menu (#{0})
1076=Edit...
1077=Wait For Gump (Any)
1078=Wait for Gump (#{0})
1079=Wait for Target
1080=Pause {0:#.00}sec
1081=Wait for {0} {1} {2}
1082=Loading '{0}'...
1083=> Stop Current Macro
1084=Play: {0}
1085=Playing Macro '{0}'...
1086=Macro '{0}' finished.
1087=Razor was unable to initialize. Error code:
1088=Description: Could not find the client Window Handle.\nCause: The client did not creeate its main window. Check to make sure your client started up properly.
1089=Description: Could not find the Client's ThreadID\nThis error means that Razor was unable to hook the client after it started. This is usually caused by errors in the client which cause it to crash to terminate before it has finished starting up. Check to make sure your client is starting up properly.
1090=Description: Could not create Windows Hooks.\nCause: Internal windows error.
1091=Description: Could not create or access Razor shared memory.\nCause: Windows Error or invalid permissions.
1092=Description: Crypt.dll has disabled itself.\nCause: Version mismatch. Reinstall Razor and use the original Crypt.dll that comes with the installation. Your Crypt.dll is corrupted.
1093=Description: Could not patch the client's Winsock functions.\nCause: Internal error, Windows Error, or Incompatible Version. Reinstall Razor.
1094=Description: Could not copy packet lengths and/or encryption information from the client.\nCause: Your client version may not be compatible with this version of Razor. You must update your client to at least version 4.0.0.
1095=Description: An invalid parameter was passed to the loader.\nCause: Mismatched DLL versions. Reinstall Razor.
1096=Your skill in {0} has changed by {4}{5:F1}, it is now {3:F1} ({1}{2:F1}).
1097=Invalid abbreviation.
1098=Invalid item ID.
1099=Invalid hue.
1100=Select an item to count.
1101=Error loading '{0}'!\nThis profile is corrupt and cannot be used.
1102=The property {0} was not found in this profile.
1103=Your counters.xml file is corrupt and cannot be used.
1104=Because you have Auto Search Containers off, you must now reopen all of your bags so that your counters can be updated.
1105=Warning: {0} amount is now {1}!
1106=Select the hue you wish to use.
1107=Take ScreenShot Now
1108=Possible values:\n{char} - Character name\n{shard} - Shard name\n{str}/{hp}/{hpmax} - Health status\n{dex}/{stam}/{stammax} - Dex status\n{int}/{mana}/{manamax} - Int status\n{weight}/{maxweight} - Weight information\n{gold} - Total Gold on character\n{AR} - Armor Rating / Physical Resistance\n{tithe} - Tithing points\n{followers}/{followersmax} - Followers slots\n{bandage} - Bandage Timer\n{statbar}/{mediumstatbar}/{largestatbar} - Status bar\n{crimtime} - How long you have been a criminal\n{stealthsteps} - Stealth steps counter\n{physresist} - Physical Resistance\n{coldresist} - Cold Resistance\n{fireresist} - Fire Resistance\n{energyresist} - Energy Resistance\n{poisonresist} - Poison Resistance\n{luck} - Luck\n{damage} - Damage Min-Max\nColor - HTML hex color code: '~#rrggbb' ('~#~' to terminate)\nOr a {Format} from the Counters list\n{skill} - Skill usage timer
1109=Razor Version: {0}\nMemory Used: {1}\nSend: {2} ({3}/s)\nRecv: {4} ({5}/s)\nConnected for {6}\n\nPlayer Serial: 0x{7:X8}\nBackpack Serial: 0x{8:X8}\n\nTracking Items: {9}\nTracking Mobs: {10}\n
1110=Set Lock: UP
1111=Set Lock: DOWN
1112=Set Lock: LOCKED
1113=Are you sure you want to remove the counter "{0}"?\nThis will effect all profiles.
1114=Load profile "{0}" now?
1115=There was an error loading that profile.
1116=You cannot delete the default profile.
1117=Enter a name for the new profile:
1118=Cannot create a new profile!\n Reason: A profile with that name already exists.\n\nWould you like to load that profile now?
1119=Enter a name for the new Dress List:
1120=Delete this dress list?
1121={0:X} (Item out of Range)
1122=Delete this item from the dress list?
1123=Target a bag to undress the list '{0}' into.
1124=Undress bag set.
1125=Item not found, or invalid item selected.
1126=That key combination already belongs to '{0}'.\nChange it to '{1}'?
1127=Data saved successfully.
1128=Warning!\nLogging packets may reduce Razor's performance. Log files can also\neasily grow very large, and Razor will not automatically remove them.\n\nRazor's packet log files may contain personal information such as\npasswords, and should be not be given to people you do not trust.\n\nAre you sure you want to enable packet logging?\n(This will not be saved in your user profile)
1129=Convert Selected to TYPE
1130=Enter a name for the new macro:
1131=That name contains invalid characters.
1132=A macro with that name already exists.
1133=This macro will be cleared before recording.\nAre you sure you want to record over this macro?
1134=Are you sure you want to PERMANENTLY delete '{0}'?\n(This cannot be undone)
1135=Insert Pause/Wait...
1136=Insert Set LastTarget
1137=Move Up
1138=Move Down
1139=Remove Action
1140=Begin Recording Here
1141=The file '{0}' was not found.
1142=Are you sure?
1143=WARNING: The following {0} file{1} count not be deleted:\n{2}
1144=This change will take effect the next time you start Razor.
1145=Enabling this option will cause Razor to save your passwords as part of your profile.\nEven though the passwords are encrypted it may be possible for someone to use them if the gain access to your profile's xml file.\nAre you sure you want to enable this feature?
1146=You must specify a valid port.
1147=Ignoring action request (already queued).
1148=Queuing action request {0}... {1} left.
1149=Finished {0} queued actions in {1:F1} seconds.
1150=Use Once Agent
1151=Add (Target)...
1152=Add Container (Target)...
1153=Remove (Target)...
1154=Clear List
1155=Target an item to add.
1156=Target a Container.
1157=Target an item to remove.
1158=Item added.
1159=Item removed.
1160={0} item(s) added to the Use Once agent.
1161=The UseOnce queue is empty!
1162=Using '{0}'.  ({1} item(s) left in the UseOnce queue)
1163=There was a problem with one of your UseOnce items, trying the next one.
1164=SellAgent: Automatically selling {0} item(s) for {1}gp.
1165=Remove
1166=Container set successfully.
1167=Clear
1168=(Push to Disable)
1169=(Push to Enable)
1170=Set Hot Bag
1171=Clear Hot Bag
1172=Organizer Agent
1173=Organizer
1174=Organize Now
1175=Container not set.
1176=Razor could not find your backpack.
1177=Organize Agent queued {0} item(s) to be moved. (This may take a few moments)
1178=Organize Agent did not find any items to move.
1179=That item is already in the list.
1180=AutoSearchExemptions
1181=Buy Agent bought {0} item(s) for {1}gp.
1182=The Buy Agent did not attempt to buy some items in your buy list because you do not have enough gold.
1183=Enter the amount:
1184=Client Process Priority set to {0}
1185=The current time is: {0}
1186=You are at {0} in '{1}'
1187=Undress bag was not found or out of range, using your backpack instead.
1188={0} item(s) queued to be de-equipped.
1189={0} item(s) queued to be equipped.
1190={0} item(s) already equipped.
1191={0} item(s) were not found. (Out of Range)
1192=Warning: Spells.def not found, spell format text will not be shown
1193=Stealth Steps: {0}
1194=Now counting stealth steps.
1195=Clear Target Queue
1196=Attack Last Combatant
1197=Target queue cleared.
1198=Target a new 'Last Target'
1199=Last Target set.
1200=New target set.
1201=No one matching that was found on your screen.
1202=Queued target self.
1203=Queued last target.
1204=Server sent new target, canceling Razor target.
1205=Target by Type {0}
1206=Scavenger
1207=Are you sure you want to delete this?
1208=Select a folder to store Razor's screen shots.
1209=Hot Keys
1210=Items
1211=Targets
1212=Agents
1213=Dress
1214=Macros
1215=Spells
1216=Skills
1217=Misc
1218=Friends
1219=Scripts
1251=1st
1252=2nd
1253=3rd
1254=4th
1255=5th
1256=6th
1257=7th
1258=8th
1260=Necromancy
1270=Chivalry
1271=Potions
1272=Special Moves
1290=Bushido
1300=Ninjitsu
1301=Sell
1302=Buy
1303=Input Required
1304=Razor Commands List
1305=Use Item in Hand
1306=You must disarm something before you can arm it.
1307=Arm/Disarm Right Hand
1308=Arm/Disarm Left Hand
1309=Drop What You are Currently Holding
1310=Spellweaving
1311=> Enable/Disable Razor HotKeys
1312=Hot Keys Enabled (Press {0} to disable)
1313=Hot Keys Disabled (Press {0} to enable)
1314=Hot Keys Enabled
1315=Hot Keys Disabled
1316=Walk: {0}
1317=Add Type (Target)...
1318=The requested target is out of range, last target not executed!
1319=Max Sell: {0}
1320=Snooping Messages
1321=Backpack Sounds
1322=Insert "If" Conditional
1323=Insert "Else"
1324=Insert "End If"
1325=Set Amount
1326=Restock
1327=Restock Now
1328=Restock Agent
1329=Target a container to restock from, or target yourself to use your bank box.
1330=That container is invalid.
1331=Restock done, queued {0} item{1}.
1332=Cancel Current Target
1333=A newer version of razor is availible for download from the Razor website.\n\nDo you wish to visit the Razor website now to download the new version?
1334=Reload
1335=Save
1336=Warning: The current target does not allow you to target the ground.  Last Target not performed.
1337=Resynchronize Client
1338=Dismount blocked.
1339=Begin Razor "PacketVideo" Recording
1340=Stop "PacketVideo" Recording/Playback
1341=There was an error starting the recording.\nThe exception has been logged.
1342=This file is not compatible with this version of Razor.  Make sure you have the latest Razor version.
1343=This video file is corrupt.\nIt may be incomplete, or it may have been tampered with.\nThe file cannot be played.
1344=There was a problem reading the file.  It may be damaged or incomplete.
1345=Enter category name:
1346=The directory could not be deleted.  Make sure it is empty.
1347=Could not create directory.  Make sure the name you entered is valid and try again.
1348=Could not move macro file.  Make sure the category you entered was valid.
1349=Friends
// 1350 to 1359 reserved (max length 15!)
1350=Stopped
1351=The End
1352=Game Over?
1353=ker-pwned
1354=Got corp por?
1355=bamboozled
1356=pwned?
1357=Jesus <3s you
1358=Kal Vas Pwned
1359=SMACKDOWN
1360=Target a player to add to your friends list.
1361=Target a player to remove from your friends list.
1362=Friend added.
1363=Friend removed.
1364=Special Constructs
1365=Insert "For Loop"
1366=Insert "End For"
1367=Enter the number of iterations:
1368=Clear Scavenger Cache
1369=Last Spell
1370=Last Skill
1371=Last Object
1372=All Names
1373=UseOnce
1374=Target Random Enemy Humanoid
1375=Target Random Grey Humanoid
1376=Target Random Innocent Humanoid
1377=Target Random Criminal Humanoid
1378=Target Random Criminal
1379=WARNING: Drag/Drop timeout! Dropping item in hand to backpack.
1380=You must restart Razor and the client for this change to take effect.
1381=You must go into your Paperdoll, click Options and then click Apply for this to take effect.
1382=Queuing dragdrop request {0}... {1} left.
1383=Restock request in progress....
1384=Your strength has changed by {0}{1}, it is now {2}.
1385=Your dexterity has changed by {0}{1}, it is now {2}.
1386=Your intelligence has changed by {0}{1}, it is now {2}.
1387=Light Levels
1388=Heal blocked (the target is poisoned)!
1389=Clear Drag/Drop Queue
1390=Stop Now
1391=> Smart Heal/Cure Self
1392=Next Target
1393=Set Restock HotBag
1394=Add to UseOnce
1395=Attack Last Target
1396=Edit Timeout...
1397=You are not holding anything.
1398=NOT allowed
1399=allowed
1400=Features negotiated with server:
1401=All features allowed.
1402=Weather filter
1403=Light Level filter
1404=Smart LastTarget
1405=Range Check LastTarget
1406=Auto-Open Doors
1407=Unequip Before Spell Cast
1408=Auto-Potion Equip
1409=Block Heal when Poisoned
1410=Looping Macros
1411=Use Once Agent
1412=Restock Agent
1413=Sell Agent
1414=Buy Agent
1415=Potion Hotkeys
1416=Random Targets
1417=Closest Targets
1418=Overhead Health/Stats Display
1419=Autoloot Agent
1420=Bone cutter Agent
1421=Advanced Macros
1422=Auto remount
1423=Automatic Bandage
1424=Enemy Target Sharing
1425=Filter Seasons
1426=Spell Target Sharing
1427=Humanoid Health Checks
1428=Journal speech checks
// up to 1465: reserved
1466=Feature Disallowed by Server
1467=This feature is not allowed by the current game server.\nYou may choose to ignore the server's allowed features on the "Options" tab.\n\nTo see a list of disallowed features, check the "Help & Status" tab.
1468=Insert Comment
1469=Add Friend
1470=Remove Friend
1471=> Mini-Heal/Cure Self
1472=You should only disable the "Patch Encryption" option if you are using a client that already has encryption disabled.  This option should remain enabled even on servers which use client encryption (such as OSI/EA official servers).\nIf you are not sure what to do, do NOT uncheck this box.\n\nAre you sure you want to turn off client-side encryption patching?
1473=Dismount
1474=Show/Hide Map Window
1475=That is too far away.
1476=Drag drop queue is FULL! Please wait.
1477=Toggle War/Peace
1478=Rewards Gump
1479=The game window size you selected is invalid. Try again.
1480=(Scavenger HotBag)
1481=(Restock HotBag {0})
1482=(UseOnce #{0})
1483=(Sell Agent HotBag)
1484=(Organizer {0} HotBag)
1485=The server address you entered could not be resolved.
1486=Party: Accept Invitation
1487=Party: Decline Invitation
1488=Harmful Target
1489=Beneficial Target
1490=(Razor Friend)
1491=Play from Here
1492=Initializing...
1493=Loading most recent profile...
1494=Loading Client...
1495=Waiting for client to start...
1496=Don't forget to donate!
1497=Welcome to Razor!
1498=2D Client (Auto Detect)
1499=3D Client (Auto Detect)
1500=(Auto Detect)
1501=Opacity: {0}%
1502=Enter new timeout value for this action (in seconds):
1503=not assigned
1504=Change Timeout
1505=Enter a Name
1506=Invalid.
1507=Staff Only Items
1508={0}'s Stats
1509=Eat Enchanted Apple
1510=Target Closest Murderer
1511=Target Closest Grey
1512=Target Closest Innocent
1513=Target Closest Enemy
1514=Target Closest Friendly
1515=Target Closest Non-Friendly
1516=Target Closest Enemy Humanoid
1517=Target Closest Grey Humanoid
1518=Target Closest Innocent Humanoid
1519=Target Closest Criminal Humanoid
1520=Target Closest Criminal
1521=Warning: The profile '{0}' is in use by another instance of Razor!\nIf you make changes to this profile it may become corrupted. It is recommended that you use a different profile for each instance of Razor.
1522=Waiting... Timeout:
1523=Razor was unable to locate and load a suitable UO cliloc file, some text may not be displayed. Please manually set your UO Data Directory or verify that it is correct.
1524=No CliLoc
1525=Bulk Order Deed
1526=Launch BOD Agent
1527=Next Humanoid Target
1528=Spells
1529=Warning: AOSAbilities.def not found, weapon move hotkeys will be unavailable
1530=Enter new text:
1531=Razor was unable to locate your UO client automatically. Please manually set your UO Data Directory or verify that it is correct.
1532=Failed to find client
1533=Unable to launch the client specified. (Error: {2})\n{0}: "{1}"
1534=Failed to launch client
1537=Target Random Innocent Monster
1538=Target Random Criminal Monster
1541=Target Closest Innocent Monster
1542=Target Closest Criminal Monster
1543=Next Monster Target
1927=Mysticism
1950=A Razor macro has been detected in your clipboard.\nWould you like to create this macro based on the clipboard data?
1951=Macro has been copied to the clipboard
1952=Deer Sounds
1953=Enter new macro name
1954=Enter new variable name
1955=Target Closest Grey Monster
1956=Target Closest Enemy Monster
1957=Target Random Grey Monster
1958=Target Random Enemy Monster
1959=Cyclops/Titan Sounds
1960=Next Enemy Humanoid Target
1961=Unable to open macro file
1962=> Pause Current Macro
1963=Macro paused..
1964=Macro resuming..
1965=Stun ready
1966=Stun successful
1967=Stun disabled
1968=Stun failed
1969=All Corpses
1970=All Mobiles
1971=Bull Sounds
1972=Dragon Sounds
1973=Set Sell HotBag
1974=Add UseOnce Container
1975=Chicken Sounds
1976=Toggle JMap Visibility
1977=Scavenger Enable/Disable
1978=Scavenger Set Hot Bag
1979=Scavenger Add Target
1980=Toggle GPS/GPM/GPM Tracker
1981=Enter new text
1982=This version of Razor is portable and your profiles and macros are stored within the Razor folder. Would you like to import your existing Profiles and Macros? This process will not effect your existing macros from your previous version.
1983=Set Organizer HotBag
1984=Set container label
1985=Add to ignore list
1986=Remove from ignore list
1987=(Razor Ignored)
1988=IgnoreList
1989=Previous Target
1990=Previous Enemy Humanoid Target
1991=Previous Humanoid Target
1992=Use Last Gump Response
1993=Set container alias
1994=> Interrupt
1995=Capture Last Opened BOD
1996=Toggle Damage Tracker
1997=>> Enable Razor HotKeys
1998=>> Disable Razor HotKeys
1999=Your UO data directory and UO client path do not match. This can cause issues such as missing animations and graphics.
2000=Target Random Mobile
2001=Target Closest Murderer Monster
2002=Target Closest Murderer Humanoid
2003=Target Closest Mobile
2004=Target Random Murderer Humanoid
2005=Target Random Murderer Monster
2006=Target Random Non-Friendly Humanoid
2007=Target Random Non-Friendly Monster
2008=Target Random Friendly Humanoid
2009=Target Random Friendly Monster
2010=Target Random Innocent Monster
2011=Target Random Criminal Monster
2012=Target Closest Non-Friendly Humanoid
2013=Target Closest Non-Friendly Monster
2014=Target Closest Friendly Humanoid
2015=Target Closest Friendly Monster
2016=Target Closest Innocent Monster
2017=Target Closest Criminal Monster
2018=Next Monster Target
2019=Previous Monster Target
2020=Add All Mobiles As Friends
2021=All Come
2022=All Follow Me
2023=All Follow
2024=All Guard Me
2025=All Guard
2026=All Kill
2027=All Stay
2028=All Stop
2029=Pet Commands
2030=Friend
2031=Str: {0}{1} - {2}
2032=Dex: {0}{1} - {2}
2033=Int: {0}{1} - {2}
2034=[{0}] {4}{5:F1} {3:F1} ({1}{2:F1})
2035=Grab Item
2036=Set Grab Item HotBag
2037=Target item to grab
2038=(Grab Item HotBag)
2039=Next Criminal Humanoid Target
2040=Next Murderer Humanoid Target
2041=Next Innocent Humanoid Target
2042=Previous Criminal Humanoid Target
2043=Previous Murderer Humanoid Target
2044=Previous Innocent Humanoid Target  
2045=> Criminal Targets
2046=> Enemy Targets
2047=> Friendly Targets
2048=> Grey Targets
2049=> Innocent Targets
2050=> Murderer Targets
2051=> Non-Friendly Targets
2052=Next Friendly Humanoid Target
2053=Next Grey Humanoid Target
2054=Next Non-Friendly Humanoid Target
2055=Previous Friendly Humanoid Target
2056=Previous Grey Humanoid Target
2057=Previous Non-Friendly Humanoid Target
2058=Toggle War Only
2059=Toggle Peace Only
2060=> Greater Heal/Cure Self
2061=Set Last Target (Beneficial)
2062=Set Last Target (Harmful)
2063=Last Beneficial Target Set
2064=Last Harmful Target Set
2065=Target Closest Friend
2066=Target Random Friend
2067=Next Friend Target
2068=Previous Friend Target
2069=Use Item in Right Hand
2070=Use Item in Left Hand
2071=Insert Overhead Message
2072=Insert Wait For Target
2073=Add All Humanoids As Friends
2074=Next Enemy Monster Target
2075=Next Criminal Monster Target
2076=Next Murderer Monster Target
2077=Next Innocent Monster Target
2078=Previous Criminal Monster Target
2079=Previous Murderer Monster Target
2080=Previous Innocent Monster Target
2081=Next Friendly Monster Target
2082=Next Grey Monster Target
2083=Next Non-Friendly Monster Target
2084=Previous Enemy Monster Target
2085=Previous Friendly Monster Target
2086=Previous Grey Monster Target
2087=Previous Non-Friendly Monster Target
2088=Target a new 'Beneficial Target'
2089=Target a new 'Harmful Target'
2090=Bird Sounds
2091=AddAllMobilesTargetFilter
2092=AddAllMobilesHumanoidTargetFilter
2093=Insert "While Loop"
2094=Insert "End While"
2095=Insert "Do"
2096=Insert "Do While Loop"
2097=Play Script: {0}
2098=Enter new script variable name
2099=Playing script '{0}'...
2100=Script '{0}' finished
2101=> Stop Current Script
2102=Party: Add
2103=Mysticism
2104=Masteries
2105=Waypoint: Next
2106=Waypoint: Previous
2107=Waypoint: Hide
2108=Insert Clear SysMessages
2109=Clear SysMessages
2110=Next Non-Friendly Target
2111=Prev Non-Friendly Target
2112=Set Hue
2113=Script: Get 'dclicktype' command
2114=Script: Get 'targettype' command
2115=Script: '{0}' copied to the clipboard
2116=Gump: Item/Mobile Info
2117=Gump: System Messages
2118=Gump: Hot Keys
2119=Gump: Boat Control
2120=Buy Agent attempted to buy {0} item(s) for {1}gp.
2121=Next Friendly Target
2122=Previous Friendly Target
2123=> Pause Current Script
2124=Script resuming from line {0}
2125=Script pausing on line {0}
2126=Script '{0}' finished ({1}ms)

================================================
FILE: etc/Language/Razor_lang.esp
================================================
// Razor Espaol/ESP Languaje Pack
// Ultima modificacion 05/01/04
::CliLoc=ESP

[controls]
WelcomeForm::Text=Bienvenido al Razor!
WelcomeForm::label5=Lenguaje por defecto:
WelcomeForm::groupBox3=Perfil
WelcomeForm::newProfile=Nuevo...
WelcomeForm::label2=Cargar:
WelcomeForm::groupBox2=Servidor
WelcomeForm::label3=IP:
WelcomeForm::label4=Port:
WelcomeForm::groupBox1=Opciones de Cliente
WelcomeForm::makeDef=Marcar como defecto
WelcomeForm::browse=Examinar
WelcomeForm::label1=Cliente:
WelcomeForm::patchEncy=Patch client encriptado
WelcomeForm::showAtStart=Mostrar siempre al ejecutar
WelcomeForm::quit=&Salir
WelcomeForm::okay=&Entrar
MainForm::generalTab=General
MainForm::label7=Lenguaje:
MainForm::logPackets=Activar logeo de paquete
MainForm::rememberPwds=Recordar clave
MainForm::systray=System Tray
MainForm::taskbar=Barra
MainForm::label11=Mostrar:
MainForm::groupBox4=Perfiles
MainForm::delProfile=Borrar
MainForm::newProfile=&Nuevo
MainForm::showWelcome=Mostrar mensaje bienvenida
MainForm::alwaysTop=Marcar para siempre visible
MainForm::groupBox1=Filtros
MainForm::opacityLabel=Opacity: 100%
MainForm::moreOptTab=Mas Opciones
MainForm::incomingCorpse=Mostrar los nombres de los cadaveres
MainForm::incomingMob=Mostrar nombres de gente y criaturas
MainForm::setHarmHue=Set
MainForm::setNeuHue=Set
MainForm::lblHarmHue=Agresibo
MainForm::lblNeuHue=Neutral
MainForm::lblBeneHue=Beneficial
MainForm::setBeneHue=Set
MainForm::setSpeechHue=Set
MainForm::setWarnHue=Set
MainForm::setMsgHue=Set
MainForm::setExHue=Set
MainForm::autoStackRes=Dejar Minerales y Peces al suelo
MainForm::queueTargets=Espera de acciones para realizar
MainForm::actionStatusMsg=Ver aciones en el mensaje de estado
MainForm::spamFilter=Filtrar Publicidad
MainForm::label4=casillas
MainForm::openCorpses=Abrir nuevos objetos en
MainForm::showNotoHue=Ver los Hues en la barra de titulo
MainForm::lblWarnHue=Mensaje de Peligro
MainForm::lblMsgHue=Mensaje Sistema
MainForm::lblExHue=Buscar Excepcion
MainForm::chkStealth=Contar Pasos Escondido
MainForm::label6=ms
MainForm::label5=Tiempo de:
MainForm::QueueActions=Activar Tiempo acciones objetos 
MainForm::chkForceSpellHue=Color del Hechizo:
MainForm::chkForceSpeechHue=Sobrescritura msg
MainForm::label3=Formato:
MainForm::displayTab=Mostrar/Contenido
MainForm::highlightSpellReags=Mostrar regs usados en el hechizo
MainForm::titlebarImages=Mostrar imagenes en barra
MainForm::sortCounters=Contador para ordenacion de listas
MainForm::checkNewConts=Auto buscar nuevos contenedores
MainForm::warnCount=Advertir cuando quedan:
MainForm::groupBox3=Mostrar barra superior
MainForm::showInBar=Mostrar contenido en barra:
MainForm::groupBox2=Contenidos
MainForm::delCounter=Del/Edit
MainForm::addCounter=Agregar
MainForm::recount=Recuento
MainForm::dressTab=Arm/Dress
MainForm::groupBox6=Arm/Dress Objetos
MainForm::dressDelSel=Borrar
MainForm::undressBag=Cambiar Undress Bolsa
MainForm::undressList=Undress Ahora
MainForm::dressUseCur=Add Current
MainForm::targItem=Agregar (Objetivo)
MainForm::dressNow=Dress Ahora
MainForm::groupBox5=Arm/Dress Seleccion
MainForm::removeDress=Borrar
MainForm::addDress=Nuevo
MainForm::undressConflicts=Mover los objetos que estan en conflicto
MainForm::skillsTab=Habilidades
MainForm::dispDelta=Mostrar Cambi
MainForm::skillCopyAll=Copiar Todos
MainForm::skillCopySel=Copiar Seleccion
MainForm::label1=Base Total:
MainForm::setlocks=Fijar todos a:
MainForm::resetDelta=Reset  +/-
MainForm::screenshotTab=Imagenes
MainForm::capNow=Take SS Now
MainForm::radioUO=Solo UO
MainForm::radioFull=Imagen Completa
MainForm::screenAutoCap=Capturar pantalla al morir
MainForm::setScnPath=...
MainForm::dispTime=Incluir tiempo en imagenes
MainForm::hotkeysTab=Teclas
MainForm::dohotkey=Ejecutar seleccion
MainForm::groupBox8=Tecla
MainForm::chkPass=Pasar al UO
MainForm::label2=Key:
MainForm::unsetHK=Unset
MainForm::setHK=Set
MainForm::chkCtrl=Ctrl
MainForm::chkAlt=Alt
MainForm::chkShift=Shift
MainForm::macrosTab=Macros
MainForm::macroActGroup=Acciones
MainForm::loopMacro=Continuo
MainForm::recMacro=Grabar
MainForm::playMacro=Play
MainForm::delMacro=Borrar
MainForm::newMacro=Nuevo
MainForm::agentsTab=Agentes
MainForm::statusTab=Ayuda && Estado
MainForm::visitForums=Ayuda && Foros de Soporte
MainForm::visitHome=Razor Homepage
MainForm::visitGuide=Razor Guia Usuario
HueEntry::Text=Select a Hue
HueEntry::cancel=Cancelar
HueEntry::okay=&Entrar
HueEntry::preview=Preview
HueEntry::inGame=Seleccionar en Juego
HueEntry::label1=Hue Numero:
AddCounter::Text=Editar Contador
AddCounter::delete=Borrar
AddCounter::target=Objetivo 
AddCounter::cancel=Cancelar
AddCounter::Add=&Agregar
AddCounter::label4=Color (Any: -1):
AddCounter::label3=Item ID:
AddCounter::label2=Formato:
AddCounter::label1=Nombre:
MacroInsertWait::Text=Insertar Espera/Pausa...
MacroInsertWait::radioMenu=Esperar para Menu
MacroInsertWait::cancel=&Cancelar
MacroInsertWait::radioStat=Espera para
MacroInsertWait::radioTarg=Espera para Objetivo
MacroInsertWait::radioGump=Espera para Gump
MacroInsertWait::label1=milisegundos
MacroInsertWait::radioPause=Parar por:
MacroInsertWait::insert=&Insertar


[strings]
1001=Estado de muerte
1002=Musica de Bardo
1003=Sonido de perro
1004=Sonido de gato
1005=Sonido de caballo
1006=Sonido de oveja
1007=Sonido Spirit Speak
1008=Sonido fracaso conjuro
1009=Tiempo
1010=Mostrar Contadores
1011=Recontar Contadores
1012=Clear AOS Ability
1013=Set Primary Ability (AOS)
1014=Set Secondary Ability (AOS)
1015=Toggle Stun (Pre-AOS)
1016=Toggle Disarm (Pre-AOS)
1017=Setting ability {0}
1018=AOS Abilities cleared.
1019=Undress Todo
1020=Undress Ambas Manos
1021=Undress Mano izquierda
1022=Undress Mano derecha
1023=Undress Sombrero
1024=Undress Joyeria
1025=Bendarte
1026=Bendar ultimo objetivo
1027=Usar bendas (No Tiempo)
1028=Botella Curacion
1029=Botella Antidoto
1030=Botella Resistencia
1031=Botella Vision Nocturna
1032=Botella Explosion
1033=Botella Fuerza
1034=Botella Agilidad
1035=Ninguna benda encontrada
1036=Ningun objeto del tipo {0} encontrado!
1037=Doble Click ({0})
1038=Re-Target
1039=Convertir el DClick por Tipo
1040=Seleccione un nuevo objetivo de accion.
1041=ADVERTENCIA: Excepcion mientras cargaba las caracteristicas del perfil: \n{0}
1042=Advertencia macro: No puede encontrar ese objeto (Fuera de Rango).
1043=Elevacion {1} - {0}
1044=Convertir elevacion por tipo
1045=Advertencia macro: No lleva nada a cabo.
1046=Equipar a {0}
1047=Desequipar a {0} (@{1})
1048=Convertir a localizacion relativa
1049=Soltar (Relativo) @({0},{1},{2})
1050=GumpResponse (Button {0})
1051=Cerrar Gump
1052=MenuResponse {0}
1053=Advertencia: No se encontro el objetivo (Necesitas un 'WaitForTarget'?)
1054=Unico Objetivo
1055=Combertir a Ultimo Objetivo
1056=Objetivo por tipo {0}
1057=Objetivo RelLoc ({0},{1},{2})
1058=Ultimo objetivo
1059=Ser el Objetivo
1060=Marcar ultimo Objetivo
1061=Objetivo al azar Rojo
1062=Objetivo al azar Gris
1063=Objetivo al azar Azul
1064=Objetivo al azar enemigo
1065=Objetivo al azar amigo
1066=Objetivo al azar no amigo
1067=Decir "{0}"
1068=UseSkill {0}
1069=CastSpell {0}
1070=SetAbility {0}
1071=Dress: {0}
1072=Undress: {0}
1073=Unequip Layer {0}
1074=Wait for Menu (Any)
1075=Wait for Menu (#{0})
1076=Editar
1077=Wait For Gump (Any)
1078=Wait for Gump (#{0})
1079=Wait for Target
1080=Parar {0:#.00}sec
1081=Wait for {0} {1} {2}
1082=Cargando '{0}'...
1083=> Parar macro actual
1084=Empezar: {0}
1085=Empezar macro '{0}'...
1086=Macro '{0}' terminado.
1087=Razor no pudo iniciarse: Codigo de error:\n
1088=Descripcion: No pudo encontrar la ventana del juego.\nPosible Causa: El cliente no pudo iniciarse correctamente.
1089=Descripcion: No pudo encontrar el ThreadID del cliente\nPosible Causa: El cliente no pudo iniciarse correctamente.
1090=Descripcion: No pudo crear los enlaces de Windows.\nPosible Causa: Error Interno.
1091=Descripcion: No pudo crear o tener acceso al Razor compartiendo memoria.\nPosible Causa: Windows Error o permiso invalido.
1092=Descripcion: Crypt.dll se ha inhabilitado.\nPosible Causa: Version defectuosa.
1093=Descripcion: No pudo parchear las funciones de Winsock del cliente.\nPosible Causa: Error Interno, Windows Error, o Version Incompatible.
1094=
1095=Advertencia: No pudo copiar el tamao del paquete y/o informacion del cifrado del cliente.\nRazor puede funcionar sin esta informacion, aunque algunas caracteristicas pueden no funcionar correctamente.Quieres ejecutar el Razor de todos modos?\n\nCausa Posible: Su version del cliente puede no ser compatible con esta version del Razor.
1096=Tu habilidad de {0} ha cambiado por {1}{2:F1}, ahora esta en {3:F1}.
1097=Abreviatura invalida.
1098=ID del objeto invalido.
1099=Hue invalido.
1100=Seleccione un articulo para contar.
1101=Error al cargar '{0}'!\nEste perfil esta corrupto y no puede ser utilizado.
1102=La caracteristica {0} no fue encontrada en este perfil.
1103=Su archivo counters.xml esta corrupto y no puede ser utilizado.
1104=El auto buscador esta desconectado, tendras que abrir de nuevo todas las bolsas para que el contador pueda utilizarse.
1105=Advertencia: {0} cantidades ahora estan {1}!
1106=Selecciona la tonalidad que deseas utilizar.
1107=Hacer imagen ahora
//1108=Posibles variantes:\n{char} - Nombre del Personaje\n{shard} - Nombre del Servidor\n{str}/{hp}/{hpmax} - Estado de salud\n{dex}/{stam}/{stammax} - Estado de destreza\n{int}/{mana}/{manamax} - Estado de inteligencia\n{weight}/{maxweight} - Informacion del Peso\n{gold} - Total de Oro en la mochila\n{AR} - Grado de Armadura / Resistencia Fisica\n{tithe} - Puntos de Paladin\n{bandage} - Tiempo en aplicar bendas\n{statbar}/{mediumstatbar}/{largestatbar} - Barra de estado\n{crimtime} - Tiempo total en estado Criminal\n{stealthsteps} - Stealth steps counterColor - HTML hex color code: '~#rrggbb' ('~#~' to terminate)\nOr a {Format} from the Counters list
1109=Razor Version: {0}\nMemory Usada: {1}\nEnviado: {2} ({3}/s)\nRecivido: {4} ({5}/s)\nConectado durante {6}\n\nPlayer Serial: 0x{7:X8}\nBackpack Serial: 0x{8:X8}\n\nTracking Items: {9}\nTracking Mobs: {10}\n
1110=Set Lock: UP
1111=Set Lock: DOWN
1112=Set Lock: LOCKED
1113=Estas seguro que quieres quitar el contador "{0}"?\nEsto afectara a todos los perfiles.
1114=Cargar perfil "{0}" ahora?
1115=Se encontro un error al cargar el perfil.
1116=No puedes suprimir el perfil por defecto.
1117=Meter nombre para nuevo perfil: 
1118=No puedes crear un nuevo perfil!\n Razon: Ya existe un perfil con ese nombre.\n\nQuieres cargar ese perfil?
1119=Nombre para nueva lista de vestuario:
1120=Suprimir esta lista?
1121={0:X} (Objeto fuera de rango)
1122=Suprimir este objeto de la lista?
1123=Seleccione un bolso para depositar '{0}'.
1124=Accion Undress en la bolsa.
1125=Objeto no encontrado, o objeto invalido seleccionado.
1126=Esa tecla pertenece ya a '{0}'.\nCambiarlo a '{1}'?
1127=Datos salvados con exitos.
1128=Advertencia!\nLos paquetes de registro pueden reducir el funcionamiento del Razor. Los ficheros de diario pueden tambien\ncrecer facilmente, y el Razor no los quitara automaticamente.\n\nRazor's puede contener la informacion personal\nclaves, y no lo facilite si no confia en el.\n\nEstas seguro que deseas permitir el registro del paquete?\n
1129=Convert Selected to TYPE
1130=Meter nombre para nuevo macro: 
1131=Ese nombre contiene caracteres invalidos.
1132=Ya existe una macro con ese nombre
1133=Esta macro ya existe.\nEstas seguro que deseas sobreescribir esta macro?
1134=Estas seguro de suprimir PERMANENTEMENTE '{0}'?\n
1135=Insertar Pausa/Espera...
1136=Insertar anterior objetivo
1137=Subir
1138=Bajar
1139=Borrar accion
1140=Comienza a registrar aqui
1141=El archivo '{0}' no fue encontrado.
1142=Estas seguro?
1143=ADVERTENCIA: El siguiente {0} archivo{1} cuenta no ser suprimido:\n{2}
1144=Esta opcion funcionara la proxima vez que inicie el Razor.
1145=Permitiendo esta opcion hara que Razor guarde su clave en su perfil.\nAunque no es recomendable ya que podrian acceder al archivo xml de su perfil.\nDesea permitir esta opcion?
1146=Debes especificar un puerto valido.
1147=Ignorar accion de peticion.
1148=Peticion de poner en cola {0}... {1} izquierda.
1149=Finalizado {0} acciones en espera en {1:F1} segundos.
1150=Agente UnUso
1151=Agregar (Objetivo)...
1152=Agregar bolsa (Objetivo)...
1153=Borrar (Objetivo)...
1154=Borrar lista
1155=Seleccione un objeto para agregar.
1156=Seleccione un envase.
1157=Seleccione un objeto para quitar.
1158=Objeto Agregado.
1159=Objeto Robado.
1160={0} objeto(s) agregados al agente de UnUso.
1161=Cola llena de UnUso!
1162=Usando '{0}'.  ({1} objeto(s) dejando en espera de UnUso)
1163=Habia un problema con uno de los articulos de UnUso, intentando el siguiente
1164=AgenteVenta: Venta automatica de {0} objeto(s) por {1}gp.
1165=Borrar
1166=Envase fijado con exito.
1167=Borrar lista
1168=(Inhabilitar)
1169=(Permitir)
1170=Bolsa determinada
1171=Quitar Bolsa
1172=Organizar Agente
1173=Organizar
1174=Organizar ahora
1175=Envase no fijado.
1176=Razor no lo encontro su backpack.
1177=Agente Organizador en cola {0} objeto(s) para mover.
1178=Agente Organizador no encontro ningun objeto para mover.
1179=Ese objeto ya esta en la lista.
1180=AutoBusquedaExepciones
1181=Agente de compra comprando {0} objeto(s) por {1}gp.
1182=El agente de compra no puedo comprar algunos objetos por falta de dinero.
1183=Introduce la cantidad:
1184=Sistema de prioridad de proceso del cliente a{0}
1185=El tiempo actual es: {0}
1186=Estas en {0} en '{1}'
1187=Soltar en el bolso no se pudo al no encontrarse, usando su mochila en lugar de otro.
1188={0} objeto(s) en espera para desequipar.
1189={0} objeto(s) en espera para equipar.
1190={0} objeto(s) equipados ya.
1191={0} objeto(s) no fueron encontrados.
1192=ADVERTENCIA: Spells.def no encontrado, el formato del hechizo no sera mostrado
1193=Pasos en Stealth: {0}
1194=Contar pasos en Stealth.
1195=Borrar objetivos en espera.
1196=Atacar ultimo combate
1197=Borrar objetivos en espera.
1198=Nuevo Objetivo 'Ultimo Objetivo'
1199=Marcar Ultimo Objetivo.
1200=Marcar Nuevo Objetivo.
1201=Nada que emparejaba fue encontrada en su pantalla.
1202=Accion de marcarte en espera.
1203=Ultimo marcado en espera.
1204=Enviado nuevo objetivo, cancelado el objetivo.
1205=Objetivo por tipo {0}
1206=Limpiador
1207=Deseas borrar esto?
1208=Seleccionar carpeta para imagenes
1209=Teclas
1210=Objetos
1211=Objetivos
1212=Agentes
1213=Equipar
1214=Macros
1215=Hechizos
1216=Habilidades
1217=Misc
// 1219 - 1250 reserved
1251=1st
1252=2nd
1253=3rd
1254=4th
1255=5th
1256=6th
1257=7th
1258=8th
// 1259 not used
1260=Necromancia
// 1261 - 1269 not used
1270=Paladin
1271=Pociones
1272=Movimientos Especiales
// 1273 - 1299 reserved
1373=UnUso
1301=Vender
1302=Comprar
1303=Requiere Entrar
1304=Lista de Comandos
1305=Usar Objeto disponible
1306=Hay que desarmarse para armarse otra vez.
1307=Arm/Disarm Mano Derecha
1308=Arm/Disarm Mano Izquierda
1309=Soltar lo que sustienes actualmente

1311=> Activar/Desactivar Teclas Razor 
1312=Teclas Habilitadas (Presiona {0} para inhabilitar)
1313=Teclas Inhabilitadas (Presiona {0} para habilitar)
1314=Teclas Habilitadas
1315=Teclas Inhabilitadas
1316=Caminado: {0}


================================================
FILE: etc/Language/Razor_lang.ita
================================================
// Razor Italian/ITA Language Pack
// Author: Metro
::CliLoc=ENU

[controls]
WelcomeForm::Text=Benvenuto su Razor!
WelcomeForm::label5=Lingua:
WelcomeForm::groupBox3=Profilo
WelcomeForm::newProfile=Nuovo...
WelcomeForm::label2=Profilo:
WelcomeForm::groupBox2=Server
WelcomeForm::label3=Server:
WelcomeForm::label4=Porta:
WelcomeForm::groupBox1=Opzioni Client
WelcomeForm::makeDef=Imposta come predefinito
WelcomeForm::browse=Sfoglia...
WelcomeForm::label1=Client:
WelcomeForm::patchEncy=Crittazione Client 
WelcomeForm::showAtStart=Mostra quando avvii Razor
WelcomeForm::quit=&Chiudi
WelcomeForm::okay=&OK
MainForm::Text=Razor v{0} (Beta)
MainForm::generalTab=Generale
MainForm::label7=Lingua:
MainForm::rememberPwds=Ricorda password 
MainForm::systray=System Tray
MainForm::taskbar=Taskbar
MainForm::label11=Mostra:
MainForm::groupBox4=Profili
MainForm::delProfile=Elimina
MainForm::newProfile=&Nuovo...
MainForm::showWelcome=Mostra finestra di benvenuto
MainForm::alwaysTop=Sempre in primo piano
MainForm::groupBox1=Filtri
MainForm::opacityLabel=Opaco: 100%
MainForm::moreOptTab=Opzioni
MainForm::logPackets=Abilita packet logging
MainForm::incomingCorpse=Mostra nomi dei corpi
MainForm::incomingMob=Mostra nomi delle creature
MainForm::setHarmHue=Set
MainForm::setNeuHue=Set
MainForm::lblHarmHue=Malvagio
MainForm::lblNeuHue=Neutrale
MainForm::lblBeneHue=Buono
MainForm::setBeneHue=Set
MainForm::setSpeechHue=Set
MainForm::setWarnHue=Set
MainForm::setMsgHue=Set
MainForm::setExHue=Set
MainForm::autoStackRes=Auto-Posa Minerali/Pesce/Legna a terra
MainForm::queueTargets=Accoda LastTarget e TargetSelf
MainForm::spamFilter=Filtro spam (sperimentale)
MainForm::label4=tile
MainForm::openCorpses=Apri nuovi corpi da
MainForm::showNotoHue=Mostra colori {char} Nella TitleBar
MainForm::lblWarnHue=Colore Msg Pericolo
MainForm::lblMsgHue=Colore Msg Razor
MainForm::lblExHue=Colore Ricerca Items
MainForm::chkStealth=Conta Passi in Stealth
MainForm::chkForceSpellHue=Colori Spells:
MainForm::chkForceSpeechHue=Colore Speech
MainForm::label3=Formato:
MainForm::moreMoreOptTab=Altre Opzioni
MainForm::label8=tile
MainForm::rangeCheckLT=Dist. check LastTarget:
MainForm::spellUnequip=Auto-Libera mani prima di castare
MainForm::actionStatusMsg=Mostra Messaggio Action-Queue
MainForm::label6=ms
MainForm::label5=Intervallo obj:
MainForm::QueueActions=Auto-Accoda azioni intervallo oggetti 
MainForm::displayTab=Display/Contatori
MainForm::highlightSpellReags=Evidenzia reagenti al cast
MainForm::titlebarImages=Mostra immagini+contatori
MainForm::sortCounters=Ordina i contatori
MainForm::checkNewConts=Auto-cerca nuovi contenitori
MainForm::warnCount=Avvisa quando un item e' a:
MainForm::groupBox3=Display Barra titoli
MainForm::showInBar=Mostra nella barra di UO:
MainForm::groupBox2=Contatori
MainForm::delCounter=Del/Edit
MainForm::addCounter=Add...
MainForm::recount=Recount
MainForm::dressTab=Arm/Dress
MainForm::groupBox6=Oggetti Arm/Dress
MainForm::clearDress=Svuota Lista
MainForm::dressDelSel=Rimuovi
MainForm::undressBag=Cambia borsa Undress
MainForm::undressList=Undress
MainForm::dressUseCur=Aggiungi Item
MainForm::targItem=Aggiungi(Target)
MainForm::dressNow=Dress
MainForm::groupBox5=Selezione Arm/Dress
MainForm::removeDress=Rimuovi
MainForm::addDress=Aggiungi
MainForm::undressConflicts=Sposta items in conflitto
MainForm::agentsTab=Agenti
MainForm::hotkeysTab=Tasti
MainForm::dohotkey=Esegui Selezionato
MainForm::groupBox8=Tasto
MainForm::chkPass=Passa ad UO
MainForm::label2=Key:
MainForm::unsetHK=Unset
MainForm::setHK=Set
MainForm::chkCtrl=Ctrl
MainForm::chkAlt=Alt
MainForm::chkShift=Shift
MainForm::macrosTab=Macro
MainForm::macroActGroup=Azioni
MainForm::loopMacro=Ripeti
MainForm::recMacro=Record
MainForm::playMacro=Usa
MainForm::delMacro=Rimuovi
MainForm::newMacro=Nuova...
MainForm::skillsTab=Skills
MainForm::dispDelta=Show Changes
MainForm::skillCopyAll=Copia Tutto
MainForm::skillCopySel=Copia Selezionato
MainForm::label1=Totale base:
MainForm::setlocks=Setta tutti:
MainForm::resetDelta=Reset  +/-
MainForm::screenshotTab=Screen Shots
MainForm::capNow=Scatta
MainForm::radioUO=Solo UO
MainForm::radioFull=Tutto
MainForm::screenAutoCap=Auto-Screen quando muori
MainForm::setScnPath=...
MainForm::dispTime=Aggiungi Tempo agli Screen
MainForm::statusTab=Aiuto && Status
MainForm::visitForums=Aiuto && Supporto Forum
MainForm::visitHome=Razor Homepage
MainForm::visitGuide=Guida a Razor
HueEntry::Text=Selez. colore
HueEntry::cancel=Cancel
HueEntry::okay=&OK
HueEntry::preview=Preview
HueEntry::inGame=Selez. in Game
HueEntry::label1=Numero:
AddCounter::Text=Counter Editor
AddCounter::delete=Delete
AddCounter::target=Target 
AddCounter::cancel=Cancel
AddCounter::Add=&OK
AddCounter::label4=Colore(No: -1):
AddCounter::label3=Item ID:
AddCounter::label2=Formato:
AddCounter::label1=Nome:
MacroInsertWait::Text=Inserisci pausa...
MacroInsertWait::radioMenu=Wait for old-style Menu/Dialog
MacroInsertWait::cancel=&Cancel
MacroInsertWait::radioStat=Wait for 
MacroInsertWait::radioTarg=Wait for Target
MacroInsertWait::radioGump=Wait for Gump
MacroInsertWait::label1=millisecondi
MacroInsertWait::radioPause=Pausa:
MacroInsertWait::insert=&Insert

[strings]
1001=Death Status
1002=Bards' Music
1003=Dog Sounds
1004=Cat Sounds
1005=Horse Sounds
1006=Sheep Sounds
1007=Spirit Speak Sound
1008=Spell Fizzle Sound
1009=Weather
1010=Mostra Contatori
1011=Riconta Contatori
1012=Clear AOS Ability
1013=Set Primary Ability (AOS)
1014=Set Secondary Ability (AOS)
1015=Toggle Stun (Pre-AOS)
1016=Toggle Disarm (Pre-AOS)
1017=Setting ability {0}
1018=AOS abilities cleared.
1019=Undress All
1020=Undress Due Mani
1021=Undress Mano Sinistra
1022=Undress Mano Destra
1023=Undress Cappello
1024=Undress Gioielli
1025=Bandage Self
1026=Bandage LastTarget
1027=Use Bandage (No Timer)
1028=Drink Heal
1029=Drink Cure
1030=Drink Refresh
1031=Drink Night Sight
1032=Drink Explosion
1033=Drink Strength
1034=Drink Agility
1035=Bende non trovate!
1036=Nessun item {0} trovato!
1037=Doppio Click ({0})
1038=Re-Target
1039=Converti a DClick by Type
1040=Seleziona nuovo target per l'azione.
1041=WARNING: Exception while loading profile property:\n{0}
1042=Macro Warning: Item non trovato (Fuori Range).
1043=Lift {1} - {0}
1044=Convert to Lift by Type
1045=Macro Warning: Niente in mano.
1046=Equip to {0}
1047=Drop to {0} (@{1})
1048=Converti a Relative Location
1049=Drop (Relative) @({0},{1},{2})
1050=GumpResponse (Button {0})
1051=Close Gump
1052=MenuResponse {0}
1053=Warning: Macro requested target, but no target sent from server! (Do you need a 'WaitForTarget'?)
1054=Absolute Target
1055=Converti a LastTarget
1056=Converti a Target by Type
1057=Target RelLoc ({0},{1})
1058=Last Target
1059=Target Self
1060=Set Last Target
1061=Target Random Red
1062=Target Random Grey
1063=Target Random Blue
1064=Target Random Enemy
1065=Target Random Friendly
1066=Target Random Non-Friendly
1067=Say "{0}"
1068=UseSkill {0}
1069=CastSpell {0}
1070=SetAbility {0}
1071=Dress: {0}
1072=Undress: {0}
1073=Unequip Layer {0}
1074=Wait for Menu (Any)
1075=Wait for Menu (#{0})
1076=Configura
1077=Wait For Gump (Any)
1078=Wait for Gump (#{0})
1079=Wait for Target
1080=Pause {0:#.00}sec
1081=Wait for {0} {1} {2}
1082=Loading '{0}'...
1083=> Ferma Macro Corrente
1084=Play: {0}
1085=Macro '{0}' iniziata...
1086=Macro '{0}' terminata.
1087=Razor was unable to initialize.  Error code:\n
1088=Description: Could not find the client Window Handle.\nPossible Cause: The Client may not have initialized properly.
1089=Description: Could not find the Client's ThreadID\nPossible Cause: The Client may not have initialized Properly.
1090=Description: Could not create Windows Hooks.\nPossible Cause: Internal error.
1091=Description: Could not create or access Razor shared memory.\nPossible Cause: Windows Error or invalid permissions.
1092=Description: Crypt.dll has disabled itself.\nPossible Cause: Version mismatch.
1093=Description: Could not patch the client's Winsock functions.\nPossible Cause: Internal error, Windows Error, or Incompatible Version.
1094=
1095=Warning: Could not copy packet lengths and/or encryption information from the client.\nRazor may be able to run without this information, though some features may not function correctly.  Would you like to start Razor anyway?\n\nPossible Cause: Your client version may not be compatible with this version of Razor.
1096=La tua skill {0} e' cambiata di {1}{2:F1}, ora e' {3:F1}.
1097=Invalid abbreviation.
1098=Invalid item id.
1099=Invalid hue.
1100=Seleziona item da contare.
1101=Errore caricamento '{0}'!\nQuesto profilo e' corrotto e non puo' essere usato.
1102=La proprieta' {0} non e' stata trovata nel profilo.
1103=Il file counters.xml e' corrotto e non puo' essere usato.
1104=Siccome hai l'Auto Search Containers off, riapri le borse per far si' che il contatore si aggiorni.
1105=Attenzione: la quantita' di {0} e' ora {1}!
1106=Scegli il colore da usare.
1107=Fotografa Ora
//1108=Possible values:\n{char} - nome Character\n{shard} - nome Shard\n{str}/{hp}/{hpmax} - Status Salute\n{dex}/{stam}/{stammax} - Status Dex\n{int}/{mana}/{manamax} - Status Int\n{weight}/{maxweight} - Weight information\n{gold} - Total Gold on character\n{AR} - Armor Rating / Physical Resistance\n{tithe} - Tithing points\n{bandage} - Bandage Timer\n{statbar}/{mediumstatbar}/{largestatbar} - Status bar\n{crimtime} - How long you have been a criminal\n{stealthsteps} - Stealth steps counterColor - HTML hex color code: '~#rrggbb' ('~#~' to terminate)\nOr a {Format} from the Counters list
1109=Versione Razor: {0} (ITA by Tyler - UOD)\nMemoria usata: {1}\nInv: {2} ({3}/s)\nRicev: {4} ({5}/s)\nConnesso da {6}\n\nPlayer Serial: 0x{7:X8}\nBackpack Serial: 0x{8:X8}\n\nTracking Items: {9}\nTracking Mobs: {10}\n
1110=Set Lock: UP
1111=Set Lock: DOWN
1112=Set Lock: LOCKED
1113=Sei sicuro di voler rimuovere il counter "{0}"?\nL'effetto avverra' su tutti i profili.
1114=Caricare profilo "{0}" ora?
1115=Errore nel caricamento del profilo.
1116=Non puo cancellare il profilo Default.
1117=Inserisci nome del nuovo profilo: 
1118=Impossibile creare nuovo profilo!\n Motivo: Esiste gia' un profilo con questo nome.\n\nVuoi caricare quel profilo ora?
1119=Inserire nome della nuova list:
1120=Cancellare questa list?
1121={0:X} (Item fuori range)
1122=Cancellare questo item dalla list?
1123=Seleziona borsa per l'Undress in '{0}'.
1124=Settata borsa Undress.
1125=Item non trovato o item non valido.
1126=Questa combinazione appartiene a '{0}'.\nCambiare a '{1}'?
1127=Salvataggio effettuato.
1128=Warning!\nLogging packets may reduce Razor's performance. Log files can also\neasily grow very large, and Razor will not automatically remove them.\n\nRazor's packet log files may contain personal information such as\npasswords, and should be not be given to people you do not trust.\n\nAre you sure you want to enable packet logging?\n(This will not be saved in your user profile)
1129=Converti Selected a TYPE
1130=Inserisci nome della nuova macro: 
1131=Il nome contiene caratteri non validi.
1132=C'e' gia' una macro con questo nome.
1133=Questa macro sara' pulita prima di registrare.\nSei sicuro di voler registrare la macro?
1134=Sei sicuro di voler cancellare definitvamente '{0}'?
1135=Inserisci Pausa...
1136=Inserisci Set LastTarget
1137=Muovi su
1138=Muovi giu
1139=Rimuovi Azione
1140=Registra da qui
1141=Il file '{0}' non e' stato trovato.
1142=Sei sicuro?
1143=Attenzione: The following {0} file{1} count non e' cancellato:\n{2}
1144=Questo cambiamento avra' effetto al prossimo riavvio.
1145=Abilitando questa opzione, Razor salvera' le tue password nel tuo profilo.\nAnche se le password sono crittate, e' possibile usarle avendo accesso al file xml del profilo.\nSei sicuro di voler attivare questa funzione?
1146=Devi specificare una porta valida.
1147=Ignorata richiesta di azione (gia' in coda).
1148=Accodate {0}... {1} left.
1149=Eseguite {0} azioni in {1:F1} secondi.
1150=Use Once Agent
1151=Aggiungi(Target)
1152=Contenitore(Target)
1153=Rimuovi(Target)
1154=Pulisci Lista
1155=Seleziona item da aggiungere.
1156=Seleziona Contenitore.
1157=Seleziona item da rimuovere.
1158=Item aggiunto.
1159=Item rimosso.
1160={0} item(s) aggiunti all'UseOnce Agent.
1161=La UseOnceQueue e' vuota!
1162=Using '{0}'.  ({1} item(s) left in the UseOnce queue)
1163=C'e' stato un problema con un UseOnce item, proviamo col prossimo.
1164=SellAgent: Sta vendendo {0} item(s) per {1}gp.
1165=Rimuovi
1166=Container settato con successo.
1167=Pulisci
1168=(Premi per Disattivare)
1169=(Premi per Attivare)
1170=Setta Hot Bag
1171=Pulisci HotBag
1172=Organizer Agent
1173=Organizer
1174=Organizza Ora
1175=Contenitore non settato.
1176=Razor non trova il tuo backpack.
1177=L'OrganizeAgent ha accodato {0} item(s) per essere mossi. (Puo' richiedere alcuni minuti)
1178=L'OrganizeAgent non ha trovato item da muovere.
1179=Questo item e' gia nella list.
1180=AutoSearchExemptions
1181=Buy Agent ha comprato {0} item(s) per {1}gp.
1182=Il BuyAgent non puo' comprare gli oggetti della BuyList perche' non hai abbastanza soldi.
1183=Inserisci num:
1184=Priorita' Client settato a {0}
1185=Il tempo e': {0}
1186=Tu sei al {0} in '{1}'
1187=Borsa Undress non trovata, usato il backpack.
1188={0} item(s) accodato per essere non-equipaggiato.
1189={0} item(s) accodato per essere equipaggiato.
1190={0} item(s) gia' equipaggiato.
1191={0} item(s) were not found. (Out of Range)
1192=Attenzione: Spells.def non trovato, il formato di testo non sara' mostrato
1193=Passi Stealth: {0}
1194=Inizio conta passi Stealth.
1195=Pulisci TargetQueue
1196=AttackLast
1197=TargetQueue pulita.
1198=Seleziona un nuovo 'Last Target'
1199=Last Target set.
1200=New target set.
1201=Nulla di corrispondente trovato.
1202=Queued target self.
1203=Queued last target.
1204=Il Server ha inviato nuovo target, cancellato il target di Razor.
1205=Target by Type {0}
1206=Scavenger
1207=Sei sicuro di voler cancellare questo?
1208=Seleziona cartella per i Razor ScreenShot.
1209=Tasti
1210=Oggetti
1211=Targets
1212=Agenti
1213=Dress
1214=Macro
1215=Spells
1216=Skills
1217=Misc
// 1219 - 1250 reserved
1251=1st
1252=2nd
1253=3rd
1254=4th
1255=5th
1256=6th
1257=7th
1258=8th
// 1259 not used
1260=Necromancy
// 1261 - 1269 not used
1270=Chivalry
1271=Potions
1272=Special Moves
// 1273 - 1299 reserved
1373=UseOnce
1301=Vendi
1302=Compra
1303=Input Richiesto
1304=Lista Comandi Razor
1305=Usa l'oggetto in mano
1306=Devi disarmare l'oggetto prima di poterlo riarmare.
1307=Arm/Disarm Mano Destra
1308=Arm/Disarm Mano Sinistra
1309=Lascia quel che stai tenendo

1311=> Attiva/Disattiva Macro Razor
1312=Macro Attivate({0} per disattivare)
1313=Macro Disattivate ({0} per attivare)
1314=MAcro Attive
1315=Macro Inattive
1316=Walk: {0}
1317=Add Type (Target)...
1318=Il target richiesto e' fuori range, LastTarget non eseguito!
1319=Max Sell: {0}


================================================
FILE: etc/Language/Razor_lang.pl
================================================
// Razor Polish/PL Language Pack
// Last Modified August 5, 2007
// Author: exile (exile(at)team-voe.com)
::CliLoc=ENU

[controls]
WelcomeForm::Text=Razor wita!
WelcomeForm::groupBox3=Katalog UO
WelcomeForm::dataBrowse=Wskaz
WelcomeForm::label5=Jezyk:
WelcomeForm::groupBox2=Serwer
WelcomeForm::label3=Serwer:
WelcomeForm::label4=Port:
WelcomeForm::groupBox1=Opcje klienta.
WelcomeForm::useEnc=Uzywaj kodowania OSI
WelcomeForm::makeDef=Zapisz domyslne ustawienia
WelcomeForm::browse=Wskaz
WelcomeForm::label1=Klient:
WelcomeForm::patchEncy=Usun kodowanie
WelcomeForm::showAtStart=Pokazuj to okno na poczatku
WelcomeForm::quit=&Zamknij
WelcomeForm::okay=&OK

MainForm::Text=Razor
MainForm::generalTab=Glowne
MainForm::label10=Uaktualnij
MainForm::systray=Tray systemowy
MainForm::taskbar=Pasek zadan
MainForm::smartCPU=Zmniejszenie obciazenia CPU
MainForm::label7=Jezyk:
MainForm::label11=Pokazuj na:
MainForm::groupBox4=Profile
MainForm::delProfile=Skasuj
MainForm::newProfile=&Nowy...
MainForm::showWelcome=Pokazuj ekran powitalny
MainForm::alwaysTop=Zawsze na wierzchu
MainForm::groupBox1=Filtry
MainForm::opacityLabel=Przenikanie: 100%
MainForm::moreOptTab=Opcje
MainForm::setLTHilight=Ustaw
MainForm::lthilight=Podswietlanie ostatniego celu:
MainForm::filterSnoop=Filtruj komunikaty Snoopingu
MainForm::incomingCorpse=Pokazuj nazwy zwlok
MainForm::incomingMob=Pokazuj nazwy istot
MainForm::setHarmHue=Ustaw
MainForm::setNeuHue=Ustaw
MainForm::lblHarmHue=Wrog
MainForm::lblNeuHue=Neutralny
MainForm::lblBeneHue=Sojusznik
MainForm::setBeneHue=Ustaw
MainForm::setSpeechHue=Ustaw
MainForm::setWarnHue=Ustaw
MainForm::setMsgHue=Ustaw
MainForm::setExHue=Ustaw
MainForm::autoStackRes=Automatycznie sortuj surowce
MainForm::queueTargets=Kolejkuj LastTarget i TargetSelf
MainForm::spamFilter=Filtruj powtarzajace sie wiadomosci
MainForm::label4=kratek
MainForm::openCorpses=Otworz ciala w zasiegu
MainForm::showNotoHue=Koloruj imie na pasku tytulowym
MainForm::lblWarnHue=Barwa ostrzezenia
MainForm::lblMsgHue=Barwa wiadomosci Razora
MainForm::lblExHue=Barwa Agenta przeszukiwania
MainForm::blockDis=Blokuj zsiadanie w trybie walki
MainForm::chkForceSpellHue=Kolor czarow:
MainForm::chkForceSpeechHue=Kolor mowy:
MainForm::label3=Format czarow:
MainForm::moreMoreOptTab=Wiecej opcji
MainForm::label18=Rozdzielczosc:
MainForm::label17=Komunikaty Razora:
MainForm::QueueActions=Auto-kolejkowanie czynnosci 
MainForm::spellUnequip=Czarowanie bez broni
MainForm::autoOpenDoors=Auto-otwieranie drzwi
MainForm::alwaysStealth=Pokazuj ilosc krokow stealth
MainForm::autoFriend=Czlonek Party jako Przyjaciel
MainForm::chkStealth=Licz kroki stealth
MainForm::rememberPwds=Pamietaj hasla
MainForm::showtargtext=Pokazuj typ celu po kliknieciu
MainForm::smartLT=Uzyj sprytnego LastTarget
MainForm::preAOSstatbar=Uzywaj malego statusu
MainForm::logPackets=Logowanie pakietow
MainForm::warnCount=Ostrzegaj gdy licznik ponizej:
MainForm::rangeCheckLT=Zasieg LastTarget:
MainForm::actionStatusMsg=Pokazuj komunikaty kolejki
MainForm::label5=Opoznienie:
MainForm::label9=Priorytet klienta:
MainForm::label8=kratek
MainForm::label6=ms
MainForm::displayTab=Liczniki
MainForm::excludePouches=Nie przeszukuj mieszkow
MainForm::highlightSpellReags=Podswietlaj skladniki
MainForm::titlebarImages=Pokazuj ikony przedmiotow
MainForm::sortCounters=Sortuj wyswietlane rzeczy
MainForm::checkNewConts=Przeszukuj nowe kontenery
MainForm::groupBox3=Wyswietlanie na pasku
MainForm::showInBar=Pokazuj na pasku UO:
MainForm::groupBox2=Liczniki
MainForm::delCounter=Usun/Edycja
MainForm::addCounter=Dodaj
MainForm::recount=Przelicz
MainForm::dressTab=Ubieranie
MainForm::groupBox6=Ubierz/Uzbroj
MainForm::clearDress=Wyczysc liste
MainForm::dressDelSel=Usun
MainForm::undressBag=Zmien torbe na rzeczy
MainForm::undressList=Rozbierz
MainForm::dressUseCur=Dodaj obecne
MainForm::targItem=Dodaj (Cel)
MainForm::dressNow=Ubierz
MainForm::groupBox5=Wybor
MainForm::removeDress=Usun
MainForm::addDress=Dodaj
MainForm::undressConflicts=Przesun kolidujace przedmioty
MainForm::skillsTab=Umiejetnosci
MainForm::dispDelta=Pokaz zmiany
MainForm::skillCopyAll=Kopiuj calosc
MainForm::skillCopySel=Kopiuj wybor
MainForm::label1=Suma:
MainForm::setlocks=Blokuj:
MainForm::resetDelta=Reset  +/-
MainForm::agentsTab=Agenci
MainForm::hotkeysTab=Klawiatura
MainForm::dohotkey=Wykonaj wybrane
MainForm::groupBox8=Klawisz
MainForm::chkPass=Przekaz do UO
MainForm::label2=Klawisz:
MainForm::unsetHK=Usun
MainForm::setHK=Ustaw
MainForm::chkCtrl=Ctrl
MainForm::chkAlt=Alt
MainForm::chkShift=Shift
MainForm::macrosTab=Makra
MainForm::macroActGroup=Akcje
MainForm::loopMacro=Petla
MainForm::recMacro=Nagraj
MainForm::playMacro=Odtworz
MainForm::delMacro=Usun
MainForm::newMacro=Nowe
MainForm::screenshotTab=Zrzut ekranu
MainForm::label12=Format:
MainForm::capNow=Zrob teraz
MainForm::radioUO=Tylko UO
MainForm::radioFull=Pelen ekran
MainForm::screenAutoCap=Automatycznie przy smierci
MainForm::setScnPath=...
MainForm::dispTime=Dodaj date i czas
MainForm::videoTab=Nagrywanie Video
MainForm::recFolder=...
MainForm::label13=Folder nagran:
MainForm::groupBox7=Nagrywanie PacketVideo
MainForm::vidRec=Nagraj PacketVideo
MainForm::groupBox10=Nagrywanie AVI
MainForm::recAVI=Nagraj AVI...
MainForm::label16=Rozdzielczosc:
MainForm::label15=FPS:
MainForm::groupBox9=Odtwarzanie PacketVideo
MainForm::label14=Predkosc:
MainForm::vidClose=Zamknij
MainForm::vidPlayStop=Stop
MainForm::vidPlay=Pusc
MainForm::vidOpen=Otworz...
MainForm::statusTab=Pomoc
MainForm::rebirth=Jedyny PreT2A Shard
MainForm::visitForums=Forum Pomocy i wsparcia
MainForm::visitHome=Strona Razor'a
MainForm::visitGuide=Podrecznik Razor'a

HueEntry::Text=Wybierz barwe
HueEntry::cancel=Przerwij
HueEntry::okay=&Okay
HueEntry::preview=Podglad
HueEntry::inGame=Wybierz w grze
HueEntry::label1=Numer barwy:

AddCounter::Text=Dodaj licznik
AddCounter::delete=Skasuj
AddCounter::target=Cel 
AddCounter::cancel=Przerwij
AddCounter::Add=&Okay
AddCounter::label4=Kolor (obojetnie: -1):
AddCounter::label3=ID przedmiotu:
AddCounter::label2=Format:
AddCounter::label1=Nazwa:

MacroInsertWait::Text=Insert Wait/Pause...
MacroInsertWait::radioMenu=Wait for old-style Menu/Dialog
MacroInsertWait::cancel=&Cancel
MacroInsertWait::radioStat=Wait for 
MacroInsertWait::radioTarg=Wait for Target
MacroInsertWait::radioGump=Wait for Gump
MacroInsertWait::label1=millisekund
MacroInsertWait::radioPause=Pause na:
MacroInsertWait::insert=&Wstaw

MacroInsertIf::Text=Wstaw If...
MacroInsertIf::label1=If:
MacroInsertIf::cancel=&przerwij
MacroInsertIf::insert=&wstaw



[strings]
1001=Status smierci
1002=Muzyka barda
1003=Dzwiek psa
1004=Dzwiek kota
1005=Dzwiek konia
1006=Dzwiek owcy
1007=Dzwiek Spirit Speak
1008=Dzwiek czaru
1009=Pogoda
1010=Wyswietl liczniki
1011=Przelicz liczniki
1012=Wyczysc Umiejetnosc AOS
1013=Ustaw pierwsza umiejetnosc (AOS)
1014=Ustaw druga umiejetnosc (AOS)
1015=wlacz ogluszanie (Pre-AOS)
1016=Wlacz rozbrajanie(Pre-AOS)
1017=Ustawiam umiejetnosc {0}
1018=Umiejetnosci AOS wyczyszczone.
1019=Zdejmij wszystko
1020=Oproznij obie rece
1021=Oproznij lewa dlon
1022=Oproznij prawa dlon
1023=Zdejmij nakrycie glowy
1024=Zdejmij nizuterie
1025=Bandazuj siebie
1026=Bandazuj Ostatni cel
1027=Uzyj bandaza
1028=Drink Heal
1029=Drink Cure
1030=Drink Refresh
1031=Drink Night Sight
1032=Drink Explosion
1033=Drink Strength
1034=Drink Agility
1035=Brak bandazy
1036=Brak przedmiotu typu {0}!
1037=Double Click ({0})
1038=Re-Target
1039=Convert to DClick by Type
1040=Select a new target this Action.
1041=WARNING: Exception while loading profile property:\n{0}
1042=Macro Warning: Cannot find that item (Out of Range).
1043=Lift {1} - {0}
1044=Convert to Lift by Type
1045=Macro Warning: Not holding anything.
1046=Equip to {0} (L:{1})
1047=Drop to {0} (@{1})
1048=Convert to Relative Location
1049=Drop (Relative) @({0},{1},{2})
1050=GumpResponse (Button {0})
1051=Close Gump
1052=MenuResponse {0}
1053=Warning: Macro requested target, but no target sent from server! (Do you need a 'WaitForTarget'?)
1054=Absolute Target
1055=Convert to LastTarget
1056=Convert to Target by Type
1057=Target RelLoc ({0},{1})
1058=Ostatni Cel
1059=Wskaz siebie
1060=Wskaz Ostatni Cel
1061=Wskaz dowolnego Reda
1062=Wskaz dowolnego Crima
1063=Wskaz dowolnego Blue
1064=Wskaz dowolnego wroga
1065=Wskaz dowolnego przyjaciela
1066=Wskaz dowolnego nieprzyjaciela
1067=Mow "{0}"
1068=UseSkill {0}
1069=CastSpell {0}
1070=SetAbility {0}
1071=Ubierz: {0}
1072=Rozbierz: {0}
1073=Unequip Layer {0}
1074=Wait for Menu (Any)
1075=Wait for Menu (#{0})
1076=Edycja...
1077=Wait For Gump (Any)
1078=Wait for Gump (#{0})
1079=Wait for Target
1080=Pause {0:#.00}sec
1081=Wait for {0} {1} {2}
1082=Loading '{0}'...
1083=> Zatrzymaj makro
1084=Play: {0}
1085=Makro '{0}'...
1086=Makro '{0}' zakonczone.
1087=Razor was unable to initialize.  Error code:\n
1088=Description: Could not find the client Window Handle.\nPossible Cause: The Client may not have initialized properly.
1089=Description: Could not find the Client's ThreadID\nPossible Cause: The Client may not have initialized Properly.
1090=Description: Could not create Windows Hooks.\nPossible Cause: Internal error.
1091=Description: Could not create or access Razor shared memory.\nPossible Cause: Windows Error or invalid permissions.
1092=Description: Crypt.dll has disabled itself.\nPossible Cause: Version mismatch.
1093=Description: Could not patch the client's Winsock functions.\nPossible Cause: Internal error, Windows Error, or Incompatible Version.
1094=
1095=Warning: Could not copy packet lengths and/or encryption information from the client.\nRazor may be able to run without this information, though some features may not function correctly.  Would you like to start Razor anyway?\n\nPossible Cause: Your client version may not be compatible with this version of Razor.
1096=Umiejetnosc {0} wzrosla o {4}{5:F1}, wynosi teraz {3:F1} ({1}{2:F1}).
1097=Zly skrot.
1098=Zle id przedmotu.
1099=Zla barwa.
1100=Wybierz przedmiot do liczenia.
1101=Error loading '{0}'!\nThis profile is corrupt and cannot be used.
1102=The property {0} was not found in this profile.
1103=Your counters.xml file is corrupt and cannot be used.
1104=Because you have Auto Search Containers off, you must now reopen all of your bags so that your counters can be updated.
1105=Uwaga: Ilosc {0} = {1}!
1106=Wybierz barwe.
1107=Zrob zrzut ekranu
//1108=Mozliwe wartosci:\n{char} - imie postaci\n{shard} - nazwa shardu\n{str}/{hp}/{hpmax} - stan zdrowia\n{dex}/{stam}/{stammax} - stan staminy\n{int}/{mana}/{manamax} - stan many\n{weight}/{maxweight} - waga\n{gold} - ilosc zlota\n{AR} - Armor Rating / Physical Resistance\n{tithe} - Tithing points\n{bandage} - Bandage Timer\n{statbar}/{mediumstatbar}/{largestatbar} - Pasek statusu\n{crimtime} - czas bycia przestepca\n{stealthsteps} - ilosc krokow stealth\nKolor - kod HTML hex : '~#rrggbb' ('~#~' konczy)\nlub {Format} z listy liczniko
1109=Wersja Razora: {0}\nUzyta pamiec: {1}\nWyslano: {2} ({3}/s)\nOdebrano: {4} ({5}/s)\nPolaczony {6}\n\nSerial gracza: 0x{7:X8}\nSerial plecaka: 0x{8:X8}\n\nSledzone przedmioty: {9}\nSledzone Moby: {10}\n
1110=Blokada: GORA
1111=Blokada: DOL
1112=Blokada: BLOKUJ
1113=Czy chcesz usunac licznik "{0}"?\nTo dotyczy kazdego profilu.
1114=Wczytac profil "{0}"?
1115=Blad przy wczytywaniu profilu.
1116=Nie usuniesz domyslnego profilu.
1117=Nazwa nowego profilu: 
1118=Blad przy tworzeniu profilu!\n Powod: profil o tej nazwie istnieje.\n\nWczytac ten profil?
1119=Wpisz nazwe listy Ubiorow:
1120=Usunac ta liste?
1121={0:X} (Poza zasiegiem)
1122=Usunac przedmiot z listy?
1123=Gdzie wlozyc rzeczy z listy  '{0}'?
1124=Pojemnik ustawiony.
1125=Obiekt nie znaleziony lub bledny
1126=Te klawisze przypisano juz do '{0}'.\nZmienic na '{1}'?
1127=Zapisano dane.
1128=Uwaga!\nLogowanie pakietow moze obnizyc wydajnosc. Log moze bardzo szybko osiagnac duzy rozmiar, a Razor ich nie usuwa.\n\nLog Razora moze zawierac poufne dane takie jak haslo,\n i nie powinien byc pokazywany osobom postronnym.\n\nNapewno wlaczyc logowanie?\n(Tylko dla tego profilu)
1129=Convert Selected to TYPE
1130=Nazwa nowego makra: 
1131=Nazwa zawiera niepoprawne znaki.
1132=Makro o tej nazwie juz istnieje.
1133=Makro zostanie wyczyszczone przed nagraniem.\nCzy napewno usunac zawartosc i nagrac nowa?
1134=Napewno usunac '{0}'?\n(Nie da sie tego cofnac)
1135=Wstaw 'Pause/Wait...'
1136=Wstaw 'Wybierz LastTarget'
1137=W gore
1138=W dol
1139=Usun akcje
1140=Nagrywaj od tego momentu
1141=Nie znaleziono pliku '{0}'.
1142=Jestes pewien?
1143=Uwaga: Nastepujace {0} plik(i){1} nie moga zostac skasowane:\n{2}
1144=Zmiana bedzie dzialac po restarcie Razor'a.
1145=Wlaczenie tej opcji sprawi, ze Razor zapisze haslo  w pliku profilu.\nMimo, ze hasla sa kodowane istnieje niebezpieczenstwo.\nCzy napewno wlaczyc ta opcje?
1146=Musisz podac poprawny port.
1147=Ignoruje zadanie (juz w kolejce).
1148=Kolejkuje zadanie {0}... pozostalo {1}.
1149=Zakonczono {0} zakolejkowanych zadan w {1:F1} sekund.
1150=Uzyj Once Agent
1151=Dodaj (Wskaz)...
1152=Dodaj pojemnik (Wskaz)...
1153=Skasuj (Wskaz)...
1154=Czysc liste
1155=Wskaz przedmiot do dodania.
1156=Wskaz pojemnik.
1157=Wskaz przedmiot do skasowania.
1158=Przedmiot dodany.
1159=Przedmiot skasowany.
1160={0} item(s) added to the Use Once agent.
1161=The UseOnce queue is empty!
1162=Using '{0}'.  ({1} item(s) left in the UseOnce queue)
1163=There was a problem with one of your UseOnce items, trying the next one.
1164=SellAgent: Automatically selling {0} item(s) for {1}gp.
1165=Remove
1166=Container set successfully.
1167=Clear
1168=(Push to Disable)
1169=(Push to Enable)
1170=Set Hot Bag
1171=Clear Hot Bag
1172=Organizer Agent
1173=Organizer
1174=Organize Now
1175=Container not set.
1176=Razor nie moze odnalezc plecaka.
1177=Organize Agent queued {0} item(s) to be moved. (This may take a few moments)
1178=Organize Agent did not find any items to move.
1179=Przedmiot jest juz na liscie.
1180=AutoSearchExemptions
1181=Agent kupowania zakupil {0} item(ow) za {1}gp.
1182=Agent kupowania nie zadzialal, poniewaz nie posiadasz przy sobie odpowiedniej ilosci zlota.
1183=Wpisz liczbe:
1184=Prioryte klienta ustawiono na {0}
1185=The current time is: {0}
1186=You are at {0} in '{1}'
1187=Undress bag was not found or out of range, using your backpack instead.
1188={0} item(s) queued to be de-equipped.
1189={0} item(s) queued to be equipped.
1190={0} item(s) already equipped.
1191={0} item(s) were not found. (Out of Range)
1192=Warning: Spells.def not found, spell format text will not be shown
1193=Krokow : {0}
1194=Zaczynam liczyc kroki.
1195=Oczysc kolejke celow
1196=Atakuj ostatniego wroga
1197=Kolejka celow ocyzscyona.
1198=Wskay nowy 'Ostatni Cel'
1199=Ostatni Cel ustawiony.
1200=Nowy cel ustawiony.
1201=Brak odpowiadajacych celi na ekranie.
1202=Zakolejkowano TargetSelf.
1203=Zakolejkowano LastTarget.
1204=Server nadeslal nowy cel, anuluje cel Razor'a.
1205=Cel wedlug typu {0}
1206=Scavenger
1207=Jestes pewien, ze chcesz to skasowac?
1208=Wskaz folder do przechowywania obrazow.
1209=Klawiatura
1210=Przedmioty
1211=Cele
1212=Agenci
1213=Ubierz
1214=Makra
1215=Czary
1216=Umiejetnosci
1217=Dodatkowe
1251=Pierwszy
1252=Drugi
1253=Trzeci
1254=Czwarty
1255=Piaty
1256=Szosty
1257=Siodmy
1258=Osmy
1260=Necromancy
1270=Chivalry
1271=Mikstury
1272=Ataki specjalne
1290=Bushido
1300=Ninjitsu
1301=Sprzedaj
1302=Kup
1303=Input Required
1304=Lista komend
1305=Uzyj trzymanego przedmiotu
1306=Musisz cos wyjac z reki aby moc to pozniej wlozyc.
1307=Arm/Disarm - Prawa reka
1308=Arm/Disarm - Lewa reka
1309=Wyrzuc to co aktualnie trzymasz

1311=> Enable/Disable Razor HotKeys
1312=Hot Keys wlaczone (Wcisnij {0} by anulowac)
1313=Hot Keys wylaczone (Wcisnij {0} by wlaczyc)
1314=Hot Keys Wlaczone
1315=Hot Keys Wylaczone
1316=Walk: {0}
1317=Add Type (Target)...
1318=Wybrany Cel jest po za zasiegiem, anulowano!
1319=Max Sell: {0}
1320=Snooping Messages
1321=Backpack Sounds
1322=Wstaw "If" Conditional
1323=Wstaw "Else"
1324=Wstaw "End If"
1325=Set Amount
1326=Restock
1327=Restock Now
1328=Restock Agent
1329=Target a container to restock from, or target yourself to use your bank box.
1330=Wskazano bledny pojemnik.
1331=Restock done, queued {0} item{1}.
1332=Anuluj wybrany cel
1333=Nowa wersja Razor'a jest dostepna\n\nChcesz odwiedzic strone Razor'a i ja pobrac?
1334=Wgraj ponownie
1335=Zapisz
1336=UWAGA: Wybrany cel nie pozwala na wskazanie ziemi.  Ostatni Cel niezakonczony.
1337=Resynchronizuj klienta
1338=Zsiadanie zablokowane.
1339=Rozpocznij nagrywanie "PacketVideo"
1340=Zatrzymaj nagrywanie/odtwarzanie "PacketVideo"
1341=Blad przy nagrywaniu.\nZdarzenie zalogowane.
1342=Plik niezgodny z ta wersja Razor'a.  Upewnij sie, ze masz najnowszego Razor'a.
1343=Plik video uszkodzony.\nMoze byc niekompatybilny.\nPlik nie zostanie odtworzony.
1344=Wystapil problem przy otwieraniu pliku. Moze byc uszkodzony lub niekompletny.
1345=Nazwa kategorii:
1346=Nie mozna skasowac katalogu.  Upewnij sie, ze jest pusty.
1347=Nie mozna stworzyc katalogu.  Upewnij sie, ze wprowadziles poprawna nazwe.
1348=Nie mozna przeniesc makra.  Upenij sie, ze podales poprawna kategorie.
1349=Przyjaciele
// 1350 to 1359 reserved (max length 15!)
1350=Stopped
1351=The End
1352=Game Over
1353=Spi czy umarl?
1354=Got corp por?
1355=bamboozled
1356=pwned?
1357=Jesus <3s you
1358=Kal Vas Pwned
1359=SMACKDOWN
1360=Kogo dodac do listy przyjaciol.
1361=Kogo usunac z listy przyjaciol.
1362=Przyjaciel dodany.
1363=Przyjaciel usuniety.
1364=Special Constructs
1365=Wstaw "For Loop"
1366=Wstawt "End For"
1367=Podaj liczbe powtorzen:
1368=Oczysc Cache
1369=Ostatni Czar
1370=Ostatnia umiejetnosc
1371=Ostatni przedmiot
1372=Pokaz imiona
1373=UzyjRaz
1374=Wskaz dowolny cel
1375=Wskaz dowolnego crima
1376=Wskaz dowolnego niewinnego
1377=Wskaz dowlonego crima
1378=Wskaz dowolnego crima
1379=UWAGA: Drag/Drop timeout! Odkladanie przedmiotu z reki do plecaka.
1380=Musisz zrestartowac Razora i klienta aby zmiany odniosly efekt.
1381=Musisz sie przelogowac aby to dzialalo poprawnie.
1382=Queuing dragdrop request {0}... {1} left.
1383=Polecenie restock w kolejce....
1384=Twoja sila wzrosla o {0}{1}, i wynosi {2}.
1385=Twoja zrecznosc wzrosla o {0}{1}, i wynosi {2}.
1386=Twoja inteligencja wzrosla o {0}{1}, i wynosi {2}.
1387=Jednolite oswietlenie
1388=Leczenie wstrzymane (cel jest zatruty)!
1389=Czyszczenie kolejki drag/drop
1390=Przerwij
1391=>Ulecz sie
1392=Nastepny Cel
1393=Set Restock HotBag
1394=Dodaj do UzyjRaz
1395=Atakuj ostatni cel
1396=Edit Timeout...
1397=Nie masz nic w rekach.
1398=Niedozwolone
1399=Dozwolone
1400=Opcje uzgadniane z serwerem:
1401=Wszystkie opcje dozwolone.
1402=Filtr Pogody
1403=Filtr oswietlenia
1404=Inteligentny OstatniCel
1405=Spr. odleglosci OstatniegoCelu
1406=Auto-Otwieranie Drzwi
1407=Rozbroj przed uzyciem czaru
1408=Auto-Uzbrajanie po wypiciu mikstury
1409=Blokuj Leczenie gdy zatruty
1410=Zapetl Makro
1411=UzyjRaz Agent
1412=Restock Agent
1413=Sell Agent
1414=Buy Agent
1415=Klawisze Mikstur
1416=Rozne Cele
1417=Liczba HP nad glowa/Wyswietl Statystyki
// up to 1465: reserved
1466=Funkcja niedozwolona przez serwer.
1467=Funkcja ta jest niedozwolona przez aktualny serwer..\nMozesz wybrac opcje ignorowania wiadomosci Serwera w zakladce "Opcje".\n\nBy sprawdzic liste niedozwolonych funkcji przejdz do zakladki "Help & Status".
1468=Wstaw komentarz
1469=Dodaj przyjaciela
1470=Skasuja przyjaciela
1471=> Mini-Leczenie/Odtruwanie siebie
1472=Wylacz opcje "Patch Encryption" jesli uzywasz klienta ktory ma juz wylaczona enkrypcje.  Opcja ta powinna byc wlaczona jesli grasz na serwerach uzywajacych enkrypcji klienta (np. oficjalne serwery OSI/EA).\nJesli nie jestes pewny wyboru, NIEODZNACZAJ tej opcji.\n\nNa pewno chcesz wylaczyc enkrypcje klienta?
1473=Zsiadanie z konia
1474=Pokaz/Schowaj okno Mapy
1475=Cel jest zbyt daleko.
1476=Kolejka drag/drop jest PELNA! Prosze zaczekac.
1477=Tryb walki
1478=Gumpy nagrod
1479=Rozmiar okna gry jest bledny. Sprobuj ponownie.
1480=(Scavenger HotBag)
1481=(Restock HotBag {0})
1482=(UzyjRaz #{0})
1483=(Sell Agent HotBag)
1484=(Organizer {0} HotBag)
1485=Adres serwera ktory wpisales jest nieosiagalny.
1486=Druzyna: Akceptuj zaproszenie
1487=Druzyna: Odrzuc zaproszenie
1488=Szkodliwy Cel
1489=Przyjazny Cel
1490=(Przyjaciel)
1491=Rozpocznij odtad
1492=Wczytywanie...
1493=Wczytywanie standardowego profilu...
1494=Wczytywanie Klienta...
1495=Oczekiwanie na start Klienta...
1496=Nie zapomnij o donate!
1497=Razor wita!
1498=Klient 2D (Auto wykrywanie)
1499=Klient 3D (Auto wykrywanie)
1500=(Auto wykrywanie)
1501=Nieprzezroczystosc: {0}%
1502=Wskaz nowa wartosc oczekiwania dla tej czynnosci (w sekundach):
1503=nieprzypisane
1504=Zmien wartosc oczekiwania
1505=Wpisz nazwe
1506=Niepoprawnie.
1507=Staff only items
1508={0}'s Statystyki
1509=Zjedz wyczarowane jablko
1510=Wskaz najblizszego Morderce
1511=Wskaz najblizszego Crima
1512=Wskaz najblizszego niewinnego
1513=Wskaz najblizszego wroga
1514=Wskaz najblizszego przyjaciela
1515=Wskaz najblizszego nieprzyjaciela
1516=Wskaz najblizszego humanoidalnego wroga
1517=Wskaz najblizszego humanoidalnego Crima
1518=Wskaz najblizszego humanoidalnego niewinnego
1519=Wskaz najblizszego humanoidalnego Crima
1520=Wskaz najblizszego Crima
1521=UWAGA: Profil '{0}' jest uzywany przez drugiego Razora!\nJesli wprowadzisz zmiany w tym profilu, dane moga zostac utracone. Zalecane jest uzywanie innych profili do kazdego wlaczonego Razora.


================================================
FILE: etc/Language/Razor_lang.rus
================================================
// Razor Russian/RUS Language Pack
// Last Modified August 13, 2005
// Author : Pavel Tsalkin [Prohor Meletevich] <pinkefir@mail.com>

::Encoding=UTF-8
::CliLoc=RUS

[controls]
WelcomeForm::Text=Добро пожаловать в Razor!
WelcomeForm::groupBox3=Директория UO
WelcomeForm::dataBrowse=Выбрать
WelcomeForm::label5=Язык:
WelcomeForm::groupBox2=Сервер
WelcomeForm::label3=Сервер:
WelcomeForm::label4=Порт:
WelcomeForm::groupBox1=Параметры клиента
WelcomeForm::useEnc=OSI шифрование
WelcomeForm::makeDef=Запомнить эти параметры
WelcomeForm::browse=Выбрать
WelcomeForm::label1=Клиент:
WelcomeForm::patchEncy=Убрать шифрование
WelcomeForm::showAtStart=Показывать при старте
WelcomeForm::quit=&Выход
WelcomeForm::okay=&Okay

MainForm::Text=Razor v{0}
MainForm::generalTab=Основные
MainForm::label10=Пров. обновления:
MainForm::systray=Трей
MainForm::taskbar=Панель задач
MainForm::smartCPU=Понижать скорость для быстрых CPU
MainForm::label7=Язык:
MainForm::label11=Вид:
MainForm::groupBox4=Профили
MainForm::delProfile=Удал.
MainForm::newProfile=&Новый...
MainForm::showWelcome=Начальный диалог (для всех профилей)
MainForm::alwaysTop=Razor всегда поверх окона UO
MainForm::groupBox1=Фильтр
MainForm::opacityLabel= Opacity: 100%
MainForm::moreOptTab=Опции
MainForm::setLTHilight=Установить
MainForm::lthilight=Последняя цель
MainForm::filterSnoop=Фильтр повторных сообщений
MainForm::incomingCorpse=Показывать имена трупов
MainForm::incomingMob=Показывать имена людей/существ
MainForm::smoothWalk=Сглаживать перемещение чара
MainForm::setHarmHue=Уст.
MainForm::setNeuHue=Уст.
MainForm::lblHarmHue=Вредн.
MainForm::lblNeuHue=Нейтр.
MainForm::lblBeneHue=Благотв.
MainForm::setBeneHue=Уст.
MainForm::setSpeechHue=Уст.
MainForm::setWarnHue=Уст.
MainForm::setMsgHue=Уст.
MainForm::setExHue=Уст.
MainForm::autoStackRes=Упорядочивать руду/рыбу/дерево
MainForm::queueTargets=Послед. Цель и Выбр. Себя в очередь
MainForm::spamFilter=Антифлуд системных сообщений
MainForm::label4=тайла
MainForm::openCorpses=Открыв. трупы с расст.
MainForm::showNotoHue=Цвет персонажа в заголовке клиента
MainForm::lblWarnHue=Предупреждения
MainForm::lblMsgHue=Сообщения от Razor
MainForm::lblExHue=Исключ. авто-поиска
MainForm::blockDis=Запретить спешиваться в бою
MainForm::chkForceSpellHue=Цвет заклинания:
MainForm::chkForceSpeechHue=Речь персонажа
MainForm::label3=Формат:
MainForm::moreMoreOptTab=Расширенные
MainForm::blockHealPoison=Не лечить если цель отравленна
MainForm::potionEquip=Раз/во-оружать пред употр. зелья
MainForm::label18=x:
MainForm::gameSize=Размер окна UO:
MainForm::label17=Сообщения Razor:
MainForm::QueueActions=Действия над объектом в очередь
MainForm::spellUnequip=Разоружить перед заклинанием
MainForm::autoOpenDoors=Открывать двери
MainForm::alwaysStealth=Показывать скрытные шаги
MainForm::autoFriend=Члены группы - друзья
MainForm::chkStealth=Подсчет скрытных шагов
MainForm::rememberPwds=Запоминать пароли
MainForm::showtargtext=Флаги цели левым щелчком
MainForm::smartLT=Быстрая последняя цель
MainForm::preAOSstatbar=Окно статуса в старом стиле
MainForm::logPackets=Статистика пакетов
MainForm::warnCount=Извещать если счетчик    <
MainForm::rangeCheckLT=Выбор целей в радиусе:
MainForm::actionStatusMsg=Сообщения об изменен. в очереди
MainForm::label5=в интервале
MainForm::label9=Приоритет клиента:
MainForm::label8=тайл.
MainForm::label6=мс
MainForm::displayTab=Заголовок UO
MainForm::excludePouches=Исключить сумки из поиска
MainForm::highlightSpellReags=Показ. реагенты при заклинании
MainForm::titlebarImages=Иконки на счетчиках в заголовке
MainForm::sortCounters=Сортировать выбранн. счетчики
MainForm::checkNewConts=Авто-поиск новых предметов
MainForm::groupBox3=Заголовок окна клиента UO
MainForm::showInBar=Показывать в заголовке UO:
MainForm::groupBox2=Счетчики
MainForm::delCounter=Измен.
MainForm::addCounter=Новый
MainForm::recount=Считать
MainForm::dressTab=Снаряжение
MainForm::groupBox6=Предметы снаряжения
MainForm::clearDress=Очистить
MainForm::dressDelSel=Убрать
MainForm::undressBag=Сумка для вещей
MainForm::undressList=Снять
MainForm::dressUseCur=Добав. одетое
MainForm::targItem=Добавить цель
MainForm::dressNow=Одет.
MainForm::groupBox5=Списки снаряжения
MainForm::removeDress=Убрать
MainForm::addDress=Добав.
MainForm::undressConflicts=Перемещать кон- фликтующие вещи
MainForm::skillsTab=Умения
MainForm::dispDelta=Показ. разницу
MainForm::skillCopyAll=Копировать все
MainForm::skillCopySel=Копир. выбранное
MainForm::label1=В сумме:
MainForm::setlocks=Уст. на все:
MainForm::resetDelta=Переключить +/-
MainForm::agentsTab=Агенты
MainForm::hotkeysTab=Горячие клавиши
MainForm::dohotkey=Запуск выбранного
MainForm::groupBox8=Горячая клавиша
MainForm::chkPass=Запуск также и в UO 
MainForm::label2=Клв.
MainForm::unsetHK=Убрать
MainForm::setHK=Уст.
MainForm::chkCtrl=Ctrl
MainForm::chkAlt=Alt
MainForm::chkShift=Shift
MainForm::macrosTab=Макрос
MainForm::macroActGroup=Действия
MainForm::loopMacro=Loop
MainForm::recMacro=Запись
MainForm::playMacro=Старт
MainForm::delMacro=Убрать
MainForm::newMacro=Новый
MainForm::screenshotTab=Снимок
MainForm::label12=Формат:
MainForm::capNow=Сделать снимок экрана
MainForm::radioUO=Только UO
MainForm::radioFull=Полн. экран
MainForm::screenAutoCap=Авто-подбор цветности
MainForm::setScnPath=...
MainForm::dispTime=Добавлять дату и время
MainForm::videoTab=Видео
MainForm::recFolder=...
MainForm::label13=Директория записи:
MainForm::groupBox7=Запись PacketVideo
MainForm::vidRec=Записать PacketVideo
MainForm::flipVidVert=Вертик.
MainForm::flipVidHoriz=Горизнт.
MainForm::groupBox10=Запись в AVI файл 
MainForm::recAVI=Записать видео в AVI файл ...
MainForm::label16=Размеры:
MainForm::label15=FPS:
MainForm::label19=Поврт.:
MainForm::groupBox9=Просмотр PacketVideo
MainForm::label14=Скор.
MainForm::vidClose=Закрыть
MainForm::vidPlayStop=Стоп
MainForm::vidPlay=Старт
MainForm::vidOpen=Открыть
MainForm::statusTab=Помощь
MainForm::rebirth=Только PreT2A шард
MainForm::visitForums=Форум Razor
MainForm::visitHome=Домашняя страница Razor
MainForm::visitGuide=Руководство пользователя

HueEntry::Text=Выбрать цвет
HueEntry::cancel=Отмена
HueEntry::okay=&Okay
HueEntry::preview=Просмотр
HueEntry::inGame=Выбрать в игре
HueEntry::label1=Номер цвета


AddCounter::Text=Доб. счетчик
AddCounter::delete=Удалить
AddCounter::target=Цель
AddCounter::cancel=Отмена
AddCounter::Add=&Okay
AddCounter::label4=Цвет (люб. -1):
AddCounter::label3=ID вещи:
AddCounter::label2=Формат:
AddCounter::label1=Имя:

MacroInsertWait::Text=Вставить Ожидание/Пауза...
MacroInsertWait::radioMenu=Ждать меню в старом стиле
MacroInsertWait::cancel=&Отмена
MacroInsertWait::radioStat=Ждать
MacroInsertWait::radioTarg=Ждать цель
MacroInsertWait::radioGump=Ждать меню
MacroInsertWait::label1=мсек.
MacroInsertWait::radioPause=Ожидать
MacroInsertWait::insert=&Вставить

MacroInsertIf::Text=Вставить "If" (Если)...
MacroInsertIf::label1=If:
MacroInsertIf::cancel=&Отмена
MacroInsertIf::insert=&Вставить

[strings]
1001=Статус смерти
1002=Музыка барда
1003=Лай собак
1004=Мяуканье кошек
1005=Ржание лошадей
1006=Блеяние овец
1007=Разговор с духами
1008=Неудачные заклинания
1009=Погода
1010=Показать счетчики
1011=Обновить счетчики
1012=Очистка спец. ударов AOS
1013=Установить основной спец. удар (AOS)
1014=Установить вторичный спец. удар (AOS)
1015=Переключить оглушение (пред-AOS)
1016=Разоружить/Вооружить (пред-AOS)
1017=Устанвливаю спец. удар {0}
1018=Спец. удары AOS очищены.
1019=Снять всё снаряжение
1020=Снять снаряжение с обоих рук
1021=Снять снаряжение с левой руки
1022=Снять снаряжение с правой руки
1023=Снять снаряжение с головы
1024=Снять ювелные изделия
1025=Перевязать себя
1026=Перевязать последнюю цель
1027=Использовать бинты (без подсчета времени)
1028=Выпить зелье Лечения
1029=Выпить зелье Противоядия
1030=Выпить зелье Восстановления
1031=Выпить зелье Ночного Зрения
1032=Бросить зелье Взрыва
1033=Выпить зелье Силы
1034=Выпить зелье Ловкости
1035=У вас нет бинтов
1036=Не найдено ни одного предмета с типом '{0}'!
1037=Двойной Щелчок ({0})
1038=Выбрать цель заново
1039=Преобразовать в "Двойной Щелчок" по типу
1040=Выбор новой цели для этого действия.
1041=ПРЕДУПРЕЖДЕНИЕ: Ошибка при загрузке значения из профиля:\n{0}
1042=ПРЕДУПРЕЖДЕНИЕ Макроса: Не могу найти объект (вне зоны досягаемости).
1043=Перемещение {1} - {0}
1044=Преобразовать в "Переместить" по типу
1045=ПРЕДУПРЕЖДЕНИЕ Макроса: В руках ни чего нет.
1046=Снарядить {0} (L:{1})
1047=Бросить в {0} (@{1})
1048=Преобразовать в "Относительное Расположение"
1049=Бросить (относительно) @({0},{1},{2})
1050=Реакция от меню (Кнопка {0})
1051=Закрыть меню
1052=Реакция от меню: {0}
1053=ПРЕДУПРЕЖДЕНИЕ: Макрос запросил цель, но она не была получена с сервера! (может вам следует использовать "Ждать Цель"?)
1054=Абсолютная цель
1055=Преобразовать в "Последнюю Цель"
1056=Преобразовать в "Цель" по типу
1057=Релокация целей ({0},{1})
1058=Последняя цель
1059=Выбрать себя
1060=Выбрать "Последнюю Цель"
1061=Выбрать случайного Красного
1062=Выбрать случайного Серого
1063=Выбрать случайного Синего
1064=Выбрать случайного Врага
1065=Выбрать случайного Дружественного
1066=Выбрать случайного Недружественного
1067=Сказать '{0}'
1068=Использовать умение {0}
1069=Вызвать заклинание {0}
1070=Установить спец. удар {0}
1071=Одеть: {0}
1072=Снять: {0}
1073=Убрать Layer {0}
1074=Ждать меню (любое)
1075=Ждать меню (#{0})
1076=Изменить
1077=Ждать диалог (любой)
1078=Ждать диалог (#{0})
1079=Ждать цель
1080=Пауза {0:#.00} сек
1081=Ждать: {0} {1} {2}
1082=Загрузка '{0}'...
1083=> Остановить текущий макрос
1084=Выполнить: {0}
1085=Запуск макроса '{0}'...
1086=Макрос '{0}' завершен.
1087=Невозможно запустить Razor. Код ошибки:\n
1088=ОПИСАНИЕ: Невозможно найти окно клиента UO.\nВозможная причина: Произошла ошибка при загрузке клиента.
1089=ОПИСАНИЕ: Невозможно найти клиент UO.\nВозможная причина: Произошла ошибка при загрузке клиента.
1090=ОПИСАНИЕ: Невозможно создать окна.\nВозможная причина: Внутренняя ошибка.
1091=ОПИСАНИЕ: Невозможно получить доступ к совместной памяти Razor.\nВозможная причина: Ошибка Windows или неправилные разрешения.
1092=ОПИСАНИЕ: Crypt.dll не загружен.\nВозможная причина: Несовпадение версий.
1093=ОПИСАНИЕ: Невозможно изменить функции Winsock Клиента UO.\nВозможная причина: Внутренняя ошибка, ошибка Windows, или несовместимая версия.
1094=
1095=ПРЕДУПРЕЖДЕНИЕ: Не могу получить длину пакета и/или информацию о шифровании клиента UO.\nRazor может запустится без этой информации, но некоторые действия будут выполняться неправильно. Хотите ли вы продолжить запуск Razor?\nВозможная причина: Версия вашего клиента несовместима с этой версией Razor.
1096=Ваше умение '{0}' изменилось на {4}{5:F1}, теперь его значение {3:F1} ({1}{2:F1}).
1097=Неверное сокращение.
1098=Неверный ID объекта.
1099=Неверный цвет.
1100=Выберите объект обсчета.
1101=Ошибка загрузки '{0}'!\nЭтот профиль испорчен и не может быть использован.
1102=Свойство {0} не найдено в текущем профиле.
1103=Ваш файл counters.xml испорчен и не может быть использован.
1104=Т.к. вы не выбрали опцию "Искать предметы в сумках", то вы должны открыть все ваши сумки, чтобы счетчики обновились.
1105=ПРЕДУПРЕЖДЕНИЕ: Величина '{0}' теперь {1}!
1106=Выберите цвет, который вы хотите использовать.
1107=Сделать снимок экрана
//1108=Возможные значения:\n{char} - Имя персонажа\n{shard} - Имя шарда\n{str}/{hp}/{hpmax} - Информация о здоровье\n{dex}/{stam}/{stammax} - Информация о ловкости\n{int}/{mana}/{manamax} - Информация об интеллекте\n{weight}/{maxweight} - Информация о весе\n{gold} - Общее кол-во золота у персонажа\n{AR} - Рейтинг брони / Физическое сопротивление\n{tithe} - Очки заклинаний палладина (tithe points)\n{bandage} - Время перевязки\n{statbar}/{mediumstatbar}/{largestatbar} - Полоски здоровья, маны и выносливости\n{crimtime} - Как долго вы будете вне закона\n{stealthsteps} - Счетчик скрытых шагов\nColor - HTML шестнадцатеричный код цвета: '~#rrggbb' ('~#~' чтобы убрать)\nИли {Format} Из списка счетчиков
1109=Версия Razor: {0}\nИспользовано памяти: {1}\nОтправлено: {2} ({3}/s)\nПолучено: {4} ({5}/s)\nВремя в игре: {6}\n\nСерийный номер игрока: 0x{7:X8}\nСерийный номер рюкзака: 0x{8:X8}\n\nСлежение за предметами (кол-во): {9}\nСлежение за существами (кол-во): {10}\n
1110=Установить на: + УВЕЛИЧЕНИЕ
1111=Установить на: - УМЕНШЕНИЕ
1112=Установить на: / ФИКСАЦИЯ
1113=Вы уверены, что хотите удалить счетчик '{0}'?\nЭто затронет все профили.
1114=Загрузить профиль '{0}'?
1115=Произошла ошибка при загрузке профиля.
1116=Профиль 'default' является профилем по умолчанию и не может быть удален!
1117=Введите имя нового профиля:
1118=Невозможно создать новый профиль!\n Причина: Профиль с таким именем уже существует.\n\nХотите ли вы загрузить существующий  профиль?
1119=Введите имя нового списка:
1120=Удалить этот список снаряжения?
1121={0:X} (Объект вне зоны досягаемости)
1122=Удалить этот объект из списка Снаряжения?
1123=Выберите сумку, в которую будут сложены снятые вещи, указанные в списке '{0}'.
1124=Сумка для снятых вещей выбрана.
1125=Объект не найден или выбран неправильный объект.
1126=Эта комбинация клавиш уже принадлежит '{0}'.\nИзменить на '{1}'?
1127=Данные успешно сохранены.
1128=Предупреждение!\nСтатистика пакетов может привести к существенному замедлению работы Razor. Размер файлов статистики также может резко возрасти.\n\nФайл статистики Razor может содержать персональную информацию, в том числе и пaроли. Вы не должны передавать этот файл людям, которым вы не доверяете.\n\nВы уверены, что хотите включить статистику пакетов?\n(Это не будет сохранено в ваш профиль)
1129=Преобразовать выбранные в Тип
1130=Введите имя нового макроса: 
1131=Это имя содержит недопустимые символы.
1132=Макрос с таким именем уже существует.
1133=Этот макрос будет очищен перед записью.\nВы уверены, что хотите перезаписать этот макрос?
1134=Вы уверены, что хотите полностью удалить '{0}'?\n(Это действие не может быть отменено)
1135=Вставить: Пауза/Ожидание...
1136=Вставить: Выбрать "Последнюю Цель"
1137=Вверх
1138=Вниз
1139=Удалить действие
1140=Начать запись с этого места
1141=Файл '{0}' не найден.
1142=Вы уверены?
1143=ПРЕДУПРЕЖДЕНИЕ: Следующее количество фала(ов) {0} не было удалено:\n{2}
1144=Эти изменения вступят в силу при следующем запуске Razor.
1145=Разрешение этой опции приведет к тому, что Razor сохранит ваши пароли как часть вашего профиля. Пароли будут зашифрованы, но злоумышленник, получивший доступ к .xml файлу профиля, сможет его использовать.\nВы уверены, что хотите сохранять пароли в профиле?
1146=Вы должны указать верный порт.
1147=Игнорирую действие (уже в очереди).
1148=Добавление действий в очередь {0}... {1} готово.
1149=Добавлено действий в очередь: {0}, время выполнения {1:F1} сек.
1150=Агент "Использовать_Один_Раз"
1151=Добавить цель...
1152=Добавить сумку...
1153=Убрать цель...
1154=Очистить список
1155=Укажите объект для добавления.
1156=Укажите сумку.
1157=Укажите объект, чтобы убрать.
1158=Объект добавлен.
1159=Объект удален.
1160=В агент "Использовать_Один_Раз" добавлено объектов: {0} 
1161=Очередь агента "Использовать_Один_Раз" пуста!
1162=Использую '{0}'.  (Исключено объектов из очереди "Использовать_Один_Раз": {1})
1163=Проблема с одним из объектов агента "Использовать_Один_Раз", попытка использовать следующий объект.
1164=Агент "Продавец": Автоматически продано объектов {0}, получено {1}gp.
1165=Убрать
1166=Сумка выбрана.
1167=Очистить
1168=(Выключить)
1169=(Включить)
1170=Выбрать сумку...
1171=Поменять сумку...
1172=Агент "Организатор"
1173=Организатор
1174=Переместить сейчас
1175=Сумка не выбрана.
1176=Razor не может найти ваш рюкзак.
1177=Агент "Организатор": добавлено объектов для упорядочивания: {0} (Это может занять некоторое время).
1178=Агент "Организатор": не найдено ни одного объекта, подходящего для упорядочивания.
1179=Этот объект уже в списке.
1180=Исключить_Из_Авто_Поиска
1181=Агент "Покупатель": автоматически куплено предметов {0}, истрачено {1}gp.
1182=Агент "Покупатель" не может произвести необходимые действия, т.к. у вас не хватает золота.
1183=Введите количество:
1184=Установлен приоритет клиента: {0}
1185=Текущее время: {0}
1186=Вы находитесь {0} в '{1}'
1187=Сумка для снятых вещей не найдена или находится слишком далеко, будет использован рюкзак.
1188=Снять снаряжение, добавлено объектов в очередь: {0}.
1189=Одеть снаряжение, добавлено объектов в очередь: {0}.
1190=Снаряжение уже одето, объектов: {0}.
1191=Не найдено объектов: {0}. (Вне зоны досягаемости)
1192=ПРЕДУПРЕЖДЕНИЕ: Файл Spells.def не найден, формат заклинаний будет недоступен
1193=Скрытых шагов: {0}
1194=Начат подсчет скрытых шагов.
1195=Очистить очередь целей
1196=Атаковать последнего нападавшего
1197=Очередь целей очищена.
1198=Указать новую "Последнюю Цель"
1199="Последняя Цель" установлена.
1200=Новая цель выбрана.
1201=На экране не найдено ни одной цели, соответствующей вашему запросу.
1202=Добавлено в очередь: "Выбрать себя".
1203=Добавлено в очередь: "Последняя Цель".
1204=Сервер получил новую цель.
1205=Выбрать по типу '{0}'
1206=Пылесос
1207=Вы уверены, что хотите удалить это?
1208=Выберете папку для сохранения снимков экрана.
1209=Горячие клавиши

1210=Предметы
1211=Цели
1212=Агенты
1213=Одежда
1214=Макросы
1215=Заклинания
1216=Умения
1217=Другое
1251=1й круг
1252=2й круг
1253=3й круг
1254=4й круг
1255=5й круг
1256=6й круг
1257=7й круг
1258=8й круг
1260=Necromancy
1270=Chivalry
1271=Зелья
1272=Специальные действия
1290=Bushido
1300=Ninjitsu
1301=Продавец
1302=Покупатель
1303=Необходим ввод значения
1304=Список команд Razor
1305=Использовать объект в руке
1306=Прежде чем вооружиться, вы должны снять оружие.
1307=Вооружить/разоружить правую руку
1308=Вооружить/разоружить левую руку
1309=Бросить объект в руках

1311=> Включить/Выключить горячие клавиши Razor
1312=Горячие клавиши обрабатываются (Нажмите {0} чтобы выключить)
1313=Горячие клавиши не используются (Нажмите {0} чтобы включить)
1314=Горячие клавиши обрабатываются
1315=Горячие клавиши не используются
1316=Шаги: {0}
1317=Добавить тип...
1318=Запрашиваемая цель вне зоны досягаемости.
1319=Продажа, max: {0}
1320=Повторяющиеся сообщения
1321=Звуки рюкзака
1322=Вставить условие "If" (условие)
1323=Вставить "Else" (иначе)
1324=Вставить "End If" (конец условия)
1325=Установить кол-во
1326=Автонаполнитель
1327=Наполнить сейчас
1328=Агент "Автонаполнитель"
1329=Выберите сумку, окуда будет производится наполнение, или выберите себя, чтобы использовать ваш банковский ящик.
1330=Эта сумка не подходит
1331=Наполнение завершено, объектов в очереди: {0}.
1332="Прекратить" текущую цель
1333=Более новая версия Razor доступна для скачивания с сайта.\n\nХотите посетить сайт Razor, чтобы скачать новую версию?
1334=Загрузить снова
1335=Сохранить
1336=ПРЕДУПРЕЖДЕНИЕ: Текущая цель не позволяет вам указывать землю. "Последняя Цель" не выполнена.
1337=Синхронизировать клиент
1338=Спешивание во время боя заблокировано.
1339=Начать запись "PacketVideo"
1340=Остановить запись/воспроизведение "PacketVideo"
1341=Произошла ошибка при попытке записи.\nОшибка было добавлена в статистику.
1342=Этот файл не совместим с этой версией Razor. Убедитесь, что у вас самая новая версия Rzor.
1343=Файл видео поврежден и не может быть воспроизведен.
1344=Невозможно прочитать файл. Он может быть поврежден.
1345=Введите имя категории:
1346=Директория не может быть удалена. Убедитесь, что она пуста.
1347=Невозможно создать директорию. Убедитесь, что вы ввели правильное имя и попробуйте снова.
1348=Невозможно переместить файл макроса. Убедитесь, что выбранная категория существует.
1349=Друзья
// 1350 to 1359 reserved (max length 15!)
1350=Остановлен
1351=Конец
1352=Игра закончена?
1353=ker-pwned
1354=Got corp por?
1355=bamboozled
1356=pwned?
1357=Jesus <3s you
1358=Kal Vas Pwned
1359=SMACKDOWN
1360=Укажите игрока, который будет добавлен в список друзей
1361=Укажите игрока, который будет удален из списка друзей
1362=Друг добавлен.
1363=Друг удален.
1364=Специальные конструкторы
1365=Вставить "For Loop" (цикл повторений)
1366=Вставить "End Loop" (конец цикла)
1367=Введите кол-во повторений:
1368=Очистить очередь
1369=Последнее заклинание
1370=Последнее умение
1371=Последний объект
1372=Показать имена всех существ
1373=Использовать_Один_Раз
1374=Выбрать случайного Врага Человека
1375=Выбрать случайного Серого Человека
1376=Выбрать случайного Невинного Человека
1377=Выбрать случайного Преступника Человека
1378=Выбрать случайного Преступника
1379=ПРЕДУПРЕЖДЕНИЕ: Закончилось время ожидания! Объект из рук перенесен в рюкзак.
1380=Вы должны перезапустить Razor и клиент, чтобы изменения вступили в силу.
1381=Вы должны выйти и зайти заново вашим персонажем, чтобы изменения вступили в силу.
1382=Добавлено запросов на "Перемещение": {0}... {1} готово.
1383=Запрос агента "Автонаполнитель" в процессе....
1384=Ваша сила изменилась на {0}{1} и стала равной {2}.
1385=Ваша ловкость изменилась на {0}{1} и стала равной {2}.
1386=Ваш интеллект изменился на {0}{1} и стал равный {2}.
1387=Уровни освещенности
1388=Невозможно вылечить цель т.к. она отравлена!
1389=Очистка очереди на "Перемещение"
1390=Остановить сейчас
1391=>Вылечить/Исцелить (от отравления) себя


================================================
FILE: etc/Language/Razor_lang.swe
================================================
// Razor Swedish/swe Language Pack
// Last Modified on Jan 15, 2007.
// Author: Ilutzio (swordsmith100(at)hotmail.com)

::Encoding=ISO-8859-1
::CliLoc=SWE

[controls]
WelcomeForm::Text=Vlkommen till Razor!
WelcomeForm::groupBox3=UO Mappen
WelcomeForm::dataBrowse=Leta...
WelcomeForm::label5=Sprk:
WelcomeForm::groupBox2=Server
WelcomeForm::label3=Server:
WelcomeForm::label4=Port:
WelcomeForm::groupBox1=Klient Alternativ
WelcomeForm::useEnc=Anvnd OSI Kryptering
WelcomeForm::makeDef=Gr Dessa Instllningar Till Standard
WelcomeForm::browse=Leta...
WelcomeForm::label1=Ladda Klient:
WelcomeForm::patchEncy=Anvnd klientens kryptering
WelcomeForm::showAtStart=Visa detta nr Razor startar
WelcomeForm::quit=&Stng
WelcomeForm::okay=&Okej

MainForm::Text=Razor v{0}
MainForm::generalTab=Allmnt
MainForm::label10=Leta efter uppdateringar:
MainForm::systray=Aktivitetsfltet
MainForm::taskbar=Meddelandefltet
MainForm::smartCPU=Anvnd smart CPU reducering
MainForm::label7=Sprk:
MainForm::label11=Visa i:
MainForm::groupBox4=Profiler
MainForm::delProfile=Radera
MainForm::newProfile=&Ny...
MainForm::showWelcome=Visa Vlkomstskrmen (fr alla anvndare)
MainForm::alwaysTop=Anvnd Smart Always on Top
MainForm::groupBox1=Filter
MainForm::opacityLabel=Opasitet: 100%
MainForm::moreOptTab=Fler Alternativ
MainForm::blockHealPoison=Blockera healing om mlet r frgiftat
MainForm::potionEquip=Avvpna/Vpna hnder fr "pots"
MainForm::label17=Razor meddelanden:
MainForm::QueueActions=Ka Object-Anvndning Automatiskt 
MainForm::spellUnequip=Avvpna hnder autom. fr magier
MainForm::autoOpenDoors=ppna drrar automatiskt
MainForm::alwaysStealth=Visa alltid Stealth steg 
MainForm::autoFriend=Behandl gruppmedl som 'Friend'
MainForm::chkStealth=Rkna stealth-steg
MainForm::rememberPwds=Kom ihg lsenord
MainForm::showtargtext=Visa mlets 'flag' vid singel-klick
MainForm::preAOSstatbar=Anvnd 'Pre-AOS' statusfnster
MainForm::logPackets=Mjliggr paket loggning
MainForm::rangeCheckLT=Avstnd p LastTarget:
MainForm::actionStatusMsg=Visa Objekt-k meddelanden
MainForm::label5=Objekt timer:
MainForm::label9=Klientens Prioritet:
MainForm::label8=tiles
MainForm::label6=ms
MainForm::label18=x
MainForm::gameSize=Betvinga Fnster:
MainForm::smartLT=Anvnd smart Last Target
MainForm::moreOptTab=Alternativ
MainForm::negotiate=Frhandla finesser med servern
MainForm::setLTHilight=Val
MainForm::lthilight=Last Target Markering:
MainForm::filterSnoop=Filtrera Snooping-meddelanden
MainForm::incomingCorpse=Visa namnen p Nya/Inkommande Lik
MainForm::incomingMob=Visa namnen p Inkommande Folk/F
MainForm::setHarmHue=Val
MainForm::setNeuHue=Val
MainForm::lblHarmHue=Harmfull
MainForm::lblNeuHue=Neutral
MainForm::lblBeneHue=Godartad
MainForm::setBeneHue=Val
MainForm::setSpeechHue=Val
MainForm::setWarnHue=Val
MainForm::setMsgHue=Val
MainForm::setExHue=Val
MainForm::autoStackRes=Bunta Malm/Fisk/Stockar vid Ftter
MainForm::queueTargets=Ka LastTarget och TargetSelf
MainForm::spamFilter=Filtrera repeterande systemmeddelanden
MainForm::label4=tiles
MainForm::openCorpses=ppna nya lik innom
MainForm::showNotoHue=Visa notoritetsfrg p {char} i TitleBar
MainForm::lblWarnHue=Varningsmedd. frg
MainForm::lblMsgHue=Razors meddel. frg
MainForm::lblExHue=Sk-Frskoningsfrg
MainForm::blockDis=Blockera avsittning i strid
MainForm::chkForceSpellHue=ndra Spell-frg:
MainForm::chkForceSpeechHue=sidostt Talfrg
MainForm::label3=Spell Format:
MainForm::displayTab=Visning/Rknare
MainForm::warnCount=Varna nr en rknare r under:
MainForm::excludePouches=Autosk aldrig Pouches
MainForm::highlightSpellReags=Markera reagenter vid Spell
MainForm::titlebarImages=Visa bilder vid Rknare
MainForm::checkNewConts=Sk autom. i nya behllare
MainForm::groupBox3=Titelfnster Visning
MainForm::showInBar=Visa detta i UOs titelfnster:
MainForm::groupBox2=Rknare
MainForm::delCounter=Rade/ndr
MainForm::addCounter=Lgg till...
MainForm::recount=Omrkn.
MainForm::dressTab=Vpna/Kld
MainForm::groupBox6=Bevpning/Kld Artiklar
MainForm::clearDress=Rensa Listan
MainForm::dressDelSel=Avlgsna
MainForm::undressBag=ndra Avkldn. sck
MainForm::undressList=Avkld
MainForm::dressUseCur=Lgg till nuvarande
MainForm::targItem=Lgg till (Ml)
MainForm::dressNow=Kld
MainForm::groupBox5=Bevpna/Kld det valda
MainForm::removeDress=Avlgsna
MainForm::addDress=Lgg till...
MainForm::undressConflicts=Avlgsna autom. bestridande artikl.
MainForm::skillsTab=Frdigheter
MainForm::dispDelta=Visa frdighets- och statndringar
MainForm::skillCopyAll=Kopiera Alla
MainForm::skillCopySel=Kopiera de Valda
MainForm::label1=Base Total:
MainForm::setlocks=Set all locks:
MainForm::resetDelta=Reset  +/-
MainForm::agentsTab=Agenter
MainForm::hotkeysTab=Snabbtange.
MainForm::dohotkey=Aktivera Valda
MainForm::groupBox8=Snabbtangent
MainForm::chkPass=Skicka ven till UO
MainForm::label2=Key:
MainForm::unsetHK=Avstll
MainForm::setHK=Bruka
MainForm::chkCtrl=Ctrl
MainForm::chkAlt=Alt
MainForm::chkShift=Shift
MainForm::macrosTab=Macron
MainForm::macroActGroup=Handlingar
MainForm::loopMacro=Slinga
MainForm::recMacro=Spela in
MainForm::playMacro=Spela upp
MainForm::delMacro=Avlgsna
MainForm::newMacro=Ny...
MainForm::screenshotTab=Skrmdumpar
MainForm::label12=Bildformat:
MainForm::capNow=Ta Skrmdump Nu
MainForm::radioUO=Endast UO
MainForm::radioFull=Helskrm
MainForm::screenAutoCap=Automatisk ddskrmsgonblick
MainForm::setScnPath=...
MainForm::dispTime=Inkludera tidsstmpel p bilderna
MainForm::videoTab=Videoinspeln.
MainForm::recFolder=...
MainForm::label13=Inspelningsmapp:
MainForm::groupBox7=PacketVideo Inspelning
MainForm::vidRec=Spela in PacketVideo
MainForm::groupBox10=AVI Video Inspelning
MainForm::flipVidVert=Vertikal
MainForm::flipVidHoriz=Horisontal
MainForm::recAVI=Spela in AVI Video...
MainForm::label16=Upplsning:
MainForm::label15=FPS:
MainForm::label19=Vnd:
MainForm::groupBox9=PacketVideo Uppspelning
MainForm::label14=Hastighet:
MainForm::vidClose=Stng
MainForm::vidPlayStop=Stoppa
MainForm::vidPlay=Spela
MainForm::vidOpen=ppna...
MainForm::statusTab=Hjlp && Status
MainForm::forumsLink=Razor Diskussionsforum
MainForm::homeLink=Razor Hemsidan
MainForm::userGuideLink=Razor Anvndarmanual

HueEntry::Text=Vlj en frg
HueEntry::cancel=Avbryt
HueEntry::okay=&Okej
HueEntry::preview=Frhandsgranska
HueEntry::inGame=Vlj i spelet
HueEntry::label1=Frgnummer:

AddCounter::Text=Lgg till en Rknare
AddCounter::delete=Ta bort
AddCounter::target=Vlj 
AddCounter::cancel=Avbryt
AddCounter::Add=&Okej
AddCounter::label4=Frg (Valfri: -1):
AddCounter::label3=Artikel ID:
AddCounter::label2=Format:
AddCounter::label1=Namn:

MacroInsertWait::Text=Lgg in en Pause...
MacroInsertWait::radioMenu=Vnta p gammaldags Meny/Dialog
MacroInsertWait::cancel=&Avbryt
MacroInsertWait::radioStat=Vnta i 
MacroInsertWait::radioTarg=Vnta p Target
MacroInsertWait::radioGump=Vnta p Gump
MacroInsertWait::label1=millisekunder
MacroInsertWait::radioPause=Pausa i:
MacroInsertWait::insert=&Inflika

MacroInsertIf::Text=Inflika Om...
MacroInsertIf::label1=Om:
MacroInsertIf::cancel=&Avbryt
MacroInsertIf::insert=&Inflika

[strings]
1001=Ddsstatus
1002=Bardmusik
1003=Hundljud
1004=Kattljud
1005=Hstljud
1006=Frljud
1007=Spirit Speak ljud
1008=Spell Fizzle ljud
1009=Vder
1010=Visa Rknare
1011=Rkna om Rknare
1012=Rensa AOS Frmga
1013=Bruka Primr Frmga (AOS)
1014=Bruka Sekundr Frmga (AOS)
1015=Stun av/p (Pre-AOS)
1016=Disarm av/p (Pre-AOS)
1017=Bruka frmga {0}
1018=AOS-frmgor rensade.
1019=Avkld allt
1020=Avkld bda hnderna
1021=Avkld Vnstra handen
1022=Avkld Hgra handen
1023=Avkld hatten
1024=Avkld smycken
1025=Bandagera Self
1026=Bandagera LastTarget
1027=Bruka Bandage (Ingen Timer)
1028=Drick Heal
1029=Drick Cure
1030=Drick Refresh
1031=Drick Night Sight
1032=Drick Explosion
1033=Drick Strength
1034=Drick Agility
1035=Inga bandage funna
1036=Inga artiklar av typen {0} funna!
1037=Dubbelklicka ({0})
1038=ter-Sikta
1039=Konvertera till DClick enligt Type
1040=Vlj ett nytt ml vid denna handling.
1041=VARNING: Undantag ptrffades medan denna profil laddades:\n{0}
1042=Macro Varning: Kan inte finna den artikeln (Fr stort avstnd).
1043=Lyft {1} - {0}
1044=Konvertera till Lyfta enligt Typ
1045=Macro Varning: Hller inte i ngot.
1046=Utrusta till {0} (L:{1})
1047=Lgg {0} (@{1})
1048=Konvertera till Relativ Plats
1049=Lgg (Relativt) @({0},{1},{2})
1050=GumpSvar (Knapp {0})
1051=Stng Gump
1052=MenySvar {0}
1053=Varning: Macrot kallade p ett target, men servern skickade inget! (Behver du kanske anvnda 'WaitForTarget'?)
1054=Absolut Target
1055=Konvertera till LastTarget
1056=Konvertera till Target enligt Typ
1057=Trget RelLoc ({0},{1})
1058=Last Tagret
1059=Target Self
1060=Vlj Last Target
1061=Stt slumpmssig Red som Target
1062=Stt slumpmssig Grey som Target
1063=Stt slumpmssig Blue som Target
1064=Stt slumpmssig Enemy som Target
1065=Stt slumpmssig Friendly som Target
1066=Stt slumpmssig Non-Friendly som Target
1067=Sg "{0}"
1068=AnvndFrdighet {0}
1069=AnvndSpell {0}
1070=BrukaFrmga {0}
1071=Kld: {0}
1072=Avkld: {0}
1073=Avkld Lager {0}
1074=Vnta p meny (Vilken som helst)
1075=Vnta p meny (#{0})
1076=ndra...
1077=Vnta p Gump (Vilken som helst)
1078=Vnta p Gump (#{0})
1079=Vnta p Riktmrke
1080=Pause {0:#.00}sek
1081=Vnta p {0} {1} {2}
1082=Laddar '{0}'...
1083=> Stoppa Aktivt Macro
1084=Spela: {0}
1085=Spelar Macro '{0}'...
1086=Macro '{0}' klart.
1087=Razor kunde itne initialisera.  Felkod:\n
1088=Beskrivning: Could not find the client Window Handle.\nMjlig Orsak: The Client may not have initialized properly.
1089=Description: Could not find the Client's ThreadID\nPossible Cause: The Client may not have initialized Properly.
1090=Description: Could not create Windows Hooks.\nPossible Cause: Internal error.
1091=Description: Could not create or access Razor shared memory.\nPossible Cause: Windows Error or invalid permissions.
1092=Description: Crypt.dll has disabled itself.\nPossible Cause: Version mismatch.
1093=Description: Could not patch the client's Winsock functions.\nPossible Cause: Internal error, Windows Error, or Incompatible Version.
1094=Description: An invalid parameter was passed to the loade.\nPossible Cause: Mismatched DLL versions.
1095=Warning: Could not copy packet lengths and/or encryption information from the client.\nRazor may be able to run without this information, though some features may not function correctly.  Would you like to start Razor anyway?\n\nPossible Cause: Your client version may not be compatible with this version of Razor.
1096=Your skill in {0} has changed by {4}{5:F1}, it is now {3:F1} ({1}{2:F1}).
1097=Invalid frkortning.
1098=Invalid artikel id.
1099=Invalid frg.
1100=Vlj en artikel att rkna.
1101=Error loading '{0}'!\nThis profile is corrupt and cannot be used.
1102=The property {0} was not found in this profile.
1103=Your counters.xml file is corrupt and cannot be used.
1104=Because you have Auto Search Containers off, you must now reopen all of your bags so that your counters can be updated.
1105=Varning: {0} mngd r nu {1}!
1106=Vlj frgen du nskar anvnda.
1107=Ta Skrmdump Nu
1108=Possible values:\n{char} - Character name\n{shard} - Shard name\n{str}/{hp}/{hpmax} - Health status\n{dex}/{stam}/{stammax} - Dex status\n{int}/{mana}/{manamax} - Int status\n{weight}/{maxweight} - Weight information\n{gold} - Total Gold on character\n{AR} - Armor Rating / Physical Resistance\n{tithe} - Tithing points\n{followers}/{followersmax} - Followers slots\n{bandage} - Bandage Timer\n{statbar}/{mediumstatbar}/{largestatbar} - Status bar\n{crimtime} - How long you have been a criminal\n{stealthsteps} - Stealth steps counter\n{physresist} - Physical Resistance\n{coldresist} - Cold Resistance\n{fireresist} - Fire Resistance\n{energyresist} - Energy Resistance\n{poisonresist} - Poison Resistance\n{luck} - Luck\n{damage} - Damage Min-Max\nColor - HTML hex color code: '~#rrggbb' ('~#~' to terminate)\nOr a {Format} from the Counters list
1109=Razor Version: {0}\nMemory Used: {1}\nSend: {2} ({3}/s)\nRecv: {4} ({5}/s)\nConnected for {6}\n\nPlayer Serial: 0x{7:X8}\nBackpack Serial: 0x{8:X8}\n\nTracking Items: {9}\nTracking Mobs: {10}\n
1110=Stt Pil: UPP
1111=Stt Pil: NER
1112=Stt Pil: LST
1113=r du sker p att du vill avlgsna rknaren "{0}"?\nDetta kommer pverka alla profiler.
1114=Ladda profilen "{0}" nu?
1115=Ett fel uppstod nr profilen skulle laddas.
1116=Du kan ej ta bort standardprofilen
1117=Skriv ett profilnamn: 
1118=Kan ej skapa en ny profil!\n Anledning: En profil vid detta namn existerar redan.\n\nVil du ladda sagda nu?
1119=Skriv ett namn fr denna nya Dress List:
1120=Ta bort denna dress list?
1121={0:X} (Artikel out of Range)
1122=Avlgsna artikeln frn denna dress list?
1123=Vlj en pse som listan '{0}' kan avklda till.
1124=Undress pse vald.
1125=Artikeln hittades ej, eller s valdes fel sort.
1126=Den tangentkombinationen anvnds redan av '{0}'.\nBut till '{1}'?
1127=Datan sparades.
1128=Warning!\nLogging packets may reduce Razor's performance. Log files can also\neasily grow very large, and Razor will not automatically remove them.\n\nRazor's packet log files may contain personal information such as\npasswords, and should be not be given to people you do not trust.\n\nAre you sure you want to enable packet logging?\n(This will not be saved in your user profile)
1129=Konvertera det valda till TYPE
1130=Skriv ett namn fr det nya macrot: 
1131=Namnet innehller icke tilltna tecken.
1132=Ett macro vid det namnet finns redan.
1133=Detta macrot kommer att rensas innan inspelning.\nVill du verkligen spela ver detta macrot?
1134=Vill du verkligen PERMANENT ta bort '{0}'?\n(Detta r utan tervndo)
1135=inflika Pause/Vntan...
1136=Inflika Vlj LastTarget
1137=Flytta Upp
1138=Flytta Ner
1139=Ta bort Handling
1140=Brja Inspeningen Hr
1141=Filen '{0}' hittades ej.
1142=r du sker?
1143=VARNING: Den fljande {0} file{1} kunde inte tas bort:\n{2}
1144=Denna ndringen kommer trda i kraft efter att Razor startats om.
1145=Vljer du detta s kommer Razor att spara dina lsenord i din profil.\nLsenorden r dock krypterade men ehuru kan nn f tag i din XML fil och f tag p dina lsenord.\nr du sker p att du vill anvnda detta val?
1146=Du mste vlja en port.
1147=Ignorerar handlingsfrfrgan (redan kad).
1148=Kar handlingsfrfrgan {0}... {1} kvar.
1149=Frdigstllde {0} kade handlingar p {1:F1} sekunder.
1150=Use Once Agent
1151=Lgg till (Target)...
1152=Lgg till Behllare (Target)...
1153=Avlgsna (Target)...
1154=Rensa Listan
1155=Vlj en artikel som ska lggas till.
1156=Vlj en behllare.
1157=Vlj en artikel att avlgsna.
1158=Artikel tillagd.
1159=Artikel avlgsnad.
1160={0} artiklar tillagda till Use Once agenten.
1161=UseOnce kn r tom!
1162=Anvnder '{0}'.  ({1} artiklar kvar i UseOnce kn)
1163=Ett problem uppstod med en av dina UseOnce artiklar, frsker med nsta.
1164=SellAgent: Sljer automatiskt {0} artiklar fr {1}gp.
1165=Avlgsna
1166=Behllare vald.
1167=Rensa
1168=(Kliicka fr att stnga av)
1169=(Klicka fr att stta p)
1170=Vlj Hot Bag
1171=Rensa Hot Bag
1172=Organizer Agent
1173=Organizer
1174=Organisera Nu
1175=En behllare r inte vald.
1176=Razor kunde inte hitta din ryggsck.
1177=Organize Agenten har kat {0} artiklar som ska flyttas. (detta kan ta ett tag)
1178=Organize Agenten hittade inga artiklar att flytta.
1179=Den artikeln r redan listad.
1180=AutoSearchExemptions
1181=Buy Agenten kpte {0} artiklar fr {1}gp.
1182=Buy Agenten kpte inte vissa artiklar p listan fr att du har inte nog med guld.
1183=Skriv mngd:
1184=Clientens Processprioritet satt till {0}
1185=KLockan r: {0}
1186=Du r vid {0} i '{1}'
1187=Undress bag hittades inte eller var utom rckhll, anvnder din ryggsck istllet
1188={0} artiklar kade fr avkldning.
1189={0} artiklar kade fr bekldning.
1190={0} artiklar r redan bekldda.
1191={0} artiklar hittades inte. (Out of Range)
1192=Varning: Spells.def hittades ej, spell format text kommer ej att visas
1193=Stealth Steg: {0}
1194=Rknar nu stealth steg.
1195=Rensa Target Queue
1196=Attackera Last Combatant
1197=Target queue rensad.
1198=Vlj ett nytt 'Last Target'
1199=Last Target valt.
1200=Nytt target valt.
1201=Inget sdant ml finns p din skrm.
1202=Kar target self.
1203=Kar last target.
1204=Servern snde ett nytt target, avbryter Razors target.
1205=Target by Type {0}
1206=Scavenger
1207=Vill du verkligen ta bort detta?
1208=Vlj en mapp vari Razors skrmdumpar ska sparas.
1209=Snabbtangenter

1210=Artiklar
1211=Targets
1212=Agenter
1213=Kld
1214=Macron
1215=Spells
1216=Frdigheter
1217=Blandat
1251=1st
1252=2nd
1253=3rd
1254=4th
1255=5th
1256=6th
1257=7th
1258=8th
1260=Necromancy
1270=Chivalry
1271=Potions
1272=Special Moves
1290=Bushido
1300=Ninjitsu
1301=Slj
1302=Kp
1303=Skrift Krvs
1304=Razor Kommandolista
1305=Anvnd Artikeln i Handen
1306=Du mste avvpna ntt innan du kan vpna det.
1307=Vpna/Avvpna Hger Hand
1308=Vpna/Avvpna Vnster Hand
1309=Avvpna det som du hller i
1310=Spellweaving
1311=> Stt p/Stng av Razors Snabbtangenter
1312=Snabbtangenter pslagna (Tryck {0} fr att stnga av dem)
1313=Snabbtangenter avstngda (Tryck {0} fr att sl p dem)
1314=Snabbtangenter pslagna
1315=Snabbtangenter avstngda
1316=G: {0}
1317=Lgg till Typ (Target)...
1318=Det valda mlet r utom rckhll, last target verkstlldes ej!
1319=Max Slj: {0}
1320=Snooping Meddelanden
1321=Ryggscksljud
1322=Inflika "If" Argument
1323=Inflika "Else"
1324=Inflika "End If"
1325=Vlj Mngd
1326=Fyll p
1327=Fyll p Nu
1328=Pfyllningsagenen
1329=Vlj en behllare att fylla p frn, eller vlj dig sjlv fr att anvnda banken.
1330=Den behllaren r ej giltig.
1331=Pfyllning klar, kade {0} artiklar{1}.
1332=Avbryt Current Target
1333=En nyare Razor version finns tillgnglig p hemsidan.\n\nVill du beska Razor websidan fr att ladda ner den nya versionen?
1334=Ladda om
1335=Spara
1336=Varning: Det nuvarande riktmrket kan ej vara markbundet.  Last Target verkstlldes ej.
1337=tersynchronisera Klienten
1338=Avsittning blockerad.
1339=Starta Razor "PacketVideo" Inspelning
1340=Stoppa "PacketVideo" Inspening/Uppspelning
1341=Ett fel uppstod vid inspeningen.\nTUndantaget har loggfrts.
1342=Denna fil r ej kompatibel med denna Razor version.  Se till att du har den senaste Razor versionen.
1343=Denna videofil r korrupt.\nDen kan vara sndrad eller mixtrad med.\nFilen kan ej spelas.
1344=Filen kunde ej lsas.  Den kan vara skadad eller sndrad.
1345=Skrev ett kategorinamn:
1346=Mappen kunde ej tas bort.  Se till att den r tom.
1347=Mapen kunde ej skapas.  Se till att det valda namnet r godtagbart.
1348=Macro filen kunde ej flyttas.  Se till att kategorinamnet r godtagbart.
1349=Friends
// 1350 to 1359 reserved (max length 15!)
1350=Stopped
1351=The End
1352=Game Over?
1353=ker-pwned
1354=Got corp por?
1355=bamboozled
1356=pwned?
1357=Jesus <3s you
1358=Kal Vas Pwned
1359=SMACKDOWN
1360=Vlj en spelare som ska lggas till din friend list.
1361=Vlj en spelare att avlgsna frn din friend list.
1362=Friend tillagd.
1363=Friend avlgsnad.
1364=Special Constructs
1365=Inflika "For Loop"
1366=Inflika "End For"
1367=Skriv in nskade upprepningar:
1368=Rensa Scavenger Cachen
1369=Last Spell
1370=Last Skill
1371=Last Object
1372=All Names
1373=UseOnce
1374=Target Random Enemy Humanoid
1375=Target Random Grey Humanoid
1376=Target Random Innocent Humanoid
1377=Target Random Criminal Humanoid
1378=Target Random Criminal
1379=VARNING: Drag/Slpp paus! Slpper den handhllna artikeln i ryggscken.
1380=Du mste starta om Razor och klienten fr att verkstlla ndringen.
1381=Du mste logga ut och sedemera in igen fr att denna ndring ska fungera.
1382=Kar dragdrop begran {0}... {1} kvar.
1383=Pfyllningsfrfrgan verkstlls....
1384=Din strength har ndrats med {0}{1}, den r nu {2}.
1385=Din dexterity ndrats med {0}{1}, den r nu {2}.
1386=Din intelligence har ndrats med {0}{1}, den r nu {2}.
1387=Light Levels
1388=Heal blockerad (mlet r frgiftat)!
1389=Rensa Drag/Slpp Kn
1390=Stoppa Nu
1391=>Heal/Cure Self
1392=Next Target
1393=Vlj Pfyllnings HotBag
1394=Lgg till UseOnce
1395=Attackera Last Target
1396=ndra Vntan...
1397=Du hller inte i ngot.
1398=INTE tilltet
1399=tilltet
1400=Finesser frhandlade med servern:
1401=Alla finesser tilltna.
1402=Vderfilter
1403=Ljusniv-filter
1404=Smart LastTarget
1405=Kontrollera avstndet p LastTarget
1406=ppna drrar automatiskt
1407=Avvpna innan Spell Cast
1408=Auto-Potion Vpning
1409=Blockera Heal vid Poison
1410=Loopar Macron
1411=Use Once Agent
1412=Pfyllningsagent
1413=Slj Agent
1414=Kp Agent
1415=Potion Snabbtangenter
1416=Slumpa Targets
// 1417 to 1465 reserved
1466=Finessen tillts ej av servern
1467=Servern tillter itne denna finess.\nDu kan vlja att ignorera servern i "Options" tabben.\n\nFr att se en lista ver icke tilltna finesser, iakta "Help & Status" tabben.
1468=Inflika Kommentar
1469=Lgg till Friend
1470=Avlgsna Friend
1471=>Mini-Heal/Cure Self
1472=Du borde bara stnga av "Patch Encryption" om du anvnder en avkrypterad klient.  Du ska behlla det ven p OSI/EA servrar.\nOm du r osker s ska du lmna boxen ikryssad..\n\r du sker p att du vill stnga av client-side encryption patching?
1473=Avsittning
1474=Visa/Dlj Map Fnstret
1475=Det r fr lngt borta.
1476=Drag-slpp kn r FULL! Var god vnta.
1477=Pendla mellan War/Peace


================================================
FILE: etc/Language/Razor_lang.tur
================================================
// Razor Turkish/TUR Language Pack
// Last Modified 08/02/05
// Author : Yilmaz YAVUZ [Mystraworld ATi]
::CliLoc=TUR

[controls]
WelcomeForm::Text=Razor a Hosgeldiniz!
WelcomeForm::groupBox3=UO dosya yolu
WelcomeForm::dataBrowse=Bul...
WelcomeForm::label5=Dil:
WelcomeForm::groupBox2=Sunucu ayarlari
WelcomeForm::label3=Sunucu:
WelcomeForm::label4=Port:
WelcomeForm::groupBox1=Istemci Ayarlari
WelcomeForm::useEnc=OSI sifrelemesi kullan
WelcomeForm::makeDef=Bu ayarlari varsayilan yap
WelcomeForm::browse=Bul...
WelcomeForm::label1=Istemci:
WelcomeForm::patchEncy=Patch client encryption
WelcomeForm::showAtStart=Razor basladiginda goster
WelcomeForm::quit=&Cikis
WelcomeForm::okay=&Tamam

MainForm::Text=Razor v{0}[waptir.com]
MainForm::generalTab=Genel
MainForm::label10=Guncelleme ayari:
MainForm::systray=System Tray
MainForm::taskbar=Taskbar
MainForm::smartCPU=Akilli CPU kullanimi
MainForm::label7=Lisan:
MainForm::label11=Goster:
MainForm::groupBox4=Profiller
MainForm::delProfile=Sil
MainForm::newProfile=&Yeni...
MainForm::showWelcome=Acilis ekranini goster(Tum kullanicilar icin)
MainForm::alwaysTop=Akilli ustte kalmayi kullan
MainForm::groupBox1=Filtreler
MainForm::opacityLabel=Seffaf: 100%
MainForm::moreOptTab=Ayarlar
MainForm::setLTHilight=Rnk
MainForm::lthilight=Son hedef belirt:
MainForm::filterSnoop=Snooping mesajlarini gosterme
MainForm::incomingCorpse=Yeni cesetlerin ismini goster
MainForm::incomingMob=Yeni kisi/npclerin ismini goster
MainForm::setHarmHue=Rnk
MainForm::setNeuHue=Rnk
MainForm::lblHarmHue=Zararli
MainForm::lblNeuHue=Tarafsiz
MainForm::lblBeneHue=Yararli
MainForm::setBeneHue=Rnk
MainForm::setSpeechHue=Rnk
MainForm::setWarnHue=Rnk
MainForm::setMsgHue=Rnk
MainForm::setExHue=Rnk
MainForm::autoStackRes=Auto-Stack Ore/Fish/Logs at Feet
MainForm::autoFriend=Partidekileri Friend olarak algila
MainForm::queueTargets=Targetself ve lasttarget leri siraya koy
MainForm::spamFilter=Tekrar eden sistem mesajlarini gosterme
MainForm::label4=ise
MainForm::openCorpses=Yeni cesetleri ac. Uzaklik
MainForm::showNotoHue=Show noto hue on {char} in TitleBar
MainForm::lblWarnHue=Uyari mesaji rengi
MainForm::lblMsgHue=Razor mesaji rengi
MainForm::lblExHue=Arama mesaji rengi
MainForm::chkStealth=Gizli yurume adimlarini say
MainForm::chkForceSpellHue=Buyu renkleri:
MainForm::chkForceSpeechHue=Konusma rengi
MainForm::label3=Buyu yazisi:
MainForm::moreMoreOptTab=Diger Ayarlar
MainForm::blockDis=Savas modunda binekten inme
MainForm::rememberPwds=Parolalari hatirla 
MainForm::showtargtext=Tek clickte hedefi goster
MainForm::smartLT=Akilli lasttarget'i kullan
MainForm::preAOSstatbar=Pre-Aos status unu kullan
MainForm::logPackets=Paket loglamasini ac
MainForm::warnCount=Eger sayaclar dusukse uyar:
MainForm::label8=kare
MainForm::rangeCheckLT=Lasttarget menzili:
MainForm::spellUnequip=Buyu yaparken silahlari indir
MainForm::actionStatusMsg=Siralama mesajlarini goster
MainForm::label6=ms
MainForm::label5=Nesne suresi
MainForm::QueueActions=Nesne geciktirme olaylarini sirala 
MainForm::label9=Istemci ustunlugu:
MainForm::displayTab=Ekran/Sayaclar
MainForm::excludePouches=Pouchlari sakin arama
MainForm::highlightSpellReags=Buyu yaparken regleri belirt
MainForm::titlebarImages=Sayaclarda resim goster
MainForm::sortCounters=Akilli sayac siraliyici kullan
MainForm::checkNewConts=Yeni kutulari ara
MainForm::groupBox3=Baslik Cubugu Gorunumu
MainForm::showInBar=Baslik cubugunda goster:
MainForm::groupBox2=Sayaclar
MainForm::delCounter=Sil/Duznle
MainForm::addCounter=Ekle...
MainForm::recount=Yenile
MainForm::dressTab=Elbise-Item
MainForm::groupBox6=Nesne listesi
MainForm::clearDress=Listeyi sil
MainForm::dressDelSel=Sil
MainForm::undressBag=Cikarma Poseti Ayarla
MainForm::undressList=Cikar
MainForm::dressUseCur=Suankini ekle
MainForm::targItem=Ekle (Nesne)
MainForm::dressNow=Giy
MainForm::groupBox5=Giysi Listesi
MainForm::removeDress=Cikar..
MainForm::addDress=Ekle...
MainForm::undressConflicts=Ayni nesneleri tasi
MainForm::skillsTab=Skiller
MainForm::dispDelta=Otomatik yenile
MainForm::skillCopyAll=Hepsini Kopyala
MainForm::skillCopySel=Secileni Kopyala
MainForm::label1=Skiller toplami:
MainForm::setlocks=Hepsini:
MainForm::resetDelta=Reset  +/-
MainForm::agentsTab=Agents
MainForm::hotkeysTab=Tuslar
MainForm::dohotkey=Secileni yap
MainForm::groupBox8=Tus
MainForm::chkPass=UO ya gecir
MainForm::label2=Tus:
MainForm::unsetHK=Bosalt
MainForm::setHK=Ayarla
MainForm::chkCtrl=Ctrl
MainForm::chkAlt=Alt
MainForm::chkShift=Shift
MainForm::macrosTab=Makrolar
MainForm::macroActGroup=Olaylar
MainForm::loopMacro=Dondur
MainForm::recMacro=Kaydet
MainForm::playMacro=Oynat
MainForm::delMacro=Sil...
MainForm::newMacro=Ekle..
MainForm::screenshotTab=Ekran Goruntusu
MainForm::label12=Resim Formati
MainForm::capNow=Simdi SS cek
MainForm::radioUO=Sadece UO
MainForm::radioFull=Tum Ekran
MainForm::screenAutoCap=Olunce otomatik ss cek
MainForm::setScnPath=...
MainForm::dispTime=Resimlere tarih ekle
MainForm::videoTab=Video cek
MainForm::recFolder=...
MainForm::label13=Kayit klasoru:
MainForm::groupBox7=PacketVideo kayidi
MainForm::vidRec=PacketVideo kaydet
MainForm::groupBox10=AVI Video kayidi
MainForm::recAVI=AVI Video kaydet...
MainForm::label16=Cozunurluk:
MainForm::label15=FPS:
MainForm::groupBox9=PacketVideo Oynat
MainForm::label14=Hiz:
MainForm::label17=Razor mesajlari:
MainForm::vidClose=Kapat
MainForm::vidPlayStop=Dur
MainForm::vidPlay=Oynat
MainForm::vidOpen=Ac...
MainForm::statusTab=Yardim && Status
MainForm::visitForums=Yardim Forumlari
MainForm::visitHome=Razor Anasayfasi
MainForm::visitGuide=Razor Klavuzu

HueEntry::Text=Renk Sec
HueEntry::cancel=Iptal
HueEntry::okay=&Tamam
HueEntry::preview=Onizle
HueEntry::inGame=Oyunda Sec
HueEntry::label1=Renk no:

AddCounter::Text=Sayac editoru
AddCounter::delete=Sil..
AddCounter::target=Hedef 
AddCounter::cancel=Iptal
AddCounter::Add=&Tamam
AddCounter::label4=Renk (Any: -1):
AddCounter::label3=Item ID:
AddCounter::label2=Bicim:
AddCounter::label1=Isim:

MacroInsertWait::Text=Bekleme/Durdurma Ekle...
MacroInsertWait::radioMenu=old-style Menu/Dialog icin bekle
MacroInsertWait::cancel=&Iptal
MacroInsertWait::radioStat=Bekle : 
MacroInsertWait::radioTarg=Hedef bekle :
MacroInsertWait::radioGump=Gumpi bekle :
MacroInsertWait::label1=milliseconds
MacroInsertWait::radioPause=Bekle:
MacroInsertWait::insert=&Ekle

MacroInsertIf::Text=If.. ekle
MacroInsertIf::label1=If:
MacroInsertIf::cancel=&Iptal
MacroInsertIf::insert=&Ekle

[strings]
1001=Death Status
1002=Bard Muzikleri
1003=Kopek sesleri
1004=Kedi sesleri
1005=At sesleri
1006=Koyun sesleri
1007=Spirit Speak sesi
1008=Buyu fizzle sesi
1009=Hava olayi sesi
1010=Sayaclari goster
1011=Sayaclari yenile
1012=AOS abilitylerini sil
1013=Set Primary Ability (AOS)
1014=Set Secondary Ability (AOS)
1015=Toggle Stun (Pre-AOS)
1016=Toggle Disarm (Pre-AOS)
1017=Setting ability {0}
1018=AOS Abilities cleared.
1019=Hepsini cikar
1020=Ellerindekini indir
1021=Sol elindekini indir
1022=Sag elindekini indir
1023=Sapkayi cikar
1024=Yuzuk/Bilezik cikar
1025=Bandaj self
1026=Son hedefe bandaj
1027=Bandaj kullan (Timersiz)
1028=Heal ic
1029=Cure ic
1030=Refresh ic
1031=Night Sight ic
1032=Explosion at
1033=Strength ic
1034=Agility ic
1035=Bandaj bulunamadi :(
1036=item type {0} bulunamadi :(
1037=Cift tikla ({0})
1038=Yeni hedef
1039=Tipine gore tiklamali yap
1040=Bu olaya yeni hedef yap.
1041=WARNING: Exception while loading profile property:\n{0}
1042=Macro Warning: Cannot find that item (Out of Range).
1043=Kaldir {1} - {0}
1044=Tipine gore kaldirmali yap
1045=Macro Warning: Hic bisi kaldirmiyor.
1046=Giy/tak {0} (L:{1})
1047=Cikar {0} (@{1})
1048=Bolgeye gore hedefle
1049=Cikar (Relative) @({0},{1},{2})
1050=Tiklama (Button {0})
1051=Kapatma
1052=Menu tiklama {0}
1053=Warning: Macro requested target, but no target sent from server! (Do you need a 'WaitForTarget'?)
1054=Bir hedef
1055=Son hedefe cevir
1056=Tipine gore hedefe cevir
1057=Target RelLoc ({0},{1})
1058=Son hedef
1059=Kendine hedef
1060=Son hedef yap
1061=Herhangi bir kirmiziyi hedefle
1062=Herhangi bir griyi hedefle
1063=Herhangi bir maviyi hedefle
1064=Herhangi bir dusmani hedefle
1065=Herhangi bir arkadasi hedefle
1066=Herhangi bir arkadas olmayani hedefle
1067=Soyle: "{0}"
1068=Skill kullan: {0}
1069=Buyu yap: {0}
1070=Ability yap: {0}
1071=Giy: {0}
1072=Cikar: {0}
1073=Unequip Layer {0}
1074=Herhangi bir menuyu bekle
1075=Menuyu bekle: (#{0})
1076=Duzenle...
1077=Herhangi bir gump u bekle
1078=Gump u bekle: (#{0})
1079=Hedefi bekle
1080={0:#.00}sn bekle
1081={0} {1} {2} icin bekle
1082=Yukleniyor: '{0}'...
1083=> Makroyu durdur
1084=Oynat: {0}
1085=Makro aktif '{0}'...
1086=Makro '{0}' bitti.
1087=Razor was unable to initialize.  Error code:\n
1088=Description: Could not find the client Window Handle.\nPossible Cause: The Client may not have initialized properly.
1089=Description: Could not find the Client's ThreadID\nPossible Cause: The Client may not have initialized Properly.
1090=Description: Could not create Windows Hooks.\nPossible Cause: Internal error.
1091=Description: Could not create or access Razor shared memory.\nPossible Cause: Windows Error or invalid permissions.
1092=Description: Crypt.dll has disabled itself.\nPossible Cause: Version mismatch.
1093=Description: Could not patch the client's Winsock functions.\nPossible Cause: Internal error, Windows Error, or Incompatible Version.
1094=
1095=Warning: Could not copy packet lengths and/or encryption information from the client.\nRazor may be able to run without this information, though some features may not function correctly.  Would you like to start Razor anyway?\n\nPossible Cause: Your client version may not be compatible with this version of Razor.
1096={0} skillin {4}{5:F1} degisti, simdi {3:F1} ({1}{2:F1}) oldu.
1097=Invalid abbreviation.
1098=Gecersiz itemid.
1099=Gecersiz renk.
1100=Sayacagim nesneyi secin.
1101=Error loading '{0}'!\nThis profile is corrupt and cannot be used.
1102={0} ozelligi bu profilde bulunamadi.
1103=counters.xml dosyaniz hasar gormus kullanilamiyor
1104=Because you have Auto Search Containers off, you must now reopen all of your bags so that your counters can be updated.
1105=Dikkat: {0} nesnesinden sadece {1} tane kaldi!
1106=Kullanmak istedigin rengi sec.
1107=Simdi SS al

1109=Razor Version: {0}\nMemory Used: {1}\nSend: {2} ({3}/s)\nRecv: {4} ({5}/s)\nConnected for {6}\n\nPlayer Serial: 0x{7:X8}\nBackpack Serial: 0x{8:X8}\n\nTracking Items: {9}\nTracking Mobs: {10}\nTurkce ceviri :\nMystraworld ATi (Y&&Y) waptir.com
1110=Set Lock: Yukari
1111=Set Lock: Asagi
1112=Set Lock: Kilitli
1113="{0}" sayacini silmek istediginize eminmisiniz?\nButun profillerde silinecektir.
1114="{0}" profilini simdi yukleyimmi?
1115=Profili yuklerken hata olustu
1116=Varsayilan profili kolay kolay silemezsiniz :)
1117=Profilinize isim yazin: 
1118=Profil olusturulamiyor!\n Cunku bu isimden bidene daha var.\n\nSimdi bu eski profili yukliyimmi?
1119=Yeni elbise listesi icin isim girin:
1120=Bu elbise listesini silmek istediginize eminmisiniz?
1121={0:X} (Item out of Range)
1122=Bu nesneyi listeden silmek istediginize eminmisiniz?
1123='{0}' listesindeki itemleri bosaltmak icin bir kutu/poset secin.
1124=Cikarma poseti ayarlandi.
1125=Nesne bulunamiyor yada sizde bir dandiklik var.
1126=That key combination already belongs to '{0}'.\nChange it to '{1}'?
1127=Veri basariyla kaydedildi.
1128=Warning!\nLogging packets may reduce Razor's performance. Log files can also\neasily grow very large, and Razor will not automatically remove them.\n\nRazor's packet log files may contain personal information such as\npasswords, and should be not be given to people you do not trust.\n\nAre you sure you want to enable packet logging?\n(This will not be saved in your user profile)
1129=Secileni bu tipe cevir
1130=Yeni makroya bi isim girin: 
1131=Bu isim olmaz kiytirik karakterler iceriyor.
1132=Bu isimde bir makro zati var.
1133=Kaydedilmeden once eski kayitli makro silinecek.\nKaydetmek istediginize eminmisiniz?
1134='{0}' silmeyi gercekten istiyormusunuz?\n(Geri donusu yok ona gore)
1135=Bekle/Durma ekle..
1136=Son hedefi secme ekle..
1137=Yukari tasi
1138=Asagi tasi
1139=Bunu sil
1140=Burdan kaydetmeye basla
1141='{0}' dosyasi bulunamadi.
1142=Eminmisin?
1143=WARNING: The following {0} file{1} count not be deleted:\n{2}
1144=Razoru yeniden baslatinca bu secenek aktif olacaktir
1145=Bu secenegi secerek parolalarinizi profilinizin bir parcasi olarak saklayacaksiniz..\nEger birileri sizin profilinizin xml dosyasini bulursa ozaman yandiniz.\nBunu halen aktif etmek istiyormusunuz?
1146=Lutfen doru durust port girin adami ayar etmeyin.
1147=Ignoring action request (already queued).
1148=Queuing action request {0}... {1} left.
1149={0} siralanmis olay {1:F1} saniyede bitti.
1150=Use Once Agent
1151=Ekle (Target)...
1152=Kutu Ekle (Target)...
1153=Sil (Target)...
1154=Listeyi sil
1155=Eklemek icin bir nesne secin
1156=Bir utu secin.
1157=Silmek icin bir nesne secin.
1158=Nesne Eklendi.
1159=Nesne Silindi.
1160={0} nesne Use Once agent a eklendi.
1161=Useonce sirasi bos.
1162=Using '{0}'.  ({1} item(s) left in the UseOnce queue)
1163=There was a problem with one of your UseOnce items, trying the next one.
1164=SellAgent: Sizin yerinize {0} nesneyi {1}gp satti.
1165=Sil
1166=Kutu basariyla ayarlandi.
1167=Bosalt
1168=(Kapatmak icin tikla)
1169=(Acmak icin tikla)
1170=Poseti ayarla
1171=Poseti iptalet
1172=Organizer Agent
1173=Toplayici
1174=Simdi topla
1175=Kutu ayarli degil.
1176=Razor cebinizi bulamadi.
1177=Toplayici {0} tane nesneyi tasiyacak bu azcik zaman alabilir.
1178=Toplayici hicbir tasinacak nesne bulamadi
1179=Bu nesne zaten listede.
1180=AutoSearchExemptions
1181={0} nesne sizin yerinize {1}gp ye satin alindi.
1182=Satin alma agenti paraniz olmadigindan yada yetmediginden satin alamadi.
1183=Miktar girin:
1184=Istemci calisma seviyesi {0} e getirildi
1185=Suanki zaman: {0}
1186=You are at {0} in '{1}'
1187=Cikarma poseti bulunamadi yada cok uzak, onun yerine cebinize cikardim.
1188={0} nesne cikarilacak.
1189={0} nesne giyilmek icin siraya kondu.
1190={0} nesne zaten giyilmis.
1191={0} nesne bulunamadi yada menzil disi
1192=Uyari : buyu ozelligi bulunamadi buyu yazisi gorunmeyecek
1193=Gizli adim: {0}
1194=Suan gizli adimlariniz sayilmaya baslandi.
1195=Hedef sirasini bosalt
1196=Son dusmana saldir
1197=Hedef sirasi bosaltildi.
1198=Yeni bir 'Son hedef' secin
1199=Son Hedef ayarlandi.
1200=Yeni hedef ayarlandi.
1201=Bu nitelige uygun biri ekranda yok.
1202=Kendine hedef alma siraya kondu.
1203=Son hedef siraya kondu.
1204=Sunucu yeni bir hedef belirledi, razorunki iptal oldu.
1205={0} tipine gore hedefle
1206=Copcu
1207=Bunu silmek istediginize eminmisiniz?
1208=Razorun SS lerini saklamak icin bir klasor secin.
1209=Tuslar
1210=Nesneler
1211=Hedefler
1212=Agentlar
1213=Giyinme
1214=Makrolar
1215=Buyuler
1216=Skiller
1217=Digerleri
1251=1st
1252=2nd
1253=3rd
1254=4th
1255=5th
1256=6th
1257=7th
1258=8th
1260=Necromancy
1270=Chivalry
1271=Potions
1272=Special Moves
1290=Bushido
1300=Ninjitsu
1301=Sat
1302=Satinal
1303=Input Required
1304=Razor komutlari listesi
1305=Elindeki itemi kullan
1306=Bisiyi elinden dusurmeden once eline alman gerek.
1307=Sag eline silah Al/Birak
1308=Sol eline silah Al/Birak
1309=Suan elinde tuttugunu dusur

1311=>Razor tuslarini kullanima Ac/Kapat
1312=Tuslar acik {0} a tikla kapat
1313=Tuslar kapali {0} a tikla ac
1314=Razor tuslari acildi
1315=Razor tuslari kapatildi
1316=Yuru: {0}
1317=Tip ekle (Target)...
1318=Istenen hedef bulunamadi, son hedefi calistiramadim!
1319=En fazla {0} tane sat
1320=Snooping Mesajlari
1321=Cep sesleri
1322="If/Eger" ekle
1323="Else/Degilse" ekle
1324="End If/Egeri bitir" ekle
1325=Miktar ayarla
1326=Doldur
1327=Simdi Doldur
1328=Doldurma Agenti
1329=Doldurmak icin kullanilacak kutuyu gosterin yada kendinize tiklayin bankanizdan doldurayim.
1330=Bu kutu yanlis.
1331={0} nesnenin doldurmasi tamamlandi{1}.
1332=Simdiki hedefi iptal et
1333=Yeni razor srm cikmis yuklemek icin web sitesini ziyaret etmek istermisin?
1334=Yenile
1335=Kaydet
1336=Uyari: Suanki hedef yeri secmenizi desteklemiyor, son hedef calistirilamadi.
1337=Istemciyi senkronize et
1338=Binekten inme engellendi.
1339=PacketVideo kaydetmeye basladi
1340="PacketVideo" kayit/tekrari durdur
1341=Kayda baslarken hata olustu.
1342=Bu dosya razorun bu surumu ile uygun degil en son surum razor kullandiginize emin olun.
1343=Bu video dosyasi bozulmus, belki yarim kalmis olabilir, dosya oynatilamadi.
1344=Dosyayi okurken problemle karsilasildi, dosya hasar gormus olabilir.
1345=Kategori ismi gir:
1346=Klasor silinemedi icinin bos olduguna emin olun.
1347=Klasor olusturulamadi dogru isim girdiginize emin olun.
1348=Makro dosyasi tasinamadi kategoriyi dogru girdiginize emin olun.
1349=Arkadaslar
// 1350 to 1359 reserved (max length 15!)
1350=Durduruldu
1351=Bitti
1352=Oyun bittimi?
1353=ker-pwned
1354=girdimi corpor
1355=imamin kayigi..
1356=yattinmi?
1357=Toprai bololsun
1358=Kal Vas yedi
1359=SMACKDOWN
1360=Arkadaslara eklemek icin bir oyuncu sec.
1361=Arkadaslardan silmek icin bir oyuncu sec.
1362=Arkadas eklendi.
1363=Arkadas silindi.
1364=Ozel islemler
1365="For Loop/Dongu" ekle
1366="End For/Dongu bitirme" ekle
1367=Dongu sayisi :
1368=Bellegi temizle
1369=Son buyu
1370=Son skill
1371=Son nesne
1372=Tum isimler
1373=UseOnce
1374=Herhangi bir dusman insani hedefle
1375=Herhangi bir gri insani hedefle
1376=Herhangi bir mavi insani hedefle
1377=Herhangi bir crim insani hedefle
1378=Herhangi bir crimi hedefle
1379=UYARI: Tasima suresi zamanasimi oldu eldeki item cebe koyuldu.
1380=Bu degisikligin olmasi icin razoru yeniden baslatman gerek
1381=Bu degisikligin olmasi icin serverdan cikip tekrar girmen gerek

================================================
FILE: etc/Razor.nsi
================================================
;--------------------------------
;Include Modern UI

  !include "MUI.nsh"

;--------------------------------
;General

  ;Name and file
  Name "Razor"
  OutFile "Razor1013_Inst.exe"

  ;Default installation folder
  InstallDir "$PROGRAMFILES\Razor"
  
  ;Get installation folder from registry if available
  InstallDirRegKey HKLM "Software\Razor" "InstallDir"


;--------------------------------
;Variables

  Var MUI_TEMP
  Var STARTMENU_FOLDER

;--------------------------------
;Interface Settings

  !define MUI_ABORTWARNING

;--------------------------------
;Pages

  !insertmacro MUI_PAGE_LICENSE ".\License.txt"
  !insertmacro MUI_PAGE_DIRECTORY
  
  ;Start Menu Folder Page Configuration
  !define MUI_STARTMENUPAGE_REGISTRY_ROOT "HKLM" 
  !define MUI_STARTMENUPAGE_REGISTRY_KEY "Software\Razor" 
  !define MUI_STARTMENUPAGE_REGISTRY_VALUENAME "StartMenuFolder"
  
  !insertmacro MUI_PAGE_STARTMENU Application $STARTMENU_FOLDER

  !insertmacro MUI_PAGE_INSTFILES
  
  !insertmacro MUI_UNPAGE_CONFIRM
  !insertmacro MUI_UNPAGE_INSTFILES

;--------------------------------
;Languages
 
  !insertmacro MUI_LANGUAGE "English"

;--------------------------------
;Installer Sections

Section "Razor" 

  ;Store installation folder
  WriteRegStr HKLM "Software\Razor" "InstallDir" $INSTDIR
  WriteRegStr HKLM "Software\Razor" "UId" "0"

  ; For tugsoft plugins to function just make sure the tugsoft key exists... put in a dummy value
  WriteRegStr HKCU "Software\Tugsoft\UOAssist\ThirdParty" "Owner" "Razor"

  WriteRegStr HKCR ".rpv" "" "Razor.PacketVideo"
  WriteRegStr HKCR "Razor.PacketVideo\DefaultIcon" "" "$INSTDIR\RPVOpenStub.exe,0"
  WriteRegStr HKCR "Razor.PacketVideo\shell\open\command" "" '"$INSTDIR\RPVOpenStub.exe" %1'

  CreateDirectory "$INSTDIR\Language"

  SetOutPath "$INSTDIR"

  WriteUninstaller "$INSTDIR\Uninstall.exe"

  File ".\Razor.exe"
  File ".\RPVOpenStub.exe"
  ;File ".\RPVEditor.exe"
  File ".\Updater.exe"
  File ".\unrar.dll"
  File ".\Crypt.dll"
  File ".\Loader.dll"
  File ".\Ultima.dll"
  File ".\zlib.dll"
  File ".\License.txt"
  File ".\License_CHS.txt"
  File ".\changelog.txt"

  File ".\Newtonsoft.Json.dll"

  SetOverwrite ifnewer
  File ".\Guardlines.def"
  File ".\Spells.def"
  File ".\Counters.xml"
  SetOverwrite on

  Delete "$INSTDIR\Crash.log"

  SetOutPath "$INSTDIR\Language"
  File ".\Language\Razor_lang.*"
  
  !insertmacro MUI_STARTMENU_WRITE_BEGIN Application
    
    ;Create shortcuts
    CreateDirectory "$SMPROGRAMS\$STARTMENU_FOLDER"
    CreateShortCut "$SMPROGRAMS\$STARTMENU_FOLDER\Razor.lnk" "$INSTDIR\Razor.exe"
    ;CreateShortcut "$SMPROGRAMS\$STARTMENU_FOLDER\RPV Editor (Alpha).lnk" "$INSTDIR\RPVEditor.exe"
    CreateShortCut "$SMPROGRAMS\$STARTMENU_FOLDER\Visit Razor's Website.lnk" "https://github.com/msturgill/razor"
    CreateShortCut "$SMPROGRAMS\$STARTMENU_FOLDER\Uninstall.lnk" "$INSTDIR\Uninstall.exe"
    CreateShortcut "$DESKTOP\Razor.lnk" "$INSTDIR\Razor.exe"
  
  !insertmacro MUI_STARTMENU_WRITE_END

SectionEnd

;--------------------------------
;Uninstaller Section

Section "Uninstall"

  DeleteRegKey HKCR ".rpv"
  DeleteRegKey HKCR "Razor.PacketVideo"
  DeleteRegKey HKLM "Software\Razor"
  DeleteRegKey HKCU "Software\Razor"

  Delete "$INSTDIR\Razor.exe"
  Delete "$INSTDIR\RPVOpenStub.exe"
  ;Delete "$INSTDIR\RPVEditor.exe"
  Delete "$INSTDIR\Crypt.dll"
  Delete "$INSTDIR\UOG.dll"
  Delete "$INSTDIR\Loader.dll"
  Delete "$INSTDIR\Ultima.dll"
  Delete "$INSTDIR\zlib.dll"
  Delete "$INSTDIR\Spells.def"
  Delete "$INSTDIR\Uninstall.exe"
  Delete "$INSTDIR\License.txt"
  Delete "$INSTDIR\License_CHS.txt"
  Delete "$INSTDIR\UOReport0.log"
  Delete "$INSTDIR\Crash.log"
  Delete "$INSTDIR\changelog.txt"
  Delete "$INSTDIR\Guardlines.def"

  Delete "$INSTDIR\Newtonsoft.Json.dll"

  RMDir /r "$INSTDIR\Language"

  MessageBox MB_YESNO|MB_ICONQUESTION "Do you want to save your razor profiles and macros?  (Selecting no will delete them)" IDYES AfterProfiles
    Delete "$INSTDIR\Counters.xml"
    RMDir /r "$INSTDIR\Profiles"
    RMDir /r "$INSTDIR\Macros"

AfterProfiles:

  MessageBox MB_YESNO|MB_ICONQUESTION "Do you want to save your screen shots and video captures?  (Selecting no will delete them)" IDYES AfterSS
    RMDir /r "$INSTDIR\ScreenShots"
    RMDir /r "$INSTDIR\Videos"

AfterSS:

  RMDir "$INSTDIR"
  
  !insertmacro MUI_STARTMENU_GETFOLDER Application $MUI_TEMP
    
  Delete "$SMPROGRAMS\$MUI_TEMP\Uninstall.lnk"
  Delete "$SMPROGRAMS\$MUI_TEMP\Razor.lnk"
  ;Delete "$SMPROGRAMS\$MUI_TEMP\RPV Editor (Alpha).lnk"
  Delete "$SMPROGRAMS\$MUI_TEMP\Visit Razor's Website.lnk"
  Delete "$DESKTOP\Razor.lnk"
  
  ;Delete empty start menu parent diretories
  StrCpy $MUI_TEMP "$SMPROGRAMS\$MUI_TEMP"
 
  startMenuDeleteLoop:
    RMDir $MUI_TEMP
    GetFullPathName $MUI_TEMP "$MUI_TEMP\.."
    
    IfErrors startMenuDeleteLoopDone
  
    StrCmp $MUI_TEMP $SMPROGRAMS startMenuDeleteLoopDone startMenuDeleteLoop
  startMenuDeleteLoopDone:

SectionEnd


================================================
FILE: etc/animdata.csv
================================================
abysmal_horror (312),312
ant_lion (787),787
arachnids_spider_black_widow (157),157
arachnids_spider_black_widow2 (173),173
arachnids_spider_dread (11),11
arachnids_spider_dread2 (19),19
arachnids_spider_frost (20),20
arachnids_spider_giant (28),28
arcane_demon (784),784
Bimbobushi (242),242
birds_eagle (5),5
birds_generic (6),6
black_ant_matriarch (808),808
black_ant_queen (807),807
black_ant_warrior (806),806
black_ant_worker (805),805
bog_thing (780),780
bogling (779),779
bonedemon (308),308
bovines_bull_brown (232),232
bovines_bull_spotted (233),233
bovines_cow_brown (216),216
bovines_cow_spotted (231),231
bruins_bear_black (211),211
bruins_bear_brown (167),167
bruins_bear_grizzly (212),212
bruins_bear_polar (213),213
canines_dog_hound (217),217
canines_hell_hound (97),97
canines_hell_hound2 (98),98
canines_wolf_dark (99),99
canines_wolf_dire (23),23
canines_wolf_grey (25),25
canines_wolf_grey2 (27),27
canines_wolf_silver (100),100
canines_wolf_timber (225),225
canines_wolf_white (34),34
canines_wolf_white2 (37),37
centaurs_centaur (101),101
Changling (264),264
chaos_demon (792),792
character_blackthorn (991),991
character_dupre (994),994
character_lord_british (990),990
chariot (786),786
clockwork_minion (757),757
clockwork_minion2 (763),763
clockwork_overseer (756),756
Crane (254),254
Crow (283),283
crystal_elemental (300),300
CuShidhe (277),277
cyclops_cyclops (75),75
daemons_daemon (9),9
daemons_daemon_black_gate (38),38
daemons_daemon_elder (40),40
daemons_daemon_exodus (102),102
daemons_daemon_ice_fiend (43),43
daemons_daemon2 (10),10
Darknight_Creeper (313),313
Dawn_Girl (774),774
deer_doe (237),237
deer_stag (234),234
demon_knight (318),318
Denkou_Yajuu (196),196
devourer (303),303
dolphins_dolphin (151),151
doppleganger (777),777
dragons_dragon_asian (103),103
dragons_dragon_retro_grey (12),12
dragons_dragon_retro_grey2 (60),60
dragons_dragon_retro_red (59),59
dragons_dragon_retro_red2 (61),61
dragons_dragon_retro_red3 (172),172
dragons_dragon_skeletal (104),104
dragons_wyrm_ancient (105),105
dragons_wyrm_retro_white (49),49
dragons_wyrm_retro_white2 (180),180
dragons_wyrm_shadow (106),106
dragons_wyvern (62),62
DreadHorn (257),257
Dryad (266),266
elementals_acid_elemental (158),158
elementals_agapite_elemental (107),107
elementals_air_elemental (13),13
elementals_blood_elemental (159),159
elementals_blood_elemental2 (160),160
elementals_bronze_elemental (108),108
elementals_copper_dull_elemental (110),110
elementals_copper_elemental (109),109
elementals_earth_elemental (14),14
elementals_fire_elemental (15),15
elementals_gold_elemental (166),166
elementals_ice_elemental (161),161
elementals_iron_elemental (111),111
elementals_poison_elemental (162),162
elementals_snow_elemental (163),163
elementals_valorite_elemental (112),112
elementals_verite_elemental (113),113
elementals_water_elemental (16),16
equines_horse_dappled_brown (200),200
equines_horse_dappled_brown_pack (291),291
equines_horse_dappled_grey (226),226
equines_horse_dark_brown (204),204
equines_horse_dark_steed (114),114
equines_horse_ethereal (115),115
equines_horse_firesteed (190),190
equines_horse_nightmare (116),116
equines_horse_nightmare2 (177),177
equines_horse_nightmare3 (178),178
equines_horse_nightmare4 (179),179
equines_horse_silver_steed (117),117
equines_horse_tan (228),228
equines_horse_war_brittanian (118),118
equines_horse_war_mage_council (119),119
equines_horse_war_minax (120),120
equines_horse_war_shadowlord (121),121
equines_unicorn (122),122
equines_unicorn_ethereal (192),192
ethereal_warriors_male (123),123
ethereal_warriors_male2 (175),175
ethereals_energy_vortex (164),164
ethereals_wisp (58),58
ethereals_wisp2 (165),165
ettins_ettin (2),2
ettins_ettin2 (18),18
Fan_Dancer (247),247
felines_cougar (63),63
felines_housecat (201),201
felines_leopard_snow (64),64
felines_leopard_snow2 (65),65
felines_panther (214),214
felines_predator_hellcat (127),127
Ferret (279),279
Fetid_Essence (273),273
fey_race_pixie (128),128
fey_race_pixie2 (176),176
fire_ant_matriarch (804),804
fire_ant_queen (783),783
fire_ant_warrior (782),782
fire_ant_worker (781),781
flails_corpser (8),8
flails_reaper (47),47
flails_swamp_tentacles (66),66
flails_swamp_tentacles2 (129),129
flesh_golem (304),304
flesh_renderer (315),315
four_armed_demon (746),746
four_armed_demon2 (785),785
fowl_normal_hen (208),208
frogs_bullfrog (81),81
frogs_frog_giant (80),80
gargoyles_gargoyle (4),4
gargoyles_gargoyle_blistering (130),130
gargoyles_gargoyle_enforcer (754),754
gargoyles_gargoyle_guard (755),755
gargoyles_gargoyle_shopkeeper (758),758
gargoyles_gargoyle_slave (753),753
gargoyles_gargoyle_stone (67),67
gazers_gazer (22),22
gazers_gazer_elder (68),68
gazers_gazer_elder2 (69),69
genies_efreet (131),131
giant_beetle (791),791
giant_beetle_ethereal (195),195
Giant_Beetle_Fire (169),169
gibberling (307),307
golem_iron (752),752
gore_fiend (305),305
gorillas_silverback (29),29
Gouzen_Ha (199),199
h_female (401),401
h_female1 (606),606
h_female3 (745),745
h_male (400),400
h_male1 (605),605
h_male3 (744),744
H_Savage_Female (184),184
h_savage_female (751),751
H_Savage_Female2 (186),186
H_Savage_Male (183),183
h_savage_male (750),750
H_SavageRider_Male (185),185
Hai_Riyo (243),243
harpies_harpy (30),30
harpies_harpy_stone (73),73
headless_headless (31),31
horde_demon (776),776
horde_demon2 (795),795
horde_demon3 (796),796
Hydra (265),265
impaler (306),306
imps_imp (74),74
imps_shadow_fiend (168),168
Juggernaut (768),768
Juka_Mage (765),765
Juka_Warrior (764),764
Kappa (240),240
kirin_kirin (132),132
kirin_kirin_ethereal (191),191
Kitsun_Tsuki (246),246
krakens_kraken (77),77
Lady_of_the_Snow (252),252
LadyMelisande (258),258
LeatherMinotaur (281),281
liche_liche_lord_retro (78),78
liche_liche_lord_retro2 (79),79
liche_liche_lord_retro3 (82),82
liche_liche_retro (24),24
liche_liche_retro3 (749),749
lizard_race_lizardman (33),33
lizard_race_lizardman2 (35),35
lizard_race_lizardman3 (36),36
lizards_alligator_brown (202),202
lizards_alligator_small (133),133
lizards_komodo_dragon (134),134
lizards_lava_lizard (206),206
llamas_llama (220),220
llamas_llama_ethereal (170),170
llamas_llama_pack (292),292
mages_evil_mage (124),124
mages_evil_mage_master (125),125
mages_evil_mage_master2 (126),126
Meer_Mage (770),770
Meer_Warrior (771),771
mf_dragon_fire (797),797
Mf_Dragon_Rust (46),46
mf_dragon_rust (798),798
Minotaur (263),263
MinotaurArmored (280),280
MondainSteed01 (284),284
mongbats_mongbat (39),39
MonstrousInterredGrizzle (259),259
MonstrousInterredGrizzle2 (272),272
mound_of_maggots (319),319
Multi Colored Horde Deamon (999),999
NPC_Adranath (772),772
NPC_Blackthorn (769),769
NPC_Blackthorn_Cohort (767),767
NPC_Cpt_Dasha (773),773
NPC_Kabur (766),766
ogres_ogre (1),1
ogres_ogre_lord (83),83
ogres_ogre_lord_arctic (135),135
ogres_ogre_lord2 (84),84
Oni (241),241
ophidians_ophidian_archmage (136),136
ophidians_ophidian_knight (137),137
ophidians_ophidian_mage (85),85
ophidians_ophidian_queen (87),87
ophidians_ophidian_warrior (86),86
orcs_orc (17),17
orcs_orc_bomber (182),182
orcs_orc_captain (7),7
orcs_orc_lord (138),138
orcs_orc_lord2 (139),139
orcs_orc_lord3 (189),189
orcs_orc_scout (181),181
orcs_orc_shaman (140),140
orcs_orc2 (41),41
ostards_ostard_desert (210),210
ostards_ostard_ethereal (171),171
ostards_ostard_forest (218),218
ostards_ostard_frenzied (219),219
paladins_paladin (141),141
Paroxysmus (256),256
Parrot (282),282
patchskeleton (309),309
plague_beast (775),775
player_ghost5 (970),970
porcines_boar (290),290
porcines_pig (203),203
quagmire (789),789
Raptalon (276),276
rat_race_ratman (42),42
rat_race_ratman2 (44),44
rat_race_ratman3 (45),45
rat_race_ratman4 (142),142
rat_race_shaman (143),143
ravager (314),314
ReaperForm (285),285
ridgeback_ridgeback (187),187
ridgeback_ridgeback_ethereal (193),193
ridgeback_savage (188),188
rodents_rabbit_cottontail (205),205
rodents_rat_giant (215),215
rodents_rat_sewer (238),238
ruminants_goat_billy (209),209
ruminants_goat_mountain (88),88
ruminants_sheep (207),207
ruminants_sheep_shorn (223),223
Rune_Beetle (244),244
sand_vortex (790),790
Satyr (271),271
scorpions_giant (48),48
sea_horse_sea_horse (144),144
sea_serpents_sea_serpent (145),145
sea_serpents_sea_serpent2 (150),150
serpents_snake (52),52
serpents_snake_giant (21),21
serpents_snake_giant_ice (89),89
serpents_snake_giant_lava (90),90
serpents_snake_giant_silver (91),91
serpents_snake_giant_silver2 (92),92
serpents_snake_giant_silver3 (93),93
shadow_knight (311),311
shadowlords_shadowlord (146),146
Shimmering_Effusion (261),261
skeletal_mount (793),793
skeletons_skeleton (50),50
skeletons_skeleton_knight (147),147
skeletons_skeleton_mage (148),148
skeletons_skeleton2 (56),56
skeletons_skeleton3 (57),57
skittering_hopper (302),302
slimes_slime (51),51
slimes_slime_frost (94),94
slimes_slime_frost2 (96),96
sphinx (788),788
spirits_blade_spirit (574),574
spirits_ghost (26),26
spirits_ghost2 (748),748
Squirrel (278),278
succubi_succubus (149),149
succubi_succubus2 (174),174
swamp_dragon (794),794
swamp_dragon_armor (799),799
swamp_dragon_ethereal (194),194
swarm (778),778
terathan_terathan_avenger (152),152
terathan_terathan_drone (71),71
terathan_terathan_queen (72),72
terathan_terathan_warrior (70),70
titans_titan (76),76
TormentedMinotaur (262),262
treefellow (301),301
Tri_Wolf (250),250
Troglodyte (267),267
trolls_troll (53),53
trolls_troll_frost (55),55
trolls_troll2 (54),54
vampire_bat (317),317
Vampyric_Beast (251),251
wailingbanshee (310),310
wailingbanshee2 (747),747
walking_dead_ghoul (153),153
walking_dead_mummy (154),154
walking_dead_rotting_corpse (155),155
walking_dead_zombie (3),3
walrus_walrus_male (221),221
wander (316),316
Wild_Guar (248),248
Yamandon (249),249
Yomotsu_Elder (255),255
Yomotsu_Priest (253),253
Yomotsu_Warrior (245),245


================================================
FILE: etc/counters.xml
================================================
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<counters>
	<counter>
		<name>Bandages</name>
		<format>aids</format>
		<itemid>3617</itemid>
		<hue>-1</hue>
	</counter>
	<counter>
		<name>Black Pearl</name>
		<format>bp</format>
		<itemid>3962</itemid>
		<hue>0</hue>
	</counter>
	<counter>
		<name>Blood Moss</name>
		<format>bm</format>
		<itemid>3963</itemid>
		<hue>0</hue>
	</counter>
	<counter>
		<name>Cure Potions</name>
		<format>cure</format>
		<itemid>3847</itemid>
		<hue>0</hue>
	</counter>
	<counter>
		<name>Garlic</name>
		<format>gl</format>
		<itemid>3972</itemid>
		<hue>0</hue>
	</counter>
	<counter>
		<name>Ginseng</name>
		<format>gs</format>
		<itemid>3973</itemid>
		<hue>0</hue>
	</counter>
	<counter>
		<name>Heal Potions</name>
		<format>heal</format>
		<itemid>3852</itemid>
		<hue>0</hue>
	</counter>
	<counter>
		<name>Mandrake Root</name>
		<format>mr</format>
		<itemid>3974</itemid>
		<hue>0</hue>
	</counter>
	<counter>
		<name>Nightshade</name>
		<format>ns</format>
		<itemid>3976</itemid>
		<hue>0</hue>
	</counter>
	<counter>
		<name>Spider's Silk</name>
		<format>ss</format>
		<itemid>3981</itemid>
		<hue>0</hue>
	</counter>
	<counter>
		<name>Sulfurous Ash</name>
		<format>sa</format>
		<itemid>3980</itemid>
		<hue>0</hue>
	</counter>
	<counter>
		<name>Arrows</name>
		<format>arw</format>
		<itemid>3903</itemid>
		<hue>-1</hue>
	</counter>
	<counter>
		<name>Bolts</name>
		<format>blt</format>
		<itemid>7163</itemid>
		<hue>-1</hue>
	</counter>
	<counter>
		<name>Platinum</name>
		<format>plat</format>
		<itemid>3821</itemid>
		<hue>1154</hue>
	</counter>
	<counter>
		<name>Folded Cloth</name>
		<format>fcloth</format>
		<itemid>5990</itemid>
		<hue>-1</hue>
	</counter>
	<counter>
		<name>Cloth Bolts</name>
		<format>bcloth</format>
		<itemid>3989</itemid>
		<hue>-1</hue>
	</counter>
	<counter>
		<name>Logs</name>
		<format>logs</format>
		<itemid>7133</itemid>
		<hue>-1</hue>
	</counter>
	<counter>
		<name>Thread</name>
		<format>thread</format>
		<itemid>4000</itemid>
		<hue>-1</hue>
	</counter>
	<counter>
		<name>Yarn</name>
		<format>yarn</format>
		<itemid>3613</itemid>
		<hue>-1</hue>
	</counter>
	<counter>
		<name>Sewing Kit</name>
		<format>sewing</format>
		<itemid>3997</itemid>
		<hue>-1</hue>
	</counter>
	<counter>
		<name>Cotton Bale</name>
		<format>bale</format>
		<itemid>3577</itemid>
		<hue>-1</hue>
	</counter>
	<counter>
		<name>Lockpicks</name>
		<format>lp</format>
		<itemid>5372</itemid>
		<hue>-1</hue>
	</counter>
	<counter>
		<name>Explosion Potions</name>
		<format>explo</format>
		<itemid>3853</itemid>
		<hue>-1</hue>
	</counter>
	<counter>
		<name>Agility Potions</name>
		<format>agility</format>
		<itemid>3848</itemid>
		<hue>-1</hue>
	</counter>
	<counter>
		<name>Total Refresh Potion</name>
		<format>refresh</format>
		<itemid>3851</itemid>
		<hue>-1</hue>
	</counter>
	<counter>
		<name>Strength Potion</name>
		<format>strength</format>
		<itemid>3849</itemid>
		<hue>-1</hue>
	</counter>
</counters>

================================================
FILE: etc/doors.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<Doors>
    <Category name="Doors">
        <Door name="Barred Metal 1" base="1669" item="BarredMetalDoor"></Door>
        <Door name="Barred Metal 2" base="8173" item="BarredMetalDoor2"></Door>
        <Door name="Dark Wood" base="1701" item="DarkWoodDoor"></Door>
        <Door name="Light Wood" base="1749" item="LightWoodDoor"></Door>
        <Door name="Medium Wood" base="1717" item="MediumWoodDoor"></Door>
        <Door name="Metal 1" base="1653" item="MetalDoor"></Door>
        <Door name="Metal 2" base="1733" item="MetalDoor2"></Door>
        <Door name="Rattan" base="1685" item="RattanDoor"></Door>
        <Door name="Strong Wood" base="1765" item="StrongWoodDoor"></Door>
    </Category>
    <Category name="House Doors">
        <Door name="Dark Wood" base="1701" item="DarkWoodHouseDoor"></Door>
        <Door name="Metal" base="1653" item="MetalHouseDoor"></Door>
    </Category>
    <Category name="Gates">
        <Door name="Dark Wood" base="2150" item="DarkWoodGate"></Door>
        <Door name="Iron" base="2084" item="IronGate"></Door>
        <Door name="Iron Short" base="2124" item="IronGateShort"></Door>
        <Door name="Light Wood" base="2105" item="LightWoodGate"></Door>
    </Category>
    <Category name="Portcullis" EW="1782" NS="1781" itemEW="PortcullisEW" itemNS="PortcullisNS"></Category>
    <Category name="Secret Doors">
        <Door name="Dungeon" base="788" item="SecretDungeonDoor"></Door>
        <Door name="Light Wood" base="836" item="SecretLightWoodDoor"></Door>
        <Door name="Stone 1" base="232" item="SecretStoneDoor1"></Door>
        <Door name="Stone 2" base="804" item="SecretStoneDoor2"></Door>
        <Door name="Stone 3" base="852" item="SecretStoneDoor3"></Door>
        <Door name="Wooden" base="820" item="SecretWoodenDoor"></Door>
    </Category>
    <Category name="Phantasya Custom">
        <Door name="Self Locking Door" base="1701" item="SelfLockingDoor"></Door>
    </Category>
</Doors>

================================================
FILE: etc/dotNet.nsh
================================================
# DotNET version checking macro.
# Written by AnarkiNet(AnarkiNet@gmail.com) originally, modified by eyal0 (for use in http://www.sourceforge.net/projects/itwister)
# Downloads and runs the Microsoft .NET Framework version 2.0 Redistributable and runs it if the user does not have the correct version.
# To use, call the macro with a string:
# !insertmacro CheckDotNET "2"
# !insertmacro CheckDotNET "2.0.9"
# (Version 2.0.9 is less than version 2.0.10.)
# All register variables are saved and restored by CheckDotNet
# No output
 
!macro CheckDotNET DotNetReqVer
  !define DOTNET_URL "http://www.microsoft.com/downloads/info.aspx?na=90&p=&SrcDisplayLang=en&SrcCategoryId=&SrcFamilyId=0856eacb-4362-4b0d-8edd-aab15c5e04f5&u=http%3a%2f%2fdownload.microsoft.com%2fdownload%2f5%2f6%2f7%2f567758a3-759e-473e-bf8f-52154438565a%2fdotnetfx.exe"
  DetailPrint "Checking your .NET Framework version..."
  ;callee register save
  Push $0
  Push $1
  Push $2
  Push $3
  Push $4
  Push $5
  Push $6 ;backup of intsalled ver
  Push $7 ;backup of DoNetReqVer
 
  StrCpy $7 ${DotNetReqVer}
 
  System::Call "mscoree::GetCORVersion(w .r0, i ${NSIS_MAX_STRLEN}, *i r2r2) i .r1 ?u"
 
  ${If} $0 == 0
  	DetailPrint ".NET Framework not found, download is required for program to run."
    Goto NoDotNET
  ${EndIf}
 
  ;at this point, $0 has maybe v2.345.678.
  StrCpy $0 $0 $2 1 ;remove the starting "v", $0 has the installed version num as a string
  StrCpy $6 $0
  StrCpy $1 $7 ;$1 has the requested verison num as a string
 
  ;MessageBox MB_OKCANCEL "found $0" IDCANCEL GiveUpDotNET
 
  ;MessageBox MB_OKCANCEL "looking for $1" IDCANCEL GiveUpDotNET
 
  ;now let's compare the versions, installed against required <part0>.<part1>.<part2>.
  ${Do}
    StrCpy $2 "" ;clear out the installed part
    StrCpy $3 "" ;clear out the required part
 
    ${Do}
      ${If} $0 == "" ;if there are no more characters in the version
        StrCpy $4 "." ;fake the end of the version string
      ${Else}
        StrCpy $4 $0 1 0 ;$4 = character from the installed ver
        ${If} $4 != "."
          StrCpy $0 $0 ${NSIS_MAX_STRLEN} 1 ;remove that first character from the remaining
        ${EndIf}
      ${EndIf}
 
      ${If} $1 == ""  ;if there are no more characters in the version
        StrCpy $5 "." ;fake the end of the version string
      ${Else}
        StrCpy $5 $1 1 0 ;$5 = character from the required ver
        ${If} $5 != "."
          StrCpy $1 $1 ${NSIS_MAX_STRLEN} 1 ;remove that first character from the remaining
        ${EndIf}
      ${EndIf}
      ;MessageBox MB_OKCANCEL "installed $2,$4,$0 required $3,$5,$1" IDCANCEL GiveUpDotNET
      ${If} $4 == "."
      ${AndIf} $5 == "."
        ${ExitDo} ;we're at the end of the part
      ${EndIf}
 
      ${If} $4 == "." ;if we're at the end of the current installed part
        StrCpy $2 "0$2" ;put a zero on the front
      ${Else} ;we have another character
        StrCpy $2 "$2$4" ;put the next character on the back
      ${EndIf}
      ${If} $5 == "." ;if we're at the end of the current required part
        StrCpy $3 "0$3" ;put a zero on the front
      ${Else} ;we have another character
        StrCpy $3 "$3$5" ;put the next character on the back
      ${EndIf}
    ${Loop}
    ;MessageBox MB_OKCANCEL "finished parts: installed $2,$4,$0 required $3,$5,$1" IDCANCEL GiveUpDotNET
 
    ${If} $0 != "" ;let's remove the leading period on installed part if it exists
      StrCpy $0 $0 ${NSIS_MAX_STRLEN} 1
    ${EndIf}
    ${If} $1 != "" ;let's remove the leading period on required part if it exists
      StrCpy $1 $1 ${NSIS_MAX_STRLEN} 1
    ${EndIf}
 
    ;$2 has the installed part, $3 has the required part
    ${If} $2 S< $3
      IntOp $0 0 - 1 ;$0 = -1, installed less than required
      ${ExitDo}
    ${ElseIf} $2 S> $3
      IntOp $0 0 + 1 ;$0 = 1, installed greater than required
      ${ExitDo}
    ${ElseIf} $2 == ""
    ${AndIf} $3 == ""
      IntOp $0 0 + 0 ;$0 = 0, the versions are identical
      ${ExitDo}
    ${EndIf} ;otherwise we just keep looping through the parts
  ${Loop}
 
  ${If} $0 < 0
    DetailPrint ".NET Framework Version found: $6, but is older than the required version: $7"
    Goto OldDotNET
  ${Else}
    DetailPrint ".NET Framework Version found: $6, equal or newer to required version: $7."
    Goto NewDotNET
  ${EndIf}
 
NoDotNET:
    MessageBox MB_YESNOCANCEL|MB_ICONEXCLAMATION \
    ".NET Framework not installed.$\nRequired Version: $7 or greater.$\nDownload .NET Framework version from www.microsoft.com?" \
    /SD IDYES IDYES DownloadDotNET IDNO NewDotNET
    goto GiveUpDotNET ;IDCANCEL
OldDotNET:
    MessageBox MB_YESNOCANCEL|MB_ICONEXCLAMATION \
    "Your .NET Framework version: $6.$\nRequired Version: $7 or greater.$\nDownload .NET Framework version from www.microsoft.com?" \
    /SD IDYES IDYES DownloadDotNET IDNO NewDotNET
    goto GiveUpDotNET ;IDCANCEL
 
DownloadDotNET:
  DetailPrint "Beginning download of latest .NET Framework version."
  NSISDL::download ${DOTNET_URL} "$TEMP\dotnetfx.exe"
  DetailPrint "Completed download."
  Pop $0
  ${If} $0 == "cancel"
    MessageBox MB_YESNO|MB_ICONEXCLAMATION \
    "Download cancelled.  Continue Installation?" \
    IDYES NewDotNET IDNO GiveUpDotNET
  ${ElseIf} $0 != "success"
    MessageBox MB_YESNO|MB_ICONEXCLAMATION \
    "Download failed:$\n$0$\n$\nContinue Installation?" \
    IDYES NewDotNET IDNO GiveUpDotNET
  ${EndIf}
  DetailPrint "Pausing installation while downloaded .NET Framework installer runs."
  ExecWait '$TEMP\dotnetfx.exe /q /c:"install /q"'
  DetailPrint "Completed .NET Framework install/update. Removing .NET Framework installer."
  Delete "$TEMP\dotnetfx.exe"
  DetailPrint ".NET Framework installer removed."
  goto NewDotNet
 
GiveUpDotNET:
  Abort "Installation cancelled by user."
 
NewDotNET:
  DetailPrint "Proceeding with remainder of installation."
  Pop $0
  Pop $1
  Pop $2
  Pop $3
  Pop $4
  Pop $5
  Pop $6 ;backup of intsalled ver
  Pop $7 ;backup of DoNetReqVer
!macroend

; IsDotNETInstalled
;
; Usage:
;   Call IsDotNETInstalled
;   Pop $0
;   StrCmp $0 1 found.NETFramework no.NETFramework
Function IsDotNETInstalled
  Push $0
  Push $1
  Push $2
  Push $3
  Push $4
 
  ReadRegStr $4 HKEY_LOCAL_MACHINE \
    "Software\Microsoft\.NETFramework" "InstallRoot"
  # remove trailing back slash
  Push $4
  Exch $EXEDIR
  Exch $EXEDIR
  Pop $4
  # if the root directory doesn't exist .NET is not installed
  IfFileExists $4 0 noDotNET
 
  StrCpy $0 0
 
  EnumStart:
 
    EnumRegKey $2 HKEY_LOCAL_MACHINE \
      "Software\Microsoft\.NETFramework\Policy"  $0
    IntOp $0 $0 + 1
    StrCmp $2 "" noDotNET
 
    StrCpy $1 0
 
    EnumPolicy:
 
      EnumRegValue $3 HKEY_LOCAL_MACHINE \
        "Software\Microsoft\.NETFramework\Policy\$2" $1
      IntOp $1 $1 + 1
       StrCmp $3 "" EnumStart
        IfFileExists "$4\$2.$3" foundDotNET EnumPolicy
 
  noDotNET:
    StrCpy $0 0
    Goto done
 
  foundDotNET:
    StrCpy $0 1
 
  done:
    Pop $4
    Pop $3
    Pop $2
    Pop $1
    Exch $0
FunctionEnd

================================================
FILE: etc/guardlines.def
================================================
# Papua
5639 3095 192 223 -128 127
5831 3237 20 30 -128 127

# Delucia
5123 3942 192 122 -128 127
5147 4064 125 20 -128 127
5235 3930 80 12 -128 127

# Yew
92 656 349 225 -30 39
441 746 216 135 0 39
258 881 399 380 0 39
657 922 42 307 0 39
657 806 17 28 0 39
718 874 38 22 0 39
761 741 19 21 0 39

# Wind
5132 3 70 55 -128 127
5132 58 81 68 -128 127
5213 98 39 28 -128 127
5197 126 55 78 -128 127
5252 112 42 58 -128 127
5252 170 32 8 -128 127
5252 178 20 5 -128 127
5252 183 10 10 -128 127
5294 19 72 120 -128 127
5279 57 15 55 -128 127
5286 25 8 32 -128 127

# Jhelom
1303 3670 189 225 -20 127
1338 3895 74 28 -20 127
1383 3951 109 94 -20 127
1494 3767 12 11 -20 127

# Vesper
2893 598 121 50 -10 127
2816 648 249 365 -10 127
2734 944 82 4 -10 127
2728 948 88 53 -10 127

# Minoc
2411 366 135 241 -10 127
2548 495 72 55 -10 127
2564 585 3 42 -10 127
2567 585 61 61 -10 127
2499 627 68 63 -10 127
2694 685 15 16 -10 127

# Serpent's Hold. Get
2868 3324 205 195 0 127

# Magincia
3653 2046 27 48 0 127
3752 2046 52 48 0 127
3680 2045 72 49 0 127
3652 2094 160 180 -128 127
3649 2256 54 47 -128 127
3554 2132 18 18 -128 127

# Nujel'm
3475 1000 360 435 0 127

# Cove
2200 1110 50 50 -10 127
2200 1160 86 86 -10 127

# Ocllo
3587 2456 119 99 -128 127 F
3706 2460 2 95 -128 127 F
3587 2555 106 73 -128 127 F
3590 2628 103 58 -128 127 F
3693 2555 61 144 -128 127 F
3754 2558 7 141 -128 127 F
3761 2555 7 144 -128 50 F
3695 2699 66 13 -128 127 F

# Haven
3590 2460 118 226 -10 127 T
3568 2552 22 79 -10 127 T
3708 2558 53 154 -10 127 T
3695 2686 13 26 -10 127 T
3759 2767 10 10 -10 127 T

# Britain
1416 1498 324 279 -10 127
1500 1408 46 90 0 127
1385 1538 31 239 -10 127
1416 1777 324 60 0 127
1385 1777 31 130 0 127
1093 1538 292 369 0 127
1330 1991 13 13 -10 127

# Skara Brae
638 2062 12 11 0 127
538 2107 150 190 -10 127

# Trinsic
1856 2636 75 28 -10 127
1816 2664 283 231 -10 127
2099 2782 18 25 -10 127
1970 2895 47 32 -10 127
1796 2696 20 67 0 127
1800 2796 16 52 0 127
1823 2943 11 11 -128 127

# Moonglow
4535 844 20 3 0 127
4530 847 31 61 0 127
4521 914 56 49 0 127
4278 915 54 19 0 127
4283 944 53 73 0 127
4377 1015 59 37 -10 127
4367 1050 142 145 0 127
4539 1036 27 18 0 127
4517 1053 23 22 0 127
4389 1198 47 39 0 127
4466 1211 32 25 0 127
4700 1108 17 18 0 127
4656 1127 26 13 0 127
4678 1162 25 25 0 127
4613 1196 23 22 0 127
4646 1212 14 17 0 127
4677 1214 26 22 0 127
4459 1276 16 16 0 127
4622 1316 22 24 0 127
4487 1353 59 21 0 127
4477 1374 69 35 0 127
4659 1387 40 40 0 127
4549 1482 29 27 0 127
4405 1451 23 23 0 127
4483 1468 21 13 0 127


#duel
5307 3681 33 26 -127 127 
5158 3436 33 28 -127 127 
5848 3500 27 30 -127 127 
6055 2324 39 24 -127 127 
5757 3658 27 26 -127 127

================================================
FILE: etc/items.xml
================================================
<?xml version="1.0" encoding="UTF-8"?>
<Items>
    <Group name="Buildings">
        <Group name="Doors">
            <Group name="Metal">
                <Group name="Barred Metal">
                    <Item ID="0x0685"/>
                    <Item ID="0x0687"/>
                    <Item ID="0x068D"/>
                    <Item ID="0x068F"/>
                    <Item ID="0x1fed"/>
                    <Item ID="0x1fee"/>
                    <Item ID="0x1fef"/>
                    <Item ID="0x1ff0"/>
                </Group>
                <Group name="Solid Metal">
                    <Item ID="0x0675"/>
                    <Item ID="0x0677"/>
                    <Item ID="0x067D"/>
                    <Item ID="0x067F"/>
                </Group>
            </Group>
            <Group name="Organic">
                <Group name="Hide">
                    <Item ID="0x022C"/>
                    <Item ID="0x022D"/>
                    <Item ID="0x022E"/>
                    <Item ID="0x022F"/>
                </Group>
                <Group name="Rattan">
                    <Item ID="0x0695"/>
                    <Item ID="0x0697"/>
                    <Item ID="0x069D"/>
                    <Item ID="0x069F"/>
                </Group>
            </Group>
            <Group name="Secret Doors">
                <Item ID="0x0319"/>
                <Item ID="0x0321"/>
                <Item ID="0x0329"/>
                <Item ID="0x0331"/>
                <Item ID="0x0339"/>
                <Item ID="0x033F"/>
                <Item ID="0x0349"/>
                <Item ID="0x034F"/>
                <Item ID="0x0359"/>
                <Item ID="0x0363"/>
            </Group>
            <Group name="Stone">
                <Group name="Crystal">
                    <Item ID="0x35E7"/>
                    <Item ID="0x367B"/>
                    <Item ID="0x367D"/>
                    <Item ID="0x367f"/>
                    <Item ID="0x3681"/>
                    <Item ID="0x3683"/>
                    <Item ID="0x3685"/>
                    <Item ID="0x3687"/>
                    <Item ID="0x3689"/>
                </Group>
            </Group>
            <Group name="Wood">
                <Group name="Floral doors">
                    <Item ID="0x2D46"/>
                    <Item ID="0x2D48"/>
                    <Item ID="0x2D63"/>
                    <Item ID="0x2D65"/>
                    <Item ID="0x2D67"/>
                    <Item ID="0x2D69"/>
                    <Item ID="0x2D6B"/>
                    <Item ID="0x2D6D"/>
                    <Item ID="0x2FE2"/>
                    <Item ID="0x2FE4"/>
                    <Item ID="0x2FE4"/>
                    <Item ID="0x319C"/>
                    <Item ID="0x319E"/>
                    <Item ID="0x31A0"/>
                    <Item ID="0x31A2"/>
                    <Item ID="0x31A4"/>
                    <Item ID="0x31A6"/>
                    <Item ID="0x31A8"/>
                    <Item ID="0x31AA"/>
                    <Item ID="0x31AC"/>
                    <Item ID="0x31AE"/>
                </Group>
                <Group name="Gray Wood">
                    <Item ID="0x3640"/>
                    <Item ID="0x3642"/>
                    <Item ID="0x3644"/>
                    <Item ID="0x3646"/>
                    <Item ID="0x368B"/>
                    <Item ID="0x368D"/>
                    <Item ID="0x368f"/>
                    <Item ID="0x3691"/>
                    <Item ID="0x3693"/>
                    <Item ID="0x3695"/>
                    <Item ID="0x3697"/>
                    <Item ID="0x3699"/>
                </Group>
                <Group name="Sliding Doors">
                    <Item ID="0x26F4"/>
                    <Item ID="0x26F6"/>
                    <Item ID="0x2990"/>
                    <Item ID="0x2991"/>
                    <Item ID="0x299e"/>
                    <Item ID="0x299f"/>
                    <Item ID="0x2A05"/>
                    <Item ID="0x2A05"/>
                    <Item ID="0x2A05"/>
                    <Item ID="0x2A09"/>
                    <Item ID="0x2A0D"/>
                    <Item ID="0x2A0f"/>
                    <Item ID="0x2A11"/>
                    <Item ID="0x2A11"/>
                    <Item ID="0x2A13"/>
                    <Item ID="0x2A15"/>
                    <Item ID="0x2A15"/>
                    <Item ID="0x2A17"/>
                    <Item ID="0x2A19"/>
                    <Item ID="0x2A19"/>
                    <Item ID="0x2A1b"/>
                </Group>
                <Group name="Solid + Metal">
                    <Item ID="0x06E5"/>
                    <Item ID="0x06E7"/>
                    <Item ID="0x06ED"/>
                    <Item ID="0x06EF"/>
                </Group>
                <Group name="Solid Dark">
                    <Group name="Gate">
                        <Item ID="0x0866"/>
                        <Item ID="0x0868"/>
                        <Item ID="0x086A"/>
                        <Item ID="0x086C"/>
                        <Item ID="0x086E"/>
                        <Item ID="0x0870"/>
                        <Item ID="0x0872"/>
                        <Item ID="0x0874"/>
                    </Group>
                    <Item ID="0x06A5"/>
                    <Item ID="0x06A7"/>
                    <Item ID="0x06AD"/>
                    <Item ID="0x06AF"/>
                </Group>
                <Group name="Solid Light">
                    <Group name="Gate">
                        <Item ID="0x0839"/>
                        <Item ID="0x083A"/>
                        <Item ID="0x083B"/>
                        <Item ID="0x083D"/>
                        <Item ID="0x083E"/>
                        <Item ID="0x083F"/>
                        <Item ID="0x0841"/>
                        <Item ID="0x0843"/>
                    </Group>
                    <Item ID="0x06D5"/>
                    <Item ID="0x06D7"/>
                    <Item ID="0x06DD"/>
                    <Item ID="0x06DF"/>
                </Group>
                <Group name="Solid Purple">
                    <Item ID="0x241F"/>
                    <Item ID="0x2420"/>
                    <Item ID="0x2421"/>
                    <Item ID="0x2422"/>
                    <Item ID="0x2423"/>
                    <Item ID="0x2424"/>
                </Group>
            </Group>
        </Group>
        <Group name="Fences">
            <Group name="Iron Fence and Gate">
                <Item ID="0x0821"/>
                <Item ID="0x0822"/>
                <Item ID="0x0823"/>
                <Item ID="0x0824"/>
                <Item ID="0x0826"/>
                <Item ID="0x0827"/>
                <Item ID="0x0829"/>
                <Item ID="0x0849"/>
                <Item ID="0x084A"/>
                <Item ID="0x084B"/>
                <Item ID="0x084C"/>
                <Item ID="0x084E"/>
                <Item ID="0x0851"/>
                <Item ID="0x0856"/>
            </Group>
            <Group name="Wooden Fence">
                <Item ID="0x085C"/>
                <Item ID="0x085D"/>
                <Item ID="0x085E"/>
                <Item ID="0x085F"/>
                <Item ID="0x0860"/>
                <Item ID="0x0861"/>
                <Item ID="0x0862"/>
                <Item ID="0x0863"/>
                <Item ID="0x0864"/>
                <Item ID="0x0865"/>
                <Item ID="0x0877"/>
                <Item ID="0x0878"/>
                <Item ID="0x088A"/>
                <Item ID="0x088B"/>
            </Group>
        </Group>
        <Group name="Floor">
            <Group name="Carpet + Rugs">
                <Group name="Blue Carpet">
                    <Item ID="0x0ABD"/>
                    <Item ID="0x0ABE"/>
                    <Item ID="0x0ABF"/>
                    <Item ID="0x0AC0"/>
                    <Item ID="0x0AC1"/>
                    <Item ID="0x0AC2"/>
                    <Item ID="0x0AC3"/>
                    <Item ID="0x0AC4"/>
                    <Item ID="0x0AC5"/>
                    <Item ID="0x0AF6"/>
                    <Item ID="0x0AF7"/>
                    <Item ID="0x0AF8"/>
                    <Item ID="0x0AF9"/>
                    <Item ID="0x3f0a"/>
                </Group>
                <Group name="Damaged Rug">
                    <Item ID="0x1098"/>
                    <Item ID="0x1099"/>
                    <Item ID="0x109a"/>
                    <Item ID="0x109b"/>
                    <Item ID="0x109c"/>
                    <Item ID="0x109d"/>
                    <Item ID="0x109e"/>
                    <Item ID="0x109f"/>
                    <Item ID="0x10a0"/>
                    <Item ID="0x10a1"/>
                    <Item ID="0x10a2"/>
                    <Item ID="0x10a3"/>
                    <Item ID="0x1DD3"/>
                    <Item ID="0x1DD4"/>
                    <Item ID="0x1DD5"/>
                    <Item ID="0x1DD6"/>
                    <Item ID="0x1DD7"/>
                    <Item ID="0x1DD8"/>
                    <Item ID="0x1DD9"/>
                    <Item ID="0x1DDA"/>
                    <Item ID="0x1DDB"/>
                    <Item ID="0x1DDC"/>
                    <Item ID="0x1DDD"/>
                    <Item ID="0x1DDE"/>
                    <Item ID="0x1DDF"/>
                    <Item ID="0x1DE0"/>
                    <Item ID="0x1DE1"/>
                    <Item ID="0x1DE2"/>
                    <Item ID="0x1DE3"/>
                    <Item ID="0x1DE4"/>
                    <Item ID="0x1DE5"/>
                    <Item ID="0x1DE6"/>
                    <Item ID="0x1DE7"/>
                    <Item ID="0x1DE8"/>
                    <Item ID="0x1DE9"/>
                    <Item ID="0x1DEA"/>
                    <Item ID="0x1DEB"/>
                    <Item ID="0x1DEC"/>
                    <Item ID="0x1DED"/>
                    <Item ID="0x1DEE"/>
                    <Item ID="0x1DEF"/>
                    <Item ID="0x1DF0"/>
                    <Item ID="0x1DF1"/>
                    <Item ID="0x1DF2"/>
                    <Item ID="0x1DF3"/>
                    <Item ID="0x1DF4"/>
                    <Item ID="0x1DF5"/>
                    <Item ID="0x1DF6"/>
                    <Item ID="0x1DF7"/>
                    <Item ID="0x1DF8"/>
                    <Item ID="0x1DF9"/>
                    <Item ID="0x1DFA"/>
                    <Item ID="0x1DFB"/>
                    <Item ID="0x1DFC"/>
                </Group>
                <Group name="Fancy Blue Carpet">
                    <Item ID="0x0AD1"/>
                    <Item ID="0x0AD2"/>
                    <Item ID="0x0AD3"/>
                    <Item ID="0x0AD4"/>
                    <Item ID="0x0AD5"/>
                    <Item ID="0x0AD6"/>
                    <Item ID="0x0AD7"/>
                    <Item ID="0x0AD8"/>
                    <Item ID="0x0AD9"/>
                    <Item ID="0x3f08"/>
                </Group>
                <Group name="Fancy Blue-Red Carpet">
                    <Item ID="0x0AEC"/>
                    <Item ID="0x0AED"/>
                    <Item ID="0x0AEE"/>
                    <Item ID="0x0AEF"/>
                    <Item ID="0x0AF0"/>
                    <Item ID="0x0AF1"/>
                    <Item ID="0x0AF2"/>
                    <Item ID="0x0AF3"/>
                    <Item ID="0x0AF4"/>
                    <Item ID="0x0AF5"/>
                    <Item ID="0x3f17"/>
                </Group>
                <Group name="Fancy Gold Carpet">
                    <Item ID="0x0ADA"/>
                    <Item ID="0x0ADB"/>
                    <Item ID="0x0ADC"/>
                    <Item ID="0x0ADD"/>
                    <Item ID="0x0ADE"/>
                    <Item ID="0x0ADF"/>
                    <Item ID="0x0AE0"/>
                    <Item ID="0x0AE1"/>
                    <Item ID="0x0AE2"/>
                    <Item ID="0x3f11"/>
                </Group>
                <Group name="Fancy Red Carpet">
                    <Item ID="0x0AE3"/>
                    <Item ID="0x0AE4"/>
                    <Item ID="0x0AE5"/>
                    <Item ID="0x0AE6"/>
                    <Item ID="0x0AE7"/>
                    <Item ID="0x0AE8"/>
                    <Item ID="0x0AE9"/>
                    <Item ID="0x0AEA"/>
                    <Item ID="0x0AEB"/>
                    <Item ID="0x3f0d"/>
                </Group>
                <Group name="Grey Rug">
                    <Item ID="0x0AB3"/>
                    <Item ID="0x0AB4"/>
                    <Item ID="0x0AB5"/>
                    <Item ID="0x0AB6"/>
                    <Item ID="0x0AB7"/>
                    <Item ID="0x0AB8"/>
                    <Item ID="0x0AB9"/>
                    <Item ID="0x0ABA"/>
                    <Item ID="0x0ABB"/>
                    <Item ID="0x0ABC"/>
                </Group>
                <Group name="Red Carpet">
                    <Item ID="0x0AC6"/>
                    <Item ID="0x0AC7"/>
                    <Item ID="0x0AC8"/>
                    <Item ID="0x0AC9"/>
                    <Item ID="0x0ACA"/>
                    <Item ID="0x0ACB"/>
                    <Item ID="0x0ACC"/>
                    <Item ID="0x0ACD"/>
                    <Item ID="0x0ACE"/>
                    <Item ID="0x0ACF"/>
                    <Item ID="0x0AD0"/>
                    <Item ID="0x3f18"/>
                </Group>
                <Group name="Red Rug">
                    <Item ID="0x0AA9"/>
                    <Item ID="0x0AAA"/>
                    <Item ID="0x0AAB"/>
                    <Item ID="0x0AAC"/>
                    <Item ID="0x0AAD"/>
                    <Item ID="0x0AAE"/>
                    <Item ID="0x0AAF"/>
                    <Item ID="0x0AB0"/>
                    <Item ID="0x0AB1"/>
                    <Item ID="0x0AB2"/>
                </Group>
            </Group>
            <Group name="Fancy Stone">
                <Group name="Blue Tiles">
                    <Item ID="0x0491"/>
                    <Item ID="0x0492"/>
                    <Item ID="0x0493"/>
                    <Item ID="0x0494"/>
                    <Item ID="0x049B"/>
                    <Item ID="0x049b"/>
                    <Item ID="0x04EA"/>
                    <Item ID="0x04EB"/>
                    <Item ID="0x04EC"/>
                    <Item ID="0x04ED"/>
                    <Item ID="0x04EE"/>
                    <Item ID="0x04EF"/>
                    <Item ID="0x04F0"/>
                    <Item ID="0x04F1"/>
                    <Item ID="0x04F2"/>
                </Group>
                <Group name="Crystal Floor">
                    <Item ID="0x35B2"/>
                    <Item ID="0x35B3"/>
                    <Item ID="0x35B4"/>
                    <Item ID="0x35B5"/>
                    <Item ID="0x35B6"/>
                    <Item ID="0x35B7"/>
                    <Item ID="0x35B8"/>
                    <Item ID="0x35B9"/>
                    <Item ID="0x35BA"/>
                    <Item ID="0x35BB"/>
                    <Item ID="0x35BC"/>
                    <Item ID="0x35BD"/>
                </Group>
                <Group name="Gray Stone">
                    <Item ID="0x361A"/>
                    <Item ID="0x361B"/>
                    <Item ID="0x361C"/>
                    <Item ID="0x361D"/>
                    <Item ID="0x361E"/>
                    <Item ID="0x361F"/>
                    <Item ID="0x3620"/>
                    <Item ID="0x3621"/>
                    <Item ID="0x3622"/>
                </Group>
                <Group name="Marble">
                    <Item ID="0x0495"/>
                    <Item ID="0x0496"/>
                    <Item ID="0x0497"/>
                    <Item ID="0x0498"/>
                    <Item ID="0x050D"/>
                    <Item ID="0x050F"/>
                    <Item ID="0x050e"/>
                    <Item ID="0x0510"/>
                    <Item ID="0x0511"/>
                    <Item ID="0x0512"/>
                    <Item ID="0x0513"/>
                    <Item ID="0x0514"/>
                </Group>
                <Group name="Red Tiles">
                    <Item ID="0x04F3"/>
                    <Item ID="0x04F4"/>
                    <Item ID="0x04F5"/>
                    <Item ID="0x04F6"/>
                    <Item ID="0x04F7"/>
                    <Item ID="0x04F8"/>
                    <Item ID="0x04F9"/>
                    <Item ID="0x04FA"/>
                    <Item ID="0x04FB"/>
                </Group>
            </Group>
            <Group name="Magic">
                <Group name="Alchemic Symbols">
                    <Item ID="0x181d"/>
                    <Item ID="0x181e"/>
                    <Item ID="0x181f"/>
                    <Item ID="0x1820"/>
                    <Item ID="0x1821"/>
                    <Item ID="0x1822"/>
                    <Item ID="0x1823"/>
                    <Item ID="0x1824"/>
                    <Item ID="0x1825"/>
                    <Item ID="0x1826"/>
                    <Item ID="0x1827"/>
                    <Item ID="0x1828"/>
                </Group>
                <Group name="Alchemical Symbols">
                    <Item ID="0x181D"/>
                    <Item ID="0x181E"/>
                    <Item ID="0x181F"/>
                    <Item ID="0x1820"/>
                    <Item ID="0x1821"/>
                    <Item ID="0x1822"/>
                    <Item ID="0x1823"/>
                    <Item ID="0x1824"/>
                    <Item ID="0x1825"/>
                    <Item ID="0x1826"/>
                    <Item ID="0x1827"/>
                </Group>
                <Group name="Black">
                    <Item ID="0x3B16"/>
                    <Item ID="0x3B17"/>
                    <Item ID="0x3B18"/>
                    <Item ID="0x3B19"/>
                    <Item ID="0x3B1A"/>
                    <Item ID="0x3B1B"/>
                    <Item ID="0x3B1C"/>
                    <Item ID="0x3B1D"/>
                    <Item ID="0x3B1E"/>
                    <Item ID="0x3B1F"/>
                    <Item ID="0x3B20"/>
                    <Item ID="0x3B21"/>
                    <Item ID="0x3B22"/>
                    <Item ID="0x3B23"/>
                    <Item ID="0x3B24"/>
                    <Item ID="0x3B25"/>
                    <Item ID="0x3B26"/>
                </Group>
                <Group name="Chaos">
                    <Item ID="0x14E3"/>
                    <Item ID="0x14E4"/>
                    <Item ID="0x14E5"/>
                    <Item ID="0x14E6"/>
                </Group>
                <Group name="Compassion">
                    <Item ID="0x14A7"/>
                    <Item ID="0x14A8"/>
                    <Item ID="0x14A9"/>
                    <Item ID="0x14AA"/>
                    <Item ID="0x14AB"/>
                    <Item ID="0x14AC"/>
                    <Item ID="0x14AD"/>
                    <Item ID="0x14AE"/>
                </Group>
                <Group name="Glass + Stars">
                    <Item ID="0x213F"/>
                    <Item ID="0x2140"/>
                    <Item ID="0x2141"/>
                    <Item ID="0x2142"/>
                    <Item ID="0x2143"/>
                    <Item ID="0x2144"/>
                    <Item ID="0x2e40"/>
                    <Item ID="0x2e41"/>
                    <Item ID="0x2e42"/>
                    <Item ID="0x2e43"/>
                    <Item ID="0x2e44"/>
                    <Item ID="0x2e45"/>
                    <Item ID="0x2e46"/>
                    <Item ID="0x2e47"/>
                </Group>
                <Group name="Honesty">
                    <Item ID="0x149F"/>
                    <Item ID="0x14A0"/>
                    <Item ID="0x14A1"/>
                    <Item ID="0x14A2"/>
                    <Item ID="0x14A3"/>
                    <Item ID="0x14A4"/>
                    <Item ID="0x14A5"/>
                    <Item ID="0x14A6"/>
                </Group>
                <Group name="Honor">
                    <Item ID="0x14C7"/>
                    <Item ID="0x14C8"/>
                    <Item ID="0x14C9"/>
                    <Item ID="0x14CA"/>
                    <Item ID="0x14CB"/>
                    <Item ID="0x14CC"/>
                    <Item ID="0x14CD"/>
                    <Item ID="0x14CE"/>
                </Group>
                <Group name="Humility">
                    <Item ID="0x14CF"/>
                    <Item ID="0x14D0"/>
                    <Item ID="0x14D1"/>
                    <Item ID="0x14D2"/>
                    <Item ID="0x14D3"/>
                    <Item ID="0x14D4"/>
                    <Item ID="0x14D5"/>
                    <Item ID="0x14D6"/>
                </Group>
                <Group name="Justice">
                    <Item ID="0x14AF"/>
                    <Item ID="0x14B0"/>
                    <Item ID="0x14B1"/>
                    <Item ID="0x14B2"/>
                    <Item ID="0x14B3"/>
                    <Item ID="0x14B4"/>
                    <Item ID="0x14B5"/>
                    <Item ID="0x14B6"/>
                </Group>
                <Group name="Sacrifice">
                    <Item ID="0x150A"/>
                    <Item ID="0x150B"/>
                    <Item ID="0x150C"/>
                    <Item ID="0x150D"/>
                    <Item ID="0x150E"/>
                    <Item ID="0x150F"/>
                    <Item ID="0x1510"/>
                    <Item ID="0x1511"/>
                </Group>
                <Group name="Spirituality">
                    <Item ID="0x14BF"/>
                    <Item ID="0x14C0"/>
                    <Item ID="0x14C1"/>
                    <Item ID="0x14C2"/>
                    <Item ID="0x14C3"/>
                    <Item ID="0x14C4"/>
                    <Item ID="0x14C5"/>
                    <Item ID="0x14C6"/>
                </Group>
                <Group name="Teleporter Symbols">
                    <Item ID="0x17CF"/>
                    <Item ID="0x17D0"/>
                    <Item ID="0x17D1"/>
                    <Item ID="0x17D2"/>
                    <Item ID="0x17D3"/>
                    <Item ID="0x17D4"/>
                    <Item ID="0x17D5"/>
                    <Item ID="0x17D6"/>
                    <Item ID="0x17D7"/>
                    <Item ID="0x17D8"/>
                    <Item ID="0x17D9"/>
                    <Item ID="0x17DA"/>
                    <Item ID="0x17DB"/>
                    <Item ID="0x17DC"/>
                    <Item ID="0x17DD"/>
                    <Item ID="0x17DE"/>
                    <Item ID="0x17DF"/>
                    <Item ID="0x17E0"/>
                    <Item ID="0x17E1"/>
                    <Item ID="0x17E2"/>
                    <Item ID="0x17E3"/>
                    <Item ID="0x17E4"/>
                    <Item ID="0x17E5"/>
                    <Item ID="0x17E6"/>
                    <Item ID="0x17E7"/>
                    <Item ID="0x17E8"/>
                    <Item ID="0x17E9"/>
                    <Item ID="0x17EA"/>
                    <Item ID="0x17EB"/>
                    <Item ID="0x17EC"/>
                    <Item ID="0x17ED"/>
                    <Item ID="0x17EE"/>
                    <Item ID="0x17EF"/>
                    <Item ID="0x17F0"/>
                    <Item ID="0x17F1"/>
                    <Item ID="0x17F2"/>
                    <Item ID="0x17FC"/>
                    <Item ID="0x17FD"/>
                    <Item ID="0x17FE"/>
                    <Item ID="0x17FF"/>
                    <Item ID="0x1800"/>
                    <Item ID="0x1801"/>
                    <Item ID="0x1802"/>
                    <Item ID="0x1803"/>
                    <Item ID="0x1804"/>
                    <Item ID="0x1805"/>
                    <Item ID="0x1806"/>
                    <Item ID="0x1807"/>
                    <Item ID="0x1808"/>
                    <Item ID="0x1809"/>
                    <Item ID="0x180A"/>
                    <Item ID="0x180B"/>
                    <Item ID="0x180C"/>
                    <Item ID="0x180D"/>
                </Group>
                <Group name="Valor">
                    <Item ID="0x14B7"/>
                    <Item ID="0x14B8"/>
                    <Item ID="0x14B9"/>
                    <Item ID="0x14BA"/>
                    <Item ID="0x14BB"/>
                    <Item ID="0x14BC"/>
                    <Item ID="0x14BD"/>
                    <Item ID="0x14BE"/>
                </Group>
            </Group>
            <Group name="Misc">
                <Item ID="0x049C"/>
                <Item ID="0x2712"/>
                <Item ID="0x2720"/>
                <Item ID="0x2721"/>
                <Item ID="0x2752"/>
                <Item ID="0x337a"/>
            </Group>
            <Group name="Organic, Other">
                <Group name="Brown Bearskin E">
                    <Item ID="0x1E40"/>
                    <Item ID="0x1E41"/>
                    <Item ID="0x1E42"/>
                    <Item ID="0x1E43"/>
                    <Item ID="0x1E44"/>
                    <Item ID="0x1E45"/>
                    <Item ID="0x1E46"/>
                    <Item ID="0x1E47"/>
                    <Item ID="0x1E48"/>
                </Group>
                <Group name="Brown Bearskin S">
                    <Item ID="0x1E36"/>
                    <Item ID="0x1E37"/>
                    <Item ID="0x1E38"/>
                    <Item ID="0x1E39"/>
                    <Item ID="0x1E3A"/>
                    <Item ID="0x1E3B"/>
                    <Item ID="0x1E3C"/>
                    <Item ID="0x1E3D"/>
                    <Item ID="0x1E3E"/>
                    <Item ID="0x2AC8"/>
                    <Item ID="0x2AC9"/>
                    <Item ID="0x2ACd"/>
                    <Item ID="0x2ACe"/>
                </Group>
                <Group name="Polar Bearskin E">
                    <Item ID="0x1E53"/>
                    <Item ID="0x1E54"/>
                    <Item ID="0x1E55"/>
                    <Item ID="0x1E56"/>
                    <Item ID="0x1E57"/>
                    <Item ID="0x1E58"/>
                    <Item ID="0x1E59"/>
                    <Item ID="0x1E5A"/>
                    <Item ID="0x1E5B"/>
                </Group>
                <Group name="Polar Bearskin S">
                    <Item ID="0x1E49"/>
                    <Item ID="0x1E4A"/>
                    <Item ID="0x1E4B"/>
                    <Item ID="0x1E4C"/>
                    <Item ID="0x1E4D"/>
                    <Item ID="0x1E4E"/>
                    <Item ID="0x1E4F"/>
                    <Item ID="0x1E50"/>
                    <Item ID="0x1E51"/>
                </Group>
                <Group name="Tatami">
                    <Item ID="0x2435"/>
                    <Item ID="0x2436"/>
                    <Item ID="0x2437"/>
                    <Item ID="0x2438"/>
                    <Item ID="0x29C0"/>
                    <Item ID="0x29C1"/>
                    <Item ID="0x29C2"/>
                    <Item ID="0x29C3"/>
                    <Item ID="0x29C4"/>
                    <Item ID="0x29C5"/>
                    <Item ID="0x29C6"/>
                    <Item ID="0x29C7"/>
                    <Item ID="0x29C8"/>
                    <Item ID="0x29C9"/>
                    <Item ID="0x29CA"/>
                    <Item ID="0x29CB"/>
                    <Item ID="0x29D0"/>
                    <Item ID="0x29D1"/>
                    <Item ID="0x29D6"/>
                    <Item ID="0x29D7"/>
                    <Item ID="0x29D8"/>
                    <Item ID="0x29D9"/>
                    <Item ID="0x29Da"/>
                    <Item ID="0x29Db"/>
                    <Item ID="0x2A1d"/>
                    <Item ID="0x2A1e"/>
                    <Item ID="0x2A1f"/>
                    <Item ID="0x2A20"/>
                    <Item ID="0x2A21"/>
                    <Item ID="0x2A21"/>
                    <Item ID="0x2A22"/>
                    <Item ID="0x2A22"/>
                    <Item ID="0x2A23"/>
                    <Item ID="0x2A23"/>
                    <Item ID="0x2A24"/>
                    <Item ID="0x2A24"/>
                    <Item ID="0x2A25"/>
                    <Item ID="0x2A26"/>
                    <Item ID="0x2A27"/>
                    <Item ID="0x2A28"/>
                    <Item ID="0x2A29"/>
                    <Item ID="0x2A3C"/>
                    <Item ID="0x2A3D"/>
                    <Item ID="0x2A3E"/>
                    <Item ID="0x2A3F"/>
                    <Item ID="0x2A40"/>
                    <Item ID="0x2A41"/>
                    <Item ID="0x2A42"/>
                    <Item ID="0x2A44"/>
                </Group>
            </Group>
            <Group name="Outdoors">
                <Group name="Cobblestone">
                    <Item ID="0x0515"/>
                    <Item ID="0x0516"/>
                    <Item ID="0x0517"/>
                    <Item ID="0x0518"/>
                    <Item ID="0x0654"/>
                    <Item ID="0x0655"/>
                </Group>
                <Group name="Drain">
                    <Item ID="0x30E7"/>
                    <Item ID="0x30E8"/>
                    <Item ID="0x30E9"/>
                    <Item ID="0x30EA"/>
                    <Item ID="0x30EB"/>
                    <Item ID="0x30EC"/>
                    <Item ID="0x30ED"/>
                    <Item ID="0x30EE"/>
                    <Item ID="0x30EF"/>
                    <Item ID="0x30F0"/>
                    <Item ID="0x30F1"/>
                    <Item ID="0x30F2"/>
                    <Item ID="0x30F3"/>
                    <Item ID="0x30F4"/>
                    <Item ID="0x30F5"/>
                    <Item ID="0x30F6"/>
                    <Item ID="0x30F7"/>
                    <Item ID="0x30F8"/>
                    <Item ID="0x30F9"/>
                    <Item ID="0x30FA"/>
                    <Item ID="0x30FB"/>
                    <Item ID="0x30FC"/>
                    <Item ID="0x30FD"/>
                    <Item ID="0x30FE"/>
                    <Item ID="0x30FF"/>
                    <Item ID="0x3100"/>
                    <Item ID="0x3101"/>
                    <Item ID="0x3102"/>
                    <Item ID="0x3103"/>
                    <Item ID="0x3104"/>
                    <Item ID="0x3105"/>
                    <Item ID="0x3106"/>
                    <Item ID="0x3107"/>
                    <Item ID="0x3108"/>
                    <Item ID="0x3109"/>
                    <Item ID="0x310A"/>
                </Group>
                <Group name="Pond">
                    <Item ID="0x2453"/>
                    <Item ID="0x2454"/>
                    <Item ID="0x2455"/>
                    <Item ID="0x2456"/>
                    <Item ID="0x2457"/>
                    <Item ID="0x2458"/>
                    <Item ID="0x2459"/>
                    <Item ID="0x245A"/>
                    <Item ID="0x245B"/>
                    <Item ID="0x245C"/>
                    <Item ID="0x245D"/>
                </Group>
                <Group name="Sand Garden">
                    <Item ID="0x245E"/>
                    <Item ID="0x245F"/>
                    <Item ID="0x2460"/>
                    <Item ID="0x2461"/>
                    <Item ID="0x2462"/>
                    <Item ID="0x2463"/>
                    <Item ID="0x2464"/>
                    <Item ID="0x2465"/>
                    <Item ID="0x2466"/>
                    <Item ID="0x2467"/>
                    <Item ID="0x2468"/>
                    <Item ID="0x2469"/>
                    <Item ID="0x246A"/>
                    <Item ID="0x246B"/>
                </Group>
                <Group name="Spotted">
                    <Item ID="0x3B27"/>
                    <Item ID="0x3B28"/>
                    <Item ID="0x3B29"/>
                    <Item ID="0x3B2A"/>
                    <Item ID="0x3B2B"/>
                    <Item ID="0x3B2C"/>
                    <Item ID="0x3B2D"/>
                    <Item ID="0x3B2E"/>
                    <Item ID="0x3B2F"/>
                    <Item ID="0x3B30"/>
                    <Item ID="0x3B31"/>
                    <Item ID="0x3B32"/>
                    <Item ID="0x3B33"/>
                    <Item ID="0x3B34"/>
                    <Item ID="0x3B35"/>
                    <Item ID="0x3B36"/>
                    <Item ID="0x3B37"/>
                </Group>
                <Group name="Tree">
                    <Item ID="0x2e69"/>
                    <Item ID="0x2e6a"/>
                    <Item ID="0x2e6b"/>
                    <Item ID="0x2e6c"/>
                    <Item ID="0x2e6d"/>
                    <Item ID="0x2e6e"/>
                    <Item ID="0x2e6f"/>
                    <Item ID="0x2e70"/>
                    <Item ID="0x2e71"/>
                    <Item ID="0x2e72"/>
                    <Item ID="0x2e73"/>
                    <Item ID="0x2e74"/>
                    <Item ID="0x2e75"/>
                    <Item ID="0x2e76"/>
                    <Item ID="0x2e77"/>
                    <Item ID="0x2e78"/>
                    <Item ID="0x2e79"/>
                    <Item ID="0x2e7a"/>
                    <Item ID="0x2e7b"/>
                    <Item ID="0x2e7c"/>
                    <Item ID="0x2e7d"/>
                    <Item ID="0x2e7e"/>
                    <Item ID="0x2e7f"/>
                    <Item ID="0x2e80"/>
                    <Item ID="0x2e81"/>
                    <Item ID="0x2e82"/>
                    <Item ID="0x2e83"/>
                    <Item ID="0x2e84"/>
                    <Item ID="0x2e85"/>
                    <Item ID="0x2e86"/>
                    <Item ID="0x2e87"/>
                    <Item ID="0x2e88"/>
                    <Item ID="0x2e89"/>
                    <Item ID="0x2e8a"/>
                    <Item ID="0x2e8b"/>
                    <Item ID="0x2e8c"/>
                    <Item ID="0x2e8d"/>
                    <Item ID="0x2e8e"/>
                    <Item ID="0x2e8f"/>
                    <Item ID="0x2e90"/>
                    <Item ID="0x2e91"/>
                    <Item ID="0x2e92"/>
                    <Item ID="0x2e93"/>
                    <Item ID="0x2e94"/>
                    <Item ID="0x2e95"/>
                    <Item ID="0x2e96"/>
                    <Item ID="0x2e97"/>
                    <Item ID="0x2e98"/>
                    <Item ID="0x2e99"/>
                    <Item ID="0x2e9a"/>
                    <Item ID="0x2e9b"/>
                    <Item ID="0x2e9c"/>
                    <Item ID="0x2e9d"/>
                    <Item ID="0x2e9e"/>
                    <Item ID="0x2e9f"/>
                    <Item ID="0x2ea0"/>
                    <Item ID="0x2ea1"/>
                    <Item ID="0x2ea2"/>
                    <Item ID="0x2ea3"/>
                    <Item ID="0x2ea4"/>
                    <Item ID="0x2ea5"/>
                    <Item ID="0x2ea6"/>
                    <Item ID="0x2ea7"/>
                    <Item ID="0x2ea8"/>
                    <Item ID="0x2ea9"/>
                    <Item ID="0x2eaa"/>
                    <Item ID="0x2eab"/>
                    <Item ID="0x2eac"/>
                    <Item ID="0x2ead"/>
                    <Item ID="0x2eae"/>
                    <Item ID="0x2eaf"/>
                    <Item ID="0x2eb0"/>
                    <Item ID="0x2eb1"/>
                    <Item ID="0x2eb2"/>
                    <Item ID="0x2eb3"/>
                    <Item ID="0x2eb4"/>
                    <Item ID="0x2eb5"/>
                    <Item ID="0x2eb6"/>
                    <Item ID="0x2eb7"/>
                    <Item ID="0x2eb8"/>
                    <Item ID="0x2eb9"/>
                    <Item ID="0x2eba"/>
                    <Item ID="0x2ebb"/>
                    <Item ID="0x2ebc"/>
                    <Item ID="0x2ebd"/>
                    <Item ID="0x2ebe"/>
                    <Item ID="0x2ebf"/>
                    <Item ID="0x2ec0"/>
                    <Item ID="0x2ec1"/>
                    <Item ID="0x2ec2"/>
                    <Item ID="0x2ec3"/>
                    <Item ID="0x2ec4"/>
                    <Item ID="0x2ec5"/>
                    <Item ID="0x2ec6"/>
                    <Item ID="0x2ec7"/>
                    <Item ID="0x2ec8"/>
                    <Item ID="0x2ec9"/>
                    <Item ID="0x2eca"/>
                    <Item ID="0x2ecb"/>
                    <Item ID="0x2ecc"/>
                    <Item ID="0x2ecd"/>
                    <Item ID="0x2ece"/>
                    <Item ID="0x2ecf"/>
                    <Item ID="0x2ed0"/>
                    <Item ID="0x2ed1"/>
                    <Item ID="0x2ed2"/>
                    <Item ID="0x2ed3"/>
                    <Item ID="0x2ed4"/>
                    <Item ID="0x2ed5"/>
                    <Item ID="0x2ed6"/>
                    <Item ID="0x2ed7"/>
                    <Item ID="0x2ed8"/>
                    <Item ID="0x2ed9"/>
                    <Item ID="0x2eda"/>
                    <Item ID="0x2edb"/>
                    <Item ID="0x2ee1"/>
                    <Item ID="0x2ee2"/>
                    <Item ID="0x2ee3"/>
                    <Item ID="0x2ee4"/>
                    <Item ID="0x2ee5"/>
                    <Item ID="0x2ee6"/>
                    <Item ID="0x2ee7"/>
                    <Item ID="0x2ee8"/>
                    <Item ID="0x2ee9"/>
                    <Item ID="0x2eea"/>
                    <Item ID="0x2eeb"/>
                    <Item ID="0x2eec"/>
                    <Item ID="0x2eed"/>
                    <Item ID="0x2eee"/>
                    <Item ID="0x2eef"/>
                    <Item ID="0x2ef0"/>
                    <Item ID="0x2ef1"/>
                    <Item ID="0x2ef2"/>
                    <Item ID="0x2ef3"/>
                    <Item ID="0x2ef4"/>
                    <Item ID="0x2ef5"/>
                    <Item ID="0x2ef6"/>
                    <Item ID="0x2ef7"/>
                    <Item ID="0x2ef8"/>
                    <Item ID="0x2ef9"/>
                    <Item ID="0x2efa"/>
                    <Item ID="0x2efb"/>
                    <Item ID="0x2efc"/>
                    <Item ID="0x2efd"/>
                    <Item ID="0x2efe"/>
                    <Item ID="0x2eff"/>
                    <Item ID="0x2f00"/>
                    <Item ID="0x2f01"/>
                    <Item ID="0x2f02"/>
                    <Item ID="0x2f03"/>
                    <Item ID="0x2f04"/>
                    <Item ID="0x2f05"/>
                    <Item ID="0x2f06"/>
                    <Item ID="0x2f07"/>
                    <Item ID="0x2f08"/>
                    <Item ID="0x2f09"/>
                    <Item ID="0x2f0a"/>
                    <Item ID="0x2f0b"/>
                    <Item ID="0x2f0c"/>
                    <Item ID="0x2f0d"/>
                    <Item ID="0x2f0e"/>
                    <Item ID="0x39da"/>
                    <Item ID="0x39db"/>
                    <Item ID="0x39dc"/>
                    <Item ID="0x39dd"/>
                    <Item ID="0x39de"/>
                    <Item ID="0x39df"/>
                    <Item ID="0x39e0"/>
                    <Item ID="0x39e1"/>
                    <Item ID="0x39e2"/>
                    <Item ID="0x39e3"/>
                    <Item ID="0x39e4"/>
                    <Item ID="0x39e5"/>
                    <Item ID="0x39e6"/>
                    <Item ID="0x3a1f"/>
                    <Item ID="0x3a20"/>
                    <Item ID="0x3a21"/>
                    <Item ID="0x3a22"/>
                    <Item ID="0x3a23"/>
                    <Item ID="0x3a24"/>
                    <Item ID="0x3a25"/>
                    <Item ID="0x3a26"/>
                    <Item ID="0x3a27"/>
                    <Item ID="0x3a28"/>
                    <Item ID="0x3a29"/>
                    <Item ID="0x3a2a"/>
                    <Item ID="0x3a2b"/>
                    <Item ID="0x3a2c"/>
                    <Item ID="0x3a2d"/>
                    <Item ID="0x3a2e"/>
                    <Item ID="0x3a2f"/>
                    <Item ID="0x3a30"/>
                    <Item ID="0x3a31"/>
                    <Item ID="0x3a32"/>
                    <Item ID="0x3a45"/>
                    <Item ID="0x3a46"/>
                    <Item ID="0x3a47"/>
                    <Item ID="0x3a48"/>
                    <Item ID="0x3a49"/>
                    <Item ID="0x3a4a"/>
                    <Item ID="0x3a4b"/>
                    <Item ID="0x3a4c"/>
                    <Item ID="0x3a4d"/>
                    <Item ID="0x3a4e"/>
                    <Item ID="0x3a4f"/>
                    <Item ID="0x3a50"/>
                    <Item ID="0x3a51"/>
                    <Item ID="0x3a52"/>
                    <Item ID="0x3a53"/>
                    <Item ID="0x3a54"/>
                    <Item ID="0x3af0"/>
                    <Item ID="0x3af1"/>
                    <Item ID="0x3af2"/>
                    <Item ID="0x3af3"/>
                    <Item ID="0x3af4"/>
                    <Item ID="0x3af5"/>
                    <Item ID="0x3af6"/>
                    <Item ID="0x3af7"/>
                    <Item ID="0x3af8"/>
                </Group>
            </Group>
            <Group name="Rough Stone">
                <Group name="Blueish Stone">
                    <Item ID="0x063b"/>
                    <Item ID="0x063c"/>
                    <Item ID="0x063d"/>
                    <Item ID="0x063e"/>
                    <Item ID="0x0652"/>
                    <Item ID="0x0653"/>
                </Group>
                <Group name="Flagstone">
                    <Item ID="0x04Fc"/>
                    <Item ID="0x04Fd"/>
                    <Item ID="0x04Fe"/>
                    <Item ID="0x04Ff"/>
                    <Item ID="0x0500"/>
                    <Item ID="0x0501"/>
                    <Item ID="0x0502"/>
                    <Item ID="0x0503"/>
                </Group>
                <Group name="Gray Stone">
                    <Item ID="0x0579"/>
                    <Item ID="0x057a"/>
                    <Item ID="0x057b"/>
                    <Item ID="0x057c"/>
                    <Item ID="0x057d"/>
                    <Item ID="0x057e"/>
                </Group>
                <Group name="Red Brick">
                    <Item ID="0x04E2"/>
                    <Item ID="0x04E3"/>
                    <Item ID="0x04E4"/>
                    <Item ID="0x04E5"/>
                    <Item ID="0x04E6"/>
                    <Item ID="0x04E7"/>
                    <Item ID="0x04E8"/>
                    <Item ID="0x04E9"/>
                    <Item ID="0x0537"/>
                    <Item ID="0x0538"/>
                    <Item ID="0x0539"/>
                    <Item ID="0x053a"/>
                </Group>
                <Group name="Red Stone">
                    <Item ID="0x0554"/>
                    <Item ID="0x0555"/>
                    <Item ID="0x0556"/>
                    <Item ID="0x0557"/>
                    <Item ID="0x055C"/>
                    <Item ID="0x055d"/>
                    <Item ID="0x055e"/>
                    <Item ID="0x055f"/>
                    <Item ID="0x0560"/>
                    <Item ID="0x0561"/>
                    <Item ID="0x0562"/>
                    <Item ID="0x0563"/>
                    <Item ID="0x0564"/>
                    <Item ID="0x0565"/>
                    <Item ID="0x0566"/>
                    <Item ID="0x0567"/>
                    <Item ID="0x0568"/>
                    <Item ID="0x0569"/>
                    <Item ID="0x062f"/>
                    <Item ID="0x0630"/>
                    <Item ID="0x0631"/>
                    <Item ID="0x0631"/>
                    <Item ID="0x0632"/>
                    <Item ID="0x0632"/>
                    <Item ID="0x0656"/>
                    <Item ID="0x0657"/>
                </Group>
                <Group name="Slate">
                    <Item ID="0x057F"/>
                    <Item ID="0x0580"/>
                    <Item ID="0x0581"/>
                    <Item ID="0x0582"/>
                    <Item ID="0x0583"/>
                    <Item ID="0x0584"/>
                    <Item ID="0x0585"/>
                    <Item ID="0x0658"/>
                    <Item ID="0x0659"/>
                </Group>
                <Group name="Stone Pavers">
                    <Item ID="0x0519"/>
                    <Item ID="0x051a"/>
                    <Item ID="0x051b"/>
                    <Item ID="0x051c"/>
                    <Item ID="0x051d"/>
                    <Item ID="0x051e"/>
                    <Item ID="0x051f"/>
                    <Item ID="0x0520"/>
                    <Item ID="0x0521"/>
                    <Item ID="0x0522"/>
                    <Item ID="0x0523"/>
                    <Item ID="0x0524"/>
                </Group>
                <Group name="White Stone">
                    <Item ID="0x0550"/>
                    <Item ID="0x0558"/>
                    <Item ID="0x0559"/>
                    <Item ID="0x055A"/>
                    <Item ID="0x055B"/>
                    <Item ID="0x055a"/>
                    <Item ID="0x055b"/>
                    <Item ID="0x056B"/>
                    <Item ID="0x056C"/>
                    <Item ID="0x056D"/>
                    <Item ID="0x056E"/>
                    <Item ID="0x056F"/>
                    <Item ID="0x0570"/>
                    <Item ID="0x0571"/>
                    <Item ID="0x0572"/>
                    <Item ID="0x0573"/>
                    <Item ID="0x0574"/>
                    <Item ID="0x0575"/>
                    <Item ID="0x0576"/>
                    <Item ID="0x0577"/>
                    <Item ID="0x05ef"/>
                    <Item ID="0x062D"/>
                    <Item ID="0x062E"/>
                    <Item ID="0x062b"/>
                    <Item ID="0x062c"/>
                    <Item ID="0x062d"/>
                    <Item ID="0x062e"/>
                    <Item ID="0x0637"/>
                    <Item ID="0x0638"/>
                    <Item ID="0x0639"/>
                    <Item ID="0x063a"/>
                    <Item ID="0x065a"/>
                    <Item ID="0x065b"/>
                    <Item ID="0x065c"/>
                    <Item ID="0x065d"/>
                </Group>
                <Group name="sandstone">
                    <Item ID="0x049D"/>
                    <Item ID="0x049e"/>
                    <Item ID="0x049f"/>
                    <Item ID="0x04a0"/>
                    <Item ID="0x0525"/>
                    <Item ID="0x0525"/>
                    <Item ID="0x0526"/>
                    <Item ID="0x0527"/>
                    <Item ID="0x0528"/>
                    <Item ID="0x0529"/>
                    <Item ID="0x052F"/>
                    <Item ID="0x052a"/>
                    <Item ID="0x052b"/>
                    <Item ID="0x052c"/>
                    <Item ID="0x0530"/>
                    <Item ID="0x0531"/>
                    <Item ID="0x0532"/>
                    <Item ID="0x0533"/>
                    <Item ID="0x0534"/>
                    <Item ID="0x0535"/>
                    <Item ID="0x0536"/>
                    <Item ID="0x1383"/>
                    <Item ID="0x1384"/>
                    <Item ID="0x1385"/>
                    <Item ID="0x1386"/>
                </Group>
            </Group>
            <Group name="Wood">
                <Group name="Bamboo Logs">
                    <Item ID="0x04C1"/>
                    <Item ID="0x04C2"/>
                    <Item ID="0x04C3"/>
                    <Item ID="0x04C4"/>
                    <Item ID="0x04C5"/>
                    <Item ID="0x0504"/>
                    <Item ID="0x0505"/>
                    <Item ID="0x0506"/>
                    <Item ID="0x0507"/>
                    <Item ID="0x0508"/>
                    <Item ID="0x0509"/>
                    <Item ID="0x050A"/>
                    <Item ID="0x050B"/>
                    <Item ID="0x050C"/>
                </Group>
                <Group name="Brown Board">
                    <Item ID="0x2978"/>
                    <Item ID="0x2979"/>
                    <Item ID="0x297A"/>
                    <Item ID="0x297B"/>
                    <Item ID="0x297C"/>
                    <Item ID="0x297D"/>
                    <Item ID="0x297E"/>
                    <Item ID="0x297F"/>
                    <Item ID="0x2980"/>
                    <Item ID="0x2981"/>
                    <Item ID="0x2982"/>
                    <Item ID="0x2983"/>
                    <Item ID="0x2984"/>
                    <Item ID="0x2985"/>
                    <Item ID="0x2986"/>
                    <Item ID="0x2987"/>
                    <Item ID="0x2988"/>
                    <Item ID="0x2989"/>
                    <Item ID="0x298A"/>
                    <Item ID="0x298B"/>
                    <Item ID="0x298C"/>
                    <Item ID="0x298D"/>
                    <Item ID="0x298E"/>
                    <Item ID="0x298F"/>
                </Group>
                <Group name="Dark Wood Board">
                    <Item ID="0x04A5"/>
                    <Item ID="0x04A6"/>
                    <Item ID="0x04A7"/>
                    <Item ID="0x04A8"/>
                    <Item ID="0x04A9"/>
                    <Item ID="0x04AA"/>
                    <Item ID="0x04AB"/>
                    <Item ID="0x04AC"/>
                    <Item ID="0x04AD"/>
                    <Item ID="0x04AE"/>
                    <Item ID="0x04AF"/>
                    <Item ID="0x04B0"/>
                    <Item ID="0x04B1"/>
                    <Item ID="0x04B2"/>
                    <Item ID="0x04B3"/>
                    <Item ID="0x04B4"/>
                    <Item ID="0x04B5"/>
                    <Item ID="0x04B6"/>
                    <Item ID="0x04B7"/>
                    <Item ID="0x04B8"/>
                    <Item ID="0x04B9"/>
                    <Item ID="0x04BA"/>
                    <Item ID="0x04BB"/>
                    <Item ID="0x04BC"/>
                    <Item ID="0x04BD"/>
                    <Item ID="0x04BE"/>
                    <Item ID="0x04BF"/>
                    <Item ID="0x04C0"/>
                </Group>
                <Group name="Floral Wood">
                    <Item ID="0x2BB5"/>
                    <Item ID="0x2BB6"/>
                    <Item ID="0x2BB7"/>
                    <Item ID="0x2BB8"/>
                    <Item ID="0x2BCF"/>
                    <Item ID="0x2CEC"/>
                    <Item ID="0x2CED"/>
                    <Item ID="0x2CEE"/>
                    <Item ID="0x2D38"/>
                    <Item ID="0x2D39"/>
                    <Item ID="0x2D3A"/>
                    <Item ID="0x2D3B"/>
                    <Item ID="0x2DCB"/>
                    <Item ID="0x2DCC"/>
                    <Item ID="0x2DCD"/>
                    <Item ID="0x2DCE"/>
                    <Item ID="0x3004"/>
                    <Item ID="0x3005"/>
                    <Item ID="0x3006"/>
                    <Item ID="0x3007"/>
                </Group>
                <Group name="Light Brown Board">
                    <Item ID="0x273A"/>
                    <Item ID="0x273B"/>
                    <Item ID="0x273C"/>
                    <Item ID="0x273D"/>
                    <Item ID="0x273E"/>
                    <Item ID="0x273F"/>
                    <Item ID="0x2740"/>
                    <Item ID="0x2741"/>
                    <Item ID="0x2742"/>
                    <Item ID="0x2743"/>
                    <Item ID="0x2744"/>
                    <Item ID="0x2745"/>
                    <Item ID="0x2746"/>
                    <Item ID="0x2747"/>
                    <Item ID="0x2748"/>
                    <Item ID="0x2749"/>
                    <Item ID="0x274A"/>
                    <Item ID="0x274B"/>
                    <Item ID="0x274C"/>
                    <Item ID="0x274D"/>
                    <Item ID="0x274E"/>
                    <Item ID="0x274F"/>
                    <Item ID="0x2750"/>
                    <Item ID="0x2751"/>
                </Group>
                <Group name="Light Red Board">
                    <Item ID="0x2722"/>
                    <Item ID="0x2723"/>
                    <Item ID="0x2724"/>
                    <Item ID="0x2725"/>
                    <Item ID="0x2726"/>
                    <Item ID="0x2727"/>
                    <Item ID="0x2728"/>
                    <Item ID="0x2729"/>
                    <Item ID="0x272A"/>
                    <Item ID="0x272B"/>
                    <Item ID="0x272C"/>
                    <Item ID="0x272D"/>
                    <Item ID="0x272E"/>
                    <Item ID="0x272F"/>
                    <Item ID="0x2730"/>
                    <Item ID="0x2731"/>
                    <Item ID="0x2732"/>
                    <Item ID="0x2733"/>
                    <Item ID="0x2734"/>
                    <Item ID="0x2735"/>
                    <Item ID="0x2736"/>
                    <Item ID="0x2737"/>
                    <Item ID="0x2738"/>
                    <Item ID="0x2739"/>
                </Group>
                <Group name="Light Wood Planks">
                    <Item ID="0x04A1"/>
                    <Item ID="0x04A2"/>
                    <Item ID="0x04A3"/>
                    <Item ID="0x04A4"/>
                    <Item ID="0x04C6"/>
                    <Item ID="0x04C7"/>
                    <Item ID="0x04C8"/>
                    <Item ID="0x04C9"/>
                    <Item ID="0x04CA"/>
                    <Item ID="0x04CB"/>
                    <Item ID="0x04CC"/>
                    <Item ID="0x04CD"/>
                    <Item ID="0x04CE"/>
                    <Item ID="0x04CF"/>
                    <Item ID="0x04D0"/>
                    <Item ID="0x04D1"/>
                    <Item ID="0x04D2"/>
                    <Item ID="0x04D3"/>
                    <Item ID="0x04D4"/>
                    <Item ID="0x04D5"/>
                    <Item ID="0x04D6"/>
                    <Item ID="0x04D7"/>
                    <Item ID="0x04D8"/>
                    <Item ID="0x04D9"/>
                    <Item ID="0x04DA"/>
                    <Item ID="0x04DB"/>
                    <Item ID="0x04DC"/>
                    <Item ID="0x04DD"/>
                    <Item ID="0x04DE"/>
                    <Item ID="0x04DF"/>
                    <Item ID="0x04E0"/>
                    <Item ID="0x04E1"/>
                </Group>
                <Group name="Parquet">
                    <Item ID="0x2425"/>
                    <Item ID="0x2426"/>
                    <Item ID="0x2427"/>
                    <Item ID="0x2428"/>
                    <Item ID="0x2429"/>
                    <Item ID="0x242a"/>
                    <Item ID="0x242b"/>
                    <Item ID="0x242c"/>
                    <Item ID="0x242d"/>
                    <Item ID="0x242e"/>
                    <Item ID="0x242f"/>
                    <Item ID="0x2430"/>
                    <Item ID="0x2431"/>
                    <Item ID="0x2432"/>
                    <Item ID="0x2434"/>
                    <Item ID="0x2435"/>
                    <Item ID="0x2436"/>
                    <Item ID="0x2437"/>
                    <Item ID="0x2438"/>
                    <Item ID="0x2439"/>
                    <Item ID="0x243A"/>
                </Group>
                <Group name="Red-Brown Board">
                    <Item ID="0x243B"/>
                    <Item ID="0x243c"/>
                    <Item ID="0x243d"/>
                    <Item ID="0x243e"/>
                    <Item ID="0x243f"/>
                    <Item ID="0x2440"/>
                    <Item ID="0x2441"/>
                    <Item ID="0x2442"/>
                    <Item ID="0x2443"/>
                    <Item ID="0x2444"/>
                    <Item ID="0x2445"/>
                    <Item ID="0x2446"/>
                    <Item ID="0x2447"/>
                    <Item ID="0x2448"/>
                    <Item ID="0x2449"/>
                    <Item ID="0x244B"/>
                    <Item ID="0x244a"/>
                    <Item ID="0x244c"/>
                    <Item ID="0x244d"/>
                    <Item ID="0x244e"/>
                    <Item ID="0x244f"/>
                    <Item ID="0x2450"/>
                    <Item ID="0x2451"/>
                    <Item ID="0x2452"/>
                    <Item ID="0x2960"/>
                    <Item ID="0x2961"/>
                    <Item ID="0x2962"/>
                    <Item ID="0x2963"/>
                    <Item ID="0x2964"/>
                    <Item ID="0x2965"/>
                    <Item ID="0x2966"/>
                    <Item ID="0x2967"/>
                    <Item ID="0x2968"/>
                    <Item ID="0x2969"/>
                    <Item ID="0x296A"/>
                    <Item ID="0x296B"/>
                    <Item ID="0x296C"/>
                    <Item ID="0x296D"/>
                    <Item ID="0x296E"/>
                    <Item ID="0x296F"/>
                    <Item ID="0x2970"/>
                    <Item ID="0x2971"/>
                    <Item ID="0x2972"/>
                    <Item ID="0x2973"/>
                    <Item ID="0x2974"/>
                    <Item ID="0x2975"/>
                    <Item ID="0x2976"/>
                    <Item ID="0x2977"/>
                </Group>
                <Group name="Yellow Board">
                    <Item ID="0x286e"/>
                    <Item ID="0x286f"/>
                    <Item ID="0x2870"/>
                    <Item ID="0x2871"/>
                    <Item ID="0x2872"/>
                    <Item ID="0x2873"/>
                    <Item ID="0x2874"/>
                    <Item ID="0x2875"/>
                    <Item ID="0x2876"/>
                    <Item ID="0x2877"/>
                    <Item ID="0x2878"/>
                    <Item ID="0x2879"/>
                    <Item ID="0x287a"/>
                    <Item ID="0x287b"/>
                    <Item ID="0x287c"/>
                    <Item ID="0x287d"/>
                    <Item ID="0x287e"/>
                    <Item ID="0x287f"/>
                    <Item ID="0x2880"/>
                    <Item ID="0x2881"/>
                    <Item ID="0x2882"/>
                    <Item ID="0x2883"/>
                    <Item ID="0x2884"/>
                    <Item ID="0x2885"/>
                </Group>
            </Group>
        </Group>
        <Group name="Roofs">
            <Group name="Organic">
                <Group name="Bark">
                    <Item ID="0x26F8"/>
                    <Item ID="0x26F9"/>
                    <Item ID="0x26FA"/>
                    <Item ID="0x26FB"/>
                    <Item ID="0x26FC"/>
                    <Item ID="0x26FD"/>
                    <Item ID="0x26FE"/>
                    <Item ID="0x26FF"/>
                    <Item ID="0x2700"/>
                    <Item ID="0x2701"/>
                    <Item ID="0x2702"/>
                    <Item ID="0x2703"/>
                    <Item ID="0x2704"/>
                    <Item ID="0x2705"/>
                    <Item ID="0x2706"/>
                    <Item ID="0x2707"/>
                    <Item ID="0x2708"/>
                    <Item ID="0x2709"/>
                    <Item ID="0x270A"/>
                    <Item ID="0x270B"/>
                    <Item ID="0x270C"/>
                </Group>
                <Group name="Blue Tent">
                    <Item ID="0x05FF"/>
                    <Item ID="0x0600"/>
                    <Item ID="0x0601"/>
                    <Item ID="0x0602"/>
                    <Item ID="0x0603"/>
                    <Item ID="0x0604"/>
                    <Item ID="0x0605"/>
                    <Item ID="0x0606"/>
                    <Item ID="0x0607"/>
                    <Item ID="0x0608"/>
                    <Item ID="0x0609"/>
                    <Item ID="0x060A"/>
                    <Item ID="0x060B"/>
                    <Item ID="0x060C"/>
                    <Item ID="0x060D"/>
                    <Item ID="0x060E"/>
                    <Item ID="0x060F"/>
                    <Item ID="0x0610"/>
                    <Item ID="0x0611"/>
                    <Item ID="0x0612"/>
                    <Item ID="0x0613"/>
                    <Item ID="0x0614"/>
                    <Item ID="0x0633"/>
                    <Item ID="0x0634"/>
                    <Item ID="0x064C"/>
                    <Item ID="0x064D"/>
                    <Item ID="0x064E"/>
                </Group>
                <Group name="Green Tent">
                    <Item ID="0x0615"/>
                    <Item ID="0x0616"/>
                    <Item ID="0x0617"/>
                    <Item ID="0x0618"/>
                    <Item ID="0x0619"/>
                    <Item ID="0x061A"/>
                    <Item ID="0x061B"/>
                    <Item ID="0x061C"/>
                    <Item ID="0x061D"/>
                    <Item ID="0x061E"/>
                    <Item ID="0x061F"/>
                    <Item ID="0x0620"/>
                    <Item ID="0x0621"/>
                    <Item ID="0x0622"/>
                    <Item ID="0x0623"/>
                    <Item ID="0x0624"/>
                    <Item ID="0x0625"/>
                    <Item ID="0x0626"/>
                    <Item ID="0x0627"/>
                    <Item ID="0x0628"/>
                    <Item ID="0x0629"/>
                    <Item ID="0x062A"/>
                    <Item ID="0x0635"/>
                    <Item ID="0x0636"/>
                    <Item ID="0x064F"/>
                    <Item ID="0x0650"/>
                    <Item ID="0x0651"/>
                </Group>
                <Group name="Hay">
                    <Item ID="0x26DA"/>
                    <Item ID="0x26DB"/>
                    <Item ID="0x26DC"/>
                    <Item ID="0x26DD"/>
                    <Item ID="0x26DE"/>
                    <Item ID="0x26DF"/>
                    <Item ID="0x26E0"/>
                    <Item ID="0x26E1"/>
                    <Item ID="0x26E2"/>
                    <Item ID="0x26E3"/>
                    <Item ID="0x26E4"/>
                    <Item ID="0x26E5"/>
                    <Item ID="0x26E6"/>
                    <Item ID="0x26E7"/>
                    <Item ID="0x26E8"/>
                    <Item ID="0x26E9"/>
                    <Item ID="0x26EA"/>
                    <Item ID="0x26EB"/>
                    <Item ID="0x26EC"/>
                </Group>
                <Group name="Leaves">
                    <Item ID="0x2B94"/>
                    <Item ID="0x2B95"/>
                    <Item ID="0x2B96"/>
                    <Item ID="0x2B97"/>
                    <Item ID="0x2B98"/>
                    <Item ID="0x2B99"/>
                    <Item ID="0x2B9A"/>
                    <Item ID="0x2B9B"/>
                    <Item ID="0x2B9C"/>
                    <Item ID="0x2B9D"/>
                    <Item ID="0x2B9E"/>
                    <Item ID="0x2B9F"/>
                    <Item ID="0x2BA0"/>
                    <Item ID="0x2BA1"/>
                    <Item ID="0x2BA2"/>
                    <Item ID="0x2BA3"/>
                    <Item ID="0x2BA4"/>
                    <Item ID="0x2BA5"/>
                    <Item ID="0x2BA6"/>
                    <Item ID="0x2BA7"/>
                    <Item ID="0x2BA8"/>
                    <Item ID="0x2F24"/>
                    <Item ID="0x2F25"/>
                    <Item ID="0x2F26"/>
                    <Item ID="0x2F27"/>
                    <Item ID="0x2F28"/>
                </Group>
                <Group name="Light Gray Tent">
                    <Item ID="0x0648"/>
                    <Item ID="0x0649"/>
                    <Item ID="0x064A"/>
                    <Item ID="0x065E"/>
                    <Item ID="0x065F"/>
                    <Item ID="0x0660"/>
                    <Item ID="0x0661"/>
                    <Item ID="0x0662"/>
                    <Item ID="0x0663"/>
                    <Item ID="0x0664"/>
                    <Item ID="0x0665"/>
                    <Item ID="0x0666"/>
                    <Item ID="0x0667"/>
                    <Item ID="0x0668"/>
                    <Item ID="0x0669"/>
                    <Item ID="0x066A"/>
                    <Item ID="0x066B"/>
                    <Item ID="0x066C"/>
                    <Item ID="0x066D"/>
                    <Item ID="0x066E"/>
                    <Item ID="0x066F"/>
                    <Item ID="0x0670"/>
                    <Item ID="0x0671"/>
                    <Item ID="0x0672"/>
                    <Item ID="0x0673"/>
                    <Item ID="0x0674"/>
                </Group>
                <Group name="Palm">
                    <Group name="Round Palm Roof">
                        <Item ID="0x05d1"/>
                        <Item ID="0x05d2"/>
                        <Item ID="0x05d3"/>
                        <Item ID="0x05d4"/>
                        <Item ID="0x05d6"/>
                        <Item ID="0x05d7"/>
                        <Item ID="0x05d8"/>
                        <Item ID="0x05d9"/>
                        <Item ID="0x05da"/>
                        <Item ID="0x05db"/>
                        <Item ID="0x05dc"/>
                        <Item ID="0x05dd"/>
                        <Item ID="0x05de"/>
                        <Item ID="0x05df"/>
                        <Item ID="0x05e0"/>
                        <Item ID="0x05e1"/>
                        <Item ID="0x05e2"/>
                        <Item ID="0x05e3"/>
                        <Item ID="0x05e4"/>
                        <Item ID="0x05e5"/>
                        <Item ID="0x05e6"/>
                        <Item ID="0x05e7"/>
                        <Item ID="0x05e8"/>
                        <Item ID="0x05e9"/>
                        <Item ID="0x05ea"/>
                        <Item ID="0x05eb"/>
                        <Item ID="0x05ec"/>
                    </Group>
                    <Item ID="0x0586"/>
                    <Item ID="0x0587"/>
                    <Item ID="0x0588"/>
                    <Item ID="0x0589"/>
                    <Item ID="0x058A"/>
                    <Item ID="0x058B"/>
                    <Item ID="0x058C"/>
                    <Item ID="0x058D"/>
                    <Item ID="0x058E"/>
                    <Item ID="0x058F"/>
                    <Item ID="0x0590"/>
                    <Item ID="0x0591"/>
                    <Item ID="0x0592"/>
                    <Item ID="0x0593"/>
                    <Item ID="0x0594"/>
                    <Item ID="0x2180"/>
                    <Item ID="0x2181"/>
                    <Item ID="0x2182"/>
                    <Item ID="0x2183"/>
                    <Item ID="0x2184"/>
                    <Item ID="0x2185"/>
                    <Item ID="0x2186"/>
                    <Item ID="0x2187"/>
                    <Item ID="0x2c60"/>
                    <Item ID="0x2c61"/>
                    <Item ID="0x2c62"/>
                    <Item ID="0x2c63"/>
                    <Item ID="0x2c64"/>
                    <Item ID="0x2c65"/>
                    <Item ID="0x2c66"/>
                    <Item ID="0x2c67"/>
                    <Item ID="0x2c68"/>
                    <Item ID="0x2c69"/>
                    <Item ID="0x2c6a"/>
                    <Item ID="0x2c6b"/>
                    <Item ID="0x2c6c"/>
                    <Item ID="0x2c6d"/>
                    <Item ID="0x2c6e"/>
                </Group>
                <Group name="Thatch">
                    <Item ID="0x05A4"/>
                    <Item ID="0x05A5"/>
                    <Item ID="0x05A6"/>
                    <Item ID="0x05A7"/>
                    <Item ID="0x05A8"/>
                    <Item ID="0x05A9"/>
                    <Item ID="0x05AA"/>
                    <Item ID="0x05AB"/>
                    <Item ID="0x05AC"/>
                    <Item ID="0x05AD"/>
                    <Item ID="0x05AE"/>
                    <Item ID="0x05AF"/>
                    <Item ID="0x05B0"/>
                    <Item ID="0x05B1"/>
                    <Item ID="0x05B2"/>
                    <Item ID="0x2148"/>
                    <Item ID="0x2149"/>
                    <Item ID="0x214a"/>
                    <Item ID="0x214b"/>
                    <Item ID="0x214c"/>
                    <Item ID="0x214d"/>
                    <Item ID="0x214e"/>
                    <Item ID="0x214f"/>
                    <Item ID="0x2c51"/>
                    <Item ID="0x2c52"/>
                    <Item ID="0x2c53"/>
                    <Item ID="0x2c54"/>
                    <Item ID="0x2c55"/>
                    <Item ID="0x2c56"/>
                    <Item ID="0x2c57"/>
                    <Item ID="0x2c58"/>
                    <Item ID="0x2c59"/>
                    <Item ID="0x2c5a"/>
                    <Item ID="0x2c5b"/>
                    <Item ID="0x2c5c"/>
                    <Item ID="0x2c5d"/>
                    <Item ID="0x2c5e"/>
                    <Item ID="0x2c5f"/>
                </Group>
            </Group>
            <Group name="Stone, Clay, Ceramic">
                <Group name="Black Ceramic">
                    <Item ID="0x23BE"/>
                    <Item ID="0x23BF"/>
                    <Item ID="0x23C0"/>
                    <Item ID="0x23C1"/>
                    <Item ID="0x23C2"/>
                    <Item ID="0x23C3"/>
                    <Item ID="0x23C4"/>
                    <Item ID="0x23C5"/>
                    <Item ID="0x23C6"/>
                    <Item ID="0x23C7"/>
                    <Item ID="0x23C8"/>
                    <Item ID="0x23C9"/>
                    <Item ID="0x23CA"/>
                    <Item ID="0x23CB"/>
                    <Item ID="0x23CC"/>
                    <Item ID="0x23CD"/>
                    <Item ID="0x23CE"/>
                    <Item ID="0x23CF"/>
                    <Item ID="0x23D0"/>
                    <Item ID="0x23D1"/>
                    <Item ID="0x23D2"/>
                    <Item ID="0x23D3"/>
                </Group>
                <Group name="Clay Shingle">
                    <Item ID="0x05B3"/>
                    <Item ID="0x05B4"/>
                    <Item ID="0x05B5"/>
                    <Item ID="0x05B6"/>
                    <Item ID="0x05B7"/>
                    <Item ID="0x05B8"/>
                    <Item ID="0x05B9"/>
                    <Item ID="0x05BA"/>
                    <Item ID="0x05BB"/>
                    <Item ID="0x05BC"/>
                    <Item ID="0x05BD"/>
                    <Item ID="0x05BE"/>
                    <Item ID="0x05BF"/>
                    <Item ID="0x05C0"/>
                    <Item ID="0x05C1"/>
                    <Item ID="0x06fd"/>
                    <Item ID="0x06fe"/>
                    <Item ID="0x06ff"/>
                    <Item ID="0x0700"/>
                    <Item ID="0x21e9"/>
                    <Item ID="0x21ea"/>
                    <Item ID="0x21eb"/>
                    <Item ID="0x21ec"/>
                    <Item ID="0x21ed"/>
                    <Item ID="0x21ee"/>
                    <Item ID="0x21ef"/>
                    <Item ID="0x21f0"/>
                    <Item ID="0x2c24"/>
                    <Item ID="0x2c25"/>
                    <Item ID="0x2c26"/>
                    <Item ID="0x2c27"/>
                    <Item ID="0x2c28"/>
                    <Item ID="0x2c29"/>
                    <Item ID="0x2c2a"/>
                    <Item ID="0x2c2b"/>
                    <Item ID="0x2c2c"/>
                    <Item ID="0x2c2d"/>
                    <Item ID="0x2c2e"/>
                    <Item ID="0x2c2f"/>
                    <Item ID="0x2c30"/>
                    <Item ID="0x2c31"/>
                    <Item ID="0x2c32"/>
                </Group>
                <Group name="Crystal Roof">
                    <Item ID="0x35BE"/>
                    <Item ID="0x35BF"/>
                    <Item ID="0x35C0"/>
                    <Item ID="0x35C1"/>
                    <Item ID="0x35C2"/>
                    <Item ID="0x35C3"/>
                    <Item ID="0x35C4"/>
                    <Item ID="0x35C5"/>
                    <Item ID="0x35C6"/>
                    <Item ID="0x35C7"/>
                    <Item ID="0x35C8"/>
                    <Item ID="0x35C9"/>
                    <Item ID="0x35CA"/>
                    <Item ID="0x35CB"/>
                    <Item ID="0x35CC"/>
                    <Item ID="0x35CD"/>
                    <Item ID="0x35CE"/>
                    <Item ID="0x35CF"/>
                    <Item ID="0x35D0"/>
                    <Item ID="0x35D1"/>
                </Group>
                <Group name="Flat">
                    <Group name="Blueish Stone">
                        <Item ID="0x063b"/>
                        <Item ID="0x063c"/>
                        <Item ID="0x063d"/>
                        <Item ID="0x063e"/>
                        <Item ID="0x0652"/>
                        <Item ID="0x0653"/>
                    </Group>
                    <Group name="Gray Stone">
                        <Item ID="0x0579"/>
                        <Item ID="0x057a"/>
                        <Item ID="0x057b"/>
                        <Item ID="0x057c"/>
                        <Item ID="0x057d"/>
                        <Item ID="0x057e"/>
                    </Group>
                    <Group name="Red Stone">
                        <Item ID="0x0554"/>
                        <Item ID="0x0555"/>
                        <Item ID="0x0556"/>
                        <Item ID="0x0557"/>
                        <Item ID="0x055C"/>
                        <Item ID="0x055d"/>
                        <Item ID="0x055e"/>
                        <Item ID="0x055f"/>
                        <Item ID="0x0560"/>
                        <Item ID="0x0561"/>
                        <Item ID="0x0562"/>
                        <Item ID="0x0563"/>
                        <Item ID="0x0564"/>
                        <Item ID="0x0565"/>
                        <Item ID="0x0566"/>
                        <Item ID="0x0567"/>
                        <Item ID="0x0568"/>
                        <Item ID="0x0569"/>
                        <Item ID="0x062f"/>
                        <Item ID="0x0630"/>
                        <Item ID="0x0631"/>
                        <Item ID="0x0631"/>
                        <Item ID="0x0632"/>
                        <Item ID="0x0632"/>
                        <Item ID="0x0656"/>
                        <Item ID="0x0657"/>
                    </Group>
                    <Group name="Slate">
                        <Item ID="0x057F"/>
                        <Item ID="0x0580"/>
                        <Item ID="0x0581"/>
                        <Item ID="0x0582"/>
                        <Item ID="0x0583"/>
                        <Item ID="0x0584"/>
                        <Item ID="0x0585"/>
                        <Item ID="0x0658"/>
                        <Item ID="0x0659"/>
                    </Group>
                    <Group name="White Stone">
                        <Item ID="0x0550"/>
                        <Item ID="0x0558"/>
                        <Item ID="0x0559"/>
                        <Item ID="0x055A"/>
                        <Item ID="0x055B"/>
                        <Item ID="0x055a"/>
                        <Item ID="0x055b"/>
                        <Item ID="0x056B"/>
                        <Item ID="0x056C"/>
                        <Item ID="0x056D"/>
                        <Item ID="0x056E"/>
                        <Item ID="0x056F"/>
                        <Item ID="0x0570"/>
                        <Item ID="0x0571"/>
                        <Item ID="0x0572"/>
                        <Item ID="0x0573"/>
                        <Item ID="0x0574"/>
                        <Item ID="0x0575"/>
                        <Item ID="0x0576"/>
                        <Item ID="0x0577"/>
                        <Item ID="0x05ef"/>
                        <Item ID="0x062D"/>
                        <Item ID="0x062E"/>
                        <Item ID="0x062b"/>
                        <Item ID="0x062c"/>
                        <Item ID="0x062d"/>
                        <Item ID="0x062e"/>
                        <Item ID="0x0637"/>
                        <Item ID="0x0638"/>
                        <Item ID="0x0639"/>
                        <Item ID="0x063a"/>
                        <Item ID="0x065a"/>
                        <Item ID="0x065b"/>
                        <Item ID="0x065c"/>
                        <Item ID="0x065d"/>
                    </Group>
                </Group>
                <Group name="Green Ceramic">
                    <Item ID="0x23EA"/>
                    <Item ID="0x23EB"/>
                    <Item ID="0x23EC"/>
                    <Item ID="0x23ED"/>
                    <Item ID="0x23EE"/>
                    <Item ID="0x23EF"/>
                    <Item ID="0x23F0"/>
                    <Item ID="0x23F1"/>
                    <Item ID="0x23F2"/>
                    <Item ID="0x23F3"/>
                    <Item ID="0x23F4"/>
                    <Item ID="0x23F5"/>
                    <Item ID="0x23F6"/>
                    <Item ID="0x23F7"/>
                    <Item ID="0x23F8"/>
                    <Item ID="0x23F9"/>
                    <Item ID="0x23FA"/>
                    <Item ID="0x23FB"/>
                    <Item ID="0x23FC"/>
                    <Item ID="0x23FD"/>
                    <Item ID="0x23FE"/>
                    <Item ID="0x23FF"/>
                </Group>
                <Group name="Orange Ceramic">
                    <Item ID="0x2920"/>
                    <Item ID="0x2921"/>
                    <Item ID="0x2922"/>
                    <Item ID="0x2923"/>
                    <Item ID="0x2924"/>
                    <Item ID="0x2925"/>
                    <Item ID="0x2926"/>
                    <Item ID="0x2927"/>
                    <Item ID="0x2928"/>
                    <Item ID="0x2929"/>
                    <Item ID="0x292A"/>
                    <Item ID="0x292B"/>
                    <Item ID="0x292C"/>
                    <Item ID="0x292D"/>
                    <Item ID="0x292E"/>
                    <Item ID="0x292F"/>
                    <Item ID="0x2930"/>
                    <Item ID="0x2931"/>
                    <Item ID="0x2932"/>
                    <Item ID="0x2933"/>
                    <Item ID="0x2934"/>
                    <Item ID="0x2935"/>
                </Group>
                <Group name="Red Ceramic">
                    <Item ID="0x23D4"/>
                    <Item ID="0x23D5"/>
                    <Item ID="0x23D6"/>
                    <Item ID="0x23D7"/>
                    <Item ID="0x23D8"/>
                    <Item ID="0x23D9"/>
                    <Item ID="0x23DA"/>
                    <Item ID="0x23DB"/>
                    <Item ID="0x23DC"/>
                    <Item ID="0x23DD"/>
                    <Item ID="0x23DE"/>
                    <Item ID="0x23DF"/>
                    <Item ID="0x23E0"/>
                    <Item ID="0x23E1"/>
                    <Item ID="0x23E2"/>
                    <Item ID="0x23E3"/>
                    <Item ID="0x23E4"/>
                    <Item ID="0x23E5"/>
                    <Item ID="0x23E6"/>
                    <Item ID="0x23E7"/>
                    <Item ID="0x23E8"/>
                    <Item ID="0x23E9"/>
                </Group>
                <Group name="Slate">
                    <Item ID="0x0595"/>
                    <Item ID="0x0596"/>
                    <Item ID="0x0597"/>
                    <Item ID="0x0598"/>
                    <Item ID="0x0599"/>
                    <Item ID="0x059A"/>
                    <Item ID="0x059B"/>
                    <Item ID="0x059C"/>
                    <Item ID="0x059D"/>
                    <Item ID="0x059E"/>
                    <Item ID="0x059F"/>
                    <Item ID="0x05A0"/>
                    <Item ID="0x05A1"/>
                    <Item ID="0x05A2"/>
                    <Item ID="0x05A3"/>
                    <Item ID="0x2178"/>
                    <Item ID="0x2179"/>
                    <Item ID="0x217a"/>
                    <Item ID="0x217b"/>
                    <Item ID="0x217c"/>
                    <Item ID="0x217d"/>
                    <Item ID="0x217e"/>
                    <Item ID="0x217f"/>
                    <Item ID="0x2c6f"/>
                    <Item ID="0x2c70"/>
                    <Item ID="0x2c71"/>
                    <Item ID="0x2c72"/>
                    <Item ID="0x2c73"/>
                    <Item ID="0x2c74"/>
                    <Item ID="0x2c75"/>
                    <Item ID="0x2c76"/>
                    <Item ID="0x2c77"/>
                    <Item ID="0x2c78"/>
                    <Item ID="0x2c79"/>
                    <Item ID="0x2c7a"/>
                    <Item ID="0x2c7b"/>
                    <Item ID="0x2c7c"/>
                    <Item ID="0x2c7d"/>
                </Group>
                <Group name="Stone Shingle">
                    <Item ID="0x28B0"/>
                    <Item ID="0x28B1"/>
                    <Item ID="0x28B2"/>
                    <Item ID="0x28B3"/>
                    <Item ID="0x28B4"/>
                    <Item ID="0x28B5"/>
                    <Item ID="0x28B6"/>
                    <Item ID="0x28B7"/>
                    <Item ID="0x28B8"/>
                    <Item ID="0x28B9"/>
                    <Item ID="0x28BA"/>
                    <Item ID="0x28BB"/>
                    <Item ID="0x28BC"/>
                    <Item ID="0x28BD"/>
                    <Item ID="0x28BE"/>
                    <Item ID="0x28BF"/>
                    <Item ID="0x28C0"/>
                    <Item ID="0x28C1"/>
                    <Item ID="0x28C2"/>
                    <Item ID="0x28C3"/>
                    <Item ID="0x28C4"/>
                    <Item ID="0x28C5"/>
                    <Item ID="0x28EB"/>
                    <Item ID="0x28EC"/>
                    <Item ID="0x28ED"/>
                    <Item ID="0x28EE"/>
                    <Item ID="0x2A2B"/>
                    <Item ID="0x2A2C"/>
                    <Item ID="0x2A2D"/>
                    <Item ID="0x2A2E"/>
                </Group>
                <Group name="Stone Tile">
                    <Item ID="0x1939"/>
                    <Item ID="0x193a"/>
                    <Item ID="0x193b"/>
                    <Item ID="0x193c"/>
                    <Item ID="0x193d"/>
                    <Item ID="0x193e"/>
                </Group>
                <Group name="White Ceramic">
                    <Item ID="0x2906"/>
                    <Item ID="0x2907"/>
                    <Item ID="0x2908"/>
                    <Item ID="0x2909"/>
                    <Item ID="0x290A"/>
                    <Item ID="0x290B"/>
                    <Item ID="0x290C"/>
                    <Item ID="0x290D"/>
                    <Item ID="0x290E"/>
                    <Item ID="0x290F"/>
                    <Item ID="0x2910"/>
                    <Item ID="0x2911"/>
                    <Item ID="0x2912"/>
                    <Item ID="0x2913"/>
                    <Item ID="0x2914"/>
                    <Item ID="0x2915"/>
                    <Item ID="0x2916"/>
                    <Item ID="0x2917"/>
                    <Item ID="0x2918"/>
                    <Item ID="0x2919"/>
                    <Item ID="0x291A"/>
                    <Item ID="0x291B"/>
                </Group>
                <Group name="Yellow Ceramic">
                    <Item ID="0x28F0"/>
                    <Item ID="0x28F1"/>
                    <Item ID="0x28F2"/>
                    <Item ID="0x28F3"/>
                    <Item ID="0x28F4"/>
                    <Item ID="0x28F5"/>
                    <Item ID="0x28F6"/>
                    <Item ID="0x28F7"/>
                    <Item ID="0x28F8"/>
                    <Item ID="0x28F9"/>
                    <Item ID="0x28FA"/>
                    <Item ID="0x28FB"/>
                    <Item ID="0x28FC"/>
                    <Item ID="0x28FD"/>
                    <Item ID="0x28FE"/>
                    <Item ID="0x28FF"/>
                    <Item ID="0x2900"/>
                    <Item ID="0x2901"/>
                    <Item ID="0x2902"/>
                    <Item ID="0x2903"/>
                    <Item ID="0x2904"/>
                    <Item ID="0x2905"/>
                </Group>
            </Group>
            <Group name="Wood">
                <Group name="Brown Log">
                    <Item ID="0x05F0"/>
                    <Item ID="0x05F1"/>
                    <Item ID="0x05F2"/>
                    <Item ID="0x05F3"/>
                    <Item ID="0x05F4"/>
                    <Item ID="0x05F5"/>
                    <Item ID="0x05F6"/>
                    <Item ID="0x05F7"/>
                    <Item ID="0x05F8"/>
                    <Item ID="0x05F9"/>
                    <Item ID="0x05FA"/>
                    <Item ID="0x05FB"/>
                    <Item ID="0x05FC"/>
                    <Item ID="0x05FD"/>
                    <Item ID="0x05FE"/>
                    <Item ID="0x2c42"/>
                    <Item ID="0x2c43"/>
                    <Item ID="0x2c44"/>
                    <Item ID="0x2c45"/>
                    <Item ID="0x2c46"/>
                    <Item ID="0x2c47"/>
                    <Item ID="0x2c48"/>
                    <Item ID="0x2c49"/>
                    <Item ID="0x2c4a"/>
                    <Item ID="0x2c4b"/>
                    <Item ID="0x2c4c"/>
                    <Item ID="0x2c4d"/>
                    <Item ID="0x2c4e"/>
                    <Item ID="0x2c4f"/>
                    <Item ID="0x2c50"/>
                </Group>
                <Group name="Diamond Shingles">
                    <Item ID="0x2B82"/>
                    <Item ID="0x2B83"/>
                    <Item ID="0x2B84"/>
                    <Item ID="0x2B85"/>
                    <Item ID="0x2B86"/>
                    <Item ID="0x2B87"/>
                    <Item ID="0x2B88"/>
                    <Item ID="0x2B89"/>
                    <Item ID="0x2B8A"/>
                    <Item ID="0x2B8B"/>
                    <Item ID="0x2B8C"/>
                    <Item ID="0x2B8D"/>
                    <Item ID="0x2B8E"/>
                    <Item ID="0x2B8F"/>
                    <Item ID="0x2B90"/>
                    <Item ID="0x2B91"/>
                    <Item ID="0x2B92"/>
                    <Item ID="0x2B93"/>
                    <Item ID="0x2F1F"/>
                    <Item ID="0x2F20"/>
                    <Item ID="0x2F21"/>
                    <Item ID="0x2F22"/>
                    <Item ID="0x2F23"/>
                    <Item ID="0x2b81"/>
                </Group>
                <Group name="Grey Log">
                    <Item ID="0x3623"/>
                    <Item ID="0x3624"/>
                    <Item ID="0x3625"/>
                    <Item ID="0x3626"/>
                    <Item ID="0x3627"/>
                    <Item ID="0x3628"/>
                    <Item ID="0x3629"/>
                    <Item ID="0x362A"/>
                    <Item ID="0x362B"/>
                    <Item ID="0x362C"/>
                    <Item ID="0x362D"/>
                    <Item ID="0x362E"/>
                    <Item ID="0x362F"/>
                    <Item ID="0x3630"/>
                    <Item ID="0x3631"/>
                    <Item ID="0x3632"/>
                    <Item ID="0x3633"/>
                    <Item ID="0x3634"/>
                    <Item ID="0x3635"/>
                </Group>
                <Group name="Wood Slat">
                    <Item ID="0x28C6"/>
                    <Item ID="0x28C7"/>
                    <Item ID="0x28C8"/>
                    <Item ID="0x28C9"/>
                    <Item ID="0x28CA"/>
                    <Item ID="0x28CB"/>
                    <Item ID="0x28CC"/>
                    <Item ID="0x28CD"/>
                    <Item ID="0x28CE"/>
                    <Item ID="0x28CF"/>
                    <Item ID="0x28D0"/>
                    <Item ID="0x28D1"/>
                    <Item ID="0x28D2"/>
                    <Item ID="0x28D3"/>
                    <Item ID="0x28D4"/>
                    <Item ID="0x28D5"/>
                    <Item ID="0x28D6"/>
                    <Item ID="0x28D7"/>
                    <Item ID="0x28D8"/>
                    <Item ID="0x28D9"/>
                    <Item ID="0x28DA"/>
                    <Item ID="0x28DB"/>
                    <Item ID="0x28E4"/>
                    <Item ID="0x28E5"/>
                    <Item ID="0x28E6"/>
                    <Item ID="0x28E7"/>
                    <Item ID="0x28E8"/>
                    <Item ID="0x28E9"/>
                    <Item ID="0x28EA"/>
                </Group>
                <Group name="Wooden Shingle">
                    <Item ID="0x05C2"/>
                    <Item ID="0x05C3"/>
                    <Item ID="0x05C4"/>
                    <Item ID="0x05C5"/>
                    <Item ID="0x05C6"/>
                    <Item ID="0x05C7"/>
                    <Item ID="0x05C8"/>
                    <Item ID="0x05C9"/>
                    <Item ID="0x05CA"/>
                    <Item ID="0x05CB"/>
                    <Item ID="0x05CC"/>
                    <Item ID="0x05CD"/>
                    <Item ID="0x05CE"/>
                    <Item ID="0x05CF"/>
                    <Item ID="0x05D0"/>
                    <Item ID="0x2170"/>
                    <Item ID="0x2171"/>
                    <Item ID="0x2172"/>
                    <Item ID="0x2173"/>
                    <Item ID="0x2174"/>
                    <Item ID="0x2175"/>
                    <Item ID="0x2176"/>
                    <Item ID="0x2177"/>
                    <Item ID="0x2c33"/>
                    <Item ID="0x2c34"/>
                    <Item ID="0x2c35"/>
                    <Item ID="0x2c36"/>
                    <Item ID="0x2c37"/>
                    <Item ID="0x2c38"/>
                    <Item ID="0x2c39"/>
                    <Item ID="0x2c3a"/>
                    <Item ID="0x2c3b"/>
                    <Item ID="0x2c3c"/>
                    <Item ID="0x2c3d"/>
                    <Item ID="0x2c3e"/>
                    <Item ID="0x2c3f"/>
                    <Item ID="0x2c40"/>
                    <Item ID="0x2c41"/>
                </Group>
            </Group>
        </Group>
        <Group name="Stairs + Rails">
            <Group name="Ladders etc.">
                <Group name="Ladder">
                    <Item ID="0x0899"/>
                    <Item ID="0x089A"/>
                    <Item ID="0x089B"/>
                    <Item ID="0x089C"/>
                    <Item ID="0x089D"/>
                    <Item ID="0x089E"/>
                    <Item ID="0x089F"/>
                    <Item ID="0x08A0"/>
                    <Item ID="0x08A1"/>
                    <Item ID="0x08A2"/>
                    <Item ID="0x08A3"/>
                    <Item ID="0x08A4"/>
                    <Item ID="0x08A5"/>
                    <Item ID="0x08A6"/>
                    <Item ID="0x2FDE"/>
                    <Item ID="0x2FDF"/>
                    <Item ID="0x3db2"/>
                    <Item ID="0x3db3"/>
                    <Item ID="0x3db4"/>
                    <Item ID="0x3db5"/>
                </Group>
            </Group>
            <Group name="Platform">
                <Item ID="0x07BD"/>
                <Item ID="0x07BE"/>
                <Item ID="0x07BF"/>
                <Item ID="0x07C0"/>
                <Item ID="0x07C1"/>
                <Item ID="0x07C2"/>
                <Item ID="0x07C3"/>
                <Item ID="0x07C4"/>
                <Item ID="0x07C5"/>
                <Item ID="0x07C6"/>
                <Item ID="0x07C9"/>
                <Item ID="0x07CA"/>
                <Item ID="0x07CB"/>
                <Item ID="0x07CC"/>
                <Item ID="0x07CD"/>
                <Item ID="0x07CE"/>
                <Item ID="0x07CF"/>
                <Item ID="0x07D0"/>
                <Item ID="0x0915"/>
                <Item ID="0x0916"/>
                <Item ID="0x0917"/>
                <Item ID="0x0918"/>
                <Item ID="0x3651"/>
                <Item ID="0x3652"/>
                <Item ID="0x3653"/>
                <Item ID="0x3654"/>
                <Item ID="0x3655"/>
                <Item ID="0x3656"/>
            </Group>
            <Group name="Rails + Banister">
                <Group name="Edging">
                    <Item ID="0x08CB"/>
                    <Item ID="0x08CC"/>
                    <Item ID="0x08CD"/>
                    <Item ID="0x08CE"/>
                </Group>
                <Group name="Stone Rail">
                    <Item ID="0x07D7"/>
                    <Item ID="0x07D8"/>
                    <Item ID="0x08EB"/>
                    <Item ID="0x08EC"/>
                    <Item ID="0x08ED"/>
                    <Item ID="0x08EE"/>
                    <Item ID="0x08EF"/>
                    <Item ID="0x08F0"/>
                    <Item ID="0x08F1"/>
                    <Item ID="0x08F2"/>
                    <Item ID="0x08F3"/>
                    <Item ID="0x08F4"/>
                    <Item ID="0x08F5"/>
                    <Item ID="0x08F6"/>
                    <Item ID="0x08F7"/>
                    <Item ID="0x08F8"/>
                    <Item ID="0x08F9"/>
                    <Item ID="0x08FA"/>
                    <Item ID="0x08FB"/>
                    <Item ID="0x08FC"/>
                    <Item ID="0x207d"/>
                </Group>
                <Group name="Suspension Bridge">
                    <Item ID="0x07E1"/>
                    <Item ID="0x07E2"/>
                    <Item ID="0x07E3"/>
                    <Item ID="0x07E4"/>
                    <Item ID="0x07E5"/>
                    <Item ID="0x07E6"/>
                    <Item ID="0x07E7"/>
                    <Item ID="0x07E8"/>
                    <Item ID="0x07E9"/>
                    <Item ID="0x07EA"/>
                    <Item ID="0x07EB"/>
                    <Item ID="0x07EC"/>
                    <Item ID="0x07ED"/>
                    <Item ID="0x07EE"/>
                    <Item ID="0x07EF"/>
                    <Item ID="0x07F0"/>
                    <Item ID="0x07F1"/>
                    <Item ID="0x07F2"/>
                    <Item ID="0x07F3"/>
                    <Item ID="0x07F4"/>
                    <Item ID="0x07F5"/>
                    <Item ID="0x07F6"/>
                    <Item ID="0x07F7"/>
                    <Item ID="0x07F8"/>
                    <Item ID="0x07F9"/>
                    <Item ID="0x07FA"/>
                    <Item ID="0x07FB"/>
                    <Item ID="0x07FC"/>
                    <Item ID="0x07FD"/>
                    <Item ID="0x07FE"/>
                    <Item ID="0x07FF"/>
                    <Item ID="0x0800"/>
                    <Item ID="0x0801"/>
                    <Item ID="0x0802"/>
                    <Item ID="0x0803"/>
                    <Item ID="0x0804"/>
                    <Item ID="0x0805"/>
                    <Item ID="0x0806"/>
                    <Item ID="0x0807"/>
                    <Item ID="0x0808"/>
                    <Item ID="0x0809"/>
                    <Item ID="0x080A"/>
                    <Item ID="0x080B"/>
                    <Item ID="0x080C"/>
                    <Item ID="0x080D"/>
                    <Item ID="0x080E"/>
                    <Item ID="0x080F"/>
                    <Item ID="0x0810"/>
                    <Item ID="0x0811"/>
                    <Item ID="0x0812"/>
                    <Item ID="0x0813"/>
                    <Item ID="0x0814"/>
                    <Item ID="0x0815"/>
                    <Item ID="0x0816"/>
                    <Item ID="0x0817"/>
                    <Item ID="0x0818"/>
                </Group>
                <Group name="Wood Rails">
                    <Item ID="0x087E"/>
                    <Item ID="0x087F"/>
                    <Item ID="0x0880"/>
                    <Item ID="0x0881"/>
                    <Item ID="0x0882"/>
                    <Item ID="0x0883"/>
                    <Item ID="0x0884"/>
                    <Item ID="0x0885"/>
                    <Item ID="0x0886"/>
                    <Item ID="0x0887"/>
                    <Item ID="0x0888"/>
                    <Item ID="0x0889"/>
                </Group>
                <Group name="Wooden Banister">
                    <Item ID="0x08AE"/>
                    <Item ID="0x08AF"/>
                    <Item ID="0x08B0"/>
                    <Item ID="0x08B1"/>
                    <Item ID="0x08B2"/>
                    <Item ID="0x08B3"/>
                    <Item ID="0x08B4"/>
                    <Item ID="0x08B5"/>
                    <Item ID="0x08B6"/>
                    <Item ID="0x08B7"/>
                    <Item ID="0x08B8"/>
                    <Item ID="0x08B9"/>
                    <Item ID="0x08BA"/>
                    <Item ID="0x08BB"/>
                    <Item ID="0x08BC"/>
                    <Item ID="0x08BD"/>
                    <Item ID="0x08BE"/>
                    <Item ID="0x08BF"/>
                    <Item ID="0x08C0"/>
                    <Item ID="0x08C1"/>
                    <Item ID="0x08C2"/>
                    <Item ID="0x08C3"/>
                    <Item ID="0x08C4"/>
                    <Item ID="0x08C5"/>
                    <Item ID="0x08C6"/>
                    <Item ID="0x08C7"/>
                    <Item ID="0x08C8"/>
                    <Item ID="0x08C9"/>
                    <Item ID="0x08CA"/>
                </Group>
            </Group>
            <Group name="Ramps">
                <Item ID="0x087A"/>
                <Item ID="0x087B"/>
                <Item ID="0x087C"/>
                <Item ID="0x087D"/>
                <Item ID="0x11BC"/>
                <Item ID="0x11BD"/>
                <Item ID="0x11BE"/>
                <Item ID="0x11BF"/>
            </Group>
            <Group name="Red Carpet">
                <Item ID="0x07BA"/>
                <Item ID="0x07BB"/>
                <Item ID="0x07BC"/>
                <Item ID="0x07C7"/>
                <Item ID="0x07C8"/>
            </Group>
            <Group name="Solid, Stone">
                <Group name="Coarse Brown Stone">
                    <Item ID="0x0784"/>
                    <Item ID="0x0785"/>
                    <Item ID="0x0786"/>
                    <Item ID="0x0787"/>
                    <Item ID="0x0788"/>
                    <Item ID="0x0788"/>
                    <Item ID="0x0789"/>
                    <Item ID="0x078A"/>
                    <Item ID="0x078B"/>
                    <Item ID="0x078C"/>
                    <Item ID="0x078D"/>
                    <Item ID="0x078E"/>
                    <Item ID="0x078F"/>
                    <Item ID="0x0790"/>
                    <Item ID="0x0791"/>
                    <Item ID="0x0792"/>
                    <Item ID="0x0793"/>
                    <Item ID="0x0794"/>
                    <Item ID="0x0795"/>
                    <Item ID="0x0796"/>
                    <Item ID="0x0797"/>
                    <Item ID="0x0798"/>
                    <Item ID="0x0799"/>
                    <Item ID="0x079A"/>
                    <Item ID="0x079B"/>
                    <Item ID="0x079C"/>
                </Group>
                <Group name="Coarse Gray Stone">
                    <Item ID="0x071E"/>
                    <Item ID="0x071E"/>
                    <Item ID="0x071F"/>
                    <Item ID="0x0736"/>
                    <Item ID="0x0737"/>
                    <Item ID="0x0749"/>
                    <Item ID="0x074A"/>
                    <Item ID="0x074B"/>
                    <Item ID="0x074C"/>
                    <Item ID="0x074D"/>
                    <Item ID="0x074E"/>
                    <Item ID="0x074F"/>
                    <Item ID="0x0782"/>
                    <Item ID="0x0783"/>
                    <Item ID="0x07A0"/>
                    <Item ID="0x07A1"/>
                    <Item ID="0x07A2"/>
                    <Item ID="0x07DA"/>
                    <Item ID="0x07DF"/>
                    <Item ID="0x07E0"/>
                    <Item ID="0x0834"/>
                    <Item ID="0x0876"/>
                    <Item ID="0x1ecb"/>
                </Group>
                <Group name="Coarse Sandstone">
                    <Item ID="0x03EE"/>
                    <Item ID="0x03EF"/>
                    <Item ID="0x03EF"/>
                    <Item ID="0x03F0"/>
                    <Item ID="0x03F1"/>
                    <Item ID="0x03F2"/>
                    <Item ID="0x03F3"/>
                    <Item ID="0x03F4"/>
                    <Item ID="0x03F5"/>
                    <Item ID="0x03F6"/>
                    <Item ID="0x03F7"/>
                    <Item ID="0x03F8"/>
                    <Item ID="0x03F9"/>
                    <Item ID="0x03FA"/>
                    <Item ID="0x03FB"/>
                    <Item ID="0x03FC"/>
                    <Item ID="0x03FD"/>
                    <Item ID="0x03FE"/>
                    <Item ID="0x03FF"/>
                    <Item ID="0x0400"/>
                    <Item ID="0x0401"/>
                    <Item ID="0x0402"/>
                </Group>
                <Group name="Crystal Stairs">
                    <Item ID="0x35D2"/>
                    <Item ID="0x35D3"/>
                    <Item ID="0x35D4"/>
                    <Item ID="0x35D5"/>
                    <Item ID="0x35D6"/>
                </Group>
                <Group name="Pink Marble">
                    <Item ID="0x0709"/>
                    <Item ID="0x0709"/>
                    <Item ID="0x070A"/>
                    <Item ID="0x070B"/>
                    <Item ID="0x070C"/>
                    <Item ID="0x070D"/>
                    <Item ID="0x070E"/>
                    <Item ID="0x070F"/>
                    <Item ID="0x0710"/>
                    <Item ID="0x0711"/>
                    <Item ID="0x0712"/>
                    <Item ID="0x0713"/>
                    <Item ID="0x0714"/>
                    <Item ID="0x0715"/>
                    <Item ID="0x0716"/>
                    <Item ID="0x0717"/>
                    <Item ID="0x0718"/>
                    <Item ID="0x0719"/>
                    <Item ID="0x071A"/>
                    <Item ID="0x071B"/>
                    <Item ID="0x071C"/>
                    <Item ID="0x071D"/>
                </Group>
                <Group name="Precise Gray Stone">
                    <Item ID="0x3609"/>
                    <Item ID="0x360A"/>
                    <Item ID="0x360B"/>
                    <Item ID="0x360C"/>
                    <Item ID="0x360D"/>
                </Group>
                <Group name="Precise Greenish Stone">
                    <Item ID="0x07A3"/>
                    <Item ID="0x07A4"/>
                    <Item ID="0x07A5"/>
                    <Item ID="0x07A6"/>
                    <Item ID="0x07A7"/>
                    <Item ID="0x07A8"/>
                    <Item ID="0x07A9"/>
                    <Item ID="0x07Aa"/>
                    <Item ID="0x07Ab"/>
                    <Item ID="0x07Ac"/>
                    <Item ID="0x07Ad"/>
                    <Item ID="0x07Ae"/>
                    <Item ID="0x07Af"/>
                    <Item ID="0x1eca"/>
                </Group>
                <Group name="Precise Light Gray Stone">
                    <Item ID="0x0750"/>
                    <Item ID="0x0750"/>
                    <Item ID="0x0751"/>
                    <Item ID="0x0752"/>
                    <Item ID="0x0753"/>
                    <Item ID="0x0754"/>
                    <Item ID="0x0755"/>
                    <Item ID="0x0756"/>
                    <Item ID="0x0757"/>
                    <Item ID="0x0758"/>
                    <Item ID="0x0759"/>
                    <Item ID="0x075A"/>
                    <Item ID="0x075B"/>
                    <Item ID="0x075C"/>
                    <Item ID="0x075D"/>
                    <Item ID="0x075E"/>
                    <Item ID="0x075F"/>
                    <Item ID="0x0760"/>
                    <Item ID="0x0761"/>
                    <Item ID="0x0762"/>
                    <Item ID="0x0763"/>
                    <Item ID="0x0764"/>
                    <Item ID="0x0765"/>
                    <Item ID="0x0766"/>
                    <Item ID="0x0767"/>
                    <Item ID="0x0768"/>
                </Group>
                <Group name="Precise Sandstone">
                    <Item ID="0x0769"/>
                    <Item ID="0x076A"/>
                    <Item ID="0x076B"/>
                    <Item ID="0x076C"/>
                    <Item ID="0x076C"/>
                    <Item ID="0x076D"/>
                    <Item ID="0x076E"/>
                    <Item ID="0x076F"/>
                    <Item ID="0x0770"/>
                    <Item ID="0x0771"/>
                    <Item ID="0x0772"/>
                    <Item ID="0x0773"/>
                    <Item ID="0x0774"/>
                    <Item ID="0x0775"/>
                    <Item ID="0x0776"/>
                    <Item ID="0x0777"/>
                    <Item ID="0x0778"/>
                    <Item ID="0x0779"/>
                    <Item ID="0x077A"/>
                    <Item ID="0x077B"/>
                    <Item ID="0x077C"/>
                    <Item ID="0x077D"/>
                    <Item ID="0x077E"/>
                    <Item ID="0x077F"/>
                    <Item ID="0x0780"/>
                    <Item ID="0x0781"/>
                    <Item ID="0x1ecc"/>
                </Group>
            </Group>
            <Group name="Solid, Wood">
                <Group name="Dark Wood">
                    <Item ID="0x0738"/>
                    <Item ID="0x0738"/>
                    <Item ID="0x0739"/>
                    <Item ID="0x073A"/>
                    <Item ID="0x073B"/>
                    <Item ID="0x073C"/>
                    <Item ID="0x073D"/>
                    <Item ID="0x073E"/>
                    <Item ID="0x073F"/>
                    <Item ID="0x0740"/>
                    <Item ID="0x0741"/>
                    <Item ID="0x0742"/>
                    <Item ID="0x0743"/>
                    <Item ID="0x0744"/>
                    <Item ID="0x0745"/>
                    <Item ID="0x0746"/>
                    <Item ID="0x0747"/>
                    <Item ID="0x0748"/>
                    <Item ID="0x07b3"/>
                    <Item ID="0x07b4"/>
                    <Item ID="0x07b5"/>
                    <Item ID="0x07b6"/>
                </Group>
                <Group name="Light Wood">
                    <Item ID="0x0720"/>
                    <Item ID="0x0720"/>
                    <Item ID="0x0721"/>
                    <Item ID="0x0722"/>
                    <Item ID="0x0723"/>
                    <Item ID="0x0724"/>
                    <Item ID="0x0725"/>
                    <Item ID="0x0726"/>
                    <Item ID="0x0727"/>
                    <Item ID="0x0728"/>
                    <Item ID="0x0729"/>
                    <Item ID="0x072A"/>
                    <Item ID="0x072B"/>
                    <Item ID="0x072C"/>
                    <Item ID="0x072D"/>
                    <Item ID="0x072E"/>
                    <Item ID="0x072F"/>
                    <Item ID="0x0730"/>
                    <Item ID="0x0731"/>
                    <Item ID="0x0732"/>
                    <Item ID="0x0733"/>
                    <Item ID="0x0734"/>
                    <Item ID="0x0735"/>
                </Group>
            </Group>
            <Group name="Stair Cabinet">
                <Item ID="0x24EC"/>
                <Item ID="0x24ED"/>
                <Item ID="0x24EE"/>
                <Item ID="0x24EF"/>
                <Item ID="0x24F0"/>
                <Item ID="0x24F1"/>
                <Item ID="0x24F2"/>
                <Item ID="0x24F3"/>
            </Group>
        </Group>
        <Group name="Walls">
            <Group name="Crystal + Marble">
                <Group name="Crystal Walls">
                    <Item ID="0x35D7"/>
                    <Item ID="0x35D8"/>
                    <Item ID="0x35D9"/>
                    <Item ID="0x35DA"/>
                    <Item ID="0x35DB"/>
                    <Item ID="0x35DC"/>
                    <Item ID="0x35DD"/>
                    <Item ID="0x35DE"/>
                    <Item ID="0x35DF"/>
                    <Item ID="0x35E0"/>
                    <Item ID="0x35E1"/>
                    <Item ID="0x35E2"/>
                    <Item ID="0x35E3"/>
                    <Item ID="0x35E4"/>
                    <Item ID="0x35E5"/>
                    <Item ID="0x35E6"/>
                    <Item ID="0x35E8"/>
                    <Item ID="0x35EA"/>
                    <Item ID="0x3670"/>
                    <Item ID="0x3671"/>
                    <Item ID="0x3672"/>
                    <Item ID="0x3673"/>
                </Group>
                <Group name="Light Blue Marble">
                    <Item ID="0x0291"/>
                    <Item ID="0x0292"/>
                    <Item ID="0x0293"/>
                    <Item ID="0x0294"/>
                    <Item ID="0x0295"/>
                    <Item ID="0x0296"/>
                    <Item ID="0x0297"/>
                    <Item ID="0x0298"/>
                    <Item ID="0x0299"/>
                    <Item ID="0x029A"/>
                    <Item ID="0x029B"/>
                    <Item ID="0x029C"/>
                    <Item ID="0x029D"/>
                    <Item ID="0x029E"/>
                    <Item ID="0x029F"/>
                    <Item ID="0x02A0"/>
                    <Item ID="0x02A1"/>
                    <Item ID="0x02A2"/>
                    <Item ID="0x02A3"/>
                    <Item ID="0x02A4"/>
                    <Item ID="0x02A7"/>
                    <Item ID="0x02A8"/>
                    <Item ID="0x02A9"/>
                    <Item ID="0x02AA"/>
                    <Item ID="0x02AB"/>
                    <Item ID="0x02AC"/>
                    <Item ID="0x02AD"/>
                    <Item ID="0x02AE"/>
                    <Item ID="0x02B5"/>
                    <Item ID="0x02B6"/>
                    <Item ID="0x02B7"/>
                    <Item ID="0x02B8"/>
                    <Item ID="0x02B9"/>
                    <Item ID="0x02BA"/>
                    <Item ID="0x02BB"/>
                    <Item ID="0x02BC"/>
                    <Item ID="0x02BD"/>
                    <Item ID="0x02BE"/>
                    <Item ID="0x02BF"/>
                    <Item ID="0x02C0"/>
                    <Item ID="0x253C"/>
                    <Item ID="0x253D"/>
                    <Item ID="0x253e"/>
                    <Item ID="0x26D0"/>
                    <Item ID="0x26D2"/>
                    <Item ID="0x26D4"/>
                    <Item ID="0x26D5"/>
                    <Item ID="0x26D6"/>
                    <Item ID="0x26D8"/>
                </Group>
                <Group name="White Marble">
                    <Item ID="0x00F8"/>
                    <Item ID="0x00F9"/>
                    <Item ID="0x00FA"/>
                    <Item ID="0x00FB"/>
                    <Item ID="0x00FC"/>
                    <Item ID="0x00FD"/>
                    <Item ID="0x00FE"/>
                    <Item ID="0x00FF"/>
                    <Item ID="0x0100"/>
                    <Item ID="0x0101"/>
                    <Item ID="0x0102"/>
                    <Item ID="0x0103"/>
                    <Item ID="0x0104"/>
                    <Item ID="0x0105"/>
                    <Item ID="0x0106"/>
                    <Item ID="0x0107"/>
                    <Item ID="0x0108"/>
                    <Item ID="0x0109"/>
                    <Item ID="0x010A"/>
                    <Item ID="0x010B"/>
                    <Item ID="0x010C"/>
                    <Item ID="0x010D"/>
                    <Item ID="0x010E"/>
                    <Item ID="0x010F"/>
                    <Item ID="0x0110"/>
                    <Item ID="0x0111"/>
                    <Item ID="0x0117"/>
                    <Item ID="0x0118"/>
                    <Item ID="0x0119"/>
                    <Item ID="0x011A"/>
                    <Item ID="0x011B"/>
                    <Item ID="0x011C"/>
                    <Item ID="0x011D"/>
                    <Item ID="0x011E"/>
                    <Item ID="0x011F"/>
                    <Item ID="0x0120"/>
                    <Item ID="0x0121"/>
                    <Item ID="0x0122"/>
                    <Item ID="0x0123"/>
                    <Item ID="0x0124"/>
                    <Item ID="0x239a"/>
                    <Item ID="0x239b"/>
                    <Item ID="0x250C"/>
                    <Item ID="0x250D"/>
                    <Item ID="0x250E"/>
                    <Item ID="0x250f"/>
                    <Item ID="0x2510"/>
                    <Item ID="0x2511"/>
                    <Item ID="0x2512"/>
                    <Item ID="0x2513"/>
                    <Item ID="0x2514"/>
                    <Item ID="0x2515"/>
                    <Item ID="0x2516"/>
                    <Item ID="0x2517"/>
                    <Item ID="0x2518"/>
                    <Item ID="0x2519"/>
                    <Item ID="0x251A"/>
                    <Item ID="0x251C"/>
                    <Item ID="0x251E"/>
                    <Item ID="0x251F"/>
                    <Item ID="0x251b"/>
                    <Item ID="0x251d"/>
                    <Item ID="0x2520"/>
                    <Item ID="0x2521"/>
                    <Item ID="0x2522"/>
                    <Item ID="0x2523"/>
                    <Item ID="0x2524"/>
                    <Item ID="0x2525"/>
                    <Item ID="0x2526"/>
                    <Item ID="0x2527"/>
                    <Item ID="0x2528"/>
                    <Item ID="0x2529"/>
                    <Item ID="0x252A"/>
                    <Item ID="0x252B"/>
                    <Item ID="0x252C"/>
                    <Item ID="0x252E"/>
                    <Item ID="0x252d"/>
                </Group>
            </Group>
            <Group name="Organic">
                <Group name="Blue Tent">
                    <Item ID="0x01F0"/>
                    <Item ID="0x01F1"/>
                    <Item ID="0x01F2"/>
                    <Item ID="0x01F3"/>
                    <Item ID="0x01F4"/>
                    <Item ID="0x01F5"/>
                    <Item ID="0x01F6"/>
                    <Item ID="0x01F7"/>
                    <Item ID="0x01F8"/>
                    <Item ID="0x01F9"/>
                </Group>
                <Group name="Cloth Frame">
                    <Item ID="0x2888"/>
                    <Item ID="0x2889"/>
                    <Item ID="0x288a"/>
                    <Item ID="0x288b"/>
                    <Item ID="0x288c"/>
                    <Item ID="0x288d"/>
                    <Item ID="0x288e"/>
                    <Item ID="0x288f"/>
                    <Item ID="0x2890"/>
                    <Item ID="0x2891"/>
                    <Item ID="0x2892"/>
                    <Item ID="0x2893"/>
                    <Item ID="0x2894"/>
                    <Item ID="0x2895"/>
                    <Item ID="0x2896"/>
                    <Item ID="0x2897"/>
                    <Item ID="0x2898"/>
                    <Item ID="0x2899"/>
                    <Item ID="0x289a"/>
                    <Item ID="0x289b"/>
                    <Item ID="0x289c"/>
                    <Item ID="0x289d"/>
                    <Item ID="0x289e"/>
                    <Item ID="0x289f"/>
                    <Item ID="0x28a0"/>
                    <Item ID="0x28a1"/>
                    <Item ID="0x28a2"/>
                    <Item ID="0x28a3"/>
                </Group>
                <Group name="Gray-Blue Tent">
                    <Item ID="0x02DE"/>
                    <Item ID="0x02DF"/>
                    <Item ID="0x02E0"/>
                    <Item ID="0x02E1"/>
                    <Item ID="0x02E2"/>
                    <Item ID="0x02E3"/>
                    <Item ID="0x02E4"/>
                    <Item ID="0x02E5"/>
                    <Item ID="0x02E6"/>
                    <Item ID="0x02E7"/>
                    <Item ID="0x02E8"/>
                    <Item ID="0x02E9"/>
                    <Item ID="0x02EA"/>
                    <Item ID="0x02EB"/>
                    <Item ID="0x02EC"/>
                    <Item ID="0x02Ef"/>
                    <Item ID="0x02f0"/>
                    <Item ID="0x02f1"/>
                    <Item ID="0x02f2"/>
                    <Item ID="0x02f3"/>
                    <Item ID="0x02f4"/>
                    <Item ID="0x0372"/>
                    <Item ID="0x0373"/>
                    <Item ID="0x0374"/>
                    <Item ID="0x0375"/>
                    <Item ID="0x0376"/>
                </Group>
                <Group name="Green Tent">
                    <Item ID="0x0230"/>
                    <Item ID="0x0231"/>
                    <Item ID="0x0232"/>
                    <Item ID="0x0233"/>
                    <Item ID="0x0234"/>
                    <Item ID="0x0235"/>
                    <Item ID="0x0236"/>
                    <Item ID="0x0237"/>
                    <Item ID="0x0238"/>
                    <Item ID="0x0239"/>
                    <Item ID="0x02Ef"/>
                    <Item ID="0x02f0"/>
                    <Item ID="0x02f1"/>
                    <Item ID="0x02f2"/>
                    <Item ID="0x02f3"/>
                    <Item ID="0x02f4"/>
                    <Item ID="0x0372"/>
                    <Item ID="0x0373"/>
                    <Item ID="0x0374"/>
                    <Item ID="0x0375"/>
                    <Item ID="0x0376"/>
                </Group>
                <Group name="Hide">
                    <Item ID="0x01B6"/>
                    <Item ID="0x01B7"/>
                    <Item ID="0x01B8"/>
                    <Item ID="0x01B9"/>
                    <Item ID="0x01BA"/>
                    <Item ID="0x01BB"/>
                    <Item ID="0x01BC"/>
                    <Item ID="0x01BD"/>
                    <Item ID="0x01BE"/>
                    <Item ID="0x01BF"/>
                    <Item ID="0x01C0"/>
                    <Item ID="0x01C1"/>
                    <Item ID="0x01C2"/>
                    <Item ID="0x01C3"/>
                    <Item ID="0x01C4"/>
                    <Item ID="0x01C5"/>
                    <Item ID="0x01C6"/>
                    <Item ID="0x01C7"/>
                    <Item ID="0x01C8"/>
                    <Item ID="0x01C9"/>
                    <Item ID="0x0432"/>
                    <Item ID="0x0433"/>
                    <Item ID="0x0434"/>
                    <Item ID="0x0435"/>
                    <Item ID="0x0435"/>
                </Group>
                <Group name="Light Gray Tent">
                    <Item ID="0x02Ef"/>
                    <Item ID="0x02f0"/>
                    <Item ID="0x02f1"/>
                    <Item ID="0x02f2"/>
                    <Item ID="0x02f3"/>
                    <Item ID="0x02f4"/>
                    <Item ID="0x0368"/>
                    <Item ID="0x0369"/>
                    <Item ID="0x036A"/>
                    <Item ID="0x036B"/>
                    <Item ID="0x036C"/>
                    <Item ID="0x036D"/>
                    <Item ID="0x036E"/>
                    <Item ID="0x036F"/>
                    <Item ID="0x0370"/>
                    <Item ID="0x0371"/>
                    <Item ID="0x0372"/>
                    <Item ID="0x0373"/>
                    <Item ID="0x0374"/>
                    <Item ID="0x0375"/>
                    <Item ID="0x0376"/>
                    <Item ID="0x0378"/>
                    <Item ID="0x0379"/>
                    <Item ID="0x037a"/>
                    <Item ID="0x037a"/>
                    <Item ID="0x037b"/>
                    <Item ID="0x037b"/>
                    <Item ID="0x037c"/>
                    <Item ID="0x037c"/>
                    <Item ID="0x037d"/>
                    <Item ID="0x037d"/>
                </Group>
                <Group name="Rattan">
                    <Item ID="0x019B"/>
                    <Item ID="0x019C"/>
                    <Item ID="0x019D"/>
                    <Item ID="0x019E"/>
                    <Item ID="0x019F"/>
                    <Item ID="0x01A0"/>
                    <Item ID="0x01A1"/>
                    <Item ID="0x01A2"/>
                    <Item ID="0x01A3"/>
                    <Item ID="0x01A5"/>
                    <Item ID="0x01A6"/>
                    <Item ID="0x01A7"/>
                    <Item ID="0x01A8"/>
                    <Item ID="0x01A9"/>
                    <Item ID="0x01AA"/>
                    <Item ID="0x01AB"/>
                    <Item ID="0x01AC"/>
                    <Item ID="0x01AD"/>
                    <Item ID="0x01AE"/>
                    <Item ID="0x01AF"/>
                    <Item ID="0x01B0"/>
                    <Item ID="0x215A"/>
                    <Item ID="0x215B"/>
                    <Item ID="0x215C"/>
                    <Item ID="0x215b"/>
                    <Item ID="0x215c"/>
                </Group>
                <Group name="Round Bamboo">
                    <Item ID="0x020F"/>
                    <Item ID="0x0210"/>
                    <Item ID="0x0211"/>
                    <Item ID="0x0212"/>
                    <Item ID="0x0213"/>
                    <Item ID="0x0214"/>
                    <Item ID="0x0215"/>
                    <Item ID="0x0216"/>
                    <Item ID="0x0217"/>
                    <Item ID="0x0218"/>
                    <Item ID="0x0219"/>
                    <Item ID="0x021A"/>
                </Group>
                <Group name="Tall Tree Wall">
                    <Item ID="0x3025"/>
                    <Item ID="0x3026"/>
                    <Item ID="0x3027"/>
                    <Item ID="0x3028"/>
                    <Item ID="0x3029"/>
                    <Item ID="0x302A"/>
                    <Item ID="0x302B"/>
                    <Item ID="0x302C"/>
                </Group>
                <Group name="Thorn">
                    <Item ID="0x2DFF"/>
                    <Item ID="0x2E00"/>
                    <Item ID="0x2E01"/>
                </Group>
                <Group name="Tree">
                    <Item ID="0x2f13"/>
                    <Item ID="0x2f14"/>
                    <Item ID="0x2f15"/>
                    <Item ID="0x2f16"/>
                    <Item ID="0x2f17"/>
                    <Item ID="0x2f18"/>
                    <Item ID="0x2f19"/>
                    <Item ID="0x2f1a"/>
                </Group>
            </Group>
            <Group name="Plaster + Clay">
                <Group name="Brown Clay">
                    <Item ID="0x2944"/>
                    <Item ID="0x2945"/>
                    <Item ID="0x2946"/>
                    <Item ID="0x2947"/>
                    <Item ID="0x2948"/>
                    <Item ID="0x2949"/>
                    <Item ID="0x294A"/>
                    <Item ID="0x294B"/>
                    <Item ID="0x294C"/>
                    <Item ID="0x294D"/>
                    <Item ID="0x294E"/>
                    <Item ID="0x294F"/>
                </Group>
                <Group name="Dark Half Timber">
                    <Item ID="0x29DC"/>
                    <Item ID="0x29DD"/>
                    <Item ID="0x29DE"/>
                    <Item ID="0x29DF"/>
                    <Item ID="0x29E0"/>
                    <Item ID="0x29E1"/>
                    <Item ID="0x29E2"/>
                    <Item ID="0x29E3"/>
                    <Item ID="0x29E4"/>
                    <Item ID="0x29E5"/>
                    <Item ID="0x29E6"/>
                    <Item ID="0x29E7"/>
                    <Item ID="0x29E8"/>
                    <Item ID="0x29E9"/>
                    <Item ID="0x29EA"/>
                    <Item ID="0x29EB"/>
                    <Item ID="0x29EC"/>
                    <Item ID="0x29ED"/>
                    <Item ID="0x29EE"/>
                    <Item ID="0x29EF"/>
                    <Item ID="0x29F0"/>
                    <Item ID="0x29F1"/>
                    <Item ID="0x29F2"/>
                    <Item ID="0x29F3"/>
                    <Item ID="0x29F4"/>
                    <Item ID="0x29F5"/>
                    <Item ID="0x29F6"/>
                    <Item ID="0x29F7"/>
                    <Item ID="0x29F8"/>
                    <Item ID="0x29F9"/>
                    <Item ID="0x29FA"/>
                    <Item ID="0x29FB"/>
                    <Item ID="0x29FC"/>
                </Group>
                <Group name="Light Brown Clay">
                    <Item ID="0x2950"/>
                    <Item ID="0x2951"/>
                    <Item ID="0x2952"/>
                    <Item ID="0x2953"/>
                    <Item ID="0x2954"/>
                    <Item ID="0x2955"/>
                    <Item ID="0x2956"/>
                    <Item ID="0x2957"/>
                    <Item ID="0x2958"/>
                    <Item ID="0x2959"/>
                    <Item ID="0x295A"/>
                    <Item ID="0x295B"/>
                </Group>
                <Group name="Light Half Timber">
                    <Item ID="0x0127"/>
                    <Item ID="0x0128"/>
                    <Item ID="0x0129"/>
                    <Item ID="0x012A"/>
                    <Item ID="0x012B"/>
                    <Item ID="0x012C"/>
                    <Item ID="0x012D"/>
                    <Item ID="0x012E"/>
                    <Item ID="0x012F"/>
                    <Item ID="0x0130"/>
                    <Item ID="0x0131"/>
                    <Item ID="0x0132"/>
                    <Item ID="0x0133"/>
                    <Item ID="0x0134"/>
                    <Item ID="0x0135"/>
                    <Item ID="0x0136"/>
                    <Item ID="0x0137"/>
                    <Item ID="0x0138"/>
                    <Item ID="0x0139"/>
                    <Item ID="0x013A"/>
                    <Item ID="0x013B"/>
                    <Item ID="0x013C"/>
                    <Item ID="0x013D"/>
                    <Item ID="0x013E"/>
                    <Item ID="0x013F"/>
                    <Item ID="0x0140"/>
                    <Item ID="0x0149"/>
                    <Item ID="0x014C"/>
                    <Item ID="0x014D"/>
                    <Item ID="0x014E"/>
                    <Item ID="0x014F"/>
                    <Item ID="0x0150"/>
                    <Item ID="0x0151"/>
                    <Item ID="0x0152"/>
                    <Item ID="0x0153"/>
                    <Item ID="0x0154"/>
                    <Item ID="0x0155"/>
                    <Item ID="0x0156"/>
                    <Item ID="0x0157"/>
                    <Item ID="0x037F"/>
                    <Item ID="0x0380"/>
                    <Item ID="0x0381"/>
                    <Item ID="0x0383"/>
                    <Item ID="0x0384"/>
                    <Item ID="0x0385"/>
                    <Item ID="0x0386"/>
                    <Item ID="0x0387"/>
                    <Item ID="0x0388"/>
                    <Item ID="0x0389"/>
                    <Item ID="0x038B"/>
                    <Item ID="0x038C"/>
                    <Item ID="0x038D"/>
                    <Item ID="0x038E"/>
                    <Item ID="0x038F"/>
                    <Item ID="0x0390"/>
                    <Item ID="0x0391"/>
                    <Item ID="0x0393"/>
                    <Item ID="0x0394"/>
                    <Item ID="0x0395"/>
                    <Item ID="0x0396"/>
                    <Item ID="0x0397"/>
                    <Item ID="0x0398"/>
                    <Item ID="0x0399"/>
                    <Item ID="0x039A"/>
                    <Item ID="0x039B"/>
                    <Item ID="0x039C"/>
                    <Item ID="0x039D"/>
                    <Item ID="0x039E"/>
                    <Item ID="0x039F"/>
                    <Item ID="0x03A0"/>
                </Group>
                <Group name="Partial Cover">
                    <Group name="ruined">
                        <Item ID="0x03B7"/>
                        <Item ID="0x03B8"/>
                        <Item ID="0x03B9"/>
                        <Item ID="0x03BF"/>
                        <Item ID="0x03Ba"/>
                        <Item ID="0x03Bb"/>
                        <Item ID="0x03Bc"/>
                        <Item ID="0x03Bd"/>
                        <Item ID="0x03C3"/>
                        <Item ID="0x03C4"/>
                        <Item ID="0x03C5"/>
                        <Item ID="0x03C6"/>
                    </Group>
                    <Item ID="0x01FF"/>
                    <Item ID="0x0200"/>
                    <Item ID="0x0201"/>
                    <Item ID="0x0203"/>
                    <Item ID="0x0204"/>
                    <Item ID="0x0205"/>
                    <Item ID="0x0206"/>
                    <Item ID="0x0209"/>
                    <Item ID="0x020A"/>
                    <Item ID="0x03C2"/>
                    <Item ID="0x03C7"/>
                    <Item ID="0x03C8"/>
                    <Item ID="0x03C9"/>
                    <Item ID="0x03CA"/>
                    <Item ID="0x03CB"/>
                    <Item ID="0x03CC"/>
                    <Item ID="0x03CD"/>
                    <Item ID="0x03CE"/>
                    <Item ID="0x03CF"/>
                    <Item ID="0x03D0"/>
                    <Item ID="0x03D1"/>
                    <Item ID="0x03D2"/>
                    <Item ID="0x03D3"/>
                    <Item ID="0x03D4"/>
                    <Item ID="0x03D5"/>
                    <Item ID="0x03D6"/>
                    <Item ID="0x03D8"/>
                    <Item ID="0x03DD"/>
                    <Item ID="0x03DE"/>
                    <Item ID="0x03DF"/>
                    <Item ID="0x03E0"/>
                    <Item ID="0x03E1"/>
                    <Item ID="0x252F"/>
                    <Item ID="0x2530"/>
                    <Item ID="0x2531"/>
                    <Item ID="0x2532"/>
                    <Item ID="0x2534"/>
                    <Item ID="0x2535"/>
                    <Item ID="0x2536"/>
                    <Item ID="0x2537"/>
                    <Item ID="0x2538"/>
                    <Item ID="0x2539"/>
                    <Item ID="0x253A"/>
                    <Item ID="0x253b"/>
                </Group>
                <Group name="Pink Clay">
                    <Item ID="0x2938"/>
                    <Item ID="0x2939"/>
                    <Item ID="0x293A"/>
                    <Item ID="0x293B"/>
                    <Item ID="0x293C"/>
                    <Item ID="0x293D"/>
                    <Item ID="0x293E"/>
                    <Item ID="0x293F"/>
                    <Item ID="0x2940"/>
                    <Item ID="0x2941"/>
                    <Item ID="0x2942"/>
                    <Item ID="0x2943"/>
                </Group>
                <Group name="Stone Trim">
                    <Item ID="0x2499"/>
                    <Item ID="0x249B"/>
                    <Item ID="0x249C"/>
                    <Item ID="0x249D"/>
                    <Item ID="0x249E"/>
                    <Item ID="0x249F"/>
                    <Item ID="0x249a"/>
                    <Item ID="0x249c"/>
                    <Item ID="0x24A0"/>
                    <Item ID="0x24A0"/>
                    <Item ID="0x24A1"/>
                    <Item ID="0x24A2"/>
                    <Item ID="0x24A3"/>
                    <Item ID="0x24A4"/>
                    <Item ID="0x24A5"/>
                    <Item ID="0x24A6"/>
                    <Item ID="0x24A7"/>
                    <Item ID="0x24A8"/>
                    <Item ID="0x24A9"/>
                    <Item ID="0x24AA"/>
                    <Item ID="0x24AB"/>
                    <Item ID="0x24AC"/>
                    <Item ID="0x2A30"/>
                    <Item ID="0x2A31"/>
                    <Item ID="0x2A32"/>
                    <Item ID="0x2A33"/>
                    <Item ID="0x2A33"/>
                    <Item ID="0x2A34"/>
                    <Item ID="0x2A34"/>
                    <Item ID="0x2A35"/>
                    <Item ID="0x2A35"/>
                    <Item ID="0x2A36"/>
                    <Item ID="0x2A36"/>
                    <Item ID="0x2A37"/>
                    <Item ID="0x2A37"/>
                    <Item ID="0x2A38"/>
                    <Item ID="0x2A38"/>
                    <Item ID="0x2A38"/>
                    <Item ID="0x2A39"/>
                    <Item ID="0x2A39"/>
                    <Item ID="0x2A3A"/>
                    <Item ID="0x2A3a"/>
                    <Item ID="0x2A3b"/>
                </Group>
            </Group>
            <Group name="Stone">
                <Group name="Bricks">
                    <Group name="Blueish Brick">
                        <Item ID="0x360E"/>
                        <Item ID="0x360F"/>
                        <Item ID="0x3610"/>
                        <Item ID="0x3611"/>
                        <Item ID="0x3612"/>
                        <Item ID="0x3613"/>
                        <Item ID="0x3614"/>
                        <Item ID="0x3615"/>
                        <Item ID="0x3616"/>
                        <Item ID="0x3617"/>
                        <Item ID="0x3618"/>
                        <Item ID="0x3619"/>
                        <Item ID="0x3636"/>
                        <Item ID="0x3637"/>
                        <Item ID="0x3638"/>
                        <Item ID="0x3639"/>
                        <Item ID="0x363A"/>
                        <Item ID="0x363B"/>
                        <Item ID="0x363C"/>
                        <Item ID="0x363D"/>
                        <Item ID="0x363E"/>
                        <Item ID="0x363F"/>
                        <Item ID="0x369F"/>
                    </Group>
                    <Group name="Brownish Brick">
                        <Item ID="0x0033"/>
                        <Item ID="0x0034"/>
                        <Item ID="0x0035"/>
                        <Item ID="0x0036"/>
                        <Item ID="0x0037"/>
                        <Item ID="0x0038"/>
                        <Item ID="0x0039"/>
                        <Item ID="0x003A"/>
                        <Item ID="0x003B"/>
                        <Item ID="0x003C"/>
                        <Item ID="0x003D"/>
                        <Item ID="0x003E"/>
                        <Item ID="0x003F"/>
                        <Item ID="0x0040"/>
                        <Item ID="0x0041"/>
                        <Item ID="0x0042"/>
                        <Item ID="0x0043"/>
                        <Item ID="0x0044"/>
                        <Item ID="0x0045"/>
                        <Item ID="0x0046"/>
                        <Item ID="0x0047"/>
                        <Item ID="0x0048"/>
                        <Item ID="0x0049"/>
                        <Item ID="0x0052"/>
                        <Item ID="0x0053"/>
                        <Item ID="0x0054"/>
                        <Item ID="0x29B6"/>
                        <Item ID="0x29B7"/>
                        <Item ID="0x29B8"/>
                        <Item ID="0x29B9"/>
                        <Item ID="0x29BA"/>
                        <Item ID="0x29BB"/>
                        <Item ID="0x29BC"/>
                        <Item ID="0x29BD"/>
                        <Item ID="0x29BE"/>
                        <Item ID="0x29BF"/>
                    </Group>
                    <Group name="Greenish Brick">
                        <Item ID="0x0241"/>
                        <Item ID="0x0242"/>
                        <Item ID="0x0243"/>
                        <Item ID="0x0244"/>
                        <Item ID="0x0245"/>
                        <Item ID="0x0246"/>
                        <Item ID="0x0247"/>
                        <Item ID="0x0248"/>
                        <Item ID="0x0249"/>
                        <Item ID="0x024A"/>
                        <Item ID="0x02F9"/>
                        <Item ID="0x02FA"/>
                        <Item ID="0x02FB"/>
                        <Item ID="0x02FC"/>
                        <Item ID="0x02FD"/>
                        <Item ID="0x02FE"/>
                        <Item ID="0x02FF"/>
                        <Item ID="0x0300"/>
                        <Item ID="0x21dd"/>
                        <Item ID="0x21de"/>
                        <Item ID="0x21df"/>
                        <Item ID="0x21e0"/>
                        <Item ID="0x21e1"/>
                        <Item ID="0x21e2"/>
                        <Item ID="0x21e3"/>
                        <Item ID="0x21e4"/>
                        <Item ID="0x21e5"/>
                        <Item ID="0x21e6"/>
                        <Item ID="0x21e7"/>
                        <Item ID="0x21e8"/>
                    </Group>
                    <Group name="Light Brick">
                        <Item ID="0x0057"/>
                        <Item ID="0x0058"/>
                        <Item ID="0x0059"/>
                        <Item ID="0x005A"/>
                        <Item ID="0x005B"/>
                        <Item ID="0x005C"/>
                        <Item ID="0x005D"/>
                        <Item ID="0x005E"/>
                        <Item ID="0x005F"/>
                        <Item ID="0x0060"/>
                        <Item ID="0x0061"/>
                        <Item ID="0x0062"/>
                        <Item ID="0x0063"/>
                        <Item ID="0x0064"/>
                        <Item ID="0x0065"/>
                        <Item ID="0x0066"/>
                        <Item ID="0x0069"/>
                        <Item ID="0x006A"/>
                        <Item ID="0x006B"/>
                        <Item ID="0x006C"/>
                        <Item ID="0x006D"/>
                        <Item ID="0x006E"/>
                        <Item ID="0x006F"/>
                        <Item ID="0x0070"/>
                        <Item ID="0x0071"/>
                        <Item ID="0x0277"/>
                        <Item ID="0x0278"/>
                        <Item ID="0x0279"/>
                        <Item ID="0x027a"/>
                        <Item ID="0x027b"/>
                        <Item ID="0x027c"/>
                        <Item ID="0x0281"/>
                        <Item ID="0x0282"/>
                        <Item ID="0x21fd"/>
                        <Item ID="0x21ff"/>
                        <Item ID="0x2200"/>
                        <Item ID="0x2201"/>
                        <Item ID="0x2202"/>
                        <Item ID="0x29A0"/>
                        <Item ID="0x29A1"/>
                        <Item ID="0x29A2"/>
                        <Item ID="0x29A3"/>
                    </Group>
                </Group>
                <Group name="Precise">
                    <Group name="Dark Gray Gothic">
                        <Item ID="0x300C"/>
                        <Item ID="0x300D"/>
                        <Item ID="0x300E"/>
                        <Item ID="0x300F"/>
                        <Item ID="0x310B"/>
                        <Item ID="0x310C"/>
                        <Item ID="0x310D"/>
                        <Item ID="0x310E"/>
                        <Item ID="0x310F"/>
                        <Item ID="0x3110"/>
                        <Item ID="0x3111"/>
                        <Item ID="0x3112"/>
                        <Item ID="0x3113"/>
                        <Item ID="0x3114"/>
                        <Item ID="0x3115"/>
                        <Item ID="0x3116"/>
                        <Item ID="0x3117"/>
                        <Item ID="0x3118"/>
                        <Item ID="0x3119"/>
                    </Group>
                    <Group name="Patterned Sandstone">
                        <Item ID="0x024C"/>
                        <Item ID="0x024D"/>
                        <Item ID="0x024E"/>
                        <Item ID="0x024F"/>
                        <Item ID="0x0250"/>
                        <Item ID="0x0251"/>
                        <Item ID="0x0252"/>
                        <Item ID="0x0253"/>
                        <Item ID="0x0254"/>
                        <Item ID="0x0255"/>
                        <Item ID="0x0256"/>
                        <Item ID="0x0257"/>
                        <Item ID="0x0258"/>
                        <Item ID="0x0259"/>
                        <Item ID="0x025A"/>
                        <Item ID="0x025B"/>
                    </Group>
                    <Group name="Precise Gray">
                        <Group name="Battlements">
                            <Item ID="0x02C7"/>
                            <Item ID="0x02C8"/>
                            <Item ID="0x02C9"/>
                            <Item ID="0x02CA"/>
                            <Item ID="0x02CB"/>
                            <Item ID="0x02CC"/>
                            <Item ID="0x02CD"/>
                        </Group>
                        <Item ID="0x007A"/>
                        <Item ID="0x007B"/>
                        <Item ID="0x007C"/>
                        <Item ID="0x007D"/>
                        <Item ID="0x007E"/>
                        <Item ID="0x007F"/>
                        <Item ID="0x0081"/>
                        <Item ID="0x0086"/>
                        <Item ID="0x0087"/>
                        <Item ID="0x0088"/>
                        <Item ID="0x0089"/>
                        <Item ID="0x008A"/>
                        <Item ID="0x008B"/>
                        <Item ID="0x008C"/>
                        <Item ID="0x008D"/>
                        <Item ID="0x008E"/>
                        <Item ID="0x008F"/>
                        <Item ID="0x02CE"/>
                        <Item ID="0x02CF"/>
                        <Item ID="0x02D0"/>
                        <Item ID="0x02D1"/>
                        <Item ID="0x02D3"/>
                        <Item ID="0x02D4"/>
                        <Item ID="0x02D7"/>
                        <Item ID="0x02D8"/>
                        <Item ID="0x0354"/>
                        <Item ID="0x035C"/>
                    </Group>
                    <Group name="Sandstone 1">
                        <Group name="Battlements">
                            <Item ID="0x0173"/>
                            <Item ID="0x0179"/>
                            <Item ID="0x017A"/>
                            <Item ID="0x017B"/>
                            <Item ID="0x017C"/>
                            <Item ID="0x017D"/>
                            <Item ID="0x01A4"/>
                        </Group>
                        <Item ID="0x0158"/>
                        <Item ID="0x0159"/>
                        <Item ID="0x015A"/>
                        <Item ID="0x015B"/>
                        <Item ID="0x015C"/>
                        <Item ID="0x015D"/>
                        <Item ID="0x015E"/>
                        <Item ID="0x015F"/>
                        <Item ID="0x0160"/>
                        <Item ID="0x0161"/>
                        <Item ID="0x0162"/>
                        <Item ID="0x0163"/>
                        <Item ID="0x0164"/>
                        <Item ID="0x0165"/>
                        <Item ID="0x0166"/>
                        <Item ID="0x0167"/>
                        <Item ID="0x0168"/>
                        <Item ID="0x0169"/>
                        <Item ID="0x016A"/>
                        <Item ID="0x016B"/>
                        <Item ID="0x016C"/>
                        <Item ID="0x016D"/>
                        <Item ID="0x016E"/>
                        <Item ID="0x016F"/>
                        <Item ID="0x0170"/>
                        <Item ID="0x0171"/>
                        <Item ID="0x0172"/>
                        <Item ID="0x0174"/>
                        <Item ID="0x017E"/>
                        <Item ID="0x017F"/>
                        <Item ID="0x0180"/>
                        <Item ID="0x0181"/>
                        <Item ID="0x0182"/>
                        <Item ID="0x0183"/>
                        <Item ID="0x0186"/>
                        <Item ID="0x0187"/>
                        <Item ID="0x0188"/>
                        <Item ID="0x0189"/>
                        <Item ID="0x018A"/>
                        <Item ID="0x018B"/>
                        <Item ID="0x018C"/>
                        <Item ID="0x018D"/>
                        <Item ID="0x0190"/>
                        <Item ID="0x0191"/>
                        <Item ID="0x0192"/>
                        <Item ID="0x0193"/>
                        <Item ID="0x0194"/>
                        <Item ID="0x0195"/>
                        <Item ID="0x0196"/>
                        <Item ID="0x0197"/>
                        <Item ID="0x0198"/>
                        <Item ID="0x0199"/>
                        <Item ID="0x019A"/>
                        <Item ID="0x01B1"/>
                        <Item ID="0x01B2"/>
                        <Item ID="0x01B3"/>
                        <Item ID="0x01B4"/>
                        <Item ID="0x01CA"/>
                        <Item ID="0x0202"/>
                        <Item ID="0x0769"/>
                        <Item ID="0x076A"/>
                        <Item ID="0x076B"/>
                        <Item ID="0x0781"/>
                    </Group>
                    <Group name="Tall Gray Gothic">
                        <Item ID="0x2FEC"/>
                        <Item ID="0x2FED"/>
                        <Item ID="0x2FFB"/>
                        <Item ID="0x2FFC"/>
                        <Item ID="0x2FFD"/>
                        <Item ID="0x2FFE"/>
                        <Item ID="0x2FFF"/>
                        <Item ID="0x2FFd"/>
                        <Item ID="0x2FFe"/>
                        <Item ID="0x3001"/>
                        <Item ID="0x3008"/>
                        <Item ID="0x3008"/>
                        <Item ID="0x3009"/>
                        <Item ID="0x300A"/>
                        <Item ID="0x300B"/>
                        <Item ID="0x300a"/>
                        <Item ID="0x300b"/>
                        <Item ID="0x300c"/>
                        <Item ID="0x300d"/>
                        <Item ID="0x300e"/>
                        <Item ID="0x300f"/>
                        <Item ID="0x3010"/>
                        <Item ID="0x3010"/>
                        <Item ID="0x3011"/>
                        <Item ID="0x3012"/>
                        <Item ID="0x3012"/>
                        <Item ID="0x3013"/>
                        <Item ID="0x3013"/>
                        <Item ID="0x3014"/>
                        <Item ID="0x3014"/>
                        <Item ID="0x3015"/>
                        <Item ID="0x3016"/>
                        <Item ID="0x3016"/>
                        <Item ID="0x3017"/>
                        <Item ID="0x3017"/>
                        <Item ID="0x311A"/>
                        <Item ID="0x311B"/>
                        <Item ID="0x311C"/>
                        <Item ID="0x311D"/>
                        <Item ID="0x311E"/>
                        <Item ID="0x311F"/>
                        <Item ID="0x3120"/>
                        <Item ID="0x3121"/>
                    </Group>
                </Group>
                <Group name="Rough + Worn">
                    <Group name="Black Block">
                        <Item ID="0x3674"/>
                        <Item ID="0x3675"/>
                        <Item ID="0x3676"/>
                        <Item ID="0x3677"/>
                    </Group>
                    <Group name="Brownish Blocks">
                        <Group name="Battlements">
                            <Item ID="0x01DA"/>
                            <Item ID="0x01E1"/>
                            <Item ID="0x01E2"/>
                            <Item ID="0x01E3"/>
                            <Item ID="0x01E4"/>
                            <Item ID="0x01E6"/>
                            <Item ID="0x01E7"/>
                        </Group>
                        <Item ID="0x01CF"/>
                        <Item ID="0x01D0"/>
                        <Item ID="0x01D1"/>
                        <Item ID="0x01D2"/>
                        <Item ID="0x01D3"/>
                        <Item ID="0x01D4"/>
                        <Item ID="0x01D5"/>
                        <Item ID="0x01D6"/>
                        <Item ID="0x01D7"/>
                        <Item ID="0x01D8"/>
                        <Item ID="0x01D9"/>
                        <Item ID="0x01DB"/>
                        <Item ID="0x01DC"/>
                        <Item ID="0x01DD"/>
                        <Item ID="0x01DE"/>
                        <Item ID="0x01DF"/>
                        <Item ID="0x01E8"/>
                        <Item ID="0x01E9"/>
                        <Item ID="0x01EA"/>
                        <Item ID="0x01EB"/>
                        <Item ID="0x29A4"/>
                        <Item ID="0x29A5"/>
                        <Item ID="0x29A6"/>
                        <Item ID="0x29A7"/>
                        <Item ID="0x29A8"/>
                        <Item ID="0x29A9"/>
                        <Item ID="0x29AA"/>
                        <Item ID="0x29AB"/>
                    </Group>
                    <Group name="Brownish Round">
                        <Item ID="0x253f"/>
                        <Item ID="0x2540"/>
                        <Item ID="0x2541"/>
                        <Item ID="0x2542"/>
                        <Item ID="0x2543"/>
                        <Item ID="0x2544"/>
                        <Item ID="0x2545"/>
                        <Item ID="0x2546"/>
                        <Item ID="0x2547"/>
                        <Item ID="0x2548"/>
                        <Item ID="0x2549"/>
                        <Item ID="0x254a"/>
                        <Item ID="0x254b"/>
                        <Item ID="0x254c"/>
                        <Item ID="0x254d"/>
                        <Item ID="0x254e"/>
                        <Item ID="0x254f"/>
                        <Item ID="0x2550"/>
                        <Item ID="0x2551"/>
                        <Item ID="0x2552"/>
                        <Item ID="0x2553"/>
                        <Item ID="0x3EF2"/>
                        <Item ID="0x3EF3"/>
                        <Item ID="0x3EF4"/>
                        <Item ID="0x3EF5"/>
                        <Item ID="0x3EF6"/>
                        <Item ID="0x3EF7"/>
                        <Item ID="0x3EF8"/>
                        <Item ID="0x3EF9"/>
                        <Item ID="0x3EFA"/>
                        <Item ID="0x3EFB"/>
                        <Item ID="0x3EFC"/>
                        <Item ID="0x3EFD"/>
                        <Item ID="0x3EFE"/>
                        <Item ID="0x3EFF"/>
                        <Item ID="0x3F00"/>
                        <Item ID="0x3F01"/>
                        <Item ID="0x3F02"/>
                        <Item ID="0x3F03"/>
                        <Item ID="0x3F04"/>
                        <Item ID="0x3F05"/>
                        <Item ID="0x3F06"/>
                        <Item ID="0x3ef2"/>
                        <Item ID="0x3ef3"/>
                        <Item ID="0x3ef4"/>
                        <Item ID="0x3ef5"/>
                        <Item ID="0x3ef6"/>
                        <Item ID="0x3ef7"/>
                        <Item ID="0x3ef8"/>
                        <Item ID="0x3ef9"/>
                        <Item ID="0x3efa"/>
                        <Item ID="0x3efb"/>
                        <Item ID="0x3efc"/>
                        <Item ID="0x3efd"/>
                        <Item ID="0x3efe"/>
                        <Item ID="0x3eff"/>
                        <Item ID="0x3f00"/>
                        <Item ID="0x3f01"/>
                        <Item ID="0x3f02"/>
                        <Item ID="0x3f03"/>
                        <Item ID="0x3f04"/>
                        <Item ID="0x3f05"/>
                        <Item ID="0x3f06"/>
                    </Group>
                    <Group name="Gray Block">
                        <Group name="Battlements">
                            <Item ID="0x00D2"/>
                            <Item ID="0x00D3"/>
                            <Item ID="0x00DB"/>
                            <Item ID="0x00E0"/>
                            <Item ID="0x00E1"/>
                            <Item ID="0x00E2"/>
                            <Item ID="0x00E3"/>
                        </Group>
                        <Item ID="0x00C5"/>
                        <Item ID="0x00C7"/>
                        <Item ID="0x00C8"/>
                        <Item ID="0x00C9"/>
                        <Item ID="0x00CA"/>
                        <Item ID="0x00CB"/>
                        <Item ID="0x00CC"/>
                        <Item ID="0x00CD"/>
                        <Item ID="0x00CE"/>
                        <Item ID="0x00CF"/>
                        <Item ID="0x00D0"/>
                        <Item ID="0x00D1"/>
                        <Item ID="0x00D4"/>
                        <Item ID="0x00D7"/>
                        <Item ID="0x00D8"/>
                        <Item ID="0x00D9"/>
                        <Item ID="0x00DA"/>
                        <Item ID="0x00DC"/>
                        <Item ID="0x00DD"/>
                        <Item ID="0x00DE"/>
                        <Item ID="0x00DF"/>
                    </Group>
                    <Group name="Light Boulder">
                        <Item ID="0x001A"/>
                        <Item ID="0x001B"/>
                        <Item ID="0x001C"/>
                        <Item ID="0x001D"/>
                        <Item ID="0x001E"/>
                        <Item ID="0x001F"/>
                        <Item ID="0x0020"/>
                        <Item ID="0x0021"/>
                        <Item ID="0x0022"/>
                        <Item ID="0x0023"/>
                        <Item ID="0x0024"/>
                        <Item ID="0x0025"/>
                        <Item ID="0x0026"/>
                        <Item ID="0x0027"/>
                        <Item ID="0x0028"/>
                        <Item ID="0x0029"/>
                        <Item ID="0x002A"/>
                        <Item ID="0x002B"/>
                        <Item ID="0x002C"/>
                        <Item ID="0x002D"/>
                        <Item ID="0x002E"/>
                        <Item ID="0x002F"/>
                        <Item ID="0x0030"/>
                        <Item ID="0x0031"/>
                        <Item ID="0x0032"/>
                        <Item ID="0x29AC"/>
                        <Item ID="0x29AD"/>
                        <Item ID="0x29AE"/>
                        <Item ID="0x29AF"/>
                        <Item ID="0x29B0"/>
                        <Item ID="0x29B1"/>
                        <Item ID="0x29B2"/>
                        <Item ID="0x29B3"/>
                        <Item ID="0x29B4"/>
                        <Item ID="0x29B5"/>
                        <Item ID="0x3127"/>
                    </Group>
                </Group>
            </Group>
            <Group name="Wood">
                <Group name="Black Board">
                    <Item ID="0x248D"/>
                    <Item ID="0x248E"/>
                    <Item ID="0x248F"/>
                    <Item ID="0x248b"/>
                    <Item ID="0x248c"/>
                    <Item ID="0x2490"/>
                    <Item ID="0x2491"/>
                    <Item ID="0x2492"/>
                    <Item ID="0x2493"/>
                    <Item ID="0x2494"/>
                    <Item ID="0x2495"/>
                    <Item ID="0x2496"/>
                    <Item ID="0x2497"/>
                    <Item ID="0x2498"/>
                </Group>
                <Group name="Brown Floral">
                    <Item ID="0x2D14"/>
                    <Item ID="0x2D15"/>
                    <Item ID="0x2D16"/>
                    <Item ID="0x2D17"/>
                    <Item ID="0x2D18"/>
                    <Item ID="0x2D19"/>
                    <Item ID="0x2D1A"/>
                    <Item ID="0x2D1B"/>
                    <Item ID="0x2D1C"/>
                    <Item ID="0x2D1D"/>
                    <Item ID="0x2D36"/>
                    <Item ID="0x2D37"/>
                    <Item ID="0x2D3C"/>
                    <Item ID="0x2D3D"/>
                    <Item ID="0x2D3E"/>
                    <Item ID="0x2D3F"/>
                    <Item ID="0x2D40"/>
                    <Item ID="0x2D41"/>
                    <Item ID="0x2D42"/>
                    <Item ID="0x2D43"/>
                    <Item ID="0x2D44"/>
                    <Item ID="0x2D45"/>
                    <Item ID="0x2DFB"/>
                    <Item ID="0x2DFC"/>
                    <Item ID="0x2DFD"/>
                    <Item ID="0x2DFE"/>
                    <Item ID="0x2F1E"/>
                </Group>
                <Group name="Cloth Frame">
                    <Item ID="0x2888"/>
                    <Item ID="0x2889"/>
                    <Item ID="0x288a"/>
                    <Item ID="0x288b"/>
                    <Item ID="0x288c"/>
                    <Item ID="0x288d"/>
                    <Item ID="0x288e"/>
                    <Item ID="0x288f"/>
                    <Item ID="0x2890"/>
                    <Item ID="0x2891"/>
                    <Item ID="0x2892"/>
                    <Item ID="0x2893"/>
                    <Item ID="0x2894"/>
                    <Item ID="0x2895"/>
                    <Item ID="0x2896"/>
                    <Item ID="0x2897"/>
                    <Item ID="0x2898"/>
                    <Item ID="0x2899"/>
                    <Item ID="0x289a"/>
                    <Item ID="0x289b"/>
                    <Item ID="0x289c"/>
                    <Item ID="0x289d"/>
                    <Item ID="0x289e"/>
                    <Item ID="0x289f"/>
                    <Item ID="0x28a0"/>
                    <Item ID="0x28a1"/>
                    <Item ID="0x28a2"/>
                    <Item ID="0x28a3"/>
                </Group>
                <Group name="Dark Board">
                    <Item ID="0x0006"/>
                    <Item ID="0x0007"/>
                    <Item ID="0x0008"/>
                    <Item ID="0x0009"/>
                    <Item ID="0x000A"/>
                    <Item ID="0x000B"/>
                    <Item ID="0x000C"/>
                    <Item ID="0x000D"/>
                    <Item ID="0x000E"/>
                    <Item ID="0x000F"/>
                    <Item ID="0x0010"/>
                    <Item ID="0x0011"/>
                    <Item ID="0x0012"/>
                    <Item ID="0x0013"/>
                    <Item ID="0x0014"/>
                    <Item ID="0x0015"/>
                    <Item ID="0x0016"/>
                    <Item ID="0x0017"/>
                </Group>
                <Group name="Dark Latticed">
                    <Item ID="0x2753"/>
                    <Item ID="0x2754"/>
                    <Item ID="0x2755"/>
                    <Item ID="0x275A"/>
                    <Item ID="0x275B"/>
                    <Item ID="0x275C"/>
                    <Item ID="0x275D"/>
                    <Item ID="0x275E"/>
                    <Item ID="0x275F"/>
                    <Item ID="0x2760"/>
                    <Item ID="0x2761"/>
                    <Item ID="0x2762"/>
                </Group>
                <Group name="Dark Panel">
                    <Item ID="0x2992"/>
                    <Item ID="0x2993"/>
                    <Item ID="0x2994"/>
                    <Item ID="0x2995"/>
                    <Item ID="0x2996"/>
                    <Item ID="0x2997"/>
                    <Item ID="0x2998"/>
                    <Item ID="0x2999"/>
                    <Item ID="0x299A"/>
                    <Item ID="0x299B"/>
                    <Item ID="0x299C"/>
                    <Item ID="0x299D"/>
                </Group>
                <Group name="Light Boards">
                    <Item ID="0x00A6"/>
                    <Item ID="0x00A7"/>
                    <Item ID="0x00A8"/>
                    <Item ID="0x00A9"/>
                    <Item ID="0x00AA"/>
                    <Item ID="0x00AB"/>
                    <Item ID="0x00AC"/>
                    <Item ID="0x00AD"/>
                    <Item ID="0x00AE"/>
                    <Item ID="0x00AF"/>
                    <Item ID="0x00B0"/>
                    <Item ID="0x00B1"/>
                    <Item ID="0x00B2"/>
                    <Item ID="0x00B3"/>
                    <Item ID="0x00B4"/>
                    <Item ID="0x00B5"/>
                    <Item ID="0x00B9"/>
                    <Item ID="0x00BA"/>
                    <Item ID="0x00BB"/>
                    <Item ID="0x00BC"/>
                    <Item ID="0x00BD"/>
                    <Item ID="0x00BE"/>
                    <Item ID="0x00BF"/>
                    <Item ID="0x00C0"/>
                    <Item ID="0x03B3"/>
                    <Item ID="0x03B4"/>
                    <Item ID="0x03B5"/>
                    <Item ID="0x03B6"/>
                    <Item ID="0x21cd"/>
                    <Item ID="0x21ce"/>
                    <Item ID="0x21cf"/>
                    <Item ID="0x21d0"/>
                    <Item ID="0x21d1"/>
                    <Item ID="0x21d2"/>
                    <Item ID="0x21d3"/>
                    <Item ID="0x21d4"/>
                    <Item ID="0x21d5"/>
                    <Item ID="0x21d6"/>
                    <Item ID="0x21d7"/>
                    <Item ID="0x21d8"/>
                    <Item ID="0x21d9"/>
                    <Item ID="0x21da"/>
                    <Item ID="0x21db"/>
                    <Item ID="0x21dc"/>
                    <Item ID="0x2500"/>
                    <Item ID="0x2501"/>
                    <Item ID="0x2502"/>
                    <Item ID="0x2503"/>
                    <Item ID="0x2504"/>
                    <Item ID="0x2505"/>
                    <Item ID="0x2506"/>
                    <Item ID="0x2507"/>
                    <Item ID="0x2508"/>
                    <Item ID="0x2509"/>
                    <Item ID="0x250A"/>
                    <Item ID="0x250b"/>
                </Group>
                <Group name="Light Latticed">
                    <Item ID="0x2713"/>
                    <Item ID="0x2714"/>
                    <Item ID="0x2715"/>
                    <Item ID="0x2716"/>
                    <Item ID="0x2717"/>
                    <Item ID="0x2718"/>
                    <Item ID="0x2719"/>
                    <Item ID="0x271A"/>
                    <Item ID="0x271B"/>
                    <Item ID="0x271C"/>
                    <Item ID="0x271D"/>
                    <Item ID="0x271E"/>
                    <Item ID="0x271F"/>
                    <Item ID="0x275A"/>
                    <Item ID="0x275B"/>
                    <Item ID="0x275C"/>
                </Group>
                <Group name="Light Panel">
                    <Item ID="0x247F"/>
                    <Item ID="0x2480"/>
                    <Item ID="0x2481"/>
                    <Item ID="0x2482"/>
                    <Item ID="0x2483"/>
                    <Item ID="0x2484"/>
                    <Item ID="0x2485"/>
                    <Item ID="0x2486"/>
                    <Item ID="0x2487"/>
                    <Item ID="0x2488"/>
                    <Item ID="0x2489"/>
                    <Item ID="0x248A"/>
                </Group>
                <Group name="Log">
                    <Item ID="0x0090"/>
                    <Item ID="0x0091"/>
                    <Item ID="0x0092"/>
                    <Item ID="0x0093"/>
                    <Item ID="0x0094"/>
                    <Item ID="0x0095"/>
                    <Item ID="0x0096"/>
                    <Item ID="0x0097"/>
                    <Item ID="0x0098"/>
                    <Item ID="0x0099"/>
                    <Item ID="0x009A"/>
                    <Item ID="0x009B"/>
                    <Item ID="0x009C"/>
                    <Item ID="0x009D"/>
                    <Item ID="0x009E"/>
                    <Item ID="0x009F"/>
                    <Item ID="0x00A0"/>
                    <Item ID="0x00A1"/>
                    <Item ID="0x00A2"/>
                    <Item ID="0x00A3"/>
                    <Item ID="0x00A4"/>
                    <Item ID="0x00A5"/>
                    <Item ID="0x0145"/>
                    <Item ID="0x0146"/>
                    <Item ID="0x0147"/>
                    <Item ID="0x0148"/>
                    <Item ID="0x21af"/>
                    <Item ID="0x21b0"/>
                    <Item ID="0x21b1"/>
                    <Item ID="0x21b2"/>
                    <Item ID="0x21b3"/>
                    <Item ID="0x21b4"/>
                    <Item ID="0x21b5"/>
                    <Item ID="0x21b6"/>
                    <Item ID="0x21b7"/>
                    <Item ID="0x21b8"/>
                    <Item ID="0x21bd"/>
                    <Item ID="0x21be"/>
                    <Item ID="0x21bf"/>
                    <Item ID="0x21c0"/>
                    <Item ID="0x21c1"/>
                    <Item ID="0x21c2"/>
                    <Item ID="0x21c3"/>
                    <Item ID="0x21c4"/>
                    <Item ID="0x21c5"/>
                    <Item ID="0x21c6"/>
                    <Item ID="0x21c7"/>
                    <Item ID="0x21c8"/>
                    <Item ID="0x21c9"/>
                    <Item ID="0x21ca"/>
                    <Item ID="0x21cb"/>
                    <Item ID="0x21cc"/>
                    <Item ID="0x24F4"/>
                    <Item ID="0x24F5"/>
                    <Item ID="0x24F6"/>
                    <Item ID="0x24F8"/>
                    <Item ID="0x24FA"/>
                    <Item ID="0x24FB"/>
                    <Item ID="0x24FC"/>
                    <Item ID="0x24FE"/>
                    <Item ID="0x24f7"/>
                    <Item ID="0x24f9"/>
                    <Item ID="0x24fd"/>
                    <Item ID="0x24ff"/>
                </Group>
                <Group name="Palisade">
                    <Item ID="0x021D"/>
                    <Item ID="0x021E"/>
                    <Item ID="0x021F"/>
                    <Item ID="0x0220"/>
                    <Item ID="0x0221"/>
                    <Item ID="0x0222"/>
                    <Item ID="0x0223"/>
                    <Item ID="0x0226"/>
                    <Item ID="0x0227"/>
                    <Item ID="0x0228"/>
                    <Item ID="0x0229"/>
                    <Item ID="0x022A"/>
                    <Item ID="0x022B"/>
                    <Item ID="0x0421"/>
                    <Item ID="0x0422"/>
                    <Item ID="0x0423"/>
                    <Item ID="0x0424"/>
                    <Item ID="0x0425"/>
                    <Item ID="0x0430"/>
                    <Item ID="0x0431"/>
                    <Item ID="0x2188"/>
                    <Item ID="0x2189"/>
                    <Item ID="0x218a"/>
                    <Item ID="0x218b"/>
                    <Item ID="0x218c"/>
                    <Item ID="0x218d"/>
                    <Item ID="0x218e"/>
                    <Item ID="0x218f"/>
                    <Item ID="0x2190"/>
                    <Item ID="0x2191"/>
                    <Item ID="0x2192"/>
                    <Item ID="0x2193"/>
                    <Item ID="0x2194"/>
                    <Item ID="0x2195"/>
                    <Item ID="0x2196"/>
                    <Item ID="0x2197"/>
                    <Item ID="0x21a5"/>
                    <Item ID="0x21a6"/>
                    <Item ID="0x21a7"/>
                    <Item ID="0x21a8"/>
                    <Item ID="0x21a9"/>
                    <Item ID="0x21aa"/>
                    <Item ID="0x21ab"/>
                    <Item ID="0x21ac"/>
                    <Item ID="0x21ad"/>
                    <Item ID="0x21ae"/>
                </Group>
                <Group name="Pink Floral">
                    <Item ID="0x2BA9"/>
                    <Item ID="0x2BAA"/>
                    <Item ID="0x2BAB"/>
                    <Item ID="0x2BAC"/>
                    <Item ID="0x2BAD"/>
                    <Item ID="0x2BAE"/>
                    <Item ID="0x2BAF"/>
                    <Item ID="0x2BB0"/>
                    <Item ID="0x2BB1"/>
                    <Item ID="0x2BB2"/>
                    <Item ID="0x2BB3"/>
                    <Item ID="0x2BB4"/>
                    <Item ID="0x2BB9"/>
                    <Item ID="0x2BBA"/>
                    <Item ID="0x2BBB"/>
                    <Item ID="0x2BBC"/>
                    <Item ID="0x2BBD"/>
                    <Item ID="0x2BBE"/>
                    <Item ID="0x2BBF"/>
                    <Item ID="0x2BC0"/>
                    <Item ID="0x2BC1"/>
                    <Item ID="0x2BC2"/>
                    <Item ID="0x2F1C"/>
                </Group>
                <Group name="Reddish Floral">
                    <Item ID="0x2BC3"/>
                    <Item ID="0x2BC4"/>
                    <Item ID="0x2BC5"/>
                    <Item ID="0x2BC6"/>
                    <Item ID="0x2BC7"/>
                    <Item ID="0x2BC8"/>
                    <Item ID="0x2BC9"/>
                    <Item ID="0x2BCA"/>
                    <Item ID="0x2BCB"/>
                    <Item ID="0x2BCC"/>
                    <Item ID="0x2CEF"/>
                    <Item ID="0x2CF0"/>
                    <Item ID="0x2CF1"/>
                    <Item ID="0x2CF2"/>
                    <Item ID="0x2CF3"/>
                    <Item ID="0x2CF4"/>
                    <Item ID="0x2CF5"/>
                    <Item ID="0x2CF6"/>
                    <Item ID="0x2CF7"/>
                    <Item ID="0x2CF8"/>
                    <Item ID="0x2F1D"/>
                </Group>
                <Group name="Yellow Board">
                    <Item ID="0x285f"/>
                    <Item ID="0x2860"/>
                    <Item ID="0x2861"/>
                    <Item ID="0x2862"/>
                    <Item ID="0x2863"/>
                    <Item ID="0x2864"/>
                    <Item ID="0x2865"/>
                    <Item ID="0x2866"/>
                    <Item ID="0x2867"/>
                    <Item ID="0x2868"/>
                    <Item ID="0x2869"/>
                    <Item ID="0x286a"/>
                    <Item ID="0x286b"/>
                    <Item ID="0x286c"/>
                    <Item ID="0x286d"/>
                </Group>
                <Group name="Yellow Floral">
                    <Item ID="0x2B7A"/>
                    <Item ID="0x2B7B"/>
                    <Item ID="0x2B7C"/>
                    <Item ID="0x2B7D"/>
                    <Item ID="0x2B7E"/>
                    <Item ID="0x2B7F"/>
                    <Item ID="0x2B80"/>
                    <Item ID="0x2DBF"/>
                    <Item ID="0x2DC0"/>
                    <Item ID="0x2DC1"/>
                    <Item ID="0x2DC2"/>
                    <Item ID="0x2DC3"/>
                    <Item ID="0x2DC4"/>
                    <Item ID="0x2DC5"/>
                    <Item ID="0x2DC6"/>
                    <Item ID="0x2DC7"/>
                    <Item ID="0x2DC8"/>
                    <Item ID="0x2DC9"/>
                    <Item ID="0x2DCA"/>
                    <Item ID="0x2DCF"/>
                    <Item ID="0x2DD0"/>
                    <Item ID="0x2DD1"/>
                    <Item ID="0x2DF7"/>
                    <Item ID="0x2DF8"/>
                    <Item ID="0x2DF9"/>
                    <Item ID="0x2DFA"/>
                    <Item ID="0x2F1B"/>
                </Group>
            </Group>
        </Group>
    </Group>
    <Group name="Creepy and Barbarism">
        <Group name="Barbaric">
            <Item ID="0x041F"/>
            <Item ID="0x0420"/>
            <Item ID="0x0426"/>
            <Item ID="0x0427"/>
            <Item ID="0x0428"/>
            <Item ID="0x0429"/>
            <Item ID="0x042A"/>
            <Item ID="0x042B"/>
            <Item ID="0x042C"/>
            <Item ID="0x042D"/>
            <Item ID="0x042E"/>
            <Item ID="0x042F"/>
            <Item ID="0x1096"/>
            <Item ID="0x2F59"/>
            <Item ID="0x2F5A"/>
            <Item ID="0x2F5B"/>
            <Item ID="0x2F5C"/>
            <Item ID="0x364C"/>
            <Item ID="0x364D"/>
            <Item ID="0x3650"/>
            <Item ID="0x365C"/>
            <Item ID="0x365D"/>
            <Item ID="0x365E"/>
            <Item ID="0x365F"/>
            <Item ID="0x3679"/>
            <Item ID="0x369c"/>
        </Group>
        <Group name="Blood">
            <Item ID="0x122A"/>
            <Item ID="0x122B"/>
            <Item ID="0x122C"/>
            <Item ID="0x122D"/>
            <Item ID="0x122E"/>
            <Item ID="0x122F"/>
            <Item ID="0x1645"/>
            <Item ID="0x1CC7"/>
            <Item ID="0x1CC8"/>
            <Item ID="0x1CC9"/>
            <Item ID="0x1CCA"/>
            <Item ID="0x1CCB"/>
            <Item ID="0x1CCC"/>
            <Item ID="0x1CCC"/>
            <Item ID="0x1CCE"/>
            <Item ID="0x1CCF"/>
            <Item ID="0x1CD0"/>
            <Item ID="0x1CD1"/>
            <Item ID="0x1CD2"/>
            <Item ID="0x1CD3"/>
            <Item ID="0x1CD4"/>
            <Item ID="0x1CD5"/>
            <Item ID="0x1CD6"/>
            <Item ID="0x1CD7"/>
            <Item ID="0x1CD8"/>
            <Item ID="0x1CD9"/>
            <Item ID="0x1CF1"/>
            <Item ID="0x1CF2"/>
            <Item ID="0x1CF3"/>
            <Item ID="0x1CF4"/>
            <Item ID="0x1CF5"/>
            <Item ID="0x1CF6"/>
            <Item ID="0x1CF7"/>
            <Item ID="0x1CF8"/>
            <Item ID="0x1CF9"/>
            <Item ID="0x1CFA"/>
            <Item ID="0x1CFB"/>
            <Item ID="0x1CFC"/>
            <Item ID="0x1CFD"/>
            <Item ID="0x1CFE"/>
            <Item ID="0x1CFF"/>
            <Item ID="0x1D00"/>
            <Item ID="0x1D01"/>
            <Item ID="0x1D02"/>
            <Item ID="0x1D03"/>
            <Item ID="0x1D04"/>
            <Item ID="0x1D05"/>
            <Item ID="0x1D06"/>
            <Item ID="0x1D07"/>
            <Item ID="0x1D08"/>
            <Item ID="0x1D09"/>
            <Item ID="0x1D0A"/>
            <Item ID="0x1D0B"/>
            <Item ID="0x1D0C"/>
            <Item ID="0x1D0D"/>
            <Item ID="0x1D0E"/>
            <Item ID="0x1D0F"/>
            <Item ID="0x1D10"/>
            <Item ID="0x1D11"/>
            <Item ID="0x1D12"/>
            <Item ID="0x1D92"/>
            <Item ID="0x1D93"/>
            <Item ID="0x1D94"/>
            <Item ID="0x1D95"/>
            <Item ID="0x1D96"/>
        </Group>
        <Group name="Body Parts">
            <Item ID="0x1CDD"/>
            <Item ID="0x1CDE"/>
            <Item ID="0x1CDF"/>
            <Item ID="0x1CE0"/>
            <Item ID="0x1CE1"/>
            <Item ID="0x1CE2"/>
            <Item ID="0x1CE3"/>
            <Item ID="0x1CE4"/>
            <Item ID="0x1CE5"/>
            <Item ID="0x1CE6"/>
            <Item ID="0x1CE7"/>
            <Item ID="0x1CE8"/>
            <Item ID="0x1CE9"/>
            <Item ID="0x1CEA"/>
            <Item ID="0x1CEB"/>
            <Item ID="0x1CEC"/>
            <Item ID="0x1CED"/>
            <Item ID="0x1CEE"/>
            <Item ID="0x1CEF"/>
            <Item ID="0x1CF0"/>
            <Item ID="0x1D9F"/>
            <Item ID="0x1DA0"/>
            <Item ID="0x1DA1"/>
            <Item ID="0x1DA2"/>
            <Item ID="0x1DA3"/>
            <Item ID="0x1DA4"/>
            <Item ID="0x1DAD"/>
            <Item ID="0x1DAE"/>
            <Item ID="0x1DAF"/>
            <Item ID="0x1DB0"/>
            <Item ID="0x1DB1"/>
            <Item ID="0x1DB2"/>
        </Group>
        <Group name="Bone Roof">
            <Item ID="0x3623"/>
            <Item ID="0x3624"/>
            <Item ID="0x3625"/>
            <Item ID="0x3626"/>
        </Group>
        <Group name="Bones">
            <Item ID="0x0ECA"/>
            <Item ID="0x0ECB"/>
            <Item ID="0x0ECC"/>
            <Item ID="0x0ECD"/>
            <Item ID="0x0ECE"/>
            <Item ID="0x0ECF"/>
            <Item ID="0x0ED0"/>
            <Item ID="0x0ED1"/>
            <Item ID="0x0ED2"/>
            <Item ID="0x1B09"/>
            <Item ID="0x1B0A"/>
            <Item ID="0x1B0B"/>
            <Item ID="0x1B0C"/>
            <Item ID="0x1B0D"/>
            <Item ID="0x1B0E"/>
            <Item ID="0x1B0F"/>
            <Item ID="0x1B10"/>
            <Item ID="0x1B11"/>
            <Item ID="0x1B12"/>
            <Item ID="0x1B13"/>
            <Item ID="0x1B14"/>
            <Item ID="0x1B15"/>
            <Item ID="0x1B16"/>
            <Item ID="0x1B17"/>
            <Item ID="0x1B18"/>
            <Item ID="0x1B19"/>
            <Item ID="0x1B1A"/>
            <Item ID="0x1B1B"/>
            <Item ID="0x1B1C"/>
        </Group>
        <Group name="Coffins etc.">
            <Item ID="0x1C22"/>
            <Item ID="0x1C23"/>
            <Item ID="0x1C24"/>
            <Item ID="0x1C25"/>
            <Item ID="0x1C26"/>
            <Item ID="0x1C27"/>
            <Item ID="0x1C28"/>
            <Item ID="0x1C29"/>
            <Item ID="0x1C2A"/>
            <Item ID="0x1C2B"/>
            <Item ID="0x1C2C"/>
            <Item ID="0x1C2D"/>
            <Item ID="0x1C2E"/>
            <Item ID="0x1C2F"/>
            <Item ID="0x1C30"/>
            <Item ID="0x1C31"/>
            <Item ID="0x1C32"/>
            <Item ID="0x1C33"/>
            <Item ID="0x1C34"/>
            <Item ID="0x1C35"/>
            <Item ID="0x1C36"/>
            <Item ID="0x1C37"/>
            <Item ID="0x1C38"/>
            <Item ID="0x1C39"/>
            <Item ID="0x1C3B"/>
            <Item ID="0x1C3C"/>
            <Item ID="0x1C3D"/>
            <Item ID="0x1C3E"/>
            <Item ID="0x1C3F"/>
            <Item ID="0x1C40"/>
            <Item ID="0x1C41"/>
            <Item ID="0x1C42"/>
            <Item ID="0x1C43"/>
            <Item ID="0x1C44"/>
            <Item ID="0x1C45"/>
            <Item ID="0x1C46"/>
            <Item ID="0x1C47"/>
            <Item ID="0x1C48"/>
            <Item ID="0x1C49"/>
            <Item ID="0x1C4A"/>
            <Item ID="0x1C4B"/>
            <Item ID="0x1C4C"/>
            <Item ID="0x1C4D"/>
            <Item ID="0x1C4F"/>
            <Item ID="0x1C50"/>
            <Item ID="0x1C51"/>
            <Item ID="0x1C52"/>
            <Item ID="0x1C53"/>
            <Item ID="0x1C54"/>
            <Item ID="0x1C55"/>
            <Item ID="0x1C56"/>
            <Item ID="0x1C57"/>
            <Item ID="0x1C58"/>
            <Item ID="0x1C59"/>
            <Item ID="0x1C5A"/>
            <Item ID="0x1C5B"/>
            <Item ID="0x1C5C"/>
            <Item ID="0x1C5D"/>
            <Item ID="0x1C5E"/>
            <Item ID="0x1C5F"/>
            <Item ID="0x1D34"/>
            <Item ID="0x1D73"/>
        </Group>
        <Group name="Corpses">
            <Item ID="0x3d64"/>
            <Item ID="0x3d65"/>
            <Item ID="0x3d66"/>
            <Item ID="0x3d67"/>
            <Item ID="0x3d68"/>
        </Group>
        <Group name="Evil Decor">
            <Item ID="0x2A58"/>
            <Item ID="0x2A59"/>
            <Item ID="0x2A5A"/>
            <Item ID="0x2A5B"/>
            <Item ID="0x2A5C"/>
            <Item ID="0x2A7F"/>
            <Item ID="0x2A80"/>
            <Item ID="0x2A81"/>
            <Item ID="0x2A82"/>
            <Item ID="0x2A83"/>
            <Item ID="0x2A84"/>
            <Item ID="0x2A85"/>
            <Item ID="0x2A86"/>
            <Item ID="0x2A87"/>
            <Item ID="0x2A88"/>
            <Item ID="0x2A89"/>
            <Item ID="0x2A8A"/>
            <Item ID="0x2A8B"/>
            <Item ID="0x2A8C"/>
            <Item ID="0x2A8D"/>
            <Item ID="0x2A8E"/>
            <Item ID="0x2A8F"/>
            <Item ID="0x2A90"/>
            <Item ID="0x2A91"/>
            <Item ID="0x2A92"/>
            <Item ID="0x2A98"/>
            <Item ID="0x2A99"/>
        </Group>
        <Group name="Grave">
            <Item ID="0x0ED3"/>
            <Item ID="0x0ED4"/>
            <Item ID="0x0ED5"/>
            <Item ID="0x0ED6"/>
            <Item ID="0x0ED7"/>
            <Item ID="0x0ED8"/>
            <Item ID="0x0ED9"/>
            <Item ID="0x0EDA"/>
            <Item ID="0x0EDB"/>
            <Item ID="0x0EDC"/>
            <Item ID="0x0EDD"/>
            <Item ID="0x0EDE"/>
            <Item ID="0x0EE0"/>
            <Item ID="0x0EE1"/>
            <Item ID="0x0EE2"/>
            <Item ID="0x1165"/>
            <Item ID="0x1166"/>
            <Item ID="0x1167"/>
            <Item ID="0x1168"/>
            <Item ID="0x1169"/>
            <Item ID="0x116A"/>
            <Item ID="0x116B"/>
            <Item ID="0x116C"/>
            <Item ID="0x116D"/>
            <Item ID="0x116E"/>
            <Item ID="0x116F"/>
            <Item ID="0x1170"/>
            <Item ID="0x1171"/>
            <Item ID="0x1172"/>
            <Item ID="0x1173"/>
            <Item ID="0x1174"/>
            <Item ID="0x1175"/>
            <Item ID="0x1176"/>
            <Item ID="0x1177"/>
            <Item ID="0x1178"/>
            <Item ID="0x1179"/>
            <Item ID="0x117A"/>
            <Item ID="0x117B"/>
            <Item ID="0x117C"/>
            <Item ID="0x117D"/>
            <Item ID="0x117E"/>
            <Item ID="0x117F"/>
            <Item ID="0x1180"/>
            <Item ID="0x1181"/>
            <Item ID="0x1182"/>
            <Item ID="0x1183"/>
            <Item ID="0x1184"/>
            <Item ID="0x1185"/>
            <Item ID="0x1186"/>
            <Item ID="0x1187"/>
            <Item ID="0x1188"/>
            <Item ID="0x1189"/>
        </Group>
        <Group name="Mummy N">
            <Item ID="0x1C38"/>
            <Item ID="0x1C3B"/>
            <Item ID="0x1C4A"/>
            <Item ID="0x1C4B"/>
            <Item ID="0x1C4C"/>
            <Item ID="0x1C9E"/>
            <Item ID="0x1C9F"/>
            <Item ID="0x1CA5"/>
            <Item ID="0x1CA6"/>
            <Item ID="0x1CB5"/>
            <Item ID="0x1CB6"/>
            <Item ID="0x1CB7"/>
            <Item ID="0x1CBA"/>
            <Item ID="0x1CBB"/>
            <Item ID="0x1CBD"/>
            <Item ID="0x1CBE"/>
            <Item ID="0x1CBF"/>
            <Item ID="0x1D30"/>
            <Item ID="0x1D31"/>
            <Item ID="0x1D32"/>
            <Item ID="0x1D33"/>
            <Item ID="0x1D34"/>
            <Item ID="0x1D35"/>
            <Item ID="0x1D36"/>
            <Item ID="0x1D37"/>
            <Item ID="0x1D38"/>
            <Item ID="0x1D39"/>
            <Item ID="0x1D3A"/>
            <Item ID="0x1D3B"/>
            <Item ID="0x1D3C"/>
            <Item ID="0x1D3D"/>
            <Item ID="0x1D3E"/>
            <Item ID="0x1D3F"/>
            <Item ID="0x1D40"/>
            <Item ID="0x1D41"/>
            <Item ID="0x1D42"/>
            <Item ID="0x1D43"/>
            <Item ID="0x1D44"/>
            <Item ID="0x1D45"/>
            <Item ID="0x1D46"/>
            <Item ID="0x1D47"/>
            <Item ID="0x1D48"/>
            <Item ID="0x1D49"/>
            <Item ID="0x1D4A"/>
            <Item ID="0x1D4B"/>
        </Group>
        <Group name="Mummy W">
            <Item ID="0x1C2B"/>
            <Item ID="0x1C2E"/>
            <Item ID="0x1C3C"/>
            <Item ID="0x1C6F"/>
            <Item ID="0x1C75"/>
            <Item ID="0x1C76"/>
            <Item ID="0x1C85"/>
            <Item ID="0x1C86"/>
            <Item ID="0x1C87"/>
            <Item ID="0x1C8B"/>
            <Item ID="0x1C8D"/>
            <Item ID="0x1C8E"/>
            <Item ID="0x1C8F"/>
            <Item ID="0x1D13"/>
            <Item ID="0x1D14"/>
            <Item ID="0x1D15"/>
            <Item ID="0x1D16"/>
            <Item ID="0x1D17"/>
            <Item ID="0x1D18"/>
            <Item ID="0x1D19"/>
            <Item ID="0x1D1A"/>
            <Item ID="0x1D1B"/>
            <Item ID="0x1D1C"/>
            <Item ID="0x1D1D"/>
            <Item ID="0x1D1E"/>
            <Item ID="0x1D1F"/>
            <Item ID="0x1D20"/>
            <Item ID="0x1D21"/>
            <Item ID="0x1D22"/>
            <Item ID="0x1D23"/>
            <Item ID="0x1D24"/>
            <Item ID="0x1D25"/>
            <Item ID="0x1D26"/>
            <Item ID="0x1D27"/>
            <Item ID="0x1D28"/>
            <Item ID="0x1D29"/>
            <Item ID="0x1D2A"/>
            <Item ID="0x1D2B"/>
            <Item ID="0x1D2C"/>
            <Item ID="0x1D2D"/>
            <Item ID="0x1D2E"/>
            <Item ID="0x1D2F"/>
            <Item ID="0x1D52"/>
            <Item ID="0x1D58"/>
            <Item ID="0x1D6A"/>
        </Group>
        <Group name="Palisade">
            <Item ID="0x021D"/>
            <Item ID="0x021E"/>
            <Item ID="0x021F"/>
            <Item ID="0x0220"/>
            <Item ID="0x0221"/>
            <Item ID="0x0222"/>
            <Item ID="0x0223"/>
            <Item ID="0x0226"/>
            <Item ID="0x0227"/>
            <Item ID="0x0228"/>
            <Item ID="0x0229"/>
            <Item ID="0x022A"/>
            <Item ID="0x022B"/>
            <Item ID="0x0421"/>
            <Item ID="0x0422"/>
            <Item ID="0x0423"/>
            <Item ID="0x0424"/>
            <Item ID="0x0425"/>
            <Item ID="0x0430"/>
            <Item ID="0x0431"/>
            <Item ID="0x2188"/>
            <Item ID="0x2189"/>
            <Item ID="0x218a"/>
            <Item ID="0x218b"/>
            <Item ID="0x218c"/>
            <Item ID="0x218d"/>
            <Item ID="0x218e"/>
            <Item ID="0x218f"/>
            <Item ID="0x2190"/>
            <Item ID="0x2191"/>
            <Item ID="0x2192"/>
            <Item ID="0x2193"/>
            <Item ID="0x2194"/>
            <Item ID="0x2195"/>
            <Item ID="0x2196"/>
            <Item ID="0x2197"/>
            <Item ID="0x21a5"/>
            <Item ID="0x21a6"/>
            <Item ID="0x21a7"/>
            <Item ID="0x21a8"/>
            <Item ID="0x21a9"/>
            <Item ID="0x21aa"/>
            <Item ID="0x21ab"/>
            <Item ID="0x21ac"/>
            <Item ID="0x21ad"/>
            <Item ID="0x21ae"/>
        </Group>
        <Group name="Ready to Bury">
            <Item ID="0x1C20"/>
            <Item ID="0x1C21"/>
            <Item ID="0x1D8A"/>
            <Item ID="0x1D8B"/>
            <Item ID="0x1D8C"/>
            <Item ID="0x1D8D"/>
            <Item ID="0x1D8E"/>
            <Item ID="0x1D8F"/>
            <Item ID="0x1D90"/>
            <Item ID="0x1D91"/>
        </Group>
        <Group name="Sarcophagus">
            <Item ID="0x1C60"/>
            <Item ID="0x1C61"/>
            <Item ID="0x1C62"/>
            <Item ID="0x1C63"/>
            <Item ID="0x1C64"/>
            <Item ID="0x1C65"/>
            <Item ID="0x1C66"/>
            <Item ID="0x1C67"/>
            <Item ID="0x1C68"/>
            <Item ID="0x1C69"/>
            <Item ID="0x1C6A"/>
            <Item ID="0x1C6B"/>
            <Item ID="0x1C6C"/>
            <Item ID="0x1C6D"/>
            <Item ID="0x1C6E"/>
            <Item ID="0x1C6F"/>
            <Item ID="0x1C70"/>
            <Item ID="0x1C71"/>
            <Item ID="0x1C72"/>
            <Item ID="0x1C73"/>
            <Item ID="0x1C74"/>
            <Item ID="0x1C75"/>
            <Item ID="0x1C76"/>
            <Item ID="0x1C77"/>
            <Item ID="0x1C78"/>
            <Item ID="0x1C79"/>
            <Item ID="0x1C7A"/>
            <Item ID="0x1C7B"/>
            <Item ID="0x1C7C"/>
            <Item ID="0x1C7D"/>
            <Item ID="0x1C7E"/>
            <Item ID="0x1C7F"/>
            <Item ID="0x1C80"/>
            <Item ID="0x1C81"/>
            <Item ID="0x1C82"/>
            <Item ID="0x1C83"/>
            <Item ID="0x1C84"/>
            <Item ID="0x1C85"/>
            <Item ID="0x1C86"/>
            <Item ID="0x1C87"/>
            <Item ID="0x1C88"/>
            <Item ID="0x1C89"/>
            <Item ID="0x1C8A"/>
            <Item ID="0x1C8B"/>
            <Item ID="0x1C8C"/>
            <Item ID="0x1C8D"/>
            <Item ID="0x1C8E"/>
            <Item ID="0x1C8F"/>
            <Item ID="0x1C90"/>
            <Item ID="0x1C91"/>
            <Item ID="0x1C92"/>
            <Item ID="0x1C93"/>
            <Item ID="0x1C94"/>
            <Item ID="0x1C95"/>
            <Item ID="0x1C96"/>
            <Item ID="0x1C97"/>
            <Item ID="0x1C98"/>
            <Item ID="0x1C99"/>
            <Item ID="0x1C9A"/>
            <Item ID="0x1C9A"/>
            <Item ID="0x1C9B"/>
            <Item ID="0x1C9C"/>
            <Item ID="0x1C9D"/>
            <Item ID="0x1C9E"/>
            <Item ID="0x1C9F"/>
            <Item ID="0x1CA0"/>
            <Item ID="0x1CA2"/>
            <Item ID="0x1CA3"/>
            <Item ID="0x1CA4"/>
            <Item ID="0x1CA5"/>
            <Item ID="0x1CA6"/>
            <Item ID="0x1CA7"/>
            <Item ID="0x1CA8"/>
            <Item ID="0x1CA9"/>
            <Item ID="0x1CAA"/>
            <Item ID="0x1CAB"/>
            <Item ID="0x1CAC"/>
            <Item ID="0x1CAD"/>
            <Item ID="0x1CAE"/>
            <Item ID="0x1CAF"/>
            <Item ID="0x1CB0"/>
            <Item ID="0x1CB2"/>
            <Item ID="0x1CB3"/>
            <Item ID="0x1CB4"/>
            <Item ID="0x1CB5"/>
            <Item ID="0x1CB6"/>
            <Item ID="0x1CB7"/>
            <Item ID="0x1CB8"/>
            <Item ID="0x1CB9"/>
            <Item ID="0x1CB9"/>
            <Item ID="0x1CBA"/>
            <Item ID="0x1CBB"/>
            <Item ID="0x1CBC"/>
            <Item ID="0x1CBD"/>
            <Item ID="0x1CBE"/>
            <Item ID="0x1CBF"/>
            <Item ID="0x2FF9"/>
            <Item ID="0x2FFA"/>
            <Item ID="0x3048"/>
            <Item ID="0x3049"/>
            <Item ID="0x304a"/>
            <Item ID="0x304b"/>
            <Item ID="0x365A"/>
            <Item ID="0x365B"/>
            <Item ID="0x369d"/>
            <Item ID="0x369e"/>
        </Group>
        <Group name="Skeleton N">
            <Item ID="0x1C38"/>
            <Item ID="0x1C4A"/>
            <Item ID="0x1C4B"/>
            <Item ID="0x1C4C"/>
            <Item ID="0x1C8A"/>
            <Item ID="0x1C8A"/>
            <Item ID="0x1C9E"/>
            <Item ID="0x1C9F"/>
            <Item ID="0x1CA5"/>
            <Item ID="0x1CA6"/>
            <Item ID="0x1CB6"/>
            <Item ID="0x1CB7"/>
            <Item ID="0x1CBD"/>
            <Item ID="0x1CBE"/>
            <Item ID="0x1CBF"/>
            <Item ID="0x1D6C"/>
            <Item ID="0x1D6D"/>
            <Item ID="0x1D6E"/>
            <Item ID="0x1D6F"/>
            <Item ID="0x1D70"/>
            <Item ID="0x1D71"/>
            <Item ID="0x1D72"/>
            <Item ID="0x1D73"/>
            <Item ID="0x1D74"/>
            <Item ID="0x1D75"/>
            <Item ID="0x1D76"/>
            <Item ID="0x1D77"/>
            <Item ID="0x1D78"/>
            <Item ID="0x1D78"/>
            <Item ID="0x1D79"/>
            <Item ID="0x1D79"/>
            <Item ID="0x1D7A"/>
            <Item ID="0x1D7A"/>
            <Item ID="0x1D7B"/>
            <Item ID="0x1D7C"/>
            <Item ID="0x1D80"/>
            <Item ID="0x1D81"/>
            <Item ID="0x1D82"/>
            <Item ID="0x1D83"/>
            <Item ID="0x1D84"/>
            <Item ID="0x1D85"/>
            <Item ID="0x1D86"/>
            <Item ID="0x1D87"/>
            <Item ID="0x1D88"/>
            <Item ID="0x1D89"/>
        </Group>
        <Group name="Skeleton W">
            <Item ID="0x1C2B"/>
            <Item ID="0x1C3C"/>
            <Item ID="0x1C6E"/>
            <Item ID="0x1C6F"/>
            <Item ID="0x1C75"/>
            <Item ID="0x1C76"/>
            <Item ID="0x1C85"/>
            <Item ID="0x1C86"/>
            <Item ID="0x1C87"/>
            <Item ID="0x1C8B"/>
            <Item ID="0x1C8D"/>
            <Item ID="0x1C8E"/>
            <Item ID="0x1C8F"/>
            <Item ID="0x1D4C"/>
            <Item ID="0x1D4D"/>
            <Item ID="0x1D4E"/>
            <Item ID="0x1D4F"/>
            <Item ID="0x1D50"/>
            <Item ID="0x1D51"/>
            <Item ID="0x1D52"/>
            <Item ID="0x1D53"/>
            <Item ID="0x1D54"/>
            <Item ID="0x1D55"/>
            <Item ID="0x1D56"/>
            <Item ID="0x1D57"/>
            <Item ID="0x1D58"/>
            <Item ID="0x1D59"/>
            <Item ID="0x1D5A"/>
            <Item ID="0x1D5B"/>
            <Item ID="0x1D5C"/>
            <Item ID="0x1D5D"/>
            <Item ID="0x1D5E"/>
            <Item ID="0x1D5F"/>
            <Item ID="0x1D60"/>
            <Item ID="0x1D61"/>
            <Item ID="0x1D62"/>
            <Item ID="0x1D63"/>
            <Item ID="0x1D64"/>
            <Item ID="0x1D65"/>
            <Item ID="0x1D66"/>
            <Item ID="0x1D67"/>
            <Item ID="0x1D68"/>
            <Item ID="0x1D69"/>
            <Item ID="0x1D6A"/>
            <Item ID="0x1D6B"/>
        </Group>
        <Group name="Skeleton">
            <Item ID="0x1A01"/>
            <Item ID="0x1A02"/>
            <Item ID="0x1A03"/>
            <Item ID="0x1A04"/>
            <Item ID="0x1A05"/>
            <Item ID="0x1A06"/>
            <Item ID="0x1A07"/>
            <Item ID="0x1A08"/>
            <Item ID="0x1A09"/>
            <Item ID="0x1A0A"/>
            <Item ID="0x1A0B"/>
            <Item ID="0x1A0C"/>
            <Item ID="0x1A0D"/>
            <Item ID="0x1A0E"/>
            <Item ID="0x1B1D"/>
            <Item ID="0x1B1E"/>
            <Item ID="0x1b7c"/>
            <Item ID="0x1b7d"/>
            <Item ID="0x1b7f"/>
            <Item ID="0x1b80"/>
        </Group>
        <Group name="Skulls">
            <Item ID="0x1853"/>
            <Item ID="0x1854"/>
            <Item ID="0x1857"/>
            <Item ID="0x1858"/>
            <Item ID="0x1AD8"/>
            <Item ID="0x1AD9"/>
            <Item ID="0x1ADA"/>
            <Item ID="0x1ADB"/>
            <Item ID="0x1ADC"/>
            <Item ID="0x1ADD"/>
            <Item ID="0x1ADE"/>
            <Item ID="0x1ADF"/>
            <Item ID="0x1AE0"/>
            <Item ID="0x1AE1"/>
            <Item ID="0x1AE2"/>
            <Item ID="0x1AE3"/>
            <Item ID="0x1AE4"/>
            <Item ID="0x21FC"/>
            <Item ID="0x2203"/>
            <Item ID="0x2204"/>
        </Group>
        <Group name="Spiders">
            <Item ID="0x0EE3"/>
            <Item ID="0x0EE4"/>
            <Item ID="0x0EE5"/>
            <Item ID="0x0EE6"/>
            <Item ID="0x10B8"/>
            <Item ID="0x10B9"/>
            <Item ID="0x10Ba"/>
            <Item ID="0x10Bb"/>
            <Item ID="0x10Bc"/>
            <Item ID="0x10Bd"/>
            <Item ID="0x10Be"/>
            <Item ID="0x10Bf"/>
            <Item ID="0x10c0"/>
            <Item ID="0x10c1"/>
            <Item ID="0x10c2"/>
            <Item ID="0x10c3"/>
            <Item ID="0x10c4"/>
            <Item ID="0x10c5"/>
            <Item ID="0x10c6"/>
            <Item ID="0x10c7"/>
            <Item ID="0x10c8"/>
            <Item ID="0x10c9"/>
            <Item ID="0x10ca"/>
            <Item ID="0x10cb"/>
            <Item ID="0x10cc"/>
            <Item ID="0x10cd"/>
            <Item ID="0x10ce"/>
            <Item ID="0x10cf"/>
            <Item ID="0x10d0"/>
            <Item ID="0x10d1"/>
            <Item ID="0x10d2"/>
            <Item ID="0x10d3"/>
            <Item ID="0x10d4"/>
            <Item ID="0x10d5"/>
            <Item ID="0x10d6"/>
            <Item ID="0x10d7"/>
            <Item ID="0x10d8"/>
            <Item ID="0x10d9"/>
            <Item ID="0x10da"/>
            <Item ID="0x10db"/>
            <Item ID="0x10dc"/>
            <Item ID="0x10dd"/>
        </Group>
        <Group name="Torture + Execution">
            <Item ID="0x1230"/>
            <Item ID="0x1245"/>
            <Item ID="0x1246"/>
            <Item ID="0x1247"/>
            <Item ID="0x1249"/>
            <Item ID="0x124B"/>
            <Item ID="0x124C"/>
            <Item ID="0x124D"/>
            <Item ID="0x124E"/>
            <Item ID="0x124F"/>
            <Item ID="0x1250"/>
            <Item ID="0x1251"/>
            <Item ID="0x1252"/>
            <Item ID="0x1253"/>
            <Item ID="0x1254"/>
            <Item ID="0x1255"/>
            <Item ID="0x1256"/>
            <Item ID="0x1257"/>
            <Item ID="0x1258"/>
            <Item ID="0x1259"/>
            <Item ID="0x125A"/>
            <Item ID="0x125B"/>
            <Item ID="0x125E"/>
            <Item ID="0x125F"/>
            <Item ID="0x1260"/>
            <Item ID="0x1261"/>
            <Item ID="0x1269"/>
            <Item ID="0x126B"/>
            <Item ID="0x126C"/>
            <Item ID="0x126D"/>
            <Item ID="0x126E"/>
            <Item ID="0x126F"/>
            <Item ID="0x1270"/>
            <Item ID="0x1271"/>
            <Item ID="0x1272"/>
            <Item ID="0x1273"/>
            <Item ID="0x1274"/>
            <Item ID="0x1275"/>
            <Item ID="0x1276"/>
            <Item ID="0x1277"/>
            <Item ID="0x1278"/>
            <Item ID="0x1279"/>
            <Item ID="0x127A"/>
            <Item ID="0x127B"/>
            <Item ID="0x127C"/>
            <Item ID="0x127E"/>
            <Item ID="0x127F"/>
            <Item ID="0x1280"/>
            <Item ID="0x1281"/>
            <Item ID="0x1282"/>
            <Item ID="0x1283"/>
            <Item ID="0x1284"/>
            <Item ID="0x1285"/>
            <Item ID="0x1286"/>
            <Item ID="0x1287"/>
            <Item ID="0x1288"/>
            <Item ID="0x1289"/>
            <Item ID="0x128A"/>
            <Item ID="0x128B"/>
            <Item ID="0x128C"/>
            <Item ID="0x128D"/>
            <Item ID="0x128F"/>
            <Item ID="0x1290"/>
            <Item ID="0x1291"/>
            <Item ID="0x1292"/>
            <Item ID="0x1293"/>
            <Item ID="0x1294"/>
            <Item ID="0x1295"/>
            <Item ID="0x1640"/>
            <Item ID="0x166D"/>
            <Item ID="0x166E"/>
            <Item ID="0x166F"/>
            <Item ID="0x2A71"/>
            <Item ID="0x2A72"/>
            <Item ID="0x2A73"/>
            <Item ID="0x2A74"/>
            <Item ID="0x2A75"/>
            <Item ID="0x2A76"/>
            <Item ID="0x2A77"/>
            <Item ID="0x2A78"/>
            <Item ID="0x2A79"/>
            <Item ID="0x2A7A"/>
        </Group>
    </Group>
    <Group name="Decoration">
        <Group name="Animal">
            <Item ID="0x2CFD"/>
            <Item ID="0x2CFE"/>
            <Item ID="0x2CFF"/>
            <Item ID="0x2D00"/>
            <Item ID="0x2D01"/>
            <Item ID="0x2D02"/>
            <Item ID="0x2D03"/>
            <Item ID="0x2D04"/>
        </Group>
        <Group name="Books">
            <Item ID="0x0C16"/>
            <Item ID="0x0FBD"/>
            <Item ID="0x0FBE"/>
            <Item ID="0x0FBF"/>
            <Item ID="0x0FC0"/>
            <Item ID="0x0FC1"/>
            <Item ID="0x0FEF"/>
            <Item ID="0x0FF0"/>
            <Item ID="0x0FF1"/>
            <Item ID="0x0FF2"/>
            <Item ID="0x0FF3"/>
            <Item ID="0x0FF4"/>
            <Item ID="0x1C11"/>
            <Item ID="0x1C13"/>
            <Item ID="0x1E20"/>
            <Item ID="0x1E21"/>
            <Item ID="0x1E22"/>
            <Item ID="0x1E23"/>
            <Item ID="0x1E24"/>
            <Item ID="0x1E25"/>
            <Item ID="0x1E5e"/>
            <Item ID="0x1E5f"/>
            <Item ID="0x2252"/>
            <Item ID="0x2253"/>
            <Item ID="0x2254"/>
            <Item ID="0x2259"/>
            <Item ID="0x225a"/>
            <Item ID="0x225b"/>
            <Item ID="0x22C5"/>
            <Item ID="0x2311"/>
            <Item ID="0x2312"/>
            <Item ID="0x238C"/>
            <Item ID="0x23A0"/>
            <Item ID="0x2D50"/>
            <Item ID="0x2d9d"/>
            <Item ID="0x36a2"/>
            <Item ID="0x36a3"/>
        </Group>
        <Group name="Container">
            <Item ID="0x0990"/>
            <Item ID="0x09A8"/>
            <Item ID="0x09A9"/>
            <Item ID="0x09AA"/>
            <Item ID="0x09AB"/>
            <Item ID="0x09AC"/>
            <Item ID="0x09B0"/>
            <Item ID="0x09B1"/>
            <Item ID="0x09B2"/>
            <Item ID="0x0E3C"/>
            <Item ID="0x0E3D"/>
            <Item ID="0x0E3E"/>
            <Item ID="0x0E3F"/>
            <Item ID="0x0E40"/>
            <Item ID="0x0E41"/>
            <Item ID="0x0E42"/>
            <Item ID="0x0E43"/>
            <Item ID="0x0E75"/>
            <Item ID="0x0E76"/>
            <Item ID="0x0E77"/>
            <Item ID="0x0E78"/>
            <Item ID="0x0E79"/>
            <Item ID="0x0E7A"/>
            <Item ID="0x0E7B"/>
            <Item ID="0x0E7C"/>
            <Item ID="0x0E7D"/>
            <Item ID="0x0E7E"/>
            <Item ID="0x0E7F"/>
            <Item ID="0x0E80"/>
            <Item ID="0x0E83"/>
            <Item ID="0x0FAE"/>
            <Item ID="0x154D"/>
            <Item ID="0x15F8"/>
            <Item ID="0x15f8"/>
            <Item ID="0x1603"/>
            <Item ID="0x1605"/>
            <Item ID="0x1940"/>
            <Item ID="0x1AD6"/>
            <Item ID="0x1AD7"/>
            <Item ID="0x1fff"/>
            <Item ID="0x2000"/>
            <Item ID="0x207b"/>
            <Item ID="0x24D5"/>
            <Item ID="0x24D6"/>
            <Item ID="0x24D7"/>
            <Item ID="0x24D8"/>
            <Item ID="0x24D9"/>
            <Item ID="0x24DA"/>
            <Item ID="0x24DB"/>
            <Item ID="0x24DC"/>
            <Item ID="0x24DD"/>
            <Item ID="0x280B"/>
            <Item ID="0x280C"/>
            <Item ID="0x280D"/>
            <Item ID="0x280E"/>
            <Item ID="0x280F"/>
            <Item ID="0x2810"/>
            <Item ID="0x2811"/>
            <Item ID="0x2812"/>
            <Item ID="0x2813"/>
            <Item ID="0x2814"/>
            <Item ID="0x2815"/>
            <Item ID="0x2816"/>
            <Item ID="0x2817"/>
            <Item ID="0x2818"/>
            <Item ID="0x2857"/>
            <Item ID="0x2858"/>
            <Item ID="0x2859"/>
            <Item ID="0x285A"/>
            <Item ID="0x285B"/>
            <Item ID="0x285C"/>
            <Item ID="0x285D"/>
            <Item ID="0x285E"/>
            <Item ID="0x3ed8"/>
            <Item ID="0x3ed9"/>
            <Item ID="0x3eda"/>
            <Item ID="0x3edb"/>
        </Group>
        <Group name="Cracks + Dirt">
            <Item ID="0x0911"/>
            <Item ID="0x0912"/>
            <Item ID="0x0913"/>
            <Item ID="0x0914"/>
            <Item ID="0x1B01"/>
            <Item ID="0x1B02"/>
            <Item ID="0x1B03"/>
            <Item ID="0x1B04"/>
            <Item ID="0x1B05"/>
            <Item ID="0x1B06"/>
            <Item ID="0x1B07"/>
            <Item ID="0x1B08"/>
            <Item ID="0x1B6C"/>
            <Item ID="0x1B6D"/>
            <Item ID="0x1B6E"/>
            <Item ID="0x1B6F"/>
            <Item ID="0x1dfd"/>
            <Item ID="0x1dfe"/>
            <Item ID="0x1dff"/>
            <Item ID="0x1e00"/>
            <Item ID="0x1e01"/>
            <Item ID="0x1e02"/>
            <Item ID="0x1e03"/>
            <Item ID="0x1e04"/>
            <Item ID="0x1e05"/>
            <Item ID="0x1e06"/>
            <Item ID="0x1e07"/>
            <Item ID="0x1e08"/>
            <Item ID="0x1e09"/>
            <Item ID="0x1e0a"/>
            <Item ID="0x1e0b"/>
            <Item ID="0x1e0c"/>
            <Item ID="0x1e0d"/>
            <Item ID="0x1e0e"/>
        </Group>
        <Group name="Crystal">
            <Item ID="0x2206"/>
            <Item ID="0x2207"/>
            <Item ID="0x2208"/>
            <Item ID="0x2209"/>
            <Item ID="0x220A"/>
            <Item ID="0x220B"/>
            <Item ID="0x220C"/>
            <Item ID="0x220D"/>
            <Item ID="0x220E"/>
            <Item ID="0x2210"/>
            <Item ID="0x2211"/>
            <Item ID="0x2212"/>
            <Item ID="0x2213"/>
            <Item ID="0x2214"/>
            <Item ID="0x2215"/>
            <Item ID="0x2216"/>
            <Item ID="0x2217"/>
            <Item ID="0x2218"/>
            <Item ID="0x221A"/>
            <Item ID="0x221B"/>
            <Item ID="0x221C"/>
            <Item ID="0x221D"/>
            <Item ID="0x221E"/>
            <Item ID="0x221F"/>
            <Item ID="0x2220"/>
            <Item ID="0x2221"/>
            <Item ID="0x2222"/>
            <Item ID="0x2224"/>
            <Item ID="0x2225"/>
            <Item ID="0x2226"/>
            <Item ID="0x2227"/>
            <Item ID="0x2228"/>
            <Item ID="0x2229"/>
            <Item ID="0x222A"/>
            <Item ID="0x222B"/>
            <Item ID="0x222C"/>
            <Item ID="0x223a"/>
            <Item ID="0x223b"/>
            <Item ID="0x223c"/>
            <Item ID="0x223d"/>
            <Item ID="0x223e"/>
            <Item ID="0x223f"/>
            <Item ID="0x2240"/>
            <Item ID="0x2241"/>
            <Item ID="0x2242"/>
            <Item ID="0x2243"/>
            <Item ID="0x2244"/>
            <Item ID="0x2245"/>
            <Item ID="0x2246"/>
            <Item ID="0x2247"/>
            <Item ID="0x2248"/>
            <Item ID="0x2249"/>
            <Item ID="0x2FE6"/>
            <Item ID="0x2FE7"/>
            <Item ID="0x2Fdc"/>
            <Item ID="0x2Fdd"/>
            <Item ID="0x35EB"/>
            <Item ID="0x35EC"/>
            <Item ID="0x35f6"/>
            <Item ID="0x35f7"/>
        </Group>
        <Group name="Directions">
            <Group name="Pointer">
                <Item ID="0x1296"/>
                <Item ID="0x1297"/>
                <Item ID="0x1298"/>
                <Item ID="0x1299"/>
                <Item ID="0x129A"/>
                <Item ID="0x129B"/>
                <Item ID="0x129C"/>
                <Item ID="0x129D"/>
                <Item ID="0x129E"/>
            </Group>
            <Group name="Signs">
                <Item ID="0x0B95"/>
                <Item ID="0x0B96"/>
                <Item ID="0x0B97"/>
                <Item ID="0x0B98"/>
                <Item ID="0x0B99"/>
                <Item ID="0x0B9A"/>
                <Item ID="0x0B9B"/>
                <Item ID="0x0B9C"/>
                <Item ID="0x0B9D"/>
                <Item ID="0x0B9E"/>
                <Item ID="0x0B9F"/>
                <Item ID="0x0BA0"/>
                <Item ID="0x0BA1"/>
                <Item ID="0x0BA2"/>
                <Item ID="0x0BA3"/>
                <Item ID="0x0BA4"/>
                <Item ID="0x0BA5"/>
                <Item ID="0x0BA6"/>
                <Item ID="0x0BA7"/>
                <Item ID="0x0BA8"/>
                <Item ID="0x0BA9"/>
                <Item ID="0x0BAA"/>
                <Item ID="0x0BAB"/>
                <Item ID="0x0BAD"/>
                <Item ID="0x0BAE"/>
                <Item ID="0x0BAF"/>
                <Item ID="0x0BB0"/>
                <Item ID="0x0BB1"/>
                <Item ID="0x0BB2"/>
                <Item ID="0x0BB3"/>
                <Item ID="0x0BB4"/>
                <Item ID="0x0BB5"/>
                <Item ID="0x0BB6"/>
                <Item ID="0x0BB7"/>
                <Item ID="0x0BB8"/>
                <Item ID="0x0BB9"/>
                <Item ID="0x0BBA"/>
                <Item ID="0x0BBB"/>
                <Item ID="0x0BBC"/>
                <Item ID="0x0BBD"/>
                <Item ID="0x0BBE"/>
                <Item ID="0x0BBF"/>
                <Item ID="0x0BC0"/>
                <Item ID="0x0BC1"/>
                <Item ID="0x0BC2"/>
                <Item ID="0x0BC3"/>
                <Item ID="0x0BC4"/>
                <Item ID="0x0BC5"/>
                <Item ID="0x0BC6"/>
                <Item ID="0x0BC7"/>
                <Item ID="0x0BC8"/>
                <Item ID="0x0BC9"/>
                <Item ID="0x0BCA"/>
                <Item ID="0x0BCB"/>
                <Item ID="0x0BCC"/>
                <Item ID="0x0BCD"/>
                <Item ID="0x0BCE"/>
                <Item ID="0x0BCF"/>
                <Item ID="0x0BD0"/>
                <Item ID="0x0BD1"/>
                <Item ID="0x0BD2"/>
                <Item ID="0x0BD3"/>
                <Item ID="0x0BD4"/>
                <Item ID="0x0BD5"/>
                <Item ID="0x0BD6"/>
                <Item ID="0x0BD7"/>
                <Item ID="0x0BD8"/>
                <Item ID="0x0BD9"/>
                <Item ID="0x0BDA"/>
                <Item ID="0x0BDB"/>
                <Item ID="0x0BDC"/>
                <Item ID="0x0BDD"/>
                <Item ID="0x0BDE"/>
                <Item ID="0x0BDF"/>
                <Item ID="0x0BE0"/>
                <Item ID="0x0BE1"/>
                <Item ID="0x0BE2"/>
                <Item ID="0x0BE3"/>
                <Item ID="0x0BE4"/>
                <Item ID="0x0BE5"/>
                <Item ID="0x0BE6"/>
                <Item ID="0x0BE7"/>
                <Item ID="0x0BE8"/>
                <Item ID="0x0BE9"/>
                <Item ID="0x0BEA"/>
                <Item ID="0x0BEB"/>
                <Item ID="0x0BEC"/>
                <Item ID="0x0BED"/>
                <Item ID="0x0BEE"/>
                <Item ID="0x0BEF"/>
                <Item ID="0x0BF0"/>
                <Item ID="0x0BF1"/>
                <Item ID="0x0BF2"/>
                <Item ID="0x0BF3"/>
                <Item ID="0x0BF4"/>
                <Item ID="0x0BF5"/>
                <Item ID="0x0BF6"/>
                <Item ID="0x0BF7"/>
                <Item ID="0x0BF8"/>
                <Item ID="0x0BF9"/>
                <Item ID="0x0BFB"/>
                <Item ID="0x0BFC"/>
                <Item ID="0x0BFD"/>
                <Item ID="0x0BFE"/>
                <Item ID="0x0BFF"/>
                <Item ID="0x0C00"/>
                <Item ID="0x0C01"/>
                <Item ID="0x0C02"/>
                <Item ID="0x0C03"/>
                <Item ID="0x0C04"/>
                <Item ID="0x0C05"/>
                <Item ID="0x0C06"/>
                <Item ID="0x0C07"/>
                <Item ID="0x0C08"/>
                <Item ID="0x0C09"/>
                <Item ID="0x0C0A"/>
                <Item ID="0x0C0B"/>
                <Item ID="0x0C0C"/>
                <Item ID="0x0C0D"/>
                <Item ID="0x0C0E"/>
                <Item ID="0x0C43"/>
                <Item ID="0x0C44"/>
                <Item ID="0x1514"/>
                <Item ID="0x1F28"/>
                <Item ID="0x1F29"/>
            </Group>
        </Group>
        <Group name="Display">
            <Group name="Bounty">
                <Item ID="0x1E60"/>
                <Item ID="0x1E61"/>
                <Item ID="0x1E62"/>
                <Item ID="0x1E63"/>
                <Item ID="0x1E64"/>
                <Item ID="0x1E65"/>
                <Item ID="0x1E66"/>
                <Item ID="0x1E67"/>
                <Item ID="0x1E68"/>
                <Item ID="0x1E69"/>
                <Item ID="0x1E6A"/>
                <Item ID="0x1E6B"/>
                <Item ID="0x1E6C"/>
                <Item ID="0x1E6D"/>
                <Item ID="0x2234"/>
                <Item ID="0x2235"/>
                <Item ID="0x224E"/>
                <Item ID="0x224F"/>
                <Item ID="0x2250"/>
                <Item ID="0x2251"/>
                <Item ID="0x2F58"/>
                <Item ID="0x2F59"/>
                <Item ID="0x2F5A"/>
                <Item ID="0x2F5B"/>
                <Item ID="0x2F5C"/>
                <Item ID="0x2F5D"/>
                <Item ID="0x2F5E"/>
                <Item ID="0x2F5F"/>
                <Item ID="0x2F60"/>
                <Item ID="0x2F61"/>
                <Item ID="0x2FB7"/>
                <Item ID="0x2FB8"/>
                <Item ID="0x312D"/>
                <Item ID="0x312E"/>
                <Item ID="0x312F"/>
                <Item ID="0x3130"/>
                <Item ID="0x3155"/>
                <Item ID="0x3156"/>
                <Item ID="0x3157"/>
                <Item ID="0x3158"/>
                <Item ID="0x3159"/>
                <Item ID="0x315A"/>
                <Item ID="0x315B"/>
                <Item ID="0x315C"/>
                <Item ID="0x315D"/>
                <Item ID="0x3172"/>
                <Item ID="0x3FFE"/>
            </Group>
            <Group name="Display Cases">
                <Item ID="0x0A9F"/>
                <Item ID="0x0AA0"/>
                <Item ID="0x0AA1"/>
                <Item ID="0x0AA2"/>
                <Item ID="0x0AA3"/>
                <Item ID="0x0AA4"/>
                <Item ID="0x0AA5"/>
                <Item ID="0x0AFD"/>
                <Item ID="0x0AFE"/>
                <Item ID="0x0AFF"/>
                <Item ID="0x0B00"/>
                <Item ID="0x0B01"/>
                <Item ID="0x0B02"/>
                <Item ID="0x0B03"/>
                <Item ID="0x0B04"/>
                <Item ID="0x0B05"/>
                <Item ID="0x0B06"/>
                <Item ID="0x0B07"/>
                <Item ID="0x0B08"/>
                <Item ID="0x0B09"/>
                <Item ID="0x0B0A"/>
                <Item ID="0x0B0B"/>
                <Item ID="0x0B0C"/>
                <Item ID="0x0B0D"/>
                <Item ID="0x0B0E"/>
                <Item ID="0x0B0F"/>
                <Item ID="0x0B10"/>
                <Item ID="0x0B11"/>
                <Item ID="0x0B12"/>
                <Item ID="0x0B13"/>
                <Item ID="0x0B14"/>
                <Item ID="0x0B15"/>
                <Item ID="0x0B16"/>
                <Item ID="0x0B17"/>
                <Item ID="0x0B18"/>
                <Item ID="0x2FEA"/>
                <Item ID="0x2FEB"/>
            </Group>
            <Group name="Pots + Potting">
                <Item ID="0x0B45"/>
                <Item ID="0x0B46"/>
                <Item ID="0x0B47"/>
                <Item ID="0x0B48"/>
                <Item ID="0x0EB0"/>
                <Item ID="0x11C6"/>
                <Item ID="0x11C7"/>
                <Item ID="0x11C8"/>
                <Item ID="0x11C9"/>
                <Item ID="0x11CA"/>
                <Item ID="0x11CB"/>
                <Item ID="0x11CC"/>
                <Item ID="0x1E0F"/>
                <Item ID="0x1E10"/>
                <Item ID="0x1E11"/>
                <Item ID="0x1E12"/>
                <Item ID="0x1E13"/>
                <Item ID="0x1E14"/>
                <Item ID="0x284A"/>
                <Item ID="0x28DC"/>
                <Item ID="0x28DD"/>
                <Item ID="0x28DE"/>
                <Item ID="0x28DF"/>
                <Item ID="0x28E0"/>
                <Item ID="0x28E1"/>
                <Item ID="0x28E2"/>
                <Item ID="0x28E3"/>
            </Group>
            <Group name="Sculptures">
                <Item ID="0x1223"/>
                <Item ID="0x1224"/>
                <Item ID="0x1225"/>
                <Item ID="0x1226"/>
                <Item ID="0x1227"/>
                <Item ID="0x1228"/>
                <Item ID="0x129F"/>
                <Item ID="0x12A0"/>
                <Item ID="0x12A1"/>
                <Item ID="0x12A2"/>
                <Item ID="0x12A3"/>
                <Item ID="0x12A4"/>
                <Item ID="0x12AE"/>
                <Item ID="0x12AF"/>
                <Item ID="0x12B0"/>
                <Item ID="0x12CA"/>
                <Item ID="0x12CB"/>
                <Item ID="0x12D5"/>
                <Item ID="0x12D6"/>
                <Item ID="0x12D7"/>
                <Item ID="0x12D8"/>
                <Item ID="0x12D9"/>
                <Item ID="0x139A"/>
                <Item ID="0x139B"/>
                <Item ID="0x139C"/>
                <Item ID="0x139D"/>
                <Item ID="0x139E"/>
                <Item ID="0x139F"/>
                <Item ID="0x13A0"/>
                <Item ID="0x13A1"/>
                <Item ID="0x13A2"/>
                <Item ID="0x13A3"/>
                <Item ID="0x1f2a"/>
                <Item ID="0x207c"/>
                <Item ID="0x241A"/>
                <Item ID="0x241B"/>
                <Item ID="0x2846"/>
                <Item ID="0x2847"/>
                <Item ID="0x2848"/>
                <Item ID="0x2849"/>
                <Item ID="0x2A9e"/>
                <Item ID="0x2A9f"/>
                <Item ID="0x2Aa0"/>
                <Item ID="0x2D0E"/>
                <Item ID="0x2D0F"/>
                <Item ID="0x2D10"/>
                <Item ID="0x2D11"/>
                <Item ID="0x2D12"/>
                <Item ID="0x2D13"/>
                <Item ID="0x2D4A"/>
                <Item ID="0x2FF6"/>
                <Item ID="0x305A"/>
                <Item ID="0x305B"/>
                <Item ID="0x305C"/>
                <Item ID="0x305D"/>
                <Item ID="0x305E"/>
                <Item ID="0x305F"/>
                <Item ID="0x3066"/>
                <Item ID="0x3067"/>
                <Item ID="0x3068"/>
                <Item ID="0x3069"/>
                <Item ID="0x306A"/>
                <Item ID="0x306B"/>
                <Item ID="0x306C"/>
                <Item ID="0x306D"/>
                <Item ID="0x306E"/>
                <Item ID="0x306F"/>
                <Item ID="0x3070"/>
                <Item ID="0x3071"/>
                <Item ID="0x3072"/>
                <Item ID="0x3073"/>
                <Item ID="0x3074"/>
                <Item ID="0x3075"/>
                <Item ID="0x3076"/>
                <Item ID="0x35F8"/>
                <Item ID="0x35F9"/>
                <Item ID="0x35FA"/>
                <Item ID="0x35FB"/>
                <Item ID="0x35FC"/>
                <Item ID="0x35FD"/>
                <Item ID="0x35FE"/>
                <Item ID="0x35FF"/>
                <Item ID="0x3600"/>
                <Item ID="0x3601"/>
                <Item ID="0x364B"/>
                <Item ID="0x3657"/>
                <Item ID="0x3658"/>
                <Item ID="0x3659"/>
                <Item ID="0x3660"/>
                <Item ID="0x369B"/>
                <Item ID="0x3BB3"/>
                <Item ID="0x3BB4"/>
                <Item ID="0x3da2"/>
            </Group>
            <Group name="Shield + Weapon Display">
                <Item ID="0x155C"/>
                <Item ID="0x155D"/>
                <Item ID="0x155E"/>
                <Item ID="0x155F"/>
                <Item ID="0x1560"/>
                <Item ID="0x1561"/>
                <Item ID="0x1562"/>
                <Item ID="0x1563"/>
                <Item ID="0x1564"/>
                <Item ID="0x1565"/>
                <Item ID="0x1568"/>
                <Item ID="0x1569"/>
                <Item ID="0x156A"/>
                <Item ID="0x156B"/>
                <Item ID="0x156C"/>
                <Item ID="0x156D"/>
                <Item ID="0x156E"/>
                <Item ID="0x156F"/>
                <Item ID="0x1570"/>
                <Item ID="0x1571"/>
                <Item ID="0x1572"/>
                <Item ID="0x1573"/>
                <Item ID="0x1574"/>
                <Item ID="0x1575"/>
                <Item ID="0x1576"/>
                <Item ID="0x1577"/>
                <Item ID="0x1578"/>
                <Item ID="0x1579"/>
                <Item ID="0x157A"/>
                <Item ID="0x157B"/>
                <Item ID="0x157C"/>
                <Item ID="0x157D"/>
                <Item ID="0x157E"/>
                <Item ID="0x157F"/>
                <Item ID="0x1580"/>
                <Item ID="0x1581"/>
                <Item ID="0x1582"/>
                <Item ID="0x1583"/>
                <Item ID="0x1584"/>
                <Item ID="0x1585"/>
                <Item ID="0x1634"/>
                <Item ID="0x1635"/>
                <Item ID="0x1636"/>
                <Item ID="0x1637"/>
                <Item ID="0x2236"/>
                <Item ID="0x2237"/>
                <Item ID="0x2238"/>
                <Item ID="0x2239"/>
                <Item ID="0x2842"/>
                <Item ID="0x2843"/>
                <Item ID="0x2844"/>
                <Item ID="0x2845"/>
                <Item ID="0x2851"/>
                <Item ID="0x2852"/>
                <Item ID="0x2853"/>
                <Item ID="0x2854"/>
                <Item ID="0x2855"/>
                <Item ID="0x2856"/>
                <Item ID="0x291C"/>
                <Item ID="0x291D"/>
                <Item ID="0x291E"/>
                <Item ID="0x291F"/>
                <Item ID="0x2A2a"/>
                <Item ID="0x2A45"/>
                <Item ID="0x2A46"/>
                <Item ID="0x2A47"/>
                <Item ID="0x2A48"/>
                <Item ID="0x2A49"/>
                <Item ID="0x2A4A"/>
                <Item ID="0x2A4B"/>
                <Item ID="0x2A4C"/>
            </Group>
            <Group name="Wall Decor">
                <Group name="Banner">
                    <Item ID="0x0426"/>
                    <Item ID="0x0427"/>
                    <Item ID="0x042A"/>
                    <Item ID="0x042B"/>
                    <Item ID="0x042C"/>
                    <Item ID="0x042D"/>
                    <Item ID="0x042E"/>
                    <Item ID="0x042F"/>
                    <Item ID="0x1586"/>
                    <Item ID="0x1587"/>
                    <Item ID="0x1588"/>
                    <Item ID="0x1589"/>
                    <Item ID="0x158a"/>
                    <Item ID="0x158b"/>
                    <Item ID="0x158c"/>
                    <Item ID="0x158d"/>
                    <Item ID="0x158e"/>
                    <Item ID="0x158f"/>
                    <Item ID="0x1590"/>
                    <Item ID="0x1591"/>
                    <Item ID="0x1592"/>
                    <Item ID="0x1593"/>
                    <Item ID="0x1594"/>
                    <Item ID="0x1595"/>
                    <Item ID="0x1596"/>
                    <Item ID="0x1597"/>
                    <Item ID="0x1598"/>
                    <Item ID="0x1599"/>
                    <Item ID="0x159a"/>
                    <Item ID="0x159b"/>
                    <Item ID="0x159c"/>
                    <Item ID="0x159d"/>
                    <Item ID="0x159e"/>
                    <Item ID="0x159f"/>
                    <Item ID="0x15AE"/>
                    <Item ID="0x15AF"/>
                    <Item ID="0x15B0"/>
                    <Item ID="0x15B1"/>
                    <Item ID="0x15B2"/>
                    <Item ID="0x15B3"/>
                    <Item ID="0x15B4"/>
                    <Item ID="0x15B5"/>
                    <Item ID="0x15B6"/>
                    <Item ID="0x15B7"/>
                    <Item ID="0x15B8"/>
                    <Item ID="0x15B9"/>
                    <Item ID="0x15BA"/>
                    <Item ID="0x15BB"/>
                    <Item ID="0x15BC"/>
                    <Item ID="0x15BD"/>
                    <Item ID="0x15BE"/>
                    <Item ID="0x15BF"/>
                    <Item ID="0x15C0"/>
                    <Item ID="0x15C1"/>
                    <Item ID="0x15C2"/>
                    <Item ID="0x15C3"/>
                    <Item ID="0x15C4"/>
                    <Item ID="0x15C5"/>
                    <Item ID="0x15C6"/>
                    <Item ID="0x15C7"/>
                    <Item ID="0x15C8"/>
                    <Item ID="0x15C9"/>
                    <Item ID="0x15CA"/>
                    <Item ID="0x15CB"/>
                    <Item ID="0x15CC"/>
                    <Item ID="0x15CD"/>
                    <Item ID="0x15CE"/>
                    <Item ID="0x15CF"/>
                    <Item ID="0x15D0"/>
                    <Item ID="0x15D1"/>
                    <Item ID="0x15D2"/>
                    <Item ID="0x15D3"/>
                    <Item ID="0x15D4"/>
                    <Item ID="0x15D5"/>
                    <Item ID="0x15D6"/>
                    <Item ID="0x15D7"/>
                    <Item ID="0x15D8"/>
                    <Item ID="0x15D9"/>
                    <Item ID="0x15DA"/>
                    <Item ID="0x15DB"/>
                    <Item ID="0x15DC"/>
                    <Item ID="0x15DD"/>
                    <Item ID="0x15DE"/>
                    <Item ID="0x15DF"/>
                    <Item ID="0x15E0"/>
                    <Item ID="0x15E1"/>
                    <Item ID="0x15E2"/>
                    <Item ID="0x15E3"/>
                    <Item ID="0x15E4"/>
                    <Item ID="0x15E5"/>
                    <Item ID="0x15E6"/>
                    <Item ID="0x15E7"/>
                    <Item ID="0x15E8"/>
                    <Item ID="0x15E9"/>
                    <Item ID="0x15EA"/>
                    <Item ID="0x15EB"/>
                    <Item ID="0x15EC"/>
                    <Item ID="0x15ED"/>
                    <Item ID="0x15EE"/>
                    <Item ID="0x15EF"/>
                    <Item ID="0x15F0"/>
                    <Item ID="0x15F1"/>
                    <Item ID="0x15F2"/>
                    <Item ID="0x15F3"/>
                    <Item ID="0x15F4"/>
                    <Item ID="0x15F5"/>
                    <Item ID="0x15a0"/>
                    <Item ID="0x15a1"/>
                    <Item ID="0x15a2"/>
                    <Item ID="0x15a3"/>
                    <Item ID="0x15a4"/>
                    <Item ID="0x15a5"/>
                    <Item ID="0x15a6"/>
                    <Item ID="0x15a7"/>
                    <Item ID="0x15a8"/>
                    <Item ID="0x15a9"/>
                    <Item ID="0x15aa"/>
                    <Item ID="0x15ab"/>
                    <Item ID="0x15ac"/>
                    <Item ID="0x15ad"/>
                    <Item ID="0x15ae"/>
                    <Item ID="0x15af"/>
                    <Item ID="0x15b0"/>
                    <Item ID="0x15b1"/>
                    <Item ID="0x15b2"/>
                    <Item ID="0x15b3"/>
                    <Item ID="0x15b4"/>
                    <Item ID="0x15b5"/>
                    <Item ID="0x15b6"/>
                    <Item ID="0x15b7"/>
                    <Item ID="0x15b8"/>
                    <Item ID="0x15b9"/>
                    <Item ID="0x15ba"/>
                    <Item ID="0x15bb"/>
                    <Item ID="0x15bc"/>
                    <Item ID="0x15bd"/>
                    <Item ID="0x15be"/>
                    <Item ID="0x15bf"/>
                    <Item ID="0x15c0"/>
                    <Item ID="0x15c1"/>
                    <Item ID="0x15c2"/>
                    <Item ID="0x15c3"/>
                    <Item ID="0x15c4"/>
                    <Item ID="0x15c5"/>
                    <Item ID="0x15c6"/>
                    <Item ID="0x15c7"/>
                    <Item ID="0x15c8"/>
                    <Item ID="0x15c9"/>
                    <Item ID="0x15ca"/>
                    <Item ID="0x15cb"/>
                    <Item ID="0x15cc"/>
                    <Item ID="0x15cd"/>
                    <Item ID="0x15ce"/>
                    <Item ID="0x15cf"/>
                    <Item ID="0x15d0"/>
                    <Item ID="0x15d1"/>
                    <Item ID="0x15d2"/>
                    <Item ID="0x15d3"/>
                    <Item ID="0x15d4"/>
                    <Item ID="0x15d5"/>
                    <Item ID="0x15d6"/>
                    <Item ID="0x15d7"/>
                    <Item ID="0x15d8"/>
                    <Item ID="0x15d9"/>
                    <Item ID="0x15da"/>
                    <Item ID="0x15db"/>
                    <Item ID="0x15dc"/>
                    <Item ID="0x15dd"/>
                    <Item ID="0x15de"/>
                    <Item ID="0x15df"/>
                    <Item ID="0x15e0"/>
                    <Item ID="0x15e1"/>
                    <Item ID="0x15e2"/>
                    <Item ID="0x15e3"/>
                    <Item ID="0x15e4"/>
                    <Item ID="0x15e5"/>
                    <Item ID="0x15e6"/>
                    <Item ID="0x15e7"/>
                    <Item ID="0x15e8"/>
                    <Item ID="0x15e9"/>
                    <Item ID="0x15ea"/>
                    <Item ID="0x15eb"/>
                    <Item ID="0x15ec"/>
                    <Item ID="0x15ed"/>
                    <Item ID="0x15ee"/>
                    <Item ID="0x15ef"/>
                    <Item ID="0x15f0"/>
                    <Item ID="0x15f1"/>
                    <Item ID="0x15f2"/>
                    <Item ID="0x15f3"/>
                    <Item ID="0x15f4"/>
                    <Item ID="0x15f5"/>
                    <Item ID="0x160F"/>
                    <Item ID="0x1610"/>
                    <Item ID="0x1611"/>
                    <Item ID="0x1612"/>
                    <Item ID="0x1613"/>
                    <Item ID="0x1614"/>
                    <Item ID="0x1615"/>
                    <Item ID="0x1616"/>
                    <Item ID="0x1617"/>
                    <Item ID="0x1618"/>
                    <Item ID="0x1619"/>
                    <Item ID="0x161A"/>
                    <Item ID="0x161B"/>
                    <Item ID="0x161C"/>
                    <Item ID="0x161D"/>
                    <Item ID="0x161E"/>
                    <Item ID="0x161F"/>
                    <Item ID="0x1620"/>
                    <Item ID="0x1621"/>
                    <Item ID="0x1622"/>
                    <Item ID="0x1623"/>
                    <Item ID="0x1624"/>
                    <Item ID="0x1625"/>
                    <Item ID="0x1626"/>
                    <Item ID="0x1627"/>
                    <Item ID="0x1628"/>
                    <Item ID="0x1629"/>
                    <Item ID="0x162A"/>
                    <Item ID="0x162B"/>
                    <Item ID="0x162C"/>
                    <Item ID="0x162D"/>
                    <Item ID="0x162E"/>
                    <Item ID="0x162F"/>
                    <Item ID="0x1630"/>
                    <Item ID="0x1631"/>
                    <Item ID="0x1632"/>
                    <Item ID="0x1633"/>
                    <Item ID="0x2FFf"/>
                    <Item ID="0x3000"/>
                </Group>
                <Group name="Curtains">
                    <Item ID="0x0980"/>
                    <Item ID="0x0981"/>
                    <Item ID="0x0982"/>
                    <Item ID="0x0983"/>
                    <Item ID="0x0984"/>
                    <Item ID="0x0985"/>
                    <Item ID="0x0986"/>
                    <Item ID="0x0987"/>
                    <Item ID="0x0988"/>
                    <Item ID="0x0989"/>
                    <Item ID="0x098A"/>
                    <Item ID="0x098B"/>
                    <Item ID="0x12DA"/>
                    <Item ID="0x12DB"/>
                    <Item ID="0x12DC"/>
                    <Item ID="0x12DD"/>
                    <Item ID="0x12DE"/>
                    <Item ID="0x12DF"/>
                    <Item ID="0x12E0"/>
                    <Item ID="0x12E1"/>
                    <Item ID="0x12E2"/>
                    <Item ID="0x12E3"/>
                    <Item ID="0x12E4"/>
                    <Item ID="0x12E5"/>
                    <Item ID="0x12E6"/>
                    <Item ID="0x12E7"/>
                    <Item ID="0x12E8"/>
                    <Item ID="0x12E9"/>
                    <Item ID="0x12EA"/>
                    <Item ID="0x12EB"/>
                    <Item ID="0x12EC"/>
                    <Item ID="0x12ED"/>
                    <Item ID="0x154E"/>
                    <Item ID="0x154F"/>
                    <Item ID="0x1557"/>
                    <Item ID="0x15f6"/>
                    <Item ID="0x15f7"/>
                    <Item ID="0x160D"/>
                    <Item ID="0x160E"/>
                    <Item ID="0x1638"/>
                    <Item ID="0x1639"/>
                    <Item ID="0x3d9c"/>
                    <Item ID="0x3d9d"/>
                    <Item ID="0x3d9e"/>
                    <Item ID="0x3d9f"/>
                    <Item ID="0x3da0"/>
                    <Item ID="0x3da1"/>
                    <Item ID="0x3da1"/>
                    <Item ID="0x3da3"/>
                    <Item ID="0x3da4"/>
                    <Item ID="0x3da5"/>
                    <Item ID="0x3da6"/>
                    <Item ID="0x3da7"/>
                    <Item ID="0x3da8"/>
                    <Item ID="0x3dab"/>
                    <Item ID="0x3dac"/>
                    <Item ID="0x3dad"/>
                    <Item ID="0x3dae"/>
                </Group>
                <Group name="Painting">
                    <Item ID="0x0C2C"/>
                    <Item ID="0x0E9F"/>
                    <Item ID="0x0EA0"/>
                    <Item ID="0x0EA1"/>
                    <Item ID="0x0EA2"/>
                    <Item ID="0x0EA5"/>
                    <Item ID="0x0EA6"/>
                    <Item ID="0x0EA7"/>
                    <Item ID="0x0EA8"/>
                    <Item ID="0x0EC8"/>
                    <Item ID="0x0EC9"/>
                    <Item ID="0x0EE7"/>
                    <Item ID="0x240D"/>
                    <Item ID="0x240E"/>
                    <Item ID="0x240F"/>
                    <Item ID="0x2410"/>
                    <Item ID="0x2411"/>
                    <Item ID="0x2412"/>
                    <Item ID="0x2413"/>
                    <Item ID="0x2414"/>
                    <Item ID="0x2415"/>
                    <Item ID="0x2416"/>
                    <Item ID="0x2417"/>
                    <Item ID="0x2418"/>
                    <Item ID="0x2886"/>
                    <Item ID="0x2887"/>
                    <Item ID="0x2887"/>
                    <Item ID="0x2A5D"/>
                    <Item ID="0x2A5E"/>
                    <Item ID="0x2A5F"/>
                    <Item ID="0x2A60"/>
                    <Item ID="0x2A61"/>
                    <Item ID="0x2A62"/>
                    <Item ID="0x2A63"/>
                    <Item ID="0x2A64"/>
                    <Item ID="0x2A65"/>
                    <Item ID="0x2A66"/>
                    <Item ID="0x2A67"/>
                    <Item ID="0x2A68"/>
                    <Item ID="0x2A69"/>
                    <Item ID="0x2A6A"/>
                    <Item ID="0x2A6B"/>
                    <Item ID="0x2A6C"/>
                    <Item ID="0x2A6D"/>
                    <Item ID="0x2A6E"/>
                    <Item ID="0x2A6F"/>
                    <Item ID="0x2A70"/>
                    <Item ID="0x3BB6"/>
                    <Item ID="0x3BB7"/>
                </Group>
                <Group name="Tapestry">
                    <Item ID="0x0FD5"/>
                    <Item ID="0x0FD6"/>
                    <Item ID="0x0FD7"/>
                    <Item ID="0x0FD8"/>
                    <Item ID="0x0FD9"/>
                    <Item ID="0x0FDA"/>
                    <Item ID="0x0FDB"/>
                    <Item ID="0x0FDC"/>
                    <Item ID="0x0FDD"/>
                    <Item ID="0x0FDE"/>
                    <Item ID="0x0FDF"/>
                    <Item ID="0x0FE0"/>
                    <Item ID="0x0FE1"/>
                    <Item ID="0x0FE2"/>
                    <Item ID="0x0FE3"/>
                    <Item ID="0x0FE4"/>
                    <Item ID="0x234E"/>
                    <Item ID="0x234F"/>
                    <Item ID="0x2D6F"/>
                    <Item ID="0x2D70"/>
                    <Item ID="0x2D71"/>
                    <Item ID="0x2D72"/>
                    <Item ID="0x2FF2"/>
                    <Item ID="0x2FF3"/>
                </Group>
                <Group name="Wall Carving">
                    <Item ID="0x121d"/>
                    <Item ID="0x121e"/>
                    <Item ID="0x121f"/>
                    <Item ID="0x1220"/>
                    <Item ID="0x1221"/>
                    <Item ID="0x1222"/>
                    <Item ID="0x1231"/>
                    <Item ID="0x1232"/>
                    <Item ID="0x1233"/>
                    <Item ID="0x1234"/>
                    <Item ID="0x1235"/>
                    <Item ID="0x1237"/>
                    <Item ID="0x1238"/>
                    <Item ID="0x1239"/>
                    <Item ID="0x123A"/>
                    <Item ID="0x123B"/>
                    <Item ID="0x123C"/>
                    <Item ID="0x123D"/>
                    <Item ID="0x123E"/>
                    <Item ID="0x1240"/>
                    <Item ID="0x1241"/>
                    <Item ID="0x1242"/>
                    <Item ID="0x1243"/>
                    <Item ID="0x1244"/>
                    <Item ID="0x1265"/>
                    <Item ID="0x1266"/>
                    <Item ID="0x1267"/>
                    <Item ID="0x12CC"/>
                    <Item ID="0x12CD"/>
                    <Item ID="0x12CE"/>
                    <Item ID="0x12CF"/>
                    <Item ID="0x12D0"/>
                    <Item ID="0x12D2"/>
                    <Item ID="0x12D3"/>
                    <Item ID="0x12D4"/>
                    <Item ID="0x3647"/>
                    <Item ID="0x3648"/>
                    <Item ID="0x3649"/>
                    <Item ID="0x364a"/>
                </Group>
                <Item ID="0x0F65"/>
                <Item ID="0x0F66"/>
                <Item ID="0x0F67"/>
                <Item ID="0x0F68"/>
                <Item ID="0x0F69"/>
                <Item ID="0x0F6A"/>
                <Item ID="0x0F71"/>
                <Item ID="0x0F72"/>
                <Item ID="0x0F73"/>
                <Item ID="0x0F74"/>
                <Item ID="0x0F75"/>
                <Item ID="0x0F76"/>
                <Item ID="0x2409"/>
                <Item ID="0x240A"/>
                <Item ID="0x240B"/>
                <Item ID="0x240C"/>
                <Item ID="0x2D73"/>
                <Item ID="0x2D74"/>
            </Group>
            <Item ID="0x24E3"/>
            <Item ID="0x24E4"/>
            <Item ID="0x24E5"/>
            <Item ID="0x2FF4"/>
            <Item ID="0x2FF5"/>
            <Item ID="0x2Fb6"/>
            <Item ID="0x2Fd4"/>
            <Item ID="0x2Fd5"/>
            <Item ID="0x3d86"/>
            <Item ID="0x3d87"/>
            <Item ID="0x3da9"/>
            <Item ID="0x3daa"/>
        </Group>
        <Group name="Docks">
            <Item ID="0x01CB"/>
            <Item ID="0x01CC"/>
            <Item ID="0x01CD"/>
            <Item ID="0x01CE"/>
            <Item ID="0x03A5"/>
            <Item ID="0x03A6"/>
            <Item ID="0x03A7"/>
            <Item ID="0x03A8"/>
            <Item ID="0x03A9"/>
            <Item ID="0x03AA"/>
            <Item ID="0x03AB"/>
            <Item ID="0x03AC"/>
            <Item ID="0x03AD"/>
            <Item ID="0x03AE"/>
            <Item ID="0x03AF"/>
            <Item ID="0x03B0"/>
            <Item ID="0x14F7"/>
            <Item ID="0x14F8"/>
            <Item ID="0x14F9"/>
            <Item ID="0x14FA"/>
        </Group>
        <Group name="Fountain">
            <Item ID="0x090D"/>
            <Item ID="0x1731"/>
            <Item ID="0x1732"/>
            <Item ID="0x1733"/>
            <Item ID="0x1735"/>
            <Item ID="0x1736"/>
            <Item ID="0x1737"/>
            <Item ID="0x1738"/>
            <Item ID="0x1739"/>
            <Item ID="0x173A"/>
            <Item ID="0x173B"/>
            <Item ID="0x173C"/>
            <Item ID="0x173D"/>
            <Item ID="0x173E"/>
            <Item ID="0x173F"/>
            <Item ID="0x1740"/>
            <Item ID="0x19C3"/>
            <Item ID="0x19C4"/>
            <Item ID="0x19C5"/>
            <Item ID="0x19C7"/>
            <Item ID="0x19C8"/>
            <Item ID="0x19C9"/>
            <Item ID="0x19CA"/>
            <Item ID="0x19CB"/>
            <Item ID="0x19CC"/>
            <Item ID="0x19CD"/>
            <Item ID="0x19CE"/>
            <Item ID="0x19CF"/>
            <Item ID="0x19D0"/>
            <Item ID="0x19D1"/>
            <Item ID="0x19D2"/>
            <Item ID="0x2AC0"/>
            <Item ID="0x2AC3"/>
            <Item ID="0x2AC6"/>
            <Item ID="0x35E9"/>
        </Group>
        <Group name="Furniture">
            <Group name="Bedding">
                <Item ID="0x0A55"/>
                <Item ID="0x0A56"/>
                <Item ID="0x0A57"/>
                <Item ID="0x0A58"/>
                <Item ID="0x0A59"/>
                <Item ID="0x0A6C"/>
                <Item ID="0x0A6D"/>
                <Item ID="0x0A6E"/>
                <Item ID="0x0A6F"/>
                <Item ID="0x0A92"/>
                <Item ID="0x0A93"/>
                <Item ID="0x0A94"/>
                <Item ID="0x0A95"/>
                <Item ID="0x11E2"/>
                <Item ID="0x11E3"/>
                <Item ID="0x11E4"/>
                <Item ID="0x11E5"/>
                <Item ID="0x11E6"/>
                <Item ID="0x11E7"/>
                <Item ID="0x11E8"/>
                <Item ID="0x11E9"/>
                <Item ID="0x11EA"/>
                <Item ID="0x11EB"/>
                <Item ID="0x1397"/>
                <Item ID="0x13A4"/>
                <Item ID="0x13A5"/>
                <Item ID="0x13A6"/>
                <Item ID="0x13A7"/>
                <Item ID="0x13A8"/>
                <Item ID="0x13A9"/>
                <Item ID="0x13AA"/>
                <Item ID="0x13AB"/>
                <Item ID="0x13AC"/>
                <Item ID="0x13AD"/>
                <Item ID="0x13AE"/>
                <Item ID="0x163a"/>
                <Item ID="0x163b"/>
                <Item ID="0x163c"/>
                <Item ID="0x1f24"/>
                <Item ID="0x1f25"/>
                <Item ID="0x1f26"/>
                <Item ID="0x1f27"/>
                <Item ID="0x1f73"/>
                <Item ID="0x1f74"/>
                <Item ID="0x1f75"/>
                <Item ID="0x1f76"/>
                <Item ID="0x1f77"/>
                <Item ID="0x1f78"/>
                <Item ID="0x1f79"/>
                <Item ID="0x1f7a"/>
                <Item ID="0x28a4"/>
                <Item ID="0x28a5"/>
                <Item ID="0x28a6"/>
                <Item ID="0x28a7"/>
                <Item ID="0x28a8"/>
                <Item ID="0x28a9"/>
                <Item ID="0x28aa"/>
                <Item ID="0x28ab"/>
                <Item ID="0x28ac"/>
                <Item ID="0x28ad"/>
                <Item ID="0x28ae"/>
                <Item ID="0x28af"/>
            </Group>
            <Group name="Curtained Furniture">
                <Item ID="0x0C17"/>
                <Item ID="0x0C18"/>
                <Item ID="0x0C31"/>
                <Item ID="0x0C32"/>
                <Item ID="0x0C33"/>
                <Item ID="0x0C34"/>
                <Item ID="0x0C35"/>
                <Item ID="0x0C36"/>
            </Group>
            <Group name="Damage">
                <Item ID="0x0C10"/>
                <Item ID="0x0C11"/>
                <Item ID="0x0C12"/>
                <Item ID="0x0C13"/>
                <Item ID="0x0C14"/>
                <Item ID="0x0C15"/>
                <Item ID="0x0C19"/>
                <Item ID="0x0C1A"/>
                <Item ID="0x0C1B"/>
                <Item ID="0x0C1C"/>
                <Item ID="0x0C1D"/>
                <Item ID="0x0C1E"/>
                <Item ID="0x0C1F"/>
                <Item ID="0x0C20"/>
                <Item ID="0x0C21"/>
                <Item ID="0x0C22"/>
                <Item ID="0x0C23"/>
                <Item ID="0x0C24"/>
                <Item ID="0x0C25"/>
                <Item ID="0x0C26"/>
                <Item ID="0x0C27"/>
                <Item ID="0x0C28"/>
                <Item ID="0x0C29"/>
                <Item ID="0x0C2A"/>
                <Item ID="0x0C2B"/>
                <Item ID="0x1894"/>
                <Item ID="0x1895"/>
                <Item ID="0x1896"/>
                <Item ID="0x1897"/>
                <Item ID="0x1898"/>
                <Item ID="0x1899"/>
                <Item ID="0x189a"/>
                <Item ID="0x189b"/>
                <Item ID="0x398c"/>
                <Item ID="0x3996"/>
                <Item ID="0x3d8a"/>
                <Item ID="0x3d8b"/>
                <Item ID="0x3d8c"/>
                <Item ID="0x3d8d"/>
                <Item ID="0x3d90"/>
                <Item ID="0x3d91"/>
                <Item ID="0x3d92"/>
                <Item ID="0x3d93"/>
                <Item ID="0x3e27"/>
                <Item ID="0x3e31"/>
            </Group>
            <Group name="Elfish Furniture">
                <Item ID="0x2D05"/>
                <Item ID="0x2D06"/>
                <Item ID="0x2D07"/>
                <Item ID="0x2D08"/>
                <Item ID="0x2D09"/>
                <Item ID="0x2D0A"/>
                <Item ID="0x2D0B"/>
                <Item ID="0x2D0C"/>
                <Item ID="0x2DD5"/>
                <Item ID="0x2DD6"/>
                <Item ID="0x2DD7"/>
                <Item ID="0x2DD8"/>
                <Item ID="0x2DD9"/>
                <Item ID="0x2DDA"/>
                <Item ID="0x2DDB"/>
                <Item ID="0x2DDC"/>
                <Item ID="0x2DDD"/>
                <Item ID="0x2DDE"/>
                <Item ID="0x2DDF"/>
                <Item ID="0x2DE0"/>
                <Item ID="0x2DE1"/>
                <Item ID="0x2DE2"/>
                <Item ID="0x2DE3"/>
                <Item ID="0x2DE4"/>
                <Item ID="0x2DE5"/>
                <Item ID="0x2DE6"/>
                <Item ID="0x2DE7"/>
                <Item ID="0x2DE8"/>
                <Item ID="0x2DE9"/>
                <Item ID="0x2DEA"/>
                <Item ID="0x2DEB"/>
                <Item ID="0x2DEC"/>
                <Item ID="0x2DED"/>
                <Item ID="0x2DEE"/>
                <Item ID="0x2DEF"/>
                <Item ID="0x2DF0"/>
                <Item ID="0x2DF1"/>
                <Item ID="0x2DF2"/>
                <Item ID="0x2DF3"/>
                <Item ID="0x2DF4"/>
                <Item ID="0x2DF5"/>
                <Item ID="0x2DF6"/>
                <Item ID="0x30df"/>
                <Item ID="0x30e0"/>
                <Item ID="0x30e1"/>
                <Item ID="0x30e2"/>
                <Item ID="0x30e3"/>
                <Item ID="0x30e4"/>
                <Item ID="0x30e5"/>
                <Item ID="0x30e6"/>
            </Group>
            <Group name="Large Beds">
                <Item ID="0x0A70"/>
                <Item ID="0x0A71"/>
                <Item ID="0x0A72"/>
                <Item ID="0x0A73"/>
                <Item ID="0x0A74"/>
                <Item ID="0x0A75"/>
                <Item ID="0x0A76"/>
                <Item ID="0x0A77"/>
                <Item ID="0x0A78"/>
                <Item ID="0x0A79"/>
                <Item ID="0x0A79"/>
                <Item ID="0x0A7A"/>
                <Item ID="0x0A7B"/>
                <Item ID="0x0A7C"/>
                <Item ID="0x0A7D"/>
                <Item ID="0x0A7E"/>
                <Item ID="0x0A7E"/>
                <Item ID="0x0A7E"/>
                <Item ID="0x0A7F"/>
                <Item ID="0x0A7F"/>
                <Item ID="0x0A80"/>
                <Item ID="0x0A81"/>
                <Item ID="0x0A82"/>
                <Item ID="0x0A83"/>
                <Item ID="0x0A84"/>
                <Item ID="0x0A85"/>
                <Item ID="0x0A86"/>
                <Item ID="0x0A87"/>
                <Item ID="0x0A88"/>
                <Item ID="0x0A89"/>
                <Item ID="0x0A8A"/>
                <Item ID="0x0A8B"/>
                <Item ID="0x0A8C"/>
                <Item ID="0x0A8C"/>
                <Item ID="0x0A8D"/>
                <Item ID="0x0A8D"/>
                <Item ID="0x0A8E"/>
                <Item ID="0x0A8F"/>
                <Item ID="0x0A90"/>
                <Item ID="0x0A91"/>
                <Item ID="0x0db0"/>
                <Item ID="0x0db1"/>
                <Item ID="0x0db2"/>
                <Item ID="0x0db3"/>
                <Item ID="0x0db4"/>
                <Item ID="0x0db5"/>
                <Item ID="0x11ce"/>
                <Item ID="0x11cf"/>
                <Item ID="0x11d0"/>
                <Item ID="0x11d1"/>
                <Item ID="0x11d2"/>
                <Item ID="0x11d3"/>
                <Item ID="0x11d4"/>
                <Item ID="0x11d5"/>
                <Item ID="0x3052"/>
                <Item ID="0x3053"/>
                <Item ID="0x3054"/>
                <Item ID="0x3055"/>
                <Item ID="0x3056"/>
                <Item ID="0x3057"/>
                <Item ID="0x3058"/>
                <Item ID="0x3059"/>
            </Group>
            <Group name="Shelf etc.">
                <Item ID="0x0A2C"/>
                <Item ID="0x0A30"/>
                <Item ID="0x0A34"/>
                <Item ID="0x0A38"/>
                <Item ID="0x0A3C"/>
                <Item ID="0x0A3D"/>
                <Item ID="0x0A44"/>
                <Item ID="0x0A45"/>
                <Item ID="0x0A4D"/>
                <Item ID="0x0A4F"/>
                <Item ID="0x0A51"/>
                <Item ID="0x0A53"/>
                <Item ID="0x0A97"/>
                <Item ID="0x0A98"/>
                <Item ID="0x0A99"/>
                <Item ID="0x0A9A"/>
                <Item ID="0x0A9B"/>
                <Item ID="0x0A9C"/>
                <Item ID="0x0A9D"/>
                <Item ID="0x0A9E"/>
                <Item ID="0x2DE9"/>
                <Item ID="0x2DEA"/>
                <Item ID="0x2DEF"/>
                <Item ID="0x2DF0"/>
                <Item ID="0x2DF1"/>
                <Item ID="0x2DF2"/>
                <Item ID="0x2DF3"/>
                <Item ID="0x2DF4"/>
                <Item ID="0x2bd7"/>
                <Item ID="0x2bd8"/>
                <Item ID="0x3084"/>
                <Item ID="0x3085"/>
                <Item ID="0x3086"/>
                <Item ID="0x3087"/>
                <Item ID="0x3098"/>
                <Item ID="0x3099"/>
                <Item ID="0x309a"/>
                <Item ID="0x309b"/>
                <Item ID="0x3605"/>
                <Item ID="0x3606"/>
                <Item ID="0x3607"/>
                <Item ID="0x3608"/>
            </Group>
            <Group name="Single Beds">
                <Item ID="0x0A5A"/>
                <Item ID="0x0A5B"/>
                <Item ID="0x0A5C"/>
                <Item ID="0x0A5D"/>
                <Item ID="0x0A5E"/>
                <Item ID="0x0A5F"/>
                <Item ID="0x0A60"/>
                <Item ID="0x0A61"/>
                <Item ID="0x0A62"/>
                <Item ID="0x0A63"/>
                <Item ID="0x0A66"/>
                <Item ID="0x0A67"/>
                <Item ID="0x0A68"/>
                <Item ID="0x0A68"/>
                <Item ID="0x0A69"/>
                <Item ID="0x0A6A"/>
                <Item ID="0x0A6B"/>
                <Item ID="0x0A6B"/>
                <Item ID="0x11F0"/>
                <Item ID="0x11F1"/>
                <Item ID="0x11F2"/>
                <Item ID="0x11F3"/>
                <Item ID="0x11F4"/>
                <Item ID="0x11F6"/>
                <Item ID="0x11F8"/>
                <Item ID="0x11FD"/>
                <Item ID="0x11FE"/>
                <Item ID="0x11FF"/>
                <Item ID="0x11Fa"/>
                <Item ID="0x1200"/>
                <Item ID="0x295C"/>
                <Item ID="0x295D"/>
                <Item ID="0x295E"/>
                <Item ID="0x295F"/>
                <Item ID="0x304C"/>
                <Item ID="0x304D"/>
                <Item ID="0x3050"/>
                <Item ID="0x3051"/>
            </Group>
            <Group name="Sitting">
                <Item ID="0x0459"/>
                <Item ID="0x045A"/>
                <Item ID="0x045B"/>
                <Item ID="0x045C"/>
                <Item ID="0x0A2A"/>
                <Item ID="0x0A2B"/>
                <Item ID="0x0B2C"/>
                <Item ID="0x0B2D"/>
                <Item ID="0x0B2E"/>
                <Item ID="0x0B2F"/>
                <Item ID="0x0B30"/>
                <Item ID="0x0B31"/>
                <Item ID="0x0B32"/>
                <Item ID="0x0B33"/>
                <Item ID="0x0B4E"/>
                <Item ID="0x0B4F"/>
                <Item ID="0x0B50"/>
                <Item ID="0x0B51"/>
                <Item ID="0x0B52"/>
                <Item ID="0x0B53"/>
                <Item ID="0x0B54"/>
                <Item ID="0x0B55"/>
                <Item ID="0x0B56"/>
                <Item ID="0x0B57"/>
                <Item ID="0x0B58"/>
                <Item ID="0x0B59"/>
                <Item ID="0x0B5A"/>
                <Item ID="0x0B5B"/>
                <Item ID="0x0B5C"/>
                <Item ID="0x0B5D"/>
                <Item ID="0x0B5E"/>
                <Item ID="0x0B5F"/>
                <Item ID="0x0B60"/>
                <Item ID="0x0B61"/>
                <Item ID="0x0B62"/>
                <Item ID="0x0B63"/>
                <Item ID="0x0B64"/>
                <Item ID="0x0B65"/>
                <Item ID="0x0B66"/>
                <Item ID="0x0B67"/>
                <Item ID="0x0B68"/>
                <Item ID="0x0B69"/>
                <Item ID="0x0B6A"/>
                <Item ID="0x0B91"/>
                <Item ID="0x0B92"/>
                <Item ID="0x0B93"/>
                <Item ID="0x0B94"/>
                <Item ID="0x0E50"/>
                <Item ID="0x0E51"/>
                <Item ID="0x0E52"/>
                <Item ID="0x0E53"/>
                <Item ID="0x11FC"/>
                <Item ID="0x1207"/>
                <Item ID="0x1208"/>
                <Item ID="0x1209"/>
                <Item ID="0x120a"/>
                <Item ID="0x120b"/>
                <Item ID="0x120c"/>
                <Item ID="0x1218"/>
                <Item ID="0x1219"/>
                <Item ID="0x1220"/>
                <Item ID="0x1221"/>
                <Item ID="0x1526"/>
                <Item ID="0x1527"/>
                <Item ID="0x1dc7"/>
                <Item ID="0x1dc8"/>
                <Item ID="0x1dc9"/>
                <Item ID="0x1dca"/>
                <Item ID="0x1dcb"/>
                <Item ID="0x1dcc"/>
                <Item ID="0x1dcd"/>
                <Item ID="0x1dce"/>
                <Item ID="0x1dcf"/>
                <Item ID="0x1dd0"/>
                <Item ID="0x1dd1"/>
                <Item ID="0x1dd2"/>
                <Item ID="0x2DE3"/>
                <Item ID="0x2DE4"/>
                <Item ID="0x2DE5"/>
                <Item ID="0x2DE6"/>
                <Item ID="0x2DEB"/>
                <Item ID="0x2DEC"/>
                <Item ID="0x2DED"/>
                <Item ID="0x2DEE"/>
                <Item ID="0x3088"/>
                <Item ID="0x3089"/>
                <Item ID="0x308a"/>
                <Item ID="0x308b"/>
                <Item ID="0x319A"/>
                <Item ID="0x319b"/>
                <Item ID="0x35ED"/>
                <Item ID="0x35EE"/>
                <Item ID="0x3dff"/>
                <Item ID="0x3e00"/>
            </Group>
            <Group name="Stone Fireplaces + Oven">
                <Item ID="0x045D"/>
                <Item ID="0x045E"/>
                <Item ID="0x045F"/>
                <Item ID="0x0460"/>
                <Item ID="0x0461"/>
                <Item ID="0x0462"/>
                <Item ID="0x046E"/>
                <Item ID="0x046F"/>
                <Item ID="0x0475"/>
                <Item ID="0x047B"/>
                <Item ID="0x0482"/>
                <Item ID="0x0489"/>
                <Item ID="0x07D6"/>
                <Item ID="0x07D9"/>
                <Item ID="0x08CF"/>
                <Item ID="0x08D0"/>
                <Item ID="0x08D1"/>
                <Item ID="0x08D2"/>
                <Item ID="0x08D3"/>
                <Item ID="0x08D4"/>
                <Item ID="0x08D5"/>
                <Item ID="0x08D6"/>
                <Item ID="0x08D8"/>
                <Item ID="0x08D9"/>
                <Item ID="0x08DA"/>
                <Item ID="0x08DB"/>
                <Item ID="0x08DC"/>
                <Item ID="0x08DD"/>
                <Item ID="0x08DE"/>
                <Item ID="0x08DF"/>
                <Item ID="0x092B"/>
                <Item ID="0x092C"/>
                <Item ID="0x0930"/>
                <Item ID="0x0931"/>
                <Item ID="0x0935"/>
                <Item ID="0x0936"/>
                <Item ID="0x0937"/>
                <Item ID="0x093D"/>
                <Item ID="0x0943"/>
                <Item ID="0x0944"/>
                <Item ID="0x0945"/>
                <Item ID="0x094B"/>
                <Item ID="0x0951"/>
                <Item ID="0x0952"/>
                <Item ID="0x0953"/>
                <Item ID="0x0959"/>
                <Item ID="0x095F"/>
                <Item ID="0x0960"/>
                <Item ID="0x0961"/>
                <Item ID="0x0967"/>
                <Item ID="0x11ec"/>
                <Item ID="0x11ed"/>
                <Item ID="0x11ee"/>
                <Item ID="0x11ef"/>
                <Item ID="0x2350"/>
                <Item ID="0x2351"/>
                <Item ID="0x2352"/>
                <Item ID="0x2358"/>
                <Item ID="0x235e"/>
                <Item ID="0x235f"/>
                <Item ID="0x2360"/>
                <Item ID="0x2366"/>
                <Item ID="0x29FD"/>
                <Item ID="0x2A04"/>
                <Item ID="0x2DDB"/>
                <Item ID="0x2DDC"/>
                <Item ID="0x3728"/>
            </Group>
            <Group name="Table">
                <Item ID="0x0B34"/>
                <Item ID="0x0B35"/>
                <Item ID="0x0B37"/>
                <Item ID="0x0B38"/>
                <Item ID="0x0B3C"/>
                <Item ID="0x0B3D"/>
                <Item ID="0x0B3E"/>
                <Item ID="0x0B3F"/>
                <Item ID="0x0B40"/>
                <Item ID="0x0B49"/>
                <Item ID="0x0B4A"/>
                <Item ID="0x0B4B"/>
                <Item ID="0x0B4C"/>
                <Item ID="0x0B6B"/>
                <Item ID="0x0B6C"/>
                <Item ID="0x0B6D"/>
                <Item ID="0x0B6E"/>
                <Item ID="0x0B6F"/>
                <Item ID="0x0B70"/>
                <Item ID="0x0B71"/>
                <Item ID="0x0B72"/>
                <Item ID="0x0B73"/>
                <Item ID="0x0B73"/>
                <Item ID="0x0B74"/>
                <Item ID="0x0B75"/>
                <Item ID="0x0B76"/>
                <Item ID="0x0B77"/>
                <Item ID="0x0B78"/>
                <Item ID="0x0B79"/>
                <Item ID="0x0B7A"/>
                <Item ID="0x0B7A"/>
                <Item ID="0x0B7D"/>
                <Item ID="0x0B7E"/>
                <Item ID="0x0B7F"/>
                <Item ID="0x0B80"/>
                <Item ID="0x0B81"/>
                <Item ID="0x0B82"/>
                <Item ID="0x0B83"/>
                <Item ID="0x0B84"/>
                <Item ID="0x0B85"/>
                <Item ID="0x0B86"/>
                <Item ID="0x0B86"/>
                <Item ID="0x0B87"/>
                <Item ID="0x0B88"/>
                <Item ID="0x0B89"/>
                <Item ID="0x0B8A"/>
                <Item ID="0x0B8B"/>
                <Item ID="0x0B8C"/>
                <Item ID="0x0B8D"/>
                <Item ID="0x0B8E"/>
                <Item ID="0x0B90"/>
                <Item ID="0x118B"/>
                <Item ID="0x118C"/>
                <Item ID="0x118D"/>
                <Item ID="0x118E"/>
                <Item ID="0x118F"/>
                <Item ID="0x1190"/>
                <Item ID="0x1191"/>
                <Item ID="0x1192"/>
                <Item ID="0x11D6"/>
                <Item ID="0x11D7"/>
                <Item ID="0x11D8"/>
                <Item ID="0x11D9"/>
                <Item ID="0x11DA"/>
                <Item ID="0x11DB"/>
                <Item ID="0x11DC"/>
                <Item ID="0x11DD"/>
                <Item ID="0x11DE"/>
                <Item ID="0x11DF"/>
                <Item ID="0x11E0"/>
                <Item ID="0x11E1"/>
                <Item ID="0x1201"/>
                <Item ID="0x1202"/>
                <Item ID="0x1203"/>
                <Item ID="0x1204"/>
                <Item ID="0x1205"/>
                <Item ID="0x1206"/>
                <Item ID="0x1667"/>
                <Item ID="0x1668"/>
                <Item ID="0x1669"/>
                <Item ID="0x166A"/>
                <Item ID="0x166B"/>
                <Item ID="0x166C"/>
                <Item ID="0x1DBB"/>
                <Item ID="0x1DBC"/>
                <Item ID="0x1DBD"/>
                <Item ID="0x1DBE"/>
                <Item ID="0x1DBF"/>
                <Item ID="0x1DC0"/>
                <Item ID="0x1DC1"/>
                <Item ID="0x1DC2"/>
                <Item ID="0x1DC3"/>
                <Item ID="0x1DC4"/>
                <Item ID="0x1DC5"/>
                <Item ID="0x1DC6"/>
                <Item ID="0x1da5"/>
                <Item ID="0x1da6"/>
                <Item ID="0x1da7"/>
                <Item ID="0x1da8"/>
                <Item ID="0x1da9"/>
                <Item ID="0x1daa"/>
                <Item ID="0x1dab"/>
                <Item ID="0x1dac"/>
                <Item ID="0x207e"/>
                <Item ID="0x207f"/>
                <Item ID="0x2819"/>
                <Item ID="0x281A"/>
                <Item ID="0x2D4B"/>
                <Item ID="0x2D4C"/>
                <Item ID="0x2D4D"/>
                <Item ID="0x2D4E"/>
                <Item ID="0x2DDD"/>
                <Item ID="0x2DDE"/>
                <Item ID="0x2DE1"/>
                <Item ID="0x2DE2"/>
                <Item ID="0x2DE7"/>
                <Item ID="0x2DE8"/>
                <Item ID="0x308c"/>
                <Item ID="0x308d"/>
                <Item ID="0x308e"/>
                <Item ID="0x308f"/>
                <Item ID="0x3090"/>
                <Item ID="0x3091"/>
                <Item ID="0x3092"/>
                <Item ID="0x3093"/>
                <Item ID="0x3094"/>
                <Item ID="0x3095"/>
                <Item ID="0x3096"/>
                <Item ID="0x3097"/>
            </Group>
        </Group>
        <Group name="Leaves, Branches, Trash">
            <Item ID="0x0911"/>
            <Item ID="0x0912"/>
            <Item ID="0x0913"/>
            <Item ID="0x0914"/>
            <Item ID="0x10Ee"/>
            <Item ID="0x10Ef"/>
            <Item ID="0x10f0"/>
            <Item ID="0x10f1"/>
            <Item ID="0x10f2"/>
            <Item ID="0x10f3"/>
            <Item ID="0x17cD"/>
            <Item ID="0x17cE"/>
            <Item ID="0x187e"/>
            <Item ID="0x187f"/>
            <Item ID="0x1880"/>
            <Item ID="0x1881"/>
            <Item ID="0x1B1F"/>
            <Item ID="0x1B20"/>
            <Item ID="0x1B21"/>
            <Item ID="0x1B22"/>
            <Item ID="0x1B23"/>
            <Item ID="0x1B24"/>
            <Item ID="0x1B25"/>
            <Item ID="0x1B26"/>
            <Item ID="0x1B81"/>
            <Item ID="0x1B82"/>
            <Item ID="0x1B83"/>
            <Item ID="0x1B84"/>
            <Item ID="0x1B85"/>
            <Item ID="0x1B86"/>
            <Item ID="0x1B87"/>
            <Item ID="0x1B88"/>
            <Item ID="0x1B89"/>
            <Item ID="0x1B8A"/>
            <Item ID="0x1B8B"/>
            <Item ID="0x1B8C"/>
            <Item ID="0x1B8D"/>
            <Item ID="0x1B8E"/>
            <Item ID="0x1B8F"/>
            <Item ID="0x1B90"/>
            <Item ID="0x1B91"/>
            <Item ID="0x1B92"/>
            <Item ID="0x1B93"/>
            <Item ID="0x1B97"/>
            <Item ID="0x1B98"/>
            <Item ID="0x1B99"/>
            <Item ID="0x1B9A"/>
            <Item ID="0x1B9B"/>
            <Item ID="0x1B9C"/>
            <Item ID="0x1B9D"/>
            <Item ID="0x1B9E"/>
            <Item ID="0x1B9F"/>
            <Item ID="0x1BA0"/>
            <Item ID="0x1BA1"/>
            <Item ID="0x1BA2"/>
            <Item ID="0x1BA3"/>
            <Item ID="0x1BA4"/>
            <Item ID="0x1BA5"/>
            <Item ID="0x1BA6"/>
            <Item ID="0x1BA7"/>
            <Item ID="0x1BA8"/>
            <Item ID="0x1BA9"/>
            <Item ID="0x1BAA"/>
            <Item ID="0x1BAB"/>
            <Item ID="0x1BAC"/>
            <Item ID="0x1BAD"/>
            <Item ID="0x1BAE"/>
            <Item ID="0x1BAF"/>
            <Item ID="0x1BB0"/>
            <Item ID="0x1BB1"/>
            <Item ID="0x1BB2"/>
            <Item ID="0x1BB4"/>
            <Item ID="0x1BB5"/>
            <Item ID="0x1BB6"/>
            <Item ID="0x1BB7"/>
            <Item ID="0x1BB8"/>
            <Item ID="0x1BB9"/>
            <Item ID="0x1BBA"/>
            <Item ID="0x1BBB"/>
            <Item ID="0x1BBC"/>
            <Item ID="0x1BBD"/>
            <Item ID="0x1db3"/>
            <Item ID="0x1db4"/>
            <Item ID="0x1db5"/>
            <Item ID="0x1db6"/>
            <Item ID="0x223a"/>
            <Item ID="0x223b"/>
            <Item ID="0x223c"/>
            <Item ID="0x223d"/>
            <Item ID="0x223e"/>
            <Item ID="0x223f"/>
            <Item ID="0x2240"/>
            <Item ID="0x2241"/>
            <Item ID="0x2242"/>
            <Item ID="0x2243"/>
            <Item ID="0x2244"/>
            <Item ID="0x2245"/>
            <Item ID="0x2246"/>
            <Item ID="0x2247"/>
            <Item ID="0x2248"/>
            <Item ID="0x2249"/>
        </Group>
        <Group name="Light Sources">
            <Item ID="0x09FB"/>
            <Item ID="0x09FC"/>
            <Item ID="0x09FE"/>
            <Item ID="0x0A00"/>
            <Item ID="0x0A01"/>
            <Item ID="0x0A03"/>
            <Item ID="0x0A05"/>
            <Item ID="0x0A06"/>
            <Item ID="0x0A07"/>
            <Item ID="0x0A0A"/>
            <Item ID="0x0A0B"/>
            <Item ID="0x0A0C"/>
            <Item ID="0x0A0F"/>
            <Item ID="0x0A13"/>
            <Item ID="0x0A15"/>
            <Item ID="0x0A18"/>
            <Item ID="0x0A1A"/>
            <Item ID="0x0A1D"/>
            <Item ID="0x0A1F"/>
            <Item ID="0x0A20"/>
            <Item ID="0x0A22"/>
            <Item ID="0x0A25"/>
            <Item ID="0x0A26"/>
            <Item ID="0x0A27"/>
            <Item ID="0x0A28"/>
            <Item ID="0x0A29"/>
            <Item ID="0x0B1A"/>
            <Item ID="0x0B1D"/>
            <Item ID="0x0B20"/>
            <Item ID="0x0B21"/>
            <Item ID="0x0B22"/>
            <Item ID="0x0B23"/>
            <Item ID="0x0B24"/>
            <Item ID="0x0B25"/>
            <Item ID="0x0B26"/>
            <Item ID="0x0DE1"/>
            <Item ID="0x0DE3"/>
            <Item ID="0x0DEa"/>
            <Item ID="0x0FAC"/>
            <Item ID="0x142C"/>
            <Item ID="0x142F"/>
            <Item ID="0x1430"/>
            <Item ID="0x1433"/>
            <Item ID="0x1434"/>
            <Item ID="0x1437"/>
            <Item ID="0x1646"/>
            <Item ID="0x1647"/>
            <Item ID="0x1849"/>
            <Item ID="0x184d"/>
            <Item ID="0x184e"/>
            <Item ID="0x1850"/>
            <Item ID="0x1853"/>
            <Item ID="0x1854"/>
            <Item ID="0x1857"/>
            <Item ID="0x1858"/>
            <Item ID="0x19AA"/>
            <Item ID="0x19Ab"/>
            <Item ID="0x19bb"/>
            <Item ID="0x1f2b"/>
            <Item ID="0x2419"/>
            <Item ID="0x24BB"/>
            <Item ID="0x24BC"/>
            <Item ID="0x24BD"/>
            <Item ID="0x24BE"/>
            <Item ID="0x24BF"/>
            <Item ID="0x24C0"/>
            <Item ID="0x24C1"/>
            <Item ID="0x24C2"/>
            <Item ID="0x24C3"/>
            <Item ID="0x24C4"/>
            <Item ID="0x24C5"/>
            <Item ID="0x24C6"/>
            <Item ID="0x24C7"/>
            <Item ID="0x24C8"/>
            <Item ID="0x24C9"/>
            <Item ID="0x24CA"/>
            <Item ID="0x29FD"/>
            <Item ID="0x2A04"/>
            <Item ID="0x35EF"/>
            <Item ID="0x3d94"/>
            <Item ID="0x3d97"/>
            <Item ID="0x3d98"/>
            <Item ID="0x3d9b"/>
        </Group>
        <Group name="Misc">
            <Item ID="0x241C"/>
            <Item ID="0x241D"/>
            <Item ID="0x241E"/>
            <Item ID="0x24CB"/>
            <Item ID="0x24CC"/>
            <Item ID="0x24CD"/>
            <Item ID="0x24CE"/>
            <Item ID="0x24CF"/>
            <Item ID="0x24D0"/>
            <Item ID="0x24D1"/>
            <Item ID="0x24D2"/>
            <Item ID="0x24D3"/>
            <Item ID="0x24D4"/>
        </Group>
        <Group name="Professions">
            <Group name="Animal Handling">
                <Item ID="0x091A"/>
                <Item ID="0x091B"/>
                <Item ID="0x0B41"/>
                <Item ID="0x0B42"/>
                <Item ID="0x0B43"/>
                <Item ID="0x0B44"/>
                <Item ID="0x0F34"/>
                <Item ID="0x0F35"/>
                <Item ID="0x0F36"/>
                <Item ID="0x0F37"/>
                <Item ID="0x0F38"/>
                <Item ID="0x0F3B"/>
                <Item ID="0x0F3C"/>
                <Item ID="0x0FB6"/>
                <Item ID="0x0FFA"/>
                <Item ID="0x1036"/>
                <Item ID="0x1037"/>
                <Item ID="0x1038"/>
                <Item ID="0x1370"/>
                <Item ID="0x1371"/>
                <Item ID="0x1372"/>
                <Item ID="0x1373"/>
                <Item ID="0x1374"/>
                <Item ID="0x1375"/>
                <Item ID="0x1376"/>
                <Item ID="0x1377"/>
                <Item ID="0x1378"/>
                <Item ID="0x1379"/>
                <Item ID="0x1420"/>
                <Item ID="0x1421"/>
                <Item ID="0x1422"/>
                <Item ID="0x1423"/>
                <Item ID="0x1424"/>
                <Item ID="0x1425"/>
                <Item ID="0x1426"/>
                <Item ID="0x1427"/>
                <Item ID="0x1428"/>
                <Item ID="0x1429"/>
                <Item ID="0x142A"/>
                <Item ID="0x142B"/>
                <Item ID="0x14E0"/>
                <Item ID="0x14E7"/>
                <Item ID="0x14E8"/>
                <Item ID="0x172e"/>
                <Item ID="0x1Ad4"/>
                <Item ID="0x1Ad5"/>
                <Item ID="0x2004"/>
                <Item ID="0x26b1"/>
                <Item ID="0x26b2"/>
                <Item ID="0x26b3"/>
                <Item ID="0x26b4"/>
                <Item ID="0x26b5"/>
                <Item ID="0x26b6"/>
                <Item ID="0x312D"/>
                <Item ID="0x312E"/>
                <Item ID="0x312F"/>
                <Item ID="0x3130"/>
                <Item ID="0x3BB8"/>
                <Item ID="0x3BB9"/>
                <Item ID="0x3BBa"/>
            </Group>
            <Group name="Arcana">
                <Group name="Alchemic Vials etc.">
                    <Item ID="0x0E24"/>
                    <Item ID="0x0E25"/>
                    <Item ID="0x0E26"/>
                    <Item ID="0x0E27"/>
                    <Item ID="0x0E28"/>
                    <Item ID="0x0E29"/>
                    <Item ID="0x0E2A"/>
                    <Item ID="0x0E2B"/>
                    <Item ID="0x0E2C"/>
                    <Item ID="0x0E9B"/>
                    <Item ID="0x0EFB"/>
                    <Item ID="0x0EFC"/>
                    <Item ID="0x0EFD"/>
                    <Item ID="0x0EFE"/>
                    <Item ID="0x0EFF"/>
                    <Item ID="0x0F00"/>
                    <Item ID="0x0F01"/>
                    <Item ID="0x0F02"/>
                    <Item ID="0x0F03"/>
                    <Item ID="0x0F04"/>
                    <Item ID="0x0F06"/>
                    <Item ID="0x0F07"/>
                    <Item ID="0x0F08"/>
                    <Item ID="0x0F09"/>
                    <Item ID="0x0F0A"/>
                    <Item ID="0x0F0B"/>
                    <Item ID="0x0F0C"/>
                    <Item ID="0x0F0D"/>
                    <Item ID="0x0F0E"/>
                    <Item ID="0x0f53"/>
                    <Item ID="0x1084"/>
                    <Item ID="0x1829"/>
                    <Item ID="0x182A"/>
                    <Item ID="0x182B"/>
                    <Item ID="0x182C"/>
                    <Item ID="0x182D"/>
                    <Item ID="0x182E"/>
                    <Item ID="0x182F"/>
                    <Item ID="0x1830"/>
                    <Item ID="0x1831"/>
                    <Item ID="0x1832"/>
                    <Item ID="0x1833"/>
                    <Item ID="0x1834"/>
                    <Item ID="0x1835"/>
                    <Item ID="0x1836"/>
                    <Item ID="0x1837"/>
                    <Item ID="0x1838"/>
                    <Item ID="0x1839"/>
                    <Item ID="0x183A"/>
                    <Item ID="0x183B"/>
                    <Item ID="0x183C"/>
                    <Item ID="0x183D"/>
                    <Item ID="0x183E"/>
                    <Item ID="0x1841"/>
                    <Item ID="0x1844"/>
                    <Item ID="0x1847"/>
                    <Item ID="0x1848"/>
                    <Item ID="0x185B"/>
                    <Item ID="0x185C"/>
                    <Item ID="0x185D"/>
                    <Item ID="0x185E"/>
                    <Item ID="0x21fe"/>
                </Group>
                <Group name="Decoration">
                    <Item ID="0x0E44"/>
                    <Item ID="0x0E45"/>
                    <Item ID="0x0E46"/>
                    <Item ID="0x0E47"/>
                    <Item ID="0x0E48"/>
                    <Item ID="0x0E49"/>
                    <Item ID="0x0E4A"/>
                    <Item ID="0x0E4B"/>
                    <Item ID="0x0E4C"/>
                    <Item ID="0x0E4D"/>
                    <Item ID="0x0E4E"/>
                    <Item ID="0x0E4F"/>
                    <Item ID="0x1005"/>
                    <Item ID="0x1006"/>
                    <Item ID="0x1007"/>
                    <Item ID="0x10FC"/>
                    <Item ID="0x110F"/>
                    <Item ID="0x1AD6"/>
                    <Item ID="0x1AD7"/>
                    <Item ID="0x1F18"/>
                    <Item ID="0x1F19"/>
                    <Item ID="0x1F1C"/>
                    <Item ID="0x1F1F"/>
                    <Item ID="0x1F20"/>
                    <Item ID="0x1F21"/>
                    <Item ID="0x1F22"/>
                    <Item ID="0x2A93"/>
                    <Item ID="0x2A94"/>
                    <Item ID="0x2AA1"/>
                    <Item ID="0x2AA2"/>
                    <Item ID="0x2AA3"/>
                    <Item ID="0x2AA4"/>
                    <Item ID="0x2AA5"/>
                    <Item ID="0x2AA6"/>
                    <Item ID="0x2AA7"/>
                    <Item ID="0x2AA8"/>
                    <Item ID="0x2AA9"/>
                    <Item ID="0x2ADC"/>
                    <Item ID="0x2ADd"/>
                    <Item ID="0x2AEC"/>
                    <Item ID="0x2AEd"/>
                    <Item ID="0x307B"/>
                    <Item ID="0x307C"/>
                    <Item ID="0x307D"/>
                    <Item ID="0x307E"/>
                    <Item ID="0x307F"/>
                    <Item ID="0x3080"/>
                    <Item ID="0x3081"/>
                    <Item ID="0x3082"/>
                    <Item ID="0x3083"/>
                    <Item ID="0x314c"/>
                    <Item ID="0x314d"/>
                    <Item ID="0x314e"/>
                    <Item ID="0x314f"/>
                    <Item ID="0x3150"/>
                    <Item ID="0x3151"/>
                    <Item ID="0x3152"/>
                    <Item ID="0x3153"/>
                    <Item ID="0x3154"/>
                    <Item ID="0x32F3"/>
                    <Item ID="0x32F4"/>
                    <Item ID="0x3660"/>
                </Group>
                <Group name="Effects">
                    <Item ID="0x0dda"/>
                    <Item ID="0x1153"/>
                    <Item ID="0x1ed9"/>
                    <Item ID="0x1ee2"/>
                    <Item ID="0x1eeb"/>
                    <Item ID="0x1ef4"/>
                    <Item ID="0x373a"/>
                    <Item ID="0x374a"/>
                    <Item ID="0x375a"/>
                    <Item ID="0x376a"/>
                    <Item ID="0x3779"/>
                    <Item ID="0x37b9"/>
                    <Item ID="0x37c4"/>
                    <Item ID="0x3818"/>
                </Group>
                <Group name="Ingredients">
                    <Item ID="0x021B"/>
                    <Item ID="0x021C"/>
                    <Item ID="0x023A"/>
                    <Item ID="0x023B"/>
                    <Item ID="0x023F"/>
                    <Item ID="0x024B"/>
                    <Item ID="0x0C3B"/>
                    <Item ID="0x0C3C"/>
                    <Item ID="0x0C3D"/>
                    <Item ID="0x0C3E"/>
                    <Item ID="0x0C3F"/>
                    <Item ID="0x0C40"/>
                    <Item ID="0x0C41"/>
                    <Item ID="0x0C42"/>
                    <Item ID="0x0F0F"/>
                    <Item ID="0x0F10"/>
                    <Item ID="0x0F11"/>
                    <Item ID="0x0F12"/>
                    <Item ID="0x0F13"/>
                    <Item ID="0x0F14"/>
                    <Item ID="0x0F15"/>
                    <Item ID="0x0F16"/>
                    <Item ID="0x0F17"/>
                    <Item ID="0x0F18"/>
                    <Item ID="0x0F19"/>
                    <Item ID="0x0F1A"/>
                    <Item ID="0x0F1B"/>
                    <Item ID="0x0F1C"/>
                    <Item ID="0x0F1D"/>
                    <Item ID="0x0F1E"/>
                    <Item ID="0x0F1F"/>
                    <Item ID="0x0F20"/>
                    <Item ID="0x0F21"/>
                    <Item ID="0x0F22"/>
                    <Item ID="0x0F23"/>
                    <Item ID="0x0F24"/>
                    <Item ID="0x0F25"/>
                    <Item ID="0x0F26"/>
                    <Item ID="0x0F27"/>
                    <Item ID="0x0F28"/>
                    <Item ID="0x0F29"/>
                    <Item ID="0x0F2A"/>
                    <Item ID="0x0F2B"/>
                    <Item ID="0x0F2C"/>
                    <Item ID="0x0F2D"/>
                    <Item ID="0x0F2E"/>
                    <Item ID="0x0F2F"/>
                    <Item ID="0x0F30"/>
                    <Item ID="0x0F78"/>
                    <Item ID="0x0F79"/>
                    <Item ID="0x0F7A"/>
                    <Item ID="0x0F7B"/>
                    <Item ID="0x0F7C"/>
                    <Item ID="0x0F7D"/>
                    <Item ID="0x0F7E"/>
                    <Item ID="0x0F7F"/>
                    <Item ID="0x0F80"/>
                    <Item ID="0x0F81"/>
                    <Item ID="0x0F82"/>
                    <Item ID="0x0F83"/>
                    <Item ID="0x0F84"/>
                    <Item ID="0x0F85"/>
                    <Item ID="0x0F86"/>
                    <Item ID="0x0F87"/>
                    <Item ID="0x0F88"/>
                    <Item ID="0x0F89"/>
                    <Item ID="0x0F8A"/>
                    <Item ID="0x0F8B"/>
                    <Item ID="0x0F8C"/>
                    <Item ID="0x0F8D"/>
                    <Item ID="0x0F8E"/>
                    <Item ID="0x0F8F"/>
                    <Item ID="0x0F90"/>
                    <Item ID="0x0F91"/>
                    <Item ID="0x18DD"/>
                    <Item ID="0x18DE"/>
                    <Item ID="0x18EB"/>
                    <Item ID="0x18EC"/>
                    <Item ID="0x1C18"/>
                    <Item ID="0x1C19"/>
                    <Item ID="0x1Ea7"/>
                    <Item ID="0x1f13"/>
                    <Item ID="0x2003"/>
                    <Item ID="0x26b1"/>
                    <Item ID="0x26b2"/>
                    <Item ID="0x26b3"/>
                    <Item ID="0x26b4"/>
                    <Item ID="0x26b5"/>
                    <Item ID="0x26b6"/>
                    <Item ID="0x26b7"/>
                    <Item ID="0x26b8"/>
                    <Item ID="0x284B"/>
                    <Item ID="0x284C"/>
                    <Item ID="0x2AAA"/>
                    <Item ID="0x2dae"/>
                    <Item ID="0x2daf"/>
                    <Item ID="0x2db1"/>
                    <Item ID="0x2db1"/>
                    <Item ID="0x2db2"/>
                    <Item ID="0x2db2"/>
                    <Item ID="0x2db3"/>
                    <Item ID="0x2db3"/>
                    <Item ID="0x2db4"/>
                    <Item ID="0x2db4"/>
                    <Item ID="0x2db5"/>
                    <Item ID="0x2db5"/>
                    <Item ID="0x2db6"/>
                    <Item ID="0x2db6"/>
                    <Item ID="0x2db7"/>
                    <Item ID="0x2db7"/>
                    <Item ID="0x2db8"/>
                    <Item ID="0x2db8"/>
                    <Item ID="0x2db9"/>
                    <Item ID="0x2db9"/>
                    <Item ID="0x2dba"/>
                    <Item ID="0x2dba"/>
                    <Item ID="0x2f60"/>
                    <Item ID="0x3155"/>
                    <Item ID="0x3183"/>
                    <Item ID="0x3184"/>
                    <Item ID="0x3186"/>
                    <Item ID="0x3188"/>
                    <Item ID="0x3189"/>
                    <Item ID="0x318A"/>
                    <Item ID="0x318B"/>
                    <Item ID="0x318C"/>
                    <Item ID="0x318D"/>
                    <Item ID="0x318E"/>
                    <Item ID="0x318F"/>
                    <Item ID="0x3190"/>
                    <Item ID="0x3191"/>
                    <Item ID="0x3192"/>
                    <Item ID="0x3193"/>
                    <Item ID="0x3194"/>
                    <Item ID="0x3195"/>
                    <Item ID="0x3196"/>
                    <Item ID="0x3197"/>
                    <Item ID="0x3198"/>
                    <Item ID="0x3199"/>
                    <Item ID="0x3678"/>
                    <Item ID="0x3679"/>
                    <Item ID="0x367A"/>
                    <Item ID="0x3db8"/>
                    <Item ID="0x3db9"/>
                    <Item ID="0x3dba"/>
                    <Item ID="0x3dbb"/>
                </Group>
                <Group name="Misc">
                    <Item ID="0x2002"/>
                </Group>
                <Group name="Runes + Books">
                    <Item ID="0x023C"/>
                    <Item ID="0x023D"/>
                    <Item ID="0x023E"/>
                    <Item ID="0x0E5C"/>
                    <Item ID="0x0E5F"/>
                    <Item ID="0x0E62"/>
                    <Item ID="0x0E65"/>
                    <Item ID="0x0E68"/>
                    <Item ID="0x181d"/>
                    <Item ID="0x181e"/>
                    <Item ID="0x181f"/>
                    <Item ID="0x1820"/>
                    <Item ID="0x1821"/>
                    <Item ID="0x1822"/>
                    <Item ID="0x1823"/>
                    <Item ID="0x1824"/>
                    <Item ID="0x1825"/>
                    <Item ID="0x1826"/>
                    <Item ID="0x1827"/>
                    <Item ID="0x1828"/>
                    <Item ID="0x1C11"/>
                    <Item ID="0x1F14"/>
                    <Item ID="0x1F15"/>
                    <Item ID="0x1F16"/>
                    <Item ID="0x1F17"/>
                    <Item ID="0x2d5e"/>
                </Group>
                <Group name="Scrolls">
                    <Item ID="0x1F2D"/>
                    <Item ID="0x1F2E"/>
                    <Item ID="0x1F2F"/>
                    <Item ID="0x1F30"/>
                    <Item ID="0x1F31"/>
                    <Item ID="0x1F32"/>
                    <Item ID="0x1F33"/>
                    <Item ID="0x1F34"/>
                    <Item ID="0x1F35"/>
                    <Item ID="0x1F36"/>
                    <Item ID="0x1F37"/>
                    <Item ID="0x1F38"/>
                    <Item ID="0x1F39"/>
                    <Item ID="0x1F3A"/>
                    <Item ID="0x1F3B"/>
                    <Item ID="0x1F3C"/>
                    <Item ID="0x1F3D"/>
                    <Item ID="0x1F3E"/>
                    <Item ID="0x1F3F"/>
                    <Item ID="0x1F40"/>
                    <Item ID="0x1F41"/>
                    <Item ID="0x1F42"/>
                    <Item ID="0x1F43"/>
                    <Item ID="0x1F44"/>
                    <Item ID="0x1F45"/>
                    <Item ID="0x1F46"/>
                    <Item ID="0x1F47"/>
                    <Item ID="0x1F48"/>
                    <Item ID="0x1F49"/>
                    <Item ID="0x1F4A"/>
                    <Item ID="0x1F4B"/>
                    <Item ID="0x1F4C"/>
                    <Item ID="0x1F4D"/>
                    <Item ID="0x1F4E"/>
                    <Item ID="0x1F4F"/>
                    <Item ID="0x1F50"/>
                    <Item ID="0x1F51"/>
                    <Item ID="0x1F52"/>
                    <Item ID="0x1F53"/>
                    <Item ID="0x1F54"/>
                    <Item ID="0x1F55"/>
                    <Item ID="0x1F56"/>
                    <Item ID="0x1F57"/>
                    <Item ID="0x1F58"/>
                    <Item ID="0x1F59"/>
                    <Item ID="0x1F5A"/>
                    <Item ID="0x1F5B"/>
                    <Item ID="0x1F5C"/>
                    <Item ID="0x1F5D"/>
                    <Item ID="0x1F5E"/>
                    <Item ID="0x1F5F"/>
                    <Item ID="0x1F60"/>
                    <Item ID="0x1F61"/>
                    <Item ID="0x1F62"/>
                    <Item ID="0x1F63"/>
                    <Item ID="0x1F64"/>
                    <Item ID="0x1F65"/>
                    <Item ID="0x1F66"/>
                    <Item ID="0x1F67"/>
                    <Item ID="0x1F68"/>
                    <Item ID="0x1F69"/>
                    <Item ID="0x1F6A"/>
                    <Item ID="0x1F6B"/>
                    <Item ID="0x1F6C"/>
                    <Item ID="0x1F6D"/>
                    <Item ID="0x1F6E"/>
                    <Item ID="0x1F6F"/>
                    <Item ID="0x1F70"/>
                    <Item ID="0x1F71"/>
                    <Item ID="0x1F72"/>
                    <Item ID="0x1f23"/>
                    <Item ID="0x2258"/>
                    <Item ID="0x2260"/>
                    <Item ID="0x2261"/>
                    <Item ID="0x2262"/>
                    <Item ID="0x2263"/>
                    <Item ID="0x2264"/>
                    <Item ID="0x2265"/>
                    <Item ID="0x2266"/>
                    <Item ID="0x2267"/>
                    <Item ID="0x2268"/>
                    <Item ID="0x2269"/>
                    <Item ID="0x226A"/>
                    <Item ID="0x226B"/>
                    <Item ID="0x226C"/>
                    <Item ID="0x226D"/>
                    <Item ID="0x226E"/>
                    <Item ID="0x226F"/>
                    <Item ID="0x2270"/>
                    <Item ID="0x2271"/>
                    <Item ID="0x2272"/>
                    <Item ID="0x2273"/>
                    <Item ID="0x2274"/>
                    <Item ID="0x2275"/>
                    <Item ID="0x2276"/>
                    <Item ID="0x2277"/>
                    <Item ID="0x2278"/>
                    <Item ID="0x2279"/>
                    <Item ID="0x227A"/>
                    <Item ID="0x227B"/>
                    <Item ID="0x227C"/>
                    <Item ID="0x2D51"/>
                    <Item ID="0x2D52"/>
                    <Item ID="0x2D53"/>
                    <Item ID="0x2D54"/>
                    <Item ID="0x2D55"/>
                    <Item ID="0x2D56"/>
                    <Item ID="0x2D57"/>
                    <Item ID="0x2D58"/>
                    <Item ID="0x2D59"/>
                    <Item ID="0x2D5a"/>
                    <Item ID="0x2D5b"/>
                    <Item ID="0x2D5c"/>
                    <Item ID="0x2D5d"/>
                    <Item ID="0x2D5e"/>
                    <Item ID="0x2D5f"/>
                    <Item ID="0x2D60"/>
                    <Item ID="0x2D61"/>
                    <Item ID="0x2D62"/>
                    <Item ID="0x2d9e"/>
                    <Item ID="0x2d9f"/>
                    <Item ID="0x2da0"/>
                    <Item ID="0x2da1"/>
                    <Item ID="0x2da2"/>
                    <Item ID="0x2da3"/>
                    <Item ID="0x2da4"/>
                    <Item ID="0x2da5"/>
                    <Item ID="0x2da6"/>
                    <Item ID="0x2da7"/>
                    <Item ID="0x2da8"/>
                    <Item ID="0x2da9"/>
                    <Item ID="0x2daa"/>
                    <Item ID="0x2dab"/>
                    <Item ID="0x2dac"/>
                    <Item ID="0x2dad"/>
                </Group>
                <Group name="Tools">
                    <Item ID="0x0DF2"/>
                    <Item ID="0x0DF3"/>
                    <Item ID="0x0DF4"/>
                    <Item ID="0x0DF5"/>
                    <Item ID="0x0E2d"/>
                    <Item ID="0x0E30"/>
                    <Item ID="0x0E31"/>
                    <Item ID="0x0FE6"/>
                    <Item ID="0x0FE7"/>
                    <Item ID="0x0FE8"/>
                    <Item ID="0x0FE9"/>
                    <Item ID="0x0FEA"/>
                    <Item ID="0x0FEB"/>
                    <Item ID="0x0FEC"/>
                    <Item ID="0x0FED"/>
                    <Item ID="0x0FEE"/>
                    <Item ID="0x10AC"/>
                    <Item ID="0x10AD"/>
                    <Item ID="0x10AE"/>
                    <Item ID="0x10AF"/>
                    <Item ID="0x10B0"/>
                    <Item ID="0x10B1"/>
                    <Item ID="0x120E"/>
                    <Item ID="0x120F"/>
                    <Item ID="0x1210"/>
                    <Item ID="0x1211"/>
                    <Item ID="0x1212"/>
                    <Item ID="0x1213"/>
                    <Item ID="0x1214"/>
                    <Item ID="0x1215"/>
                    <Item ID="0x1216"/>
                    <Item ID="0x1810"/>
                    <Item ID="0x1811"/>
                    <Item ID="0x1851"/>
                    <Item ID="0x1852"/>
                    <Item ID="0x1865"/>
                    <Item ID="0x1866"/>
                    <Item ID="0x19BB"/>
                    <Item ID="0x1C12"/>
                    <Item ID="0x1C14"/>
                    <Item ID="0x1C16"/>
                    <Item ID="0x1E5c"/>
                    <Item ID="0x1E5d"/>
                    <Item ID="0x1d97"/>
                    <Item ID="0x1d98"/>
                    <Item ID="0x1ecd"/>
                    <Item ID="0x1ed0"/>
                    <Item ID="0x2A7B"/>
                    <Item ID="0x2A7C"/>
                    <Item ID="0x2A7D"/>
                    <Item ID="0x2A7E"/>
                    <Item ID="0x2A9A"/>
                    <Item ID="0x2A9C"/>
                    <Item ID="0x2A9D"/>
                    <Item ID="0x2A9b"/>
                    <Item ID="0x2AB8"/>
                    <Item ID="0x2DD3"/>
                    <Item ID="0x2DD4"/>
                    <Item ID="0x2db0"/>
                    <Item ID="0x2db0"/>
                    <Item ID="0x2f57"/>
                    <Item ID="0x2f5c"/>
                    <Item ID="0x2f5d"/>
                    <Item ID="0x2f5f"/>
                    <Item ID="0x2f61"/>
                    <Item ID="0x3077"/>
                    <Item ID="0x3078"/>
                    <Item ID="0x3079"/>
                    <Item ID="0x307a"/>
                </Group>
            </Group>
            <Group name="Baking">
                <Item ID="0x09E9"/>
                <Item ID="0x09EA"/>
                <Item ID="0x09EB"/>
                <Item ID="0x09FA"/>
                <Item ID="0x0A1E"/>
                <Item ID="0x1039"/>
                <Item ID="0x103D"/>
                <Item ID="0x103E"/>
                <Item ID="0x103F"/>
                <Item ID="0x103a"/>
                <Item ID="0x1040"/>
                <Item ID="0x1041"/>
                <Item ID="0x1042"/>
                <Item ID="0x1043"/>
                <Item ID="0x1045"/>
                <Item ID="0x1046"/>
                <Item ID="0x1083"/>
                <Item ID="0x1449"/>
                <Item ID="0x14E9"/>
                <Item ID="0x14EA"/>
                <Item ID="0x14ff"/>
                <Item ID="0x187e"/>
                <Item ID="0x187f"/>
                <Item ID="0x1880"/>
                <Item ID="0x1881"/>
                <Item ID="0x1882"/>
                <Item ID="0x1883"/>
                <Item ID="0x1884"/>
                <Item ID="0x1885"/>
                <Item ID="0x1886"/>
                <Item ID="0x1887"/>
                <Item ID="0x1888"/>
                <Item ID="0x1889"/>
                <Item ID="0x188a"/>
                <Item ID="0x188b"/>
                <Item ID="0x1893"/>
                <Item ID="0x1920"/>
                <Item ID="0x1921"/>
                <Item ID="0x1922"/>
                <Item ID="0x1923"/>
                <Item ID="0x1924"/>
                <Item ID="0x192C"/>
                <Item ID="0x192D"/>
                <Item ID="0x192E"/>
                <Item ID="0x192F"/>
                <Item ID="0x1930"/>
            </Group>
            <Group name="Carpenter">
                <Item ID="0x0C39"/>
                <Item ID="0x0C3A"/>
                <Item ID="0x1028"/>
                <Item ID="0x1029"/>
                <Item ID="0x102A"/>
                <Item ID="0x102B"/>
                <Item ID="0x102C"/>
                <Item ID="0x102D"/>
                <Item ID="0x102E"/>
                <Item ID="0x102F"/>
                <Item ID="0x1030"/>
                <Item ID="0x1031"/>
                <Item ID="0x1032"/>
                <Item ID="0x1033"/>
                <Item ID="0x1034"/>
                <Item ID="0x1035"/>
                <Item ID="0x1038"/>
                <Item ID="0x10E1"/>
                <Item ID="0x10E2"/>
                <Item ID="0x10E4"/>
                <Item ID="0x10E5"/>
                <Item ID="0x10E6"/>
                <Item ID="0x10E7"/>
                <Item ID="0x10E8"/>
                <Item ID="0x10E9"/>
                <Item ID="0x12B3"/>
                <Item ID="0x19F1"/>
                <Item ID="0x19F2"/>
                <Item ID="0x19F3"/>
                <Item ID="0x19F4"/>
                <Item ID="0x19F5"/>
                <Item ID="0x19F6"/>
                <Item ID="0x19F7"/>
                <Item ID="0x19F8"/>
                <Item ID="0x19F9"/>
                <Item ID="0x19FA"/>
                <Item ID="0x19FB"/>
                <Item ID="0x19FC"/>
                <Item ID="0x1BD8"/>
                <Item ID="0x1BD9"/>
                <Item ID="0x1BDB"/>
                <Item ID="0x1BDC"/>
                <Item ID="0x1BDE"/>
                <Item ID="0x1BDF"/>
                <Item ID="0x1BE1"/>
                <Item ID="0x1BE2"/>
                <Item ID="0x1E6E"/>
                <Item ID="0x1E6F"/>
                <Item ID="0x1E70"/>
                <Item ID="0x1E71"/>
                <Item ID="0x1E72"/>
                <Item ID="0x1E73"/>
                <Item ID="0x1E74"/>
                <Item ID="0x1E75"/>
                <Item ID="0x1E76"/>
                <Item ID="0x1E77"/>
                <Item ID="0x1E78"/>
                <Item ID="0x1E79"/>
                <Item ID="0x1E7A"/>
                <Item ID="0x1E7B"/>
                <Item ID="0x1E7C"/>
                <Item ID="0x1E7D"/>
                <Item ID="0x1E7E"/>
                <Item ID="0x1E7F"/>
                <Item ID="0x1E80"/>
                <Item ID="0x1E81"/>
                <Item ID="0x1E82"/>
                <Item ID="0x1EB1"/>
                <Item ID="0x1EB2"/>
                <Item ID="0x1EB3"/>
                <Item ID="0x1EB4"/>
                <Item ID="0x1EB5"/>
                <Item ID="0x1EB6"/>
                <Item ID="0x1EB7"/>
                <Item ID="0x1EB8"/>
                <Item ID="0x1EB9"/>
                <Item ID="0x1EBA"/>
                <Item ID="0x1EBB"/>
                <Item ID="0x1EBC"/>
                <Item ID="0x1db3"/>
                <Item ID="0x1db4"/>
                <Item ID="0x1db5"/>
                <Item ID="0x1db6"/>
                <Item ID="0x1db7"/>
                <Item ID="0x1db8"/>
            </Group>
            <Group name="Cooking">
                <Item ID="0x0970"/>
                <Item ID="0x0974"/>
                <Item ID="0x0975"/>
                <Item ID="0x097F"/>
                <Item ID="0x0991"/>
                <Item ID="0x0992"/>
                <Item ID="0x09DC"/>
                <Item ID="0x09DD"/>
                <Item ID="0x09DE"/>
                <Item ID="0x09DF"/>
                <Item ID="0x09E0"/>
                <Item ID="0x09E1"/>
                <Item ID="0x09E2"/>
                <Item ID="0x09E3"/>
                <Item ID="0x09E4"/>
                <Item ID="0x09E5"/>
                <Item ID="0x09E6"/>
                <Item ID="0x09E7"/>
                <Item ID="0x09E8"/>
                <Item ID="0x09ED"/>
                <Item ID="0x09F3"/>
                <Item ID="0x1039"/>
                <Item ID="0x103D"/>
                <Item ID="0x103E"/>
                <Item ID="0x103F"/>
                <Item ID="0x103a"/>
                <Item ID="0x1040"/>
                <Item ID="0x1041"/>
                <Item ID="0x1042"/>
                <Item ID="0x1043"/>
                <Item ID="0x1045"/>
                <Item ID="0x1046"/>
                <Item ID="0x1083"/>
                <Item ID="0x10E7"/>
                <Item ID="0x10E8"/>
                <Item ID="0x10E9"/>
                <Item ID="0x10Ee"/>
                <Item ID="0x10Ef"/>
                <Item ID="0x10f0"/>
                <Item ID="0x10f1"/>
                <Item ID="0x10f2"/>
                <Item ID="0x10f3"/>
                <Item ID="0x1449"/>
                <Item ID="0x14ff"/>
                <Item ID="0x1865"/>
                <Item ID="0x1866"/>
                <Item ID="0x1871"/>
                <Item ID="0x1872"/>
                <Item ID="0x1873"/>
                <Item ID="0x1874"/>
                <Item ID="0x18E3"/>
                <Item ID="0x18E4"/>
                <Item ID="0x1AA2"/>
                <Item ID="0x1E15"/>
                <Item ID="0x1E16"/>
                <Item ID="0x1E17"/>
                <Item ID="0x1E18"/>
                <Item ID="0x1E19"/>
                <Item ID="0x1E1A"/>
                <Item ID="0x1E1B"/>
                <Item ID="0x1E1C"/>
                <Item ID="0x1E1D"/>
                <Item ID="0x1E1E"/>
                <Item ID="0x1E1F"/>
                <Item ID="0x1E83"/>
                <Item ID="0x1E84"/>
                <Item ID="0x1E85"/>
                <Item ID="0x1E86"/>
                <Item ID="0x1E87"/>
                <Item ID="0x1E88"/>
                <Item ID="0x1E89"/>
                <Item ID="0x1E8A"/>
                <Item ID="0x1E8B"/>
                <Item ID="0x1E8C"/>
                <Item ID="0x1E8D"/>
                <Item ID="0x1E8E"/>
                <Item ID="0x1E8F"/>
                <Item ID="0x1E90"/>
                <Item ID="0x1E91"/>
                <Item ID="0x1E92"/>
                <Item ID="0x1E93"/>
                <Item ID="0x1E94"/>
                <Item ID="0x1E95"/>
                <Item ID="0x1E96"/>
                <Item ID="0x1E97"/>
                <Item ID="0x1E98"/>
                <Item ID="0x1E99"/>
                <Item ID="0x1Eb0"/>
                <Item ID="0x207a"/>
                <Item ID="0x207b"/>
                <Item ID="0x3daf"/>
                <Item ID="0x3db0"/>
                <Item ID="0x3db1"/>
                <Item ID="0x3db8"/>
                <Item ID="0x3db9"/>
                <Item ID="0x3dba"/>
                <Item ID="0x3dbb"/>
            </Group>
            <Group name="Farming">
                <Group name="Plants">
                    <Item ID="0x02DB"/>
                    <Item ID="0x0C4f"/>
                    <Item ID="0x0C50"/>
                    <Item ID="0x0C51"/>
                    <Item ID="0x0C52"/>
                    <Item ID="0x0C53"/>
                    <Item ID="0x0C54"/>
                    <Item ID="0x0C55"/>
                    <Item ID="0x0C56"/>
                    <Item ID="0x0C57"/>
                    <Item ID="0x0C58"/>
                    <Item ID="0x0C59"/>
                    <Item ID="0x0C5C"/>
                    <Item ID="0x0C5a"/>
                    <Item ID="0x0C5b"/>
                    <Item ID="0x0C5d"/>
                    <Item ID="0x0C5e"/>
                    <Item ID="0x0C5f"/>
                    <Item ID="0x0C60"/>
                    <Item ID="0x0C61"/>
                    <Item ID="0x0C62"/>
                    <Item ID="0x0C63"/>
                    <Item ID="0x0C64"/>
                    <Item ID="0x0C65"/>
                    <Item ID="0x0C66"/>
                    <Item ID="0x0C67"/>
                    <Item ID="0x0C68"/>
                    <Item ID="0x0C69"/>
                    <Item ID="0x0C6a"/>
                    <Item ID="0x0C6b"/>
                    <Item ID="0x0C6c"/>
                    <Item ID="0x0C6f"/>
                    <Item ID="0x0C70"/>
                    <Item ID="0x0C71"/>
                    <Item ID="0x0C72"/>
                    <Item ID="0x0C73"/>
                    <Item ID="0x0C74"/>
                    <Item ID="0x0C75"/>
                    <Item ID="0x0C76"/>
                    <Item ID="0x0C79"/>
                    <Item ID="0x0C7a"/>
                    <Item ID="0x0C7b"/>
                    <Item ID="0x0C7c"/>
                    <Item ID="0x0C7d"/>
                    <Item ID="0x0C7e"/>
                    <Item ID="0x0D1A"/>
                    <Item ID="0x0D1B"/>
                    <Item ID="0x0D1C"/>
                    <Item ID="0x0D1D"/>
                    <Item ID="0x0D1E"/>
                    <Item ID="0x0D1F"/>
                    <Item ID="0x0D20"/>
                    <Item ID="0x0D21"/>
                    <Item ID="0x0D22"/>
                    <Item ID="0x0D23"/>
                    <Item ID="0x0D24"/>
                    <Item ID="0x0DAE"/>
                    <Item ID="0x0DAF"/>
                    <Item ID="0x0DEb"/>
                    <Item ID="0x0DEc"/>
                    <Item ID="0x0DEd"/>
                    <Item ID="0x0DEe"/>
                    <Item ID="0x1449"/>
                    <Item ID="0x1A99"/>
                    <Item ID="0x1A9A"/>
                    <Item ID="0x1A9B"/>
                    <Item ID="0x1A9E"/>
                    <Item ID="0x1A9F"/>
                    <Item ID="0x1AA0"/>
                    <Item ID="0x1AA1"/>
                    <Item ID="0x1AA2"/>
                    <Item ID="0x1Ebd"/>
                    <Item ID="0x1Ebe"/>
                    <Item ID="0x1Ebf"/>
                    <Item ID="0x3d12"/>
                    <Item ID="0x3d17"/>
                    <Item ID="0x3d18"/>
                    <Item ID="0x3d19"/>
                    <Item ID="0x3d1a"/>
                    <Item ID="0x3d1b"/>
                    <Item ID="0x3d1c"/>
                </Group>
                <Group name="Tools">
                    <Item ID="0x1500"/>
                    <Item ID="0x1501"/>
                    <Item ID="0x1502"/>
                    <Item ID="0x1503"/>
                    <Item ID="0x1504"/>
                    <Item ID="0x1505"/>
                    <Item ID="0x1506"/>
                    <Item ID="0x1507"/>
                    <Item ID="0x1E34"/>
                    <Item ID="0x1E35"/>
                </Group>
            </Group>
            <Group name="Fisher + Sailor">
                <Item ID="0x020D"/>
                <Item ID="0x0DBF"/>
                <Item ID="0x0DC0"/>
                <Item ID="0x0DC8"/>
                <Item ID="0x0DC9"/>
                <Item ID="0x0DCA"/>
                <Item ID="0x0DCA"/>
                <Item ID="0x0DCB"/>
                <Item ID="0x0DCC"/>
                <Item ID="0x0DCD"/>
                <Item ID="0x0DCE"/>
                <Item ID="0x0DCF"/>
                <Item ID="0x0DD0"/>
                <Item ID="0x0DD1"/>
                <Item ID="0x0DD2"/>
                <Item ID="0x0DD3"/>
                <Item ID="0x0DD4"/>
                <Item ID="0x0DD5"/>
                <Item ID="0x0DD6"/>
                <Item ID="0x0DD6"/>
                <Item ID="0x0DD7"/>
                <Item ID="0x0DD7"/>
                <Item ID="0x0DD8"/>
                <Item ID="0x0DD8"/>
                <Item ID="0x0DD9"/>
                <Item ID="0x0DD9"/>
                <Item ID="0x0FC4"/>
                <Item ID="0x0FC5"/>
                <Item ID="0x0FC6"/>
                <Item ID="0x0FC7"/>
                <Item ID="0x0FC8"/>
                <Item ID="0x0FC9"/>
                <Item ID="0x0FCA"/>
                <Item ID="0x0FCB"/>
                <Item ID="0x0FCC"/>
                <Item ID="0x0FCD"/>
                <Item ID="0x0FCE"/>
                <Item ID="0x0FCF"/>
                <Item ID="0x0FD0"/>
                <Item ID="0x0FD1"/>
                <Item ID="0x0FD2"/>
                <Item ID="0x0FD3"/>
                <Item ID="0x0FD4"/>
                <Item ID="0x1047"/>
                <Item ID="0x1048"/>
                <Item ID="0x14EB"/>
                <Item ID="0x14EC"/>
                <Item ID="0x14ED"/>
                <Item ID="0x14EE"/>
                <Item ID="0x14F1"/>
                <Item ID="0x14F2"/>
                <Item ID="0x14F3"/>
                <Item ID="0x14F4"/>
                <Item ID="0x14F5"/>
                <Item ID="0x14F6"/>
                <Item ID="0x1E26"/>
                <Item ID="0x1E27"/>
                <Item ID="0x1E28"/>
                <Item ID="0x1E29"/>
                <Item ID="0x1E2A"/>
                <Item ID="0x1E2B"/>
                <Item ID="0x1E9A"/>
                <Item ID="0x1E9B"/>
                <Item ID="0x1E9C"/>
                <Item ID="0x1E9D"/>
                <Item ID="0x1E9E"/>
                <Item ID="0x1E9F"/>
                <Item ID="0x1EA0"/>
                <Item ID="0x1EA1"/>
                <Item ID="0x1EA2"/>
                <Item ID="0x1EA3"/>
                <Item ID="0x1EA4"/>
                <Item ID="0x1EA5"/>
                <Item ID="0x1EA6"/>
                <Item ID="0x2003"/>
                <Item ID="0x2710"/>
                <Item ID="0x2711"/>
                <Item ID="0x3d8e"/>
                <Item ID="0x3d8f"/>
            </Group>
            <Group name="Fletcher">
                <Item ID="0x0DFA"/>
                <Item ID="0x0DFB"/>
                <Item ID="0x0fc2"/>
                <Item ID="0x1020"/>
                <Item ID="0x1021"/>
                <Item ID="0x1022"/>
                <Item ID="0x1023"/>
                <Item ID="0x1024"/>
                <Item ID="0x1025"/>
                <Item ID="0x1BD1"/>
                <Item ID="0x1BD2"/>
                <Item ID="0x1BD3"/>
                <Item ID="0x1BD4"/>
                <Item ID="0x1BD5"/>
                <Item ID="0x1BD6"/>
                <Item ID="0x1BD8"/>
                <Item ID="0x1BD9"/>
                <Item ID="0x1BDB"/>
                <Item ID="0x1BDC"/>
                <Item ID="0x1BDE"/>
                <Item ID="0x1BDF"/>
                <Item ID="0x1BE1"/>
                <Item ID="0x1BE2"/>
                <Item ID="0x1BFB"/>
                <Item ID="0x1BFC"/>
                <Item ID="0x1BFD"/>
                <Item ID="0x1BFE"/>
                <Item ID="0x2DD7"/>
            </Group>
            <Group name="Hairdressing">
                <Item ID="0x0DFC"/>
                <Item ID="0x0DFD"/>
                <Item ID="0x0DFE"/>
                <Item ID="0x0DFF"/>
                <Item ID="0x0E00"/>
                <Item ID="0x0E01"/>
                <Item ID="0x0E02"/>
                <Item ID="0x0E03"/>
                <Item ID="0x0E04"/>
                <Item ID="0x0E05"/>
                <Item ID="0x0E06"/>
                <Item ID="0x0E07"/>
                <Item ID="0x0E08"/>
                <Item ID="0x0E09"/>
                <Item ID="0x0E0A"/>
                <Item ID="0x0E0B"/>
                <Item ID="0x0E0C"/>
                <Item ID="0x0E0D"/>
                <Item ID="0x0E0E"/>
            </Group>
            <Group name="Healer">
                <Item ID="0x0002"/>
                <Item ID="0x0003"/>
                <Item ID="0x0004"/>
                <Item ID="0x0005"/>
                <Item ID="0x0C3B"/>
                <Item ID="0x0C3C"/>
                <Item ID="0x0C3D"/>
                <Item ID="0x0C3E"/>
                <Item ID="0x0C3F"/>
                <Item ID="0x0C40"/>
                <Item ID="0x0C41"/>
                <Item ID="0x0C42"/>
                <Item ID="0x0E20"/>
                <Item ID="0x0E21"/>
                <Item ID="0x0E22"/>
                <Item ID="0x0E23"/>
                <Item ID="0x0E30"/>
                <Item ID="0x0E31"/>
                <Item ID="0x0Ee9"/>
                <Item ID="0x1008"/>
                <Item ID="0x1009"/>
                <Item ID="0x10AC"/>
                <Item ID="0x10AD"/>
                <Item ID="0x10AE"/>
                <Item ID="0x10AF"/>
                <Item ID="0x10B0"/>
                <Item ID="0x10B1"/>
                <Item ID="0x19BB"/>
                <Item ID="0x312D"/>
                <Item ID="0x312E"/>
                <Item ID="0x312F"/>
                <Item ID="0x3130"/>
            </Group>
            <Group name="Jeweler">
                <Group name="Resources">
                    <Item ID="0x0F0F"/>
                    <Item ID="0x0F10"/>
                    <Item ID="0x0F11"/>
                    <Item ID="0x0F12"/>
                    <Item ID="0x0F13"/>
                    <Item ID="0x0F14"/>
                    <Item ID="0x0F15"/>
                    <Item ID="0x0F16"/>
                    <Item ID="0x0F17"/>
                    <Item ID="0x0F18"/>
                    <Item ID="0x0F19"/>
                    <Item ID="0x0F1A"/>
                    <Item ID="0x0F1B"/>
                    <Item ID="0x0F1C"/>
                    <Item ID="0x0F1D"/>
                    <Item ID="0x0F1E"/>
                    <Item ID="0x0F1F"/>
                    <Item ID="0x0F20"/>
                    <Item ID="0x0F21"/>
                    <Item ID="0x0F22"/>
                    <Item ID="0x0F23"/>
                    <Item ID="0x0F24"/>
                    <Item ID="0x0F25"/>
                    <Item ID="0x0F26"/>
                    <Item ID="0x0F27"/>
                    <Item ID="0x0F28"/>
                    <Item ID="0x0F29"/>
                    <Item ID="0x0F2A"/>
                    <Item ID="0x0F2B"/>
                    <Item ID="0x0F2C"/>
                    <Item ID="0x0F2D"/>
                    <Item ID="0x0F2E"/>
                    <Item ID="0x0F2F"/>
                    <Item ID="0x0F30"/>
                    <Item ID="0x1876"/>
                    <Item ID="0x1877"/>
                    <Item ID="0x1878"/>
                    <Item ID="0x1879"/>
                    <Item ID="0x1BE3"/>
                    <Item ID="0x1BE4"/>
                    <Item ID="0x1BE5"/>
                    <Item ID="0x1BE6"/>
                    <Item ID="0x1BE7"/>
                    <Item ID="0x1BE8"/>
                    <Item ID="0x1BE9"/>
                    <Item ID="0x1BEA"/>
                    <Item ID="0x1BEB"/>
                    <Item ID="0x1BEC"/>
                    <Item ID="0x1BED"/>
                    <Item ID="0x1BEE"/>
                    <Item ID="0x1BEF"/>
                    <Item ID="0x1BF0"/>
                    <Item ID="0x1BF1"/>
                    <Item ID="0x1BF2"/>
                    <Item ID="0x1BF3"/>
                    <Item ID="0x1BF4"/>
                    <Item ID="0x1BF5"/>
                    <Item ID="0x1BF6"/>
                    <Item ID="0x1BF7"/>
                    <Item ID="0x1BF8"/>
                    <Item ID="0x1BF9"/>
                    <Item ID="0x1BFA"/>
                    <Item ID="0x3192"/>
                    <Item ID="0x3193"/>
                    <Item ID="0x3194"/>
                    <Item ID="0x3195"/>
                    <Item ID="0x3196"/>
                    <Item ID="0x3197"/>
                    <Item ID="0x3198"/>
                    <Item ID="0x3199"/>
                </Group>
                <Item ID="0x0FBB"/>
                <Item ID="0x0FBC"/>
                <Item ID="0x102A"/>
                <Item ID="0x102B"/>
                <Item ID="0x1085"/>
                <Item ID="0x1086"/>
                <Item ID="0x1087"/>
                <Item ID="0x1088"/>
                <Item ID="0x1089"/>
                <Item ID="0x108a"/>
                <Item ID="0x108b"/>
                <Item ID="0x1f05"/>
                <Item ID="0x1f06"/>
                <Item ID="0x1f07"/>
                <Item ID="0x1f08"/>
                <Item ID="0x1f09"/>
                <Item ID="0x1f0a"/>
                <Item ID="0x3BB5"/>
            </Group>
            <Group name="Lock picking + Traps">
                <Item ID="0x108c"/>
                <Item ID="0x108f"/>
                <Item ID="0x1092"/>
                <Item ID="0x1093"/>
                <Item ID="0x10F5"/>
                <Item ID="0x10F6"/>
                <Item ID="0x10Fc"/>
                <Item ID="0x10fd"/>
                <Item ID="0x1103"/>
                <Item ID="0x1104"/>
                <Item ID="0x1108"/>
                <Item ID="0x1109"/>
                <Item ID="0x110f"/>
                <Item ID="0x1110"/>
                <Item ID="0x1116"/>
                <Item ID="0x1117"/>
                <Item ID="0x111b"/>
                <Item ID="0x111c"/>
                <Item ID="0x1122"/>
                <Item ID="0x1123"/>
                <Item ID="0x1125"/>
                <Item ID="0x1126"/>
                <Item ID="0x112b"/>
                <Item ID="0x112c"/>
                <Item ID="0x112f"/>
                <Item ID="0x1130"/>
                <Item ID="0x1133"/>
                <Item ID="0x1134"/>
                <Item ID="0x113a"/>
                <Item ID="0x1140"/>
                <Item ID="0x1141"/>
                <Item ID="0x1145"/>
                <Item ID="0x1146"/>
                <Item ID="0x114b"/>
                <Item ID="0x114c"/>
                <Item ID="0x1193"/>
                <Item ID="0x1194"/>
                <Item ID="0x119a"/>
                <Item ID="0x119b"/>
                <Item ID="0x11a0"/>
                <Item ID="0x11a1"/>
                <Item ID="0x11a6"/>
                <Item ID="0x11a7"/>
                <Item ID="0x11ac"/>
                <Item ID="0x11ad"/>
                <Item ID="0x11b1"/>
                <Item ID="0x11b2"/>
                <Item ID="0x11b6"/>
                <Item ID="0x11b7"/>
                <Item ID="0x11c0"/>
                <Item ID="0x11c1"/>
                <Item ID="0x14FB"/>
                <Item ID="0x14FC"/>
                <Item ID="0x14FD"/>
                <Item ID="0x14FE"/>
                <Item ID="0x1508"/>
                <Item ID="0x1509"/>
                <Item ID="0x1512"/>
                <Item ID="0x1513"/>
                <Item ID="0x151A"/>
                <Item ID="0x151B"/>
                <Item ID="0x151C"/>
                <Item ID="0x151D"/>
                <Item ID="0x1B8f"/>
                <Item ID="0x1Bc0"/>
                <Item ID="0x1Bc1"/>
                <Item ID="0x1d99"/>
                <Item ID="0x1d9a"/>
                <Item ID="0x1ed3"/>
                <Item ID="0x1ed6"/>
                <Item ID="0x37a0"/>
            </Group>
            <Group name="Massage">
                <Item ID="0x1914"/>
                <Item ID="0x1915"/>
                <Item ID="0x1916"/>
                <Item ID="0x1917"/>
            </Group>
            <Group name="Metalwork">
                <Item ID="0x0FAF"/>
                <Item ID="0x0FB0"/>
                <Item ID="0x0FB1"/>
                <Item ID="0x0FB4"/>
                <Item ID="0x0FB5"/>
                <Item ID="0x0FB7"/>
                <Item ID="0x0FB8"/>
                <Item ID="0x0FBB"/>
                <Item ID="0x0FBC"/>
                <Item ID="0x100e"/>
                <Item ID="0x100f"/>
                <Item ID="0x1010"/>
                <Item ID="0x1011"/>
                <Item ID="0x1012"/>
                <Item ID="0x1013"/>
                <Item ID="0x10E1"/>
                <Item ID="0x10E2"/>
                <Item ID="0x1769"/>
                <Item ID="0x176a"/>
                <Item ID="0x176b"/>
                <Item ID="0x1876"/>
                <Item ID="0x1877"/>
                <Item ID="0x1878"/>
                <Item ID="0x1879"/>
                <Item ID="0x197A"/>
                <Item ID="0x197E"/>
                <Item ID="0x1982"/>
                <Item ID="0x1986"/>
                <Item ID="0x198A"/>
                <Item ID="0x198E"/>
                <Item ID="0x1992"/>
                <Item ID="0x1996"/>
                <Item ID="0x199A"/>
                <Item ID="0x199E"/>
                <Item ID="0x19A2"/>
                <Item ID="0x19A6"/>
                <Item ID="0x19B7"/>
                <Item ID="0x19B8"/>
                <Item ID="0x19B9"/>
                <Item ID="0x19BA"/>
                <Item ID="0x1A82"/>
                <Item ID="0x1A83"/>
                <Item ID="0x1A86"/>
                <Item ID="0x1A87"/>
                <Item ID="0x1A88"/>
                <Item ID="0x1A8B"/>
                <Item ID="0x1BE3"/>
                <Item ID="0x1BE4"/>
                <Item ID="0x1BE5"/>
                <Item ID="0x1BE6"/>
                <Item ID="0x1BE7"/>
                <Item ID="0x1BE8"/>
                <Item ID="0x1BE9"/>
                <Item ID="0x1BEA"/>
                <Item ID="0x1BEB"/>
                <Item ID="0x1BEC"/>
                <Item ID="0x1BED"/>
                <Item ID="0x1BEE"/>
                <Item ID="0x1BEF"/>
                <Item ID="0x1BF0"/>
                <Item ID="0x1BF1"/>
                <Item ID="0x1BF2"/>
                <Item ID="0x1BF3"/>
                <Item ID="0x1BF4"/>
                <Item ID="0x1BF5"/>
                <Item ID="0x1BF6"/>
                <Item ID="0x1BF7"/>
                <Item ID="0x1BF8"/>
                <Item ID="0x1BF9"/>
                <Item ID="0x1BFA"/>
                <Item ID="0x1db7"/>
                <Item ID="0x2DD5"/>
                <Item ID="0x2DD6"/>
                <Item ID="0x2DD8"/>
            </Group>
            <Group name="Sculptor">
                <Item ID="0x12B1"/>
                <Item ID="0x12B2"/>
                <Item ID="0x12B3"/>
                <Item ID="0x12C8"/>
                <Item ID="0x12C9"/>
                <Item ID="0x12b0"/>
                <Item ID="0x12b1"/>
                <Item ID="0x12b2"/>
                <Item ID="0x12b3"/>
                <Item ID="0x32F0"/>
                <Item ID="0x32F2"/>
                <Item ID="0x32F8"/>
            </Group>
            <Group name="Skill Training">
                <Item ID="0x100A"/>
                <Item ID="0x100B"/>
                <Item ID="0x1070"/>
                <Item ID="0x1074"/>
                <Item ID="0x1E2C"/>
                <Item ID="0x1E2D"/>
                <Item ID="0x1ec0"/>
                <Item ID="0x1ec3"/>
            </Group>
            <Group name="Skinner">
                <Item ID="0x1067"/>
                <Item ID="0x1068"/>
                <Item ID="0x1069"/>
                <Item ID="0x106B"/>
                <Item ID="0x1078"/>
                <Item ID="0x1079"/>
                <Item ID="0x107A"/>
                <Item ID="0x107C"/>
                <Item ID="0x107b"/>
                <Item ID="0x107d"/>
                <Item ID="0x107e"/>
                <Item ID="0x107f"/>
                <Item ID="0x1080"/>
                <Item ID="0x1082"/>
                <Item ID="0x1082"/>
                <Item ID="0x11F4"/>
                <Item ID="0x11F5"/>
                <Item ID="0x11F6"/>
                <Item ID="0x11F7"/>
                <Item ID="0x11F8"/>
                <Item ID="0x11F8"/>
                <Item ID="0x11F9"/>
                <Item ID="0x11F9"/>
                <Item ID="0x11FA"/>
                <Item ID="0x11FB"/>
                <Item ID="0x11Fa"/>
                <Item ID="0x11Fb"/>
                <Item ID="0x1871"/>
                <Item ID="0x1872"/>
                <Item ID="0x1873"/>
                <Item ID="0x1874"/>
                <Item ID="0x1875"/>
                <Item ID="0x3d69"/>
                <Item ID="0x3d6a"/>
                <Item ID="0x3d6b"/>
            </Group>
            <Group name="Tailoring + Clothwork">
                <Item ID="0x0DEF"/>
                <Item ID="0x0DF6"/>
                <Item ID="0x0DF7"/>
                <Item ID="0x0DF8"/>
                <Item ID="0x0DFA"/>
                <Item ID="0x0DFB"/>
                <Item ID="0x0EC6"/>
                <Item ID="0x0EC7"/>
                <Item ID="0x0F95"/>
                <Item ID="0x0F96"/>
                <Item ID="0x0F97"/>
                <Item ID="0x0F98"/>
                <Item ID="0x0F99"/>
                <Item ID="0x0F9A"/>
                <Item ID="0x0F9B"/>
                <Item ID="0x0F9C"/>
                <Item ID="0x0F9D"/>
                <Item ID="0x0F9E"/>
                <Item ID="0x0F9F"/>
                <Item ID="0x0FA0"/>
                <Item ID="0x0FA1"/>
                <Item ID="0x0FA9"/>
                <Item ID="0x0FAB"/>
                <Item ID="0x0e1d"/>
                <Item ID="0x0e1e"/>
                <Item ID="0x0e1f"/>
                <Item ID="0x1015"/>
                <Item ID="0x1019"/>
                <Item ID="0x101c"/>
                <Item ID="0x101f"/>
                <Item ID="0x105F"/>
                <Item ID="0x1060"/>
                <Item ID="0x1061"/>
                <Item ID="0x1062"/>
                <Item ID="0x10a4"/>
                <Item ID="0x1420"/>
                <Item ID="0x1421"/>
                <Item ID="0x175d"/>
                <Item ID="0x175e"/>
                <Item ID="0x175f"/>
                <Item ID="0x1760"/>
                <Item ID="0x1761"/>
                <Item ID="0x1762"/>
                <Item ID="0x1763"/>
                <Item ID="0x1764"/>
                <Item ID="0x1765"/>
                <Item ID="0x1766"/>
                <Item ID="0x1767"/>
                <Item ID="0x1768"/>
                <Item ID="0x1a9c"/>
                <Item ID="0x1a9d"/>
                <Item ID="0x2001"/>
                <Item ID="0x2DD9"/>
                <Item ID="0x2DD9"/>
                <Item ID="0x2DD9"/>
                <Item ID="0x2DDA"/>
                <Item ID="0x2e3c"/>
                <Item ID="0x2e3d"/>
                <Item ID="0x2e3e"/>
                <Item ID="0x2e3f"/>
            </Group>
            <Group name="Tinker/Carver">
                <Item ID="0x0C39"/>
                <Item ID="0x0C3A"/>
                <Item ID="0x1026"/>
                <Item ID="0x1027"/>
                <Item ID="0x1028"/>
                <Item ID="0x1029"/>
                <Item ID="0x102A"/>
                <Item ID="0x102B"/>
                <Item ID="0x102C"/>
                <Item ID="0x102D"/>
                <Item ID="0x102E"/>
                <Item ID="0x102F"/>
                <Item ID="0x1030"/>
                <Item ID="0x1031"/>
                <Item ID="0x1032"/>
                <Item ID="0x1033"/>
                <Item ID="0x1034"/>
                <Item ID="0x1035"/>
                <Item ID="0x1038"/>
                <Item ID="0x1043"/>
                <Item ID="0x104B"/>
                <Item ID="0x104C"/>
                <Item ID="0x104D"/>
                <Item ID="0x104E"/>
                <Item ID="0x104F"/>
                <Item ID="0x1050"/>
                <Item ID="0x1051"/>
                <Item ID="0x1052"/>
                <Item ID="0x1053"/>
                <Item ID="0x1054"/>
                <Item ID="0x1055"/>
                <Item ID="0x1056"/>
                <Item ID="0x1057"/>
                <Item ID="0x1058"/>
                <Item ID="0x1059"/>
                <Item ID="0x105A"/>
                <Item ID="0x105B"/>
                <Item ID="0x105C"/>
                <Item ID="0x105D"/>
                <Item ID="0x105E"/>
                <Item ID="0x10AC"/>
                <Item ID="0x10AD"/>
                <Item ID="0x10AE"/>
                <Item ID="0x10AF"/>
                <Item ID="0x10B0"/>
                <Item ID="0x10B1"/>
                <Item ID="0x10E3"/>
                <Item ID="0x10E4"/>
                <Item ID="0x10E5"/>
                <Item ID="0x10E6"/>
                <Item ID="0x10E7"/>
                <Item ID="0x10E8"/>
                <Item ID="0x10E9"/>
                <Item ID="0x12B3"/>
                <Item ID="0x19F1"/>
                <Item ID="0x19F2"/>
                <Item ID="0x19F3"/>
                <Item ID="0x19F4"/>
                <Item ID="0x19F5"/>
                <Item ID="0x19F6"/>
                <Item ID="0x19F7"/>
                <Item ID="0x19F8"/>
                <Item ID="0x19F9"/>
                <Item ID="0x19FA"/>
                <Item ID="0x19FB"/>
                <Item ID="0x19FC"/>
                <Item ID="0x1E6E"/>
                <Item ID="0x1E77"/>
                <Item ID="0x1EA8"/>
                <Item ID="0x1EA9"/>
                <Item ID="0x1EAC"/>
                <Item ID="0x1EAb"/>
                <Item ID="0x1EB6"/>
                <Item ID="0x1EB7"/>
                <Item ID="0x1EB8"/>
                <Item ID="0x1EB9"/>
                <Item ID="0x1EBA"/>
                <Item ID="0x1EBB"/>
                <Item ID="0x1EBC"/>
            </Group>
            <Group name="Treasure + Trade">
                <Item ID="0x0F0F"/>
                <Item ID="0x0F10"/>
                <Item ID="0x0F11"/>
                <Item ID="0x0F12"/>
                <Item ID="0x0F13"/>
                <Item ID="0x0F14"/>
                <Item ID="0x0F15"/>
                <Item ID="0x0F16"/>
                <Item ID="0x0F17"/>
                <Item ID="0x0F18"/>
                <Item ID="0x0F19"/>
                <Item ID="0x0F1A"/>
                <Item ID="0x0F1B"/>
                <Item ID="0x0F1C"/>
                <Item ID="0x0F1D"/>
                <Item ID="0x0F1E"/>
                <Item ID="0x0F1F"/>
                <Item ID="0x0F20"/>
                <Item ID="0x0F21"/>
                <Item ID="0x0F22"/>
                <Item ID="0x0F23"/>
                <Item ID="0x0F24"/>
                <Item ID="0x0F25"/>
                <Item ID="0x0F26"/>
                <Item ID="0x0F27"/>
                <Item ID="0x0F28"/>
                <Item ID="0x0F29"/>
                <Item ID="0x0F2A"/>
                <Item ID="0x0F2B"/>
                <Item ID="0x0F2C"/>
                <Item ID="0x0F2D"/>
                <Item ID="0x0F2E"/>
                <Item ID="0x0F2F"/>
                <Item ID="0x0F30"/>
                <Item ID="0x1851"/>
                <Item ID="0x1852"/>
                <Item ID="0x1B3F"/>
                <Item ID="0x1B40"/>
                <Item ID="0x1B41"/>
                <Item ID="0x1B42"/>
                <Item ID="0x1B43"/>
                <Item ID="0x1B44"/>
                <Item ID="0x1B45"/>
                <Item ID="0x1B46"/>
                <Item ID="0x1B47"/>
                <Item ID="0x1B48"/>
                <Item ID="0x1B4A"/>
                <Item ID="0x1B4B"/>
                <Item ID="0x1B4C"/>
                <Item ID="0x1B4D"/>
                <Item ID="0x1B4E"/>
                <Item ID="0x1B4F"/>
                <Item ID="0x1B50"/>
                <Item ID="0x1B51"/>
                <Item ID="0x1B53"/>
                <Item ID="0x1B54"/>
                <Item ID="0x1B55"/>
                <Item ID="0x1B56"/>
                <Item ID="0x1B57"/>
                <Item ID="0x1B58"/>
                <Item ID="0x1B59"/>
                <Item ID="0x1B5A"/>
                <Item ID="0x1B5B"/>
                <Item ID="0x1B5C"/>
                <Item ID="0x1B5D"/>
                <Item ID="0x1B5F"/>
                <Item ID="0x1B60"/>
                <Item ID="0x1B61"/>
                <Item ID="0x1B62"/>
                <Item ID="0x1B63"/>
                <Item ID="0x1B64"/>
                <Item ID="0x1B65"/>
                <Item ID="0x1B66"/>
                <Item ID="0x1B67"/>
                <Item ID="0x1B68"/>
                <Item ID="0x1B69"/>
                <Item ID="0x1B6A"/>
                <Item ID="0x1B6B"/>
                <Item ID="0x1ec6"/>
                <Item ID="0x1ec7"/>
                <Item ID="0x1ec8"/>
                <Item ID="0x1ec9"/>
                <Item ID="0x2936"/>
                <Item ID="0x2937"/>
                <Item ID="0x3192"/>
                <Item ID="0x3193"/>
                <Item ID="0x3194"/>
                <Item ID="0x3195"/>
                <Item ID="0x3196"/>
                <Item ID="0x3197"/>
                <Item ID="0x3198"/>
                <Item ID="0x3199"/>
            </Group>
        </Group>
        <Group name="Sea Life">
            <Item ID="0x3060"/>
            <Item ID="0x3061"/>
            <Item ID="0x3062"/>
            <Item ID="0x3063"/>
            <Item ID="0x3678"/>
            <Item ID="0x3AF9"/>
            <Item ID="0x3AFA"/>
            <Item ID="0x3AFB"/>
            <Item ID="0x3AFC"/>
            <Item ID="0x3AFD"/>
            <Item ID="0x3AFE"/>
            <Item ID="0x3AFF"/>
            <Item ID="0x3B00"/>
            <Item ID="0x3B01"/>
            <Item ID="0x3B02"/>
            <Item ID="0x3B03"/>
            <Item ID="0x3B04"/>
            <Item ID="0x3B05"/>
            <Item ID="0x3B06"/>
            <Item ID="0x3B07"/>
            <Item ID="0x3B08"/>
            <Item ID="0x3B09"/>
            <Item ID="0x3B0A"/>
            <Item ID="0x3B0B"/>
            <Item ID="0x3B0C"/>
            <Item ID="0x3B0D"/>
            <Item ID="0x3B0E"/>
            <Item ID="0x3B0F"/>
            <Item ID="0x3B10"/>
            <Item ID="0x3B11"/>
            <Item ID="0x3B12"/>
            <Item ID="0x3B13"/>
            <Item ID="0x3B14"/>
            <Item ID="0x3B15"/>
        </Group>
        <Group name="Sweet Life">
            <Group name="Bar">
                <Item ID="0x190E"/>
                <Item ID="0x190F"/>
                <Item ID="0x1910"/>
                <Item ID="0x1911"/>
                <Item ID="0x1912"/>
                <Item ID="0x1913"/>
                <Item ID="0x1918"/>
                <Item ID="0x1919"/>
                <Item ID="0x191A"/>
                <Item ID="0x191B"/>
                <Item ID="0x191C"/>
                <Item ID="0x191D"/>
                <Item ID="0x191E"/>
                <Item ID="0x191F"/>
                <Item ID="0x1941"/>
                <Item ID="0x1942"/>
                <Item ID="0x1943"/>
                <Item ID="0x1AD6"/>
                <Item ID="0x1AD7"/>
            </Group>
            <Group name="Drinking">
                <Item ID="0x098D"/>
                <Item ID="0x098E"/>
                <Item ID="0x0995"/>
                <Item ID="0x0996"/>
                <Item ID="0x0997"/>
                <Item ID="0x0998"/>
                <Item ID="0x0999"/>
                <Item ID="0x099A"/>
                <Item ID="0x099B"/>
                <Item ID="0x099C"/>
                <Item ID="0x099D"/>
                <Item ID="0x099E"/>
                <Item ID="0x099F"/>
                <Item ID="0x09A0"/>
                <Item ID="0x09A1"/>
                <Item ID="0x09A2"/>
                <Item ID="0x09A7"/>
                <Item ID="0x09AD"/>
                <Item ID="0x09B3"/>
                <Item ID="0x09BF"/>
                <Item ID="0x09C4"/>
                <Item ID="0x09C5"/>
                <Item ID="0x09C6"/>
                <Item ID="0x09C7"/>
                <Item ID="0x09C8"/>
                <Item ID="0x09CA"/>
                <Item ID="0x09CB"/>
                <Item ID="0x09D6"/>
                <Item ID="0x09EE"/>
                <Item ID="0x09EF"/>
                <Item ID="0x09F0"/>
                <Item ID="0x0FF6"/>
                <Item ID="0x0FF7"/>
                <Item ID="0x0FF8"/>
                <Item ID="0x0FF9"/>
                <Item ID="0x0FFB"/>
                <Item ID="0x0FFC"/>
                <Item ID="0x0FFD"/>
                <Item ID="0x0FFE"/>
                <Item ID="0x0FFF"/>
                <Item ID="0x1000"/>
                <Item ID="0x1001"/>
                <Item ID="0x1002"/>
                <Item ID="0x1f7d"/>
                <Item ID="0x1f7e"/>
                <Item ID="0x1f7f"/>
                <Item ID="0x1f80"/>
                <Item ID="0x1f81"/>
                <Item ID="0x1f82"/>
                <Item ID="0x1f83"/>
                <Item ID="0x1f84"/>
                <Item ID="0x1f85"/>
                <Item ID="0x1f86"/>
                <Item ID="0x1f87"/>
                <Item ID="0x1f88"/>
                <Item ID="0x1f89"/>
                <Item ID="0x1f8a"/>
                <Item ID="0x1f8b"/>
                <Item ID="0x1f8c"/>
                <Item ID="0x1f8d"/>
                <Item ID="0x1f8e"/>
                <Item ID="0x1f8f"/>
                <Item ID="0x1f90"/>
                <Item ID="0x1f91"/>
                <Item ID="0x1f92"/>
                <Item ID="0x1f93"/>
                <Item ID="0x1f94"/>
                <Item ID="0x1f95"/>
                <Item ID="0x1f96"/>
                <Item ID="0x1f97"/>
                <Item ID="0x1f98"/>
                <Item ID="0x1f99"/>
                <Item ID="0x1f9a"/>
                <Item ID="0x1f9b"/>
                <Item ID="0x1f9c"/>
                <Item ID="0x1f9d"/>
                <Item ID="0x1f9e"/>
                <Item ID="0x24E1"/>
                <Item ID="0x24E2"/>
                <Item ID="0x24E6"/>
                <Item ID="0x24E7"/>
                <Item ID="0x284B"/>
                <Item ID="0x284C"/>
            </Group>
            <Group name="Eating">
                <Item ID="0x0976"/>
                <Item ID="0x0977"/>
                <Item ID="0x0978"/>
                <Item ID="0x0979"/>
                <Item ID="0x097A"/>
                <Item ID="0x097B"/>
                <Item ID="0x097C"/>
                <Item ID="0x097D"/>
                <Item ID="0x097E"/>
                <Item ID="0x098C"/>
                <Item ID="0x0993"/>
                <Item ID="0x0994"/>
                <Item ID="0x09A3"/>
                <Item ID="0x09A4"/>
                <Item ID="0x09A5"/>
                <Item ID="0x09A6"/>
                <Item ID="0x09AE"/>
                <Item ID="0x09AF"/>
                <Item ID="0x09B4"/>
                <Item ID="0x09B5"/>
                <Item ID="0x09B6"/>
                <Item ID="0x09B7"/>
                <Item ID="0x09B8"/>
                <Item ID="0x09B9"/>
                <Item ID="0x09BA"/>
                <Item ID="0x09BB"/>
                <Item ID="0x09BC"/>
                <Item ID="0x09BD"/>
                <Item ID="0x09BE"/>
                <Item ID="0x09C0"/>
                <Item ID="0x09C1"/>
                <Item ID="0x09C2"/>
                <Item ID="0x09C3"/>
                <Item ID="0x09C9"/>
                <Item ID="0x09CC"/>
                <Item ID="0x09CD"/>
                <Item ID="0x09CE"/>
                <Item ID="0x09CF"/>
                <Item ID="0x09D0"/>
                <Item ID="0x09D1"/>
                <Item ID="0x09D2"/>
                <Item ID="0x09D3"/>
                <Item ID="0x09D4"/>
                <Item ID="0x09D5"/>
                <Item ID="0x09D7"/>
                <Item ID="0x09D8"/>
                <Item ID="0x09D9"/>
                <Item ID="0x09DA"/>
                <Item ID="0x09E9"/>
                <Item ID="0x09EA"/>
                <Item ID="0x09EB"/>
                <Item ID="0x09EC"/>
                <Item ID="0x09F1"/>
                <Item ID="0x09F2"/>
                <Item ID="0x09F4"/>
                <Item ID="0x09F5"/>
                <Item ID="0x09F6"/>
                <Item ID="0x09F7"/>
                <Item ID="0x09F8"/>
                <Item ID="0x09F9"/>
                <Item ID="0x09FA"/>
                <Item ID="0x0C5C"/>
                <Item ID="0x0C5D"/>
                <Item ID="0x0C6A"/>
                <Item ID="0x0C6B"/>
                <Item ID="0x0C6C"/>
                <Item ID="0x0C6D"/>
                <Item ID="0x0C6E"/>
                <Item ID="0x0C70"/>
                <Item ID="0x0C71"/>
                <Item ID="0x0C72"/>
                <Item ID="0x0C73"/>
                <Item ID="0x0C74"/>
                <Item ID="0x0C75"/>
                <Item ID="0x0C77"/>
                <Item ID="0x0C78"/>
                <Item ID="0x0C79"/>
                <Item ID="0x0C7A"/>
                <Item ID="0x0C7B"/>
                <Item ID="0x0C7C"/>
                <Item ID="0x0C7F"/>
                <Item ID="0x0C80"/>
                <Item ID="0x0C81"/>
                <Item ID="0x0C82"/>
                <Item ID="0x103B"/>
                <Item ID="0x103C"/>
                <Item ID="0x1040"/>
                <Item ID="0x1041"/>
                <Item ID="0x1042"/>
                <Item ID="0x15F9"/>
                <Item ID="0x15FA"/>
                <Item ID="0x15FB"/>
                <Item ID="0x15FC"/>
                <Item ID="0x15FD"/>
                <Item ID="0x15FE"/>
                <Item ID="0x15FF"/>
                <Item ID="0x1600"/>
                <Item ID="0x1601"/>
                <Item ID="0x1602"/>
                <Item ID="0x1604"/>
                <Item ID="0x1605"/>
                <Item ID="0x1606"/>
                <Item ID="0x1607"/>
                <Item ID="0x1608"/>
                <Item ID="0x1609"/>
                <Item ID="0x160A"/>
                <Item ID="0x160B"/>
                <Item ID="0x160C"/>
                <Item ID="0x171D"/>
                <Item ID="0x171E"/>
                <Item ID="0x171F"/>
                <Item ID="0x1720"/>
                <Item ID="0x1721"/>
                <Item ID="0x1722"/>
                <Item ID="0x1723"/>
                <Item ID="0x1724"/>
                <Item ID="0x1725"/>
                <Item ID="0x1726"/>
                <Item ID="0x1727"/>
                <Item ID="0x1728"/>
                <Item ID="0x1729"/>
                <Item ID="0x172A"/>
                <Item ID="0x172B"/>
                <Item ID="0x172C"/>
                <Item ID="0x172D"/>
                <Item ID="0x1E15"/>
                <Item ID="0x1E16"/>
                <Item ID="0x1E17"/>
                <Item ID="0x1E18"/>
                <Item ID="0x1E19"/>
                <Item ID="0x1E1A"/>
                <Item ID="0x1E1B"/>
                <Item ID="0x1E1C"/>
                <Item ID="0x1E1D"/>
                <Item ID="0x1E1E"/>
                <Item ID="0x1E1F"/>
                <Item ID="0x1ad3"/>
                <Item ID="0x24DE"/>
                <Item ID="0x24DF"/>
                <Item ID="0x24E0"/>
                <Item ID="0x24E8"/>
                <Item ID="0x24E9"/>
                <Item ID="0x24EB"/>
                <Item ID="0x2834"/>
                <Item ID="0x2835"/>
                <Item ID="0x2836"/>
                <Item ID="0x2837"/>
                <Item ID="0x283E"/>
                <Item ID="0x283F"/>
                <Item ID="0x2840"/>
                <Item ID="0x2841"/>
                <Item ID="0x284D"/>
                <Item ID="0x284E"/>
                <Item ID="0x284F"/>
                <Item ID="0x2850"/>
                <Item ID="0x2D4F"/>
                <Item ID="0x2Fd6"/>
                <Item ID="0x2Fd7"/>
                <Item ID="0x2Fd8"/>
            </Group>
            <Group name="Games">
                <Item ID="0x0E12"/>
                <Item ID="0x0E13"/>
                <Item ID="0x0E14"/>
                <Item ID="0x0E15"/>
                <Item ID="0x0E16"/>
                <Item ID="0x0E17"/>
                <Item ID="0x0E18"/>
                <Item ID="0x0E19"/>
                <Item ID="0x0E1A"/>
                <Item ID="0x0E1B"/>
                <Item ID="0x0E1C"/>
                <Item ID="0x0FA2"/>
                <Item ID="0x0FA3"/>
                <Item ID="0x0FA4"/>
                <Item ID="0x0FA5"/>
                <Item ID="0x0FA6"/>
                <Item ID="0x0FA7"/>
                <Item ID="0x0FA8"/>
                <Item ID="0x0FAA"/>
                <Item ID="0x0FAD"/>
                <Item ID="0x12A5"/>
                <Item ID="0x12A6"/>
                <Item ID="0x12A7"/>
                <Item ID="0x12A8"/>
                <Item ID="0x12A9"/>
                <Item ID="0x12AA"/>
                <Item ID="0x12AB"/>
                <Item ID="0x12AC"/>
                <Item ID="0x1E2e"/>
                <Item ID="0x1E2f"/>
                <Item ID="0x1E30"/>
                <Item ID="0x1E31"/>
                <Item ID="0x1E32"/>
                <Item ID="0x1E33"/>
                <Item ID="0x2256"/>
                <Item ID="0x2257"/>
                <Item ID="0x2830"/>
                <Item ID="0x2831"/>
                <Item ID="0x2838"/>
                <Item ID="0x2839"/>
                <Item ID="0x283A"/>
                <Item ID="0x283B"/>
                <Item ID="0x283C"/>
                <Item ID="0x283D"/>
            </Group>
            <Group name="Music">
                <Item ID="0x0E9C"/>
                <Item ID="0x0E9D"/>
                <Item ID="0x0E9E"/>
                <Item ID="0x0EB1"/>
                <Item ID="0x0EB2"/>
                <Item ID="0x0EB3"/>
                <Item ID="0x0EB4"/>
                <Item ID="0x0EB5"/>
                <Item ID="0x0EB6"/>
                <Item ID="0x0EB7"/>
                <Item ID="0x0EB8"/>
                <Item ID="0x0EB9"/>
                <Item ID="0x0EBA"/>
                <Item ID="0x0EBB"/>
                <Item ID="0x0EBC"/>
                <Item ID="0x0EBD"/>
                <Item ID="0x0EBE"/>
                <Item ID="0x0EBF"/>
                <Item ID="0x0EC0"/>
                <Item ID="0x2805"/>
                <Item ID="0x2807"/>
                <Item ID="0x2832"/>
                <Item ID="0x2833"/>
                <Item ID="0x2AF9"/>
                <Item ID="0x2AFD"/>
                <Item ID="0x2AFa"/>
                <Item ID="0x2AFe"/>
            </Group>
        </Group>
    </Group>
    <Group name="Equipment">
        <Group name="Amazon">
            <Item ID="0x2659"/>
            <Item ID="0x265A"/>
            <Item ID="0x265B"/>
            <Item ID="0x265C"/>
            <Item ID="0x265D"/>
            <Item ID="0x265E"/>
        </Group>
        <Group name="Arcana Clothes">
            <Item ID="0x26AD"/>
            <Item ID="0x26AE"/>
            <Item ID="0x26AF"/>
            <Item ID="0x26B0"/>
        </Group>
        <Group name="Armor Female">
            <Item ID="0x1C00"/>
            <Item ID="0x1C01"/>
            <Item ID="0x1C02"/>
            <Item ID="0x1C03"/>
            <Item ID="0x1C04"/>
            <Item ID="0x1C05"/>
            <Item ID="0x1C06"/>
            <Item ID="0x1C07"/>
            <Item ID="0x1C08"/>
            <Item ID="0x1C09"/>
            <Item ID="0x1C0A"/>
            <Item ID="0x1C0B"/>
            <Item ID="0x1C0C"/>
            <Item ID="0x1C0D"/>
        </Group>
        <Group name="Bone">
            <Item ID="0x144E"/>
            <Item ID="0x144F"/>
            <Item ID="0x1450"/>
            <Item ID="0x1451"/>
            <Item ID="0x1452"/>
            <Item ID="0x1453"/>
            <Item ID="0x1454"/>
            <Item ID="0x1455"/>
            <Item ID="0x1456"/>
            <Item ID="0x1457"/>
        </Group>
        <Group name="Chainmail">
            <Item ID="0x13BB"/>
            <Item ID="0x13BE"/>
            <Item ID="0x13BF"/>
            <Item ID="0x13C0"/>
            <Item ID="0x13C3"/>
            <Item ID="0x13C4"/>
        </Group>
        <Group name="Dragon Armor">
            <Item ID="0x2641"/>
            <Item ID="0x2642"/>
            <Item ID="0x2643"/>
            <Item ID="0x2644"/>
            <Item ID="0x2645"/>
            <Item ID="0x2646"/>
            <Item ID="0x2647"/>
            <Item ID="0x2648"/>
        </Group>
        <Group name="Dresses + Skirts">
            <Item ID="0x1515"/>
            <Item ID="0x1516"/>
            <Item ID="0x1531"/>
            <Item ID="0x1537"/>
            <Item ID="0x1538"/>
            <Item ID="0x1EFF"/>
            <Item ID="0x1F00"/>
            <Item ID="0x1F01"/>
            <Item ID="0x1F02"/>
            <Item ID="0x267B"/>
            <Item ID="0x267C"/>
            <Item ID="0x267D"/>
            <Item ID="0x267E"/>
            <Item ID="0x267F"/>
            <Item ID="0x2680"/>
            <Item ID="0x2681"/>
            <Item ID="0x2682"/>
            <Item ID="0x2783"/>
            <Item ID="0x279A"/>
            <Item ID="0x27CE"/>
            <Item ID="0x27E5"/>
        </Group>
        <Group name="Elven Equipment">
            <Item ID="0x2B67"/>
            <Item ID="0x2B68"/>
            <Item ID="0x2B69"/>
            <Item ID="0x2B6A"/>
            <Item ID="0x2B6B"/>
            <Item ID="0x2B6C"/>
            <Item ID="0x2B6D"/>
            <Item ID="0x2B6E"/>
            <Item ID="0x2B6F"/>
            <Item ID="0x2B70"/>
            <Item ID="0x2B71"/>
            <Item ID="0x2B72"/>
            <Item ID="0x2B73"/>
            <Item ID="0x2B74"/>
            <Item ID="0x2B75"/>
            <Item ID="0x2B76"/>
            <Item ID="0x2B77"/>
            <Item ID="0x2B78"/>
            <Item ID="0x2B79"/>
            <Item ID="0x2FB9"/>
            <Item ID="0x2FBA"/>
            <Item ID="0x2FC3"/>
            <Item ID="0x2FC4"/>
            <Item ID="0x2FC5"/>
            <Item ID="0x2FC6"/>
            <Item ID="0x2FC7"/>
            <Item ID="0x2FC8"/>
            <Item ID="0x2FC9"/>
            <Item ID="0x2FCA"/>
            <Item ID="0x2FCB"/>
            <Item ID="0x315E"/>
            <Item ID="0x315F"/>
            <Item ID="0x3160"/>
            <Item ID="0x3161"/>
            <Item ID="0x3162"/>
            <Item ID="0x3163"/>
            <Item ID="0x3164"/>
            <Item ID="0x3165"/>
            <Item ID="0x3166"/>
            <Item ID="0x3167"/>
            <Item ID="0x3168"/>
            <Item ID="0x3169"/>
            <Item ID="0x316A"/>
            <Item ID="0x316B"/>
            <Item ID="0x316C"/>
            <Item ID="0x316D"/>
            <Item ID="0x316E"/>
            <Item ID="0x316F"/>
            <Item ID="0x3170"/>
            <Item ID="0x3173"/>
            <Item ID="0x3174"/>
            <Item ID="0x3175"/>
            <Item ID="0x3176"/>
            <Item ID="0x3177"/>
            <Item ID="0x3178"/>
            <Item ID="0x3179"/>
            <Item ID="0x317A"/>
            <Item ID="0x317B"/>
            <Item ID="0x317C"/>
            <Item ID="0x317D"/>
            <Item ID="0x317E"/>
            <Item ID="0x317F"/>
            <Item ID="0x3180"/>
            <Item ID="0x3181"/>
        </Group>
        <Group name="Elven Weapon">
            <Item ID="0x2D1E"/>
            <Item ID="0x2D1F"/>
            <Item ID="0x2D20"/>
            <Item ID="0x2D21"/>
            <Item ID="0x2D22"/>
            <Item ID="0x2D23"/>
            <Item ID="0x2D24"/>
            <Item ID="0x2D25"/>
            <Item ID="0x2D26"/>
            <Item ID="0x2D27"/>
            <Item ID="0x2D28"/>
            <Item ID="0x2D29"/>
            <Item ID="0x2D2A"/>
            <Item ID="0x2D2B"/>
            <Item ID="0x2D2C"/>
            <Item ID="0x2D2D"/>
            <Item ID="0x2D2E"/>
            <Item ID="0x2D2F"/>
            <Item ID="0x2D30"/>
            <Item ID="0x2D31"/>
            <Item ID="0x2D32"/>
            <Item ID="0x2D33"/>
            <Item ID="0x2D34"/>
            <Item ID="0x2D35"/>
            <Item ID="0x3171"/>
        </Group>
        <Group name="Footwear + Pants">
            <Item ID="0x152E"/>
            <Item ID="0x1539"/>
            <Item ID="0x153A"/>
            <Item ID="0x170B"/>
            <Item ID="0x170C"/>
            <Item ID="0x170D"/>
            <Item ID="0x170E"/>
            <Item ID="0x170F"/>
            <Item ID="0x1710"/>
            <Item ID="0x1711"/>
            <Item ID="0x1712"/>
            <Item ID="0x264F"/>
            <Item ID="0x2650"/>
            <Item ID="0x279B"/>
            <Item ID="0x27E6"/>
        </Group>
        <Group name="Gargoyle">
            <Item ID="0x0283"/>
            <Item ID="0x0284"/>
            <Item ID="0x0285"/>
            <Item ID="0x0286"/>
            <Item ID="0x0287"/>
            <Item ID="0x0288"/>
            <Item ID="0x0289"/>
            <Item ID="0x028a"/>
            <Item ID="0x0301"/>
            <Item ID="0x0302"/>
            <Item ID="0x0303"/>
            <Item ID="0x0304"/>
            <Item ID="0x0305"/>
            <Item ID="0x0306"/>
            <Item ID="0x0307"/>
            <Item ID="0x0308"/>
            <Item ID="0x0309"/>
            <Item ID="0x030a"/>
            <Item ID="0x030b"/>
            <Item ID="0x030c"/>
            <Item ID="0x030d"/>
            <Item ID="0x030e"/>
            <Item ID="0x0310"/>
            <Item ID="0x0311"/>
            <Item ID="0x0403"/>
            <Item ID="0x0404"/>
            <Item ID="0x0405"/>
            <Item ID="0x0406"/>
            <Item ID="0x0407"/>
            <Item ID="0x0408"/>
            <Item ID="0x0409"/>
            <Item ID="0x040a"/>
        </Group>
        <Group name="Hanging Armor">
            <Item ID="0x13BC"/>
            <Item ID="0x13BD"/>
            <Item ID="0x13C1"/>
            <Item ID="0x13C2"/>
            <Item ID="0x13C8"/>
            <Item ID="0x13C9"/>
            <Item ID="0x13CA"/>
            <Item ID="0x13CF"/>
            <Item ID="0x13D0"/>
            <Item ID="0x13D1"/>
            <Item ID="0x13D7"/>
            <Item ID="0x13D8"/>
            <Item ID="0x13D9"/>
            <Item ID="0x13DE"/>
            <Item ID="0x13DF"/>
            <Item ID="0x13E0"/>
            <Item ID="0x13E5"/>
            <Item ID="0x13E6"/>
            <Item ID="0x13E7"/>
            <Item ID="0x13E8"/>
            <Item ID="0x13E9"/>
            <Item ID="0x13EA"/>
        </Group>
        <Group name="Hats, Masks, Helmets">
            <Item ID="0x141B"/>
            <Item ID="0x141C"/>
            <Item ID="0x153F"/>
            <Item ID="0x1540"/>
            <Item ID="0x1543"/>
            <Item ID="0x1544"/>
            <Item ID="0x1545"/>
            <Item ID="0x1546"/>
            <Item ID="0x1547"/>
            <Item ID="0x1548"/>
            <Item ID="0x1549"/>
            <Item ID="0x154A"/>
            <Item ID="0x154B"/>
            <Item ID="0x154C"/>
            <Item ID="0x1713"/>
            <Item ID="0x1714"/>
            <Item ID="0x1715"/>
            <Item ID="0x1716"/>
            <Item ID="0x1717"/>
            <Item ID="0x1718"/>
            <Item ID="0x1719"/>
            <Item ID="0x171A"/>
            <Item ID="0x171B"/>
            <Item ID="0x19Bc"/>
            <Item ID="0x19Bd"/>
            <Item ID="0x1F0B"/>
            <Item ID="0x1F0C"/>
            <Item ID="0x236C"/>
            <Item ID="0x236D"/>
            <Item ID="0x2689"/>
            <Item ID="0x268A"/>
            <Item ID="0x268B"/>
            <Item ID="0x268C"/>
            <Item ID="0x268D"/>
            <Item ID="0x268E"/>
            <Item ID="0x268F"/>
            <Item ID="0x2690"/>
            <Item ID="0x269D"/>
            <Item ID="0x269E"/>
            <Item ID="0x26A1"/>
            <Item ID="0x26A2"/>
            <Item ID="0x26A3"/>
            <Item ID="0x26A4"/>
            <Item ID="0x2776"/>
            <Item ID="0x2777"/>
            <Item ID="0x2778"/>
            <Item ID="0x2784"/>
            <Item ID="0x2785"/>
            <Item ID="0x2789"/>
            <Item ID="0x278E"/>
            <Item ID="0x278F"/>
            <Item ID="0x2798"/>
            <Item ID="0x27C1"/>
            <Item ID="0x27C2"/>
            <Item ID="0x27C3"/>
            <Item ID="0x27CC"/>
            <Item ID="0x27CF"/>
            <Item ID="0x27D0"/>
            <Item ID="0x27D4"/>
            <Item ID="0x27D9"/>
            <Item ID="0x27DA"/>
            <Item ID="0x27E3"/>
        </Group>
        <Group name="Jester">
            <Item ID="0x171C"/>
            <Item ID="0x1F9F"/>
            <Item ID="0x1FA0"/>
            <Item ID="0x2649"/>
            <Item ID="0x264A"/>
            <Item ID="0x2655"/>
            <Item ID="0x2656"/>
        </Group>
        <Group name="Leather">
            <Item ID="0x13C5"/>
            <Item ID="0x13C6"/>
            <Item ID="0x13C7"/>
            <Item ID="0x13CB"/>
            <Item ID="0x13CC"/>
            <Item ID="0x13CD"/>
            <Item ID="0x13CE"/>
            <Item ID="0x13D2"/>
            <Item ID="0x13D3"/>
            <Item ID="0x2691"/>
            <Item ID="0x2692"/>
        </Group>
        <Group name="Misc">
            <Item ID="0x153B"/>
            <Item ID="0x153C"/>
            <Item ID="0x153D"/>
            <Item ID="0x153E"/>
            <Item ID="0x1541"/>
            <Item ID="0x1542"/>
            <Item ID="0x27A0"/>
            <Item ID="0x27EB"/>
        </Group>
        <Group name="Plate">
            <Item ID="0x1408"/>
            <Item ID="0x1409"/>
            <Item ID="0x140A"/>
            <Item ID="0x140B"/>
            <Item ID="0x140C"/>
            <Item ID="0x140D"/>
            <Item ID="0x140E"/>
            <Item ID="0x140F"/>
            <Item ID="0x1410"/>
            <Item ID="0x1411"/>
            <Item ID="0x1412"/>
            <Item ID="0x1413"/>
            <Item ID="0x1414"/>
            <Item ID="0x1415"/>
            <Item ID="0x1416"/>
            <Item ID="0x1417"/>
            <Item ID="0x1418"/>
            <Item ID="0x1419"/>
            <Item ID="0x141A"/>
            <Item ID="0x264B"/>
            <Item ID="0x264C"/>
        </Group>
        <Group name="Ringmail">
            <Item ID="0x13EB"/>
            <Item ID="0x13EC"/>
            <Item ID="0x13ED"/>
            <Item ID="0x13EE"/>
            <Item ID="0x13EF"/>
            <Item ID="0x13F0"/>
            <Item ID="0x13F1"/>
            <Item ID="0x13F2"/>
        </Group>
        <Group name="Samurai Weapon">
            <Item ID="0x27A2"/>
            <Item ID="0x27A3"/>
            <Item ID="0x27A4"/>
            <Item ID="0x27A5"/>
            <Item ID="0x27A6"/>
            <Item ID="0x27A7"/>
            <Item ID="0x27A8"/>
            <Item ID="0x27A9"/>
            <Item ID="0x27AA"/>
            <Item ID="0x27AB"/>
            <Item ID="0x27AC"/>
            <Item ID="0x27AD"/>
            <Item ID="0x27AE"/>
            <Item ID="0x27AF"/>
            <Item ID="0x27ED"/>
            <Item ID="0x27EE"/>
            <Item ID="0x27EF"/>
            <Item ID="0x27F0"/>
            <Item ID="0x27F1"/>
            <Item ID="0x27F2"/>
            <Item ID="0x27F3"/>
            <Item ID="0x27F4"/>
            <Item ID="0x27F5"/>
            <Item ID="0x27F6"/>
            <Item ID="0x27F7"/>
            <Item ID="0x27F8"/>
            <Item ID="0x27F9"/>
            <Item ID="0x27FA"/>
            <Item ID="0x2804"/>
            <Item ID="0x2806"/>
            <Item ID="0x2808"/>
            <Item ID="0x2808"/>
        </Group>
        <Group name="Samurai+Ninja">
            <Item ID="0x264D"/>
            <Item ID="0x264E"/>
            <Item ID="0x2651"/>
            <Item ID="0x2652"/>
            <Item ID="0x2653"/>
            <Item ID="0x2654"/>
            <Item ID="0x2667"/>
            <Item ID="0x2668"/>
            <Item ID="0x266B"/>
            <Item ID="0x266C"/>
            <Item ID="0x266D"/>
            <Item ID="0x266E"/>
            <Item ID="0x2673"/>
            <Item ID="0x2674"/>
            <Item ID="0x2677"/>
            <Item ID="0x2678"/>
            <Item ID="0x2679"/>
            <Item ID="0x267A"/>
            <Item ID="0x2774"/>
            <Item ID="0x2775"/>
            <Item ID="0x2779"/>
            <Item ID="0x277A"/>
            <Item ID="0x277B"/>
            <Item ID="0x277C"/>
            <Item ID="0x277D"/>
            <Item ID="0x277E"/>
            <Item ID="0x277F"/>
            <Item ID="0x2780"/>
            <Item ID="0x2786"/>
            <Item ID="0x2787"/>
            <Item ID="0x2788"/>
            <Item ID="0x278A"/>
            <Item ID="0x278B"/>
            <Item ID="0x278D"/>
            <Item ID="0x2790"/>
            <Item ID="0x2791"/>
            <Item ID="0x2792"/>
            <Item ID="0x2793"/>
            <Item ID="0x2794"/>
            <Item ID="0x2796"/>
            <Item ID="0x2797"/>
            <Item ID="0x279D"/>
            <Item ID="0x27A1"/>
            <Item ID="0x27BF"/>
            <Item ID="0x27C0"/>
            <Item ID="0x27C4"/>
            <Item ID="0x27C5"/>
            <Item ID="0x27C6"/>
            <Item ID="0x27C7"/>
            <Item ID="0x27C8"/>
            <Item ID="0x27C9"/>
            <Item ID="0x27CA"/>
            <Item ID="0x27CB"/>
            <Item ID="0x27D1"/>
            <Item ID="0x27D2"/>
            <Item ID="0x27D3"/>
            <Item ID="0x27D5"/>
            <Item ID="0x27D6"/>
            <Item ID="0x27D8"/>
            <Item ID="0x27DB"/>
            <Item ID="0x27DC"/>
            <Item ID="0x27DD"/>
            <Item ID="0x27DE"/>
            <Item ID="0x27DF"/>
            <Item ID="0x27E1"/>
            <Item ID="0x27E2"/>
            <Item ID="0x27E8"/>
            <Item ID="0x27EC"/>
        </Group>
        <Group name="Shields">
            <Item ID="0x1B72"/>
            <Item ID="0x1B73"/>
            <Item ID="0x1B74"/>
            <Item ID="0x1B75"/>
            <Item ID="0x1B76"/>
            <Item ID="0x1B77"/>
            <Item ID="0x1B78"/>
            <Item ID="0x1B79"/>
            <Item ID="0x1B7A"/>
            <Item ID="0x1B7B"/>
            <Item ID="0x1BC3"/>
            <Item ID="0x1BC4"/>
            <Item ID="0x1BC5"/>
            <Item ID="0x1BC6"/>
            <Item ID="0x1BC7"/>
        </Group>
        <Group name="Shirts + Tunics">
            <Item ID="0x1517"/>
            <Item ID="0x1518"/>
            <Item ID="0x1EFD"/>
            <Item ID="0x1EFE"/>
            <Item ID="0x1F7B"/>
            <Item ID="0x1F7C"/>
            <Item ID="0x1FA1"/>
            <Item ID="0x1FA2"/>
            <Item ID="0x1FFD"/>
            <Item ID="0x1FFE"/>
            <Item ID="0x265F"/>
            <Item ID="0x2660"/>
            <Item ID="0x2661"/>
            <Item ID="0x2662"/>
            <Item ID="0x2663"/>
            <Item ID="0x2664"/>
            <Item ID="0x2665"/>
            <Item ID="0x2666"/>
            <Item ID="0x2671"/>
            <Item ID="0x2672"/>
            <Item ID="0x2799"/>
            <Item ID="0x279C"/>
            <Item ID="0x27E4"/>
            <Item ID="0x27E7"/>
        </Group>
        <Group name="Shrouds + Cloaks">
            <Item ID="0x1530"/>
            <Item ID="0x1F03"/>
            <Item ID="0x1F04"/>
            <Item ID="0x2683"/>
            <Item ID="0x2684"/>
            <Item ID="0x2685"/>
            <Item ID="0x2686"/>
            <Item ID="0x2687"/>
            <Item ID="0x2782"/>
            <Item ID="0x27CD"/>
        </Group>
        <Group name="Studded">
            <Item ID="0x13D4"/>
            <Item ID="0x13D5"/>
            <Item ID="0x13D6"/>
            <Item ID="0x13DA"/>
            <Item ID="0x13DB"/>
            <Item ID="0x13DC"/>
            <Item ID="0x13DD"/>
            <Item ID="0x13E1"/>
            <Item ID="0x13E2"/>
        </Group>
        <Group name="Weapon + Tools">
            <Item ID="0x0DF0"/>
            <Item ID="0x0DF1"/>
            <Item ID="0x0E81"/>
            <Item ID="0x0E82"/>
            <Item ID="0x0E85"/>
            <Item ID="0x0E86"/>
            <Item ID="0x0E87"/>
            <Item ID="0x0E88"/>
            <Item ID="0x0E89"/>
            <Item ID="0x0E8A"/>
            <Item ID="0x0F43"/>
            <Item ID="0x0F44"/>
            <Item ID="0x0F45"/>
            <Item ID="0x0F46"/>
            <Item ID="0x0F47"/>
            <Item ID="0x0F48"/>
            <Item ID="0x0F49"/>
            <Item ID="0x0F4A"/>
            <Item ID="0x0F4B"/>
            <Item ID="0x0F4C"/>
            <Item ID="0x0F4D"/>
            <Item ID="0x0F4E"/>
            <Item ID="0x0F4F"/>
            <Item ID="0x0F50"/>
            <Item ID="0x0F51"/>
            <Item ID="0x0F52"/>
            <Item ID="0x0F5C"/>
            <Item ID="0x0F5D"/>
            <Item ID="0x0F5E"/>
            <Item ID="0x0F5F"/>
            <Item ID="0x0F60"/>
            <Item ID="0x0F61"/>
            <Item ID="0x0F62"/>
            <Item ID="0x0F63"/>
            <Item ID="0x13AF"/>
            <Item ID="0x13B0"/>
            <Item ID="0x13B1"/>
            <Item ID="0x13B2"/>
            <Item ID="0x13B3"/>
            <Item ID="0x13B4"/>
            <Item ID="0x13B5"/>
            <Item ID="0x13B6"/>
            <Item ID="0x13B7"/>
            <Item ID="0x13B8"/>
            <Item ID="0x13B9"/>
            <Item ID="0x13BA"/>
            <Item ID="0x13E3"/>
            <Item ID="0x13E4"/>
            <Item ID="0x13F4"/>
            <Item ID="0x13F5"/>
            <Item ID="0x13F6"/>
            <Item ID="0x13F7"/>
            <Item ID="0x13F8"/>
            <Item ID="0x13F9"/>
            <Item ID="0x13FA"/>
            <Item ID="0x13FB"/>
            <Item ID="0x13FC"/>
            <Item ID="0x13FD"/>
            <Item ID="0x13FE"/>
            <Item ID="0x13FF"/>
            <Item ID="0x1400"/>
            <Item ID="0x1401"/>
            <Item ID="0x1402"/>
            <Item ID="0x1403"/>
            <Item ID="0x1404"/>
            <Item ID="0x1405"/>
            <Item ID="0x1406"/>
            <Item ID="0x1407"/>
            <Item ID="0x1438"/>
            <Item ID="0x1439"/>
            <Item ID="0x143A"/>
            <Item ID="0x143B"/>
            <Item ID="0x143C"/>
            <Item ID="0x143D"/>
            <Item ID="0x143E"/>
            <Item ID="0x143F"/>
            <Item ID="0x1440"/>
            <Item ID="0x1441"/>
            <Item ID="0x1442"/>
            <Item ID="0x1443"/>
            <Item ID="0x26BA"/>
            <Item ID="0x26BB"/>
            <Item ID="0x26BC"/>
            <Item ID="0x26BD"/>
            <Item ID="0x26BE"/>
            <Item ID="0x26BF"/>
            <Item ID="0x26C0"/>
            <Item ID="0x26C1"/>
            <Item ID="0x26C2"/>
            <Item ID="0x26C3"/>
            <Item ID="0x26C4"/>
            <Item ID="0x26C5"/>
            <Item ID="0x26C6"/>
            <Item ID="0x26C7"/>
            <Item ID="0x26C8"/>
            <Item ID="0x26C9"/>
            <Item ID="0x26CA"/>
            <Item ID="0x26CB"/>
            <Item ID="0x26CC"/>
            <Item ID="0x26CD"/>
            <Item ID="0x26CE"/>
            <Item ID="0x26CF"/>
            <Item ID="0x26ac"/>
        </Group>
    </Group>
    <Group name="Miniatures + Celebrations">
        <Group name="8th Anniversary Items">
            <Item ID="0x2B01"/>
            <Item ID="0x2B02"/>
            <Item ID="0x2B03"/>
            <Item ID="0x2B04"/>
            <Item ID="0x2B05"/>
            <Item ID="0x2B06"/>
            <Item ID="0x2B07"/>
            <Item ID="0x2B08"/>
            <Item ID="0x2B09"/>
            <Item ID="0x2B0A"/>
            <Item ID="0x2B0B"/>
            <Item ID="0x2B0C"/>
            <Item ID="0x2B0D"/>
            <Item ID="0x2B0E"/>
            <Item ID="0x2B0F"/>
            <Item ID="0x2B10"/>
            <Item ID="0x2B11"/>
            <Item ID="0x2B12"/>
            <Item ID="0x2B13"/>
        </Group>
        <Group name="9th Anniversary Items">
            <Item ID="0x3DB1"/>
            <Item ID="0x3F07"/>
            <Item ID="0x3F08"/>
            <Item ID="0x3F09"/>
            <Item ID="0x3F0A"/>
            <Item ID="0x3F0B"/>
            <Item ID="0x3F0C"/>
            <Item ID="0x3F0D"/>
            <Item ID="0x3F0E"/>
            <Item ID="0x3F0F"/>
            <Item ID="0x3F10"/>
            <Item ID="0x3F11"/>
            <Item ID="0x3F12"/>
            <Item ID="0x3F13"/>
            <Item ID="0x3F14"/>
            <Item ID="0x3F15"/>
            <Item ID="0x3F16"/>
            <Item ID="0x3F17"/>
            <Item ID="0x3F18"/>
            <Item ID="0x3F19"/>
            <Item ID="0x3F1A"/>
            <Item ID="0x3F1B"/>
            <Item ID="0x3F1C"/>
            <Item ID="0x3F1D"/>
            <Item ID="0x3F1E"/>
            <Item ID="0x3F1F"/>
            <Item ID="0x3F20"/>
            <Item ID="0x3F21"/>
            <Item ID="0x3F22"/>
            <Item ID="0x3F23"/>
            <Item ID="0x3F24"/>
            <Item ID="0x3F25"/>
            <Item ID="0x3F26"/>
            <Item ID="0x3F27"/>
        </Group>
        <Group name="Mini House's">
            <Item ID="0x22C4"/>
            <Item ID="0x22C9"/>
            <Item ID="0x22CA"/>
            <Item ID="0x22CB"/>
            <Item ID="0x22CC"/>
            <Item ID="0x22CD"/>
            <Item ID="0x22CE"/>
            <Item ID="0x22CF"/>
            <Item ID="0x22D0"/>
            <Item ID="0x22D1"/>
            <Item ID="0x22D2"/>
            <Item ID="0x22D3"/>
            <Item ID="0x22D4"/>
            <Item ID="0x22D5"/>
            <Item ID="0x22D6"/>
            <Item ID="0x22D7"/>
            <Item ID="0x22D8"/>
            <Item ID="0x22D9"/>
            <Item ID="0x22DA"/>
            <Item ID="0x22DB"/>
            <Item ID="0x22DC"/>
            <Item ID="0x22DD"/>
            <Item ID="0x22DE"/>
            <Item ID="0x22DF"/>
            <Item ID="0x22E0"/>
            <Item ID="0x22E1"/>
            <Item ID="0x22E2"/>
            <Item ID="0x22E3"/>
            <Item ID="0x22E4"/>
            <Item ID="0x22E5"/>
            <Item ID="0x22E6"/>
            <Item ID="0x22E7"/>
            <Item ID="0x22E8"/>
            <Item ID="0x22E9"/>
            <Item ID="0x22EA"/>
            <Item ID="0x22EB"/>
            <Item ID="0x22EC"/>
            <Item ID="0x22ED"/>
            <Item ID="0x22EE"/>
            <Item ID="0x22EF"/>
            <Item ID="0x22F0"/>
            <Item ID="0x22F1"/>
            <Item ID="0x22F2"/>
            <Item ID="0x22F3"/>
            <Item ID="0x22F4"/>
            <Item ID="0x22F5"/>
            <Item ID="0x22F6"/>
            <Item ID="0x22F7"/>
            <Item ID="0x22F8"/>
            <Item ID="0x22F9"/>
            <Item ID="0x22FA"/>
            <Item ID="0x22FB"/>
            <Item ID="0x22FC"/>
            <Item ID="0x22FD"/>
            <Item ID="0x22FE"/>
            <Item ID="0x22FF"/>
            <Item ID="0x2300"/>
            <Item ID="0x2301"/>
            <Item ID="0x2302"/>
            <Item ID="0x2303"/>
            <Item ID="0x2304"/>
            <Item ID="0x2313"/>
            <Item ID="0x2314"/>
            <Item ID="0x2315"/>
            <Item ID="0x2316"/>
            <Item ID="0x2317"/>
            <Item ID="0x2318"/>
            <Item ID="0x2319"/>
        </Group>
        <Group name="Mini Monster UO:KR/SA">
            <Item ID="0x3ffd"/>
        </Group>
        <Group name="Mini Monsters AOS">
            <Item ID="0x25F8"/>
            <Item ID="0x25F9"/>
            <Item ID="0x25FA"/>
            <Item ID="0x25FB"/>
            <Item ID="0x25FC"/>
            <Item ID="0x2602"/>
            <Item ID="0x2603"/>
            <Item ID="0x2604"/>
            <Item ID="0x2605"/>
            <Item ID="0x2606"/>
            <Item ID="0x2607"/>
            <Item ID="0x2608"/>
            <Item ID="0x2609"/>
            <Item ID="0x260A"/>
            <Item ID="0x260B"/>
            <Item ID="0x260C"/>
            <Item ID="0x260D"/>
            <Item ID="0x260E"/>
            <Item ID="0x260F"/>
            <Item ID="0x2610"/>
            <Item ID="0x2611"/>
            <Item ID="0x2612"/>
            <Item ID="0x2613"/>
            <Item ID="0x2614"/>
            <Item ID="0x2615"/>
            <Item ID="0x2616"/>
            <Item ID="0x2617"/>
            <Item ID="0x2618"/>
            <Item ID="0x2619"/>
            <Item ID="0x261A"/>
            <Item ID="0x261B"/>
            <Item ID="0x261C"/>
            <Item ID="0x261D"/>
            <Item ID="0x261E"/>
            <Item ID="0x261F"/>
            <Item ID="0x2620"/>
            <Item ID="0x2621"/>
            <Item ID="0x2622"/>
            <Item ID="0x2623"/>
            <Item ID="0x2624"/>
            <Item ID="0x2625"/>
            <Item ID="0x2626"/>
            <Item ID="0x2627"/>
            <Item ID="0x2628"/>
            <Item ID="0x2629"/>
            <Item ID="0x262A"/>
            <Item ID="0x262B"/>
            <Item ID="0x262C"/>
            <Item ID="0x262D"/>
            <Item ID="0x262E"/>
            <Item ID="0x262F"/>
            <Item ID="0x2630"/>
            <Item ID="0x2631"/>
            <Item ID="0x2632"/>
            <Item ID="0x2633"/>
        </Group>
        <Group name="Mini Monsters UO">
            <Item ID="0x20CF"/>
            <Item ID="0x20D0"/>
            <Item ID="0x20D1"/>
            <Item ID="0x20D2"/>
            <Item ID="0x20D3"/>
            <Item ID="0x20D4"/>
            <Item ID="0x20D5"/>
            <Item ID="0x20D6"/>
            <Item ID="0x20D7"/>
            <Item ID="0x20D8"/>
            <Item ID="0x20D9"/>
            <Item ID="0x20DA"/>
            <Item ID="0x20DB"/>
            <Item ID="0x20DC"/>
            <Item ID="0x20DD"/>
            <Item ID="0x20DE"/>
            <Item ID="0x20DF"/>
            <Item ID="0x20E0"/>
            <Item ID="0x20E1"/>
            <Item ID="0x20E2"/>
            <Item ID="0x20E3"/>
            <Item ID="0x20E4"/>
            <Item ID="0x20E5"/>
            <Item ID="0x20E6"/>
            <Item ID="0x20E7"/>
            <Item ID="0x20E8"/>
            <Item ID="0x20E9"/>
            <Item ID="0x20EA"/>
            <Item ID="0x20EB"/>
            <Item ID="0x20EC"/>
            <Item ID="0x20ED"/>
            <Item ID="0x20EE"/>
            <Item ID="0x20EF"/>
            <Item ID="0x20F0"/>
            <Item ID="0x20F1"/>
            <Item ID="0x20F2"/>
            <Item ID="0x20F3"/>
            <Item ID="0x20F4"/>
            <Item ID="0x20F5"/>
            <Item ID="0x20F6"/>
            <Item ID="0x20F7"/>
            <Item ID="0x20F8"/>
            <Item ID="0x20F9"/>
            <Item ID="0x20FA"/>
            <Item ID="0x20FB"/>
            <Item ID="0x20FC"/>
            <Item ID="0x20FD"/>
            <Item ID="0x20FE"/>
            <Item ID="0x20FF"/>
            <Item ID="0x2100"/>
            <Item ID="0x2101"/>
            <Item ID="0x2102"/>
            <Item ID="0x2103"/>
            <Item ID="0x2106"/>
            <Item ID="0x2107"/>
            <Item ID="0x2108"/>
            <Item ID="0x2109"/>
            <Item ID="0x210A"/>
            <Item ID="0x210B"/>
        </Group>
        <Group name="Mini Monsters UO:LBR">
            <Item ID="0x21F1"/>
            <Item ID="0x2580"/>
            <Item ID="0x2581"/>
            <Item ID="0x2582"/>
            <Item ID="0x2583"/>
            <Item ID="0x2584"/>
            <Item ID="0x2585"/>
            <Item ID="0x2586"/>
            <Item ID="0x2587"/>
            <Item ID="0x2588"/>
            <Item ID="0x2589"/>
            <Item ID="0x258B"/>
            <Item ID="0x258C"/>
            <Item ID="0x258D"/>
            <Item ID="0x258E"/>
            <Item ID="0x258F"/>
            <Item ID="0x2590"/>
            <Item ID="0x2591"/>
            <Item ID="0x2592"/>
            <Item ID="0x2593"/>
            <Item ID="0x2594"/>
            <Item ID="0x2595"/>
            <Item ID="0x2596"/>
            <Item ID="0x2597"/>
            <Item ID="0x2598"/>
            <Item ID="0x2599"/>
            <Item ID="0x259A"/>
            <Item ID="0x259B"/>
            <Item ID="0x259C"/>
            <Item ID="0x259D"/>
            <Item ID="0x259E"/>
            <Item ID="0x259F"/>
            <Item ID="0x25A0"/>
            <Item ID="0x25A1"/>
            <Item ID="0x25A2"/>
            <Item ID="0x25A3"/>
            <Item ID="0x25A4"/>
            <Item ID="0x25A5"/>
            <Item ID="0x25A6"/>
            <Item ID="0x25A7"/>
            <Item ID="0x25A8"/>
            <Item ID="0x25A9"/>
            <Item ID="0x25AA"/>
            <Item ID="0x25AB"/>
            <Item ID="0x25AC"/>
            <Item ID="0x25AD"/>
            <Item ID="0x25AE"/>
            <Item ID="0x25AF"/>
            <Item ID="0x25B0"/>
            <Item ID="0x25B1"/>
            <Item ID="0x25B2"/>
            <Item ID="0x25B3"/>
            <Item ID="0x25B4"/>
            <Item ID="0x25B5"/>
            <Item ID="0x25B6"/>
            <Item ID="0x25B7"/>
            <Item ID="0x25B8"/>
            <Item ID="0x25B9"/>
            <Item ID="0x25BA"/>
            <Item ID="0x25BB"/>
            <Item ID="0x25BC"/>
            <Item ID="0x25BD"/>
            <Item ID="0x25BE"/>
            <Item ID="0x25BF"/>
            <Item ID="0x25C0"/>
            <Item ID="0x25C1"/>
            <Item ID="0x25C2"/>
            <Item ID="0x25C3"/>
            <Item ID="0x25C4"/>
            <Item ID="0x25C5"/>
            <Item ID="0x25C6"/>
            <Item ID="0x25C7"/>
            <Item ID="0x25C8"/>
            <Item ID="0x25C9"/>
            <Item ID="0x25CA"/>
            <Item ID="0x25CB"/>
            <Item ID="0x25CC"/>
            <Item ID="0x25CD"/>
            <Item ID="0x25CE"/>
            <Item ID="0x25CF"/>
            <Item ID="0x25D0"/>
            <Item ID="0x25D1"/>
            <Item ID="0x25D2"/>
            <Item ID="0x25D3"/>
            <Item ID="0x25D4"/>
            <Item ID="0x25D5"/>
            <Item ID="0x25D6"/>
            <Item ID="0x25D7"/>
            <Item ID="0x25D8"/>
            <Item ID="0x25D9"/>
            <Item ID="0x25DA"/>
            <Item ID="0x25DB"/>
            <Item ID="0x25DC"/>
            <Item ID="0x25DD"/>
        </Group>
        <Group name="Mini Monsters UO:ML">
            <Item ID="0x2D82"/>
            <Item ID="0x2D83"/>
            <Item ID="0x2D84"/>
            <Item ID="0x2D85"/>
            <Item ID="0x2D88"/>
            <Item ID="0x2D89"/>
            <Item ID="0x2D8A"/>
            <Item ID="0x2D8B"/>
            <Item ID="0x2D8C"/>
            <Item ID="0x2D8D"/>
            <Item ID="0x2D90"/>
            <Item ID="0x2D93"/>
            <Item ID="0x2D94"/>
            <Item ID="0x2D95"/>
            <Item ID="0x2D96"/>
            <Item ID="0x2D97"/>
            <Item ID="0x2D98"/>
            <Item ID="0x2D99"/>
            <Item ID="0x2D9A"/>
            <Item ID="0x2D9B"/>
            <Item ID="0x2D9C"/>
        </Group>
        <Group name="Mini Monsters UO:SE">
            <Item ID="0x2763"/>
            <Item ID="0x2764"/>
            <Item ID="0x2765"/>
            <Item ID="0x2766"/>
            <Item ID="0x2767"/>
            <Item ID="0x2768"/>
            <Item ID="0x2769"/>
            <Item ID="0x276A"/>
            <Item ID="0x276B"/>
            <Item ID="0x276C"/>
            <Item ID="0x276D"/>
            <Item ID="0x276E"/>
            <Item ID="0x276F"/>
            <Item ID="0x2770"/>
            <Item ID="0x2771"/>
            <Item ID="0x2772"/>
            <Item ID="0x2773"/>
            <Item ID="0x281B"/>
            <Item ID="0x281C"/>
        </Group>
        <Group name="Spring">
            <Item ID="0x18d9"/>
            <Item ID="0x18da"/>
            <Item ID="0x1944"/>
            <Item ID="0x1945"/>
            <Item ID="0x1946"/>
            <Item ID="0x1947"/>
            <Item ID="0x1948"/>
            <Item ID="0x1949"/>
            <Item ID="0x194A"/>
            <Item ID="0x194B"/>
            <Item ID="0x194C"/>
            <Item ID="0x194D"/>
            <Item ID="0x194E"/>
            <Item ID="0x194F"/>
            <Item ID="0x1950"/>
            <Item ID="0x1951"/>
            <Item ID="0x1952"/>
            <Item ID="0x1953"/>
            <Item ID="0x1954"/>
            <Item ID="0x1956"/>
        </Group>
        <Group name="Winter">
            <Group name="Santa Reindeer">
                <Item ID="0x3A55"/>
                <Item ID="0x3A56"/>
                <Item ID="0x3A57"/>
                <Item ID="0x3A58"/>
                <Item ID="0x3A59"/>
                <Item ID="0x3A5A"/>
                <Item ID="0x3A5B"/>
                <Item ID="0x3A5C"/>
                <Item ID="0x3A5D"/>
                <Item ID="0x3A5E"/>
                <Item ID="0x3A5F"/>
                <Item ID="0x3A60"/>
                <Item ID="0x3A61"/>
                <Item ID="0x3A62"/>
                <Item ID="0x3A63"/>
                <Item ID="0x3A64"/>
                <Item ID="0x3A65"/>
                <Item ID="0x3A66"/>
                <Item ID="0x3A67"/>
                <Item ID="0x3A68"/>
                <Item ID="0x3A69"/>
                <Item ID="0x3A6A"/>
                <Item ID="0x3A6B"/>
                <Item ID="0x3A6C"/>
            </Group>
            <Group name="Santa Sleigh">
                <Item ID="0x3A73"/>
                <Item ID="0x3A74"/>
                <Item ID="0x3A76"/>
                <Item ID="0x3A77"/>
                <Item ID="0x3A7A"/>
                <Item ID="0x3A7C"/>
                <Item ID="0x3A7D"/>
                <Item ID="0x3A7E"/>
                <Item ID="0x3A80"/>
                <Item ID="0x3A81"/>
                <Item ID="0x3A84"/>
                <Item ID="0x3A86"/>
                <Item ID="0x3A87"/>
                <Item ID="0x3A88"/>
                <Item ID="0x3A8A"/>
                <Item ID="0x3A8B"/>
                <Item ID="0x3A8D"/>
                <Item ID="0x3A8E"/>
                <Item ID="0x3A90"/>
                <Item ID="0x3A91"/>
            </Group>
            <Item ID="0x2328"/>
            <Item ID="0x2329"/>
            <Item ID="0x232A"/>
            <Item ID="0x232B"/>
            <Item ID="0x232C"/>
            <Item ID="0x232D"/>
            <Item ID="0x232E"/>
            <Item ID="0x232F"/>
            <Item ID="0x2332"/>
            <Item ID="0x2336"/>
            <Item ID="0x236e"/>
            <Item ID="0x236f"/>
            <Item ID="0x2374"/>
            <Item ID="0x2375"/>
            <Item ID="0x2376"/>
            <Item ID="0x2377"/>
            <Item ID="0x2378"/>
            <Item ID="0x2BD9"/>
            <Item ID="0x2BDA"/>
            <Item ID="0x2BDB"/>
            <Item ID="0x2BDC"/>
            <Item ID="0x2BDD"/>
            <Item ID="0x2BDE"/>
            <Item ID="0x2BDF"/>
            <Item ID="0x2BE0"/>
            <Item ID="0x2BE1"/>
            <Item ID="0x2BE2"/>
            <Item ID="0x2BE3"/>
            <Item ID="0x2BE4"/>
            <Item ID="0x2BE5"/>
            <Item ID="0x2BE6"/>
            <Item ID="0x2BE7"/>
            <Item ID="0x2b14"/>
            <Item ID="0x3BBb"/>
            <Item ID="0x3BBc"/>
        </Group>
    </Group>
    <Group name="Multipart">
        <Group name="Dolphin Rug East">
            <Item ID="0x38d9"/>
            <Item ID="0x38da"/>
            <Item ID="0x38db"/>
            <Item ID="0x38dc"/>
            <Item ID="0x38dd"/>
            <Item ID="0x38de"/>
            <Item ID="0x38df"/>
            <Item ID="0x38e0"/>
            <Item ID="0x38e1"/>
            <Item ID="0x38e2"/>
            <Item ID="0x38e3"/>
            <Item ID="0x38e4"/>
            <Item ID="0x38e5"/>
            <Item ID="0x38e6"/>
            <Item ID="0x38e7"/>
            <Item ID="0x38e8"/>
            <Item ID="0x38e9"/>
            <Item ID="0x38ea"/>
            <Item ID="0x38eb"/>
            <Item ID="0x38ec"/>
            <Item ID="0x38ed"/>
            <Item ID="0x38ee"/>
            <Item ID="0x38ef"/>
            <Item ID="0x38f0"/>
            <Item ID="0x38f1"/>
            <Item ID="0x38f2"/>
            <Item ID="0x38f3"/>
            <Item ID="0x38f4"/>
        </Group>
        <Group name="Dolphin Rug S">
            <Item ID="0x38f5"/>
            <Item ID="0x38f6"/>
            <Item ID="0x38f7"/>
            <Item ID="0x38f8"/>
            <Item ID="0x38f9"/>
            <Item ID="0x38fa"/>
            <Item ID="0x38fb"/>
            <Item ID="0x38fc"/>
            <Item ID="0x38fd"/>
            <Item ID="0x38fe"/>
            <Item ID="0x38ff"/>
            <Item ID="0x3900"/>
            <Item ID="0x3901"/>
            <Item ID="0x3902"/>
            <Item ID="0x3903"/>
            <Item ID="0x3904"/>
            <Item ID="0x3905"/>
            <Item ID="0x3906"/>
            <Item ID="0x3907"/>
            <Item ID="0x3908"/>
            <Item ID="0x3909"/>
            <Item ID="0x390a"/>
            <Item ID="0x390b"/>
            <Item ID="0x390c"/>
            <Item ID="0x390d"/>
            <Item ID="0x390e"/>
            <Item ID="0x390f"/>
            <Item ID="0x3910"/>
        </Group>
        <Group name="Japanese Gate">
            <Item ID="0x24AD"/>
            <Item ID="0x24AE"/>
            <Item ID="0x24AF"/>
            <Item ID="0x24B0"/>
            <Item ID="0x24B1"/>
            <Item ID="0x24B2"/>
            <Item ID="0x24B3"/>
            <Item ID="0x24B4"/>
            <Item ID="0x24B5"/>
            <Item ID="0x24B6"/>
            <Item ID="0x24B7"/>
            <Item ID="0x24B8"/>
            <Item ID="0x24B9"/>
            <Item ID="0x24BA"/>
        </Group>
        <Group name="Lighthouse">
            <Item ID="0x1AA4"/>
            <Item ID="0x1AA5"/>
            <Item ID="0x1AA6"/>
            <Item ID="0x1AA7"/>
            <Item ID="0x1AA8"/>
            <Item ID="0x1AA9"/>
            <Item ID="0x1AAA"/>
            <Item ID="0x1AAB"/>
            <Item ID="0x1AAC"/>
            <Item ID="0x1AAD"/>
            <Item ID="0x1AAE"/>
            <Item ID="0x1AAF"/>
            <Item ID="0x1AB0"/>
            <Item ID="0x1AB1"/>
            <Item ID="0x1AB2"/>
            <Item ID="0x1AB3"/>
            <Item ID="0x1AB4"/>
            <Item ID="0x1AB5"/>
            <Item ID="0x1AB6"/>
            <Item ID="0x1AB7"/>
            <Item ID="0x1AB8"/>
            <Item ID="0x1AB9"/>
            <Item ID="0x1ABA"/>
            <Item ID="0x1ABB"/>
            <Item ID="0x1ABC"/>
            <Item ID="0x1ABD"/>
            <Item ID="0x1ABE"/>
            <Item ID="0x1ABF"/>
            <Item ID="0x1AC0"/>
            <Item ID="0x1AC1"/>
            <Item ID="0x1AC2"/>
            <Item ID="0x1AC3"/>
            <Item ID="0x1AC4"/>
            <Item ID="0x1AC5"/>
            <Item ID="0x1AC6"/>
            <Item ID="0x1AC7"/>
            <Item ID="0x1AC8"/>
            <Item ID="0x1AC9"/>
            <Item ID="0x1ACA"/>
            <Item ID="0x1ACB"/>
            <Item ID="0x1ACC"/>
            <Item ID="0x1ACD"/>
            <Item ID="0x1ACE"/>
            <Item ID="0x1ACF"/>
            <Item ID="0x1AD0"/>
            <Item ID="0x1AD1"/>
            <Item ID="0x1AD2"/>
        </Group>
        <Group name="Rose Rug E">
            <Item ID="0x38a0"/>
            <Item ID="0x38a1"/>
            <Item ID="0x38a2"/>
            <Item ID="0x38a3"/>
            <Item ID="0x38a4"/>
            <Item ID="0x38a5"/>
            <Item ID="0x38a6"/>
            <Item ID="0x38a7"/>
            <Item ID="0x38a8"/>
            <Item ID="0x38a9"/>
            <Item ID="0x38aa"/>
            <Item ID="0x38ab"/>
            <Item ID="0x38ac"/>
            <Item ID="0x38ad"/>
            <Item ID="0x38ae"/>
            <Item ID="0x38af"/>
            <Item ID="0x38b0"/>
            <Item ID="0x38b1"/>
            <Item ID="0x38b2"/>
            <Item ID="0x38b3"/>
            <Item ID="0x38b4"/>
            <Item ID="0x38b5"/>
            <Item ID="0x38b6"/>
            <Item ID="0x38b7"/>
            <Item ID="0x38b8"/>
            <Item ID="0x38b9"/>
            <Item ID="0x38ba"/>
            <Item ID="0x38bb"/>
            <Item ID="0x38bc"/>
        </Group>
        <Group name="Serpent Pillar">
            <Item ID="0x233C"/>
            <Item ID="0x233D"/>
            <Item ID="0x233E"/>
            <Item ID="0x233F"/>
            <Item ID="0x2340"/>
            <Item ID="0x2341"/>
            <Item ID="0x2342"/>
            <Item ID="0x2343"/>
            <Item ID="0x2344"/>
            <Item ID="0x2345"/>
            <Item ID="0x2346"/>
            <Item ID="0x2347"/>
            <Item ID="0x2348"/>
            <Item ID="0x2349"/>
            <Item ID="0x234A"/>
        </Group>
        <Group name="Sieges">
            <Group name="Ballista">
                <Item ID="0x16FA"/>
                <Item ID="0x1701"/>
                <Item ID="0x3FC0"/>
                <Item ID="0x3FC8"/>
                <Item ID="0x3FCF"/>
                <Item ID="0x3FD0"/>
                <Item ID="0x3FD2"/>
                <Item ID="0x3FD4"/>
                <Item ID="0x3FD6"/>
                <Item ID="0x3FD8"/>
                <Item ID="0x3FDA"/>
                <Item ID="0x3FDC"/>
                <Item ID="0x3FDE"/>
                <Item ID="0x3FE0"/>
                <Item ID="0x3FE2"/>
                <Item ID="0x3FE3"/>
            </Group>
            <Group name="Ballista">
                <Item ID="0x3F90"/>
                <Item ID="0x3F95"/>
                <Item ID="0x3F9D"/>
                <Item ID="0x3FA4"/>
                <Item ID="0x3FA5"/>
                <Item ID="0x3FA7"/>
                <Item ID="0x3FA9"/>
                <Item ID="0x3FAB"/>
                <Item ID="0x3FAD"/>
                <Item ID="0x3FAF"/>
                <Item ID="0x3FB1"/>
                <Item ID="0x3FB3"/>
                <Item ID="0x3FB5"/>
                <Item ID="0x3FB7"/>
                <Item ID="0x3FB8"/>
                <Item ID="0x3FB9"/>
            </Group>
            <Group name="Ballista">
                <Item ID="0x189F"/>
                <Item ID="0x18A0"/>
                <Item ID="0x18A1"/>
                <Item ID="0x18A2"/>
                <Item ID="0x18A3"/>
                <Item ID="0x18A4"/>
                <Item ID="0x18A5"/>
                <Item ID="0x18A6"/>
                <Item ID="0x18A7"/>
                <Item ID="0x18A8"/>
                <Item ID="0x18A9"/>
                <Item ID="0x18AA"/>
                <Item ID="0x18AC"/>
                <Item ID="0x18B1"/>
                <Item ID="0x3F77"/>
            </Group>
            <Group name="Ballista">
                <Item ID="0x18F0"/>
                <Item ID="0x18F1"/>
                <Item ID="0x18F2"/>
                <Item ID="0x18F3"/>
                <Item ID="0x18F4"/>
                <Item ID="0x18F6"/>
                <Item ID="0x18F7"/>
                <Item ID="0x18F8"/>
                <Item ID="0x18F9"/>
                <Item ID="0x18FA"/>
                <Item ID="0x18FB"/>
                <Item ID="0x18FC"/>
                <Item ID="0x1904"/>
                <Item ID="0x1909"/>
                <Item ID="0x3F5D"/>
            </Group>
            <Group name="Ballista">
                <Item ID="0x18F1"/>
                <Item ID="0x18FD"/>
                <Item ID="0x18FE"/>
                <Item ID="0x18FF"/>
                <Item ID="0x1900"/>
                <Item ID="0x1901"/>
                <Item ID="0x1902"/>
                <Item ID="0x1903"/>
                <Item ID="0x3F3F"/>
                <Item ID="0x3F44"/>
                <Item ID="0x3F50"/>
                <Item ID="0x3F61"/>
                <Item ID="0x3F62"/>
                <Item ID="0x3F64"/>
            </Group>
            <Group name="Ballista">
                <Item ID="0x16FA"/>
                <Item ID="0x16FE"/>
                <Item ID="0x16FF"/>
                <Item ID="0x1701"/>
                <Item ID="0x3FC0"/>
                <Item ID="0x3FC5"/>
                <Item ID="0x3FC7"/>
                <Item ID="0x3FCC"/>
                <Item ID="0x3FCD"/>
                <Item ID="0x3FCE"/>
                <Item ID="0x3FCF"/>
                <Item ID="0x3FE2"/>
                <Item ID="0x3FE3"/>
            </Group>
            <Group name="Ballista">
                <Item ID="0x189F"/>
                <Item ID="0x18A0"/>
                <Item ID="0x18A1"/>
                <Item ID="0x18A2"/>
                <Item ID="0x18AC"/>
                <Item ID="0x18B1"/>
                <Item ID="0x18CE"/>
                <Item ID="0x18CF"/>
                <Item ID="0x18D0"/>
                <Item ID="0x18D1"/>
                <Item ID="0x3F71"/>
                <Item ID="0x3F72"/>
                <Item ID="0x3F77"/>
            </Group>
            <Group name="Ballista">
                <Item ID="0x3F90"/>
                <Item ID="0x3F95"/>
                <Item ID="0x3F9A"/>
                <Item ID="0x3F9B"/>
                <Item ID="0x3F9C"/>
                <Item ID="0x3FA0"/>
                <Item ID="0x3FA1"/>
                <Item ID="0x3FA2"/>
                <Item ID="0x3FA3"/>
                <Item ID="0x3FA4"/>
                <Item ID="0x3FB7"/>
                <Item ID="0x3FB8"/>
                <Item ID="0x3FB9"/>
            </Group>
            <Group name="Cannon">
                <Item ID="0x0E6B"/>
                <Item ID="0x0E6C"/>
                <Item ID="0x0E6D"/>
                <Item ID="0x0E6E"/>
                <Item ID="0x0E6F"/>
                <Item ID="0x0E70"/>
                <Item ID="0x0E71"/>
                <Item ID="0x0E72"/>
                <Item ID="0x0E73"/>
                <Item ID="0x0E74"/>
            </Group>
            <Group name="Catapult">
                <Item ID="0x1694"/>
                <Item ID="0x1695"/>
                <Item ID="0x1696"/>
                <Item ID="0x1697"/>
                <Item ID="0x1698"/>
                <Item ID="0x1699"/>
                <Item ID="0x169A"/>
                <Item ID="0x169B"/>
                <Item ID="0x169C"/>
                <Item ID="0x169D"/>
                <Item ID="0x16A2"/>
                <Item ID="0x16A7"/>
                <Item ID="0x16AC"/>
                <Item ID="0x16B1"/>
            </Group>
            <Group name="Catapult">
                <Item ID="0x16B9"/>
                <Item ID="0x16BA"/>
                <Item ID="0x16BB"/>
                <Item ID="0x16BC"/>
                <Item ID="0x16BD"/>
                <Item ID="0x16BE"/>
                <Item ID="0x16BF"/>
                <Item ID="0x16C0"/>
                <Item ID="0x16C1"/>
                <Item ID="0x16C2"/>
                <Item ID="0x16C7"/>
                <Item ID="0x16CC"/>
                <Item ID="0x16D1"/>
                <Item ID="0x16D6"/>
            </Group>
            <Group name="Catapult">
                <Item ID="0x1648"/>
                <Item ID="0x1649"/>
                <Item ID="0x164A"/>
                <Item ID="0x164B"/>
                <Item ID="0x164C"/>
                <Item ID="0x164D"/>
                <Item ID="0x164E"/>
                <Item ID="0x164F"/>
                <Item ID="0x1654"/>
                <Item ID="0x1659"/>
                <Item ID="0x165E"/>
                <Item ID="0x1663"/>
            </Group>
            <Group name="Catapult">
                <Item ID="0x1672"/>
                <Item ID="0x1673"/>
                <Item ID="0x1674"/>
                <Item ID="0x1675"/>
                <Item ID="0x1676"/>
                <Item ID="0x1677"/>
                <Item ID="0x1678"/>
                <Item ID="0x1679"/>
                <Item ID="0x167E"/>
                <Item ID="0x1683"/>
                <Item ID="0x1688"/>
                <Item ID="0x168E"/>
            </Group>
        </Group>
        <Group name="Skull Rug E">
            <Item ID="0x3869"/>
            <Item ID="0x386a"/>
            <Item ID="0x386b"/>
            <Item ID="0x386c"/>
            <Item ID="0x386d"/>
            <Item ID="0x386e"/>
            <Item ID="0x386f"/>
            <Item ID="0x3870"/>
            <Item ID="0x3871"/>
            <Item ID="0x3872"/>
            <Item ID="0x3873"/>
            <Item ID="0x3874"/>
            <Item ID="0x3875"/>
            <Item ID="0x3876"/>
            <Item ID="0x3877"/>
            <Item ID="0x3878"/>
            <Item ID="0x3879"/>
            <Item ID="0x387a"/>
            <Item ID="0x387b"/>
            <Item ID="0x387c"/>
            <Item ID="0x387d"/>
            <Item ID="0x387e"/>
            <Item ID="0x387f"/>
            <Item ID="0x3880"/>
            <Item ID="0x3881"/>
            <Item ID="0x3882"/>
            <Item ID="0x3883"/>
            <Item ID="0x3884"/>
        </Group>
        <Group name="Skull Rug S">
            <Item ID="0x3885"/>
            <Item ID="0x3886"/>
            <Item ID="0x3887"/>
            <Item ID="0x3888"/>
            <Item ID="0x3889"/>
            <Item ID="0x388a"/>
            <Item ID="0x388b"/>
            <Item ID="0x388c"/>
            <Item ID="0x388d"/>
            <Item ID="0x388e"/>
            <Item ID="0x388f"/>
            <Item ID="0x3890"/>
            <Item ID="0x3891"/>
            <Item ID="0x3892"/>
            <Item ID="0x3893"/>
            <Item ID="0x3894"/>
            <Item ID="0x3895"/>
            <Item ID="0x3896"/>
            <Item ID="0x3897"/>
            <Item ID="0x3898"/>
            <Item ID="0x3899"/>
            <Item ID="0x389a"/>
            <Item ID="0x389b"/>
            <Item ID="0x389c"/>
            <Item ID="0x389d"/>
            <Item ID="0x389e"/>
            <Item ID="0x389f"/>
            <Item ID="0x38a0"/>
        </Group>
        <Group name="Skull Rug S">
            <Item ID="0x38bd"/>
            <Item ID="0x38be"/>
            <Item ID="0x38bf"/>
            <Item ID="0x38c0"/>
            <Item ID="0x38c1"/>
            <Item ID="0x38c2"/>
            <Item ID="0x38c3"/>
            <Item ID="0x38c4"/>
            <Item ID="0x38c5"/>
            <Item ID="0x38c6"/>
            <Item ID="0x38c7"/>
            <Item ID="0x38c8"/>
            <Item ID="0x38c9"/>
            <Item ID="0x38ca"/>
            <Item ID="0x38cb"/>
            <Item ID="0x38cc"/>
            <Item ID="0x38cd"/>
            <Item ID="0x38ce"/>
            <Item ID="0x38cf"/>
            <Item ID="0x38d0"/>
            <Item ID="0x38d1"/>
            <Item ID="0x38d2"/>
            <Item ID="0x38d3"/>
            <Item ID="0x38d4"/>
            <Item ID="0x38d5"/>
            <Item ID="0x38d6"/>
            <Item ID="0x38d7"/>
            <Item ID="0x38d8"/>
        </Group>
        <Group name="Telescope">
            <Item ID="0x1459"/>
            <Item ID="0x145A"/>
            <Item ID="0x145B"/>
            <Item ID="0x145C"/>
            <Item ID="0x145D"/>
            <Item ID="0x145E"/>
            <Item ID="0x145F"/>
            <Item ID="0x1460"/>
            <Item ID="0x1461"/>
            <Item ID="0x1462"/>
            <Item ID="0x1463"/>
            <Item ID="0x1464"/>
            <Item ID="0x1465"/>
            <Item ID="0x1466"/>
            <Item ID="0x1467"/>
            <Item ID="0x1468"/>
            <Item ID="0x1469"/>
            <Item ID="0x146A"/>
            <Item ID="0x146B"/>
            <Item ID="0x146D"/>
            <Item ID="0x146E"/>
            <Item ID="0x146F"/>
            <Item ID="0x1470"/>
            <Item ID="0x1471"/>
            <Item ID="0x1472"/>
            <Item ID="0x1473"/>
            <Item ID="0x1474"/>
            <Item ID="0x1475"/>
            <Item ID="0x1476"/>
            <Item ID="0x1477"/>
            <Item ID="0x1478"/>
            <Item ID="0x1479"/>
            <Item ID="0x147A"/>
            <Item ID="0x147B"/>
            <Item ID="0x147C"/>
            <Item ID="0x147D"/>
            <Item ID="0x147E"/>
            <Item ID="0x147F"/>
            <Item ID="0x1480"/>
            <Item ID="0x1481"/>
            <Item ID="0x1482"/>
            <Item ID="0x1483"/>
            <Item ID="0x1484"/>
            <Item ID="0x1485"/>
            <Item ID="0x1486"/>
            <Item ID="0x1487"/>
            <Item ID="0x1488"/>
            <Item ID="0x1489"/>
            <Item ID="0x148A"/>
            <Item ID="0x148B"/>
            <Item ID="0x148C"/>
            <Item ID="0x148D"/>
            <Item ID="0x148E"/>
            <Item ID="0x148F"/>
            <Item ID="0x1490"/>
            <Item ID="0x1491"/>
            <Item ID="0x1492"/>
            <Item ID="0x1493"/>
            <Item ID="0x1494"/>
            <Item ID="0x1495"/>
            <Item ID="0x1496"/>
            <Item ID="0x1497"/>
            <Item ID="0x1498"/>
            <Item ID="0x1499"/>
            <Item ID="0x149A"/>
        </Group>
        <Group name="Vat + Ladder E">
            <Item ID="0x14D7"/>
            <Item ID="0x14D8"/>
            <Item ID="0x14D9"/>
            <Item ID="0x14DB"/>
            <Item ID="0x14DC"/>
            <Item ID="0x14DD"/>
            <Item ID="0x14DE"/>
            <Item ID="0x14DF"/>
            <Item ID="0x14E2"/>
        </Group>
        <Group name="Vat + Ladder S">
            <Item ID="0x14D7"/>
            <Item ID="0x14D9"/>
            <Item ID="0x14DA"/>
            <Item ID="0x14DB"/>
            <Item ID="0x14DC"/>
            <Item ID="0x14DD"/>
            <Item ID="0x14DE"/>
            <Item ID="0x14DF"/>
            <Item ID="0x14E1"/>
        </Group>
        <Group name="Vat">
            <Item ID="0x14D7"/>
            <Item ID="0x14D8"/>
            <Item ID="0x14D9"/>
            <Item ID="0x14DA"/>
            <Item ID="0x14DB"/>
            <Item ID="0x14DC"/>
            <Item ID="0x14DD"/>
            <Item ID="0x14DE"/>
            <Item ID="0x14DF"/>
        </Group>
        <Group name="Water Vat + Ladder E">
            <Item ID="0x14D7"/>
            <Item ID="0x14DE"/>
            <Item ID="0x14DF"/>
            <Item ID="0x1550"/>
            <Item ID="0x1552"/>
            <Item ID="0x1553"/>
            <Item ID="0x1555"/>
            <Item ID="0x1558"/>
            <Item ID="0x1559"/>
        </Group>
        <Group name="Water Vat + Ladder S">
            <Item ID="0x14D7"/>
            <Item ID="0x14DE"/>
            <Item ID="0x14DF"/>
            <Item ID="0x1551"/>
            <Item ID="0x1552"/>
            <Item ID="0x1553"/>
            <Item ID="0x1556"/>
            <Item ID="0x1558"/>
            <Item ID="0x1559"/>
        </Group>
        <Group name="Water Vat">
            <Item ID="0x14D7"/>
            <Item ID="0x14DE"/>
            <Item ID="0x14DF"/>
            <Item ID="0x1550"/>
            <Item ID="0x1552"/>
            <Item ID="0x1553"/>
            <Item ID="0x1556"/>
            <Item ID="0x1558"/>
            <Item ID="0x1559"/>
        </Group>
        <Group name="Wine Vat + Ladder E">
            <Item ID="0x14D7"/>
            <Item ID="0x14DE"/>
            <Item ID="0x14DF"/>
            <Item ID="0x151E"/>
            <Item ID="0x151F"/>
            <Item ID="0x1521"/>
            <Item ID="0x1522"/>
            <Item ID="0x1523"/>
            <Item ID="0x1525"/>
        </Group>
        <Group name="Wine Vat + Ladder S">
            <Item ID="0x14D7"/>
            <Item ID="0x14DE"/>
            <Item ID="0x14DF"/>
            <Item ID="0x151E"/>
            <Item ID="0x1520"/>
            <Item ID="0x1521"/>
            <Item ID="0x1522"/>
            <Item ID="0x1523"/>
            <Item ID="0x1524"/>
        </Group>
        <Group name="Wine Vat">
            <Item ID="0x14D7"/>
            <Item ID="0x14DE"/>
            <Item ID="0x14DF"/>
            <Item ID="0x151E"/>
            <Item ID="0x151F"/>
            <Item ID="0x1521"/>
            <Item ID="0x1522"/>
            <Item ID="0x1523"/>
            <Item ID="0x1524"/>
        </Group>
    </Group>
    <Group name="Nature">
        <Group name="Acid">
            <Group name="corners">
                <Item ID="0x2E02"/>
                <Item ID="0x2E03"/>
                <Item ID="0x2E04"/>
                <Item ID="0x2E05"/>
                <Item ID="0x2E06"/>
                <Item ID="0x2E07"/>
                <Item ID="0x2E08"/>
                <Item ID="0x2E09"/>
                <Item ID="0x2E0a"/>
                <Item ID="0x2E0b"/>
                <Item ID="0x2E0c"/>
                <Item ID="0x2E0d"/>
                <Item ID="0x2E0e"/>
                <Item ID="0x2E0f"/>
                <Item ID="0x2E10"/>
                <Item ID="0x2E11"/>
                <Item ID="0x2E12"/>
                <Item ID="0x2E13"/>
                <Item ID="0x2E14"/>
                <Item ID="0x2E15"/>
                <Item ID="0x2E16"/>
                <Item ID="0x2E17"/>
                <Item ID="0x2E18"/>
                <Item ID="0x2E19"/>
                <Item ID="0x2E1a"/>
                <Item ID="0x2E1b"/>
                <Item ID="0x2E1c"/>
                <Item ID="0x2E1d"/>
                <Item ID="0x2E1e"/>
                <Item ID="0x2E1f"/>
                <Item ID="0x2E20"/>
                <Item ID="0x2E21"/>
                <Item ID="0x2E22"/>
                <Item ID="0x2E23"/>
                <Item ID="0x2E24"/>
                <Item ID="0x2E25"/>
                <Item ID="0x2E26"/>
                <Item ID="0x2E27"/>
                <Item ID="0x2E28"/>
                <Item ID="0x2E29"/>
            </Group>
            <Item ID="0x2E2a"/>
            <Item ID="0x2E2b"/>
            <Item ID="0x2E2c"/>
            <Item ID="0x2E2d"/>
            <Item ID="0x2E2e"/>
            <Item ID="0x2E2f"/>
            <Item ID="0x2E30"/>
            <Item ID="0x2E31"/>
            <Item ID="0x2E32"/>
            <Item ID="0x2E33"/>
            <Item ID="0x2E34"/>
            <Item ID="0x2E35"/>
            <Item ID="0x2E36"/>
            <Item ID="0x2E37"/>
            <Item ID="0x2E38"/>
            <Item ID="0x2E39"/>
            <Item ID="0x2E3a"/>
            <Item ID="0x2E3b"/>
        </Group>
        <Group name="Cave">
            <Group name="Cave Drawings">
                <Item ID="0x2F62"/>
                <Item ID="0x2F63"/>
                <Item ID="0x2F64"/>
                <Item ID="0x2F65"/>
                <Item ID="0x2F66"/>
                <Item ID="0x2F67"/>
                <Item ID="0x2F68"/>
                <Item ID="0x2F69"/>
                <Item ID="0x2F6a"/>
                <Item ID="0x2F6b"/>
                <Item ID="0x2F6c"/>
                <Item ID="0x2F6d"/>
                <Item ID="0x2F6e"/>
                <Item ID="0x2F6f"/>
                <Item ID="0x2F70"/>
                <Item ID="0x2F71"/>
                <Item ID="0x2F72"/>
                <Item ID="0x2F73"/>
                <Item ID="0x2F74"/>
                <Item ID="0x2F75"/>
                <Item ID="0x2F76"/>
                <Item ID="0x2F77"/>
                <Item ID="0x2F78"/>
                <Item ID="0x2F79"/>
                <Item ID="0x2F7a"/>
                <Item ID="0x2F7b"/>
                <Item ID="0x2F7c"/>
                <Item ID="0x2F7d"/>
                <Item ID="0x2F7e"/>
                <Item ID="0x2F7f"/>
                <Item ID="0x2F80"/>
                <Item ID="0x2F81"/>
                <Item ID="0x2F82"/>
                <Item ID="0x2F83"/>
                <Item ID="0x2F84"/>
                <Item ID="0x2F85"/>
                <Item ID="0x2F86"/>
                <Item ID="0x2F87"/>
                <Item ID="0x2F88"/>
                <Item ID="0x2F89"/>
                <Item ID="0x2F8a"/>
                <Item ID="0x2F8b"/>
                <Item ID="0x2F8c"/>
                <Item ID="0x2F8d"/>
                <Item ID="0x2F8e"/>
                <Item ID="0x2F8f"/>
                <Item ID="0x2F90"/>
                <Item ID="0x2F91"/>
                <Item ID="0x2F92"/>
                <Item ID="0x2F93"/>
                <Item ID="0x2F94"/>
                <Item ID="0x2F95"/>
                <Item ID="0x2F96"/>
                <Item ID="0x2F97"/>
                <Item ID="0x2F98"/>
                <Item ID="0x2F99"/>
                <Item ID="0x2F9a"/>
                <Item ID="0x2F9b"/>
                <Item ID="0x2F9c"/>
                <Item ID="0x2F9d"/>
                <Item ID="0x2F9e"/>
                <Item ID="0x2F9f"/>
                <Item ID="0x2Fa0"/>
                <Item ID="0x2Fa1"/>
                <Item ID="0x2Fa2"/>
                <Item ID="0x2Fa3"/>
                <Item ID="0x2Fa4"/>
                <Item ID="0x2Fa5"/>
                <Item ID="0x2Fa6"/>
                <Item ID="0x2Fa7"/>
                <Item ID="0x2Fa8"/>
                <Item ID="0x2Fa9"/>
                <Item ID="0x2Faa"/>
                <Item ID="0x2Fab"/>
                <Item ID="0x2Fac"/>
                <Item ID="0x2Fad"/>
                <Item ID="0x2Fae"/>
                <Item ID="0x2Faf"/>
                <Item ID="0x2Fb0"/>
                <Item ID="0x2Fb1"/>
                <Item ID="0x2Fb2"/>
                <Item ID="0x2Fb3"/>
                <Item ID="0x2Fb4"/>
                <Item ID="0x2Fb5"/>
            </Group>
            <Group name="Cave Steps">
                <Item ID="0x079D"/>
                <Item ID="0x079E"/>
                <Item ID="0x079F"/>
                <Item ID="0x07B0"/>
                <Item ID="0x07B1"/>
                <Item ID="0x07B2"/>
                <Item ID="0x07B7"/>
                <Item ID="0x07B8"/>
                <Item ID="0x07B9"/>
            </Group>
            <Group name="Cave Wall">
                <Item ID="0x025C"/>
                <Item ID="0x025D"/>
                <Item ID="0x025E"/>
                <Item ID="0x025F"/>
                <Item ID="0x0260"/>
                <Item ID="0x0261"/>
                <Item ID="0x0262"/>
                <Item ID="0x0263"/>
                <Item ID="0x0264"/>
                <Item ID="0x0265"/>
                <Item ID="0x0266"/>
                <Item ID="0x0267"/>
                <Item ID="0x0268"/>
                <Item ID="0x0269"/>
                <Item ID="0x026A"/>
                <Item ID="0x026B"/>
                <Item ID="0x026C"/>
                <Item ID="0x026D"/>
                <Item ID="0x026E"/>
                <Item ID="0x026F"/>
                <Item ID="0x0270"/>
                <Item ID="0x0271"/>
                <Item ID="0x0272"/>
                <Item ID="0x0273"/>
                <Item ID="0x0274"/>
                <Item ID="0x0275"/>
                <Item ID="0x0276"/>
                <Item ID="0x027D"/>
                <Item ID="0x027E"/>
                <Item ID="0x027F"/>
                <Item ID="0x0280"/>
                <Item ID="0x08E0"/>
                <Item ID="0x08E1"/>
                <Item ID="0x08E2"/>
                <Item ID="0x08E3"/>
                <Item ID="0x08E4"/>
                <Item ID="0x08E5"/>
                <Item ID="0x08E6"/>
                <Item ID="0x08E7"/>
                <Item ID="0x08E8"/>
                <Item ID="0x08E9"/>
                <Item ID="0x08EA"/>
                <Item ID="0x2166"/>
                <Item ID="0x2167"/>
                <Item ID="0x2168"/>
                <Item ID="0x216a"/>
                <Item ID="0x3539"/>
                <Item ID="0x353a"/>
                <Item ID="0x353b"/>
                <Item ID="0x353c"/>
            </Group>
            <Group name="Corners">
                <Item ID="0x0540"/>
                <Item ID="0x0541"/>
                <Item ID="0x0542"/>
                <Item ID="0x0543"/>
                <Item ID="0x0544"/>
                <Item ID="0x0545"/>
                <Item ID="0x0546"/>
                <Item ID="0x0547"/>
                <Item ID="0x0548"/>
                <Item ID="0x0549"/>
                <Item ID="0x054A"/>
                <Item ID="0x054B"/>
                <Item ID="0x054C"/>
                <Item ID="0x054D"/>
                <Item ID="0x054E"/>
                <Item ID="0x054F"/>
                <Item ID="0x0551"/>
                <Item ID="0x0552"/>
                <Item ID="0x0553"/>
                <Item ID="0x056A"/>
            </Group>
            <Item ID="0x040B"/>
            <Item ID="0x040C"/>
            <Item ID="0x040D"/>
            <Item ID="0x040E"/>
            <Item ID="0x040F"/>
            <Item ID="0x0410"/>
            <Item ID="0x0411"/>
            <Item ID="0x0412"/>
            <Item ID="0x0413"/>
            <Item ID="0x0414"/>
            <Item ID="0x0415"/>
            <Item ID="0x0416"/>
            <Item ID="0x0417"/>
            <Item ID="0x0418"/>
            <Item ID="0x0419"/>
            <Item ID="0x041A"/>
            <Item ID="0x041B"/>
            <Item ID="0x041C"/>
            <Item ID="0x041D"/>
            <Item ID="0x041E"/>
            <Item ID="0x053B"/>
            <Item ID="0x053c"/>
            <Item ID="0x053d"/>
            <Item ID="0x053e"/>
            <Item ID="0x053f"/>
        </Group>
        <Group name="Dirt">
            <Item ID="0x1B27"/>
            <Item ID="0x1B28"/>
            <Item ID="0x1B29"/>
            <Item ID="0x1B2A"/>
            <Item ID="0x1B2B"/>
            <Item ID="0x1B2C"/>
            <Item ID="0x1B2D"/>
            <Item ID="0x1B2E"/>
            <Item ID="0x1B2F"/>
            <Item ID="0x1B30"/>
            <Item ID="0x1B31"/>
            <Item ID="0x1B32"/>
            <Item ID="0x1B33"/>
            <Item ID="0x1B34"/>
            <Item ID="0x1B35"/>
            <Item ID="0x1B36"/>
            <Item ID="0x1B37"/>
            <Item ID="0x1B38"/>
            <Item ID="0x1B39"/>
            <Item ID="0x1B3A"/>
            <Item ID="0x1B3B"/>
            <Item ID="0x1B3C"/>
            <Item ID="0x1B3D"/>
            <Item ID="0x1B3E"/>
            <Item ID="0x31F4"/>
            <Item ID="0x31F5"/>
            <Item ID="0x31F6"/>
            <Item ID="0x31F7"/>
            <Item ID="0x31F8"/>
            <Item ID="0x31F9"/>
            <Item ID="0x31Fa"/>
            <Item ID="0x31Fb"/>
            <Item ID="0x32c9"/>
            <Item ID="0x32ca"/>
        </Group>
        <Group name="Flora + Fauna">
            <Group name="Broad Trees">
                <Item ID="0x30bd"/>
                <Item ID="0x30be"/>
                <Item ID="0x30bf"/>
                <Item ID="0x30c0"/>
                <Item ID="0x30c1"/>
                <Item ID="0x30c2"/>
                <Item ID="0x30c3"/>
                <Item ID="0x30c4"/>
                <Item ID="0x30c5"/>
                <Item ID="0x30c6"/>
                <Item ID="0x30c7"/>
                <Item ID="0x30c8"/>
                <Item ID="0x30c9"/>
                <Item ID="0x30ca"/>
                <Item ID="0x30cb"/>
                <Item ID="0x30cc"/>
                <Item ID="0x30cd"/>
                <Item ID="0x30ce"/>
                <Item ID="0x30cf"/>
                <Item ID="0x30d0"/>
                <Item ID="0x30d1"/>
                <Item ID="0x30d2"/>
                <Item ID="0x30d3"/>
                <Item ID="0x30d4"/>
                <Item ID="0x30d5"/>
                <Item ID="0x30d6"/>
                <Item ID="0x30d7"/>
                <Item ID="0x30d8"/>
                <Item ID="0x30d9"/>
                <Item ID="0x30da"/>
                <Item ID="0x30db"/>
                <Item ID="0x30dc"/>
                <Item ID="0x30dd"/>
                <Item ID="0x30de"/>
            </Group>
            <Group name="Desert">
                <Item ID="0x0C93"/>
                <Item ID="0x0C94"/>
                <Item ID="0x0C95"/>
                <Item ID="0x0C96"/>
                <Item ID="0x0C97"/>
                <Item ID="0x0C98"/>
                <Item ID="0x0C99"/>
                <Item ID="0x0C9A"/>
                <Item ID="0x0C9B"/>
                <Item ID="0x0C9C"/>
                <Item ID="0x0C9D"/>
                <Item ID="0x0C9E"/>
                <Item ID="0x0CA5"/>
                <Item ID="0x0CA6"/>
                <Item ID="0x0CA7"/>
                <Item ID="0x0CA8"/>
                <Item ID="0x0CA9"/>
                <Item ID="0x0CAA"/>
                <Item ID="0x0CAB"/>
                <Item ID="0x0CC4"/>
                <Item ID="0x0CC5"/>
                <Item ID="0x0CC6"/>
                <Item ID="0x0CC7"/>
                <Item ID="0x0D25"/>
                <Item ID="0x0D26"/>
                <Item ID="0x0D27"/>
                <Item ID="0x0D28"/>
                <Item ID="0x0D2A"/>
                <Item ID="0x0D2C"/>
                <Item ID="0x0D2E"/>
                <Item ID="0x0D30"/>
                <Item ID="0x0D31"/>
                <Item ID="0x0D32"/>
                <Item ID="0x0D33"/>
                <Item ID="0x0D35"/>
                <Item ID="0x0D37"/>
                <Item ID="0x0D38"/>
                <Item ID="0x0D3F"/>
                <Item ID="0x0D40"/>
                <Item ID="0x0Dc4"/>
                <Item ID="0x0Dc5"/>
                <Item ID="0x3020"/>
                <Item ID="0x3021"/>
                <Item ID="0x3022"/>
                <Item ID="0x3023"/>
                <Item ID="0x3024"/>
            </Group>
            <Group name="Flowers">
                <Item ID="0x0C37"/>
                <Item ID="0x0C38"/>
                <Item ID="0x0C45"/>
                <Item ID="0x0C46"/>
                <Item ID="0x0C47"/>
                <Item ID="0x0C48"/>
                <Item ID="0x0C49"/>
                <Item ID="0x0C4A"/>
                <Item ID="0x0C4b"/>
                <Item ID="0x0C4c"/>
                <Item ID="0x0C4d"/>
                <Item ID="0x0C4e"/>
                <Item ID="0x0D29"/>
                <Item ID="0x0D2B"/>
                <Item ID="0x0D2D"/>
                <Item ID="0x0D2F"/>
                <Item ID="0x0D34"/>
                <Item ID="0x0D36"/>
                <Item ID="0x0c83"/>
                <Item ID="0x0c84"/>
                <Item ID="0x0c85"/>
                <Item ID="0x0c86"/>
                <Item ID="0x0c87"/>
                <Item ID="0x0c88"/>
                <Item ID="0x0c89"/>
                <Item ID="0x0c8a"/>
                <Item ID="0x0c8b"/>
                <Item ID="0x0c8c"/>
                <Item ID="0x0c8d"/>
                <Item ID="0x0c8e"/>
                <Item ID="0x0cbe"/>
                <Item ID="0x0cbf"/>
                <Item ID="0x0cc0"/>
                <Item ID="0x0cc1"/>
                <Item ID="0x18DF"/>
                <Item ID="0x18E0"/>
                <Item ID="0x18E1"/>
                <Item ID="0x18E2"/>
                <Item ID="0x18E5"/>
                <Item ID="0x18E6"/>
                <Item ID="0x18E9"/>
                <Item ID="0x18EA"/>
                <Item ID="0x1f0d"/>
                <Item ID="0x1f0e"/>
                <Item ID="0x1f0f"/>
                <Item ID="0x1f10"/>
                <Item ID="0x1f11"/>
                <Item ID="0x1f12"/>
                <Item ID="0x234b"/>
                <Item ID="0x234c"/>
                <Item ID="0x234d"/>
            </Group>
            <Group name="Fruit Trees">
                <Group name="Miniatures">
                    <Item ID="0x3128"/>
                    <Item ID="0x3129"/>
                    <Item ID="0x312a"/>
                    <Item ID="0x3f07"/>
                    <Item ID="0x3f0c"/>
                    <Item ID="0x3f16"/>
                </Group>
                <Item ID="0x0CE0"/>
                <Item ID="0x0CE1"/>
                <Item ID="0x0CE2"/>
                <Item ID="0x0CE3"/>
                <Item ID="0x0CE4"/>
                <Item ID="0x0CE5"/>
                <Item ID="0x0D94"/>
                <Item ID="0x0D95"/>
                <Item ID="0x0D96"/>
                <Item ID="0x0D97"/>
                <Item ID="0x0D98"/>
                <Item ID="0x0D99"/>
                <Item ID="0x0D9A"/>
                <Item ID="0x0D9B"/>
                <Item ID="0x0D9C"/>
                <Item ID="0x0D9D"/>
                <Item ID="0x0D9E"/>
                <Item ID="0x0D9F"/>
                <Item ID="0x0DA0"/>
                <Item ID="0x0DA1"/>
                <Item ID="0x0DA2"/>
                <Item ID="0x0DA3"/>
                <Item ID="0x0DA4"/>
                <Item ID="0x0DA5"/>
                <Item ID="0x0DA6"/>
                <Item ID="0x0DA7"/>
                <Item ID="0x0DA8"/>
                <Item ID="0x0DA9"/>
                <Item ID="0x0DAA"/>
                <Item ID="0x0DAB"/>
                <Item ID="0x2471"/>
                <Item ID="0x2472"/>
                <Item ID="0x2473"/>
                <Item ID="0x2474"/>
                <Item ID="0x2475"/>
                <Item ID="0x2476"/>
                <Item ID="0x2477"/>
                <Item ID="0x26ed"/>
                <Item ID="0x26ee"/>
                <Item ID="0x26ef"/>
                <Item ID="0x26f0"/>
                <Item ID="0x26f1"/>
                <Item ID="0x26f2"/>
                <Item ID="0x26f3"/>
                <Item ID="0x3122"/>
                <Item ID="0x3123"/>
                <Item ID="0x3124"/>
                <Item ID="0x36a0"/>
            </Group>
            <Group name="Hedge, Grass, Ferns">
                <Item ID="0x0C8F"/>
                <Item ID="0x0C90"/>
                <Item ID="0x0C91"/>
                <Item ID="0x0C92"/>
                <Item ID="0x0C9F"/>
                <Item ID="0x0CA0"/>
                <Item ID="0x0CA1"/>
                <Item ID="0x0CA2"/>
                <Item ID="0x0CA3"/>
                <Item ID="0x0CA4"/>
                <Item ID="0x0CAC"/>
                <Item ID="0x0CAD"/>
                <Item ID="0x0CAE"/>
                <Item ID="0x0CAF"/>
                <Item ID="0x0CB0"/>
                <Item ID="0x0CB1"/>
                <Item ID="0x0CB2"/>
                <Item ID="0x0CB3"/>
                <Item ID="0x0CB4"/>
                <Item ID="0x0CB5"/>
                <Item ID="0x0CB6"/>
                <Item ID="0x0CBC"/>
                <Item ID="0x0CBD"/>
                <Item ID="0x0CC3"/>
                <Item ID="0x0DB8"/>
                <Item ID="0x0DB9"/>
            </Group>
            <Group name="Misc Nature">
                <Item ID="0x0CF3"/>
                <Item ID="0x0CF4"/>
                <Item ID="0x0CF5"/>
                <Item ID="0x0CF6"/>
                <Item ID="0x0CF7"/>
                <Item ID="0x0D3B"/>
                <Item ID="0x0D3C"/>
                <Item ID="0x0D3D"/>
                <Item ID="0x0DAC"/>
                <Item ID="0x0DAD"/>
                <Item ID="0x0E56"/>
                <Item ID="0x0E57"/>
                <Item ID="0x0E58"/>
                <Item ID="0x0E59"/>
                <Item ID="0x1Ad4"/>
                <Item ID="0x1Ad5"/>
                <Item ID="0x1B1F"/>
                <Item ID="0x1B20"/>
                <Item ID="0x1B21"/>
                <Item ID="0x1B22"/>
                <Item ID="0x1B23"/>
                <Item ID="0x1B24"/>
                <Item ID="0x1B25"/>
                <Item ID="0x1B26"/>
                <Item ID="0x1B81"/>
                <Item ID="0x1B82"/>
                <Item ID="0x1B83"/>
                <Item ID="0x1B84"/>
                <Item ID="0x1B85"/>
                <Item ID="0x1B86"/>
                <Item ID="0x1B87"/>
                <Item ID="0x1B88"/>
                <Item ID="0x1B89"/>
                <Item ID="0x1B8A"/>
                <Item ID="0x1B8B"/>
                <Item ID="0x1B8C"/>
                <Item ID="0x1B8D"/>
                <Item ID="0x1B8E"/>
                <Item ID="0x1B8F"/>
                <Item ID="0x1B90"/>
                <Item ID="0x1B91"/>
                <Item ID="0x1B92"/>
                <Item ID="0x1B93"/>
                <Item ID="0x1B97"/>
                <Item ID="0x1B98"/>
                <Item ID="0x1B99"/>
                <Item ID="0x1B9A"/>
                <Item ID="0x1B9B"/>
                <Item ID="0x1B9C"/>
                <Item ID="0x1B9D"/>
                <Item ID="0x1B9E"/>
                <Item ID="0x2232"/>
                <Item ID="0x2233"/>
            </Group>
            <Group name="Mushroom">
                <Item ID="0x0D0C"/>
                <Item ID="0x0D0D"/>
                <Item ID="0x0D0E"/>
                <Item ID="0x0D0F"/>
                <Item ID="0x0D10"/>
                <Item ID="0x0D11"/>
                <Item ID="0x0D11"/>
                <Item ID="0x0D12"/>
                <Item ID="0x0D12"/>
                <Item ID="0x0D13"/>
                <Item ID="0x0D14"/>
                <Item ID="0x0D15"/>
                <Item ID="0x0D16"/>
                <Item ID="0x0D17"/>
                <Item ID="0x0D18"/>
                <Item ID="0x0D19"/>
                <Item ID="0x222E"/>
                <Item ID="0x222F"/>
                <Item ID="0x2230"/>
                <Item ID="0x2231"/>
            </Group>
            <Group name="Tall Trees">
                <Item ID="0x0D41"/>
                <Item ID="0x0D42"/>
                <Item ID="0x0D43"/>
                <Item ID="0x0D44"/>
                <Item ID="0x0D45"/>
                <Item ID="0x0D46"/>
                <Item ID="0x0D47"/>
                <Item ID="0x0D48"/>
                <Item ID="0x0D49"/>
                <Item ID="0x0D4A"/>
                <Item ID="0x0D4B"/>
                <Item ID="0x0D4C"/>
                <Item ID="0x0D4D"/>
                <Item ID="0x0D4E"/>
                <Item ID="0x0D4F"/>
                <Item ID="0x0D50"/>
                <Item ID="0x0D51"/>
                <Item ID="0x0D52"/>
                <Item ID="0x0D53"/>
                <Item ID="0x0D54"/>
                <Item ID="0x0D55"/>
                <Item ID="0x0D56"/>
                <Item ID="0x0D57"/>
                <Item ID="0x0D58"/>
                <Item ID="0x0D59"/>
                <Item ID="0x0D5A"/>
                <Item ID="0x0D5B"/>
                <Item ID="0x0D5C"/>
                <Item ID="0x0D5D"/>
                <Item ID="0x0D5E"/>
                <Item ID="0x0D5F"/>
                <Item ID="0x0D60"/>
                <Item ID="0x0D61"/>
                <Item ID="0x0D62"/>
                <Item ID="0x0D63"/>
                <Item ID="0x0D64"/>
                <Item ID="0x0D65"/>
                <Item ID="0x0D66"/>
                <Item ID="0x0D67"/>
                <Item ID="0x0D68"/>
                <Item ID="0x0D69"/>
                <Item ID="0x0D6A"/>
                <Item ID="0x0D6B"/>
                <Item ID="0x0D6C"/>
                <Item ID="0x0D6D"/>
                <Item ID="0x0D6E"/>
                <Item ID="0x0D6F"/>
                <Item ID="0x0D70"/>
                <Item ID="0x0D71"/>
                <Item ID="0x0D72"/>
                <Item ID="0x0D73"/>
                <Item ID="0x0D74"/>
                <Item ID="0x0D75"/>
                <Item ID="0x0D76"/>
                <Item ID="0x0D77"/>
                <Item ID="0x0D78"/>
                <Item ID="0x0D79"/>
                <Item ID="0x0D7A"/>
                <Item ID="0x0D7B"/>
                <Item ID="0x0D7C"/>
                <Item ID="0x0D7D"/>
                <Item ID="0x0D7E"/>
                <Item ID="0x0D7F"/>
                <Item ID="0x0D80"/>
                <Item ID="0x0D81"/>
                <Item ID="0x0D82"/>
                <Item ID="0x0D83"/>
                <Item ID="0x0D84"/>
                <Item ID="0x0D85"/>
                <Item ID="0x0D86"/>
                <Item ID="0x0D87"/>
                <Item ID="0x0D88"/>
                <Item ID="0x0D89"/>
                <Item ID="0x0D8A"/>
                <Item ID="0x0D8B"/>
                <Item ID="0x0D8C"/>
                <Item ID="0x0D8D"/>
                <Item ID="0x0D8E"/>
                <Item ID="0x0D8F"/>
                <Item ID="0x0D90"/>
                <Item ID="0x0D91"/>
                <Item ID="0x0D92"/>
                <Item ID="0x0D93"/>
                <Item ID="0x309c"/>
                <Item ID="0x309d"/>
                <Item ID="0x309e"/>
                <Item ID="0x309f"/>
                <Item ID="0x30a0"/>
                <Item ID="0x30a1"/>
                <Item ID="0x30a2"/>
                <Item ID="0x30a3"/>
                <Item ID="0x30a4"/>
                <Item ID="0x30a5"/>
                <Item ID="0x30a6"/>
                <Item ID="0x30a7"/>
                <Item ID="0x30a8"/>
                <Item ID="0x30a9"/>
                <Item ID="0x30aa"/>
                <Item ID="0x30ab"/>
                <Item ID="0x30ac"/>
                <Item ID="0x30ad"/>
                <Item ID="0x30ae"/>
                <Item ID="0x30af"/>
                <Item ID="0x30b0"/>
                <Item ID="0x30b1"/>
                <Item ID="0x30b2"/>
                <Item ID="0x30b3"/>
                <Item ID="0x30b4"/>
                <Item ID="0x30b5"/>
                <Item ID="0x30b6"/>
                <Item ID="0x30b7"/>
                <Item ID="0x30b8"/>
                <Item ID="0x30b9"/>
                <Item ID="0x30ba"/>
                <Item ID="0x30bb"/>
                <Item ID="0x30bc"/>
                <Item ID="0x39a3"/>
                <Item ID="0x39a4"/>
                <Item ID="0x39a5"/>
                <Item ID="0x39a6"/>
                <Item ID="0x39a7"/>
                <Item ID="0x39a8"/>
                <Item ID="0x39a9"/>
                <Item ID="0x39aa"/>
                <Item ID="0x39ab"/>
                <Item ID="0x39ac"/>
                <Item ID="0x39ad"/>
                <Item ID="0x39ae"/>
                <Item ID="0x39af"/>
                <Item ID="0x39b1"/>
                <Item ID="0x39b2"/>
                <Item ID="0x39b3"/>
                <Item ID="0x39b4"/>
                <Item ID="0x39b5"/>
                <Item ID="0x39b6"/>
                <Item ID="0x39b7"/>
                <Item ID="0x39b8"/>
                <Item ID="0x39b9"/>
                <Item ID="0x39ba"/>
                <Item ID="0x39bb"/>
                <Item ID="0x39bc"/>
                <Item ID="0x39c3"/>
                <Item ID="0x39c4"/>
                <Item ID="0x39c5"/>
                <Item ID="0x39c6"/>
                <Item ID="0x39c7"/>
                <Item ID="0x39c8"/>
                <Item ID="0x39c9"/>
                <Item ID="0x39ca"/>
                <Item ID="0x39cb"/>
                <Item ID="0x39cc"/>
                <Item ID="0x39cd"/>
                <Item ID="0x39ce"/>
                <Item ID="0x39cf"/>
                <Item ID="0x39d0"/>
                <Item ID="0x39d1"/>
                <Item ID="0x39d2"/>
                <Item ID="0x39d3"/>
                <Item ID="0x39e7"/>
                <Item ID="0x39e8"/>
                <Item ID="0x39e9"/>
                <Item ID="0x39ea"/>
                <Item ID="0x39eb"/>
                <Item ID="0x39ec"/>
                <Item ID="0x39ed"/>
                <Item ID="0x39ee"/>
                <Item ID="0x39ef"/>
                <Item ID="0x39f0"/>
                <Item ID="0x39f1"/>
                <Item ID="0x39f2"/>
                <Item ID="0x39f3"/>
                <Item ID="0x39f4"/>
                <Item ID="0x39f5"/>
                <Item ID="0x39f6"/>
                <Item ID="0x39f7"/>
                <Item ID="0x39f8"/>
                <Item ID="0x39f9"/>
                <Item ID="0x39fa"/>
                <Item ID="0x39fb"/>
                <Item ID="0x39fc"/>
                <Item ID="0x39fd"/>
                <Item ID="0x39fe"/>
                <Item ID="0x39ff"/>
                <Item ID="0x3a00"/>
                <Item ID="0x3a01"/>
                <Item ID="0x3a02"/>
                <Item ID="0x3a03"/>
                <Item ID="0x3a04"/>
                <Item ID="0x3a05"/>
                <Item ID="0x3a06"/>
                <Item ID="0x3a09"/>
                <Item ID="0x3a0a"/>
                <Item ID="0x3a0b"/>
                <Item ID="0x3a0c"/>
                <Item ID="0x3a0d"/>
                <Item ID="0x3a0e"/>
                <Item ID="0x3a0f"/>
                <Item ID="0x3a10"/>
                <Item ID="0x3a11"/>
                <Item ID="0x3a12"/>
                <Item ID="0x3a13"/>
                <Item ID="0x3a14"/>
                <Item ID="0x3a15"/>
                <Item ID="0x3a16"/>
                <Item ID="0x3a17"/>
                <Item ID="0x3a18"/>
                <Item ID="0x3a19"/>
                <Item ID="0x3a1a"/>
                <Item ID="0x3a1b"/>
                <Item ID="0x3a1c"/>
                <Item ID="0x3a1d"/>
                <Item ID="0x3a1e"/>
                <Item ID="0x3a33"/>
                <Item ID="0x3a34"/>
                <Item ID="0x3a35"/>
                <Item ID="0x3a36"/>
                <Item ID="0x3a37"/>
                <Item ID="0x3a38"/>
                <Item ID="0x3a39"/>
                <Item ID="0x3a3a"/>
                <Item ID="0x3a3b"/>
                <Item ID="0x3a3c"/>
                <Item ID="0x3a3d"/>
                <Item ID="0x3a3e"/>
                <Item ID="0x3a3f"/>
                <Item ID="0x3a40"/>
                <Item ID="0x3a41"/>
                <Item ID="0x3a42"/>
                <Item ID="0x3a43"/>
                <Item ID="0x3a44"/>
                <Item ID="0x3a9c"/>
                <Item ID="0x3a9d"/>
                <Item ID="0x3a9e"/>
                <Item ID="0x3a9f"/>
                <Item ID="0x3aa0"/>
                <Item ID="0x3aa1"/>
                <Item ID="0x3aa2"/>
                <Item ID="0x3aa3"/>
                <Item ID="0x3aa4"/>
                <Item ID="0x3aa5"/>
                <Item ID="0x3aa6"/>
                <Item ID="0x3aa7"/>
                <Item ID="0x3aa8"/>
                <Item ID="0x3aa9"/>
                <Item ID="0x3aaa"/>
                <Item ID="0x3aab"/>
                <Item ID="0x3aac"/>
                <Item ID="0x3aad"/>
                <Item ID="0x3aae"/>
                <Item ID="0x3aaf"/>
                <Item ID="0x3ab0"/>
                <Item ID="0x3ab1"/>
                <Item ID="0x3ab2"/>
                <Item ID="0x3ab3"/>
                <Item ID="0x3ab4"/>
                <Item ID="0x3ab5"/>
                <Item ID="0x3ab6"/>
                <Item ID="0x3ab7"/>
                <Item ID="0x3ab8"/>
                <Item ID="0x3ab9"/>
                <Item ID="0x3aba"/>
                <Item ID="0x3abb"/>
                <Item ID="0x3abc"/>
                <Item ID="0x3abd"/>
                <Item ID="0x3abe"/>
                <Item ID="0x3abf"/>
                <Item ID="0x3ac0"/>
                <Item ID="0x3ac1"/>
                <Item ID="0x3ac2"/>
                <Item ID="0x3ac3"/>
                <Item ID="0x3ac4"/>
                <Item ID="0x3ac5"/>
                <Item ID="0x3ac6"/>
                <Item ID="0x3ac7"/>
                <Item ID="0x3ac8"/>
                <Item ID="0x3ac9"/>
                <Item ID="0x3aca"/>
                <Item ID="0x3acb"/>
                <Item ID="0x3acc"/>
                <Item ID="0x3acd"/>
                <Item ID="0x3ace"/>
                <Item ID="0x3acf"/>
                <Item ID="0x3ad0"/>
                <Item ID="0x3ad1"/>
                <Item ID="0x3ad2"/>
                <Item ID="0x3ad3"/>
                <Item ID="0x3ad4"/>
                <Item ID="0x3ad5"/>
                <Item ID="0x3ad6"/>
                <Item ID="0x3ad7"/>
                <Item ID="0x3ad8"/>
                <Item ID="0x3ad9"/>
                <Item ID="0x3ada"/>
                <Item ID="0x3adb"/>
                <Item ID="0x3adc"/>
                <Item ID="0x3add"/>
                <Item ID="0x3ade"/>
                <Item ID="0x3adf"/>
                <Item ID="0x3ae0"/>
                <Item ID="0x3ae1"/>
                <Item ID="0x3ae2"/>
                <Item ID="0x3ae3"/>
                <Item ID="0x3ae4"/>
                <Item ID="0x3ae5"/>
                <Item ID="0x3ae6"/>
                <Item ID="0x3ae7"/>
                <Item ID="0x3ae8"/>
                <Item ID="0x3ae9"/>
                <Item ID="0x3aea"/>
                <Item ID="0x3aeb"/>
                <Item ID="0x3aec"/>
                <Item ID="0x3aed"/>
                <Item ID="0x3aee"/>
                <Item ID="0x3aef"/>
            </Group>
            <Group name="Trees for Wood">
                <Item ID="0x0CC8"/>
                <Item ID="0x0CC9"/>
                <Item ID="0x0CCA"/>
                <Item ID="0x0CCB"/>
                <Item ID="0x0CCC"/>
                <Item ID="0x0CCD"/>
                <Item ID="0x0CCE"/>
                <Item ID="0x0CCF"/>
                <Item ID="0x0CD0"/>
                <Item ID="0x0CD1"/>
                <Item ID="0x0CD2"/>
                <Item ID="0x0CD3"/>
                <Item ID="0x0CD4"/>
                <Item ID="0x0CD5"/>
                <Item ID="0x0CD6"/>
                <Item ID="0x0CD7"/>
                <Item ID="0x0CD8"/>
                <Item ID="0x0CD9"/>
                <Item ID="0x0CDA"/>
                <Item ID="0x0CDB"/>
                <Item ID="0x0CDC"/>
                <Item ID="0x0CDD"/>
                <Item ID="0x0CDE"/>
                <Item ID="0x0CDF"/>
                <Item ID="0x0CE6"/>
                <Item ID="0x0CE7"/>
                <Item ID="0x0CE8"/>
                <Item ID="0x0CE9"/>
                <Item ID="0x0CEA"/>
                <Item ID="0x0CF8"/>
                <Item ID="0x0CF9"/>
                <Item ID="0x0CFA"/>
                <Item ID="0x0CFB"/>
                <Item ID="0x0CFC"/>
                <Item ID="0x0CFD"/>
                <Item ID="0x0CFE"/>
                <Item ID="0x0CFF"/>
                <Item ID="0x0D00"/>
                <Item ID="0x0D01"/>
                <Item ID="0x0D02"/>
                <Item ID="0x0D03"/>
                <Item ID="0x0db7"/>
                <Item ID="0x1B7E"/>
                <Item ID="0x22aa"/>
                <Item ID="0x2478"/>
                <Item ID="0x2479"/>
                <Item ID="0x247A"/>
                <Item ID="0x247B"/>
                <Item ID="0x247C"/>
                <Item ID="0x247D"/>
                <Item ID="0x247E"/>
                <Item ID="0x36a1"/>
            </Group>
            <Group name="Vines">
                <Item ID="0x0CEB"/>
                <Item ID="0x0CEC"/>
                <Item ID="0x0CED"/>
                <Item ID="0x0CEE"/>
                <Item ID="0x0CEF"/>
                <Item ID="0x0CF0"/>
                <Item ID="0x0CF1"/>
                <Item ID="0x0CF2"/>
                <Item ID="0x0D34"/>
                <Item ID="0x1f0d"/>
                <Item ID="0x1f0e"/>
                <Item ID="0x1f0f"/>
                <Item ID="0x1f10"/>
                <Item ID="0x1f11"/>
                <Item ID="0x1f12"/>
                <Item ID="0x2CF9"/>
                <Item ID="0x2CFA"/>
                <Item ID="0x2CFB"/>
                <Item ID="0x2CFC"/>
            </Group>
            <Group name="Water Plants">
                <Item ID="0x0CB7"/>
                <Item ID="0x0CB8"/>
                <Item ID="0x0CB9"/>
                <Item ID="0x0CBA"/>
                <Item ID="0x0CBB"/>
                <Item ID="0x0D04"/>
                <Item ID="0x0D05"/>
                <Item ID="0x0D06"/>
                <Item ID="0x0D07"/>
                <Item ID="0x0D08"/>
                <Item ID="0x0D09"/>
                <Item ID="0x0D0A"/>
                <Item ID="0x0D0B"/>
                <Item ID="0x0DBA"/>
                <Item ID="0x0DBB"/>
                <Item ID="0x0DBC"/>
                <Item ID="0x0DBD"/>
                <Item ID="0x0DBE"/>
                <Item ID="0x0Dc1"/>
                <Item ID="0x0Dc2"/>
                <Item ID="0x0Dc3"/>
                <Item ID="0x246C"/>
                <Item ID="0x246D"/>
                <Item ID="0x246E"/>
                <Item ID="0x246F"/>
                <Item ID="0x2470"/>
            </Group>
        </Group>
        <Group name="Grass">
            <Item ID="0x177D"/>
            <Item ID="0x177e"/>
            <Item ID="0x177f"/>
            <Item ID="0x1780"/>
            <Item ID="0x1781"/>
            <Item ID="0x1782"/>
            <Item ID="0x1783"/>
            <Item ID="0x1784"/>
            <Item ID="0x1785"/>
            <Item ID="0x1786"/>
            <Item ID="0x1787"/>
            <Item ID="0x1788"/>
            <Item ID="0x1789"/>
        </Group>
        <Group name="Lava">
            <Group name="Lava with Stone">
                <Item ID="0x131e"/>
                <Item ID="0x1324"/>
                <Item ID="0x1327"/>
                <Item ID="0x132a"/>
                <Item ID="0x132d"/>
                <Item ID="0x1330"/>
                <Item ID="0x1333"/>
                <Item ID="0x1336"/>
                <Item ID="0x1339"/>
                <Item ID="0x133c"/>
                <Item ID="0x133f"/>
                <Item ID="0x1342"/>
                <Item ID="0x1345"/>
                <Item ID="0x1348"/>
                <Item ID="0x134b"/>
                <Item ID="0x3286"/>
                <Item ID="0x3287"/>
                <Item ID="0x3288"/>
                <Item ID="0x3289"/>
                <Item ID="0x328a"/>
                <Item ID="0x328b"/>
                <Item ID="0x328c"/>
                <Item ID="0x328d"/>
                <Item ID="0x328e"/>
                <Item ID="0x328f"/>
                <Item ID="0x3290"/>
                <Item ID="0x3291"/>
                <Item ID="0x3292"/>
                <Item ID="0x3293"/>
                <Item ID="0x3294"/>
                <Item ID="0x3295"/>
                <Item ID="0x329a"/>
                <Item ID="0x329b"/>
            </Group>
            <Group name="Lavafall">
                <Item ID="0x1A19"/>
                <Item ID="0x1A1E"/>
                <Item ID="0x1A23"/>
                <Item ID="0x1A28"/>
                <Item ID="0x1A2D"/>
                <Item ID="0x1A32"/>
                <Item ID="0x1A37"/>
                <Item ID="0x1A3B"/>
                <Item ID="0x1A3F"/>
                <Item ID="0x1A43"/>
                <Item ID="0x1A47"/>
                <Item ID="0x1A4C"/>
                <Item ID="0x1A51"/>
                <Item ID="0x1A56"/>
                <Item ID="0x1A5B"/>
                <Item ID="0x1A60"/>
                <Item ID="0x1A65"/>
                <Item ID="0x1A69"/>
                <Item ID="0x1A6D"/>
                <Item ID="0x1A71"/>
            </Group>
            <Group name="animation">
                <Item ID="0x1A75"/>
                <Item ID="0x1A7C"/>
                <Item ID="0x1A7D"/>
                <Item ID="0x1A7E"/>
                <Item ID="0x2AE4"/>
                <Item ID="0x343b"/>
                <Item ID="0x3447"/>
                <Item ID="0x344e"/>
                <Item ID="0x3457"/>
                <Item ID="0x3462"/>
                <Item ID="0x3468"/>
                <Item ID="0x36b0"/>
                <Item ID="0x36bd"/>
                <Item ID="0x36ca"/>
                <Item ID="0x36e4"/>
                <Item ID="0x36fe"/>
                <Item ID="0x3709"/>
            </Group>
            <Group name="stone only">
                <Item ID="0x329c"/>
                <Item ID="0x329d"/>
                <Item ID="0x329e"/>
                <Item ID="0x329f"/>
                <Item ID="0x32a0"/>
                <Item ID="0x32a1"/>
                <Item ID="0x32a2"/>
                <Item ID="0x32a3"/>
                <Item ID="0x32a4"/>
                <Item ID="0x32a5"/>
                <Item ID="0x32a6"/>
                <Item ID="0x32a7"/>
                <Item ID="0x32a8"/>
                <Item ID="0x32aa"/>
                <Item ID="0x32ab"/>
                <Item ID="0x32ac"/>
                <Item ID="0x32ad"/>
                <Item ID="0x32ae"/>
                <Item ID="0x32af"/>
                <Item ID="0x32b0"/>
                <Item ID="0x32b1"/>
                <Item ID="0x3546"/>
                <Item ID="0x354d"/>
                <Item ID="0x354e"/>
                <Item ID="0x354f"/>
                <Item ID="0x3550"/>
                <Item ID="0x3551"/>
                <Item ID="0x3552"/>
                <Item ID="0x3553"/>
                <Item ID="0x3554"/>
                <Item ID="0x3555"/>
                <Item ID="0x3556"/>
                <Item ID="0x3557"/>
                <Item ID="0x3558"/>
                <Item ID="0x3559"/>
                <Item ID="0x355a"/>
                <Item ID="0x355b"/>
                <Item ID="0x355c"/>
                <Item ID="0x355d"/>
                <Item ID="0x355e"/>
                <Item ID="0x355f"/>
                <Item ID="0x3560"/>
                <Item ID="0x3561"/>
            </Group>
            <Item ID="0x12ee"/>
            <Item ID="0x12f4"/>
            <Item ID="0x12fa"/>
            <Item ID="0x1300"/>
            <Item ID="0x1306"/>
            <Item ID="0x1312"/>
            <Item ID="0x1318"/>
            <Item ID="0x136e"/>
            <Item ID="0x137e"/>
            <Item ID="0x1380"/>
            <Item ID="0x1382"/>
            <Item ID="0x2B3E"/>
            <Item ID="0x2B45"/>
            <Item ID="0x2B4b"/>
            <Item ID="0x2B50"/>
            <Item ID="0x2B5c"/>
            <Item ID="0x3296"/>
            <Item ID="0x3297"/>
            <Item ID="0x3298"/>
            <Item ID="0x3299"/>
            <Item ID="0x3547"/>
            <Item ID="0x3548"/>
            <Item ID="0x3549"/>
            <Item ID="0x354a"/>
            <Item ID="0x354b"/>
            <Item ID="0x354c"/>
        </Group>
        <Group name="Rock + Boulder">
            <Item ID="0x134F"/>
            <Item ID="0x1350"/>
            <Item ID="0x1351"/>
            <Item ID="0x1352"/>
            <Item ID="0x1353"/>
            <Item ID="0x1354"/>
            <Item ID="0x1355"/>
            <Item ID="0x1356"/>
            <Item ID="0x1357"/>
            <Item ID="0x1358"/>
            <Item ID="0x1359"/>
            <Item ID="0x135A"/>
            <Item ID="0x135B"/>
            <Item ID="0x135C"/>
            <Item ID="0x135D"/>
            <Item ID="0x135E"/>
            <Item ID="0x135F"/>
            <Item ID="0x1360"/>
            <Item ID="0x1361"/>
            <Item ID="0x1362"/>
            <Item ID="0x1363"/>
            <Item ID="0x1364"/>
            <Item ID="0x1365"/>
            <Item ID="0x1366"/>
            <Item ID="0x1367"/>
            <Item ID="0x1368"/>
            <Item ID="0x1369"/>
            <Item ID="0x136A"/>
            <Item ID="0x136B"/>
            <Item ID="0x136C"/>
            <Item ID="0x136D"/>
            <Item ID="0x1771"/>
            <Item ID="0x1772"/>
            <Item ID="0x1773"/>
            <Item ID="0x1774"/>
            <Item ID="0x1775"/>
            <Item ID="0x1776"/>
            <Item ID="0x1777"/>
            <Item ID="0x1778"/>
            <Item ID="0x1779"/>
            <Item ID="0x177A"/>
            <Item ID="0x177B"/>
            <Item ID="0x177C"/>
            <Item ID="0x364E"/>
            <Item ID="0x364F"/>
        </Group>
        <Group name="Snow">
            <Item ID="0x17BD"/>
            <Item ID="0x17BE"/>
            <Item ID="0x17BF"/>
            <Item ID="0x17C0"/>
            <Item ID="0x17C1"/>
            <Item ID="0x17C2"/>
            <Item ID="0x17C3"/>
            <Item ID="0x17C4"/>
            <Item ID="0x17C5"/>
            <Item ID="0x17C6"/>
            <Item ID="0x17C7"/>
            <Item ID="0x17C8"/>
            <Item ID="0x17C9"/>
            <Item ID="0x17CA"/>
            <Item ID="0x17CB"/>
            <Item ID="0x17CC"/>
            <Item ID="0x17cD"/>
            <Item ID="0x17cE"/>
        </Group>
        <Group name="Swamp">
            <Group name="Animation">
                <Item ID="0x320d"/>
                <Item ID="0x3213"/>
                <Item ID="0x321a"/>
                <Item ID="0x3220"/>
                <Item ID="0x3226"/>
                <Item ID="0x322c"/>
                <Item ID="0x3236"/>
                <Item ID="0x3241"/>
            </Group>
            <Group name="Corners">
                <Item ID="0x3252"/>
                <Item ID="0x3253"/>
                <Item ID="0x3254"/>
                <Item ID="0x3255"/>
                <Item ID="0x3256"/>
                <Item ID="0x3257"/>
                <Item ID="0x3269"/>
                <Item ID="0x3270"/>
                <Item ID="0x3271"/>
                <Item ID="0x3272"/>
                <Item ID="0x3273"/>
                <Item ID="0x3274"/>
                <Item ID="0x3275"/>
                <Item ID="0x3276"/>
                <Item ID="0x3277"/>
                <Item ID="0x3278"/>
                <Item ID="0x3279"/>
                <Item ID="0x327a"/>
                <Item ID="0x327b"/>
                <Item ID="0x327c"/>
                <Item ID="0x327d"/>
                <Item ID="0x327e"/>
                <Item ID="0x327f"/>
                <Item ID="0x3280"/>
                <Item ID="0x3281"/>
                <Item ID="0x3282"/>
                <Item ID="0x3283"/>
                <Item ID="0x3284"/>
                <Item ID="0x3285"/>
            </Group>
            <Group name="Growth">
                <Item ID="0x3209"/>
                <Item ID="0x320a"/>
                <Item ID="0x3258"/>
                <Item ID="0x3259"/>
                <Item ID="0x325a"/>
                <Item ID="0x325b"/>
                <Item ID="0x325c"/>
                <Item ID="0x325d"/>
                <Item ID="0x325e"/>
                <Item ID="0x325f"/>
                <Item ID="0x3260"/>
                <Item ID="0x3261"/>
                <Item ID="0x3262"/>
                <Item ID="0x3263"/>
                <Item ID="0x3264"/>
                <Item ID="0x3265"/>
                <Item ID="0x3266"/>
                <Item ID="0x3267"/>
                <Item ID="0x3268"/>
            </Group>
            <Group name="Stumps">
                <Item ID="0x324b"/>
                <Item ID="0x324c"/>
                <Item ID="0x324d"/>
                <Item ID="0x324e"/>
                <Item ID="0x324f"/>
                <Item ID="0x3250"/>
                <Item ID="0x3251"/>
            </Group>
            <Item ID="0x326A"/>
            <Item ID="0x326a"/>
            <Item ID="0x326b"/>
            <Item ID="0x326c"/>
            <Item ID="0x326d"/>
            <Item ID="0x326e"/>
            <Item ID="0x326f"/>
        </Group>
        <Group name="Water">
            <Group name="Corners">
                <Item ID="0x179D"/>
                <Item ID="0x179E"/>
                <Item ID="0x179F"/>
                <Item ID="0x17A0"/>
                <Item ID="0x17A1"/>
                <Item ID="0x17A2"/>
                <Item ID="0x17A3"/>
                <Item ID="0x17A4"/>
                <Item ID="0x17A5"/>
                <Item ID="0x17A6"/>
                <Item ID="0x17A7"/>
                <Item ID="0x17A8"/>
                <Item ID="0x17A9"/>
                <Item ID="0x17AA"/>
                <Item ID="0x17AB"/>
                <Item ID="0x17AC"/>
                <Item ID="0x17AD"/>
                <Item ID="0x17AE"/>
                <Item ID="0x17AF"/>
                <Item ID="0x17B0"/>
                <Item ID="0x17B1"/>
                <Item ID="0x17B2"/>
            </Group>
            <Group name="Objects">
                <Item ID="0x3421"/>
                <Item ID="0x3426"/>
                <Item ID="0x342c"/>
                <Item ID="0x3486"/>
                <Item ID="0x348b"/>
                <Item ID="0x34ac"/>
                <Item ID="0x34b0"/>
            </Group>
            <Group name="Waterfall">
                <Item ID="0x34ED"/>
                <Item ID="0x34F4"/>
                <Item ID="0x34F9"/>
                <Item ID="0x34FF"/>
                <Item ID="0x3505"/>
                <Item ID="0x350B"/>
                <Item ID="0x3513"/>
                <Item ID="0x3517"/>
                <Item ID="0x351D"/>
                <Item ID="0x3523"/>
            </Group>
            <Group name="Wave etc.">
                <Item ID="0x1fa3"/>
                <Item ID="0x1fa8"/>
                <Item ID="0x1fae"/>
                <Item ID="0x1fb2"/>
                <Item ID="0x1fb7"/>
                <Item ID="0x1fbc"/>
                <Item ID="0x1fc6"/>
                <Item ID="0x346e"/>
                <Item ID="0x3474"/>
                <Item ID="0x347a"/>
                <Item ID="0x3480"/>
                <Item ID="0x3490"/>
                <Item ID="0x3494"/>
                <Item ID="0x349a"/>
                <Item ID="0x34a0"/>
                <Item ID="0x34a6"/>
                <Item ID="0x34ab"/>
                <Item ID="0x34b5"/>
                <Item ID="0x34b9"/>
                <Item ID="0x34bd"/>
                <Item ID="0x34c2"/>
                <Item ID="0x34c7"/>
                <Item ID="0x34d1"/>
                <Item ID="0x352d"/>
            </Group>
            <Item ID="0x1797"/>
            <Item ID="0x1798"/>
            <Item ID="0x179a"/>
            <Item ID="0x179b"/>
            <Item ID="0x179c"/>
            <Item ID="0x3499"/>
            <Item ID="0x349f"/>
            <Item ID="0x34a5"/>
            <Item ID="0x34ab"/>
        </Group>
    </Group>
</Items>


================================================
FILE: etc/license.txt
================================================
Razor Software License Agreement


This Agreement sets forth the terms and conditions under which
the software known as Razor(tm) will be licensed by the author(s)
("The Razor Author") to you ("Licensee"), and by which Derivative 
Works (as hereafter defined) of Razor will be licensed by you
to The Razor Author.

Definitions:

 "Derivative Work(s)" shall mean any revision, enhancement,
 modification, translation, abridgement, condensation or
 expansion created by Licensee or The Razor Author that is based upon the
 Software or a portion thereof that would be a copyright
 infringement if prepared without the authorization of the
 copyright owners of the Software or portion thereof.

 "Standard Version" shall mean Razor, as originally created by
 The Razor Author.

 "Software" shall mean Razor and the Derivative Works created
 by Licensee and the collection of files distributed by the
 Licensee with The Razor Author, and the collection of files created
 through textual modifications.

 "Copyright Holder" is whoever is named in the copyright or
 copyrights for the Derivative Works.

 "Licensee" is you, only if you agree to be bound by the terms
 and conditions set forth in this Agreement.

 "Freely Available" means that no fee is charged for the item
 It also means that recipients of the item may not redistribute
 it in any way shape or form.

1. The Razor Author maintains all rights, title and interest in and to
Razor, including all applicable copyrights, trade secrets,
patents and other intellectual rights therein.  Licensee hereby
grants to The Razor Author all right, title and interest into the compilation
of Razor. 

2. The Razor Author hereby grants to Licensee a royalty free, worldwide right
and license to use, Razor in accordance with the terms and conditions
of this Agreement.

3. Licensee hereby grants to The Razor Author a royalty free, worldwide right
and license to use, copy, distribute and make Derivative Works of
Derivative Works created by Licensee and sublicensing rights of
any of the foregoing.

4. The data and images supplied as input to or produced as output
from the Software do not automatically fall under the copyright
of this Software, but belong to whomever generated them, and may
be sold commercially, but may not be aggregated with this Software.

5. The Razor Author makes no representation about the suitability of Razor
for any purposes.  The Razor Author shall have no duty or requirement to
include any Derivative Works into Razor.

6. THIS PACKAGE IS PROVIDED "AS IS" WITHOUT WARRANTIES OF ANY
KIND, WHETHER EXPRESS OR IMPLIED, INCLUDING (BUT NOT LIMITED TO)
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, AND
WITHOUT ANY WARRANTIES AS TO NONINFRINGEMENT.

7. IN NO EVENT SHALL COPYRIGHT HOLDER BE LIABLE FOR ANY DIRECT,
SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES WHATSOEVER RESULTING
FROM LOSS OF USE OF DATA OR PROFITS, WHETHER IN AN ACTION OF
CONTRACT, NEGLIGENCE OR OTHER TORTIOUS CONDUCT, ARISING OUT OF OR
IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS PACKAGE.

8. Without limitation of the foregoing, You agree to commit no
act which, directly or indirectly, would violate any U.S. law,
regulation, or treaty, or any other international treaty or
agreement to which the United States adheres or with which the
United States complies, relating to the export or re-export of
any commodities, software, or technical data.

9. At no time shall anyone affiliated with Electronic Arts download
or use this software.  This software is provided soley for end-users
who have purchased Ultima Online for use in non-profit ways.

10. In addition to local, federal, and international laws 
prohibiting reverse engineering, the Licensee herby agrees to at no 
time make any attempts to decompile Razor or associated libraries 
or alter them in any way other without express written consent 
from the author.



================================================
FILE: etc/overrides.def
================================================
# This file allows you to override static values in Razor

## Two-Handed Weapons
# Razor uses the standard 1H and 2H for weapons to determine if they are one
# handed or two handed. You can override which weapon is two-handed

# twohanded id true/false
# Example: Crossbow
#twohanded 0xF4F false
#twohanded 0xF50 false


================================================
FILE: etc/spells.def
================================================
# Flag | Spell | Circle | Name | Words of Power | Regs Used
# Flag = H(armful) N(eutral) B(eneficial)

#
# Magery:
#
H | 1 | 1 | Clumsy | Uus Jux | BM | NS
N | 2 | 1 | Create Food | In Mani Ylem | GL | GS | MR
H | 3 | 1 | Feeblemind | Rel Wis | GS | NS
B | 4 | 1 | Heal | In Mani | GL | GS | SS
H | 5 | 1 | Magic Arrow | In Por Ylem | SA
N | 6 | 1 | Night Sight | In Lor | SS | SA
B | 7 | 1 | Reactive Armor | Flam Sanct | GL | SA | SS
H | 8 | 1 | Weaken | Des Mani | GL | NS
B | 1 | 2 | Agility | Ex Uus | BM | MR
B | 2 | 2 | Cunning | Uus Wis | MR | NS
B | 3 | 2 | Cure | An Nox | GL | GS
H | 4 | 2 | Harm | An Mani | NS | SS
N | 5 | 2 | Magic Trap | In Jux | GL | SA | SS
N | 6 | 2 | Magic Untrap | An Jux | BM | SA
B | 7 | 2 | Protection | Uus Sanct | GL | GS | SA
B | 8 | 2 | Strength | Uus Mani | MR | NS
B | 1 | 3 | Bless | Rel Sanct | GL | MR
H | 2 | 3 | Fireball | Vas Flam | BP
N | 3 | 3 | Magic Lock | An Por | SA | BM | GL
H | 4 | 3 | Poison | In Nox | NS
N | 5 | 3 | Telekinesis | Ort Por Ylem | BM | MR
N | 6 | 3 | Teleport | Rel Por | BM | MR
N | 7 | 3 | Unlock | Ex Por | BM | SA
N | 8 | 3 | Wall of Stone | In Sanct Ylem | BM | GL
B | 1 | 4 | Arch Cure | Vas An Nox | GL | GS | MR
B | 2 | 4 | Arch Protection | Vas Uus Sanct | GL | GS | MR | SA
H | 3 | 4 | Curse | Des Sanct | GL | NS | SA
N | 4 | 4 | Fire Field | In Flam Grav | BP | SS | SA
B | 5 | 4 | Greater Heal | In Vas Mani | GL | GS | MR | SS
H | 6 | 4 | Lightning | Por Ort Grav | MR | SA
H | 7 | 4 | Mana Drain | Ort Rel | BP | MR | SS
N | 8 | 4 | Recall | Kal Ort Por | BP | BM | MR
H | 1 | 5 | Blade Spirits | In Jux Hur Ylem | BP | MR | NS
N | 2 | 5 | Dispel Field | An Grav | GL | BP | SS | SA
N | 3 | 5 | Incognito | Kal In Ex | BM | GL | NS
B | 4 | 5 | Magic Reflection | In Jux Sanct | GL | MR | SS
H | 5 | 5 | Mind Blast | Por Corp Wis | BP | MR | NS | SA
H | 6 | 5 | Paralyze | An Ex Por | GL | MR | SS
N | 7 | 5 | Poison Field | In Nox Grav | BP | NS | SS
N | 8 | 5 | Summon Creature | Kal Xen | BM | MR | SS
N | 1 | 6 | Dispel | An Ort | GL | MR | SA
H | 2 | 6 | Energy Bolt | Corp Por | BP | NS
H | 3 | 6 | Explosion | Vas Ort Flam | BM | MR
N | 4 | 6 | Invisibility | An Lor Xen | BM | NS
N | 5 | 6 | Mark | Kal Por Ylem | BP | BM | MR
N | 6 | 6 | Mass Curse | Vas Des Sanct | GL | MR | NS | SA
N | 7 | 6 | Paralyze Field | In Ex Grav | BP | GS | SS
N | 8 | 6 | Reveal | Wis Quas | BM | SA
H | 1 | 7 | Chain Lightning | Vas Ort Grav | BP | MR | BM | SA
N | 2 | 7 | Energy Field | In Sanct Grav | BP | MR | SS | SA
H | 3 | 7 | Flamestrike | Kal Vas Flam | SS | SA
N | 4 | 7 | Gate Travel | Vas Rel Por | BP | MR | SA
H | 5 | 7 | Mana Vampire | Ort Sanct | BP | BM | MR | SS
N | 6 | 7 | Mass Dispel | Vas An Ort | BP | GL | MR | SA
H | 7 | 7 | Meteor Swarm | Flam Kal Des Ylem | BM | SS | MR | SA
N | 8 | 7 | Polymorph | Vas Ylem Rel | BM | MR | SS
H | 1 | 8 | Earthquake | In Vas Por | BM | GS | MR | SA
H | 2 | 8 | Energy Vortex | Vas Corp Por | BP | BM | MR | NS
B | 3 | 8 | Resurrection | An Corp | BM | GL | GS
N | 4 | 8 | Summon Air Elemental | Kal Vas Xen Hur | BM | MR | SS
N | 5 | 8 | Summon Daemon | Kal Vas Xen Corp | BM | MR | SS | SA
N | 6 | 8 | Summon Earth Elemental | Kal Vas Xen Ylem | BM | MR | SS
N | 7 | 8 | Summon Fire Elemental | Kal Vas Xen Flam | BM | MR | SS | SA
N | 8 | 8 | Summon Water Elemental | Kal Vas Xen An Flam | BM | MR | SS

#
# Necromancy
#
N | 1 | 10 | Animate Dead | Uus Corp | DB | GD
H | 2 | 10 | Blood Oath | In Jux Mani Xen | DB
N | 3 | 10 | Corpse Skin | In Agle Corp Ylem | BW | GD
B | 4 | 10 | Curse Weapon | An Sanct Gra Char | PI
H | 5 | 10 | Evil Omen | Pas Tym An Sanct | BW | NC
N | 6 | 10 | Horrific Beast | Rel Xen Vas Bal | BW | DB
N | 7 | 10 | Lich Form | Rel Xen Corp Ort | NC | DB | GD
H | 8 | 10 | Mind Rot | Wis An Ben | BW | DB | PI
H | 9 | 10 | Pain Spike | In Sar | GD | PI
H | 10 | 10 | Poison Strike | In Vas Nox | NC
H | 11 | 10 | Strangle | In Bal Nox | NC | DB
N | 12 | 10 | Summon Familiar | Kal Xen Bal | BW | GD | DB
N | 13 | 10 | Vampiric Embrace | Rel Xen An Sanct | BW | NC | PI
H | 14 | 10 | Vengeful Spirit | Kal Xen Bal Beh | BW | GD | PI
H | 15 | 10 | Wither | Kal Vas An Flam | NC | GD | PI
N | 16 | 10 | Wraith Form | Rel Xen Um | PI | NC
N | 17 | 10 | Exorcism | Ort Corp Grav | NC | GD

#
# Chivalry
#
B | 1 | 20 | Cleanse by Fire | Expor Flamus
B | 2 | 20 | Close Wounds | Obsu Vulni
B | 3 | 20 | Consecrate Weapon | Consecrus Arma
N | 4 | 20 | Dispel Evil | Dispiro Malas
B | 5 | 20 | Divine Fury | Divinum Furis
H | 6 | 20 | Enemy of One | Forul Solum
H | 7 | 20 | Holy Light | Augus Luminos
B | 8 | 20 | Noble Sacrifice | Dium Prostra
B | 9 | 20 | Remove Curse | Extermo Vomica
N | 10 | 20 | Sacred Journey | Sanctum Viatas

#
# Bushido
#
H | 1 | 40 | Honorable Execution | 
B | 2 | 40 | Confidence | 
B | 3 | 40 | Evasion | 
H | 4 | 40 | Counter Attack | 
H | 5 | 40 | Lightning Strike | 
H | 6 | 40 | Momentum Strike | 

#
# Ninjisu
#
H | 1 | 50 | Focus Attack | 
H | 2 | 50 | Death Strike | 
B | 3 | 50 | Animal Form | 
H | 4 | 50 | Ki Attack | 
H | 5 | 50 | Surprise Attack | 
H | 6 | 50 | Backstab | 
N | 7 | 50 | Shadowjump | 
N | 8 | 50 | Mirror Image | 

#
# Spellweaving
#
N | 1 | 60 | Arcane Circle | Myrshalee
B | 2 | 60 | Gift of Renewal | Olorisstra
N | 3 | 60 | Immolating Weapon | Thalshara
H | 4 | 60 | Attune Weapon | Haeldril
H | 5 | 60 | Thunderstorm | Erelonia
H | 6 | 60 | Nature's Fury | Rauvvrae
N | 7 | 60 | Summon Fey | Alalithra
N | 8 | 60 | Summon Fiend | Nylisstra
N | 9 | 60 | Reaper Form | Tarisstree
H | 10 | 60 | Wildfire | Haelyn
H | 11 | 60 | Essence of Wind | Anathrae
N | 12 | 60 | Dryad Allure | Rathril
N | 13 | 60 | Ethereal Voyage | Orlavdra
H | 14 | 60 | Word of Death | Nyraxle
B | 15 | 60 | Gift of Life | Illorae
B | 16 | 60 | Arcane Empowerment | Aslavdra

#
# Mysticism
#
H | 28 | 65 | Nether Bolt | In Corp Ylem
N | 29 | 65 | Healing Stone | Kal In Mani
H | 30 | 65 | Purge Magic | An Ort Sanct
N | 31 | 65 | Enchant | In Ort Ylem
H | 32 | 65 | Sleep | In Zu
H | 33 | 65 | Eagle Strike | Kal Por Xen
H | 34 | 65 | Animated Weapon | In Jux Por Ylem
N | 35 | 65 | Stone Form | In Rel Ylem
N | 36 | 65 | Spell Trigger | In Vas Ort Ex
H | 37 | 65 | Mass Sleep | Vas Zu
B | 38 | 65 | Cleansing Winds | In Vas Mani Hur
H | 39 | 65 | Bombard | Corp Por Ylem
H | 40 | 65 | Spell Plague | Vas Rel Jux Ort
H | 41 | 65 | Hail Storm | Kal Des Ylem
H | 42 | 65 | Nether Cyclone | Grav Hur
H | 43 | 65 | Rising Colossus | Kal Vas Xen Corp Ylem

#
# Masteries
# TODO: Correct flags
#
N | 1 | 70 | Inspire | Uus Por
N | 2 | 70 | Invigorate | An Zu
N | 3 | 70 | Resilience | Kal Mani Tym
N | 4 | 70 | Perserverance | Uus Jux Sanct
N | 5 | 70 | Tribulation | In Jux Hur Rel
N | 6 | 70 | Despair | Kal Des Mani Tym
N | 7 | 70 | Death Ray | In Grav Corp
N | 8 | 70 | Ethereal Burst | Uus Ort Grav
N | 9 | 70 | Nether Blast | In Vas Xen Por
N | 10 | 70 | Mystic Weapon | Vas Ylem Wis
N | 11 | 70 | Command Undead | In Corp Xen Por
N | 12 | 70 | Conduit | Uus Corp Grav
N | 13 | 70 | Mana Shield | Faerkulggen
N | 14 | 70 | Summon Reaper | Lartarisstree
N | 15 | 70 | Enchanted Summoning | NA
N | 16 | 70 | Anticipate Hit | NA
N | 17 | 70 | Warcry | NA
N | 18 | 70 | Intuition | NA
N | 19 | 70 | Rejuvenate | NA
N | 20 | 70 | Holy Fist | NA
N | 21 | 70 | Shadow | NA
N | 22 | 70 | White Tiger Form | NA
N | 23 | 70 | Flaming Shot | NA
N | 24 | 70 | Playing The Odds | NA
N | 25 | 70 | Thrust | NA
N | 26 | 70 | Pierce | NA
N | 27 | 70 | Stagger | NA
N | 28 | 70 | Toughness | NA
N | 29 | 70 | Onslaught | NA
N | 30 | 70 | Focused Eye | NA
N | 31 | 70 | Elemental Fury | NA
N | 32 | 70 | Called Shot | NA
N | 33 | 70 | Saving Throw | NA
N | 34 | 70 | Shield Bash | NA
N | 35 | 70 | Bodyguard | NA
N | 36 | 70 | Heighten Senses | NA
N | 37 | 70 | Tolerance | NA
N | 38 | 70 | Injected Strike | NA
N | 39 | 70 | Potency | NA
N | 40 | 70 | Rampage | NA
N | 41 | 70 | Fists of Fury | NA
N | 42 | 70 | Knockout | NA
N | 43 | 70 | Whispering | NA
N | 44 | 70 | Combat Training | NA
N | 45 | 70 | Boarding | NA



================================================
FILE: etc/uorguardlines.def
================================================
# Papua
5639 3095 192 223 -128 127
5831 3237 20 30 -128 127

# Delucia
5123 3942 192 122 -128 127
5147 4064 125 20 -128 127
5235 3930 80 12 -128 127

# Yew
92 656 349 225 -30 39
441 746 216 135 0 39
258 881 399 380 0 39
657 922 42 307 0 39
657 806 17 28 0 39
718 874 38 22 0 39
761 741 19 21 0 39

# Wind
5132 3 70 55 -128 127
5132 58 81 68 -128 127
5213 98 39 28 -128 127
5197 126 55 78 -128 127
5252 112 42 58 -128 127
5252 170 32 8 -128 127
5252 178 20 5 -128 127
5252 183 10 10 -128 127
5294 19 72 120 -128 127
5279 57 15 55 -128 127
5286 25 8 32 -128 127

# Jhelom
1303 3670 189 225 -20 127
1338 3895 74 28 -20 127
1383 3951 109 94 -20 127
1494 3767 12 11 -20 127

# Vesper
2899 599 25 9 -128 127
2899 608 84 26 -128 127
2983 624 25 32 -128 127
2937 634 46 22 -128 127
2983 617 7 7 -128 127
2845 634 92 110 -128 127
2937 685 58 59 -128 127			
2822 744 235 270 -128 127			
2818 696 27 14 -128 127			
2760 944 62 55 -128 127			
2728 966 32 33 -128 127			
2747 958 13 8 -128 127			

# Minoc
2411 366 135 241 -10 127
2548 495 72 55 -10 127
2564 585 3 42 -10 127
2567 585 61 61 -10 127
2499 627 68 63 -10 127
2694 685 15 16 -10 127

# Serpent's Hold. Get
2868 3324 205 195 0 127
2978 3545 11 11 0 127

# Magincia
3653 2046 27 48 0 127
3752 2046 52 48 0 127
3680 2045 72 49 0 127
3652 2094 160 180 -128 127
3649 2256 54 47 -128 127
3554 2132 18 18 -128 127

# Nujel'm
3583 1000 252 435 0 127
3544 1169 39 44 0 127
3514 1202 11 11 0 127

# Cove
2200 1110 50 50 -10 127
2200 1160 86 86 -10 127
2339 1256 11 11 0 127

# Ocllo
3597 2456 129 99 -128 127 F
3726 2493 7 13 -128 127 F
3597 2555 158 145 -128 127 F
3590 2595 7 40 -128 127 F


# Britain
1416 1498 324 279 -10 127
1500 1408 46 90 0 127
1385 1538 31 239 -10 127
1416 1777 324 60 0 127
1385 1777 31 130 0 127
1093 1538 292 369 0 127
1330 1991 13 13 -10 127

# Skara Brae
638 2062 12 11 0 127
538 2107 150 190 -10 127

# Trinsic
1856 2636 75 28 -10 127
1816 2664 283 231 -10 127
2099 2782 18 25 -10 127
1970 2895 47 32 -10 127
1796 2696 20 67 0 127
1800 2796 16 52 0 127
1823 2943 11 11 -128 127

# Moonglow
4535 844 20 3 0 127
4530 847 31 61 0 127
4521 914 56 49 0 127
4278 915 54 19 0 127
4283 944 53 73 0 127
4377 1015 59 37 -10 127
4367 1050 142 145 0 127
4539 1036 27 18 0 127
4517 1053 23 22 0 127
4389 1198 47 39 0 127
4466 1211 32 25 0 127
4700 1108 17 18 0 127
4656 1127 26 13 0 127
4678 1162 25 25 0 127
4613 1196 23 22 0 127
4646 1212 14 17 0 127
4677 1214 26 22 0 127
4459 1276 16 16 0 127
4622 1316 22 24 0 127
4487 1353 59 21 0 127
4477 1374 69 35 0 127
4659 1387 40 40 0 127
4549 1482 29 27 0 127
4405 1451 23 23 0 127
4483 1468 21 13 0 127


#duel
#5307 3681 33 26 -127 127 
#5158 3436 33 28 -127 127 
#5848 3500 27 30 -127 127 
#6055 2324 39 24 -127 127 
#5757 3658 27 26 -127 127

================================================
FILE: help/docs/download.md
================================================
---
description: Download Razor, a free tool designed to help with simple tasks while playing Ultima Online
---

# Download UO Razor

???+ tip "Client Support"
    It's **highly recommended** that you use the [ClassicUO](https://www.classicuo.eu/) client with this version of Razor, however it should work with the original 5.x and 7.x clients though support for any bugs may be limited.

    If you plan on using Razor with the original client, download the `x86` version otherwise download `x64` for ClassicUO.

## Latest Release

Use the links below to download the **latest** version of Razor. To learn more about each version, view the [release notes](releasenotes.md). You can also download previous versions on [Github](https://github.com/markdwags/Razor/releases).

[Download Razor 1.9.77.0 (x64)](https://github.com/markdwags/Razor/releases/download/v1.9.77.0/Razor-x64-1.9.77.0.zip){ .md-button .md-button--primary }

[Download Razor 1.9.77.0 (x86)](https://github.com/markdwags/Razor/releases/download/v1.9.77.0/Razor-x86-1.9.77.0.zip){ .md-button }

## Developer Preview

This is built automatically after each commit to master, so it may contain bugs and/or unfinished features but is generally considered stable.

[![Build & Deploy Dev Preview](https://github.com/markdwags/Razor/actions/workflows/build.yml/badge.svg?branch=master)](https://github.com/markdwags/Razor/actions/workflows/build.yml)

[Download Developer Preview (1.9.X.0) (x64)](https://github.com/markdwags/Razor/releases/download/Razor-dev-preview/Razor-dev-x64-preview.zip){ .md-button .md-button--primary }

[Download Developer Preview (1.9.X.0) (x86)](https://github.com/markdwags/Razor/releases/download/Razor-dev-preview/Razor-dev-x86-preview.zip){ .md-button }

[More Info](https://github.com/markdwags/Razor/releases/tag/Razor-dev-preview)


================================================
FILE: help/docs/faq.md
================================================
# Portability

This version of Razor is completely portable and can be installed in any location. All profiles, scripts, macros are all stored within subfolders of `Razor.exe`.

# Migrating Existing Profiles

To migrate/move Profiles, Scripts and Macros between Razor installations, simply close out of all instances of Razor and copy/paste the following folders/files from your old Razor location to the new location:

- `Profiles`
- `Macros`
- `Scripts`
- `counters.xml`
- `Razor.exe.config` (only if you made changes)

# Application Layout

## Folders

### Profiles

When you open Razor for the first time, a set of default settings are created.

!!! tip "Multiple Profiles"
    It's **highly recommend** that have you have 1 profile per character. If you use the same profile among multiple characters while logged in, you could potentially lose changes to your profile. It's doable, but requires an extra bit a caution to ensure you keep all your profiles synced up.

### Macros

Macros are stored in the `Macros` folder and saved with the `.macro` file extension. These files can be read using any basic text editor.

!!! tip "Absolute Target Variables"
    Macros are scared across Profiles. To avoid making multiple macros that do the same thing, be sure to review [Absolute Target Variables](help/macros.md#absolute-target-variables)

!!! warning
    Editing macros within the file can be difficult beyond simply copy/pasting due to syntax. If you'd like the ability to edit scripts in a text editor, check out the [Razor Scripting Engine](guide/index.md).

### Scripts

Scripts are stored in the `Scripts` folder and saved with the `.razor` file extension. These files can be read using any basic text editor.

!!! tip "Razor Scripting Engine"
    Razor has a built-in editor to help with syntax, color coding and auto-completion. Review the [Razor Scripting Engine](guide/index.md) for more details.

## Files

| File               | Descripton                                                                                                                                                                                                                                                  |
| ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `animdata.csv`     | This file contains the list of animations used when filtering different mobiles in                                                                                                                                                                          |
| `counters.xml`     | This files contains the list of items that can be counted by Razor. While the use of the counter in the titlebar has been deprecated for the in-game counter bar available in ClassicUO it's still required for the macro and script system to count items. |
| `guidelines.def`   | This file contains the guardline definitions that display on the UOPS map                                                                                                                                                                                   |
| `overrides.def`    | This file contains overrides for specific static values in Razor. See file for details.                                                                                                                                                                     |
| `Razor.exe.config` | This file is the base configuration for Razor and contains a few settings, such as more organizer or restock agents, that require the application to be started when those values are changed.                                                              |
| `spells.def`       | This file contains the list of spells in game and if they are considered Harmful or Beneficial.                                                                                                                                                             |

!!! warning
    Files not listed here the related binaries required for Razor to work. They include files ending with `.dll, .lib, .exe, .exp, .pdb` and **_should not_** be part of restoring Razor files between installations.

## Configuration

| File                   | Description                                                                 |
| ---------------------- | --------------------------------------------------------------------------- |
| `Razor.exe.config`     | This configuration is used if you are using Razor with the OSI client       |
| `ClassicUO.exe.config` | This configuration is used if you are using Razor with the ClassicUO client |

You must manually edit that file if you want to set any of these values.

```xml
  <appSettings>
    <add key="UODataDir" value="C:\Games\UO" />
    <add key="UOClient" value="C:\Games\UO\client.exe" />
    <add key="LastPort" value="2593" />
    <add key="LastProfile" value="default" />
    <add key="LastServer" value="login.server.com" />
    <add key="LastServerId" value="0" />
    <add key="ClientEncrypted" value="1" />
    <add key="ServerEncrypted" value="0" />
    <add key="ShowWelcome" value="1" />
    <add key="UId" value="21613fcd" />
    <add key="MaxOrganizerAgents" value="20" />
    <add key="MaxBuyAgents" value="10" />
    <add key="MaxRestockAgents" value="10" />
    <add key="ImportProfilesAndMacros" value="true" />
    <add key="BackupPath" value=".\Backup" />
  </appSettings>
```

### Agents

If you need more Organizer, Buy or Restock agents, modify these values or add them to the ClassicUO config.

```xml
<add key="MaxOrganizerAgents" value="20" />
<add key="MaxBuyAgents" value="10" />
<add key="MaxRestockAgents" value="10" />
```

# Overhead Messages

For details on how to use the Overhead Messages feature, view the [help guide](help/displaycounters.md#overhead-messages).

# In-Game Commands

Razor supports the following in-game commands (not case-sensitive).

!!! note "Command Prefix"
    The command prefix with the OSI client is `-`.

If you are using ClassicUO, you must prefix each command with `>`.

For example, instead of `-where` you would type `>where`. This is due to ClassicUO commands starting with `-` and several UO commands for yell, whisper, guild use other symbols so Razor had find something unique.

- `help` - Displays all the in-game commands you see here.
- `adduseonce` - Creates a target that adds the item to the **UseOnce** list.
- `time` - Displays the current client system time.
- `where` - Displays your X/Y/Z coordinates according to Razor.

!!! tip
    Some shards support `[where` to get your location from the server.

- `ping` - Pings the server 5 times and returns the results.
- `echo` - Send a message to yourself. Useful for leaving a note to yourself when macroing, for example.
- `getserial` - Get information on the RPV you are viewing to verify authenticity.
- `rpvinfo` - Get information on the RPV you are viewing to verify authenticity.
- `macro [name]` - This will run a macro in-game. If you have a macro called `CreateRobes` you would type `macro CreateRobes`.
- `hue` - Display information about an item, include the hue.
- `item` - Same as `hue`.
- `info` - Display a gump that shows info about the item or mobile selected.
- `resync` - This will resync your client, the same way the resync hotkey does.
- `mobile` - Display some general information about a mobile (used for debugging)
- `weather [weather_type] [num_of_effects]` - Set the weather in the game. Weather will end automatically after 6 minutes, on newer clients it will end in 10 minutes.
  - `[weather_type]`:
    - `0` - It starts to rain
    - `1` - A fierce storm approaches
    - `2` - It begins to snow
    - `3` - A storm is brewing
  - `[num_of_effects]` - Max number on the screen (client restriction) is 70.
- `season [season_type]` - Sets the season. This is client side only.
  - `[season_type]`:
    - `0` - Spring
    - `1` - Summer
    - `2` - Fall
    - `3` - Winter
    - `4` - Desolation
- `set [variable]` - Sets a macro variable\*
- `waypoint [x] [y]` or `track off` - Sets a waypoint at a specific `X/Y` location. If you pass `off` it will remove it from the client.
- `sysmsgs` - Show the current system message buffer
- `boat` - Show in-game boat control gump
- `hotkeys` - Show in-game gump with used hot keys

# Legacy Versions

These versions were developed before ClassicUO and will only work with the standard OSI client.

!!! warning
    These versions are no longer supported and while they should work just fine they should be considered legacy.

| Razor Version                                                       | Hash                                                                       |
| ------------------------------------------------------------------- | -------------------------------------------------------------------------- |
| [Razor v1.5.0.16](https://www.razorce.com/Razor_UOR_CE-1.5.0.16.zip) | `SHA256: 63D0B617FCE217C067A3270323C9E58B63F379F401B4224E0EA937DAA7871B8B` |
| [Razor v1.5.0.15](https://www.razorce.com/Razor_UOR_CE-1.5.0.15.zip) | `SHA256: 64916F16A72FDE5E9C17B3A180001A896E9472458C8DB69E09DC7E37D78A6B30` |
| [Razor v1.5.0.14](https://www.razorce.com/Razor_UOR_CE-1.5.0.14.zip) | `SHA256: 1D352F7814311FDBFC3EF16DEAD6664562C85B3817D953112F687099A98D104A` |
| [Razor v1.5.0.13](https://www.razorce.com/Razor_UOR_CE-1.5.0.13.zip) | `SHA256: 090D753820B791E115532E96703DE1650B4DB0CE88191355D0F65A5799A51571` |
| [Razor v1.5.0.12](https://www.razorce.com/Razor_UOR_CE-1.5.0.12.zip) | `SHA256: 1AC1DAFBBDEE3DBEB1D031E63CAF904D43B60A05E98CB83ECA4872F892BD4F36` |
| [Razor v1.5.0.11](https://www.razorce.com/Razor_UOR_CE-1.5.0.11.zip) | `SHA256: 5945E5F9D5C87FEF552881C319167BD4ED012AE01D31FA855449B034129F7225` |
| [Razor v1.5.0.10](https://www.razorce.com/Razor_UOR_CE-1.5.0.10.zip) | `SHA256: 80FACEE8DB005E5CB7A89EFEBEE4BEE2DA242C0BF9AFA31B20ADEBEC44ED7FEF` |
| [Razor v1.5.0.9](https://www.razorce.com/Razor_UOR_CE-1.5.0.9.zip)   | `SHA256: 63158C8987BA0E7FBBA5917018595617830CF7B72A699A50A34F79A943365EE0` |
| [Razor v1.5.0.8](https://www.razorce.com/Razor_UOR_CE-1.5.0.8.zip)   | `SHA256: 0D25D01C85CFC8BA51D4FFEEBF59A3DC23B2400850A4B41C613DFC50AFAD5487` |
| [Razor v1.5.0.7](https://www.razorce.com/Razor_UOR_CE-1.5.0.7.zip)   | `SHA256: BD239C8F10FB80C3D1F6D185557679A0FCCF0CE35B2DB6D726B0DB0DB8BE7B7A` |

## Experimental

This version of Razor is identical to version `1.5.0.16` except with one major change to how Razor figures our your position to address the Razor "desync" issue.

Some users have reported issues when logging in so that is why this version is marked as experimental. If you experience issues, please revert to 1.5.0.16.

| Razor Version                                                       | Hash                                                                       |
| ------------------------------------------------------------------- | -------------------------------------------------------------------------- |
| [Razor v1.5.0.17](https://www.razorce.com/Razor_UOR_CE-1.5.0.17.zip) | `SHA256: D26E8B887FC26B94FB5B0C50530BE07A4393783CCBEAA9C3FD5B38171A857571` |

## Validate Checksum

- Windows (using Powershell)

```powershell
Get-FileHash '.\Razor-1.x.x.x.zip' -Algorithm SHA25
```

- Mac

```bash
shasum -a 256 /path/to/Razor-1.x.x.x.zip' -Algorithm SHA256
```

- Linux

```bash
sha256sum /path/to/Razor-1.x.x.x.zip
```

## Configuration File

The **Welcome Screen** will control some of these settings, but some settings can only be changed by editing `.\Razor.exe.config`.

```xml
<appSettings>
    <add key="PatchEncy" value="1" /> <!-- Patch client encryption -->
    <add key="ServerEnc" value="0" /> <!-- Use OSI encryption -->
    <add key="MaxOrganizerAgents" value="20" /> <!-- Override the default Organizer agent count -->
    <add key="MaxBuyAgents" value="10" /> <!-- Override the default Buy agent count -->
    <add key="MaxRestockAgents" value="10" /> <!-- Override the default Restock agent count -->
    <add key="ImportProfilesAndMacros" value="false" />  <!-- If true, will import macros and profiles from %AppData%\Razor -->
    <add key="LastProfile" value="Test" /> <!-- Last profile used in Razor -->
    <add key="LastServer" value="test.server.com" /> <!-- Last server connected to in Razor -->
    <add key="LastPort" value="2597" /> <!-- Last server port connected to in Razor -->
    <add key="LastServerId" value="1" /> <!-- Index of the server selected in the dropdown -->
    <add key="ShowWelcome" value="1" /> <!-- Show the Welcome Screen when loading Razor -->
    <add key="UOClient" value="D:\Games\UO\client.exe" /> <!-- Location to Ultima Online client -->
    <add key="UODataDir" value="D:\Games\UO" /> <!-- Location to Ultima Online data directory -->
</appSettings>

<!-- You can define a list of servers here by adding values between <Servers></Servers> -->
<Servers>
    <add key="Custom Server" value="server.someserver.com,2593" />
</Servers>
```


================================================
FILE: help/docs/guide/commands.md
================================================
---
title: Script Commands
description: A list of all script commands for Razor, complete with descriptions and examples
---

# Command Overview

The commands issued in the scripting engine are similar to commands you might enter into a command prompt or shell.  Each line has a starting command and a set of parameters.  Some of those parameters are required, some are optional.

`command (required) [optional]`

All parameters are shown inside of parenthesis or brackets.  Parameters within parenthesis are **required** while those in brackets are _optional_ and will default to specific value if not provided.

If you want to pass several words as a single parameter you must wrap them using `'` or `"`. For example `'hello goodbye'` is one parameter, while `hello` `goodbye` is two.

For example, if your script is something like:

```razor
# Say 'Hello'
say Hello friends!
```

You will end up just saying `Hello`.  Instead, you if you wrap the words in single (') or double quotes (") the engine will see it as a single parameter.

```razor
# Say 'Hello friends!'
say 'Hello friends!'
```

If you prefix a command with the `@` this will silence any warning/output from the command.  For example:

!!! example

    ```razor
    // Generate warning if robe is out of reach
    lifttype 'robe'

    // Silence warning if robe is out of reach
    @lifttype 'robe'
    ```

Without the `@` symbol, if a robe isn't available, you would get an warning message telling you that it couldn't find a robe. But since the `@` symbol was provided, no warning is displayed.

# Action Commands

## attack

**Syntax**: `attack (serial)` or `attack ('variablename')`

**Description**: Attack a specific serial or variable tied to a serial.

!!! example

    === "Attack Target"

        ```razor
        attack '0x21B4'
        ```

    === "Attack Variable"

        ```razor
        attack 'attackdummy'
        ```
## cast

**Syntax**: `cast ('name of spell')`

**Description**: Cast a spell by name

!!! example

    === "Cast specific spell"

        ```razor
        cast 'greater heal'
        wft
        target 'self'
        ```

## classicuo

**Syntax**: `classicuo ('setting') ('value')` or `cuo ('setting') ('value')`

**Description**: This command will change specific settings/properties in your current ClassicUO profile.

!!! tip
    Type `>cuo list` to get a list of profile settings/properties to change

!!! example

    === "Turn off CUO music"

        ```razor
        overhead 'Turn off the music!'
        classicuo 'enablemusic' false
        ```

    === "Adjust music volume to 50%"

        ```razor
        overhead 'Turning music to 50%'
        classicuo 'musicvolume' 50
        ```

## cleardragdrop

**Syntax**: `cleardragdrop`

**Description**: Clears Razor's the drag/drop queue

!!! example

    === "Clear on sysmsg message"

        ```razor
        if insysmsg 'cannot reach'
            cleardragdrop
        endif
        ```

## clearhands

**Syntax**: `clearhands ('left'/'right'/'both')`

**Description**: Undress your hands based on the param.

!!! example

    === "Undress both hands"

        ```razor
        clearhands 'both'
        ```

    === "Undress left hand"

        ```razor
        clearhands 'left'
        ```

## cooldown

**Syntax**: `cooldown ('name') ('seconds') ['hue'] ['icon name'] ['sound'] ['stay visible'] ['foreground color'] ['background color']`

**Description**: This command will add a custom cooldown that will display as a gump in-game.

??? tip "Supported Foreground & Background Colors"
    You can set the foreground and background color of the specific cooldown down by using one of the colors below:

    > AliceBlue, AntiqueWhite, Aqua, Aquamarine, Azure, Beige, Bisque, Black, BlanchedAlmond, Blue, BlueViolet, Brown, BurlyWood, CadetBlue, Chartreuse, Chocolate, Coral, CornflowerBlue, Cornsilk, Crimson, Cyan, DarkBlue, DarkCyan, DarkGoldenrod, DarkGray, DarkGreen, DarkKhaki, DarkMagenta, DarkOliveGreen, DarkOrange, DarkOrchid, DarkRed, DarkSalmon, DarkSeaGreen, DarkSlateBlue, DarkSlateGray, DarkTurquoise, DarkViolet, DeepPink, DeepSkyBlue, DimGray, DodgerBlue, Firebrick, FloralWhite, ForestGreen, Fuchsia, Gainsboro, GhostWhite, Gold, Goldenrod, Gray, Green, GreenYellow, Honeydew, HotPink, IndianRed, Indigo, Ivory, Khaki, Lavender, LavenderBlush, LawnGreen, LemonChiffon, LightBlue, LightCoral, LightCyan, LightGoldenrodYellow, LightGray, LightGreen, LightPink, LightSalmon, LightSeaGreen, LightSkyBlue, LightSlateGray, LightSteelBlue, LightYellow, Lime, LimeGreen, Linen, Magenta, Maroon, MediumAquamarine, MediumBlue, MediumOrchid, MediumPurple, MediumSeaGreen, MediumSlateBlue, MediumSpringGreen, MediumTurquoise, MediumVioletRed, MidnightBlue, MintCream, MistyRose, Moccasin, NavajoWhite, Navy, OldLace, Olive, OliveDrab, Orange, OrangeRed, Orchid, PaleGoldenrod, PaleGreen, PaleTurquoise, PaleVioletRed, PapayaWhip, PeachPuff, Peru, Pink, Plum, PowderBlue, Purple, RebeccaPurple, Red, RosyBrown, RoyalBlue, SaddleBrown, Salmon, SandyBrown, SeaGreen, SeaShell, Sienna, Silver, SkyBlue, SlateBlue, SlateGray, Snow, SpringGreen, SteelBlue, Tan, Teal, Thistle, Tomato, Transparent, Turquoise, Violet, Wheat, White, WhiteSmoke, Yellow, YellowGreen

??? tip "Supported Icon Names"
    You can use any of the following icons.

    **NOTE:** Icon availability is based on the version of the client you have. If the icon doesn't display, it must be an icon that doesn't exist your data files.

    > AchievePerfection, ActiveMeditation, Agility, AnimalForm, AnticipateHit, ArcaneEmpowerment, ArchProtection, ArmorPierce, AttuneWeapon, AuraOfNausea, BarakoDraftOfMight, BarrabHemolymphConcentrate, Berserk, Bleed, Bless, Block, BloodOathCaster, BloodOathCurse, BloodwormAnemia, Boarding, Bodyguard, BoneBreaker, BoneBreakerImmune, CaddelliteInfused, CalledShot, CityTradeDeal, Clumsy, CombatTraining, Conduit, Confidence, ConsecrateWeapon, CorpseSkin, CounterAttack, CriminalStatus, Cunning, Curse, CurseWeapon, DeathRay, DeathRayDebuff, DeathStrike, DefenseMastery, DespairCaster, DespairTarget, Disarm, Disguised, DivineFury, DragonTurtleDebuff, DualWield, ElementalFury, ElementalFuryDebuff, Enchant, EnchantedSummoning, EnemyOfOne, EnemyOfOneDebuff, EssenceOfWind, EtherealBurst, EtherealVoyage, Evasion, EvilOmen, FactionStatLoss, FanDancerFanFire, FeebleMind, Feint, FeintDebuff, FishPie, FistsOfFury, Fly, FocusedEye, ForceArrow, GazeDespair, GiftOfLife, GiftOfRenewal, GrapesOfWrath, Healing, HeatOfBattleStatus, HeightenedSenses, HidingAndOrStealth, HiryuPhysicalResistance, HitLowerAttack, HitLowerDefense, HonorableExecution, Honored, HonoredDebuff, HorrificBeast, HowlOfCacophony, Humility, HumilityDebuff, ImmolatingWeapon, Incognito, InjectedStrike, InjectedStrikeDebuff, Inspire, Intuition, Invigorate, Invisibility, JukariBurnPoiltice, Knockout, KurakAmbushersEssence, LichForm, LightningStrike, MagicReflection, ManaPhase, ManaShield, MassCurse, MassSleep, MedusaStone, Mindrot, MomentumStrike, MortalStrike, MysticalPolymorphTotem, MysticWeapon, NightSight, Onslaught, OrangePetals, PainSpike, Paralyze, Perfection, Perseverance, Pierce, PlayingTheOdds, PlayingTheOddsDebuff, Poison, PoisonImmunity, Polymorph, Potency, PotionGloriousFortune, Protection, PsychicAttack, Rage, RageFocusingBuff, RageFocusingDebuff, Rampage, ReactiveArmor, ReaperForm, Resilience, RoseOfTrinsic, RotwormBloodDisease, RuneBeetleCorruption, SakkhraProphylaxis, SavingThrow, Shadow, ShieldBash, SkillUseDelay, Sleep, Sparks, SpellFocusingBuff, SpellFocusingDebuff, SpellPlague, Spirituality, SplinteringEffect, Stagger, StoneForm, Strangle, Strength, Surge, Swarm, SwarmImmune, SwingSpeedDebuff, TalonStrike, Thrust, ThrustDebuff, Thunderstorm, Tolerance, Toughness, TribulationCaster, TribulationTarget, TrueFear, UnknownGoblin, UnknownRedDrop, UnknownStar, UnknownTomato, UraliTranceTonic, VampiricEmbrace, Veterinary, Warcry, Warding, Weaken, Webbing, Whispering, WhiteTigerForm, WraithForm    

!!! example

    === "Simple cooldown"

        ```razor
        cooldown 'Refresh' 20
        ```

    === "Cooldown with custom hued text"

        ```razor
        cooldown 'Refresh' 20 234
        ```

    === "Cooldown with icon"

        ```razor
        cooldown 'Refresh' 15 0 'Agility'
        ```

    === "Cooldown a custom sound (flute)"

        ```razor
        cooldown 'Health Check' 20 0 0 61
        ```

    === "Cooldown remains when expired"

        ```razor
        # default cooldown, 20 seconds, remains after it expires
        cooldown 'Health Check' 20 0 0 0 true

        # default cooldown, 25 seconds, 235 hue, icon 30012, no sound, remains after it expires
        cooldown 'Health Check' 20 235 30012 0 true
        ```

    === "Cooldown with custom colors"

        ```razor
        cooldown 'Stay 1' 20 0 0 0 false 'Firebrick' 'Peru'
        ```

    === "Reset existing cooldown"

        ```razor        
        cooldown 'Refresh' 20

        wait 10 seconds

        cooldown 'Refresh' 20
        ```

## dclick

**Syntax**: `dclick (serial)` or `dclick ('left'/'right'/'hands')`

**Description**: This command will use (double-click) a specific item or mobile or use the item in one of your hands using `left`, `right` or `hands` to use an item in either hand.

!!! example

    === "Double-click a specific item id"

        ```razor
        dclick '0x34AB'
        ```

    === "Double-click a variable"

        ```razor
        dclick 'myvariable'
        ```

    === "Double-click any item in your hands"
        ```razor
        dclick 'hands'
        ```
    
    === "Double-click item in right hand"
        ```razor
        dclick 'right'
        ```

## dclicktype

**Syntax**: `dclicktype ('name of item'/'graphicId') [inrange (true/false)/backpack] [hue]`

**Description**: This command will use (double-click) an item type either provided by the name or the graphic ID.

!!! tip "Range Check"
    If you include the optional `true` parameter, items within range (2 tiles) will only be considered. If you include the optional `backpack` parameter, items in your backpack only be considered.

!!! tip "Getting the graphic name or ID"
    To get the name or the ID of item, use the `>info` command in Razor and click on the item. You can use either the `Item Name` or `Id`.

    ![item-command](../images/infocommand.png)

!!! example

    === "Use any item"

        ```razor
        dclicktype 'dagger'
        waitfortarget
        targettype 'robe'
        ```

    === "..with range check"

        ```razor hl_lines="1"
        dclicktype 'dagger' true
        waitfortarget
        targettype 'robe' true
        ```

    === "..with backpack only"

        ```razor hl_lines="1"
        dclicktype 'dagger' backpack
        waitfortarget
        targettype 'robe' backpack
        ```

    === "..with backpack and hue only"

        ```razor hl_lines="1"
        dclicktype 'dagger' backpack 45
        waitfortarget
        targettype 'robe' backpack
        ```

## dress

**Syntax**: `dress ('name of dress list')` or `dress (serial)`

**Description**: This command will execute a spec dress list you have defined in Razor or dress (left and drop) a specific serial

!!! example

    === "Use existing dress list"

        ```razor
        dress 'My Sunday Best'
        ```
    
    === "Using a serial"

        ```razor hl_lines="1"
        dress '0x345234'
        ```

    === "Using a variable"

        ```razor hl_lines="2"
        setvar 'hat'
        dress 'hat'
        ```

## drop

**Syntax**: `drop (serial) (x) (y) [z]` or `drop (serial) (layer)` or `drop 'ground' (x) (y) [z]`

**Description**: This command will drop the item you are holding either at your feet, on a specific layer , at a specific X/Y/Z location on the ground or within the defined serial.

!!! tip
    The functionality of `drop 'ground' (x) (y) [z]` is also available in with [droprelloc](./#droprelloc).

!!! tip
    A list of available [layers](./layers.md) for reference that can be used with this command.

!!! example

    === "Lift item, drop on your chest/torso"

        ```razor
        lift '0x400D54A7'
        drop 'self' InnerTorso
        ```

    === "Lift item, drop on ground at location"

        ```razor
        lift '0x400D54A7'
        drop 'ground' 5926 1148 0
        ```

## droprelloc

**Syntax**: `droprelloc (x) (y)`

**Description**: This command will drop the item you're holding to a location relative to your position.

Example:

!!! example

    === "Drop Relative Location"

        ```razor
        lift '0x400EED2A'
        wait 1000
        droprelloc 1 1
        ```

## getlabel

**Syntax**: `getlabel ('serial') ('variable name')`

**Description**: This command will get the label (text obtained by single-clicking an item) and save it to a variable.

!!! example

    === "Find a dog"

        ```razor
        if findtype '217' as 'a_dog'
            getlabel 'a_dog' 'dog_label'

            if 'Fido' in 'dog_label'
                overhead 'found mydog!' 5
                overhead 'dog_label' 67
            endif    
        endif
        ```

    === "Find a silver kryss"

        ```razor        
        setvar 'silver_bag'

        if findtype '0x140' as 'kryss'
            getlabel 'kryss' 'kryss_label'

            if 'silver' in 'kryss_label'
                overhead 'found silver kryss!' 5
                
                lift 'kryss' 1
                drop 'silver_bag' -1 -1 0
            endif    
        endif
        ```

## hotkey

**Syntax**: `hotkey ('name of hotkey')`

**Description**: This command will execute any Razor hotkey by name.

!!! example

    === "Hotkey"

        ```razor
        skill 'detect hidden'
        waitfortarget
        hotkey 'target self'
        ```

## interrupt

**Syntax**: `interrupt ['layer']`

**Description**: This command will interrupt a casting action. You can pass an [optional layer](layers.md) if you want interrupt to only attempt an interrupt using a specific layer.

!!! tip
    If you don't provide a specific layer to use for interrupt, Razor will search in the following order:

    `shirt, shoes, pants, head, gloves, ring, neck, waist, innertorse, bracelet, middletorso, earrings, arms, cloak, outertorso, outerlegs, innerlegs, righthand, lefthand`

!!! example

    === "Example"

        ```razor
        cast 'energy bolt'
        if hp < 10
            interrupt
            cast 'greater healing'
            wft
            target 'self'
        else
            wft
            target 'last'    
        endif        
        ```

    === "Specific layer"

        ```razor hl_lines="3"
        cast 'energy bolt'
        if hp < 10
            interrupt 'pants'
            cast 'greater healing'
            wft
            target 'self'
        else
            wft
            target 'last'    
        endif 
        ```

## lift

**Syntax**: `lift ('serial') ['amount'] ['timeout']`

**Description**: This command will lift a specific item and amount. If no amount is provided, `1` is set as default. If no timeout is provided, `30000` (30 seconds) is set as default

!!! tip "dress command"
    If you're looking to lift an item to wear, consider using the `dress` command instead.

!!! example

    === "Lift item and drop to the ground"

        ```razor
        lift '0x400EED2A'
        wait 1000
        droprelloc 1 1 0
        ```

    === "Lift item, timeout in 5 seconds if unable"
        
        ```razor       
        lift '0x400EED2A' 1 5000
        droprelloc 1 1 0
        ```

## lifttype

**Syntax**: `lifttype ('gfx') ['amount'] ['hue']` or `lifttype ('name of item') ['amount'] ['hue']`

**Description**: This command will lift a specific item by type either by the graphic id or by the name from your backpack. If no amount is provided, `1` is defaulted.

!!! example

    === "Lift by name"

        ```razor
        lifttype 'robe'
        wait 1000
        droprelloc 1 1
        ```

    === "Lift by item id"

        ```razor
        lifttype '0x1FCD'
        wait 1000
        droprelloc 1 1
        ```

    === "Lift by name, max 5"

        ```razor
        lifttype 'fish steak%s%' 5
        wait 1000
        droprelloc 1 1
        ```

    === "Lift by name, max 5, specific hue"

        ```razor
        lifttype 'fish steak%s%' 5 45
        wait 1000
        droprelloc 1 1
        ```

## music

**Syntax**: `music ('index')`

**Description**: This command will play music based on the ID.

!!! tip
    The music ID can often be found in `Music\Digital\Config.txt` in the main client files.

!!! example

    === "Description"

        ```razor hl_lines="3"
        overhead 'playings bucsden'
        wait 500
        music 11
        ```

## potion

**Syntax**: `potion ('potion type')`

Types: `heal, cure, refresh, nightsight, ns, explosion, strength, str, agility`

**Description**: This command will use a specific potion based on the type.

!!! example

    === "Use agility potion"

        ```razor
        potion 'agility'
        ```

    === "Use heal potion"

        ```razor
        potion 'heal'
        ```

## rename

**Syntax**: `rename (serial) ('name')`

**Description**: This command will attempt to rename the mobile to a new name.

!!! example

    === "Rename using serial"

        ```razor
        rename '0x453' 'Fluffy'
        ```

    === "Rename using variables"

        ```razor
        setvar 'mypet'

        rename 'mypet' 'Fluffy'
        ```

    === "Rename using last target"

        ```razor
        rename 'lasttarget' 'Fluffy'
        ```

## random

**Syntax**: `random ('max number')`

**Description**: This command will generate a random number between 1 and the max number.

!!! example

    === "Random Message Check"

        ```razor
        clearsysmsg

        random 10

        if insysmsg 'Random: 5'
            say 'Hello!'
        else
            say 'Hail!'
        endif
        ```

## script

**Syntax**: `script ('name')` or `script ('category\name')`

**Description**: This command will call another script.

!!! tip
    You can call scripts in categories using a `category1\category2\scriptname` format.

!!! example

    === "Execute script"

        ```razor hl_lines="2"
        if hp = 40
            script 'healcure'
        endif
        ```

    === "Execute script in category"

        ```razor hl_lines="2"
        if mana = 40
            script 'magery\meditation'
        endif
        ```

## setability

**Syntax**: `setability ('primary'/'secondary'/'stun'/'disarm') ['on'/'off']`

**Description**: This will set a specific ability on or off. If `on` or `off` is missing, `on` is defaulted.

!!! example

    === "Set stun"

        ```razor
        setability 'stun'
        ```

    === "Turn off stun"

        ```razor
        setability 'stun' off
        ```

## setvar

**Syntax**: `setvar ('variable') ['serial'] ['timeout']` or `setvariable ('variable') ['serial'] ['timeout']`

**Description**: This command will pause the script until you select a target to be assigned a variable. You can also provide a serial directly, which will bypass the target selection. Default timeout is 30 seconds that can be changed by passing in a new timeout value in milliseconds.

!!! tip "Temp variables"
    If you use `setvar!` (note the `!`) the variable will not be available in Razor's variable list to be used by other scripts and will go away at the end of the script's execution. You can remove it with the `unsetvar!` command.

!!! example

    === "Set variable and use it"

        ```razor
        setvar 'dummy'

        cast 'magic arrow'
        waitfortarget
        target 'dummy'
        ```

    === "Set variable with serial"

        ```razor
        setvar 'spellbook' '0x40000D'

        dress 'spellbook'        
        ```
    
    === "Set temp variable with serial"

        ```razor
        setvar! 'tempvar' '0x40000D'

        dclick 'tempvar'       
        ```

## skill

**Syntax**: `skill ('name of skill')` or `skill last`

**Description**: This command will use a specific skill (assuming it's a usable skill).

!!! tip "Supported skill names"
    `anatomy, animallore, itemidentification, itemid, armslore, begging, peacemaking, peace, cartography, detectinghidden, discord, discordance, evaluatingintelligence, evalint, forensicevaluation, forensiceval, hiding, provocation, provo, inscription, poisoning, spiritspeak, stealing, taming, tasteidentification, tasteid, tracking, meditation, stealth, removetrap, imbuing`

!!! example

    === "Use meditation"

        ```razor
        while mana < maxmana
            say 'mediation!'
            skill 'meditation'
            wait 11000
        endwhile
        ```

## sound

**Syntax**: `sound ('serial')`

**Description**: This command will play a specific sound based on serial id.

!!! example

    === "Description"

        ```razor hl_lines="3"
        overhead 'daemon sound'
        wait 500
        sound '0x166'
        ```

## unsetvar

**Syntax**: `unsetvar ('variable')`

**Description**: This command will remove the variable from the variable list.

!!! tip "Temp variables"
    If you use `unsetvar!` (note the `!`) with `setvar!` the variable will be removed from the list of variables just available for the script's execution.

!!! example

    === "Set variable, use it, unset"

        ```razor
        setvar 'dummy'

        cast 'magic arrow'
        waitfortarget
        target 'dummy'

        unsetvar 'dummy'
        ```
    
    === "Set temp variable with serial, unset"

        ```razor
        setvar! 'tempvar' '0x40000D'

        dclick 'tempvar'       

        unsetvar! 'tempvar'
        ```

## virtue

**Syntax**: `virtue ('honor'/'sacrifice'/'valor')`

**Description**: This command will invoke Honor, Sacrifice or Valor.

!!! example

    === "Invoke Honor"

        ```razor
        virtue 'honor'
        ```

    === "Invoke Sacrifice"

        ```razor
        virtue 'sacrifice'
        ```

    === "Invoke Valor"

        ```razor
        virtue 'valor'
        ```

## walk

**Syntax**: `walk ('direction')`

**Description**: This command will turn and/or walk your player in a certain direction.

!!! example

    === "Walk around"

        ```razor
        walk 'North'
        walk 'Up'
        walk 'West'
        walk 'Left'
        walk 'South'
        walk 'Down'
        walk 'East'
        walk 'Right'
        ```

## wait & pause

**Syntax**: `wait (time in milliseconds)` or `pause (time in milliseconds)` or `wait (duration) (shorthand)`

**Description**: This command will pause the execution of a script for a given time.

!!! tip "Tips"
    `1000` milliseconds is equal to `1` second. `1000 x number of seconds = total milliseconds`

    To make your script easier to read, you can **shorthand** instead of defining the full time in milliseconds.

    | Accepted Shorthand              |
    | ------------------------------- |
    | `seconds`, `second`, `sec`, `s` |
    | `minutes`, `minute`, `min`, `m` |

!!! example

    === "Wait 5 seconds"

        ```razor hl_lines="2"
        while stam < 100    
            wait 5000
        endwhile
        ```

    === "Wait 2 seconds (with shorthand)"

        ```razor hl_lines="2 6"
        while stam < 100    
            wait 2 sec
        endwhile

        while stam < 100    
            wait 2 seconds
        endwhile
        ```

    === "Wait 3 minutes (with shorthand)"

        ```razor hl_lines="2"
        say 'AFK for 3 minutes'
        wait 3 minutes
        say 'Back!'
        ```

## undress

**Syntax**: `undress ('name of dress list')'` or `undress 'LayerName'` or `undress (serial)`

**Description**: This command will either undress you completely if no dress list is provided. If you provide a dress list, only those specific items will be undressed. Lastly, you can define a layer name to undress.

!!! tip
    Available [layers](./layers.md) for reference

!!! example

    === "Full naked"

        ```razor
        undress
        ```

    === "Specfic items in dress list"

        ```razor
        undress 'My Sunday Best'
        ```

    === "Remove your shirt and pants"

        ```razor
        undress 'Shirt'
        undress 'Pants'
        ```
    === "Using a serial"

        ```razor hl_lines="1"
        undress '0x345234'
        ```

    === "Using a variable"

        ```razor hl_lines="2"
        setvar 'hat'
        undress 'hat'
        ```

# Agent Commands

## organizer

**Syntax**: `organizer ('number') ['set']`

**Description**: This command will execute a specific organizer agent. If the `set` parameter is included, you will instead be prompted to set the organizer agent's hotbag.

!!! example

    === "Execute organizer agent 1"

        ```razor
        organizer 1
        ```

    === "Set a hotbag on organizer agent 4"

        ```razor
        organizer 4 'set'
        ```

## restock

**Syntax**: `restock ('number') ['set']`

**Description**: This command will execute a specific restock agent. If the `set` parameter is included, you will instead be prompted to set the restock agent's hotbag.

!!! example

    === "Use Restock Agent 1"

        ```razor
        if count garlic < 4
            restock 1
        endif
        ```

    === "Set a hotbag on Restock Agent 4"

        ```razor
        restock 4 'set'
        ```

## scavenger

**Syntax**: `scavenger ('clear'/'add'/'on'/'off'/'set')`

**Description**: This command will control the scavenger agent.

* `clear`: Clear scavenger agent cache
* `add`: Select an item to add to the list
* `on`: Turn on the scavenger agent
* `off`: Turn off the scavenger agent
* `set`: Set the scavenger agent's hotbag

!!! example

    === "Turn off scavenger"

        ```razor
        scavenger 'off'
        ```

## sell

**Syntax**: `sell`

**Description**: This command will set the Sell agent's hotbag.

!!! example

    === "Set Agent Hotbag"

        ```razor
        sell
        ```

## useonce

**Syntax**: `useonce ('add'/'addcontainer')`

**Description**: This command will execute the UseOnce agent. If the `add` parameter is included, you can add items to your UseOnce list. If the `addcontainer` parameter is included, you can add all items in a container to your UseOnce list.

!!! example

    === "Use top item"

        ```razor
        useonce
        ```

    === "Add to list"

        ```razor
        useonce 'add'
        ```

    === "Add to container"

        ```razor
        useonce 'addcontainer'
        ```

# Gumps, Menus, & Prompt Commands

## gumpresponse

**Syntax**: `gumpresponse ('buttonID')`

**Description**: Responds to a specific gump button

!!! example

    === "Gump Response"

        ```razor
        gumpresponse 4
        ```

## gumpclose

**Syntax**: `gumpclose ['gumpID']`

**Description**: This command will close the last gump that opened. You may pass an optional gump ID.

!!! example

    === "Close last gump"

        ```razor
        gumpclose
        ```

    === "Close gump with id"

        ```razor
        dclick '0x4000174B'
        waitforgump 2341449854        
        gumpclose 2341449854
        ```

## menu

**Syntax**: `menu ('serial') ('index') ['false']`

**Description**: Selects a specific index within a context menu. Razor will block the menu from appearing by default. If you include the optional `false` parameter, the context menu won't be blocked by Razor.

!!! tip "Context Menu"
    This command applies to the context menu accessed on some servers via a single-click (such as on yourself, to open your paperdoll or backpack).

    ![context-menu](../images/contextmenu.png)

!!! example

    === "Open Paperdoll"

        ```razor
        menu 0 0
        ```

    === "Open Backpack"

        ```razor
        menu 0 1
        ```

## menuresponse

**Syntax**: `menuresponse ('index') ('menuId') ['hue']`

**Description**: Responds to a specific menu and menu ID

!!! warning
    This command does not work on context menus, they are for a less used menu type.  See the `menu` command to use context/popup menus.

!!! example

    === "Description"

        ```razor
        menuresponse 3 4
        ```

## promptresponse

**Syntax**: `promptresponse ('prompt response')`

**Description**: This command will respond to a prompt triggered from actions such as renaming runes or giving a guild title.

!!! example

    === "Rename a recall rune"

        ```razor
        dclicktype 'rune'
        waitforprompt
        promptresponse 'to home'
        ```

## waitforgump

**Syntax**: `waitforgump (gump id/'any') [timeout]`

**Description**: This command will wait for a gump. If no `gump id` is provided, it will wait for **any** gump. Default timeout is 30 seconds that can be changed by passing in a new timeout value in milliseconds.

!!! tip "Timeout parameter"
    To modify the default 30 second timeout for any gump, you must include include the `any` keyword before the timeout.

    `waitforgump 'any' 5000` will wait for 5 seconds

    `waitforgump 5000` will wait 30 seconds for a gump with the id of 5000

!!! example

    === "Wait for any gump"

        ```razor
        waitforgump 'any' 
        ```

    === "Wait for any gump for 10 seconds"

        ```razor
        waitforgump 'any' 10000
        ```

    === "Wait for specific gump"

        ```razor
        waitforgump 4
        ```

    === "Wait for specific gump for 5 seconds"

        ```razor
        waitforgump 34252 5000
        ```

## waitformenu

**Syntax**: `waitformenu (menu id/'any') [timeout]`

**Description**: This command will wait for a context menu. If no `menu id` is provided, it will wait for **any** menu. Default timeout is 30 seconds that can be changed by passing in a new timeout value in milliseconds.

!!! tip "Timeout parameter"
    To modify the default 30 second timeout for any menu, you must include include the `any` keyword before the timeout.

    `waitformenu 'any' 5000` will wait for 5 seconds

    `waitformenu 5000` will wait 30 seconds for a menu with the id of 5000

!!! warning
    This command does not work on context menus, they are for an less used menu type.  See the `menu` command to use context/popup menus.

!!! example

    === "Wait for any menu"

        ```razor
        waitformenu
        ```

    === "Wait for any menu for 5 seconds"

        ```razor
        waitformenu 'any' 5000
        ```

    === "Wait for specific menu"

        ```razor
        waitformenu 4
        ```

## waitforprompt

**Syntax**: `waitforprompt (promptid/'any') [timeout]`

**Description**: This command will wait for a prompt before continuing. If no `prompt id` is provided, it will wait for **any** prompt. Default timeout is 30 seconds that can be changed by passing in a new timeout value in milliseconds.

!!! tip "Timeout parameter"
    To modify the default 30 second timeout for any gump, you must include include the `any` keyword before the timeout.

    `waitforprompt 'any' 5000` will wait for 5 seconds

    `waitforprompt 5000` will wait 30 seconds for a prompt with the id of 5000

!!! example

    === "Renaming recalling rune"

        ```razor hl_lines="2"
        dclicktype 'rune'
        waitforprompt
        promptresponse 'to home'
        ```

    === "Rename recalling rune with wait"

        ```razor hl_lines="2"
        dclicktype 'rune'
        waitforprompt 'any' 5000
        promptresponse 'to home'
        ```

# Ignore Commands

## clearignore

**Syntax**: `clearignore`

**Description**: Clears your scripting ignore list

!!! tip
    Works in conjunction with `ignore` and `unignore`

!!! example

    === "General"

        ```razor hl_lines="1"
        clearignore

        if findtype 3572 backpack as 'wand' or findtype 3570 backpack as 'wand'
            overhead 'found' 44
            overhead 'wand' 44
    
            ignore 'wand'
        else
            overhead 'not found' 33
        endif
        ```

## ignore

**Syntax**: `ignore ('serial')` or `ignore ('list name')`

**Description**: Adds a specific serial to the script engine's ignore list to avoid finding items when using commands like `findtype`

!!! example

    === "Ignore by serial"

        ```razor hl_lines="3"
        clearignore

        ignore '0x123A'
        ```

    === "Ignore by variable"

        ```razor hl_lines="7"
        clearignore

        if findtype 3572 backpack as 'wand' or findtype 3570 backpack as 'wand'
            overhead 'found' 44
            overhead 'wand' 44
    
            ignore 'wand'
        else
            overhead 'not found' 33
        endif
        ```

## unignore

**Syntax**: `unignore ('serial')` or `unignore ('list name')`

**Description**: Removes a specific serial to the script engine's ignore list

!!! example

    === "Unignore by serial"

        ```razor hl_lines="1"
        unignore '0x123A'
        ```

    === "Unignore by variable"

        ```razor hl_lines="11"
        clearignore

        if findtype 3572 backpack as 'wand' or findtype 3570 backpack as 'wand'
            overhead 'found' 44
            overhead 'wand' 44
    
            ignore 'wand'

            wait 1000

            unignore 'wand'
        else
            overhead 'not found' 33
        endif
        ```

# List Commands

## clearlist

**Syntax**: `clearlist ('list name')`

**Description**: This command will clear a list but doesn't remove it.

!!! example

    === "General"

        ```razor
        if list 'mylist' > 0
            clearlist 'mylist'
        endif

        pushlist 'sample' 'hello'
        ```

## createlist

**Syntax**: `createlist ('list name')`

**Description**: This command will create an empty list.

!!! example

    === "Simple"

        ```razor
        if not listexists 'sample'
            createlist 'sample'
        endif

        pushlist 'sample' 'hello'
        ```

    === "Iterating Lists (foreach)"

        ```razor        
        if not listexists 'words'
            createlist 'words'
        endif

        pushlist 'words' 'loot'
        pushlist 'words' 'taming'
        pushlist 'words' 'felucca'
        pushlist 'words' 'trammel'
        pushlist 'words' 'pk'
        pushlist 'words' 'pvp'
        pushlist 'words' 'britannia'
        pushlist 'words' 'dungeon'
        pushlist 'words' 'crafting'
        pushlist 'words' 'gm'
        pushlist 'words' 'mobs'
        pushlist 'words' 'spawn'
        pushlist 'words' 'vendor'

        # Start at loot, and keep saying each item in the list the end.
        foreach 'word' in 'words'
            # Show the current item in the list above your head
            overhead 'word'
        endfor
        ```

## poplist

**Syntax**: `poplist ('list name') ('list value'/'front'/'back')`

**Description**: This command will remove an item from the list. You can either pass in the specific item, or use `front` or `back` to remove the item from the front or back of the list.

!!! tip
    You can use `poplist` as an [expression](../expressions/#poplist).

!!! example

    === "Remove first item in list"

        ```razor
        createlist 'list'
        pushlist 'list' 'hello'
        pushlist 'list' 'bye'

        poplist 'list' 'front'        
        ```

## pushlist

**Syntax**: `pushlist ('list name') ('list item') ['front'/'back']`

**Description**: This command will add an item to the list. You can define where in the list using `front` or `back` to remove the item from the front or back of the list. Default `pushlist` will add the item to end of the list.

!!! example

    === "Add item to list"

        ```razor
        createlist 'list'
        pushlist 'list' 'hello'
        pushlist 'list' 'bye'        
        ```

    === "Add item to front of list"

        ```razor
        createlist 'list'
        pushlist 'list' 'hello'
        pushlist 'list' 'bye' 'front'
        ```

## removelist

**Syntax**: `removelist ('list name')`

**Description**: This command will remove a list completely including all items in the list.

!!! example

    === "General"

        ```razor
        removelist 'listname'        
        ```
# Messaging Commands

## alliance

**Syntax**: `alliance ('message to send')`

**Description**: This command will force your character to say an alliance message passed as the parameter.

!!! example

    === "General"

        ```razor
        alliance 'Allies assemble!'
        ```

## clearsysmsg

**Syntax**: `clearsysmsg`

**Description**: Clears the internal system message queue

!!! example

    === "General"

        ```razor
        sysmsg 'hello'
        sysmsg 'bye'

        if insysmsg 'hello'
            say 'hello!'
        endif

        clearsysmsg

        if insysmsg 'bye'
            say 'this condition wont be met since it was cleared on line 8'
        endif
        ```

## emote

**Syntax**: `emote ('message to send') [hue]`

**Description**: This command will force your character to emote the message passed as the parameter.

!!! tip
    This command will append `*` around the emote so `emote 'smiles'` will be displayed in game as `*smiles*`.

!!! example

    === "Emote"

        ```razor
        emote 'smiles'
        ```

    === "Emote with hue"

        ```razor
        emote 'smiles in another color' 454
        ```

## guild

**Syntax**: `guild ('message to send')`

**Description**: This command will force your character to say a guild message passed as the parameter.

!!! example

    === "Guild message"

        ```razor
        guild 'Hello fellow guildmates!'
        ```

## overhead

**Syntax**: `overhead ('text') ['color'] ['serial']`

**Description**: This command will display a message over your head. Only you can see this.

!!! example

    === "Overhead message"

        ```razor
        if stam = 100
            overhead 'ready to go!'
        endif
        ```

## say

**Syntax**: `say ('message to send') [hue]` or `msg ('message to send') [hue]`

**Description**: This command will force your character to say the message passed as the parameter.

!!! example

    === "Say message"

        ```razor
        say 'Hello world!'
        ```

    === "Say message with hue"

        ```razor
        say 'Hello world!' 454
        ```

## sysmsg

**Syntax**: `sysmsg ('message to display in system message')`

**Description**: This command will display a message in the lower-left of the client.

!!! example

    === "Description"

        ```razor hl_lines="2"
        if stam = 100
            sysmsg 'ready to go!'
        endif
        ```

## waitforsysmsg

**Syntax**: `waitforsysmsg ('message to wait for') [timeout]` or `wfsysmsg ('message to wait for') [timeout]`

**Description**: This command will wait a specific message to be added to the system message queue before continuing.  Default timeout is 30 seconds that can be changed by passing in a new timeout value in milliseconds.

!!! example

    === "Wait for system message"

        ```razor hl_lines="1"
        waitforsysmsg 'ready to go'
        overhead 'Ready!'
        ```

    === "Wait for system message for 5 seconds"

        ```razor hl_lines="1"
        waitforsysmsg 'ready to go' 5000
        overhead 'Done waiting'
        ```

## whisper

**Syntax**: `whisper ('message to send') [hue]`

**Description**: This command will force your character to whisper the message passed as the parameter.

!!! example

    === "Whisper message"

        ```razor
        whisper 'Hello world!'
        ```

    === "Whisper message with hue"

        ```razor
        whisper 'Hello world!' 454
        ```

## yell

**Syntax**: `yell ('message to send') [hue]`

**Description**: This command will force your character to yell the message passed as the parameter.

!!! example

    === "Yell message"

        ```razor
        yell 'Hello world!'
        ```

    === "Yell message with hue"

        ```razor
        yell 'Hello world!' 454
        ```

# Targeting Commands

## clearall

**Syntax**: `clearall`

**Description**: Combines the following actions into one command: `Cancel Current Target, Clear Target Queue, Drop What You Are Currently Holding and Clear Drag/Drop Queue` into a single command.

!!! example

    === "Clear on sysmsg message"

        ```razor
        if insysmsg 'cannot find'
            clearall
        endif
        ```

## lasttarget

**Syntax**: `lasttarget`

**Description**: This command will target your last target set in Razor.

!!! example

    === "Cast on last target"

        ```razor
        cast 'magic arrow'
        waitfortarget
        lasttarget
        ```

## setlasttarget

**Syntax**: `setlasttarget ('serial')`

**Description**: This command will set the last target to the serial you pass as a parameter.

!!! tip
    You can use `hotkey 'Set Last Target'` if you prefer getting a cursor and targetting a specific object.

!!! example

    === "Set last target on variable"

        ```razor
        setvar 'dog' 0x239
        setlasttarget 'dog'
        ```

    === "..with findtype"

        ```razor
        // find a dog
        if findtype '217' as 'dog'
            setlasttarget 'dog'
            cast 'lightning'
            wft
            target 'dog'
        endif
        ```

## target

**Syntax**: `target ('closest/random/next/prev') [type1,type2] [humanoid/monster]` or `target ('closest/random/next/prev') [type1!type2] [humanoid/monster]` or `target (serial)` or `target (clear/cancel)`

**Description**: This command will target a specific mobile based either the type searched for or the serial. If you provide a list of target types, you can use `,` for a general list and `!` for a priority list.

| Type              | Notoriety Name                                   | Notoriety Color                            |
| ----------------- | ------------------------------------------------ | ------------------------------------------ |
| `nonfriendly`     | Attackable, Criminal, Enemy, Murderer            | Gray (but not criminal), Gray, Orange, Red |
| `friendly`        | Innocent, Guild/Ally                             | Blue, Green                                |
| `enemy`           | Enemy                                            | Orange                                     |
| `red`/`murderer`  | Murderer                                         | Red                                        |
| `gray`/`grey`     | Attackable, Criminal                             | Gray (but not criminal), Gray              |
| `criminal`        | Criminal                                         | Gray                                       |
| `blue`/`innocent` | Innocent                                         | Blue                                       |
| `friend`          | Based on your [friends list](../../help/friends) | Any                                        |

| List Type | Delimiter | Description                                                                                                        |
| --------- | --------- | ------------------------------------------------------------------------------------------------------------------ |
| General   | `,`       | When the script tries to acquire a target, it will look for all the target types passed in the list. See Examples. |
| Priority  | `!`       | When the script tries to acquire a target, it will prioritize each type. See Examples.                             |

!!! example

    === "Specific target"

        ```razor
        cast 'lightning'
        waitfortarget
        target '0xBB3'
        ```

    === "General list"

        ```razor
        cast 'lightning'
        waitfortarget

        // General list using a ,
        // If a red mobile is closer than a gray mobile, this will target the red mobile
        target closest gray,red
        ```

    === "Priority list"

        ```razor
        cast 'lightning'
        waitfortarget

        // Priority list using a !
        // If a red mobile is closer than a gray mobile, this will target the gray mobile
        target closest gray!red
        ```

    === "Target closest red"

        ```razor
        cast 'lightning'
        waitfortarget
        target closest 'red'
        ```

    === "Target closest gray or red monster"

        ```razor
        cast 'lightning'
        waitfortarget
        target closest 'gray,red' monster
        ```

    === "Target random mobile"

        ```razor
        cast 'lightning'
        waitfortarget
        target random
        ```

    === "Target random red monster"

        ```razor
        cast 'lightning'
        waitfortarget
        target random 'red' monster
        ```

    === "Next humanoid target"

        ```razor        
        target next humanoid
        ```    

    === "Cancel current target"

        ```razor        
        target cancel
        ```
    
    === "Clear target queue"

        ```razor        
        target clear
        ```

## targetrelloc

**Syntax**: `targetrelloc (x-offset) (y-offset)`

**Description**: This command will target a specific location on the map relative to your position.

!!! example

    === "Target 1 X, 1 Y from player location"

        ```razor
        cast 'fire field'
        waitfortarget
        targetrelloc 1 1
        ```

## targetloc

**Syntax**: `targetloc (x) (y) (z)`

**Description**: This command will target a specific location on the map.

!!! example

    === "Specific location"
     
        ```razor
        cast 'fire field'
        waitfortarget
        targetloc 5923 1145 0
        ```

## targettype

**Syntax**: `targettype ('name of item or mobile type'/'graphicId') [inrange (true/false)/backpack] [hue]`

**Description**: This command will target a specific type of mobile or item based on the graphic id or based on the name of the item or mobile.

!!! tip "Range Check"
    If the optional parameter is passed in as `true` only items within the range of `2` tiles will be considered. If the optional parameter is passed in as `backpack` only items in your backpack will be considered.

!!! tip "Getting the graphic name or ID"
    To get the name or the ID of item, use the `>info` command in Razor and click on the item. You can use either the `Item Name` or `Id`.

    ![item-command](../images/infocommand.png)

!!! example

    === "Target by name (any range)"

        ```razor hl_lines="3"
        dclicktype 'dagger'
        waitfortarget
        targettype 'robe'
        ```

    === "Target by type (any range)"

        ```razor hl_lines="3"
        dclick '0x4005ECAF'
        waitfortarget
        targettype '0x1F03'
        ```

    === "Target by type using serial (in range)" 

        ```razor hl_lines="3"
        dclick '0x4005ECAF'
        waitfortarget
        targettype '0x1F03' true
        ```
    
    === "Target by type using name (in range)" 

        ```razor hl_lines="3"
        dclick 'dagger'
        waitfortarget
        targettype 'robe' true
        ```

    === "Target by name (in backpack)" 
           
        ```razor hl_lines="3"
        dclicktype 'dagger' backpack
        waitfortarget
        targettype 'robe' backpack
        ```
    
    === "Target by name with hue (in backpack)" 
           
        ```razor hl_lines="3"
        dclicktype 'dagger' backpack
        waitfortarget
        targettype 'robe' backpack 45
        ```

## waitfortarget

**Syntax**: `waitfortarget [pause in milliseconds]` or `wft [pause in milliseconds]`

**Description**: This command will cause the script to pause until you have a target cursor.  By default it will wait 30 seconds but you can define a specific wait time if you prefer.

!!! example

    === "Cast and wait"

        ```razor hl_lines="2"
        cast 'energy bolt'
        waitfortarget
        hotkey 'Target Closest Enemy'
        ```

    === "Using 'wft' shorthand on last target"

        ```razor hl_lines="2"
        cast 'energy bolt'
        wft
        target 'last'
        ```

# Timer Commands

## createtimer

**Syntax**: `createtimer ('timer name')`

**Description**: This command will create a timer and immediately start counting up from 0

!!! example

    === "Create Timer"

        ```razor        
        if not timerexists 'sample'
            createtimer 'sample'
        endif           
        ```

## removetimer

**Syntax**: `removetimer ('timer name')`

**Description**: This command will remove/delete a specific timer

!!! example

    === "Delete Timer"

        ```razor        
        if timerexists 'sample'
            removetimer 'sample'
        endif           
        ```

## settimer

**Syntax**: `settimer ('timer name') ('number in milliseconds')`

**Description**: This command will set a timer to a specific number and start to count up immediately.

!!! example

    === "Set Timer"

        ```razor
        // Create a new timer
        if not timerexists 'sample'
            createtimer 'sample'
        endif

        // Reset every 10 seconds
        if timer 'sample' > 10000
            settimer 'sample' 0
        endif            
        ```


================================================
FILE: help/docs/guide/comments.md
================================================
---
title: Script Comments
description: A simple overview on how to leave comments in your UO Razor Scripts
---

# Comments Overview

You can use `//` or `#` at the beginning of the line to leave comments in your script.  These lines will be ignored during execution.

## // or #

!!! example

    === "Using //"

        ```razor
        // Hello world example
        say 'hello'
        //say 'world'
        ```

    === "Using #"

        ```razor
        # Hello world example
        say 'hello'
        # say 'world'
        ```


================================================
FILE: help/docs/guide/expressions.md
================================================
---
title: Script Expressions
description: A list of all script expressions for Razor, complete with descriptions and examples
---

# Statements & Loops

As found in the Razor macro system, you can use `if`, `for`, `foreach`, and `while` when writing a script to add some basic logic and flows.

## if

**Syntax**:

```razor
if (expression)
    // commands to execute if this expression is true
elseif (expression)
    // commands to execute if the first expression was false, and this expression is true
else
    // commands to execute if both expressions above were false, default to running these
endif
```

**Description**: This selects a path to execute based on the value of a boolean expression. An `if` statement can be combined with `else` or `elseif` to choose two or more distinct paths based on the result of the boolean expression. All `if` statements must end with `endif`.

!!! example

    === "if/endif"

        ```razor
        if stam = 100
            overhead 'Stam at 100!'
        endif
        ```

    === "if/elseif/else"

        ```razor
        if stam = 100
            say 'Stamina full'
        elseif stam < 20
            say 'Still a ways to go'
        elseif stam < 60
            say 'Getting closer'
        else
            say 'waiting'
        endif
        ```

    === "if/elseif"

        ```razor
        if stam = 100
            say 'Stamina full'
        elseif stam < 20
            say 'Still a ways to go'
        elseif stam < 60
            say 'Getting closer'
        endif
        ```

    === "Using 'not'"

        ```razor
        if not stam = 100
            say 'Stamina is not full'    
        endif
        ```

## for

**Syntax**:

```razor
for ('number')
    // commmands to execute the number of times defined in the for statement
endfor
```

**Description**: This allows you to execute a block of commands a specific number of times. All `for` loops must end with `endfor`.

!!! tip
    You can use the [index](variables.md#index-variable) variable to track your position in the for loop.

When using `for` or `while` you have access to the `index` variable. This can be used with `overhead` (for example) to indicate the current loop number.

!!! example

    === "Say 'Hello' 10 times"

        ```razor        
        for 10
            say 'hello'
            wait 1000
        endfor
        ```

    === "Output current loop number"

        ```razor
        for 10
            wait 1000
            overhead 'index'
        endfor
        ```

## foreach

**Syntax**:

```razor
foreach ('variable') in ('list')
    // commands to execute for each item that is in a list
endfor
```

**Description**: This allows you to iterate over a list containing values. All `foreach` loops must end with `endfor`.

!!! example

    === "Loop through each item in a list"

        ```razor        
        createlist 'mylist'
        pushlist 'mylist' '0x1'
        pushlist 'mylist' '0x2'

        foreach 'item' in 'mylist'
           overhead 'item'
        endfor
        ```

## while

**Syntax**:

```razor
while ('expression')
    // commands to execute as long as the expression is remains true
endwhile
```

**Description**: This allows you execute a block of commands while a certain expression is true. All `while` loops must end with `endwhile`.

!!! example

    === "While"

        ```razor
        while hits < 100
            say 'I need a heal!'
            wait 1000
        endwhile
        ```

# Expression Operators

When using the `if` or `while` conditions, you can access the following expressions in the statement.

The following operators are supported:

| Operator | Description           |
| -------- | --------------------- |
| =        | Equal                 |
| ==       | Equal                 |
| !=       | Not equal             |
| <        | Less than             |
| <=       | Less than or equal    |
| >        | Greater than          |
| >=       | Greater than or equal |

# Expressions

Expressions are combined with statements like `if` and `while` to alter the execution path of your script.

Below are the several different types of expressions you can use broken into categories.

# List Expressions

## inlist

- `inlist ('list name') ('list item')`

Description: Used to check if a specific item is in a list

!!! example

    === "General"

        ```razor
        if inlist 'my_list' 'item1'
            overhead 'found item!'
        endif
        ```   

## list

- `list ('list name')`

Description: Used to check how many items are in a specific list

!!! example

    === "General"

        ```razor
        if list 'mylist' = 10
            overhead '10 items in your list'
        endif
        ```

## listexists

- `listexists ('list name')`

Description: Used to check if a list exists with a specific name.

!!! example

    === "General"

        ```razor
        if not listexists 'mylist'
            createlist 'mylist'
        endif
        ```

## poplist

- `poplist ('list name') ('list value'/'front'/'back')`

Description: This command will remove (pop) an item from the list. You can either pass in the specific item, or use `front` or `back` to remove the item from the front or back of the list.

!!! example

    === "General"

        ```razor
        if poplist 'mylist' back as 'item'
            overhead 'item'
        endif
        ```

# Misc Expressions

## count/counter

- `count ('name of counter')`
- `counter ('name of counter')`
- `count ('name of item') [hue]`
- `count (graphicID) [hue]`

Description: Used to get the current amount of a specific item in player's backpack.
Omitting the hue argument will result in count of all items of the specified type regardless of their hue.
The expression can be used either directly by item type and hue, or by referencing a named counter manually set up in the Counters tab.
[More info](../help/displaycounters.md#counters)

!!! example

    === "Counting garlic"

        ```razor
        if count 'garlic' < 5
            say 'getting low on garlic'
        endif
        ```
        
    === "Counting runebooks"
    
        ```razor
        if count 'spellbook' '1121' == 0
            say 'no runebooks found!'
        endif
        ```
        
    === "Detecting fancy coins"

        ```razor
        if count 'gold coin' > count 'gold coin' 0
            overhead 'woot woot fancy coins in the pack!'
        endif
        ```

## findtype

- `findtype ('name of item') [inrangecheck (true/false)/backpack] [hue]` OR `findtype (graphicID) [inrangecheck (true/false)/backpack] [hue]`

Description: Used to check if a specific item name of graphic ID exists. Range check, if true, will check within 2 tiles.

!!! tip "The `as` keyword"
    If you use `findtype` along with `as` you can assign a temporary variable to use throughout the script. See example below.

!!! tip "In-Game Info Gump"
    Not sure what name to enter or graphic ID to enter? Type `>info` and click on any item or mobile for more information.

    ![item-command](../images/infocommand.png)

    Click the blue dot next to the value you want to copy to the clipboard.

!!! example

    === "Find a saw"

        ```razor
        if findtype 'saw'
            say 'found saw'
        endif
        ```
    
    === "Find a saw using graphic id"

        ```razor
        if findtype '4148'
            say 'found saw'
        endif
        ```

    === "Find a saw within 2 tiles"

        ```razor
        if findtype 'saw' true
            say 'found saw within 2 tiles'
        endif
        ```

    === "Find a saw in your backpack"

        ```razor
        if findtype 'saw' backpack
            say 'found saw in my pack'
        endif
        ```

    === "Find a dagger and use it (using as)"

        ```razor hl_lines="1"
        if findtype 'dagger' as 'mydagger'
            overhead 'found dagger'
            dclick 'mydagger'
        endif
        ```

    === "Find a dagger in backpack with a hue"

        ```razor
        if findtype 'dagger' backpack 45 as 'mydagger'
            overhead 'found dagger'
            dclick 'mydagger'
        endif
        ```

## insysmsg

- `insysmsg ('message to look for')`
- `insysmessage ('message to look for')`

Description: Used to check if certain text appears within the system message log.

!!! tip "System Message Queue"
    Not sure if a specific message is in Razor's system message queue? Type `>sysmsgs` to see what Razor can find.

    Using `clearsysmsg` will clear out the queue completely.

!!! example

    === "Check for message"

        ```razor
        if insysmsg 'too far away'
            overhead 'You are too far away'
        endif
        ```   

## itemcount

- `itemcount`

Description: Used to return the current number of items you're carrying

!!! example

    === "General"

        ```razor
        if itemcount < 125
            overhead 'I still have room!'
        endif
        ```

## queued

- `queued`

Description: Used to check if your current queue is active (from restocking, organizing, etc)

!!! example

    === "General"

        ```razor
            if queued
                overhead 'Queue is active'
            else
                overhead 'No queue'
            endif
        ```

    === "Organizer"

        ```razor
        overhead 'Organizing'

        organizer 1

        while queued
            overhead 'Currently Organizing'
            wait 500 
        endwhile

        overhead 'Organized'
        ```

    === "Restock"

        ```razor
        overhead 'Restocking'

        restock 11
        waitfortarget 
        target 'self'

        while queued
            overhead 'Currently restocking'
            wait 500 
        endwhile

        overhead 'Restocked'
        ```

## targetexists

- `targetexists ['any'/'beneficial'/'harmful'/'neutral']`

Description: Used to check if the client current has a target cursor up

!!! example

    === "General"

        ```razor
        if targetexists 'beneficial'
            overhead 'Beneficial target found'
        elseif targetexists 'harmful'
            overhead 'Harmful target found'
        endif
        ```

## varexist

- `varexist`
- `varexists`

Description: Used to check if a variable exists.

!!! example

    === "General"

        ```razor
        if not varexist 'myrunebook'
            overhead 'Runebook variable not found -- select one'
            setvar 'myrunebook'
        endif

        dclick 'myrunebook'
        waitforgump 'any'
        gumpresponse 5
        ```

# Player Attribute Expressions

## diffhits

- `diffhits`
- `diffhp`

Description: Used to get the difference between you max hits and current hits.

!!! example

    === "General"

        ```razor
        if diffhits > 40
            overhead 'I need a heal!'
        endif
        ```

## diffmana

- `diffmana`

Description: Used to get the difference between you max mana and current mana.

!!! example

    === "General"

        ```razor
        if diffmana > 40
            skill 'Meditation'
        endif
        ```

## diffstam

- `diffstam`

Description: Used to get the difference between you max stamina and current stamina.

!!! example

    === "General"

        ```razor
         if diffstam > 30
            overhead 'Need stamina'
        endif
        ```

## diffweight

- `diffweight`

Description: Used to get the difference between you max weight and current weight.

!!! example

    === "General"

        ```razor
        if diffweight > 20
            overhead 'I can lift 20 more stone'
        endif
        ```

## followers

Description: Used to get the current number of followers.

!!! example

    === "General"

        ```razor
        if followers = 0
            overhead 'No one following me!'
        else
            overhead 'I have followers'
        endif
        ```

    === "..used with maxfollowers"

        ```razor
        if followers < maxfollowers
            overhead 'You can have more followers!'
        else
            overhead 'You hit your followers limit'
        endif
        ```

## findbuff

- `findbuff 'name of buff/debuff`

Description: Used to check if a specific buff/debuff is applied to you.

!!! example

    === "Check for magic reflection"

        ```razor
        if findbuff 'magic reflection'
            overhead 'Im set!'
        else
            cast 'magic reflection'
            wft
            target 'self'
        endif
        ```

## hidden

- `hidden`

Description: Used to check if you are hidden.

!!! example

    === "Check if hidden"

        ```razor
        if hidden
            overhead 'they cant see me'
        endif
        ```

## hp & maxhp

- `hp`
- `maxhp`
- `hits`
- `maxhits`

Description: Used to get your current or max hit points/health levels.

!!! example

    === "Example 1"

        ```razor
        while hp < 100
            say 'not at 100 yet'
            wait 5000
        endwhile
        ```

    === "Example 2"

        ```razor
        if maxhp = 120
            say 'Full hp!'
        endif
        ```

## lhandempty

- `lhandempty`

Description: Used to check if your left hand is empty

!!! example

    === "General"

        ```razor
        if lhandempty
            hotkey 'empty right hand!'
        endif
        ```

## invuln

- `invuln`
- `invul`
- `blessed`

Description: Used to get your invulnerable status

!!! example

    === "General"

        ```razor
        if invuln
            overhead 'I feel.. so powerful.'
        endif
        ```


## mana & maxmana

- `mana`
- `maxmana`

Description: Used to get your current or max mana levels.

!!! example

    === "General"

        ```razor
        while mana < maxmana
            skill 'meditation'
            wait 11000
        endwhile
        ```

## maxfollowers

Description: Used to get the maximum number of allowed followers.

!!! example

    === "General"

        ```razor
        if followers = maxfollowers
            overhead 'You hit your limit'       
        endif
        ```

    === "..used with followers"

        ```razor
        if followers < maxfollowers
            overhead 'You can have more followers!'
        else
            overhead 'You hit your followers limit'
        endif
        ```

## maxweight

- `maxweight`

Description: Used to get your max allowed weight.

!!! example

    === "General"

        ```razor
        if weight <= maxweight
            say 'I am overweight'
        endif
        ```

## mounted

- `mounted`

Description: Used to check if you are currently on a mount

!!! example

    === "General"

        ```razor
        if mounted
            say 'mounted'
        else
            say 'not mounted'
        endif
        ```

## name

- `name`

Description: Used to get your name of the currently logged in character

!!! example

    === "General"

        ```razor
        if name = 'Quick'
            overhead 'thats me!'
        endif
        ```

## paralyzed

- `paralyzed`

Description: Used to check if you are currently paralyzed.

!!! example

    === "General"

        ```razor
        if paralyzed
            overhead 'I cannot move!'
        endif
        ```

## poisoned

- `poisoned`

Description: Used to check if you are currently poisoned.

!!! example

    === "General"

        ```razor
        if poisoned
            hotkey 'drink cure'
        endif
        ```

## position

- `position (x, y)`
- `position (x, y, z)`

Description: Used to check if your current position matches the provided.

!!! example

    === "General"

        ```razor
        if position 2729 2133
            overhead 'You are currently in front of the Bucs Den teleporter'
        elseif position 2728 2133 5
            overhead 'You are standing on the Bucs Den teleporter'
        endif
        ```

## rhandempty

- `rhandempty`

Description: Used to check if your right hand is empty

!!! example

    === "General"

        ```razor
        if rhandempty
            hotkey 'empty right hand!'
        endif
        ```

## skill

- `skill ('name')`

Description: Used to get the current skill level for a given skill.

!!! tip "Supported skill names"
    Razor used to rely on a static list of names but now reads from your client's skills.mul file for the names of the skill.

!!! tip "Real vs Shown (or Value)"
    By default, Razor will compare against the shown skill value that includes other factors such as your stats. If you'd like to compare to the real skill value, use the `!` in front of `skill`.  See the example below.

!!! example

    === "Compare Shown Skill"

        ```razor
        if skill 'magery' < 62.5
            cast 'invisibility'
            waitfortarget
            target 'self'
        endif
        ```
    
    === "Compare Real Skill"

        ```razor
        // Note the ! at the end of the skill expression command
        // This tells Razor to look at the real value, not the shown value
        if skill! 'magery' < 62.5
            cast 'invisibility'
            waitfortarget
            target 'self'
        endif
        ```

## stam & maxstam

- `stam`
- `maxstam`

Description: Used to get your current stamina or max stamina.

!!! example

    === "General (stam)"

        ```razor
        if stam < 30
            say 'I need to rest'
        endif
        ```

    === "General (maxstam)"       

        ```razor
        if maxstam = 120
            say 'I feel so powerful!'
        endif
        ```

## str, dex & int

- `str`
- `dex`
- `int`

Description: Used to get your current strength, dexterity and intelligence.

!!! example

    === "Strength"

        ```razor
        if str = 100
            say 'Strength does not come from physical capacity. It comes from an indomitable will.'
        endif
        ```

    === "Dexterity"

        ```razor
        if dex = 100
            say 'Dexterity comes by experience and practice.'
        endif
        ```

    === "Intelligence"

        ```razor
        if str = 100
            say 'The true sign of intelligence is not knowledge but imagination.'
        endif
        ```

## warmode

- `warmode`

Description: Used to get your current combat/war status

!!! example

    === "General"

        ```razor
        if warmode
            overhead 'Lets fight'
        else
            overhead 'Peace to you'
        endif
        ```

## weight

- `weight`

Description: Used to get your current weight.

!!! example

    === "General"

        ```razor
        if weight = 300
            say 'I feel heavy'
        endif
        ```

# Timer Expressions

## timer

- `timer ('name')`

Description: Used to check how much time is left in an existing timer

!!! example

    === "General"

        ```razor
        // Create a new timer
        if not timerexists 'sample'
            createtimer 'sample'
        endif

        // Reset every 10 seconds
        if timer 'sample' > 10000
            settimer 'sample' 0
        endif
        ```

    === "Alert"

        ```razor
        # Create a new timer
        createtimer 'alert'

        while not dead            
    
            // Reset every 10 seconds
            if timer 'alert' > 10000
                overhead 'ALERT TRIGGERED!'
                settimer 'alert' 0
            endif

        endwhile

        
        ```

## timerexists

- `timerexist ('name')`

Description: Used to check if a timer exists

!!! example

    === "General"

        ```razor
        // Create a new timer
        if not timerexists 'sample'
            createtimer 'sample'
        endif

        // Reset every 10 seconds
        if timer 'sample' > 10000
            settimer 'sample' 0
        endif
        ```


================================================
FILE: help/docs/guide/index.md
================================================
---
description: A comprehensive guide to the UO Razor scripting engine, including descriptions & examples for all commands, expressions, keywords
---

# Introduction

The **UO Razor Scripting Engine** is a _"command based scripting language"_ designed to make it easier to read, create, edit and share UO Razor scripts.

To learn more about this version of Razor, please visit the [home page](https://www.razorce.com).

# Quick Start

Check out the various [Commands](commands.md), [Expressions](expressions.md), and [Keywords](keywords.md) that are available along with working examples.

# Design

This scripting engine attempts to maintain and improve existing Razor functionality, offer quality of life improvements over the existing macro system, and provide an easily approachable syntax that is accessible regardless of skill level.

For example, instead of having to do the following with a Razor macro:

1. Record macro
2. Double click dagger
3. Stop recording
4. Right-click on dagger
5. Select Double Click use by type

You can simply type:

```razor
dclicktype 'dagger'
```

# Razor Scripts vs. Razor Macros

While updates to Razor have made it easier to edit and share macros, one of the core issues is that they weren't designed to be read and edited by users directly, instead the serialized format they're saved in expects you to use the macro editor in Razor.

For example, even a basic macro that casts blade spirit, waits for the target and casts a relative location based on your position can be difficult to read to the untrained eye.

```razor
Assistant.Macros.MacroCastSpellAction|33
Assistant.Macros.WaitForTargetAction|30
Assistant.Macros.TargetRelLocAction|3|1
```

With a Razor script, it becomes:

```razor
cast 'blade spirits'
waitfortarget
targetrelloc 3 1
```

Another example using a script that uses detect hidden, waits for target, targets self, waits .40 seconds, checks for a system message, says something and targets the closest mobile.

```razor
Assistant.Macros.UseSkillAction|14
Assistant.Macros.WaitForTargetAction|30
Assistant.Macros.HotKeyAction|1059|
Assistant.Macros.PauseAction|00:00:00.4000000
Assistant.Macros.IfAction|4|0|you can see nothing
Assistant.Macros.ElseAction
Assistant.Macros.SpeechAction|0|38|3|ENU|2|16|52|I Ban Thee
Assistant.Macros.WaitForTargetAction|30
Assistant.Macros.HotKeyAction|2003|
Assistant.Macros.EndIfAction
```

With a UO Razor script, it becomes:

```razor
skill 'detecthidden'
waitfortarget
target 'self'

wait 400

if insysmsg 'you see nothing'
    overhead 'All clear'
else
    say 'I ban thee'
    waitfortarget
    target closest grey humanoid
endif
```

As you can see, while maintaining the same functionality of macros, a Razor script is much easier to read, edit and share.

!!! tip "Convert Macros to Scripts"
    **Right-Click** on any macro to convert it to a script.

# Script Editor

UO Razor scripts can be written using any text editor. The script editor built into Razor offers syntax highlighting and auto-completion.

!!! tip "Window Size"
    You can resize the Razor window to make the script editor larger. You can also adjust the size of the script list to give you additional room.

Here are a list of some of keyboard shortcuts available in the editor:

## General/Misc

Common text editor shortcuts (such as `Ctrl-C` and `Ctrl-V` for copy/paste are not listed):

- ++ctrl+g++: Goto to a specific line dialog

- ++ctrl+f++: Find/Search dialog
- ++f3++: Find next
- ++ctrl+h++: Search & replace dialog
- ++ctrl+shift+c++: Comment / Uncomment selected code
- ++alt+"Mouse Drag"++: Select multiple lines of text
- ++ctrl+home++: Go to the first line
- ++ctrl+end++: Go to the last line
- ++alt+up++: Move selected lines up
- ++alt+down++: Move selected lines down

## Bookmarks

- ++ctrl+b++: Bookmark line
- ++ctrl+shift+b++: Remove bookmark
- ++ctrl+b++: Move cursor to next bookmark
- ++ctrl+shift+n++: Move cursor to previous bookmark

## Auto-Complete

- ++ctrl+space++: Open auto-complete menu

## Zoom

- ++ctrl+"Mouse Wheel Up"++: Zoom in
- ++ctrl+"Mouse Wheel Down"++: Zoom out
- ++ctrl+0++: Reset zoom

# About

The **Razor Scripting Engine** was designed and implemented by [Quick](https://github.com/markdwags) and is released under GPLv3.

================================================
FILE: help/docs/guide/keywords.md
================================================
---
title: Script Keywords
description: A list of all script keywords for Razor, complete with descriptions and examples
---

# Keywords Overview

## and

Syntax: `(statement) and (statement)`

Description: The `and` keyword links statements together and if all statements are `true` the condition is met.

!!! example

    === "General"

        ```razor
        if insysmsg 'hello' and insysmsg 'bye'
            say 'found'
        endif
        ```

## as

Syntax: `(statement) as (variable)`

Description: The `as` keyword works in conjunction with the `findtype` expression.

!!! example

    === "General"

        ```razor
        if findtype 'dagger' as 'mydagger'
            overhead 'found dagger'
            dclick 'mydagger'
        endif
        ```

## break

Syntax: `break`

Description: The `break` keyword terminate the closest enclosing loop such as a `for` loop.

!!! example

    === "General"

        ```razor
        for 100
            if stam = 100
                break
            else
                say 'loop again'
            endif
        endfor
        ```

## continue

Syntax: `continue`

Description: The `continue` keyword passes control to the next iteration of the enclosing `for` or `while` loop which the keyword appears.

!!! example

    === "General"

        ```razor
        while stam < 100

            if stam = 50
               say 'At 50!'
               // Skip saying 'Not at 50'
               continue
            endif

            say 'Not at 50'

        endwhile
        ```

## in

Syntax: `(word) in (variable string)`

Description: The `in` keyword works in conjunction with the `getlabel` command.

!!! example

    === "General"

        ```razor hl_lines="4"
        
        if findtype '217' as 'a_dog'
            getlabel 'a_dog' 'dog_label'

            if 'Fido' in 'dog_label'
                overhead 'found mydog!' 5
                overhead 'dog_label' 67
            endif    
        endif
        ```


## loop/replay

Syntax: `loop` OR `replay`

Description: The `loop` or `replay` keyword will restart the currently run script back to the beginning indefinitely.

!!! example

    === "General"

        ```razor
        if mana = 100
            say 'all done!'
            stop
        else
            say 'still meditating'
        endif

        wait 1000

        loop
        ```

## not

Syntax: `not (statement)`

Description: They `not` keyword returns the opposite of the statement result.

!!! example

    === "General"

        ```razor
        if not 'dead'
            say 'I live!'
        endif

        if 'dead'
            say 'I died!'
        endif
        ```

        ```razor
        while not hp = 100
            overhead 'My HP isnt full'
        endwhile
        ```

## or

Syntax: `(statement) or (statement)`

Description: The `or` keyword links statements together and if one statements is `true` the condition is met.

!!! example

    === "General"

        ```razor
        if insysmsg 'hello' or insysmsg 'bye'
            say 'found'
        endif
        ```

## stop

Syntax: `stop`

Description: The `stop` keyword will stop the execution of the current script.

!!! example

    === "General"

        ```razor
        if stam = 100
            say 'all done!'
            stop
        else
            say 'still waiting'
        endif

        wait 1000

        loop
        ```


================================================
FILE: help/docs/guide/layers.md
================================================
---
title: Script Layers
description: A list of all script layers for Razor
---

# Layers Overview

If the command you're using requires a `layername` (such as `dropitem`) can use any of the following keywords (case insensitive):

- `RightHand`
- `LeftHand`
- `Shoes`
- `Pants`
- `Shirt`
- `Head`
- `Gloves`
- `Ring`
- `Talisman`
- `Neck`
- `Hair`
- `Waist`
- `InnerTorso`
- `Face`
- `Bracelet`
- `FacialHair`
- `MiddleTorso`
- `Earrings`
- `Arms`
- `Cloak`
- `Backpack`
- `OuterTorso`
- `OuterLegs`
- `InnerLegs`


================================================
FILE: help/docs/guide/variables.md
================================================
---
title: Script Variables
description: A list of all script variables for Razor with descriptions
---

# Variables Overview

Variables (also referred to as aliases) are commonly used values designed to be referenced in any of your scripts.

You can either define your own variables or you can use this list of pre-defined variables.

# Defining Variables

You can create custom variables that are available in your scripts.  This can be done one of two ways.  First, you can create custom variables in the Razor UI by going to the Options tab under the Scripts tab.

![variables](../images/scripts-options.png)

Simply click Add, give it a name and target the item or mobile and that variable is available in your scripts.  In the screenshot above, `regbag` is set to a bag.  To use this variable in a script, you simply reference it.

* Open your reg bag

```razor
dclick 'regbag'
```

You can also set variables in scripts by using the `setvar` command.  To update the `regbag` command, you might do something like this:

* Get target cursor to select item or mobile

```razor
setvar 'regbag'
```

The script will pause until you select a target. After you select a target, it will update and move on to the next line in the script.

# Pre-Defined Variables

Along with defining your own variables, you can use these pre-defined variables in your scripts.

| Variable          | Description                                                |
| ----------------- | ---------------------------------------------------------- |
| `backpack`          | `Returns:` The serial of your own backpack                 |
| `hands`             | `Returns:` The serial of the item in either hand           |
| `index`             | `Returns:` The index of the current loop iteration           |
| `lasttarget` / `last` | `Returns:` The serial of your current last target in Razor |
| `lastobject`        | `Returns:` The serial of your last used object in Razor    |
| `lefthand`          | `Returns:` The serial of the item in your left hand        |
| `righthand`         | `Returns:` The serial of the item in your right hand       |
| `self`              | `Returns:` The serial of your player                       |

## Index Variable

When using `for` or `while` you have access to the `index` variable. This can be used with `overhead` (for example) to indicate the current loop number.

For example, this script snippet will output the numbers 0-9 overhead every second.

```razor
for 10
    wait 1000
    overhead 'index'
endfor
```

```razor
for 10
    if index == 7
        overhead '7th loop'
    endif
endfor
```


================================================
FILE: help/docs/help/advanced.md
================================================
# Advanced

![advanced](../images/advanced.png)

This tab will show some data regarding Razor internals and give you access to some staff related functionality. The data on the left is purely for informational purposes only.

## Options

|Feature|Description|
|-------|-----------|
|Open Data Directory|Opens Windows Explorer to the folder containing your profiles and macros.|
|Enable packet logging|This feature will save all packets flowing between the UO client and server. Useful for debugging purposes but when enabled can slow down Razor and eventually cause a large file to be created if not disabled.|
|Negotiate features with server|This allows Razor to communicate with the server to enable/disable certain features in Razor. When this box is not checked, Razor will fail to respond to a negotiation packet and you will subsequently be disconnected from the server you are connected to.|
|Enable UOA API|This opens up a limited API that can be used by 3rd party applications (such as various mapping tools) to get some data from Razor.|

## Disable SmartCPU

SmartCPU has been completely removed from this version, but the option to disable it remains in place in case it was enabled in an older version.

## Backup

To create a backup, click the `Create Backup` button. This will copy all your profiles, macros and scripts to the `Backups` folder in the root of your Razor folder.

# Decoration

This tab gives shard staff an easy way to add new items in-game. You can manage the item list by editing `items.xml` in the Razor root path.

![advanced](../images/advanced-deco.png)

# Doors

This tab gives shard staff an easy way to add new doors in-game. You can manage the item list by editing `doors.xml` in the Razor root path.

![advanced](../images/advanced-doors.png)


================================================
FILE: help/docs/help/agents.md
================================================
# Agents

The Agents tab is for organizing, restocking and moving items.

![agents](../images/agents.png)

## Aliases

!!! tip "Aliases"

    You can right-click on an agent and assign it an aliases to help identify it easier.

    ![agent-aliases](../images/agent-aliases.gif)

## Use Once Agent

This agent lets you set item(s) in your backpack to be used via a hotkey.

Once the item is used, it is removed from the list. This is very useful for for trapped pouches. Add all your trapped pouches to the list and use them on the run. The list will remove each one as it's popped, and warn you when your list is empty.

* **Add (Target)**
    - Use this option to add items, one at a time.
* **Add Container (Target)**
    - Use this option to add the contents of an entire bag. Open the bag before targeting so Razor can 'see' the contents. This is the best option for adding multiple trapped pouches with the **Use Once Agent**. Keep them inside another bag and add the bag.
* **Remove (Target)**
    - Remove items from the list. This option gives a cursor target. Target the item to be removed.
* **Clear List**
    - Clears all items from the list.

## Sell Agent

Items on this list sell automatically to vendors when you begin a sale transaction (you must still be at the appropiate vendor). Choose how many to sell each time; a great tool for BOD collection.

The listing is done by item type, not item ID. If you have a magic longsword and a player-made longsword in your pack, adding longsword would result in both being sold. If you add plate armor to the list, the agent will attempt to sell all plate armor, colored or not, magic or not. The list can be disable without being cleared.

* **Add (Target)**
    - Click for a targeting cursor, target the item to add.
* **Remove**
    - Highlight an item in the list and click remove to delete it.
* **Set Hot Bag**
    - Razor will attempt to sell all items in a specified bag.
* **Clear**
    - Clear the list
* **Max Sell**
    - Select how many of each item to sell. Each item must be sold to the appropriate vendor. The vendor must have sufficient gold to buy the item. When you are selling you may note a discrepancy between the razor messages, gold received and the vendor replies. Razor will try to sell all items that can be sold to the vendor you are at, and the total it gives is for all those items combined. If the vendor cannot purchase all the items, the amount actually received will be less the the total stated by Razor. This does not mean you have been ripped off, only that the vendor couldn't buy everything. Continue on to the next vendor of the same type to continue selling.
* **(Push to Disable/Enable)**
    - Turn the sell agent on or off.

## Organizer Agent

This agent is used to move items from one container to another.

For example, if I purchase 20 mortar and pestle for my alchemist, I can easily bag them all without having to click and drag each one individually. If I click 20 potions from kegs and want them in my pvp supply bag, it can be done quickly without accidentally using one, without all the click and drag. There are 10 different organizers so there is room to set and keep frequently used lists. Hot keys will allow you to use the organizer and reset the target bag organized to.

* **Add (Target)**
    - Use this option to add items.
* **Set Hot Bag**
    - Set the hot bag to organize the items to. When it is already set, the tab changes to say 'Clear Hot Bag'. Both give a targeting cursor.
* **Organize Now**
    - Once everything is set, click this tab to activate the organizer.
* **Remove**
    - Highlight an item and click this tab to remove the item from the list.
* **Clear**
    - Clear the organizer; it can now be reset.
* **Stop Now**
    - Stops the organizer mid-process.

## Scavenger Agent

This agent is for automatically picking up items off the ground that are in range. Very useful, for example, during an IDOC.

* **Add (Target)**
    - Click for a targeting cursor, target the item to add.
* **Remove**
    - Highlight an item in the list and click remove to delete it.
* **Set Hot Bag**
    - Razor will put all items scavenged into this bag. If not bag is set, it will go into your main backpack.
* **Clear**
    - Clear the list.
* **Clear Scavenger Cache**
    - Razor will only try to pick up an item once, and move on. If Razor missed some items on the ground, click this button so it will try again.
* **(Push to Disable/Enable)**
    - Turn the scavenger agent on or off.

## Buy Agent

The buy agent is for setting lists of items to buy at vendors.

Used for purchasing large quantities or multiple items. Remember to check vendor prices each time Before enabling and using this agent. Use with caution, it is possible for the vendors to have items listed incorrectly. This will cause an erroneous purchase for you.

* **Add (Target)**
    - Target the item to be added to the list. A second gump (see below) prompts you to enter the amount to be purchased.
* **Edit**
    - Highlight any item in the list and click Edit to change the amount to purchase. A gump prompts you to enter the amount.
* **Remove**
    - Highlight any item and click Remove to delete it from the list.
* **Clear List**
    - Clear the entire list.
* **(Push to Disable/Enable)**
    - Use this tab to turn the agent off and on. Each buy agent can be set separately.

## Restock Agent

The Restock agent is used to drag items from a container to be placed inside your backpack.

Setting this up will enable you to restock your character at the click of a key. The restock agent will only stock up to the amount you indicate, not simply add the amounts to what you already have. For example, my restock agent is set to include 33 black pearl.

When I use the restock agent, it will top my black pearl up to 33; it won't add 33 more.

* **Add (Target)**
    - Target the item to be added to the list. A second gump (see below) prompts you to enter the amount to be purchased.
* **Remove**
    - Highlight any item and click Remove to delete it from the list.
* **Set Amount**
    - Highlight any item in the list and click Set Amount to change the restock amount. A gump prompts you to enter the amount:
* **Clear List**
    - Clear the entire list.
* **Clear Hot Bag**
    - Use this tab to set the hotbag to restock too. If no bag is indicated, Razor restocks to your main backpack.
* **Restock Now**
    - Activate the agent. You will receive a targeting cursor. Target the container to restock from. If you are at the bank, with your bank open, you can target your character to refill from the bank. This may also be set as a hotkey.

## IgnoreList Agent

Players added to this list will have all the say, yell, emote, etc blocked. Spell power words will still be seen.

* **Add (Target)**
    - Target the character to be added to the list.
* **Remove**
    - Highlight any name and click Remove to delete it from the list.
* **Remove (Target)**
    - Gives a targeting cursor. Target the player to remove from the list.
* **Clear List**
    - Clear the entire list.
* **(Push to Disable/Enable)**
    - Turn the Ignore list off and on.

================================================
FILE: help/docs/help/armdress.md
================================================
# Arm / Dress

The Arm/Dress tab is for setting clothes, armor and weapons for use. These settings are used with hotkeys.

![armdress](../images/armdress.png)

## Arm/Dress Selection

![armdresssel](../images/armdress-selection.png)

This is the list of arm/dresses can consist of a complete outfit or just one item. Hotkeys can be assigned to each. Use the **Add** and **Remove** buttons to manage.

* **Automatically move conflicting items**
    - Check this box so Razor can dress you properly. This allows items to be removed when neccesary. For example, you are equiped with a halberd and hit your hotkey to equip a war axe. With this box checked, Razor can un-equip the halberd to equip the war axe. This will apply to all lists and hotkeys.

## Arm/Dress Items

![armdress-item](../images/armdress-items.png)

This is where you define the items for each list created above. Highlight a list from the left and use the following tabs to set it up. Any entries can be right-clicked for conversion to 'Dress by Type'.

>> ***Note:** 'Dress by type' will tell Razor to look for any item of that type to use, not only the specific item used to set the list. This is most useful for weapons.*

* **Dress**
    - Highlight a list from the left and click this tab to dress in the items from that list.
* **Undress**
    - Highlight a list from the left and click this tab to undress the items from that list.
* **Add (Target)**
    - Click this tab to add items to a list. You will get a targeting cursor to target the item to be added.
* **Add Current**
    - Adds everything currently being worn to the highlighted list.
* **Remove**
    - Highlight an item and click 'Remove' to delete an item from the list.
* **Clear List**
    - Clear the current list.
* **Change Undress Bag**
    - Gives a targeting cursor. Target the bag you want to undress to.

================================================
FILE: help/docs/help/displaycounters.md
================================================
# Display/Counters

![displayscounters](../images/displayscounters.png)

## Display

### Title Bar Display

!!! note
    If you are using ClassicUO, images will not display in the title bar. It's recommended to use the built-in counter bar.

![titlebar](../images/titlebar.png)

This feature will display the values of your counters and other information in the title bar of the Ultima Online client. Along with the **Format** of the counter wrapped in `{}`, Razor has the following values built in. Check **Show in UO title bar** to enable.

- `{ar}` - Total Armor Rating
- `{char}` - This will display your character's name
- `{crimtime}` - When you become a criminal, this timer will count up until you are not longer one
- `{buffsdebuffs}` - The buffs/debuffs currently applied to your character
- `{damage}` - Display your min and max damage
- `{dex}` - Your current dex
- `{followersmax}` - The max number of followers allowed by your character
- `{followers}` - The current number of followers assigned to your character
- `{gold}` - Total amount of gold in your backpack
- `{gate}` - When you cast Gate, a timer will display for the 30 seconds the gate is up
- `{hpmax}` - Your max hit points
- `{hp}` - Your current hit points
- `{int}` - Your current intelligence level
- `{largestatbar}` - Display a large status bar
- `{manamax}` - Your max mana points
- `{mana}` - Your current mana level
- `{maxweight}` - The max number of stones you can carry
- `{mediumstatbar}` - Display a medium status bar
- `{shard}` - The name of the Shard you're playing on
- `{skill}` - When you use a skill from an assigned Razor hotkey, it will start a counter
- `{stammax}` - Your max stamina
- `{stam}` - Your current stamina
- `{statbar}` - Display a small status bar
- `{stealthsteps}` - The current number of steps taken since you stealthed
- `{str}` - Your current strength
- `{uptime}` - The length of time you've been connected
- `{weight}` - Your current weight in stones

Values that work on AOS+ servers.

- `{coldresist}`
- `{energyresist}`
- `{fireresist}`
- `{luck}`
- `{physresist}`
- `{poisonresist}`
- `{tithe}`

Here is a default title bar to built yours off of:

`{char} - {crimtime} {weight}/{maxweight} - ~#FF0000 {hp}/{hpmax} ~#~ - ~#FE2EF7 {stam}/{stammax}~#~ - ~#0080FF {mana}/{manamax} ~#~ {bp} {bm} {gl} {gs} {mr} {ns} {ss} {sa} Gold: {gold}`

#### Color

You can color the title bar text using any HTML style 6 digit hex number.  Use the code in the following manner:

HTML hex color code: `~#rrggbb` ('`~#~`' to terminate)

For the purpose of example, I want to change the color of my hp display to orange. I would use the following code to do so: `~#FF6600 {hp}/{hpmax} ~#~`. The '`~#FF6600`' tells Razor to color everything between it and the '`~#~`' to an orange color, the color orange selected by the six digits, FF6600. The '`~#~`' tells Razor to stop coloring. If you need to know the color codes for this function, try this page.

### Track gold per sec/min/hour

When using **Track Gold Per sec/min/hour** these values will work:

- `{goldtotal}` - The amount of gold collected since you checked the **Track gold per sec/min/hour** box
- `{goldtotalmin}` - The amount of time that has gone by since you started tracking your gold intake
- `{gpm}` - Display your gold per minute
- `{gps}` - Display your gold per second
- `{gph}` - Display your gold per hour

### Other

* **Highlight Spell Reagents on Cast**
    - Whenever you cast a spell, a red background will highlight the reagents used to cast the spell.
* **Show noto hue on {char} in TitleBar**
    - When enabled, the name of your character on the Title bar will show in the same color as it will when you are clicked in the game.
* **Enable gold per sec/min/hour trackers**
    - When checked, the counter will start monitoring your gold intake using the values above.

## Counters

![counters](../images/counters.png)

Counters are used to track the number of items you currently have in your backpack. The most commonly used counter is for reagents but this feature can be used on any item. Razor will come with some common counters available to you by default.

#### Adding a counter

  - Click **Add...** under the list of counters.
  - Click **Target** and target the item to add. The Item ID and color fields should auto-populate for you.
  - The **Name** (of the item) is the name as you see it when you click the item.
  - The **Format** is the letter code you want to use. For example, the default for black pearl is `bp`.
  - Click **OK** once all fields are entered.
  - If you want this counter to display in the titlebar, check **Display image in title bar**. For example when used with black pearl, the title bar displays a small black pearl beside the count rather than the abbrev `bp`.

To **Edit or Remove** a counter, select it and click **Del/Edit**.

Click **Recount** to force Razor to check all the containers on your character and get the correct acounts.

### Others
* **Show Images with Counters**
    - Check this to show counter images instead of abbreviations. Each counter can be modified individually from the counter table with the edit tab to disable this.
* **Warn when a counter is below X**
    - When your counter for any specific item drops below **X**, Razor will provide a warning in red.

## Bandage Timer

![bandagetimer](../images/bandagetimer.png)

* **Show bandage timer**
    - When you have this enabled, when you use a bandage a timer will display.

## Overhead Messages

![overhead](../images/overhead.png)

Check `Enabled` to turn on the overhead messages feature.

This option will display messages above your head that are triggered based on system messages in the lower-left that come in from the server. For example, when the message `You begin applying bandages.` comes through, you can have the message `[Applying bandages]` appear above your head.

!!! tip "Expand Overhead Messages"
    You can extract specific words from the system message to display in the overhead messages (`{1}` for the first word, `{2}` for the second word, etc).
    If the system message is `You must wait 80 seconds!`, you can set the overhead message to `Wait {4}s` and it would display `Wait 80s` overhead.

| Option | Description |
| ------ | ----------- |
| Format | Set the format of the overhead message. It must contain `{msg}` for your custom message to appear. Default is `[{msg}]`.|
| Message Style | Set the message style to appear overhead depending on your preference. Default is `Unicode`. |

### Create Overhead Message

* Enter part of the message or the whole message into the `Search Text` field.
* (Optional) If you need help finding the message, click `Search` and select the message you want to capture.

!!! tip
    If your message is custom to your shard and not on the search list, simply click `Add` to capture it. It doesn't need to be a static message in the client files.

* Click `Add` and enter the message you want to appear overhead and click `OK`.
* Your overhead message capture will appear at the bottom of the list.

### Demo

![overheaddemo](../images/overheaddemo.gif)

## Waypoints

![waypoints](../images/waypoints.png)

This feature lets you set waypoints, that will display within the client.

* **Show waypoint messages overhead**
    - Direct waypoint messages from system message to overhead.
* **Show tile distance every X**
    - If checked, it will show the current distance every X seconds.
* **Hide waypoint within**
    - When you're within X tiles, hide/clear the waypoint.
* **Create waypoint on death**
    - Upon death, create a waypoint.

### Create Waypoint

* Enter the name for the waypoint in the `Name` field.
* Either manually enter the X and Y coordinates or click `Use Current Position` to auto-fill.
* Click `Add Waypoint`

!!! tip
    Double-click a waypoint in the UI to activate it in game. You can also assign hotkeys to cycle between waypoints.

================================================
FILE: help/docs/help/filters.md
================================================
# Filters

## General

![filters](../images/filters.png)

Filters will change the way the client will display visuals or play audio.

* **Sound Filters**
    * Allow you to block the client from playing certain sounds.
* **Light Filter**
    * Force the client to always display 100% light levels
* **Death Filter**
    * Prevent the "You are dead" animation from playing
* **Filter dragons**
    * Override the dragon graphic and replace it with something else.
* **Filter drakes**
    * Override the drake graphic and replace it with something else.
* **Filter daemons**
    * Override the daemon graphic and replace it with something else.

## Text & Messages

* **Text Filter**

Enable the text filter to block all text from any mobile.

* **Filter Messages**

Instead of spamming your screen system or overhead messages, if checked it will keep filtering messages as long as you have the filter delay. When those seconds pass, it will show you the message.

* Filter snooping messages
* Filter repeating system messages
* Filter repeating Razor messages
* Filter repeating overhead messages
* Filter Delay

## Target Filter

![targetfilters](../images/targetfilters.png)

Mobiles on this list will be ignored completely by Razor.

!!! tip
    This feature is intended to be used to add NPCs that might be picked up during events that take place in towns or where NPCs are.

## Sound & Music

![sound](../images/soundmusic.png)

* Enable Sound Filter
    - When checked, sounds that are checked will be blocked from playing in the client.
* Play Selected Sound
    - Listen to the selected sound. If you check `Play in client` the sound will play in the client if logged in.
* Show filtered sound info
    - If a sound is blocked, show the name in system messages.
* Show non-filtered sound info
    - If a sound plays, show the name in system messages.
* Play Music In Client
    - Plays the specific song in the client if logged in.

================================================
FILE: help/docs/help/friends.md
================================================
# Friends

![friends](../images/friends.png)

## Friend Groups & Lists

Razor allows you to manage groups of friends to prevent you from targeting those on the list.

|Feature|Description|
|-------|-----------|
|Treat part members as 'Friends'|If enabled, anyone in your party is considered a friend regardless if they are in a friends group.|
|Show [Party-Friend] overhead|Shows a message overhead on party members who are friends.|
|Next/Prev Target ignores 'Friends'|Ignore friends when using Next/Prev targeting unless you specifically use the `Next/Prev Friend` hotkey.|
|Auto-accept party invites from friends|If a friend sends you a party invite, it will auto accept it.|
|Next/Prev highlights 'Friends'|Your friends will be highlighted when using Next/Prev|


================================================
FILE: help/docs/help/general.md
================================================
# General Settings

The General tab has setting largely related to the client itself and Razor in general.

![general](../images/general.png)

## General

### Profiles

Each character has a profile that contains your settings, such as the options in Razor and your hotkeys.

!!! tip "Profile Location"
        Profiles are stored in the same location as `Razor.exe` under `.\Profiles\`. You can create a new profile, which will be based on the *default profile settings* (`default.xml`)

!!! tip "Multiple Profiles"
    It's **highly recommend** that have you have 1 profile per character. If you use the same profile among multiple characters while logged in, you could potentially lose changes to your profile. It's doable, but requires an extra bit a caution to ensure you keep all your profiles synced up.

|Feature|Description|
|----|----|
|New|Create a new profile based off of the default Razor profile.|
|Save|Save all the current Razor settings without having to log out.|
|Clone|Clone the existing selected profile and create a new one.|
|Delete|Delete the selected profile.|

#### Creating a new profile

Clicking **New** will generate a new profile based on the default profile that comes with Razor. If you rather create a new profile using an existing profile, select that profile first and click the **Clone** button.

#### Saving your profiles

Razor will save your profile two ways.

* When you open your paperdoll in UO, click **Logout** and click **OK**.
    * This triggers the client to tell Razor that you logged off, which performs the profile save.
* Click the **Save** button manually to ensure your changes are saved.

### Maps / Boat

#### UOPS

![uops](../images/map-uops.png)

Razor's Ultima Online Position System (UOPS) gives you a basic map.

#### Boat Control

![boat](../images/map-boat.png)

**Boat Control** was inspired by UO Rudder and designed to make navigating the seas of Britannia much easier. This tool is built into Razor.

!!! tip
    Right-clicking on 1 of the 4 directions will set relative location.

### Other

|Feature|Description|
|-|-|
|Show Welcome Screen (Global Setting)|When checked, opening Razor will give you the **Welcome Screen**. This is where you can enter new servers, change your client location, etc.|
|Use Smart Always on Top|Razor will stay on top of the UO window when it becomes active and hide when it becomes inactive.|
|Show in Taskbar or System Tray|You can have Razor in the Taskbar or the System Tray. It's all up to you.|
|Default Client Priority| This changes the priority given to the process. Honestly, leave it at **Normal**. This feature should be removed. It's old.|
|Opacity|Adjust the transparency of Razor. Useful on a single monitor.|
|Language|The `.\Language\` folder contains all the translations. Some are missing, feel free to translate based on the `.enu` file located in the package.|


================================================
FILE: help/docs/help/hotkeys.md
================================================
# Hot Keys

![displayscounters](../images/hotkeys.png)

Hot keys tie your keyboard and mouse to specific actions within Ultima Online, or to specific functions within Razor.

## Filter Box

As you type in this box, the list will be narrowed down helping you find a specific hotkey.

## Hot Key Setup

- **Ctrl - Alt - Shift - Key**
    - Located on the right, these are used to select the key. Once you have highlighted the hotkey to be set from the left index, click in the key field and type the key to be used for that setting. If you want to use a key with control, shift or alt keys, check them as well.
- **Unset/Set**
    - Once you select the key, click Set. If this key combination has already been used by another setting in Razor, a warning is given. If the set is successful, the hotkey will appear beside the entry in the index. Click Unset to remove the key combination.
- **Command**
    - You can define a custom command (accessed via `>command`) here that will execute this hotkey wouldn't hitting the key combination.
- **Pass to UO**
    - When you set a hotkey, it becomes a key combination for Razor. Check this box to have hotkeys continue on to the client. If you do not check this box, Razor will read the command and it will go no further.
- **Execute Selected**
    - Useful for using commands from the hotkey list without setting a key. For rarely used actions or testing.

## Hot Key Categories

Hot keys are broken up into several categories.

- **Agents**
    - Hot keys related to using your agents
- **Dress**
    - Hot keys related to arming/disarming yourself and executing one of the **Arm/Dress** selections.
- **Friends**
    - Hot keys related to adding friends, enabling and disabling friend groups.
- **Items**
    - Hot keys related to using bandages, potions and items in your hand.
- **Macros**
    - Hot keys that will run **Macros** you've created.
- **Misc**
    - Hot keys that don't fall under any specific category. Notable section is **Special Moves** for Stun or Disarm.
- **Scripts**
    - Hot keys related to running scripts.
- **Skills**
    - Hot keys related to executing your skills.
- **Spells**
    - Hot keys related to casting your spells.
- **Targets**
    - Hot keys related to selecting targets.

## Notoriety & Target Definitions

| Type       | Notoriety Color         |
| ---------- | ----------------------- |
| Innocent   | Blue                    |
| Guild/Ally | Green                   |
| Attackable | Gray (but not criminal) |
| Criminal   | Gray                    |
| Enemy      | Orange                  |
| Murderer   | Red                     |

| Target       | Type                                  |
| ------------ | ------------------------------------- |
| Non-Friendly | Attackable, Criminal, Enemy, Murderer |
| Friendly     | Innocent, Guild/Ally                  |
| Enemy        | Enemy                                 |
| Red          | Murderer                              |
| Grey         | Attackable, Criminal                  |
| Criminal     | Criminal                              |
| Innocent     | Innocent                              |


================================================
FILE: help/docs/help/index.md
================================================
---
description: A comprehensive guide to all the features found in Razor
---

# Help with Razor

This guide is broken down based on the different tabs found in Razor.

* [General](general.md)
* [Options](options.md)
* [Display/Counters](displaycounters.md)
* [Arm/Dress](armdress.md)
* [Skills](skills.md)
* [Agents](agents.md)
* [Filters](filters.md)
* [Hot Keys](hotkeys.md)
* [Macros](macros.md)
* [Scripts](scripts.md)
* [Friends](friends.md)
* [Screen Shots](screenshots.md)
* [Advanced](advanced.md)

If you're unable to find a solution using the information here or you'd like to submit a feature request or bug report, use the following resources.

* Submit a bug/issue on the [official Razor GitHub Repo](https://github.com/markdwags/Razor/issues).
* Join us in **#razor** on Discord

[![Chat on Discord status](https://img.shields.io/discord/458277173208547350.svg?logo=discord)](https://discord.gg/VdyCpjQ)

For more information about the Razor Scripting Engine, go [here](https://www.razorce.com/guide/).


================================================
FILE: help/docs/help/macros.md
================================================
# Macros

Macros allow you to run a set of recorded actions. Macros can be used to macro skills or perform other actions even while AFK or while playing another character. Macros can be used for gathering resources and crafting.

Macros are divided into two sections. The column on the left is the macro index of all macros you make. On the right is the action area, used to set and edit the macros you create. Macros are saved to a folder, 'Macros', in your Razor folder. These can be edited in text format.

![macros](../images/macros.png)

## Macros

### Categories

Categories can be created to organize your macros into groups. While, unlike the rest of the profile, macros are shared across all characters. Each character can have their own hot key settings depending on how frequent that character would use the macro (if at all).

**Right click the left column for the following options:**

* **Add Category**
    - Add a category to place macros in. A gump will prompt you to enter a name.
* **Delete Category**
    - Highlight a category and click delete to remove it. Macros inside the category will need to be removed first.
* **Move to Category**
    - Move macros to the category you choose.
* **Refresh Macro List**
    - Update changes made to the list.

## Creating a macro

To Create a Macro, begin by clicking the 'New' tab at the bottom of the gump. A second gump prompts you to enter the name of the macro; click 'OK'.

The macro will now appear in the left index. Highlight the macro name with a left click. A list of functions to set the macro will now show beside the right action window. Right click the macro name to move it into a category if you choose.

### Set/Recording a macro

To Set/Record a Macro, highlight the macro in the left index. Click the 'Record' tab on the right and go through the actions in-game that you want in the macro. When you have finished, click the 'Stop' tab. Once the macro is created, the 'Stop' tab will change to a 'Play' tab when the macro is not running. To clear the macro entirely for re-recording, click the Record tab again. A prompt warns your original macro will be cleared.

You now have the basis of a macro. From here, you can fine tune it with a list of options found with a right-click.

* **Reload**
    * Update Razor folder changes without closing Razor. This option will applies to the entire Razor folder, not specific macros. If you have edited a macro in text format, or added a a pre-made macro to the folder that isn't showing up, use this option.
* **Save**
    * Saves changes made to Razor in the text file without closing the program.
* **Move Up/Down**
    * Highlight a line and move it up or down with these two commands. Useful for changing text placement, misplaced commands, and more. **Tip:** If you hold down `CTRL-ALT` and use the `UP` and `DOWN` keys.
* **Remove Action**
    * Highlight a line and click this option to delete the action from the macro. This cannot be recovered except by re-recording the action.
* **Begin Recording Here**
    * Use this option to add actions you have missed. Razor will begin recording in the current macro. The action(s) will appear after the line highlighted.
* **Play from Here**
    * Play the macro from the line indicated. Useful for checking macros as you set them.
* **Special Constructs**    
    * **Pause/Wait**
        * This option gives a second gump of choices. A pause can be entered based on a specific amount of time. Waits can be added for gumps, targets, and old-style menus. Waits can also be added based on hitpoints, mana, or dexterity reaching a specified amount.
        For example: Wait for Mana <= 90
    * **Set Last Target**
        * Gives a cursor to set a new last target.
    * **Comment**
        * Does not actually appear in the macro. This is for user notes and comments.
    * **"If" Conditional**
        * Set a command depending on circumstances - If mana is <= ; If black pearl =>
    * **"Else"**
        * You can continue the "if" conditional by adding 'else'. For example: 
        * If black pearl is <= 32
        * Use restock agent 5
        * Else If black pearl is => 33
        * Use organizer agent 5
        * End if
        * This would tell razor to restock with restock agent 5 if black pearl if it is equal to or less than 32, use organizer agent 5 if black pearl is equal to or greater than 33.
    * **"End If"**
        * Use this line to end your 'if' commands. This tells Razor this part of the macro is complete.
    * **"For Loop"**
        * A command to loop (repeat) all actions following. A gump appears with this option, enter the number of times to repeat.
    * **"End For"**
        * Use this when actions to be looped have ended. This line tells razor the "for Loop" part of the macro has ended.

## Options

This version of Razor has an expanded section with additional macro options

![macros-advanced](../images/macros-options.png)

#### Absolute Target Variables

The concept with **Absolute Target Variables** is to remove duplicate macros for the same thing. For example, you have a Recall macro that casts recall, waits for target, and clicks a rune or runebook. If you have 5 characters doing the same thing, you need 5 macros because the unique ID of the rune or runebook is different.

With **Absolute Target Variables** in that same scenario, you can have one macro cover all 5 characters. Your macro and absolute target variable might look like this:


![macros-advanced1](../images/macros-advanced-at1.png) ![macros-advanced](../images/macros-advanced-at.png)

As long as you have setup a `$rune` variable on your profile, that macro will work across all profiles.

* **Add**
    * This will give you a target in game to select the item to create a variable based on
* **Insert**
    * This will insert the currently selected variable into the selected macro.
* **Retarget**
    * If you need to update the variable to a new item, use this.
* **Remove**
    * Remove the selected variable from the list.

### Options

* **Force different 'TargetByType'**
    * Prevents a macro from selecting the same item over and over (for example, the item is out of range)
* **Range check on 'TargetByType'**
    * Macros will only target items by type that are in range of your character. This is to prevent a macro from trying to target an item out of range.
* **Range check on 'DoubleClickType'**
    * Same idea here. Macros will only double-click items in range of your character.
* **Step Through Macro**
    * If checked, each step in the macro will require you to click `Next`. Useful for debugging your macros.

* **Default macro action delay (50ms)**
    - The OSI client required a 50ms delay, which isn't required by ClassicUO. Some macros were designed with ths 50ms delay in mind. Checking this and restarting Razor will restore it. 
* **Disable Playing/Finished Message**
    - Hide the message that shows when you run a macro.


================================================
FILE: help/docs/help/options.md
================================================
# Options

## Speech & Messages

![options](../images/options.png)

* **Search Exemption Hue**
    - Used in conjunction with the **AutoSearchExemption** feature on the agents tab. Containers and/or container types added to this agent will appear the *Search Exemption Hue* while in your backpack. Click the set tab to the right to change the color.

!!! note
    The color of the item does not actually change. When removed from your backpack it will return to the original color.

* **Razor Message Hue**
    - Razor messages sent to your client will be this color. Click the set tab to change the color.
* **Warning Message Hue**
    - Razor messages sent to your client specifically to warn you of something, like low reagents, will be this color. Click the set tab to change the color.
* **Override Speech Hue**
    - Check this box to force all speech on your screen to be one color. Click the set tab to select the color.
* **Last Target Highlight**
    - When checked, the last target will highlight the selected color. Click the set tab to select the highlight hue.
* **Override Spell Hues**
    - Like speech, checking this box allows you to select the color for spell text, both words of power or spell names. Colors may be selected for beneficial, harmful, and neutral spells.
* **Override Spell Format**
    - If checked, Razor will transform spell power words into the actual spell name.
* **Spell Format**
    - This field determines how you view spells being cast.
        - `{power}` will show words of power on your screen. These are the actual spell words.
        - `{name}` or `{spell}` will show the spell name.
        - `{circle}` will show the circle of the spell.
* **Show buff/debuff overhead**
    - Check this option if you want to see when a buff/debuff has been added/removed from your character (ie: `[+Magic Reflection]` or `[+Reactive Armor]`).
    - **Default Buff/Debuff Format** `[{action}{name}]`
        - `{action}` will be a `+` or `-` symbol indicating if it was added or removed.
        - `{name}` will be the official name of the buff/debuff.
* **Filter Snooping Messages**
    - Filters out the messages when someone nearby is snooping that can be seen as spam.
* **Show Incoming People/Creatures**
    - This will show the names of players and creatures as they enter your screen.
    
!!! note
    This option exist within the UO client itself. It's recommend to disable the one in the UO Client or in Razor or it will produce duplicated names when new players or creatures enter the screen.*

* **Show New/Incoming Corpses**
    - As above, but with corpses.

* **Show container labels**
    - This option will allow you to tag containers and give them a label. This should allow for easier pixel sorting.
    - **Default Format** `[{label}] ({name})`
* **Show health above people/creatures**
    - Check this option to show changes in player's health with a text percentage over their heads. The numbers will show in blue - green at 100%, to yellow at 50%, to purple - red at 0%.
    - **Default Health Format** - `[{0%}]` or `[NN%]`
* **Show mana/stam above party members**
    - As above, but mana and stamina.
* **Show damage dealt**
    - Display the damage you've dealt in the lower-left or overhead.
* **Show damage taken**
    - Display the damage you're taking in the lower-left or overhead.

## Targeting & Queues

![options-targets](../images/options-targetqueues.png)

* **Queue LastTarget and TargetSelf**
    - This is used with **Last Target** and/or **Target Self** hotkeys. When this option is selected, `Last Target` and `Target Self` commands will be placed in queue until they can be executed. For example, you cast a spell and hit the `Last Target Hotkey` too soon. The moment the target is up, the last target function will be executed. A hotkey can be set to clear the queue when needed.
* **Show Action-Queue status messages**
    - A toggle to turn off/on messages about actions being queued. Unchecking this option will still allow some important messages to come through.
* **Auto-Queue Object Delay actions**
    - When checked, Razor will automatically queue up your double-clicks. It will prevents the message "You must wait to perform another action". This is an important setting for a well-run macro. The object delay field below should reflect your specific connection. Set the object delay at your average ping to the server + 500 (approx)
* **Object Delay**
    - Sets the number of milliseconds between actions. Unchecking the box will set it to 0.
* **Show Target Self/Last/Clear Overhead**
    - When checked, the messages for `[Target Self]`, `[Last Target]` and `[Clear Target Queue]` will display overhead instead of in the lower-left corner.
* **Range check Last Target: *X* tiles**
    - This option will have Razor check that last target is within range. If it's not, Razor sends a warning message and your target is not cancelled out. Last Target can be selected to try again without having to bring the cursor up a second time.  Select the number of tiles, within game allowances.
* **Show target flag on single click**
    - Select to display a text flag over last targets; to be used with Smart Target option. Flags show as `[Current Target]`, `[Beneficial Target]`, or `[Harmful Target]`.

!!! tip
    To edit this format, go into your profile and search for `PartyStatFmt`. `[{0}% / {1}%]` is the standard format.*

* **Attack/target name overhead**
    - When you attack a target, or aquire a new target using a hotkey, it will display the name of your target above your head.
* **Show text target indicator**
    - When checked, a simple text indicator above the target's head will appear

### Smart Targeting

Smart Targeting enables Razor to use beneficial or harmful spells according to your previous actions.

For example, in battle if you cast Energy Bolt (a harmful spell) at an enemy and Greater Heal (a beneficial spell) at a friend, Razor will remember the last targets for each spell type. The next time you cast a harmful spell with `Last Target`, Razor will target the enemy even if you just casted Greater Heal on your friend with last target without requiring you to set a new target.

!!! tip "Smart Targeting Hot Keys"
    You can set your `Harmful` and `Beneficial` target manually by using `Set Last Target (Beneficial)` or `Set Last Target (Harmful)`.
 
* **Use smart last target**
    - Enables smart targeting
* **'Next/Prev Friend' sets beneficial only**
    - Using Next/Prev Friend will only set the beneficial target (this option works in conjunction with the [Friends tab](friends.md))
* **'Next/Prev Friendly' sets beneficial only**
    - Using Next/Prev Friendly will only set the beneficial target.
* **'Next/Prev Non-Friendly' harmful only**
    - Using Next/Prev Friendly will only set the harmful target.

## Additional Options

![options-additional](../images/options-additional.png)

* **Use Pre-AOS status window**
    - The default status window is from the AOS expansion. If you check this box, it will look like the Pre-AOS window.
    
!!! tip
    You will need to close, then re-open your status bar in-game for the change to take effect.*

* **Auto-Stack Ore/Fish/Logs at Feet**
    - When checked, when these items are placed into your bag, they will stack at your feet instead. Useful for gathering resources.
* **Open new corpses within *X* tiles**
    - This option automatically opens new corpses within the selected number of tiles.

!!! tip
    Use with caution, this function does not differentiate between a blue, grey, or red corpse.

* **Block opening corpses twice**
    - Used with the above option, if checked a corpse that was auto-opened will not auto-open again. Manually opening a corpse does not prevent it from auto-opening.
* **Block Dismount in War Mode**
    - Double-clicking yourself will dismount from any ride you may be on. This selection will cause Razor to block dismount while you are in war mode, preventing accidental dismount.
* **Block trade requests**
    - When checked, any trade request initiated by another person will be auto-blocked.
* **Block party invites**
    - When checked, this will block all party invites automatically.
* **Season**
    - Set the season in the client.
* **Light**
    - Adjust the slider to set the **Light Level** on the client. To keep this setting, be sure **Light Filter** is checked on the **General** tab.
* **Enable Min/Max**
    - This feature lets you set the min and max light levels that Razor will allow.
* **Remember passwords**
    - Using this option will save your passwords in your Profile.xml file. When logging in the saved password will be entered for you although the field will remain blank on your screen.
    
!!! warning
    Anyone who obtains a copy of your profile maybe be able to decrypt your password and log into your account.

* **Count stealth steps**
    - Keeps track of steps taken while hidden, displaying the number on the bottom left of your screen unless you check **Overhead** and they will display over your character.
* **Automatically open doors**
    - This option will auto-opens a door every time you walk up to, or turn to face, the door.
* **Auto Unequip hands before casting**
    - Removes weapons from your hands automatically when you cast a spell, delaying the spell until it can be cast.
* **Auto Un/Re-equip hands for potions**
    - The same as above but for using potions. Once the potion is used, the item is returned to your hand.
* **Block heal if target is poisoned**
    - This prevents the cast of a wasted heal on a poisoned target.
* **Force Game Size**
    - Set your game window to the size you want. Once you have entered the size, it needs to be applied. Open options in-game (ALT+O or use the tab from the paperdoll) and click **Apply**. The game window size will be applied and remembered.
* **Static magic fields/walls**
    - This option will replace the field spells with static colored tiles. Checking labels will also show the name of the field.


================================================
FILE: help/docs/help/screenshots.md
================================================
# Screen Shots

![ss](../images/screenshots.png)

A self-explanatory section used to take and manage your in-game screenshots.  Set the path, file type, window size, delay from here.

================================================
FILE: help/docs/help/scripts.md
================================================
# Scripts

The Razor Scripting Engine is a "command based scripting language" designed to make it easier to read, create, edit and share Razor scripts.

For a comprehensive guide on how to use it, please go [here](https://www.razorce.com/guide/).

![scripts](../images/scripts.png)


================================================
FILE: help/docs/help/skills.md
================================================
# Skills

The Skills tab gives you general information about your skills.

![skills](../images/skills.png)

## Skill Table

* **Skill Name**
    - This will list every skill in the game.
* **Value**
    - This is your skill level before stat modifiers are applied.
* **Base**
    - Your skill level with stat modifiers applied. Also known as the **'Show Real'** skill level. Use these numbers when calculating skill caps.
* **+/-**
    - This column shows any change in skill level since you logged in, or used the reset button.
* **Cap**
    - The skill cap for each skill.
* **Lock**
    - The lock setting for each skill. `'D'` for down, `'U'` for up, and `'L'` for a locked skill.

## Other

* **Reset +/-**
    - Resets all +/- column entries in the skill table to 0.0
* **Set all locks**
    - Set the locks for all skills according to your selection from the drop-down tab.
* **Copy Selected**
    - Copies the skill information from the selected skills to the clipboard. Click a skill to highlight it. For multiple skill selection, hold the control key and click all skills to be copied.
* **Copy All**
    - As above, all skills are automatically selected with this tab.
* **Log skill changes**
    - All your skill changes will be logged and timestamp into a `.csv` file in your Razor folder.
* **Show skill/stat changes**
    - When checked, Razor will inform you of each skill level change, the change amount and the total change since the last +/- reset.
* **Capture MIBs to file**
    - When you open an MIB, a file is written to the root folder of Razor.

!!! warning
    This feature only works with the default RunUO MIB Gump.

* **Base Total**
    - Displays your character's total base skill level.

================================================
FILE: help/docs/history.md
================================================
# History

![oldsplash](images/old-splash.jpg){ align=right }

Razor was originally designed by Bryan Pass, known as `Zippy` in the RunUO community as a replacement to UOAssist. Based on commit notes, active development (new features, bug fixes) on Razor ceased some time in the early 2010's with the source code being released in 2014.

The code initially didn't include `Crypt.dll` and `Loader.dll` which are required to fully integrate with the UO client. At some point, the code for those projects released into the same GitHub repo (at the time of this edit, `https://github.com/msturgill/razor` no longer is available).

The original project was last updated May 2nd, 2014 which was simply an update from .NET 2.0 to .NET 4.0 and while over 50 forks exist on GitHub, none of them have been active or have made significant changes except for a few exceptions:

* `Jaedan` (which this version is based on) who updated the original Razor project to compile and work in Visual Studio 2017 and made improvements to `Crypt.dll` that enabled this project to move forward.
* `SaschaKP` who made several performance changes from generic to non-generic collections that I incorporated in the first release.

I have been actively maintaining this project since early April 2018 and based this version off of `1.4.0.3`, which was simply the version `1.0.13.13` updated to .NET 4.0. All the changes for this version of Razor started under version `1.5.0.X`+.

Another closed source version of Razor exists (the `1.0.14.x` versions) that was maintained by a private shard that made some enhancements, notably around targeting. This version of Razor has long since incorporated the majority of changes you can find in that version.

* In June 2019 integration into [ClassicUO](https://github.com/ClassicUO/ClassicUO) was officially established.
* In March 2020 the [Razor Scripting Engine](https://www.razorce.com/guide/) was added to make it easier to read, create, edit and share Razor scripts while staying true to the project's state goals.
* In May 2021 Razor moved from .NET 4.0 to 4.7.2 to bring it in line with ClassicUO.

# Community Edition

When I started this project back in early 2018, nearly all the [feedback, ideas, discussion](https://www.uorforum.com/threads/improving-razor-razor-development.33134/) and [testing](https://www.uorforum.com/threads/razor-1-5-bug-issue-release-tracking.33405/) came from the [UO:Renaissance](http://www.uorenaissance.com) community, one of the only freeshards where the rules only allow for the use of Razor. The original **UO:R Community Edition** name was used to not only distinguish between other versions of Razor that were available but give credit to a community that provided so much support early on.

As the popularity of this version grew, especially after the implementation of ClassicUO support, it became widely used across the whole UO freeshard community, from small private shards to some of the largest shards in the community and continues to be built on the feedback and contributions from all different corners of the community.

With that said, I find it more appropriate to simply call this version the **Razor Community Edition**.

Thank you to everyone across the whole UO freeshard community who has contributed to this version of Razor in some way.

If you'd like contribute, see the [CONTRIBUTING](https://github.com/markdwags/Razor/blob/master/CONTRIBUTING.md) file for more information.


================================================
FILE: help/docs/index.md
================================================
![razor](images/razor.png){ align=right }

# Razor Community Edition

Razor is a free tool designed to help with simple tasks while playing Ultima Online.

The goal of this project was to revive and continue development and maintenance of the abandoned Razor project, focusing on *quality of life* improvements while attempting to keep the spirit and vision the original developers had for Razor by not driving down the path of advanced automation that's found in other UO assistants.

For more information about this version of Razor, read the [history](./history.md), review the [release notes](./releasenotes.md), and [download](./download.md) Razor.

# Help & Support

* For information about how to use Razor, please review the [help guide](./help/).
* For information about UO Razor scripts, please review the [scripting guide](./guide/).

If you're unable to find a solution using the information here or you'd like to submit a feature request or bug report, use the following resources.

* Submit a feature/bug/issue on our [official Razor GitHub Repo](https://github.com/markdwags/Razor/issues).
* Join us in `#razor` on Discord (we use the the official [ClassicUO](https://www.classicuo.eu/) Discord server)

[![Chat on Discord status](https://img.shields.io/discord/458277173208547350.svg?logo=discord)](https://discord.gg/zrdyYcc)

# License

!!! info
    All work is released under the GPLv3 license. This project does not distribute any copyrighted game assets. In order to run this application you'll need to legally obtain a copy of the Ultima Online Classic Client.

See the [LICENSE](https://github.com/markdwags/Razor/blob/master/LICENSE.md) file for details.


================================================
FILE: help/docs/install/linux.md
================================================
---
title: Linux Install
description: A quick guide on how to get Razor up and running on Linux
---

# Overview

To run Razor with [ClassicUO](https://www.classicuo.eu/) on Linux, you will need to install [Mono](https://www.mono-project.com/)

!!! info
    These steps were tested and validated a fresh installation of Linux Mint 19.1, Ubuntu 20.04, and Debian 11.5
    
    Based on your current configuration and Linux distribution, the steps may vary.

## Install Mono

!!! warning
    If you're running another version of Linux, please read the [installation steps](https://www.mono-project.com/download/stable/#download-lin) from the main Mono site and follow those instead.

* Open the command/console/terminal and add the Mono repo to your system

```bash
sudo apt install gnupg ca-certificates
sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 3FA7E0328081BFF6A14DA29AA6A19B38D3D831EF
echo "deb https://download.mono-project.com/repo/ubuntu stable-bionic main" | sudo tee /etc/apt/sources.list.d/mono-official-stable.list
sudo apt update
```

* Install the latest version of Mono

```bash
sudo apt install -y mono-complete
```

* Run the following commands from the console:

```bash
sudo apt-get install -y libmono-system-windows-forms4.0-cil
sudo apt-get install -y libmono-system-net-http4.0-cil
sudo apt-get install -y libmono-system-runtime-serialization4.0-cil
```

## Install libz

This package is required for ClassicUO to load gumps successfully.

* Install `libz`

```bash
sudo apt-get install -y libz-dev
```

## Install ClassicUO (Launcher)

* Download the latest version of the [ClassicUO Launcher](https://www.classicuo.eu/).
  
* Extract `ClassicUOLauncher-linux-x64-release.zip` to a local folder (ie: `/home/username/games/classicuo-launcher`)

```bash
mkdir /home/username/games/classicuo-launcher
cd /home/username/games/classicuo-launcher
unzip ClassicUOLauncher-linux-x64-release.zip.zip
```

* Run ClassicUO Launcher

```bash
chmod +x ClassicUOLauncher

./ClassicUOLauncher
```

* Install ClassicUO by clicking **Update Available**

![cuoinstall](../images/cuolauncher-update.png)


## Install Razor

* Download the latest version of [Razor](../download.md).
* Extract to `/home/username/games/classicuo-launcher/ClassicUO/Data/Plugins/Razor`
* Click **Edit Profiles** and setup your profile (server name, Ultima Online path, client version, etc)
* Click **Plugins** and then **Add** and browse to `/home/username/games/classicuo-launcher/ClassicUO/Data/Plugins/Razor` and select `Razor.exe`
* Save the profile and click **Launch**

!!! tip
    You can also run ClassicUO without using the launcher.

    Go to `/home/username/games/classicuo-launcher/ClassicUO` and type `mono ClassicUO.exe` or `./ClassicUO`

!!! warning

    On first launch, it might appear stuck on the Razor splash screen.

    ![splash](../images/linuxsplash.png)

    Behind that is a message box warning you that it will use a default profile. If you experience this, simply hit `Enter` with the splash screen active.


================================================
FILE: help/docs/install/windows.md
================================================
---
title: Windows Install
description: A quick guide on how to get Razor up and running on Windows
---

!!! warning "Client Support"
    It's **highly recommended** that you use the [ClassicUO](https://www.classicuo.eu/) client with this version of Razor, however it should work with the original 5.x and 7.x clients though support for any bugs may be limited.

# Install: Razor and ClassicUO

First, we need to download and install ClassicUO.

1. Download the [ClassicUO Launcher](https://www.classicuo.eu) and extract the `.zip` file to any location of your choosing (ie: `C:\CUOLauncher`)
2. Run `ClassicUOLauncher.exe`
3. When `ClassicUOLauncher.exe` opens, it will automatically download the latest version of ClassicUO and install it in a sub-folder called `ClassicUO` in the folder you extracted the launcher (ie: `C:\CUOLauncher\ClassicUO`). This process should only takes a few seconds.
4. Setup a profile to connect to your shard by clicking `Edit Profiles`
5. On the `Profile` tab click `Add`  
    - Give your profile a name
    - Enter your username and password if you'd like it to be saved
    - Enter the server IP and port number of the shard you're connecting to
    - Enter (or search for) the path to your UO files. These are the actual game files for the shard you're connecting to
    - Enter the client version number if it isn't auto-detected
  
Example of a completed profile:

![cuolauncher](../images/cuolauncher-profile.png)

Now, we need to install Razor.

1. [Download](../download.md) the latest version of Razor and extract the `.zip` file to `C:\CUOLauncher\ClassicUO\Data\Plugins\Razor` (replacing `C:\CUOLauncher` with the location you selected above if you picked something different)

    !!! hint
        If the `Data` and/or `Plugins` folders don't exist (most likely scenario on a new install) you can just create them first.

2. In the ClassicUO Launcher, go to the `Plugins` tab and click `Add`
3. Browse to the `\Data\Plugins\Razor` folder and select `Razor.exe`

    ![cuolauncher-plugins](../images/cuolauncher-plugin.png)

4. Click `Save Profile` and then `Back`
5. Select your profile and click `Launch`

If everything was setup correctly, you should see ClassicUO along with Razor open.

## Advanced: settings.json

If you would like to configure ClassicUO and Razor without the launcher, create a file called `settings.json` and copy/paste this template into it and change the following values: `ip, port, ultimaonlinedirectory, clientversion, plugins`

```json
{
  username: "",
  password: "",
  ip: "login.myshard.com",
  port: 2593,
  ultimaonlinedirectory: "C:/Path/To/UO/Files",
  clientversion: "5.0.8.3",
  lastcharactername: "",
  cliloc: "Cliloc.enu",
  lastservernum: 1,
  fps: 60,
  window_position: null,
  window_size: null,
  is_win_maximized: true,
  saveaccount: false,
  autologin: false,
  reconnect: false,
  reconnect_time: 30,
  login_music: true,
  login_music_volume: 30,
  shard_type: 0,
  fixed_time_step: true,
  run_mouse_in_separate_thread: true,
  force_driver: 0,
  use_verdata: false,
  encryption: 0,
  plugins: [
  "C:/Path/To/Razor/Razor.exe"
  ]
}
```

# Update: Razor and ClassicUO

These steps assume that you already have obtained and installed the Ultima Online game asset files in the local system and are already using ClassicUO.

- [Download the latest release of Razor](../download.md).

    !!! warning
        Windows will sometimes block `.dll` and `.exe` files from being ran after they're downloaded so you may have to open up a Powershell prompt from within the Razor folder and run `gci | Unblock-File`

- Extract the `.zip` into your existing Razor location (ie: `C:\CUOLauncher\ClassicUO\Data\Plugins\Razor`), overwriting all files, with the exception of one file:
    - **counters.xml** - This is the default counters file used to display items in your titlebar. If you've added any new counters, they would be lost if overwritten.
- Open ClassicUO back up and verify Razor is running the version you upgraded to.  

!!! hint "Standard OSI Client"

    The upgrade steps above should also work if you're using the standard OSI client, follow these steps.

    * Right-click on the Razor shortcut or Razor.exe, go to Properties. On the Compatibility tab, select **Run this program in compatibility mode** for and select **Windows XP SP2**. Also select **Run this program as an administrator**
    * Run Razor either via the shortcut or clicking the Razor.exe directly.
    * Razor should prompt to **Run As Administrator**. You must allow this for Razor to function correctly.

# Welcome Screen (Legacy Client Only)

!!! error "ClassicUO Users"
    If you're using ClassicUO, you should *never* see this screen. If you're trying to open ClassicUO and see this screen, click **Quit** and launch ClassicUO.

If you're using the legacy client, to The first time you run Razor, it will open with a **Welcome Screen** and give you an option to import your existing settings if they exist.

![welcome](../images/welcome.png)

Browse to your `client.exe` that you want to run along with Razor. Set the **UO Data Directory** (most likely the same path as your `client.exe`). Either use the pre-configured servers or enter your own server in the list here.

Click **OK** to open Razor and Ultima Online.


================================================
FILE: help/docs/releasenotes.md
================================================
---
description: Stay up-to-date with the latest Razor release notes
---

# Release Notes

Below is a list of the latest releases notes going back to the first release of this version of Razor.

## 1.10.X (Dev Version)

* You can always find the latest dev preview [here](https://github.com/markdwags/Razor/releases/tag/Razor-dev-preview).
* Fixed issue with `setvar` not giving you a target cursor if you stopped the script before selecting a target.

* Changed `setlasttarget` to require you provide a serial or variable as parameter. See [docs](guide/commands.md#setlasttarget).

## 1.9.77.0 (03/23/2023)

This version includes more updates to the scripting engine, including the ability to create cooldowns that will display as a gump. This version also introduces lists and timers to the scripting engine. Be sure to review the latest scripting docs for details.

* Added the `cooldown` command that generates a gump-based cooldown timer that can be customized (icon, color, name, order, etc)
* Added [list commands](guide/commands.md#list-commands) and [list expressions](guide/expressions.md#list-expressions)
* Added [timer commands](guide/commands.md#timer-commands) and [timer expressions](guide/expressions.md#timer-expressions)
* Added the `foreach` loop to interact with lists
* Option to disable 25ms delay on script line execution
* Updated script variables to be part of the same system that sets variables using the `as` operator
* Fixed missing syntax highlight for `maxweight`, `clearhands`, `cleardragdrop`, `sell`
* Running a script will show the name in the system message
* Fixed the `ignore` and `unignore` commands
* Fixed the `varexists` expression
* Added the `unsetvar` command
* Updated the `interrupt` command to let you pass a specific layer
* Option to disable highlighting on the script UI
* Better error handling on script syntax issues

## 1.8.61.0 (12/07/2022)

This version includes several new scripting commands, the ability to resize the Razor window, and Pandora like features. Versioning will slightly change, next versions will be 1.9.X.0, 1.10.X.0, 1.11.X.0, etc where X indicates the build/run ID.

* Fix issue with delete profile button
* Added `sound` and `music` script commands that will play specific sound or music in the client
* Added `classicuo/cuo` script commands, `>cuo` manual command to control ClassicUO settings directly
* Added sound trigger option to overhead messages
* Fixed issue with buffs/debuff filter not loading on a profile change
* Reload scripts will read all changes made externally to scripting files
* Added the ability to resize the Razor window
* Fixed issue with buy agents not saving/loading correctly
* Added `itemcount` expression that returns the number of items you carry in total
* Fixed `lifttype` to pull the correct amount when including a hue
* Added `rename` command to allow you to rename a follower
* Added `getlabel` command with the `in` expression to capture text from a single clicked item
* Fixed script tab not displaying the set hotkey
* Added Pandora inspired tabs in the Advanced (shard staff specific)
* Removed the script popout editor now that you can resize the main Razor window
* Updated the `dress` and `undress` commands to accept a serial or variable
* Updated `gumpclose` to accept an optional gump id
* Added an option to trigger male or female sounds base on specific emotes (ie: `*cheer*` or `*laugh*`)
* Script editor will highlight the current line when executed via the Play button in the UI
* Updated `setvar` to accept a serial (bypassing the target click) and to set temp variables using `!` (see docs)
* Fixed issue when using `findtype` with `or` and `as` where the variable wouldn't assign correctly
* Increased system message queue from 25 to 100 messages
* Added `ignore`, `unignore`, and `clearignore` commands

## 1.7.4.49 (07/26/2022)

* Added `followers` and `maxfollowers` expressions
* You can manage your agents in-game using `>restock #`, `>org #`, or `>buy #`
* `>info` command will display an image of the item
* Added the option for Next/Prev to be alphabetical
* Updated how damage when dealt or taken is displayed
* Fixed the mobile filter so it doesn't rely on movement
* Mobile filter is applied to mobiles on the screen when changing it in the UI
* Added wyrm as a mobile filter
* Added `targetexists` expression
* Added `diffhits, diffweight, diffmana, diffstam` expressions
* If the server disables macro loops that will also disable script loops
* Added an [index variable](https://www.razorce.com/guide/variables/#index-variable) to reference in scripts
* Added `name, paralyzed, invuln, warmode` expressions
* You can now assign `>custom` commands to hotkeys and execute using a command
* Fixed issue with the macro/script key binding not always displaying correctly in the UI

## 1.7.3.36 (01/10/2022)

* Option for buy agents to ignore the amount of gold you have
* `findtype`, `targettype`, `liftype` will match on the full item name only
* Agents can be assigned an [alias to be more easily identified in the dropdown](https://www.razorce.com/help/agents/#aliases)
* Agent aliases can be used in scripts
* Organizer and restock agent won't force the UI to come to the front when executing via scripts
* Added Next/Prev Friendly hotkey
* Added a pause script hotkey
* Added Pause/Resume to popout script editor
* When changing values in agents, it will be an in-game gump vs. a Razor UI inputbox
* Added `varexist` expression
* Added a `hue` parameter to `findtype`, `targettype`, `dclicktype` and `lifttype` for items
* Updated how the script `count/counter` expression works, it no longer requires you to have a counter setup under Display->Counters (thanks @sorsarre)

## 1.7.1.7 (10/13/2021)

* Added the keyword `as` when scripting to assign temp variables. See scripting guide.
* Fixed issue with auto-save of scripts
* `AutoSearchExemption` will now save by type
* `menu` command will block popup unless you pass a parameter
* Sound filter list and sound names are in sync, sorts in alphabetical order, block correct sounds
* Fixed syntax highlighting on nested quotes in scripts
* Razor should now run again with the legacy OSI client
* Razor settings are stored in a simple csv file now
* Feature flags can be 32-bit

## 1.7.0.12 (5/29/2021)

This version has two key updates. First, it updates the .NET framework from 4.0 to 4.7.2, bringing it inline with ClassicUO. Secondly, to make script editing a bit easier, there is now a popout editor available.

* Updated Razor to .NET 4.7.2 and increased the version to from 1.6.x to 1.7.x
* Added a new popout script editor. Right-click on the script editor to use it.
* Copy screenshots to clipboard and open screenshot folder from UI
* Fixed undress command when using a layer
* Fixed issue with `guardlines.ref` not being read by UOPS
* Added syntax highlighting for `targetloc` command
* `targetloc` requires two params, z will default to 0 if not included
* Show incoming name/target only for new mobiles
* `setvar` command will create the variable if it doesn't exist
* Added `cleardragdrop` command
* Added `interrupt` command
* Added `cancel` param to the `target` command
* Added `clear` param to the `target` command to clear the target queue
* Fixed issue with nested for loops and the `break` statement
* If you clone a profile to an existing name, it will block that
* When recording a script, it will capture `target 'self'`
* Fix how auto-script save works on Linux

## 1.6.9.21 (02/27/2021)

* Fixed issue with `setvar` and similar named variables
* `spirit` and `forensic` are valid `skill` entries for scripting
* Added `queued` expression to scripting
* Removed global script range checkboxes, review the guide for the correct syntax
* Fixed `drop` command to check for the correct params
* `lifttype` will default to 1 if not value is provided
* Import/export agents from the UI by clipboard or other profiles
* `findtype` supports the `backpack` param
* `lift` and `lifttype` will correctly wait before continuing
* `dress` and `undress` will also correctly wait before continuing
* `waitforsysmsg`, `waitforgump`, `waitgformenu`, `waitforprompt` will accept a timeout param
* Check if a spell needs channeling before triggering unequip
* Counters correctly save when you click Save
* Added `clearall` command. See scripting guide for details.
* Target Closest Friendly Humanoid will only target a humanoid
* Updated `target` command with new features. See scripting guide for details
* Added support for `@` quiet prefix for commands
* Added `clearhands` command to drop what you have in your hands
* `dclick` now supports `left`, `right` and `hands` to use an item in your hand
* Added `virtue` command to invoke honor, valor or sacrifice
* `Cancel Target` will cancel setting a varible if it's active
* Fixed `TargetByType` and `DoubleClickType` in macros with range check. The range checks were always meant to include in your backpack too
* Added `random` command to generate a random number you can use with `insysmsg` to help perform a random action
* Improved support for keycode differences between Windows and X11
* Additional support for dotnet core 3.1

## 1.6.8.15 (12/15/2020)

* Implemented treeview and categories for scripts
* Added ability to adjust the size of the script editing window and the list of scripts
* `script` command can now call the new supported categories
* Added `findbuff` scripting expression
* Fixed right-click menu not opening when selecting something in the script editor
* Script will throw an error if you use `if count` with an counter that isn't setup
* Fixed issue with the individual sound filter being off by 1
* Added `guild` and `alliance` scripting commands
* Converting macros to scripts will retain the same name if available
* Added `position` scripting expression
* Added ability to override which weapons Razor consider two handed
* ++ctrl+s++ will save the current script you're editing
* Save indicator in main window when editing scripts
* Fixed issue with `lift` command requiring the optional parameter

## 1.6.7.10 (10/24/2020)

* `>info` command gump will close when you try to close it
* Split 'Auto-Un/Reequip hands for potions' into 2 options
* Added in-game gump to show assigned Razor hotkeys. Type `>hotkeys`
* Added hotkeys for all Razor gumps that were available in commands (`info`, `sysmsg`, `hotkeys`)
* Added Set Hot Key button to agents
* New Filters tab on Razor and moved all filtering related features as sub-tabs
* Ability to block/filter specific text
* Added `whisper` and `yell` commands to scripting
* Fixed issue loading files when using the OSI client
* Option to disable tooltips in the script editor
* Fixed infinite loop issue with scripts when using nested for loops
* The script list on the UI will be in alphabetical order on Linux
* Added `waitforsysmsg` command as this can be achieved already using while loops.

## 1.6.6.15 (09/14/2020)

* Fixed ancient Razor bug that could cause non-existent items to remain in your queue (ie: when you stack a pile of gold on to another). This should fix some instances where scavenger isn't picking up items (thanks @SaschaKP)
* Fixed another ancient Razor bug where the vendor pack items aren't updated realtime by the server (it's managed client side). Razor should behave exactly like this. This will remove the warning in extinfos with amounts not matching. (thanks @SaschaKP)
* Fixed issue where party/friends overhead messages
* Moved the Overhead Messages feature to the `Display/Counters` tab so its more visible to everyone
* Revamped the General tab UI as it was too cluttered. Removed UOAM and Ultima Mapper shortcuts
* Moved the `Sound/Music` tab to the main `Filter` tab
* Moved the `Waypoint` tab to the `Display/Counters` tab
* Change the hue of the overhead message in the macro UI
* Fixed issue with scripts not parsing words like `spider's silk` correctly
* Fixed macro->script conversion for wait/pauses
* Created hotkeys to help generate script commands for `targettype` and `dclicktype`
* Added right-click menu to script list (reload, open externally, copy to clipboard)
* `>info` command will popup a gump that will display information about a mobile or item and let you copy by clicking the blue buttons
* Fixed some issues loading the previous profile
* Added `>sysmsgs` to display a gump of the current system messages in Razor's buffer for macro and scripting
* Prevent empty strings from going into the system message buffer

## 1.6.5.16 (08/08/2020)

* Fixed issue with saving scripts in certain scenarios
* `targettype` will find mobiles and items by name
* Moved Friends tab to the main tab list
* Added stop command to scripts
* Removed unused dependency
* Set friend tag and hue per group
* Attack name overhead "new targets only" works on hotkeys
* Changed default encoding on profiles to UTF8 (cross platform support)
* Added the ability to set waypoints in-game
* Create a waypoint to the position of your corpse upon death
* Added '`backpack`' option to `dclicktype` and `targettype`
* Moved Filters to the main tab list
* Added Next/Prev Non-Friendly Targets
* Added `clearsysmsg`/`clearjournal` to scripts and macros

## 1.6.4.32 (05/17/2020)

* Fixed any errors related to systray and long titles
* Razor supports Linux again after fixing issues related to the new script editor
* Fixed issues with `dclicktype` and `targettype` range check (both Macros and Scripts)
* Fixed a few packet exception issues when logging in or casting spells
* Script engine optimizations (better error reporting, better timeout/pause handling)
* Fixed issues related to `waitfortarget`/`wft` not working correctly
* Fixed issues with nested if/else/endif
* Fixed the '`lasttarget`' variable
* Added '`hidden`' expression
* Fixed '`findtype`' expression
* Added range check to '`findtype`'
* Fixed righthand, lefthand and hand variables/aliases
* Field to filter scripts in the UI
* Added hotkey to add party members (`/add`)
* Added feature to convert macros to scripts (right-click macro and convert)
* Backup will include Razor Scripts
* Added support for Mystic and Masteries
* Show Attack message when using Attack Last Target hotkey

## 1.6.4.2 (03/16/2020)

This version introduces a new scripting engine that makes it easier to create and share macros.

For more information, visit the [Razor Scripting Engine Guide](https://www.razorce.com/guide/).

* Introduction of the Razor Scripting Engine (thanks to everyone for your time testing and providing feedback)
* New Sound & Music Tab: Filter out any game sound, trigger music and listen to any sound
* Added while loop to the macro system
* Fixed issue with auto-screenshot not working with players with invalid characters in their name
* Enforce your min light level on login
* You can extract specific words from the system message to display in the overhead messages (`{1} {2}`, etc for the first, second word)
* Added Set Macro Variable Target Action to macros that will pause until you set a variable (same behavior as "Set Last Target")
* Razor's Last Object (hotkey and macro/scripts) should work as expected
* `>hue` and `>item` commands are a bit more informative
* You can copy/paste friends list when you aren't actually logged in
* Added option to have next/prev friend highlight friend in Friends tab
* The Discord overlay shouldn't cause any access violations
* SysTray will go away on close (instead of leaving ghost ones behind)

## 1.6.2.23 (12/18/19)

* Changed interrupt order to start shirt, shoes, pants
* Fixed Edit button on Overhead Message UI
* Capture compressed gumps for WaitForGump
* Additional UI SafeActions
* Added ability to filter out mobiles from being targeted
* Added `if skill` to macros
* Fixed invalid cast error on `if counter`
* Fixes a bug were when changing a character in same account, using different profiles (not default), causes a sudden lockdown of razor window, that also locks ClassicUO from * loading, causing a crash after a while.
* Double clicking Overhead Message macro action now opens Input box for editing message instead of Pause action menu.
* Bandage timer will restart if bandage is applied before it ends
* Using 'Add Target' under the friends tab will give you a target
* Renaming a macro removes the old entry from the hotkey list
* Added Set HotKey button to macro UI
* Added `>set` command to set macro variables in-game
* Prioritize key that triggered event, include number row in SDL keymap
* For ClassicUO, dont trigger Hotkey.OnKeyDown if key is a modifier key
* UOPS displays Trammel and TerMur correctly
* Fixed issue with GumpReponses with text entries not loading
* Bandage timer will stop on "You did not stay close enough to heal your target.
* Bandage timer will reset if you bandage yourself before finishing
* Remove packet block on 0xF0 when using ClassicUO to allow party tracking in WorldMap
* Added mobile filter for daemons

## 1.6.1.32 (08/05/19)

* Next/Previous will only set Beneficial when using Next/Prev Friend
* Changed Razor commands from - to > (ie: -hue is >hue)
* Next/Previous Target will check if the target is a friend
* Next/Previous Friendly can be set to only set Beneficial
* Next/Previous Non-Friendly can be set to only set Harmful
* Fix to how names are handled per mobile
* Pet & Boat commands now use the speech override hue
* Enabled the seasons dropdown when using ClassicUO
* Fixed ContextMenu not recording & execution
* AbsoluteTargetVariables and DoubleClickVariables have been merged into MacroVariables.
* When adding an Overhead Message, if it doesn't exist in the list you will be prompted to add it anyway
* Fixed issue with Friends and Dress lists not always loading when using ClassicUO
* Improved the bandage timer to pick up additional start/stop messages
* Set Last Beneficial & Set Last Harmful now have the proper system message
* Friend hotkeys now display under a new "Friends" hotkey category
* Buff/Debuff overhead messages can be filtered and hues changed
* Added check to prevent multiple single-click flag checks
* Additional SafeActions added to the UI
* Added {name} as an option for the target indicator
* Added the ability to edit the bandage start/stop messages
* Fixed issue using the delete key when removing Friends
* Updated the screenshot capture on death (option to add a delay, and to capture self death or death of others)

## 1.6.0.57 (06/28/19)

After 57 builds, Razor now fully supports [ClassicUO](https://github.com/andreakarasho/ClassicUO). Thanks to KaRaShO for his amazing work on this client. Thanks to Jaedan, DarkLotus, and everyone who helped test Razor and provided feedback.

* Enabled support for ClassicUO and standard OSI client
* Enabled cross-platform support (specifically Linux)
* Several optimzations, tweaks, and overall improvements to Razor.
* Queue Last/Self default to disabled
* Auto-queue object delay default to disabled
* Clean Config.cs formatting
* Merged UltimaSDK
* Add Grab HotKey & Set Grab Hotbag
* New Next/Prev Hotkeys
* Added Criminal, Murderer and Innocent Next/Prev hotkeys
* Add Next/Previous for Friendly, Gray and Non-Friendly
* Refactored the Next/Prev code
* Added target sub-categories in HotKeys
* Restored {mana} and {stam}
* Added Toggle War and Toggle Peace only hotkeys
* Added < and > to if macro actions
* Added {maxhp}, {maxstam} and {maxmana} as variable options in the IfActions in macros
* Added a Greater Heal/Cure hotkey, relabeled Heal/Cure Hotkey to "Smart Heal/Cure"
* Support SmartLastTarget in AttackLastTarget
* Added Set Beneficial and Harmful hotkeys
* Added option to disable auto-open door when hidden
* Added use item for Right or Left hotkeys
* Added option to disable play/finished macro message
* Next/Prev will ignore ghosts and blessed mobiles (just like random and closest)
* Added ability to insert overhead messages in macros
* Hotkey enable/disable messages will use warning or default Razor message hues. This should make it easier to see/read when you're hitting the hotkeys.
* Next/Prev friend won't set them as a combatant
* Added Insert Wait For Target for macros
* Added option under Display/Counters to display bandage timer overhead or in system messages
* Removed Friends Agent and added new Friends Groups
* Create groups of friends
* Enable/disable groups
* Copy/paste friends in and out of Razor
* Implemented filtering of repeating messages for system, Razor and overhead messages
  
## 1.5.0.17 (03/17/19)

This version completely changes how Razor handles movement. Prior to this release, Razor would parse movement packets to determine your current X/Y/Z. During certain in-game actions, such as running when casting, this would sometimes cause you to desync. This is when the server thinks you're at a certain X/Y/Z and Razor thinks you're on another.

Razor will instead start a timer in the client that checks if the position has changed in client memory. When your position changes, it will send a message to notify Razor.

This way, Razor is no longer in the business of reading movement packets which should prevent you from ever desyncing.

### Razor

* Razor should no longer "desync" (usually experienced by people with lower pings).
* Crypt.dll has been cleaned up and optimized. You should notice Razor and UO start up quicker.
* If Razor has an issue verifying an animation for the filter dropdown, it will just load it by default.

### Macros

* The "Waiting.. Timeout" message when you're running a macro is easier to read.

### HotKeys

* If you use the "Add All Mobiles To Friends" it won't add the same person twice.

## 1.5.0.16 (03/04/19)

### Razor

* Changed the position of the Quit button on the Welcome screen.
* Removed packet and AVI recording since the feature has been sunset by modern applications and technology. If you need to watch or record packet videos, please use and older version. If you want to record videos, check out OBS.

### Options->Speech & Messages

* Added an Edit button to the Overhead message window to edit a message.
* Added an option to show [Friend] overhead if that mobile is on your friends list.

### Options->Targeting & Queues

* Fixed issue with Next/Prev Humanoid still targeting friends even when the checkbox was checked.

### Options->Additional Options

* Combined "Always show stealth steps" and "Count stealth steps" into one checkbox. The Now counting stealth steps. message has been removed since it didn't have any logic to only fire off when stealth was successful. Utilize the Overhead message feature if you want to see something overhead on a successful stealth.
* You can now customize the step message overhead.
* The Static Wall and label checkbox will now load/save properly.
  
### Skills

* Added an option to show skill/stat gains overhead.

## 1.5.0.15 (02/17/19)

### Razor

* Revamped the main Razor UI: As the feature set has grown, space has become limited. This initially led me down the road of expanding the window based on the top, but this started to prove to not be a good long term solution. I tried to keep the look and feel as close to Razor as possible.
* Removed window adjusting size based on the tab. It's now a static size.
* The "Options" tab now has sub-tabs with features broken into smaller categories.
* The "More Options" tab has been removed and condensed into "Options"
* The "Display/Counters" tab has been broken into two sub-tabs.
* The "Macros" tab has been broken into two sub-tabs, instead of that little button to expand the window.
* Numerous other slight adjustments.
* Revamp of the Welcome UI: Just to go along with the main UI revamp.
* More easily manage servers from the welcome UI
* Warning if your UO Client Directory and UO Data Directory don't match (often a source of issues for people)

### Macros

* Razor now will record and play prompt actions (ie: renaming runes, renaming runebooks, etc).
* Re-targeting a mobile on the DoubleClick action (ie: a horse) will work instead of having to re-record the double-click action.

### HotKeys

* Added a hotkey to add all the mobiles in range to your friends list.
* Added hotkeys for all pet commands (all follow, all kill, etc). This does the exact same thing as a standard macro recorded saying the command.
* The following targeting hotkeys exist in another version of Razor (1.0.14.10) that was updated in 2017. They've been added in this version.
    * Closest Criminal Monster
    * Closest Innocent Monster
    * Closest Murderer Humanoid
    * Closest Murderer Monster
    * Random Criminal Monster
    * Random Innocent Monster
    * Random Murderer Humanoid
    * Random Murderer Monster
    * Next Monster Target
    * Previous Monster Target
* The following targeting hotkeys are new to this version of Razor and did not exist in previous versions.
    * Closest Friendly Humanoid
    * Closest Friendly Monster
    * Closest Non-Friendly Humanoid
    * Closest Non-Friendly Monster
    * Random Friendly Humanoid
    * Random Friendly Monster
    * Random Non-Friendly Humanoid
    * Random Non-Friendly Monster
    * Closest Mobile
    * Random Mobile
  
### General

* When you change your profile, the animation filter list will properly reload.
  
### Options->Targeting & Queues

* Added option to change the text of the target indictor.
* Added option to prevent Next/Prev target hotkeys from targeting friends.

## 1.5.0.14 (01/16/19)

### Display/Counters

* Added a damage tracker feature that can be enabled/disabled via a hotkey that will track the following:
    * DPS (Damage Per Second)
    * Final DPS
    * Max DPS
    * Total Damage Dealt
    * Total Damage Taken
    * Max Single Damage Dealt (and to which mobile)
    * Max Single Damage Taken
    * Top 5 Damage Dealt By Name (ie: if you kill dragons for an hour, it will give you the total damage you dished out to all those dragons)
* When you stop the damage tracker, the stats above will be displayed in your client and journal.
* Updated the UO Title Bar to accept the following variables to display the tracked values above: {dps}, {maxdps}, {maxdamagedealt}, {maxdamagetaken}, {totaldamagedealt}, {totaldamagetaken}
* You can change the text in Razor's title bar just as you can with the UO title bar.


### General

* Added the ability to toggle Dragons and Drakes to use a different graphic. This will have the same effect as those who use the "artmods" to replace the large dragon graphic will a small dragon or some other graphic completely (Blackthrone is a popular one). In other words, only you will see the graphic change.
* Minor UI tweaks you may or may not notice.

### Hot Keys

* Added a hotkey that will only enable hotkeys (not toggle on/off).
* Added a hotkey that will only disable hotkeys (not toggle on/off).

### Maps

* Added UOAssist API support back into Crypt so Ultima Mapper and other applications that use that will work with this version of Razor.
* Added buttons to quickly open UOAM or Ultima Mapper from the Maps tab.

### Macros

* Added the ability to filter macros for easy searching.

### More Options

* You can now set individual hue colors for overhead messages.
* Damage indicators in UO don't show up in your journal. Added an option to have damage dealt and damage taken display overhead or in the lower-left which will have it log to your journal.

## 1.5.0.13 (01/01/19)

### More Options

* Added option that will turn magic fields/walls into static tiles.
* Updated the attack name overhead feature to include the names of targets acquired via hotkeys.
* Added option to display a text target indicator over a newly acquired target.
* You can no longer open up multiple container label and overhead message windows.

### Macros

* Along with AbsoluteTarget variables, you can now create DoubleClick variables. NOTE: The goal of these macro variables is allow macros to be shared across multiple characters without requiring cloned copies of the macros.
* You can retarget to Lift and LiftByType actions (instead of having to record, re-lift new item, stop recording, delete old action)
* Pausing a macro when one isn't running will no longer cause a crash.
* Copy/pasted macro lines won't appear "linked" and will work across other macros.

### Maps

* The boat control will now let you set relative location. Right-click on the direction you're going to set the relative location.

## 1.5.0.12 (12/25/18)

### Razor

* Fixed the issue that was causing the "filter exceptions" popup
* The -ping command will display the correct value for the average
* Entering the wrong -command will no longer result in an error popup
* The previous version reverted Razor from using the updated visual style back to the older looking style due to a Windows patch last month (KB4459942). This has been fixed.

### Macros

* Fixed the issue with Absolute Target Variables not saving correctly in a macro

### Agents

* Like the Organizer Agent, you can no longer enter mulitple items into a Restock Agent
* Double-clicking on the list when viewing the Restock or Buy agents will popup the dialog to change the value (same behavior as clicking Edit)

## 1.5.0.11 (11/20/18)

### Razor

* Razor will check the value of UODataDir in your config before looking to the registry, making it now fully portable and able to handle computers with multiple versions of UO installed. This should fix missing images in the titlebar on counters for some people.
* Razor will try to be a little smarter when determining if it's offscreen and reset itself if it is.

### More Options

* If your container has a non-generic name (ie: holiday bags, special chests), you can set an alias so the container label will work on it.
* Added an option to automatically block trades
* Added an option to auto-accept party invites from friends
* You can set an min/max light level. Be sure you have your Light Filter unchecked before using this feature.

### Macros

* Double-click GumpResponse to check button ID
* Added Use Last Gump Response to macro options (ie: to update a macro using a runebook)

### Hot Keys

* Added a hotkey to interrupt spell casting (same effect as having a macro that picked up and equipped a pair of shoes).
* You can now capture data from large and small BOD deeds. The file will be saved in a .csv file (BODs.csv) in the root path of Razor.
  
## 1.5.0.10 (11/2/18)

### Razor

* Razor won't display extra systray icons
* Manually typing in a server name will save it correctly to the config
* Razor will correctly handle different sized maps
* Razor will import your macros, profiles and counter.xml from %AppData%\Razor when you run it the first time and the ImportProfilesAndMacros is set to true in the config.
* Razor will ignore if Window's font is zoomed (Windows 7 is 125% by default on some machines)
* -ping command will give a litle more detail

### Options

* You can now set the season in Razor that will display in the client. This will only change what you see.

### More Options

You can now assign container labels to containers (chests, bags, etc) in UO. This label can be colored coded and set to help identify what is in the container.
Overhead messages can be changed from Unicode to ASCII (more classic look)

### Macros

* Absolute Targets will now save in the profile instead of a separate file.
* Double-Clicking "If", Comments or "For Loops" should open the correct dialog
* Added ability to edit speech in macros
* Potential fix to WaitForGump action not working
* After you add a macro via the clipboard, it will desolate your clipboard.

### Agents

* Create a new agent IgnoreList, this allows you to add people to the list and all messages (regular, yell, whisper, emotes), except for spells, will be blocked from displaying in UO. This includes being blocked from going into Razor's internal SysMessage queue to be used for macros.

### Hot Keys

* Add UseOnce Container should no longer crash Razor
* Added Previous Target hotkeys to match the Next Target hotkeys
* Organizer and Restock hotkeys sorting has been changed to be more clear (this will require mapping those hotkeys)
* Instead of trying to figure out the monsters using mobtypes.txt, I changed the logic of targeting monsters to target anything that isn't human. This should prevent scenarios where it wouldn't target a monster using an animal model.

### Advanced

* The backup profile/macros button should now work if a certain folder is missing.

### Display/Counters

* {skill} timer will start when using skills directly in the client

## 1.5.0.9 (9/26/18)

### Map

* Captured MIBs display on screen
* Boat uses your Razor speech text
* Fixed Stop from adding slow or one
* Fixed slow left from not responding (stubborn tillerman)

### Display/Counters

* Added {buffsdebuffs} to display bar with timer countdown
* Fixed {followers} and {maxfollowers}
* Gold tracker now shows total minutes {goldtotalmin}
* Gold tracker will start when you pick up your first gold pile if enabled
* Added {uptime} to show how long you've been connected

### Options

* Added option to block auto-opening corpses twice in a session

### More Options

* Buffs and debuffs can now be displayed over your head

### Hotkeys

* Added Scavenger Enable/Disable, Scavenger Set Hot Bag and Scavenger Add Target
* Added HotKey to trigger Gold tracker on or off

### Advanced

* Fixed Advanced tab to show which features are enabled

### Razor

* Default Razor config will be taskbar instead of systray

### Macros

* Added option to do a range check on TargetByType
* Added option to do a range check on DoubleClickTargetType
* Fixed the WalkAction macro to no longer cause massive desync issues

### Screenshots

* You can now upload screenshots to Imgur from Razor for easy sharing. All images are uploaded anonymously and are not linked to any Imgur account.
Razor will keep a history of images uploaded, and store the delete hash so they can be deleted.

## 1.5.0.8 (8/29/18)

### Razor

* I had a talk with the tillerman and he agreed to respond to your boat commands.

### Map

* Party members who are out of range will continue to update their position on your map.
* When using "Smart Always On Top", JMap will react like Razor and UOPS do when you unfocus the current UO client.
* Added HotKey that will toggle JMap visible/hidden.
* Fixed issue with MIB coords sometimes being negative.
* Updating the X/Y changes now update markers correctly.
* Marker X/Y accept proper inputs.
* New MIB icons for mib x/y coords.
* Fixed rendering offset with some markers
* Mouse coords should now display correctly.
* TMap and MIB Markers should now highlight their corresponding tile when hovered.

### Options

* Object delay has a checkbox. Unchecking it will set your delay to 0. You can still leave it enabled and enter 0.

## 1.5.0.7 (8/24/18)

This version includes a new Overhead system that lets you trigger messages that are in the lower-left to appear overhead.

### Razor

* Updated the main UI to use the modern Windows theme if it's enabled. Looks much nicer now.
* Sound filters for bulls, dragons and chickens.
* Updated UI size and text size for all input forms.
* Moved packet logging location to Razor directory
* Added Save button to Profile (previously you could only save your profile by exiting out of UO completely)
* Additional updates to Razor to make it fully portable. If the registry keys for UO are missing, it will default and use the UODataDir defined in the config. You should be able to copy/paste your UO folder and Razor to any location now.

### Map

* Enabled JMap
* Added stop and a close button to the Boat Control Window
* Added MIB capture feature. When you open an MIB, it will write the X/Y coordinates to a file that can display in JMap.

### Hot Keys

* Added "Set Sell HotBag" hotkey
* Added "Add UseContainer" hotkey
  
### Display/Counters

* Added gold per second, minute and hour to titlebar. This can be enabled per session and tracked via adding {gps}, {gpm}, {gph} and {totalgold} to your display bar
* Fixed skill timer ({skill} in the displaybar) to be more accurate
  
### More Options

* Added Overhead Message UI
* Updated Force Screen Size checkbox to tell you to open options and click Apply instead of logging out and back in
* Added option to put stealth count overhead
  
## 1.5.0.6 (7/18/18)

* Added light level bar to change in game
* Unchecking the light filter will reset it
* Added boat control UI and functionality (similar to UO Rudder)
* Added initial Map tab for new map update, most features are not enabled
* Added a hotkey to only show mobiles
* Added a hotkey to only show corpses
* Target Closest Gray Monster will include dire wolves and hellhounds.
* Option to disable put self/last/clear target messages from being overhead
* Added option to display stun messages overhead
* Updated bundled counter.xml to include more useful items
* Added feature to log your skill gains to a CSV file per character
* Sound filters for bulls and dragons
* Removed some responses from the -mobile command that didn't show data
  
## 1.5.0.5 (5/18/18)
* Updated the -mobile command to have some additional information
* Add IsSeaMonster to each Mobile object
* Fixed the Target Closest Gray Monster and Random Gray Monster to include Sea Monsters (sea serpents, etc)
  
## 1.5.0.4

* Fixed issue with macros not opening up in the editor if they were in categories.
* Added ability to step through a macro when playing (ie. for debugging)
* Stepping through a macro now works from "Play From Here"
* Added a button to disable SmartCPU for testing purposes
* Added Hotkey to Pause current macro
* Added the -item command to do the same as -hue
  
## 1.5.0.3

* "Fixed" issue with missing Z axis on player. Compiling Crypt.dll with Optimizations would break it. Need more research but a current work around.
* Additional check on disabling SmartCPU
* Additional generic to non-generic array changes
* Auto-open doors is default true in new profiles
* Added by type protection based on @uoitalia's code
* Added Target Next Enemy Humanoid
* Added a checkbox to force different TargetByType targets. In other words, don't target the same type twice.
* Added -clearitems and -resync commands. -clearitems is experimental to see if it addresses issues where items out of range are picked up
* Added Cyclops and Titans sound filter
* Deer Sound filter works correctly
* Fixed issue with the Hotkeys filter no resetting when you left the tab and came back
* You can open a macro externally to your default editor

## 1.5.0.2
* Added Target Random Grey Monster
* Added Target Random Enemy Monster
* Added Target Closest Grey Monster
* Added Target Closest Enemy Monster
  
## 1.5.0.1
* Fixed issue with organizer agents not saving correctly (and thus not loading correctly)
* Fixed issue with not being able to delete an absolute target when you had 1 left
* Razor will remember the last server you picked
* Additional validation on the OK button to be sure you selected a data dir and UO client
* Added a few issues with getting PacketFilter errors on values that didn't exist.
  
## 1.5.0.0

### Razor

* Remove the auto-update feature check
* Remove PayPal button on Razor splash
* Popup windows for input should auto-focus and not require clicking in the text field first
* Convert much of the old .NET Hashtables and Arraylists to hopefully improve with performance
* Remove the use the DateTime.Now and use DateTime.UtcNow for the internal mechanism (DateTime.Now is 10 times slower than DateTime.UtcNow)
* Added -hue command
* Removed dependancy on InstallDir being in HKLM which should result in more people able to use Force Screen size. GetInstallDirectory now returns the folder the Razor.exe is running in.
* Removed all dependancy on the HMCU for the registry. All settings are in App.config and all Profiles and Macros are expected to be the sub folder of Razor.exe
* Additional UI adjustments

### General

* Completely remove the SmartCPU feature
* Add Clone Profile button to easily create a copy of an existing profile instead of having to use the default
* Add Checkbox to enable confirmation buttons on buttons that clear lists or delete things
* Delete confirmation when you deleting a profile
  
### Options

* Add {circle} to the Spell Format option to display, if you want, the circle the spell was casted from.

### Macros

* Copy macro to clipboard
* New button to create macro from clipboard
* Control-UP / Down to move macro line
* Rename macro from UI
* Double click macro action opens Edit dialog instead of having to right-click and Edit..
* Adding a macro to a group should not require typing in the group name each time
  
### Arms/Dress

* Add confirmation box on Clear List
  
### Agents

* Add confirmation box on all clear buttons (so tired of accidently clicking clear instead of clear hotbag)

### Hotkeys

* Filter by name to quickly find a hotkey


================================================
FILE: help/docs/stylesheets/extra.css
================================================
:root>* {
  --md-code-hl-function-color: #e72b2b;
  --md-code-hl-constant-color: #2B90AF;
  --md-code-hl-keyword-color: #FF860E;
  --md-code-hl-string-color: #B5F109;
  --md-code-hl-number-color: #AE81FF;
}


================================================
FILE: help/docs/uoaapi.md
================================================
# UOAssist API (UOA API)

Razor supports the **UO Assist API** to allow basic integration into Razor. This information was pulled from [here](http://web.archive.org/web/20100419122932/http://www.tugsoft.com/uoassist/thirdpartydev.asp). It has been slightly modified for formatting purposes.

## Messages Received

Messages that Razor will process  (WM_USER = 0x0400 or 1024)

### Request Data  (WM_USER+200)

This is used to register your application with Razor.  Once your application is registered Razor will begin sending your application the messages described below.

* Parameters: WPARAM = The window handle where you want messages sent.  LPARAM = flags  ( 1 = get house notifications, NOTE all notification with a lesser notify value than the house notification will go to all windows that have requested information)
* Returns 2 on unhook, 1 on success, 0 on failure (failure means all slots full) .  
!!! note
    If you have registered a window and wish to unregister just send the message with the window handle again. 

### Count Resources (WM_USER+201)

This will prompt Razor to begin counting resources. 

* Parameters:  NONE
* Returns 1 on successful start or 0 on stop.

!!! note
    If resources are already being counted the count will be stopped.

    Currently it will always return 0 - this MAY be changed in the future but for now it will be zero

### Get Coords (WM_USER+202)

Gets the current location of the character.

* Parameters:  NONE
* Returns: X in the loword and Y in the hiword.  (x=LOWORD(retVal); y=HIWORD(retVal);)
* 
!!! note
    You MUST use SendMessage for the return value to be valid.

### Get Skill (WM_USER+203)

Gets the current skill level of specified skill.

* Parameters: WPARAM = skill number ( 0 based )  LPARAM (when 0 the return will be the 'display' value, when 1 it will be the 'base' value, 2 = get lock value, 3 = get skill name  ).
* Returns:  Skill level * 10.  Meaning if the skill level was 19.4 you would get 194 returned.  Or if lock value was requested the return is 0 = up, 1 = down, 2 = locked.  If the skill name is requested the value is a global atom that you will need to free.

!!! note
    You MUST use SendMessage for the return value to be valid.

### Get Stat (WM_USER+204)

Gets the stat and its related attribute.

* Parameters: WPARAM = stat to get   (str = 0, int = 1, dex = 2, weight = 3, 4 = Max HP, 5 = tithing points)
* Returns: Requested stat (str,int,dex, weight, max hp) in the loword and (hp,mana,stam, max weight, current hp) in hiword.   You MUST use SendMessage for the return value to be valid.

### Set Active Macro (WM_USER + 205)

!!! tip
    This is not enabled in Razor

Sets the active macro

* Parameters: WPARAM = macro (zero based  0-7)

### Play macro (WM_USER+206)

Plays/Stops active macro

* Parameters: None
* Returns: 0 - macro stopped  1 - macro playing

### Display text (WM_USER+207)

Displays text on the game screen

* Parameters: WPARAM loword = color  hiword = (0- over characters head 1- system message)
                    LPARAM = global atom that contains string - Razor frees the atom after using it (See Windows SDK on ATOMS)
* Returns 0 - failure either the user isn't logged in or the atom wasn't found,    1 - success

!!! tip
    Razor will only read strings 255 characters or less, I didn't actually test to see if uo can handle strings that long so if you plan to use long strings you should test that out first.

### Request house/boat information (WM_USER+208)

Requests the information on house(s)/boat(s) in the nearby area.

* Parameters: None
* Returns:  0 - failure (not logged into game) 1 - success

!!! tip
    You should make sure you are set to receive updates from Razor first.

### Add command line command (WM_USER+209)

Add a command line command to Razor.  When the user types the command (prefix is '-') you can receive a notification and the parameters the user enters using this feature.  For example if you add the command 'broadcast' and the user types in '-broadcast run away' your window will receive a message with 'run away' as the parameters (in a global ATOM).

* Parameters: WPARAM - HWND of the window to receive the message. LPARAM - ATOM of the command (NOTE: spaces won't work correct)
* Returns On failure  0 - All command space has been used,  1 - the command ATOM was not found (must be a global atom)
    - On success - returns the value of the message your window will receive (should be >= WM_USER + 400). The message you will receive will be like this:
        - MessageID = return value from add call (remember to use SendMessage)
        - WPARAM =  NULL - either a global atom couldn't be create or no parameters were entered
        - or a global ATOM that contains the parameters (You must delete the ATOM yourself)(See Windows SDK on ATOMS)

!!! tip
    Commands are not case sensitive.  If you add a command '/command' the user will have to type -/command in order for you to get the message.  To remove a command send the command again with a zero as the WPARAM.

### Get User ID (WM_USER+210)

You must use send message on this one.  It returns a ID that Razor can use to identify the user (NOTE: it is not the actual user ID used by the servers).  This is used to add a player to your party.

* Returns 0 if no user is logged in or a value if a user is logged into the game.

### Get Shard Name (WM_USER+211)

* Returns 0 if no user is logged into the game or if a global atom could not be created.
* Returns a global atom with the shard name in it. 

You must use SendMessage for this message.

### Add user to party (WM_USER+212)

* Parameters: WPARAM - User ID obtained from Get User ID message.
* Returns 0 on success, 1 on error (will not work if a macro is playing)  You must use send message if you want the return value.

### Get UO window handle (WM_USER + 213)

* Parameters: None
* Returns the HWND of the UO window.  NOTE - you must use SendMessage to get the correct value.

### Get poison status  (WM_USER + 214)

* Parameters: None
* Returns  1 if poisoned or 0 if not poisoned.  NOTE - you must use SendMessage to get the correct value.

### Set skill lock (WM_USER + 215)

* Parameters:  WPARAM = zero based skill number, LPARAM = lock direction  [0 = up, 1 = down, 2 = locked]
* Returns 0 on success, 1 on failure (will fail with invalid param(s) or not logged into game).  NOTE: when the lock value is set Razor requests the current skill values from the server.  So don't set locks in rapid succession for a long period of time or you may lag yourself out.

### Get account identifier (WM_USER + 216)

* Parameters:  None currently
* Returns 0 if no character is logged into game otherwise a identifier for the account

## Messages Sent

Messages Razor will send to apps that have registered a valid window.

### Resource Count Finished (WM_USER+301)

This message is sent when resource counting has finished.

* Parameters : WPARAM is defined below and LPARAM is the count
    - BloodMoss = 1
    - BlackPearl = 2
    - Garlic = 3
    - Ginseng = 4
    - Mandrake Root = 5
    - NightShade = 6
    - Sulfurous Ash = 7
    - Spider Silk = 8
    - User1 = 9
    - User2 = 10    
    - User3 = 11
    - User4 = 12
    - User5 = 13
    - User6 = 14
    - Batwing = 100
    - DaemonBlood = 101
    - GraveDust = 102
    - NoxCrystal = 103
    - PigIron = 104
    - Tithing = 200

### Spell was attempted  (WM_USER+302)

This message is sent when a spell is attempted.  It is not known if the spell will fail or timeout or be cancelled.

* Parameters:  WPARAM is the spell being cast (1 based)

### Logon (WM_USER+303)

Sent when a character logs into the game

* Parameters:  WPARAM is a character identifier (number value).

### Magery skill level (WM_USER+304)

Sent a few seconds after entering game and then whenever the skills window is opened or the skill level changes.

* Parameters: WPARAM is set to the whole number of the skill.  LPARAM is set to the tenth's.

### Current Int and Mana Level (WM_USER+305)

Sent whenever new information is sent from the server.

* Parameters: WPARAM has Intel and LPARAM has current mana level.

### Skill Level (WM_USER+306)

Sent a few seconds after entering the game and then whenever the skills window is opened or a skill level changes.

* Parameters: WPARAM is skillnum (0 based).  LPARAM is skill level * 10. Meaning if the skill is 19.4 you will get 194

### Macro Finished (WM_USER+307)

Send when a macro finishes playing through one pass.

### Logout (WM_USER+308)

Sent when a character logs out of the game.

### Current Max HP and HP Level (WM_USER+309)

Sent whenever new information is sent from the server.

* Parameters: WPARAM has Max HP and LPARAM has current hit point level. (NOTE this changed 8/2001 because of changes OSI made to how max hp are calculated [no longer str = max hp]).

### Current Dex and Stamina Level (WM_USER+310)

Sent whenever new information is sent from the server.

* Parameters: WPARAM has Dex and LPARAM has current stamina level.

### Add House/boat (WM_USER+311)  [You must set flag 1 to get this message]

Sent whenever a house comes into update range.

* Parameters:    WPARAM - X in the loword and Y in the hiword.  (x=LOWORD(wParam); y=HIWORD(wParam);)
                      LPARAM - house type

* Types:
    - 0x4000=small boat (n)
    - 0x4001=small boat (e)
    - 0x4002= small boat (s)
    - 0x4003=small boat (w)
    - 0x4004=small dragon boat (n)
    - 0x4005=small boat (e)
    - 0x4006=small boat (s)
    - 0x4007=small boat (w)
    - 0x4008=medium boat (n)
    - 0x4009=medium boat (e)
    - 0x400a=medium boat (s)
    - 0x400b=medium boat (w)
    - 0x400c=medium dragon boat (n)
    - 0x400d=medium boat (e)
    - 0x400e=medium boat (s)
    - 0x400f=medium boat (w)
    - 0x4010=large boat (n) 
    - 0x4011=large boat (e)
    - 0x4012=large boat (s)
    - 0x4013=large boat (w)
    - 0x4014=large dragon boat (n)
    - 0x4015=large boat (e)
    - 0x4016=large boat (s)
    - 0x4017=large boat (w)
    - 0x4064=small plaster
    - 0x4066=small field stone
    - 0x4068=small brick
    - 0x406a=small wood
    - 0x406c=small wood and plaster
    - 0x406e=small hut
    - 0x4070=blue tent
    - 0x4072=green tent
    - 0x4074=large house
    - 0x4076=two story (wood & plaster)
    - 0x4078=two story (plaster)
    - 0x407a=tower
    - 0x407c=keep
    - 0x407e=castle
    - 0x408c=generic shop
    - 0x4096=marble patio
    - 0x4098=small tower
    - 0x409a=log cabin
    - 0x409c=sandstone patio
    - 0x409e=villa
    - 0x40a0=stone shop
    - 0x40a2=marble shop
    - 0x5388=minax's fortress

### Delete House/Boat (WM_USER+312) [You must set flag 1 to get this message]

Sent when a boat moves or is dry docked or disappears (same with house)

* Parameters:    WPARAM - X in the loword and Y in the hiword.  (x=LOWORD(wParam); y=HIWORD(wParam);) LPARAM - house type

### Facet/land info (WM_USER+313) [You must set flag 1 to get this message]

Sent when the client receives information on which facet/world you are on.  This happens when you switch facets/worlds and can at other times as well

* Parameters:    WPARAM -  0 = Felucca  1 = Trammel  2 = Ilshenar

### Power hour entered (WM_USER+314)

!!! tip
    Not used by Razor

Sent when the client receives the 'You are in your power hour!' message.

================================================
FILE: help/mkdocs.yml
================================================
site_name: UO Razor - Ultima Online Assistant
site_description: UO Razor is a free tool designed to help with simple tasks while playing Ultima Online
site_author: Project maintained by Quick
site_url: https://www.razorce.com
copyright: Copyright &copy; 2023 Quick
repo_url: https://github.com/markdwags/Razor
repo_name: Razor
edit_uri: "tree/master/help/docs"
extra_css:
  - stylesheets/extra.css
nav:
- UO Razor Home: index.md
- Download: download.md
- Install:
    - Windows: install/windows.md
    - Linux: install/linux.md
- Release Notes: releasenotes.md
- Help Guide:
    - Help Overview: help/index.md    
    - General: help/general.md
    - Options: help/options.md    
    - Display/Counters: help/displaycounters.md
    - Arm/Dress: help/armdress.md
    - Skills: help/skills.md
    - Agents: help/agents.md
    - Filters: help/filters.md
    - Hot Keys: help/hotkeys.md
    - Macros: help/macros.md
    - Scripts: help/scripts.md
    - Friends: help/friends.md    
    - Screen Shots: help/screenshots.md
    - Advanced: help/advanced.md
- Scripting Guide:
    - Scripting Overview: guide/index.md
    - Commands: guide/commands.md
    - Comments: guide/comments.md
    - Expressions: guide/expressions.md
    - Keywords: guide/keywords.md
    - Layers: guide/layers.md
    - Variables: guide/variables.md
- More Information:
    - FAQ: faq.md
    - History: history.md
    - UOAssist API: uoaapi.md

theme: 
    name: material    
    custom_dir: overrides
    language: en    
    logo: images/razor.png
    favicon: images/razor.ico
    features:
        - navigation.top
        - navigation.instant
        - navigation.tracking
        - navigation.indexes
        - search.suggest
        - search.highlight
        - search.share
    icon:
        repo: fontawesome/brands/github
    palette:
        - media: "(prefers-color-scheme: dark)"
          scheme: slate
          primary: red
          accent: blue
          toggle:
            icon: material/weather-sunny
            name: Switch to light mode            
        - media: "(prefers-color-scheme: light)"
          scheme: default
          primary: red
          toggle:
            icon: material/weather-night
            name: Switch to dark mode
    font:
        #text: Mulish
        #text: Alata
        #text: Noto Sans JP
        #text: Lato
        #text: Ubuntu
        text: Titillium Web
        code: Fira Code

markdown_extensions:
  - admonition
  - toc:
      baselevel: 3    
      permalink: true    
  - pymdownx.highlight:
      linenums: true
      linenums_style: pymdownx.inline
  - pymdownx.inlinehilite
  - pymdownx.superfences
  - pymdownx.keys
  - pymdownx.tabbed:
      alternate_style: true
  - attr_list
  - pymdownx.details
  - meta

plugins:
  - search
  - git-revision-date-localized
  - social

extra:  
  social:
    - icon: fontawesome/brands/github
      link: https://github.com/markdwags/Razor
  analytics:
    provider: google
    property: G-9ER2MNGL02  
    feedback:
      title: Was this page helpful?
      ratings:
        - icon: material/emoticon-happy-outline
          name: This page was helpful
          data: 1
          note: >-
            Thanks for your feedback!
        - icon: material/emoticon-sad-outline
          name: This page could be improved
          data: 0
          note: >- 
            Thanks for your feedback! Help us improve this page by
            contributing to <a href="https://github.com/markdwags/Razor" target="_blank" rel="noopener">our repository</a>.


================================================
FILE: help/overrides/main.html
================================================

{% extends "base.html" %}

{% block extrahead %}
        
{% endblock %}


================================================
FILE: help/pygments.lexers.razor
================================================
"""
    pygments.lexers.razor
    ~~~~~~~~~~~~~~~~~~~~~~~~

    Lexers for languages related to the Razor UO assistant scripting language.

    :copyright: Copyright 2006-2022 by the Pygments team, see AUTHORS.
    :license: BSD, see LICENSE for details.
"""

import re
from bisect import bisect

from pygments.lexer import RegexLexer, bygroups, default, include, this, using
from pygments.lexers.python import PythonLexer
from pygments.token import Comment, Keyword, Name, Number, Operator, \
    Punctuation, String, Text, Whitespace

__all__ = ['RazorLexer']

class RazorLexer(RegexLexer):
    """
    Lexer for Razor script files.

    .. versionadded:: 2.14.0
    """
    name = 'RazorL'
    aliases = ['razor']
    filenames = ['*.razor']
    mimetypes = ['text/x-razor']
    flags = re.MULTILINE

    _python = r'py(?:t(?:h(?:o(?:n)?)?)?)?'

    tokens = {
        'root': [
            # Single-line comments
            (r'(#|\/\/).*$\n?', Comment.Single),

            # Strings
            (r'(\"[^\"]*\")|(\'[^\']*\')', String),

            # Hex values
            (r'0x[0-9a-fA-F]+', Number.Hex),

            # Numbers
            (r'\b\d+\b', Number),

            # Keywords
            (r'\b(if|elseif|else|endif|while|endwhile|for|foreach|endfor|break|continue|not|and|or|stop|replay|loop|as|in)\b', Keyword),

            # Command words
            (r'\b(clearhands|sell|cleardragdrop|attack|cast|dress|undress|dressconfig|target|targettype|targetloc|targetrelloc|dress|drop|waitfortarget|wft|dclick|dclicktype|dclickvar|usetype|useobject|droprelloc|lift|lifttype|waitforgump|gumpresponse|gumpclose|menu|menuresponse|waitformenu|promptresponse|waitforprompt|hotkey|say|msg|overhead|sysmsg|wait|pause|waitforstat|setability|setlasttarget|lasttarget|setvar|unsetvar|skill|useskill|walk|script|useonce|organizer|organize|org|restock|scav|scavenger|potion|clearsysmsg|clearjournal|whisper|yell|guild|alliance|emote|waitforsysmsg|wfsysmsg|clearall|virtue|interrupt|sound|music|classicuo|cuo|rename|getlabel|ignore|unignore|clearignore|cooldown|settimer|removetimer|createtimer|poplist|pushlist|removelist|createlist|clearlist)\b', Name.Builtin),

            # Layer words
            (r'\b(RightHand|LeftHand|Shoes|Pants|Shirt|Head|Gloves|Ring|Talisman|Neck|Hair|Waist|InnerTorso|Bracelet|FacialHair|MiddleTorso|Earrings|Arms|Cloak|Backpack|OuterTorso|OuterLegs|InnerLegs|backpack|true|false|criminal|enemy|friend|friendly|grey|gray|innocent|murderer|red|blue|nonfriendly|cancel|clear|minutes|minute|min|seconds|second|sec)\b', Name.Decorator),

            # Expression words
            (r'\b(queued|position|insysmsg|insysmessage|findtype|findbuff|finddebuff|stam|maxstam|hp|maxhp|maxhits|hits|mana|maxmana|str|dex|int|poisoned|hidden|mounted|rhandempty|lhandempty|skill|count|counter|weight|dead|closest|close|rand|random|next|prev|previous|human|humanoid|monster|varexist|varexist|followers|maxfollowers|maxweight|targetexists|diffmana|diffstam|diffhits|diffhp|diffweight|blessed|invul|invuln|warmode|name|paralyzed|itemcount|poplist|atlist|listexists|list|inlist|timer|timerexists)\b', Name.Function),

            # Default
            (r'.', Text),
        ]
    }
    


================================================
FILE: help/pygments.mapping.razor
================================================
# Automatically generated by scripts/gen_mapfiles.py.
# DO NOT EDIT BY HAND; run `tox -e mapfiles` instead.

LEXERS = {    
    'BashLexer': ('pygments.lexers.shell', 'Bash', ('bash', 'sh', 'ksh', 'zsh', 'shell'), ('*.sh', '*.ksh', '*.bash', '*.ebuild', '*.eclass', '*.exheres-0', '*.exlib', '*.zsh', '.bashrc', 'bashrc', '.bash_*', 'bash_*', 'zshrc', '.zshrc', '.kshrc', 'kshrc', 'PKGBUILD'), ('application/x-sh', 'application/x-shellscript', 'text/x-shellscript')),
    'JsonLexer': ('pygments.lexers.data', 'JSON', ('json', 'json-object'), ('*.json', 'Pipfile.lock'), ('application/json', 'application/json-object')),
    'RazorLexer': ('pygments.lexers.razor', 'RazorL', ('razor',), ('*.razor'), ('text/x-razor',)),        
    'CSharpLexer': ('pygments.lexers.dotnet', 'C#', ('csharp', 'c#', 'cs'), ('*.cs',), ('text/x-csharp',)),
    'XmlLexer': ('pygments.lexers.html', 'XML', ('xml',), ('*.xml', '*.xsl', '*.rss', '*.xslt', '*.xsd', '*.wsdl', '*.wsf'), ('text/xml', 'application/xml', 'image/svg+xml', 'application/rss+xml', 'application/atom+xml')),
}


================================================
FILE: help/pygments.styles.razor
================================================
"""
    pygments.styles.razor
    ~~~~~~~~~~~~~~~~~~~

    A highlighting style for Pygments, inspired by Razor UO.

    :copyright: Copyright 2006-2022 by the Pygments team, see AUTHORS.
    :license: BSD, see LICENSE for details.
"""

from pygments.style import Style
from pygments.token import Keyword, Name, Comment, String, Error, \
     Number, Operator, Generic, Whitespace, Token


class RazorStyle(Style):
    """
    Styles somewhat like UO razor assistant
    """

    background_color = "#000000"
    highlight_color = "#222222"

    styles = {
        Token:                     "#cccccc",
        Whitespace:                "",
        Comment:                   "#969696",
        Comment.Single:            "#969696",
        Comment.Preproc:           "",
        Comment.Special:           "bold #cd0000",

        Keyword:                   "#cdcd00",
        Keyword.Declaration:       "#00cd00",
        Keyword.Namespace:         "#cd00cd",
        Keyword.Pseudo:            "",
        Keyword.Type:              "#00cd00",

        Operator:                  "#3399cc",
        Operator.Word:             "#cdcd00",

        Name:                      "",
        Name.Class:                "#00cdcd",
        Name.Builtin:              "#2B90AF",
        Name.Exception:            "bold #666699",
        Name.Variable:             "#00cdcd",

        String:                    "#B5F109",
        Number:                    "#AE81FF",
        Number.Hex:                "#F9254D",

        Generic.Heading:           "bold #000080",
        Generic.Subheading:        "bold #800080",
        Generic.Deleted:           "#cd0000",
        Generic.Inserted:          "#00cd00",
        Generic.Error:             "#FF0000",
        Generic.Emph:              "italic",
        Generic.Strong:            "bold",
        Generic.Prompt:            "bold #000080",
        Generic.Output:            "#888",
        Generic.Traceback:         "#04D",

        Error:                     "border:#FF0000"
    }