# variable system error list

## the way an autoresponder works is:

* **parse.** mimu reads from ➜ right to determine what actions are needed. parsing is done serially and conquentially; allowing mimu to form an ordered plan of execution for the AR.
  * during this phase, small errors are caught and already visible. these errors are usually found in previews; such as `/autoresponder show`. [#parsing-errors](#parsing-errors "mention")
* **replace.** mimu substitutes placeholders (e.g. `{user}`) to their real values (e.g. `@iara`).
  * there are very, very few limitations to placeholders; they rarely have any errors. [#placeholder-errors](#placeholder-errors "mention")
* **verify**. mimu checks for all required permissions and that other conditions are met.
  * errors are generally expected. these errors often indicate the AR is working as expected; and are failsafe mechanisms to ensure a command doesn't run when it should not. [#expected-errors-missing-arguments-perms-etc](#expected-errors-missing-arguments-perms-etc "mention")
* **run**. when, and only when all the above are good ➜ mimu runs the functions in strict chronological order.

### because of how unique and complicated autoresponders work, you may run into errors of all types. this place serves as an index of all such errors.

{% hint style="success" %}
long-form errors, such as `PERMISSION_ERROR`: `DENIED_PERMISSIONS` can be disabled with the `{silent}` variable. you can also set a custom error when it occurs, with `{silent: you don't have the things needed to use this!}`
{% endhint %}

### parsing errors

these refer to errors that happen at the first step; typically due to inconsistent information or wrong information being passed into function variables (such as typing gibberish where a number is expected).&#x20;

{% hint style="info" %}
while these errors **should be paid attention to**, it is important to be reminded that errors shown in previews may not be representative of a full error, but more of a warning.

sometimes parsing does not have things determined yet; such as arguments with \[$N] are not properly set in an `/autoresponder show`. it is strongly recommended for you to run the autoresponder or `/send` first.
{% endhint %}

| error code                                                | description                                                                                                                                                                                                                                           | limiting variable                                                                                                                      |                                                                                                                                                                                                        |                                                          |                     |
| --------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------- | ------------------- |
| `MODIFYINV_ERROR` : `INVALID_MODIFY_AMOUNT`               | the amount you specified for an inventory change is **not a valid number** (for example, `sdjfkdsjf`)                                                                                                                                                 | `{modifyinv:}`                                                                                                                         |                                                                                                                                                                                                        |                                                          |                     |
| `ITEM_ERROR` : `TOO_MANY_ITEM_USER_DENY`                  | autoresponders can only deny up to 3 users' inventory items.                                                                                                                                                                                          | `{denyitem:}`                                                                                                                          |                                                                                                                                                                                                        |                                                          |                     |
| `ROLE_ERROR` : `INVALID_ROLE_PROVIDED`                    | one of the roles you used in your addrole / removerole configuration is invalid or could not be resolved by mimu.                                                                                                                                     | `{addrole:}` and `{removerole:}`                                                                                                       |                                                                                                                                                                                                        |                                                          |                     |
| `ROLE_ERROR` : `INVALID_ROLE_POSITION`                    | mimu’s highest role is **below** the role you are trying to add or remove, so discord does not allow the action.                                                                                                                                      | `{addrole:}` and `{removerole:}`                                                                                                       |                                                                                                                                                                                                        |                                                          |                     |
| `EMBED_ERROR` : `EMBED_NOT_FOUND`                         | the premade embed name you used does not exist, *or* the embed color / object is missing. mimu cannot find the embed to render.                                                                                                                       | `{embed:}`                                                                                                                             |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_ROLE`                                            | <p>a role you provided is not valid or could not be found in the server. this usually happens if:</p><ul><li>the role id / mention / name is wrong</li><li>the role was deleted</li><li>mimu can’t resolve it from the text you typed</li></ul>       | `{requirerole:}` and `{denyrole:}`                                                                                                     |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_PERMISSION`                                      | <p>the permission name you provided is not a valid discord permission.<br>for example: <code>ADMINSTRATOR</code> instead of <code>ADMINISTRATOR</code>.</p>                                                                                           | `{requireperm:}` / `{denyperm:}`                                                                                                       |                                                                                                                                                                                                        |                                                          |                     |
| `CHANNEL_ERROR`: `INVALID_CHANNEL`                        | the autoresponder is used in a channel *not* listed in `{requirechannel:}`                                                                                                                                                                            | `{requirechannel:}`                                                                                                                    |                                                                                                                                                                                                        |                                                          |                     |
| `CHANNEL_ERROR`: `DENIED_CHANNEL`                         | the autoresponder is used in a channel listed in `{denychannel:}`                                                                                                                                                                                     | `{denychannel:}`                                                                                                                       |                                                                                                                                                                                                        |                                                          |                     |
| `USER_ERROR`: `REQUIRED_USER_MISMATCH`                    | the invoking user is *not* listed in `{requireuser:}`                                                                                                                                                                                                 | `{requireuser:}`                                                                                                                       |                                                                                                                                                                                                        |                                                          |                     |
| `USER_ERROR`: `DENIED_USER`                               | the invoking user *is* listed in `{denyuser:}`                                                                                                                                                                                                        | `{denyuser:}`                                                                                                                          |                                                                                                                                                                                                        |                                                          |                     |
| `ROLE_ERROR`: `DENIED_ROLES`                              | the member has a role listed in `{denyrole:}`                                                                                                                                                                                                         | `{denyrole:}`                                                                                                                          |                                                                                                                                                                                                        |                                                          |                     |
| `PERMISSION_ERROR`: `INSUFFICIENT_PERMISSIONS`            | the member does *not* have the permissions listed in `{requireperm:}`                                                                                                                                                                                 | `{requireperm:}`                                                                                                                       |                                                                                                                                                                                                        |                                                          |                     |
| `PERMISSION_ERROR`: `DENIED_PERMISSIONS`                  | the member *has* a permission listed in `{denyperm:}`                                                                                                                                                                                                 | `{denyperm:}`                                                                                                                          |                                                                                                                                                                                                        |                                                          |                     |
| `ITEM_ERROR`: `DENIED_ITEM`                               | the user has an item or amount blocked by `{denyitem:}`                                                                                                                                                                                               | `{denyitem:}`                                                                                                                          |                                                                                                                                                                                                        |                                                          |                     |
| `CHANNEL_ERROR` : `INVALID_CHANNEL`                       | <p>the channel you provided is invalid or could not be found in the server. this can happen if:</p><ul><li>the channel id / mention / name is wrong</li><li>the channel was deleted</li><li>mimu doesn’t have access to see that channel</li></ul>    | `{requirechannel:}` / `{denychannel:}`                                                                                                 |                                                                                                                                                                                                        |                                                          |                     |
| `CANNOT_SEND_TO_CHANNEL`                                  | mimu is missing `send messages` or `view channel`                                                                                                                                                                                                     | `{sendto:}` or current channel                                                                                                         |                                                                                                                                                                                                        |                                                          |                     |
| `CANNOT_SEND_EMBED_TO_CHANNEL`                            | missing `embed links` permission in the channel                                                                                                                                                                                                       | \[may be altered with `{sendto:}` as well] `{embed:}`                                                                                  |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_USER`                                            | <p>the user you provided is invalid or could not be found in the server. this can happen if:</p><ul><li>you typed an id / mention that doesn’t exist</li><li>the user left the server</li><li>mimu can’t resolve the input text to a member</li></ul> | placeholders or configs that expect a valid user (e.g. `{requireuser:}`, user-based args etc, or anything parsing a member from text). |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_USER_REQUSER`                                    | you used `{requireuser:user\|not_valid_user}` but the not\_valid\_user input was not a valid user.                                                                                                                                                    | `{requireuser:}`                                                                                                                       |                                                                                                                                                                                                        |                                                          |                     |
| <p></p><p><code>INVALID\_USER\_DENYUSER</code></p><p></p> | you used `{denyuser:user\|not_valid_user}` but the not\_valid\_user isn't valid.                                                                                                                                                                      | `{denyperm:}`                                                                                                                          |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_USER_REQPERM`                                    | you used `{requireperm:user\|not_valid_user}` but the not\_valid\_user isn't valid.                                                                                                                                                                   | `{requireperm:}`                                                                                                                       |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_USER_DENYPERM`                                   | you used `{denyperm:user\|not_valid_user}` but the not\_valid\_user isn't valid.                                                                                                                                                                      | `{denyperm:}`                                                                                                                          |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_USER_REQROLE`                                    | you used `{requirerole:user\|not_valid_user}` but the not\_valid\_user isn't valid.                                                                                                                                                                   | `{requirerole:}`                                                                                                                       |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_USER_DENYROLE`                                   | you used `{denyrole:user\|not_valid_user}` but the not\_valid\_user isn't valid.                                                                                                                                                                      | `{denyrole:}`                                                                                                                          |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_USER_REQBAL`                                     | you used `{requirebal:amount\|user}` but the user part could not be resolved to a valid member.                                                                                                                                                       | `{requirebal:}`                                                                                                                        |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_USER_REQITEM`                                    | you used `{requireitem:item\|amount\|user}` but the target user could not be resolved to a valid member.                                                                                                                                              | `{requireitem:}`                                                                                                                       |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_USER_DENYITEM`                                   | you used `{denyitem:item\|amount\|user}` but the target user could not be resolved to a valid member.                                                                                                                                                 | `{denyitem:}`                                                                                                                          |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_USER_IS_BOT`                                     | you tried to modify a balance or inventory for a **bot user**, which is not allowed.                                                                                                                                                                  | `{modifybal:}` or `{modifyinv:}`                                                                                                       |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_ITEM_NAME` or `INVALID_ITEM`                     | <p> </p><p>you used <code>{user\_item:}</code> or <code>{user\_item\_count:}</code> without a valid item name or id. typically:</p><ul><li>the item name part is blank, or</li><li>the placeholder couldn’t parse the item name at all</li></ul>      | `{user_item:}` `{user_item_count:}`                                                                                                    |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_ITEM_AMOUNT`                                     | <p>inside <code>{modifyinv:}</code>, the amount (middle part) is not a valid number.<br>for example: <code>{modifyinv:sword                                                                                                                           | abc                                                                                                                                    | @user}</code> wwhere abc is not a number.</p>                                                                                                                                                          | `{modifyinv:}`                                           |                     |
| `INVALID_SHOP_ITEM_ID`                                    | you tried to **add** inventory with `{modifyinv:item\|amount\|user}` using an item id / name that doesn’t match any valid shop product.                                                                                                               | `{modifyinv:}`                                                                                                                         |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_INVENTORY_ITEM`                                  | you tried to **remove** inventory with `{modifyinv:}` using an item name / id that the user does not have.                                                                                                                                            | user doesn't have this item in inventory                                                                                               |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_INV_OPERATION`                                   | <p>you used <code>{modifyinv:}</code> with an invalid operator.<br>valid operators are <code>+</code> and <code>-</code>. anything else will error.</p>                                                                                               | `{modifyinv:}`                                                                                                                         |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_AMOUNT`                                          | <p>inside <code>{modifybal:}</code>, the amount is not a valid number.<br>e.g. <code>{modifybal:abc}</code> or <code>{modifybal:+abc                                                                                                                  | @user}</code>.</p>                                                                                                                     | `{modifybal:}`                                                                                                                                                                                         |                                                          |                     |
| `INVALID_BAL_OPERATION`                                   | <p>you used <code>{modifybal:}</code> with an invalid operator.<br>valid ones are: <code>+</code>, <code>-</code>, <code>\*</code>, <code>/</code>, <code>=</code>.</p>                                                                               | `{modifybal:}`                                                                                                                         |                                                                                                                                                                                                        |                                                          |                     |
| `TOO_MANY_EMBEDS`                                         | <p>you tried to use <code>{embed}</code> more than the allowed number of times in a single autoresponder.<br>the total premade embed count is capped at <code>10</code>.</p>                                                                          | `{embed:}`                                                                                                                             |                                                                                                                                                                                                        |                                                          |                     |
| `NO_BUTTON_NAME_PROVIDED`                                 | you used `{addbutton:}` without specifying a button name.                                                                                                                                                                                             | `{addbutton:}`                                                                                                                         |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_BUTTON_NAME`                                     | you used `{addbutton:name}` but that name does not match any existing saved buttonresponder.                                                                                                                                                          | `{addbutton:}`                                                                                                                         |                                                                                                                                                                                                        |                                                          |                     |
| `NO_LINKBUTTON_TEXT_PROVIDED`                             | you used `{addlinkbutton:label\|link}` without a text label.                                                                                                                                                                                          | `{addlinkbutton:}`                                                                                                                     |                                                                                                                                                                                                        |                                                          |                     |
| `NO_LINKBUTTON_URL_PROVIDED`                              | you used `{addlinkbutton:text\|}` without a url, url is missing                                                                                                                                                                                       | `{addlinkbutton:}`                                                                                                                     |                                                                                                                                                                                                        |                                                          |                     |
| `LINKBUTTON_INVALID_URL_PROVIDED`                         | the url you provided to `{addlinkbutton:}` is not a valid url. it needs to start with http and be a full link like <https://mimu.bot/>                                                                                                                | `{addlinkbutton:}`                                                                                                                     |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_CHOICES`                                         | you used `{choose}` (or `{choose1}`, `{choose2}`, etc) but didn’t provide **at least 2** valid choices separated by `\|`.                                                                                                                             | `{choose:}`                                                                                                                            |                                                                                                                                                                                                        |                                                          |                     |
| `INVALID_ORIGINAL_CHOICE_FOR_LOCK`                        | you tried to use `{lockedchoose}` before a valid `{choose}` was set for that slot. since there’s no original choice index to “lock” to, it can’t work.                                                                                                | `{lockedchoose:}`                                                                                                                      |                                                                                                                                                                                                        |                                                          |                     |
| `INSUFFICIENT_LOCKED_CHOICES`                             | <p>you used <code>{lockedchoose:a                                                                                                                                                                                                                     | b                                                                                                                                      | c}</code> but there isn’t a corresponding choice at the original random index.<br>for example, if the original <code>{choose}</code> picked the third item, but your locked list only has 2 items.</p> | `{lockedchoose:}` list is shorter than `{choose:}` list. |                     |
| `INVALID_WEIGHTS`                                         | <p></p><p>you used <code>{weightedchoose:}</code> but the weights are invalid. for example:</p><ul><li>non-numeric entries</li><li>negative numbers</li><li>all weights are zero</li><li>nothing parseable as a number</li></ul>                      | `{weightedchoose:}`                                                                                                                    |                                                                                                                                                                                                        |                                                          |                     |
| `INSUFFICIENT_WEIGHTS_FOR_CHOOSE`                         | <p>you provided fewer weights than there are choices attached to that slot.<br>for example, <code>{choose:a                                                                                                                                           | b                                                                                                                                      | c}</code> then <code>{weightedchoose:1                                                                                                                                                                 | 2}</code>.</p>                                           | `{weightedchoose:}` |
| `INSUFFICIENT_RANGE`                                      | <p></p><p>you used <code>{range:start-end}</code> but:</p><ul><li><code>start</code> or <code>end</code> is not a valid number, or</li><li><code>start</code> is greater than <code>end</code></li></ul>                                              | `{range:}`                                                                                                                             |                                                                                                                                                                                                        |                                                          |                     |

### expected errors (missing arguments / perms etc)

these refer to errors that are **not breaking**, and are intended to provide more clarity to the user running the trigger (whether that is an autoresponder or a buttonresponder or what else).

these usually mean:

* the autoresponder is working as designed,
* but some **requirement** for it to run was not met (roles, balance, items, arguments, permissions, etc).

| error code                                  | description                                                                                                                                                                                                                                                                                                                           | limiting variable |
| ------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------- |
| `ROLE_ERROR` : `INSUFFICIENT_ROLES`         | you tried to run an autoresponder that requires at least one role, but the user running it does not have any of the required roles.                                                                                                                                                                                                   | `{requirerole:}`  |
| `BALANCE_ERROR` : `INSUFFICIENT_BALANCE`    | <p></p><p>a user did not have enough currency for the autoresponder to run.<br>for example:</p><blockquote><p><strong>iara</strong> needs (at least) 10 💰 for this autoresponder to run.</p></blockquote>                                                                                                                            | `{requirebal:}`   |
| `INVENTORY_ERROR` : `INSUFFICIENT_ITEM`     | <p>a user is missing an item, or does not have enough of that item, for the autoresponder to run successfully.<br>for example:</p><blockquote><p><strong>xyz</strong> needs <code>1 × apple</code> for this autoresponder to run successfully.</p></blockquote>                                                                       | `{requireitem:}`  |
| `ARGUMENT_ERROR` : `INVALID_ARGUMENTS`      | <p></p><p>one or more of the <strong>required arguments</strong> to your autoresponder are invalid or missing.<br>the error message will tell you <em>which</em> argument failed, and (if possible) show what you typed, e.g.:</p><blockquote><p>the 2nd argument is not a valid number. you wrote <code>abc</code>.</p></blockquote> | `{requirearg:}`   |
| `MODIFYBAL_ERROR` : `INVALID_MODIFY_AMOUNT` | the amount you tried to set a balance to is **not a valid number**.                                                                                                                                                                                                                                                                   | `{modifybal:}`    |

## placeholder errors

very rare but sometimes occurs — pay attention to these!

| error code                               | description                                                    | variable          |
| ---------------------------------------- | -------------------------------------------------------------- | ----------------- |
| `BAL_ERROR` : `TOO_MANY_BAL_REQS`        | autoresponders can only check for up to 3 user balances.       | `{user_balance:}` |
| `ITEM_ERROR` : `TOO_MANY_ITEM_USER_REQS` | autoresponders can only require up to 3 users' inventory items | `{requireitem:}`  |

## runtime errors

these are errors that occur during the running of the autoresponder, at the last step. it is strongly recommended to pay attention to these. :warning:

| error code                                              | description                                                                                                                                                                                              | variable                           |
| ------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------- |
| `ROLE_ERROR` : `INVALID_MIMU_PERMISSION`                | mimu tried to **add or remove roles**, but does not have the `Manage Roles` permission in that server.                                                                                                   | `{addrole:}` or `{removerole:}`    |
| `SETNICK_ERROR` : `INVALID_MIMU_PERMISSION`             | mimu tried to **change someone’s nickname**, but does not have the `Manage Nicknames` permission in that server.                                                                                         | `{setnick:}`                       |
| `ADDREACTION_ERROR` : `INVALID_MIMU_PERMISSION`         | mimu tried to **react with emojis** to a message or reply, but does not have the `Add Reactions` permission in that channel.                                                                             | `{reactreply:}` or `` {react:}` `` |
| `MESSAGE_ERROR` : `CANNOT_DELETE_MESSAGE`               | <p></p><p>the autoresponder tried to delete the <strong>trigger message</strong>, but:</p><ul><li>mimu does not have <code>Manage Messages</code>, or</li><li>the message was already deleted.</li></ul> | `{delete}` or `{deletereply:}`     |
| `MESSAGE_ERROR` : `CANNOT_MESSAGE_USER`                 | <p></p><p>the autoresponder tried to <strong>dm the user</strong>, but could not, usually because:</p><ul><li>the user has dms disabled for the server, or</li><li>the user left the server.</li></ul>   | `{dm:}`                            |
| `MODIFYINV_ERROR` : `TOO_MANY_MODIFICATIONS`            | the autoresponder is trying to modify **more than 6 user–item pairs** in a single run. this is capped for safety.                                                                                        | `{modifyinv:}`                     |
| `MODIFYINV_ERROR` : `EXCEED_MODIFYINVENTORY_AMT_NOPREM` | on **non-premium servers**, autoresponder inventory changes **will not apply** if the amount exceeds `10,000` for that item.                                                                             | `{modifyinv:}`                     |
| `MODIFYINV_ERROR` : `EXCEED_MODIFYINVENTORY_AMT`        | autoresponder inventory changes **will not apply** if the amount of the item exceeds `1,000,000,000,000` (1 trillion).                                                                                   | `{modifyinv:}`                     |
| `MODIFYBAL_ERROR` : `TOO_MANY_MODIFICATIONS`            | the autoresponder is trying to modify balances for **more than 3 users** at once. this is capped for safety.                                                                                             | `{modifybal:}`                     |
| `MODIFYBAL_ERROR` : `EXCEED_MODIFYBAL_AMT_NOPREM`       | on **non-premium servers**, autoresponder balance changes are limited to **±100,000**. if the change is bigger, it will not be applied.                                                                  | `{modifybal:}`                     |
| `MODIFYBAL_ERROR` : `EXCEED_MODIFYBAL_AMT`              | autoresponder balance changes are limited to **±1,000,000,000**. above that, the change will not be applied.                                                                                             | `{modifybal:}`                     |
| `ROLE_ERROR` : `TOO_MANY_USERS`                         | you tried to add or remove roles for **more than 3 users** at once in a single autoresponder.                                                                                                            | `{addrole:}` and `{removerole:}`   |
| `ROLE_ERROR` : `TOO_MANY_ROLES`                         | you tried to add / remove **more than 10 roles** for a single user at once.                                                                                                                              | `{addrole:}` and `{removerole:}`   |
| `SETNICK_ERROR` : `TOO_MANY_NICKNAMES`                  | you tried to modify nicknames for **more than 3 users** in a single autoresponder run.                                                                                                                   | `{setnick:}`                       |
| `SETNICK_ERROR` : `NICKNAME_TOO_LONG`                   | the nickname you tried to set is **longer than 32 characters**, which discord does not allow.                                                                                                            | `{setnick:}`                       |
| `SETNICK_ERROR` : `INVALID_ROLE_POSITION`               | mimu tried to change the nickname of someone **higher than or equal to** its own role, or the server owner. discord blocks this.                                                                         | `{setnick:}`                       |
| `ADDREACTION_ERROR` : `TOO_MANY_REACTIONS`              | an autoresponder is trying to add **more than 5 reactions** to the trigger message or reply.                                                                                                             | `{react:}` or `{reactreply:}`      |
| `ADDREACTION_ERROR` : `INVALID_EMOJI`                   | at least one emoji you tried to react with is **invalid or not accessible** to mimu (e.g. from a server mimu is not in).                                                                                 | `{react:}` or `{reactreply:}`      |
| `MESSAGE_ERROR` : `MESSAGE_TOO_LONG`                    | the **final text content** of your autoresponder is over discord’s 4`000` character limit for a single message.                                                                                          | n/a                                |
| `MESSAGE_ERROR` : `EMBED_DESCRIPTION_TOO_LONG`          | the description of one of your embeds is longer than discord’s limit of `4096` characters.                                                                                                               | `{embed:}` (custom embed)          |
| `MESSAGE_ERROR` : `TOO_MANY_EMBED_CHARACTERS`           | the **combined** text across all embeds (titles, descriptions, fields, footers, authors) exceeds discord’s overall embed character limit (`6000` chars).                                                 | `{embed:}`                         |
| `BUTTON_ERROR` : `TOO_MANY_BUTTONS`                     | you tried to create more than `25` buttons in a single autoresponder response (discord limit: 5 buttons × 5 rows).                                                                                       | `{addbutton:}` `{addlinkbutton:}`  |
