Installing Elder Scrolls Online Addons Effectively

Compatibility and Conflict Management in Elder Scrolls Online Addon Systems

Root Causes of Addon Conflicts

Common conflict scenarios:

Diagnostic Tools for Conflict Identification

1. ESO In-Game Console Commands The `/console` command provides real-time feedback on addon loading errors, Lua script failures, and API version mismatches. Key commands include:

   /console listaddons – Displays loaded addons and their status (enabled/disabled).
   /console addon – Toggles an addon to test for conflicts.
   /console log – Filters the chat log for errors (e.g., "LUA_ERROR").

   Use case: Immediate identification of addons failing to load or triggering errors during startup.
2. ESO Log Files (ESOLogs.txt) Located in `%LocalAppData%\ESO\Live\Logs`, this file records detailed script execution logs, including stack traces for Lua errors. Use a text editor with search functionality (e.g., Notepad++) to filter for:

   "Interface\\AddOns\\" – Paths to problematic addons.
   "attempt to call a nil value" – Common error for missing dependencies.
   "version mismatch" – API or addon version conflicts.

   Use case: Post-crash analysis to pinpoint the exact line of code causing failures.
3. Third-Party Log Analyzers (e.g., ESOUI Log Parser) Specialized tools like the ESOUI GitHub repository’s log parser automate error detection by parsing `ESOLogs.txt` for patterns indicative of conflicts. These tools often highlight:
   • Duplicate event registrations.
   • Unresolved LibStub dependencies.
   • Deprecated API calls.
   Use case: Large-scale addon setups where manual log review is impractical.
4. Mod Managers (e.g., ESO Mod Manager, ESOUI Mod Manager) These tools provide visual conflict warnings, such as:
   • Version compatibility alerts (e.g., "Addon X requires ESO Patch 1.12.0").
   • Dependency graphs showing circular references between addons.
   • Load order suggestions based on community-reported stability.
   Use case: Pre-installation checks to avoid known conflicts.
5. Manual Inspection via Lua Debugger Advanced users can attach a debugger (e.g., Lua Debugger) to the ESO process to step through addon initialization. This reveals:
   • Race conditions in event handlers.
   • Memory leaks from unclosed file handles.
   • Global variable collisions.
   Use case: Custom addon development or resolving obscure conflicts.

Strategies for Addon Prioritization and Load Order

1. Dependency-Based Load Order Addons with hard dependencies (e.g., `LibStub` libraries) must load before dependent addons. Example:

   • Libraries (e.g., `LibAddonMenu-2.0`, `LibCustomTweaks-1.0`) → Load first.
   • Core functionality addons (e.g., `WeakAuras`, `UnitFrames`) → Load second.
   • UI overlays (e.g., `MinimapOverlays`, `BuffTrackers`) → Load last.

   Implementation: Use `ESO_AddOns.toc` files to define dependencies via `## DependsOn:` or `## OptionalDependsOn:` directives.
2. Conditional Activation via Profiles ESO’s built-in profile system allows disabling addons per character or zone. Strategies include:
   • Zone-specific toggles: Disable `DungeonTools` in open-world zones where they’re unnecessary.
   • Role-based activation: Enable `HealerAuras` only for healing builds.
   • Conflict mitigation: Disable `AddonA` in profiles where `AddonB` (a known conflict) is active.
   Tools: Use `/console profile ` to create and switch profiles, or third-party tools like ProfileManager.
3. Load Order Overrides Mod managers (e.g., ESO Mod Manager) allow manual load order adjustments. Best practices:
   • Place critical addons (e.g., `WeakAuras`) early in the list.
   • Group UI-heavy addons (e.g., `ActionBarOverlays`) together to minimize rendering conflicts.
   • Avoid placing experimental addons before stable ones to contain fallout.
   Warning: Incorrect load order can cause silent failures (e.g., an addon assuming another is already loaded).
4. Testing Stability Post-Installation A structured testing approach ensures conflicts are caught early:
   1. Incremental Loading: Add one addon at a time and verify functionality.
   2. Stress Testing: Perform actions that trigger conflicts (e.g., opening menus, casting spells) repeatedly.
   3. Log Monitoring: Use `/console log LUA_ERROR` during testing to catch latent issues.
   4. Character Rotation: Test across multiple characters to identify profile-specific conflicts.

