Agent skill

Mysql Slow Query Diagnose

by openocta in openocta/openocta_skills

Slow query diagnosis with root cause analysis and index optimization recommendations.

MITAuto-check passedDatabases

Install Mysql Slow Query Diagnose

skills CLI
$ npx skills add openocta/openocta_skills --skill mysql-slow-query-diagnose -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install openocta/openocta_skills mysql-slow-query-diagnose --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/openocta/openocta_skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/mysql-slow-query-diagnose .claude/skills/mysql-slow-query-diagnose && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
mysql-slow-query-diagnose
GitHub stars
167
Token cost
~2.7k tokens
SKILL.md length
600 words
Files
3
Skills in repo
8
Repo updated
First seen
Licence
MIT

At a glance

Slow query diagnosis with root cause analysis and index optimization recommendations.

  • Works in 4 steps: Collect Slow Queries → Analyze Each Top Query → Calculate Efficiency Metrics → …
  • Tasks that involve Query optimization
  • SKILL.md covers Overview, When to Use, Required MCP Server and Diagnostic Workflow, plus 4 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Mysql Slow Query Diagnose is an agent skill from openocta/openocta_skills. Slow query diagnosis with root cause analysis and index optimization recommendations. Identifies TOP N slow queries, analyzes scan efficiency, calculates index hit rate, and suggests covering indexes — turning a 20-minute manual diagnosis into 8 seconds.

Its SKILL.md is about 2.7k tokens, which your agent loads only when the skill is triggered. The skill folder holds 2 other files (for example `README.md` and `mate.json`).

It sits in Databases, covering Query optimization. It works with MySQL. The repository describes itself as: 本仓库用于汇集第三方贡献的 OpenOcta 技能(Skill)资源,便于分享、版本管理与分发。 The licence is MIT.

When your agent uses it

  • Tasks that involve Query optimization

Example prompts

  • “/mysql-slow-query-diagnose”

Requirements

  • Pre-approved tools (allowed-tools): db_query, db_get_slow_log, db_describe_table, db_get_status

Workflow steps

4 steps, taken from the step headings in SKILL.md.

  1. Collect Slow Queries
  2. Analyze Each Top Query
  3. Calculate Efficiency Metrics
  4. Generate Index Recommendations

What it can do on your machine

Read from SKILL.md and the folder at commit 6ac4479. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • db_query
    • db_get_slow_log
    • db_describe_table
    • db_get_status

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are sql).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Mysql Slow Query Diagnose loads about 2.7k tokens when it runs. Until then it costs about 70 tokens; SKILL.md has 600 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~70
When it runs · the whole SKILL.md, loaded when a task matches
~2.7k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from openocta/openocta_skills at commit 6ac4479, republished under its MIT licence (© openocta). 600 words, ~2,748 tokens.

Download SKILL.mdSave it as .claude/skills/mysql-slow-query-diagnose/SKILL.md (or your agent's skills folder). This skill also uses 2 other files; get the full folder from GitHub.
name
mysql-slow-query-diagnose
description
Slow query diagnosis with root cause analysis and index optimization recommendations. Identifies TOP N slow queries, analyzes scan efficiency, calculates index hit rate, and suggests covering indexes — turning a 20-minute manual diagnosis into 8 seconds.
allowed-tools
db_query, db_get_slow_log, db_describe_table, db_get_status
version
1.0.0

MySQL Slow Query Diagnose (Diagnosis + Optimization)

Overview

Slow queries are the #1 cause of database performance degradation. This skill goes beyond simply listing slow queries — it performs root cause analysis for each one: how many rows scanned vs returned, which index was used (or missed), and what index to add to fix it.

Key capabilities:

  • Identify TOP N slow queries by execution time, lock time, or scan rows
  • Calculate index hit rate (rows_examined / rows_sent) — the key metric for query efficiency
  • Analyze EXPLAIN plans to identify full table scans, filesort, temporary tables
  • Suggest covering indexes with estimated improvement
  • Output a prioritized action list sorted by impact

Real-world result: A DBA team reduced average slow query resolution from 20 minutes to 8.3 seconds — 144x improvement — by having AI perform the diagnosis automatically.

When to Use

Apply this skill when:

  • Database response time suddenly increases
  • Application reports query timeouts
  • Monitoring shows slow query count spike
  • Periodic performance review / health check
  • After schema changes to verify query performance
  • Developer asks "why is this query slow?"

Required MCP Server

ToolPurposeExample
db_queryRun diagnostics and EXPLAINdb_query("EXPLAIN SELECT ...")
db_get_slow_logRetrieve slow query entriesdb_get_slow_log(hours=1, limit=20)
db_describe_tableCheck table indexesdb_describe_table("orders")
db_get_statusGet performance countersdb_get_status("Slow_queries")
Required MySQL Privileges
  • SELECT on mysql.slow_log or performance_schema.events_statements_summary_by_digest
  • PROCESS — for EXPLAIN on other sessions' queries

Diagnostic Workflow

Step 1: Collect Slow Queries
sql
-- Option A: MySQL 5.7+ performance_schema (recommended)
SELECT
  DIGEST_TEXT AS sql_template,
  COUNT_STAR AS exec_count,
  ROUND(SUM_TIMER_WAIT / 1000000000000, 3) AS total_time_sec,
  ROUND(AVG_TIMER_WAIT / 1000000000000, 3) AS avg_time_sec,
  ROUND(MAX_TIMER_WAIT / 1000000000000, 3) AS max_time_sec,
  ROUND(SUM_ROWS_EXAMINED / COUNT_STAR, 0) AS avg_rows_examined,
  ROUND(SUM_ROWS_SENT / COUNT_STAR, 0) AS avg_rows_sent,
  SUM_NO_INDEX_USED AS no_index_count
FROM performance_schema.events_statements_summary_by_digest
WHERE DIGEST_TEXT IS NOT NULL
  AND SUM_TIMER_WAIT > 0
ORDER BY SUM_TIMER_WAIT DESC
LIMIT 20;

-- Option B: slow_log table (if enabled)
SELECT
  start_time,
  user_host,
  query_time,
  lock_time,
  rows_sent,
  rows_examined,
  LEFT(sql_text, 300) AS sql_fragment
FROM mysql.slow_log
WHERE start_time > DATE_SUB(NOW(), INTERVAL 1 HOUR)
ORDER BY query_time DESC
LIMIT 20;

Also check overall slow query status:

sql
SHOW GLOBAL STATUS LIKE 'Slow_queries';
SHOW GLOBAL STATUS LIKE 'Slow_launch_threads';
SHOW VARIABLES LIKE 'long_query_time';
SHOW VARIABLES LIKE 'slow_query_log';
Step 2: Analyze Each Top Query

For each slow query identified, run:

sql
-- Get the EXPLAIN plan
EXPLAIN FORMAT=JSON {the_query};

-- Check current table indexes
SHOW INDEX FROM {table_name};

-- Check table size and row count
SELECT
  TABLE_NAME,
  TABLE_ROWS,
  ROUND(DATA_LENGTH / 1024 / 1024, 2) AS data_mb,
  ROUND(INDEX_LENGTH / 1024 / 1024, 2) AS index_mb
FROM information_schema.TABLES
WHERE TABLE_SCHEMA = '{db}' AND TABLE_NAME = '{table}';
Step 3: Calculate Efficiency Metrics

For each query, compute:

MetricFormulaInterpretation
Index Hit Raterows_sent / rows_examined × 100%<1% = severe index miss
Scan Efficiencyrows_examined / table_rows>50% = nearly full scan
Lock Ratiolock_time / query_time × 100%>30% = lock contention
Exec FrequencyCOUNT_STAR from digestHigh + slow = critical

Classification:

IF index_hit_rate < 1% AND no_index_used:
  → Type: MISSING_INDEX (Critical)
  → Action: Add index
ELSE IF scan_efficiency > 50%:
  → Type: FULL_SCAN (High)
  → Action: Optimize query or add covering index
ELSE IF lock_ratio > 30%:
  → Type: LOCK_CONTENTION (Medium)
  → Action: Check concurrent transactions
ELSE IF avg_time > threshold:
  → Type: DATA_VOLUME (Medium)
  → Action: Archive or partition
Step 4: Generate Index Recommendations

For each missing index case, suggest:

sql
-- Example: query is SELECT * FROM orders WHERE status = ? AND create_time > ?
-- Current: full table scan, 12M rows examined, 380 rows returned
-- Index hit rate: 380/12800000 = 0.003% → CRITICAL

-- Recommended index:
ALTER TABLE orders ADD INDEX idx_status_createtime (status, create_time);

-- Expected improvement:
-- rows_examined: 12,000,000 → ~40,000 (300x reduction)
-- query_time: 23.7s → <0.1s

Index design rules:

  1. Equality first — columns with = condition go first in composite index
  2. Range last — columns with >, <, BETWEEN go last
  3. Covering index — if possible, include all SELECT columns to avoid table lookup
  4. Order matters — (status, create_time) ≠ (create_time, status)

Output Templates

Initial Report
🔍 MySQL Slow Query Diagnostic Report
══════════════════════════════════════
📋 Instance: {host}:{port}
   Analysis Period: Last {hours} hours
   Slow Query Threshold: {threshold}s
   Total Slow Queries: {count}

🔴 TOP {N} Slow Queries (by total impact)
─────────────────────────────────────────

  TOP 1 ⚡ Total Impact: {total_time}s across {count} executions
  ┌─────────────────────────────────────────────┐
  │ SQL: {sql_template}                         │
  │ Avg Time: {avg}s  |  Max: {max}s            │
  │ Rows Examined: {examined}  |  Returned: {sent}│
  │ Index Hit Rate: {rate}% 🔴 MISSING INDEX     │
  │                                             │
  │ Root Cause: Full table scan on {table}       │
  │   → No index on ({columns})                 │
  │                                             │
  │ ✅ Recommended:                              │
  │   ALTER TABLE {table} ADD INDEX              │
  │     idx_{name} ({columns});                  │
  │   Expected: {current}s → <0.1s              │
  └─────────────────────────────────────────────┘

  TOP 2 ⚡ ...
  TOP 3 ⚡ ...

📊 Summary
  | Rank | SQL Pattern | Executions | Avg Time | Hit Rate | Fix |
  |------|------------|------------|----------|----------|-----|
  | 1    | {pattern}  | {count}    | {time}s  | {rate}%  | Add index |
  | 2    | ...        | ...        | ...      | ...      | ... |

⚡ Priority Actions
  1. [Critical] Add index on {table}({cols}) — fixes TOP 1, est. 300x speedup
  2. [High] Add index on {table}({cols}) — fixes TOP 2
  3. [Medium] Schedule batch query for off-peak — TOP 3 is legitimate report
After Index Applied (Follow-up)
✅ Index Verification
══════════════════
  Query: {sql_template}
  Before: avg {old}s, examined {old_rows} rows
  After:  avg {new}s, examined {new_rows} rows
  Improvement: {factor}x faster 🎉

Example Usage

User: "Check slow queries on db-prod-01, last 1 hour"

AI Response:

I'll analyze slow queries from the last hour.

🔍 MySQL Slow Query Diagnostic Report
══════════════════════════════════════
📋 Instance: db-prod-01:3306
   Analysis Period: Last 1 hour
   Total Slow Queries: 62

🔴 TOP 3 Slow Queries

  TOP 1 ⚡ 23.7s avg × 47 executions = 1,114s total impact
  ┌────────────────────────────────────────────────┐
  │ SELECT * FROM order_detail                     │
  │   WHERE create_time > ? AND status = ?         │
  │                                                │
  │ Avg Time: 23.7s | Max: 45.2s                  │
  │ Rows Examined: 12,800,000 | Returned: 380      │
  │ Index Hit Rate: 0.003% 🔴                       │
  │                                                │
  │ Root Cause: Full table scan — no index on      │
  │   (status, create_time)                        │
  │                                                │
  │ ✅ Fix: ALTER TABLE order_detail ADD INDEX      │
  │      idx_status_createtime (status, create_time)│
  │   Expected: 23.7s → <0.1s (237x faster)        │
  └────────────────────────────────────────────────┘

  TOP 2 ⚡ 8.4s avg × 12 executions = 100.8s total impact
  │ Full scan on user_order (5.6M rows)
  │ Fix: ADD INDEX (merchant_id)

  TOP 3 ⚡ 4.2s avg × 3 executions = 12.6s total impact
  │ Index hit, batch report — schedule off-peak

⚡ Priority Actions:
  1. [Critical] Add (status, create_time) on order_detail
  2. [High] Add (merchant_id) on user_order
  3. [Info] Schedule TOP 3 report query to 02:00-05:00
Show full SKILL.md (238 more words)Show less

Best Practices

Index Design Checklist
  • Equality columns first, range columns last
  • High-cardinality columns first in composite index
  • Consider covering index for hot queries (avoid table lookup)
  • Check existing indexes before adding (avoid duplicates)
  • Estimate index size: rows × avg_col_size × 1.5
  • Add indexes online (MySQL 5.6+ supports ALTER TABLE ... ALGORITHM=INPLACE)
When NOT to Add an Index
  • Query runs infrequently (batch job once a day)
  • Table is small (< 10,000 rows) — full scan may be faster
  • Write-heavy table — each index adds write overhead
  • Query already uses a good index but returns many rows (data volume issue)
Common Anti-Patterns
Anti-PatternWhy It's BadFix
SELECT * with indexCan't use covering indexSelect only needed columns
LIKE '%keyword%'Leading wildcard can't use indexUse full-text search or LIKE 'keyword%'
OR conditionsMay cause index mergeRewrite as UNION ALL or use composite index
Function on indexed column WHERE YEAR(dt)=2024Index not usedUse range: WHERE dt >= '2024-01-01'

Quick Reference

ActionQuery
Top slow queries (perf_schema)SELECT ... FROM events_statements_summary_by_digest ORDER BY SUM_TIMER_WAIT DESC
Top slow queries (slow_log)SELECT ... FROM mysql.slow_log WHERE start_time > ... ORDER BY query_time DESC
EXPLAIN a queryEXPLAIN FORMAT=JSON SELECT ...
Show table indexesSHOW INDEX FROM table_name
Table sizeSELECT ... FROM information_schema.TABLES WHERE TABLE_NAME='...'
Check slow query log statusSHOW VARIABLES LIKE 'slow_query_log'
Enable slow query logSET GLOBAL slow_query_log = ON

Use this skill for intelligent slow query diagnosis — not just listing queries, but explaining WHY they're slow and HOW to fix them.

© openocta, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 2 other files in mysql-slow-query-diagnose of openocta/openocta_skills.

  • SKILL.md
  • README.md
  • mate.json

Open the folder on GitHubat commit 6ac4479

Compare with similar skills

Mysql Slow Query Diagnose next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Mysql Slow Query Diagnose compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Mysql Slow Query Diagnose this skillopenocta/openocta_skills167—~2.7kAutomated safety check: PassMIT
DB Ops SopOpenDCAI/DataMind451—~388Automated safety check: PassApache-2.0
Altimate Data Warehouse DelegateAltimateAI/data-engineering-skills128—~1.4kAutomated safety check: PassMIT
MySQL Schema and Query Tuningplanetscale/database-skills7083 repos~1.4kAutomated safety check: PassMIT
Vitess for PlanetScaleplanetscale/database-skills7081 repos~1.2kAutomated safety check: PassMIT
Database OptimizerJeffallan/claude-skills12k—~1.6kAutomated safety check: PassMIT

Similar skills

  • DB Ops Sop

    OpenDCAI/DataMind

    Database operations runbook — backup, recovery, performance tuning, troubleshooting.

    451 GitHub stars~388 tokensUpdated 20 days ago
    DatabasesAuto-check passed
  • Altimate Data Warehouse Delegate

    AltimateAI/data-engineering-skills

    Delegates dbt and warehouse tasks such as lineage, migrations and cost attribution to the altimate-code CLI agent and relays its answer back.

    128 GitHub stars~1.4k tokensUpdated 2 days ago
    DatabasesAuto-check passed
  • MySQL Schema and Query Tuning

    planetscale/database-skills

    Official

    Guides safe, measurable MySQL and InnoDB changes across schema design, indexing, query tuning, transactions, locking and replication, with rollout steps.

    708 GitHub starsUsed in 3 repos~1.4k tokens
    DatabasesAuto-check passed
  • Vitess for PlanetScale

    planetscale/database-skills

    Official

    Guidance on Vitess sharding, VSchema design, query tuning and connection problems for MySQL-compatible databases running on PlanetScale.

    708 GitHub starsUsed in 1 repo~1.2k tokens
    DatabasesAuto-check passed
  • Database Optimizer

    Jeffallan/claude-skills

    Tunes PostgreSQL and MySQL performance by analyzing slow queries and execution plans, designing indexes, rewriting queries and adjusting configuration, one validated change at a time.

    12k GitHub stars~1.6k tokensUpdated 6 days ago
    DatabasesAuto-check passed
  • SQL Pro

    Jeffallan/claude-skills

    Optimizes SQL queries and designs schemas using CTEs, window functions, covering indexes and EXPLAIN ANALYZE, with notes on dialect differences between major databases.

    12k GitHub stars~1.3k tokensUpdated 6 days ago
    DatabasesAuto-check passed

More from openocta/openocta_skills

All 8 skills in this repo
  • Mysql Full Inspection Skill

    openocta/openocta_skills

    对远程多实例MySQL数据库执行全方位深度巡检,覆盖基础健康、连接负载、性能慢查询、索引冗余、主从复制、容量空间、账号安全、配置风险八大维度,全自动完成巡检扫描、风险识别、问题定级、优化建议、报告归档与飞书推送,适用于生产/测试所有运行中MySQL实例常态化合规巡检。适用场景:用户要求进行 MySQL 全链路健康检查、MySQL 综合巡检、MySQL 风险扫描、MySQL 性能审计、MySQL…

    167 GitHub stars~2k tokensUpdated 3 mo ago
    Auto-check passed
  • Server Patrol

    openocta/openocta_skills

    Linux 与网络设备只读健康巡检;直接运行 scripts/patrol.sh,配置由平台侧信道注入,Agent 不读取环境变量

    167 GitHub stars~522 tokensUpdated 3 mo ago
    Auto-check passed
  • Wechat Gzh Analyzer

    openocta/openocta_skills

    分析微信公众号后台数据,包括文章阅读量、评论、点赞等统计。当用户需要分析微信公众号数据、导出公众号文章统计报表时调用此技能。

    167 GitHub stars~2.6k tokensUpdated 3 mo ago
    Auto-check passed
  • Mysql Deadlock Analyzer

    openocta/openocta_skills

    Full-chain MySQL deadlock analysis. An agent skill from openocta/openocta_skills.

    167 GitHub stars~2.2k tokensUpdated 3 mo ago
    Auto-check passed
  • Mysql Replication Lag Resolver

    openocta/openocta_skills

    Replication lag root cause analysis with automated resolution workflow.

    167 GitHub stars~2.6k tokensUpdated 3 mo ago
    Auto-check passed
  • Tidb Cluster Inspector

    openocta/openocta_skills

    Comprehensive TiDB cluster inspection. An agent skill from openocta/openocta_skills.

    167 GitHub stars~2.9k tokensUpdated 3 mo ago
    Auto-check passed

Works with

Categories

Questions about Mysql Slow Query Diagnose

What does Mysql Slow Query Diagnose do?

Slow query diagnosis with root cause analysis and index optimization recommendations. Mysql Slow Query Diagnose is an agent skill from openocta/openocta_skills. Slow query diagnosis with root cause analysis and index optimization recommendations.

When should I use Mysql Slow Query Diagnose?

Mysql Slow Query Diagnose fits situations like: tasks that involve Query optimization.

How do I install Mysql Slow Query Diagnose in Claude Code?

Run `npx skills add openocta/openocta_skills --skill mysql-slow-query-diagnose -a claude-code`. Or copy the skill folder (mysql-slow-query-diagnose in openocta/openocta_skills) into .claude/skills/mysql-slow-query-diagnose in your project. Claude Code loads it when a task matches its description.

How do I install Mysql Slow Query Diagnose in Codex?

Run `npx skills add openocta/openocta_skills --skill mysql-slow-query-diagnose -a codex`. Or copy the skill folder (mysql-slow-query-diagnose in openocta/openocta_skills) into .agents/skills/mysql-slow-query-diagnose in your project. Codex loads it when a task matches its description.

Can I use Mysql Slow Query Diagnose in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add openocta/openocta_skills --skill mysql-slow-query-diagnose -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/mysql-slow-query-diagnose, .gemini/skills/mysql-slow-query-diagnose, .github/skills/mysql-slow-query-diagnose and .opencode/skills/mysql-slow-query-diagnose in your project.

What does Mysql Slow Query Diagnose need to run?

SKILL.md names no scripts, command-line tools or credentials: Mysql Slow Query Diagnose is instructions for the agent only. Its frontmatter pre-approves these tools: db_query, db_get_slow_log, db_describe_table, db_get_status.

Does Mysql Slow Query Diagnose access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Mysql Slow Query Diagnose safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Mysql Slow Query Diagnose use?

Mysql Slow Query Diagnose is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Mysql Slow Query Diagnose use?

About 2.7k tokens (SKILL.md is roughly 11k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Mysql Slow Query Diagnose?

Skills that share tags, products or a category with Mysql Slow Query Diagnose: DB Ops Sop (OpenDCAI/DataMind, 451 stars), Altimate Data Warehouse Delegate (AltimateAI/data-engineering-skills, 128 stars), MySQL Schema and Query Tuning (planetscale/database-skills, 708 stars) and Vitess for PlanetScale (planetscale/database-skills, 708 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Mysql Slow Query Diagnose?

openocta (a GitHub user) maintains it in openocta/openocta_skills, which has 167 GitHub stars. The repository holds 8 skills in this directory. The repository was last updated on June 22, 2026.

Source: openocta/openocta_skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.