Structuring Addon Folders to Minimize Conflicts

1. Root Folder: `Interface\Add

   Advanced Customization: Modifying and Creating ESO Addons

   The Elder Scrolls Online (ESO) addon system extends functionality through Lua scripting, enabling players to tailor the interface to their needs. Advanced customization involves leveraging ESO’s Lua environment, native APIs, and third-party libraries to create or modify addons. This section explores the technical foundations of ESO’s scripting model, provides a structured template for a basic addon, and compares built-in APIs with community-driven frameworks to optimize development workflows.
   

   ESO’s Lua Scripting Environment and Core Functions

   ESO’s addon scripting relies on a modified Lua 5.1 environment, with restrictions to ensure stability and security. Key mechanisms include hook-based event handling, secure handlers for UI interactions, and memory management via weak references. The following functions form the backbone of addon development:

   - `hooksecurefunc`: Attaches a function to an existing API call without replacing it, preserving original behavior while injecting custom logic.
   ```lua
   -- Example: Log player combat damage dealt
   hooksecurefunc("CombatLogForPlayer", function(event, ...)
   local _, _, _, _, _, _, _, _, _, damage = CombatLogGetCurrentEventInfo();
   if event == "SWING_DAMAGED" then
   DEFAULT_CHAT_FRAME:AddMessage("Dealt " .. damage .. " damage.");
   end
   end);
   ```

   - `SECUREHANDLER_*`: Secure handlers (e.g., `SECUREHANDLER_SCRIPT`) execute scripts in a sandboxed environment, preventing UI exploits. Critical for actions like casting spells or opening menus.
   ```lua
   -- Example: Secure handler for a macro button
   local function OnClick()
   CastSpellByName("Restoration");
   end
   SecureHandlerScript(1, "OnClick", OnClick);
   ```

   - Event Triggers: ESO exposes events like `PLAYER_LOGIN`, `COMBAT_LOG_EVENT_UNFILTERED`, and `UNIT_HEALTH` via the `EventRegistry` system. Events are registered with:
   ```lua
   EventRegistry:RegisterCallback("PLAYER_LOGIN", function()
   print("Player logged in. Initializing addon...");
   end);
   ```

   Context: These functions enable non-intrusive modifications to ESO’s core systems. `hooksecurefunc` ensures backward compatibility, while `SECUREHANDLER_*` guarantees security for user-triggered actions. Event triggers provide real-time data access without polling.
   

   Template for a Simple Addon: Health Bar Overlay

   Below is a minimal addon template for a floating health bar overlay, annotated to illustrate key components. This example uses ESO’s native APIs and adheres to best practices for performance and maintainability.

   ```lua
   -- File: HealthBarOverlay.lua
   -- Description: Displays a floating health bar for the target unit.

   local addonName, addon = ...
   local frame = CreateFrame("Frame", "HealthBarOverlayFrame", UIParent);
   frame:SetPoint("CENTER", 0, 0); -- Position relative to UIParent

   -- Health bar texture and status bar
   local healthBar = CreateFrame("StatusBar", "HealthBarOverlayStatusBar", frame);
   healthBar:SetSize(200, 20);
   healthBar:SetStatusBarTexture("Interface\\AddOns\\UI_SquareTextures\\StatusBar.tga");
   healthBar:SetStatusBarColor(0, 1, 0); -- Green

   -- Update health bar based on target unit
   local function UpdateHealthBar()
   local unit = "target";
   local health, maxHealth = UnitHealth(unit), UnitHealthMax(unit);
   local healthPercent = (health / maxHealth) or 0;
   healthBar:SetValue(healthPercent);
   healthBar:SetStatusBarColor(healthPercent > 0.3 and 0 or 1, 1, 0); -- Color gradient
   end

   -- Register event handlers
   EventRegistry:RegisterCallback("PLAYER_TARGET_CHANGED", UpdateHealthBar);
   EventRegistry:RegisterCallback("UNIT_HEALTH", function(_, unit)
   if unit == "target" then UpdateHealthBar(); end
   end);

   -- Initialize on addon load
   function addon:OnInitialize()
   UpdateHealthBar(); -- Set initial state
   end
   ```

   Key Components:
   1. Frame Creation: The overlay is anchored to `UIParent` with `CreateFrame`.
   2. StatusBar: Uses ESO’s built-in textures and color gradients for visual feedback.
   3. Event Binding: `PLAYER_TARGET_CHANGED` and `UNIT_HEALTH` events dynamically update the bar.
   4. Modularity: The `UpdateHealthBar` function encapsulates logic for reusability.

   Best Practices:
   

2. Avoid global variables; scope functions within the addon namespace (`addonName`).
3. Use `EventRegistry` for efficient event handling instead of polling.
4. Leverage ESO’s native textures (`StatusBar.tga`) for consistency.

Modular Addon Development with LibStub and Ace3

Third-party libraries like LibStub (for library loading) and Ace3 (for modular frameworks) streamline addon development by providing reusable components. Below is a comparison of their roles and integration methods.

LibStub: A lightweight library loader that ensures dependencies are initialized before use. Example:
```lua
-- Load LibStub and a hypothetical library (e.g., LibDataBroker)
local LibStub = LibStub;
local LibDataBroker = LibStub:GetLibrary("LibDataBroker-1.0");
if not LibDataBroker then
error("LibDataBroker-1.0 is required but not found.");
end
```

Ace3 Frameworks: Ace3 offers modules for common tasks, such as:


5. AceEvent-3.0: Simplifies event handling with a unified API.
6. AceGUI-3.0: Provides pre-built UI widgets (e.g., sliders, buttons).
7. AceSerializer-3.0: Manages configuration data persistence.

Integration Example:
```lua
-- Using AceEvent for event registration
local AceEvent = LibStub:GetLibrary("AceEvent-3.0");
AceEvent:RegisterEvent("PLAYER_LOGIN", function()
print("AceEvent: Player logged in.");
end);
```

Use Cases:


8. LibStub: Essential for addons with dependencies (e.g., data providers like LibDataBroker).
9. Ace3: Ideal for complex UIs or settings menus (e.g., AceConfig-3.0 for configuration panels).

Limitations:


10. LibStub: Requires manual library installation via ESO’s addon manager.
11. Ace3: Adds overhead (~100KB) and may conflict with ESO’s UI updates if misused.

Comparison: Native ESO APIs vs. Community Libraries

The following table contrasts ESO’s built-in APIs with third-party libraries, highlighting use cases and trade-offs.


Feature	Native ESO APIs	Community Libraries (e.g., LibStub, Ace3)
Purpose	Core functionality (events, UI elements).	Extended features (modularity, data handling).
Use Cases	Event registration, frame creation.	Configuration panels, data brokering, UI widgets.
Performance	Optimized for ESO; minimal overhead.	Additional memory usage; may introduce lag.
Security	Sandboxed via `SECUREHANDLER_*`.	Depends on library implementation (e.g., Ace3 uses LuaJIT).
Maintenance	Updated with ESO patches.	Requires manual updates; risk of abandonment.
Example Libraries	`EventRegistry`, `CreateFrame`.	LibDataBroker, AceGUI, LibStub.
Limitations	Limited to ESO’s exposed APIs.	Potential conflicts with ESO’s UI system.

Key Insight:
Native APIs are preferred for performance-critical tasks (e.g., combat logs), while libraries excel in modularity (e.g., settings menus). Always test library compatibility with ESO updates, as community tools may lag behind official changes.

Performance Optimization and Addon Efficiency in The Elder Scrolls Online

Efficient addon management is critical for maintaining smooth gameplay in The Elder Scrolls Online (ESO), where poorly optimized scripts can degrade performance through memory leaks, excessive CPU usage, or unnecessary draw calls. Benchmarking reveals that unoptimized addons—particularly those with aggressive event hooks or unmanaged resource loading—can reduce FPS by 10–30% in high-population zones or during combat. This section examines the technical and practical measures to mitigate these issues, including script optimization, performance monitoring, and strategic addon replacement.

Performance degradation in ESO addons typically stems from three primary inefficiencies: unbound event listeners, redundant rendering operations, and unmanaged resource allocation. Event hooks, for instance, may persist even after their intended use, accumulating overhead with each game loop iteration. Similarly, addons that load textures, models, or UI elements without lazy-loading mechanisms force the client to process assets prematurely, increasing memory footprint. Below, structured techniques address these challenges while preserving functionality.


Performance Impact of Poorly Optimized Addons

The most common performance offenders in ESO addons fall into categories defined by their operational scope and resource consumption. Memory leaks occur when addons fail to release references to objects (e.g., Lua tables, event handlers) after they are no longer needed. CPU spikes are often tied to frequent event callbacks or inefficient loops, particularly in addons that monitor player actions or NPC interactions in real time. FPS drops correlate with excessive draw calls, where overlays or HUD modifications render unnecessary elements outside the viewport or during critical gameplay moments.

Benchmark data from community tests (e.g., using ESOUI Benchmark Tool or RTSS) indicates that:


12. Addons with >50 active event hooks can increase CPU usage by 15–25% during combat.
13. Unoptimized UI scaling (e.g., dynamic resizing without caching) may trigger 20–40 additional draw calls per second.
14. Texture-heavy overlays (e.g., unoptimized minimaps or radar systems) can consume 100–300MB of VRAM if not managed via lazy-loading.

Below is a table summarizing key offenders and their typical impact:


Addon Type	Primary Performance Issue	Measurable Impact	Example Addons
Combat Log Parsers	Unbound event listeners for combat events	CPU usage spikes during PvE/PvM (10–20%)	CombatText, WeakAuras (ESO)
Dynamic UI Scalers	Frequent recalculations of anchor points	FPS drops in high-action zones (5–15%)	UIScale, BetterUI
Minimap/Overlay Mods	Uncached texture rendering	VRAM bloat (100–300MB), occasional stuttering	RadarMap, WorldMapPlus
Automation Scripts	Polling loops for player state	CPU throttling during idle moments (5–10%)	AutoLoot, SkillQueue

Script Optimization Techniques

Optimizing addon scripts requires a combination of event management, resource deferral, and algorithm efficiency. The following techniques address the most common bottlenecks:

Minimizing Event Hooks
Event listeners are a primary source of CPU overhead. Addons should:


15. Use weak references for event handlers to allow garbage collection when unused.
16. Implement conditional event binding, where hooks are only active during specific game states (e.g., combat, crafting).
17. Replace frequent `EVENT_PLAYER_ACTIVATED` checks with state flags (e.g., `IsInCombat`) to reduce polling.

Lazy-Loading Resources
Deferring non-critical asset loading until necessary reduces initial memory usage. Strategies include:


18. Dynamic texture loading: Load minimap textures or fonts only when the addon’s UI is visible.
19. On-demand UI rendering: Hide complex overlays by default and reveal them via user triggers (e.g., `/addon toggle`).
20. Asset pooling: Reuse textures or models across multiple addons to avoid redundant VRAM allocation.

Reducing Draw Calls
Excessive rendering operations directly impact FPS. Mitigation includes:


21. Viewport culling: Disable off-screen UI elements using `GetScreenRect()` checks.
22. Layer consolidation: Combine multiple transparent overlays into a single texture atlas.
23. Frame rate synchronization: Throttle animations or updates to align with ESO’s render loop (e.g., `60 FPS cap` for non-critical UI).

Code-Level Optimizations
Lua performance in ESO is influenced by:


24. Avoiding global variables: Localize variables within functions to reduce lookup time.
25. Using tables efficiently: Pre-allocate array sizes and avoid sparse tables for iterative operations.
26. Minimizing string operations: Concatenate strings in bulk rather than per-frame (e.g., `table.concat` for log messages).

Critical Note: Always test optimizations in low-end hardware configurations (e.g., integrated graphics) to ensure broad compatibility. Some "optimizations" (e.g., aggressive event unbinding) may introduce instability if not handled gracefully.

Monitoring Addon Performance

Effective performance monitoring combines in-game tools and external utilities to isolate addon-specific issues. Below are the most reliable methods:

In-Game Monitoring
ESO provides built-in metrics for basic diagnostics:


27. FPS Counter: Enable via `Settings > Display > Show FPS` to identify frame rate drops during addon interactions.
28. Task Manager: Accessible via `/taskmanager` (default key: `Ctrl+Shift+T`) to track CPU/GPU usage per process. Compare values with addons enabled/disabled.
29. Memory Usage: Monitor via `Settings > Performance > Memory Usage` (though granular addon tracking requires external tools).

External Software
For deeper analysis, use specialized tools:


30. Process Explorer (Microsoft Sysinternals): Tracks ESO’s memory and handle leaks in real time. Look for abnormally high `GDI Objects` or `Thread Count` when addons are active.
31. GPU-Z/MSI Afterburner: Measures VRAM usage and GPU utilization during addon-heavy scenes (e.g., dungeons). Spikes in Texture Memory often indicate unoptimized overlays.
32. Lua Profiler Addons: Tools like ESO Profiler (third-party) inject Lua performance metrics to identify slow functions.

Benchmarking Workflow
1. Baseline Measurement: Record FPS, CPU, and VRAM usage with all addons disabled.
2. Incremental Testing: Enable addons one by one and retest. Note the largest deviations from the baseline.
3. Stress Testing: Perform actions that trigger addon events (e.g., crafting, combat) and observe spikes in task manager.


Disabling or Replacing Resource-Heavy Addons

When an addon cannot be optimized further, replacement or selective disabling is necessary. Below are function-preserving alternatives for common offenders, categorized by use case:

Combat and Log Parsers


33. Original Addon: CombatText (high CPU usage due to event hooks)
34. Replacement: CombatLogParser (lighter, uses Lua tables for buffering)
35. Alternative: WeakAuras (ESO fork) with event throttling enabled

UI Scaling and Layout


36. Original Addon: BetterUI (dynamic resizing causes draw call overhead)
37. Replacement: UIScale (static scaling, lower CPU footprint)
38. Alternative: LibSharedMedia (for font/texture optimization)

Minimap and Overlay Systems


39. Original Addon: RadarMap (uncached textures, high VRAM usage)
40. Replacement: MinimapPlus (lazy-loaded textures, atlas support)
41. Alternative: WorldMapPlus (disable "dynamic zoom" feature)

Automation Scripts


42. Original Addon: AutoLoot (polling loops increase CPU usage)
43. Replacement: LootFilter (event-driven, no active polling)

Community Resources and Best Practices for Addon Development in The Elder Scrolls Online

The Elder Scrolls Online (ESO) addon development thrives on collaboration, open-source contributions, and adherence to best practices that ensure functionality, security, and compliance. Developers and users rely on centralized repositories, structured documentation, and ethical guidelines to maintain a sustainable ecosystem. This section explores official and unofficial platforms for sharing addons, methods for contributing to open-source projects, and standards for documentation and versioning. Ethical considerations are emphasized to uphold the integrity of the community and ZeniMax Media’s Terms of Service (ToS).


Official and Unofficial Repositories for ESO Addons

Addons for The Elder Scrolls Online are distributed across multiple repositories, each serving distinct purposes such as official support, community-driven development, or archival. Understanding these platforms ensures developers and users access reliable, up-to-date resources.

• ESOUI (Official Repository)
  The primary hub for ESO addons, maintained by ZeniMax Media. It hosts addons directly integrated with the game client, often updated alongside patches. Accessible via the in-game Addon Manager or the official ESOUI website.

  Note: Addons from ESOUI are pre-approved for compatibility and security, reducing risks of conflicts or malware.

• Nexus Mods (Community-Driven)
  A widely used platform for user-submitted addons, featuring categories for ESO, detailed forums, and version history tracking. Nexus Mods allows developers to monetize addons via optional donations or premium memberships. Compatibility is user-reported, requiring manual verification.

  Warning: While Nexus Mods hosts verified addons, third-party submissions may lack official scrutiny. Always review changelogs and user feedback.

• GitHub (Open-Source Development)
  Preferred for collaborative projects, GitHub hosts repositories for addons with active development cycles, including forks, pull requests, and issue tracking. Many popular addons (e.g., Deadly Boss Mods, Unit Frames) originate here. Developers use GitHub for version control, documentation, and community feedback.

  Best Practice: Star or watch repositories to stay updated on new releases and security patches.

• CurseForge (Alternative Community Hub)
  Similar to Nexus Mods, CurseForge provides a structured environment for addon distribution, with features like automatic updates and mod manager integration. Less centralized than Nexus Mods but growing in popularity for niche addons.
• Archival and Legacy Repositories
  Some older or abandoned addons may reside on forums (e.g., ESO Forums, ESO Insider) or personal websites. These sources lack official support and may pose compatibility risks with newer ESO updates.

  Recommendation: Prioritize repositories with active moderation (e.g., ESOUI, GitHub) to minimize risks.

Contributing to Open-Source ESO Addon Projects

Open-source addon development relies on community contributions, including code reviews, bug fixes, and documentation improvements. GitHub and similar platforms streamline collaboration through standardized workflows. Below are key practices for effective contributions.

• Forking and Cloning Repositories
  To contribute, fork the original repository to your GitHub account, then clone the fork locally using:

  git clone https://github.com/your-username/repository-name.git

  This creates a working copy where changes can be tested before submission.

• Code Reviews and Pull Requests (PRs)
  Submit changes via pull requests, adhering to the repository’s CONTRIBUTING.md guidelines. PRs should:
  • Include a clear title and description explaining the purpose of changes.
  • Reference relevant issues or feature requests (e.g., "Fixes #42").
  • Follow the project’s coding standards (e.g., indentation, naming conventions).

  Example PR Description: "Add support for ESO Patch 6.4.0 by updating the /combatlog handler to include new spell IDs. Tested on Retail and PTR environments."

• Testing and Quality Assurance
  Test changes across multiple ESO versions (Retail, PTR) and configurations (e.g., UI scaling, addon conflicts). Document edge cases or limitations in the PR description.

  Critical Note: Never submit untested code that may break existing functionality or violate ESO’s ToS.

• Documentation Updates
  Maintain or improve project documentation, including:
  • README files (installation instructions, dependencies).
  • Wiki pages (advanced usage, troubleshooting).
  • Changelogs (version history, breaking changes).
  Use Markdown formatting for consistency and readability.
• Licensing and Attribution
  Respect the original project’s license (e.g., MIT, GPL). Credit contributors and original authors in the code and documentation. Avoid relicensing without explicit permission.

Writing Clear Addon Descriptions, Versioning, and Changelogs

Discoverability and maintainability depend on structured metadata, versioning schemes, and transparent changelogs. These elements help users and developers assess compatibility, dependencies, and updates efficiently.

• Addon Descriptions
  A well-written description should include:
  • Purpose: Concise explanation of the addon’s core functionality (e.g., "A unit frame mod for tracking raid debuffs in real-time").
  • Features: Bullet-point list of key functionalities (e.g., customizable frames, threat meter integration).
  • Dependencies: Required addons or libraries (e.g., LibStub, CallbackHandler-1.0).
  • Compatibility: ESO versions, UI scales, and known conflicts (e.g., "Tested on 6.3.0–6.4.0; may conflict with X addon").
  • Screenshots: Visual examples of the addon in action (hosted on Imgur or similar services).

  Example Description Snippet: "Deadly Boss Mods (DBM) – A warning system for raid bosses and dungeons. Features cooldown tracking, health bars, and boss-specific timers. Requires LibStub and CallbackHandler-1.0. Compatible with ESO 6.2.0+. Known conflict with WeakAuras due to overlapping triggers."

• Versioning Schemes
  Follow semantic versioning (SemVer) for clarity:
  • MAJOR.MINOR.PATCH (e.g., 3.2.1)
  • MAJOR: Breaking changes (e.g., API updates).
  • MINOR: New features or improvements.
  • PATCH: Bug fixes or minor tweaks.

  Example Version Bump: v2.1.0 → v3.0.0: "Dropped support for ESO 6.0.0; requires LibStub 2.0."

• Changelogs
  Maintain a changelog file (e.g., CHANGELOG.md) with entries formatted as:

  ## [3.2.1] – 2024-03-15
  

  Added

• Support for new ESO Patch 6.4.0 abilities.

### Fixed


• Resolved crash when using with Unit Frames 1.5.0.

### Removed


• Legacy Lua 5.1 compatibility (ESO now uses Lua 5.4).

Include dates, contributor names (if applicable), and links to related PRs or issues.

• Metadata Standards
  For repositories, include a metadata.json or addon.xml file with standardized fields:

  <

  Mastering the installation and customization of The Elder Scrolls Online addons empowers players to tailor their gaming experience to precise preferences, whether through enhanced combat tools, streamlined user interfaces, or automated efficiency features. By systematically addressing compatibility issues, optimizing performance, and engaging with the broader developer community, users can ensure a stable and enriched gameplay environment. This guide serves as a comprehensive reference for navigating the technical and creative dimensions of ESO addons, fostering both individual productivity and collaborative innovation within the modding ecosystem.