## Goals and principles (reader-first, answer-first) [#1-goals-and-principles-reader-first-answer-first]
* Intent. Every page exists to help a developer finish a real task quickly and correctly.
* Pages **MUST** optimize for clarity, scannability, accuracy, and trust;
* Pages **MUST NOT** contain marketing language in technical sections. \[HIGH]
* Pages **SHOULD** be answer-first (solution before theory) and example-first (real code before exposition). (Why: task-focused, plain, and scannable pages help readers complete work on the first try; marketing copy and theory up front slow readers and reduce trust.)
Principles.
1. Answer-first. Open with purpose, outcome, and prerequisites. Then show the steps (or the API signature in reference). Background theory moves to its own Explanation page or a brief end section. (Why: leading with the solution shortens time-to-success; moving theory prevents detours for readers who just need to act.)
Example (good):
Goal: “Send a jetton from a web app.” Prerequisites: JS SDK, funded testnet wallet. Steps: 1–5. Verify: expected output. Troubleshoot: common errors.
2. Example-first and precise. Provide copy-pasteable snippets with expected output. Use `` values and define them at first use. Avoid unnecessary narrative around code. (Why: runnable, minimal examples remove guesswork; placeholders prevent users from pasting unsafe, hard-coded values.)
3. Minimal concepts in task pages. Do not front-load long explanations in step-by-step/how-tos. Link to a concept page instead. (Why: keeping theory separate avoids cognitive overload; readers can pull background only if they need it.)
4. Single source of truth. Don’t duplicate reference tables in guides. Summarize only what's needed, then link to the reference anchor. (Why: duplication drifts and conflicts; deep links keep guides brief and ensure details stay correct in one place.)
5. Scannability. Prefer short paragraphs (≤ \~5 sentences) and short sentences (\~15–20 words). Use headings, lists, and tables to chunk information. See [§8](#8-readability-and-scannability) for norms and flexibility. (Why: short, well-chunked text is faster to scan and reduces rereads and errors.)
Anti-patterns (MUST NOT). Vague claims (“blazingly fast”), filler (“simply”, “just”, “obviously”, “please note”), and long theoretical detours in task pages. (Why: vague or padded text wastes time and hides the action; front-loaded theory blocks progress for users who came to do a task.)
## Audience and assumptions [#2-audience-and-assumptions]
Default audience. The primary reader is new to blockchain but experienced in software development. (Why: sets a clear baseline so pages explain TON concepts without re-teaching general programming.) Pages **MUST NOT** re-teach generic developer skills (e.g., basic shell, Git, Python/JS syntax) unless a step is unusual for TON. (Why: keeps pages focused and shorter; duplicating generic skills adds noise and goes stale quickly.)
Declaring prerequisites. Step by step and how-to pages **SHOULD** include a Prerequisites block at the top. Reference pages **SHOULD** include a one-line Summary to orient the reader. (Why: consistent placement improves scanning and lets readers self-select quickly.)
### 2.1 What belongs in Prerequisites [#21-what-belongs-in-prerequisites]
Prerequisites are entry conditions: things the reader must have or have done before starting. Each item **MUST** be concrete and verifiable. (Why: readers should be able to check each prerequisite before starting to avoid wasted effort.)
Examples of valid prerequisite categories:
* **Software already installed** (not installed during the guide). Specify version and link to download page.
* **Accounts or access already obtained**: API keys, RPC endpoints, wallet accounts.
* **Artifacts from prior work**: `"A deployed contract from [Deploy a counter](https://docs.ton.org/llms/path/to/guide/content.md)"`, `"A funded testnet wallet"`.
* **Funds or tokens**: "Testnet GRAM from the [faucet](https://...)".
* **Unusual hardware** (only when relevant): "A machine with at least 16 GiB RAM".
### 2.2 What does not belong in Prerequisites [#22-what-does-not-belong-in-prerequisites]
* **Obvious assumptions**. You **MUST NOT** list: internet connection, an operating system, a keyboard, a terminal/shell, a browser, a text editor, or similar universal tools. (Why: obvious items waste space and insult reader intelligence.) \[HIGH]
* **Things installed or created during the guide**. If step 1 is "Install the SDK", the SDK is **NOT** a prerequisite — the prerequisite is what is needed to install it (e.g., Node.js). You **MUST NOT** list items that the guide itself provides. (Why: listing in-guide installations as prerequisites confuses readers about what they need beforehand.) \[HIGH]
* **Skills or knowledge**. "Familiarity with TypeScript" or "Understanding of smart contracts" are audience statements, not prerequisites. Use a separate "Audience" note for these (e.g., "Audience: Intermediate. Assumes working knowledge of TypeScript and async/await."). You **MUST NOT** mix skills into the Prerequisites list. (Why: skills cannot be "installed" or verified the same way; separating them clarifies what readers need to do vs. know.) \[HIGH]
* **Background reading or concept links**. `"Read the [Account model](https://docs.ton.org/llms/foundations/accounts/content.md) page first"` belongs in prose or a "Background" section, not Prerequisites. If understanding a concept is truly required, state it as an audience assumption. You **SHOULD NOT** put learning links in Prerequisites. (Why: prerequisites are for artifacts and tools, not reading assignments.)
### 2.3 Version specifications [#23-version-specifications]
* Software prerequisites **MUST** specify at least the version tested in the guide. (Why: unversioned requirements cause "works on my machine" failures.) \[HIGH]
* Software prerequisites **SHOULD** specify a supported range when known (e.g., "Node.js 20 or later LTS", "Python 3.10+"). (Why: ranges tell readers whether their existing installation works.)
* You **MUST NOT** use vague terms like "latest" or "recent version". (Why: "latest" changes over time and provides no actionable information.) \[HIGH]
### 2.4 Links in Prerequisites [#24-links-in-prerequisites]
* Each software prerequisite **MUST** link to an official download or installation page, not to the project homepage or documentation root. (Why: readers need to act, not browse; download pages are actionable.) \[HIGH]
* For tools with OS-specific installers, you **MAY** link to a general downloads page that offers all variants.
* For TON-ecosystem tools documented in these docs, link to the internal installation guide if one exists.
### 2.5 Prerequisite examples [#25-prerequisite-examples]
Good:
```text
Prerequisites:
- [Node.js](https://nodejs.org/en/download/) 20 or later LTS
- A funded testnet wallet (get testnet GRAM from the [faucet](https://t.me/testgiver_ton_bot))
- An RPC endpoint — use a public endpoint or get one from [TON Center](https://toncenter.com/)
```
Bad:
```text
Prerequisites:
- A computer with internet access ← obvious
- Node.js ← no version, no link
- Install the TON SDK ← installed in the guide, not a prerequisite
- Familiarity with JavaScript ← skill, not a prerequisite
- Read the [wallets overview](https://docs.ton.org/llms/wallets/content.md) ← background reading, not a prerequisite
```
### 2.6 Audience and skill assumptions [#26-audience-and-skill-assumptions]
Pages with advanced requirements **MUST** state them at the top in a separate Audience note, not in Prerequisites. (Why: separating "what you need to have" from "what you need to know" helps readers self-select.)
Example:
```text
Audience: Advanced. Assumes understanding of TVM exit codes and TL-B schemas.
See: [TVM exit codes](https://docs.ton.org/llms/tvm/exit-codes/content.md), [TL-B overview](https://docs.ton.org/llms/data-formats/tlb/content.md).
```
Inclusive/global readers. Use plain, international English; avoid idioms and culture-specific references. Prefer neutral, inclusive terms (e.g., allowlist/denylist). (Why: idioms and local metaphors confuse non-native readers; inclusive terms are more precise and avoid unintended exclusion.)
## Documentation framework (content types) [#3-documentation-framework-content-types]
Rule. Each page **MUST** be one of the following: Step by step, How-to guide, Explanation, or Reference. Types **MUST NOT** be mixed on a single page. The chosen type **MUST** be clear from the title and content. (Why: single-purpose pages are easier to find and follow; mixing types blurs intent and causes duplication.)
Small, clearly marked asides (e.g., a 1–2-step “Verify” box in an Explanation) **MAY** appear when they aid comprehension; the page’s primary type remains unchanged. (Why: tiny, labeled asides help understanding without turning a concept page into a task page.)
### 3.1 What each type means (and looks like) [#31-what-each-type-means-and-looks-like]
* Step by step (first success). Single happy path for newcomers. Hand-holding is **RECOMMENDED**. (Why: one clear path gets novices to a working result quickly; branching early increases drop-off.)
Title style: “Deploy a counter contract on testnet”. (Why: action-oriented titles set expectations and help search/TOC scanning.)
Sections (suggested): Objective → Prerequisites → Steps → Verify → Troubleshoot → Next steps. Keep Next steps minimal (1–3 essential links) or omit when the path is linear. **SHOULD** avoid theory beyond two short bullets; link to an Explanation page. (Why: predictable structure reduces cognitive load; keeping theory brief prevents blocking progress.)
* How-to guide (goal-oriented procedure). A recipe to achieve a specific outcome. **MUST** be procedural and concise. (Why: readers come for a recipe; extra narrative slows execution and invites errors.)
Title style: “How to mint a jetton with the CLI”. (Why: the “How to …” pattern matches search intent and signals page type while staying specific.)
Rule: **MUST NOT** embed long background; link to concepts as needed. (Why: avoids duplication and keeps the guide focused; background stays current in one canonical place.)
* Explanation (concepts/why). Background, architecture, trade-offs. **SHOULD** avoid step lists and commands. (Why: separating “why” from “how” improves comprehension and prevents pages from doing two jobs badly.)
Title style: “Account model and messages in TON”. (Why: noun-based titles signal conceptual content and improve browseability.)
* Reference (complete, factual). Exhaustive specs for APIs/CLI/SDK/types/errors. Non-narrative tables and exact semantics. (Why: factual, uniform entries are scannable and machine-linkable; narrative slows lookups.)
Title style: “`tvm.runvm` — interface and exit codes”. (Why: placing the exact identifier in the title improves search and deep linking.)
Rule: **MUST** be precise, consistent, and anchor-linkable. (Why: deep anchors let guides link directly; precision prevents support churn and conflicting copies.)
## Voice and tone [#4-voice-and-tone]
Objective. Sound like a helpful expert: professional, precise, and approachable. Use the same voice across all pages. (Why: a consistent, expert tone builds trust and reduces cognitive load; readers know what to expect across the site.)
Rules (binding).
* Use present tense, active voice, and the imperative mood. Write steps as commands (e.g., “Run the validator.”), not future tense or passive voice. Avoid addressing the reader with “you”. (Why: imperative, active phrasing makes the action clear without personal address and reduces ambiguity in steps.)
* Be neutral and inclusive. Avoid slang, idioms, culture-specific jokes, or hype. (Why: neutral language is easier for non-native readers and translators, and avoids alienating parts of the audience.)
* **MUST NOT** use filler or patronizing words: simply, just, obviously, clearly, please note. Replace with exact instructions (Why: filler wastes time and can sound condescending; precise verbs tell the reader exactly what to do.)
* Emojis in prose and headings **MUST NOT** appear. Use clear text or an `` when emphasis is needed. (Why: emojis are ambiguous, distract from procedures, and do not localize reliably.)
* Emojis in code/command blocks **MAY** appear only when they are part of runnable code or a literal command/output string. Do not add emojis for decoration; the snippet **MUST** remain copy-pasteable and executable as shown. If quoting a UI/log message that contains an emoji, keep it verbatim inside quotes. (Why: runnable examples take precedence; avoiding decorative emojis preserves clarity and execution.)
* Emojis in compact tables **MAY** be used sparingly as visual indicators only when they follow a widely understood convention (for example, `✅` / `❌` for supported/not supported, or `★` to mark a recommended option) and **MUST** be paired with a text label in the same cell or a descriptive header (e.g., “Supported — Yes/No”). Do not rely on an emoji alone to convey meaning, and **MUST NOT** use decorative or non-standard pictograms (for example, a play triangle to indicate videos). (Why: paired, conventional icons preserve clarity for screen readers, localization, and cases where emojis don’t render.)
* Even where emojis are technically allowed (code/output or compact tables), they **SHOULD** be rare and **MUST** have a clear purpose. If the same meaning is clear without the emoji, remove it. (Why: conventional text remains clearer for global readers and translators.)
* Use plain terms over legalese/Latinisms. “Use” not “utilize”; “before” not “prior to.” (Why: common words improve comprehension and reduce rereads; they are also translated more consistently.)
* Avoid first-person pronouns (“we”, “I”, “our”). When an organization, product, or service is the actor, use its proper name (e.g., “MyTonWallet”, “TON”) or a neutral noun (“the node”, “the SDK”). Prefer imperative instructions without “you”. See [§5.8](#5-8-dont-get-personal) and [§5.10](#5-10-pronouns-and-person-references). (Why: neutral, explicit actors read cleanly and translate reliably.)
Marketing and promotional language (ban).
* You **MUST NOT** use marketing-style language anywhere in technical content, including titles, headings, steps, tables, references, and callouts. This includes: \[HIGH]
* Superlatives and hype: "blazingly fast", "revolutionary", "world-class", "seamless", "best-in-class", "powerful", "cutting-edge".
* Vague positive adjectives: "reliable", "robust", "essential", "elegant", "intuitive", "flexible", "comprehensive", "scalable" (when used without measurable criteria).
* Dramatic or emotional framing: "elusive", "challenging", "painful", "frustrating", "nightmare", "perfectly", "beautifully". Technical writing states facts, not feelings.
* Intensity words that exaggerate: "instantly", "immediately" (unless literally true), "extremely", "incredibly", "massive", "huge" (for non-quantified values).
* Storytelling openers: "Imagine…", "Picture this…", "Have you ever…", "What if…". Start with the task or fact instead.
(Why: hype and drama erode trust, slow scanning, obscure required actions, and age poorly.)
* Replace subjective claims with measurable facts (numbers, constraints, conditions) or remove them entirely. If a claim cannot be tested or measured, delete it. (Why: facts enable correct implementation and reproducible results.) \[HIGH]
* When describing benefits, state **what** happens and **under what conditions**, not how it feels. (Why: readers need actionable information, not emotional appeals.)
* Bad: "This approach provides a robust and reliable solution."
* Good: "This approach retries failed requests up to three times with exponential backoff."
* Bad: "Tests catch issues instantly."
* Good: "Tests run in under 2 seconds and fail on the first assertion violation."
Micro-examples.
* Bad: “We’ll just quickly configure the node; it’s super easy!”
Good: “Configure the node.”
* Bad: “Let’s go ahead and utilize the script.”
Good: “Run the script.”
* Bad: “Obviously, the transaction fails if the fee is low.”
Good: “The transaction fails if the fee is too low.”
## Grammar and usage [#5-grammar-and-usage]
Objective. Make sentences easy to parse on first read. (Why: clear, low-friction sentences reduce rereads and mistakes during implementation.)
### 5.1 Voice, tense, and person [#51-voice-tense-and-person]
* You **MUST** use active voice by default. Passive voice **MAY** be used only when the actor is unknown or irrelevant. (Why: active voice makes who does what explicit; passive hides responsibility and confuses steps.)
* Good: “The validator stops if the config is invalid.”
* Bad: “The validator is stopped if the config is invalid.”
* You **MUST** use the present tense for general behavior and instructions; the future tense **SHOULD** be reserved for time-dependent statements. (Why: present tense reads simpler and matches how-to steps; future tense adds unnecessary words and ambiguity.)
* Good: “The API returns JSON.”
* Bad: “The API will return JSON.”
* Prefer imperative instructions without addressing the reader (“you”). Avoid first-person pronouns (“we”, “I”, “our”); when an organization, product, or service is the actor, use its proper name (e.g., “TON Center”, “TON”). See [§5.8](#5-8-dont-get-personal) and [§5.10](#5-10-pronouns-and-person-references). (Why: imperative, neutral phrasing keeps actors clear without personal address.)
### 5.2 Plain, precise wording [#52-plain-precise-wording]
* You **SHOULD** prefer common words over legalese or Latinisms. (Why: familiar words are understood faster and translated more reliably.)
* Use “use,” not “utilize.” Use “before,” not “prior to.”
* Hedging and filler **MUST NOT** appear: simply, just, obviously, clearly, please note. Replace with exact actions or facts. (Why: filler wastes time and can sound condescending; specifics tell readers exactly what to do.)
### 5.3 Acronyms and terms [#53-acronyms-and-terms]
* On first mention, you **MUST** spell out the term and follow with the acronym in parentheses. Use the acronym thereafter. (Why: defines terms once and keeps later text concise.)
* Example: “The Open Network (TON)…”
* Project terminology **MUST** follow the term bank/glossary (see [§13](#13-terminology-and-naming)). Avoid introducing synonyms for the same concept. (Why: one canonical term prevents confusion and search/indexing issues.)
### 5.4 Audience calibration [#54-audience-calibration]
* Assume developers are new to blockchain (but experienced in software). **MUST NOT** re-teach generic developer skills unless a TON-specific nuance requires it (see [§2](#2-audience-and-assumptions)). Provide concise prerequisites when needed. (Why: focusing on TON reduces noise and keeps pages shorter and more relevant.)
### 5.5 Global and inclusive language [#55-global-and-inclusive-language]
* You **MUST** avoid idioms, cultural references, and biased terms. Prefer neutral alternatives (e.g., allowlist/denylist). Use people-neutral wording and accessible examples. (Why: idioms and bias exclude readers and harm translation; neutral wording is clearer for everyone.)
### 5.6 Spelling and contractions [#56-spelling-and-contractions]
* Spelling **MUST** follow American English (e.g., color, analyze). (Why: a single spelling standard prevents mixed variants and review churn.)
* Contractions (don’t, can’t) **MAY** be used when they improve flow and do not reduce clarity. (Why: natural phrasing is easier to read as long as the meaning stays clear.)
### 5.7 Avoid unfinished work [#57-avoid-unfinished-work]
Articles **MUST NOT** have any TODO, mentions of the work on the article to be done in future, itemized or text plans on its continuation, unfinished sections (headers without any text afterwards). The only exception is use of the `` component to tell the whole page is not finished yet. \[HIGH]
### 5.8 Don't get personal [#58-dont-get-personal]
Articles **MUST NOT** use pronouns "you", "your" to refer to a reader, and **MUST NOT** use pronouns "we", "I", "our" to refer to an author. (Why: documentation must only describe facts; it knows no facts about readers; most facts about writers are off-topic). \[HIGH]
### 5.9 Avoid tautology, pleonasm, throat-clearing, and circular references [#59-avoid-tautology-pleonasm-throat-clearing-and-circular-references]
Objective. Remove wordy redundancies and self-referential boilerplate so the reader gets the signal only. (Why: cutting redundancy speeds reading and reduces confusion.)
#### Rules (normative) [#rules-normative]
* You **MUST** remove tautologies/pleonasms (duplicate meaning in different words). (Why: redundant pairs add length without adding meaning.)
* Bad: “End result” → Good: “result”
* Bad: “Advance planning” → Good: “planning”
* Bad: “Free gift” → Good: “gift”
* You **MUST NOT** use throat-clearing/circular openers that describe the doc instead of delivering value. (Why: readers come to act; meta-introductions delay the task.) \[HIGH]
* Bad: “In this section, we will discuss how to…”, “This document aims to explain…”
* Good: “Deploy a validator on testnet.” (start with the action)
* You **SHOULD** collapse wordy boilerplate into precise verbs. (Why: shorter, direct phrasing is faster to parse.)
* Bad: “In order to” → Good: “To”
* Bad: “For the purpose of” → Good: “To”
* Bad: “Due to the fact that” → Good: “Because”
* You **MUST** avoid doublets/triplets (pairs that mean the same thing). (Why: repeating the same idea signals uncertainty and wastes space.)
* Bad: “each and every”, “basic fundamentals”, “final outcome”, “past history”, “future plans going forward”, “merge together”, “close proximity”, “completely eliminate”
* You **MUST** avoid tautological logic and circular definitions. (Why: circular text doesn’t explain behavior and blocks understanding.)
* Bad: “A jetton is a jetton if it conforms to the jetton standard.”
* Good: “A jetton is a fungible token on TON defined by the Jetton standard, which specifies message formats for mint/transfer/burn.”
* You **SHOULD** replace hedges and intensifiers with facts. (Why: intensity words add emotion, not information; facts reduce ambiguity.) \[HIGH]
* Avoid: “basically”, “essentially”, “really”, “very”, “actually”, “literally” (unless literal).
* If precision matters, give a number, constraint, or example instead.
* You **MUST NOT** use and/or. (Why: it is ambiguous; readers cannot tell if both are allowed or required.)
* Write: “A, B, or both” or “A or B” (choose one).
* You **SHOULD NOT** use etc. in procedures or lists. (Why: open-ended lists leave readers unsure what is required.)
* Either complete the list or write “for example” and stop.
* You **MUST** avoid “as mentioned above/below”; link to the exact anchor instead (see [§12](#12-links-and-cross-references)). (Why: relative references break when pages change; links stay accurate.)
* You **SHOULD** simplify “whether or not” → “whether”; “the reason is because” → “because”; “not uncommon” → “common/often.” (Why: simpler forms are clearer and shorter.)
See also: [Appendix B](#b-banned-and-preferred-terms) lists additional banned intensifiers and tone words.
#### Before/after micro-examples [#beforeafter-micro-examples]
* Throat-clearing
* Before: “In this guide, we will show you how to configure a validator.”
* After: “Configure a validator.”
* Tautology
* Before: “The final outcome of the deployment process…”
* After: “The result of the deployment…”
* Wordy boilerplate
* Before: “In order to reduce fees, you need to…”
* After: “To reduce fees, …”
* Hedge + intensifier
* Before: “It’s basically very important to verify the address.”
* After: “Verify the address.”
* Circular reference
* Before: “Sharding improves scalability because it shards the chain.”
* After: “Sharding splits the chain into parallel shards that process transactions concurrently, increasing throughput.”
### 5.10 Pronouns and person references [#510-pronouns-and-person-references]
* You **MUST** use gender-neutral singular “they/them/their” when referring to an unspecified or generic person. **MUST NOT** use gendered or split forms such as “he”, “she”, “he/she”, “s/he”, or “(s)he” for generic subjects. \[HIGH] (Why: singular “they” is inclusive, concise, and avoids awkward constructions.)
* Prefer imperative instructions or role nouns to avoid pronouns when possible (e.g., “Deploy the contract.” or “The operator updates the config.”). (Why: direct phrasing is clearer and reduces ambiguity.)
* When referring to a named individual who has stated pronouns, use that person’s pronouns; if unknown or irrelevant, default to “they”. (Why: respect individuals while keeping language inclusive.)
* Do **NOT** anthropomorphize software or networks with gendered pronouns. Use neutral nouns or “it” (e.g., “the node restarts”, “it fails to start”). (Why: avoids confusion and maintains technical tone.)
* For organizations, products, and services, use the proper name (e.g., “TON”, “MyTonWallet”) or the neutral “it”; do not use “we/I/our” in documentation. (Why: consistent, neutral references read cleanly and translate reliably.)
### 5.11 Parentheses [#511-parentheses]
* Parentheses **MAY** be used for short clarifications and abbreviation expansions (for example, “The Open Network (TON)”) but **SHOULD NOT** be used for extended side remarks. (Why: side remarks buried in parentheses are easy to miss and hard to translate.)
* When a parenthetical includes an extra idea, condition, or step, split the sentence into two sentences or move the extra idea into its own sentence or list item instead of nesting it in parentheses. (Why: one idea per sentence is easier to parse and localize.)
* Where a parenthetical is necessary for precision, keep it short and avoid chaining more than one set of parentheses in the same sentence. (Why: multiple nested asides make sentences hard to read.)
## Punctuation and mechanics [#6-punctuation-and-mechanics]
Objective. Remove ambiguity and increase scan speed with consistent mechanics. (Why: predictable punctuation choices make sentences easier to parse and reduce misreads.)
### 6.1 Commas, colons, semicolons [#61-commas-colons-semicolons]
* The Oxford (serial) comma **MUST** be used in lists of three or more items: “nodes, wallets, and explorers.” (Why: prevents ambiguity about whether the last two items are grouped.)
* Comma splices **MUST NOT** occur. If two clauses can stand alone, use a period or a coordinating conjunction. (Why: run-on sentences are hard to scan; separating clauses improves clarity.)
* Bad: “The node restarts, it begins syncing.”
* Good: “The node restarts. It then begins syncing.”
* Colons **SHOULD** introduce lists or explanations after a complete clause. Semicolons **SHOULD** be rare. Prefer shorter sentences. (Why: correct colon use signals structure; semicolons slow scanning and can often be replaced by periods.)
### 6.2 Quotation marks and emphasis [#62-quotation-marks-and-emphasis]
* Quotation marks **MUST** be used only for actual quotations or literal UI text/messages, not for emphasis. (Why: quotes indicate exact strings; using them for emphasis misleads readers and translators.)
* Good: The error message “Account not found” appears.
* Bad: The “validator” node… (do not quote terms)
* House rule — quoting style: Use the international style with American spelling. Quotation punctuation **MUST** remain outside closing quotes unless it is part of the quoted text. This differs from American book style; keep it consistent. (Why: keeps code-adjacent strings accurate and avoids adding punctuation that isn’t part of the literal.) \[HIGH]
* Use double quotation marks for log/error strings and other literal UI text when quoting it as text; place punctuation outside unless it is part of the string. (Why: quotes remain the convention for messages/text and keep literals copyable.)
* This rule applies to quoted UI/log/error strings only; it does not apply to code spans or headings. (Why: code spans and headings have their own styling rules.)
* Log messages and error strings **MUST** appear verbatim in quotation marks; **MUST NOT** add emphasis or change casing/punctuation. (Why: exact copying/grepping depends on matching strings.) \[HIGH]
* When referencing interactive controls or keyboard keys that the reader should click or press, you **MUST** use `Label` for the control or key name. You **MUST NOT** use quotation marks, bold, or italics to style controls in instructions. (Why: `` is designed for controls/keys and keeps actions easy to scan and copy.)
* Good: Click `Settings`, then select `Network`.
* Bad: Click “Settings” or **Settings**.
* UI or menu labels that appear in screenshots or descriptive text but are not being presented as actions **MAY** be written in quotes. Avoid mixing `` and quoted labels arbitrarily; prefer one style consistently within a page/section. For quoted UI strings, follow the house quoting style above. Punctuation follows normal sentence rules outside ``. (Why: consistent styling keeps text readable and copyable.)
* Error codes/identifiers **MUST** use code formatting: `ERR_FEE_TOO_LOW`, `EADDRINUSE`, `ENOENT`. (Why: code styling distinguishes tokens from prose and aids scanning and copy/paste.)
* When paraphrasing behavior, you **MUST NOT** alter message semantics; label paraphrases clearly and avoid quotation marks. (Why: altered wording leads to mismatches during troubleshooting.)
#### Emphasis (bold and italics) [#emphasis-bold-and-italics]
* Bold and italics **SHOULD** be used sparingly in body text. Prefer structure (headings, lists), precise wording, or an admonition over visual emphasis. (Why: heavy emphasis reduces scan speed and harms raw-Markdown readability.)
##### Bold [#bold]
* Bold **SHOULD** mark scan points: a skimming reader should be able to bounce between bolded words and still understand the key actions or constraints in a section. (Why: using bold as a scan path keeps pages easy to scan.)
* Use bold for a few critical words in a heading or paragraph, not whole sentences. If the paragraph still communicates the same information when bold is removed, prefer plain text and drop the bold. (Why: unnecessary bold increases noise without adding meaning.)
* You **MUST NOT** bold entire sentences, paragraphs, or whole list items. If a label is needed, use a heading or an appropriate callout instead. (Why: large bold blocks create visual noise and duplicate heading semantics.) \[HIGH]
* You **MUST NOT** use bold to style tokens, flags, filenames, or UI/log messages; use code font for tokens, quotation marks for log/error strings and UI text, and `` for UI/menu labels and key names. (Why: consistent, literal styling keeps examples copy-pasteable, searchable, and accessible.) \[HIGH]
* Within a paragraph, you **SHOULD NOT** use more than one short bold span (≤ 3 words). Reserve it for rare emphasis that clarifies meaning, not for decoration. (Why: limiting emphasis keeps true highlights noticeable.)
##### Italics [#italics]
* Italics **MAY** be used for first-mention term emphasis or titles of publications, books, papers, or standards. Avoid using italics for recurring emphasis in procedures. (Why: minimal, conventional italics aid comprehension.)
* When introducing an important concept on a concept or explanation page and a glossary link is not attached, you **MAY** italicize the first meaningful mention to signal definition, then stop italicizing later mentions. (Why: one highlighted introduction is enough to draw attention without cluttering the scan path.)
* Use italics for subtle emphasis that matters in sentence context but should not become a scan target. Use bold when the reader should find a word while scanning quickly. (Why: separating roles for bold and italics keeps both predictable.)
* Link text **MUST NOT** be styled with bold or italics. Do not wrap links in emphasis (for example, `**[Foo](https://docs.ton.org/llms/foo/content.md)**`, `_ [Foo](https://docs.ton.org/llms/foo/content.md)_`) and do not put bold or italic markup inside the link label. When the link label is a code identifier, use inline code as the label (for example, ``[`foo_bar`](https://docs.ton.org/llms/ref/foo_bar/content.md)``). (Why: links are already visually distinct; extra emphasis adds noise and makes scanning harder.) \[HIGH]
### 6.3 Code styling [#63-code-styling]
* Code, filenames, paths, API endpoints, flags, and literals **MUST** use code formatting (inline backticks or fenced blocks). **MUST NOT** add punctuation inside code that isn’t part of the code. (Why: visual separation prevents misreading and keeps examples copy-pasteable without edits.) \[HIGH]
### 6.4 Lists [#64-lists]
* Use numbered lists for procedures and bulleted lists for unordered sets. If list items are full sentences, **SHOULD** end with periods; otherwise, omit terminal punctuation consistently. (Why: matching list type to purpose improves comprehension; consistent punctuation keeps visual noise low.)
* Unordered list markers **MUST** be `-` (hyphen). **MUST NOT** use `*` or `+`. (Why: a single marker keeps diffs cleaner and avoids mixed styles.)
* Ordered lists **MUST** use `1.` for every item; let the MDX parser auto-number in the rendered output. (Why: auto-numbering prevents renumber churn when inserting/reordering steps.)
### 6.5 Thematic breaks [#65-thematic-breaks]
* Thematic breaks / horizontal rules (`---`, `***`, `___`, or HTML `
`) **MUST NOT** be used. Use headings, whitespace, or an admonition to separate sections. (Why: horizontal rules fragment structure, reduce screen-reader/navigation cues, and add noise in raw Markdown.) * You **MUST NOT** simulate separators with repeated characters or ASCII art (e.g., `=====`, `-----`). (Why: pseudo-rules create the same problems and look like code noise.) * This rule does not apply to YAML frontmatter delimiters `---` at the top of a file. Frontmatter **MAY** use `---` as required by the site generator. (Why: frontmatter is metadata, not content.) ### 6.6 Blockquotes [#66-blockquotes] * Blockquotes **MUST** be reserved for literal quotations from a source (another page in these docs or an external source). Include attribution inline or in the sentence introducing the quote; internal quotes **SHOULD** link to the exact anchor; external quotes **SHOULD** link to the canonical HTTPS source. (Why: clear attribution preserves trust and lets readers verify context.) * Blockquotes **MUST NOT** be used for callouts/admonitions, warnings, tips, examples, emphasis, or general instructions. Use the `` component for callouts (see [§11.2](#11-2-how-to-write-the-callout), [Appendix A](#a-admonition-levels-and-usage)) and headings/lists for structure. (Why: misusing blockquotes harms structure, accessibility, and localization.)
* Visual callouts (Note/Tip/Caution/Warning) **MUST** use only the `` component. The only supported `type` values are `"note"`, `"tip"`, `"caution"`, and `"danger"`; do **NOT** use other components or type values. \[HIGH] (Why: a single component and fixed types keep rendering, accessibility, and localization consistent.)
* Short phrases or UI/log strings **SHOULD** use inline quotation marks instead of a blockquote. Tokens and identifiers **MUST** use code font, not blockquotes. (Why: inline quotes and code font are more precise and copy-friendly.)
* Keep quotations brief (prefer ≤ two sentences or one short paragraph). For longer material, summarize in your own words and link to the source. (Why: long quotes impede scanning and duplicate external content.)
* Nested blockquotes **MUST NOT** be used. Quoted code or output **SHOULD** appear in fenced code blocks with attribution above the block, not inside a blockquote. (Why: fenced blocks remain copy-pasteable and render consistently.)
`) **MUST NOT** be used. Use headings, whitespace, or an admonition to separate sections. (Why: horizontal rules fragment structure, reduce screen-reader/navigation cues, and add noise in raw Markdown.) * You **MUST NOT** simulate separators with repeated characters or ASCII art (e.g., `=====`, `-----`). (Why: pseudo-rules create the same problems and look like code noise.) * This rule does not apply to YAML frontmatter delimiters `---` at the top of a file. Frontmatter **MAY** use `---` as required by the site generator. (Why: frontmatter is metadata, not content.) ### 6.6 Blockquotes [#66-blockquotes] * Blockquotes **MUST** be reserved for literal quotations from a source (another page in these docs or an external source). Include attribution inline or in the sentence introducing the quote; internal quotes **SHOULD** link to the exact anchor; external quotes **SHOULD** link to the canonical HTTPS source. (Why: clear attribution preserves trust and lets readers verify context.) * Blockquotes **MUST NOT** be used for callouts/admonitions, warnings, tips, examples, emphasis, or general instructions. Use the `
## Headings and titles [#7-headings-and-titles]
Objective. Make navigation obvious and sections self-explanatory. (Why: clear, self-describing headings reduce misclicks, speed scanning, and make deep links understandable out of context.)
### 7.1 Case and form [#71-case-and-form]
* Site-managed H1. Pages **MUST NOT** include an in-body H1. The page title is provided by the site generator/frontmatter. The first visible heading in the page content **MUST** be an H2. (Why: the template renders the title; omitting an in-body H1 avoids duplicate titles and keeps a consistent heading hierarchy.)
* In MDX content, you **MUST NOT** write `# ` (H1), `
`, or use components that render an H1. Start headings at `##` (H2). (Why: syntax-level bans prevent accidental H1s in raw Markdown/MDX and keep navigation consistent.) * Imported snippets/partials **MUST NOT** emit H1 headings; they **MUST** begin at H2 or lower within the host page’s hierarchy. (Why: embedded content inherits the page’s structure and must not reset the heading level.) * All headings **MUST** use sentence case (capitalize only the first word and proper nouns). (Why: sentence case is easier to read, avoids random capitalization, and localizes more reliably.) \[HIGH] * Task (procedure) headings **MUST** start with an imperative verb; concept headings **SHOULD** be noun phrases. (Why: imperatives signal actions the reader takes; noun phrases signal explanatory content, improving navigation and search relevance.) * Task: “Deploy a validator.” * Concept: “Validator architecture.” * How-to titles. For the How-to doc type, the page title **MUST** follow “How to X”. Internal section headings (H2/H3) remain imperative. (Why: the pattern clarifies page type and improves discoverability without changing procedural heading style.) ### 7.2 Gerunds and labels [#72-gerunds-and-labels] * For task/procedure headings (H2/H3), gerunds (e.g., “Creating…”, “Configuring…”) **SHOULD NOT** be used. Prefer imperative verbs. (Why: gerunds are vague about action vs. state; imperatives are clearer and translate better.) * Concept headings **MAY** use concise noun phrases (e.g., “Naming”, “Spelling”, “Versioning”). (Why: short labels act as clear section tags and improve scan speed.) * Fixed labels like Troubleshooting, Changelog, or FAQ are acceptable. Imperatives read cleaner and translate better in procedural sections. (Why: common labels match user expectations and TOC patterns; imperatives keep steps actionable.) * House default: use “Troubleshoot” by default; “Troubleshooting” is acceptable when aligning with established ecosystem conventions. (Why: one default reduces variance; allowing the alternate keeps external consistency where needed.) ### 7.3 Uniqueness and linkability [#73-uniqueness-and-linkability] * Headings **MUST** be unique at the same nesting level within a page and **MUST** make sense out of context (as TOC/sidebar links). Avoid repeated “Introduction” sections; prefer specific names. (Why: unique, descriptive headings prevent anchor collisions and make links meaningful in search and sharing.) ### 7.4 Formatting restrictions [#74-formatting-restrictions] * Headings **MUST NOT** contain styling other than text: no bold, italics, `code`, quotes, or ALL CAPS (acronyms permitted). Keep headings clean; use formatting in body text only. (Why: extra styling harms scannability, clutters the TOC, and causes inconsistent rendering.) * Exceptions: * Reference pages only: Headings **MAY** include code font for identifiers (API names, flags, error codes), e.g., `tvm.runvm` — interface and exit codes. (Why: monospaced identifiers preserve exact casing and aid search/copy.) * When the heading contains a literal UI/log/error message, quotation marks **MAY** be included (e.g., Fix “Account not found”). (Why: quoting exact strings shows what to grep or match without altering punctuation.) ### 7.5 Practical length norms [#75-practical-length-norms] * Headings **SHOULD** be concise. As a norm, Page title (site/frontmatter) ≤ \~60 characters; H2/H3 ≤ \~70 characters. Exceed only for clarity. (Why: concise titles fit sidebars and search results without truncation; brevity improves scanning.) Examples (good): * “Run a validator on testnet” (H2, imperative) * “Account model and messages in TON” (H2, concept) Examples (bad): * “Running and configuring the validator” (gerunds) * “How the `validator` works” (code in heading)
## Readability and scannability [#8-readability-and-scannability]
Objective. Keep text fast to read and effortless to scan. (Why: quick comprehension reduces rereads and mistakes during implementation.)
### 8.1 Paragraphs and sentences [#81-paragraphs-and-sentences]
* One idea per paragraph. Paragraphs **SHOULD** be ≤ 5 sentences; single-sentence paragraphs are acceptable for emphasis. These are recommended norms, not hard caps—exceed only when clarity requires it. (Why: tight, focused paragraphs are easier to scan; short norms keep pages consistent without blocking necessary detail.)
* Each sentence **SHOULD** convey one main idea. If a sentence starts to describe two distinct actions or conditions, split it into two sentences or convert the extra actions into a list. (Why: one-idea sentences are easier to scan and translate; lists make multi-step actions obvious.)
* Sentences **SHOULD** average 15–20 words. Long, multi-clause sentences **SHOULD** be split. Front-load key points. (Why: mid-length sentences reduce cognitive load; splitting prevents misreads; leading with the main point speeds understanding.)
### 8.2 Structure for scanning [#82-structure-for-scanning]
* Use subheadings, lists, and tables to break up dense text. Provide breathing room around code, tables, and images (blank lines before/after blocks). (Why: chunking and whitespace make structure visible and stop content from blending together.)
* Highlight critical notes with admonitions (Note/Tip/Important/Caution/Warning) sparingly so they retain impact. (Why: overuse causes readers to ignore callouts; sparing use signals importance.)
* This guidance does not limit required safety callouts in [§11](#11-safety-critical-content-blockchain-specific); when in doubt, include the safety callout. (Why: preventing harm overrides brevity and visual economy.)
### 8.3 Micro-examples [#83-micro-examples]
Before (hard to scan):
“After deploying, if fees are misconfigured, the transaction might fail and the node logs a warning; you can retry after adjusting the config, but it’s better to verify the fee policy first because otherwise the wallet may reject the message.”
After (scannable):
* Verify fees before deploying.
* If the transaction fails with `FEE_TOO_LOW`:
1. Update the fee policy.
2. Retry the deployment.
* The node logs a warning on failure.
## Recommended page structures (by type) [#9-recommended-page-structures-by-type]
Objective. Make pages predictable without forbidding alternatives. (Why: predictable shapes reduce scanning time and help readers know what to expect.)
Rule. The patterns below are **RECOMMENDED**. You **MAY** deviate when another structure improves clarity, but pages in the same section **SHOULD** be consistent. (Why: consistency within a section helps navigation and comparison; flexibility allows better fit for edge cases.)
### 9.1 Step by step (first success) [#91-step-by-step-first-success]
Recommended sections:
Objective → Prerequisites → Steps (3–7) → Verify (expected output or result) → Troubleshoot (common errors) → Next steps. Keep Next steps minimal (1–3 essential links) or omit when the path is linear. (Why: this flow gets newcomers to a working result, confirms success, handles common failures, and points to what to do next.)
Notes: Keep a single happy path; theory **SHOULD** be limited to ≤ two bullets and linked to an Explanation page. (Why: branching and long theory cause drop-offs; brief links keep momentum while offering depth when needed.)
Example outline (good):
* Objective: “Deploy a counter contract on testnet.”
* Prerequisites: Node.js 20+, TON SDK JS, funded testnet wallet, ``.
* Steps: 1) Initialize project … 2) Compile … 3) Deploy …
* Verify: “Expected output” block showing successful deployment.
* Troubleshoot: `INSUFFICIENT_FUNDS`, `INVALID_WORKCHAIN` fixes.
* Next steps: Link to contract upgrades guide.
### 9.2 How-to guides (goal-oriented procedures) [#92-how-to-guides-goal-oriented-procedures]
Recommended sections:
Goal → Prerequisites → Steps → Result → Links to Reference (anchor each flag/param). (Why: the reader sees what they’re trying to achieve, what they need, how to do it, what outcome to expect, and where to look up details.)
Notes: Do not embed long background; link to concepts instead. Keep each step a single action with sub-bullets for options. (Why: separating theory prevents duplication and keeps the guide tight; one action per step reduces ambiguity and errors.)
### 9.3 Explanations (concepts/why) [#93-explanations-conceptswhy]
Recommended sections:
What/Why → Core concepts → Trade-offs → Related topics. (Why: this order frames purpose first, then explains mechanics, then consequences, and finally directs to adjacent ideas.)
Notes: Avoid command sequences. Use diagrams and short examples to illustrate concepts. (Why: commands distract from understanding; visuals and minimal examples clarify ideas without turning the page into a procedure.)
### 9.4 Reference (complete, factual) [#94-reference-complete-factual]
Recommended sections:
Summary → Parameters/Fields (tables) → Returns/Responses → Errors (codes, meanings) → Examples (minimal usage) → Optional See also (1–3 essential anchors). (Why: a uniform, tabular layout makes lookups fast and supports deep linking and automation.)
Notes: Be exhaustive and anchor-linkable; minimize narrative. Keep formats consistent across entries. (Why: completeness and anchors enable precise links from guides; minimal prose speeds lookup; consistency lets readers scan different entries the same way.)
## Code and command examples [#10-code-and-command-examples]
Objective. Ensure examples are precise, copy-pasteable, and unambiguous. (Why: readers should be able to run examples without editing or guessing.)
### 10.1 General rules [#101-general-rules]
* Examples **MUST** be copy-pasteable. **MUST NOT** include shell prompts (`$`, `>`) in command blocks. (Why: prompts get copied accidentally and break commands.) \[HIGH]
* Command and expected output **MUST** be presented as separate fenced blocks. (Why: mixing them causes copy errors and makes results hard to recognize.) \[HIGH]
* Placeholders **MUST** use `` (e.g., ``, ``), and each placeholder **MUST** be defined on first use. (Why: a consistent, visible pattern prevents pasting unsafe hard-coded values.) \[HIGH]
* Fenced code blocks **MUST** specify a language (` ```bash `, ` ```rust `, ` ```json `, …). (Why: language tags enable correct highlighting and tooling.)
* Filenames shown in examples **MUST** be realistic and kebab-case (e.g., `wallet-config.json`, not `MyConfig.json`). (Why: examples should model the conventions we require elsewhere.)
* Long commands **MUST NOT** be hard-wrapped. Prefer UI soft wrap. If a tool supports safe line continuation (e.g., `\` in POSIX shells), continuation **MAY** be used and must be copy-pasteable as shown. (Why: hard wraps break execution; soft wrap or continuations keep commands runnable.)
* You **SHOULD** favor examples that run end-to-end on testnet by default. (Why: safer defaults reduce risk and support quick validation.)
* Inside language code, placeholders **SHOULD** be neutral (e.g., `UPPER_SNAKE` inside strings or comments) when angle brackets would clash with language syntax; in commands and prose, placeholders **MUST** use ``. (Why: avoids syntax errors in code while keeping a single placeholder style in prose/CLI.)
* In runnable examples, configuration values and other parameters that the reader is expected to change **MUST** be collected in one clearly visible block near the top of the snippet. When the language allows top-level declarations, this block **MUST** use top-level constants instead of redefining values inside the entry function or helpers; when the language forbids top-level declarations, group these parameters at the start of the entry function. (Why: collecting adjustable values in one visible place makes examples easier to understand and update.) \[HIGH]
### Error and log style [#error-and-log-style]
* Quoted UI/log messages **MUST** appear verbatim in quotation marks. (Why: exact strings are searchable and prevent confusion.)
* Error codes and identifiers **MUST** be rendered in code font (e.g., `ERR_FEE_TOO_LOW`). (Why: monospace distinguishes tokens and aids copy/paste.)
* When summarizing behavior instead of quoting, **MUST NOT** change semantics and avoid using quotes; indicate that it is a summary. (Why: paraphrases should not be mistaken for literal messages and must stay accurate.)
Good:
````text
```bash
ton-node start --ledger --network testnet
```
There,
`` — path to the local ledger directory.
`` — HTTPS endpoint of the TON RPC provider.
Expected output:
```text
Node started. Workchain: 0 Shard: -1 Status: running
```
````
Bad:
````text
```bash
$ ton-node start --ledger /home/bob/ledger --network mainnet # includes prompt, hard-coded values
```
````
### 10.2 Partial snippets [#102-partial-snippets]
* Partial snippets (focused excerpts) **MAY** be used when teaching a narrow concept, even if not runnable alone. (Why: small, targeted examples clarify one idea without setup noise.)
* Partial snippets **MUST** be labeled clearly in the comment on the first line of the block: “// Not runnable: brief how to make it runnable”. (Why: prevents readers from attempting to execute incomplete code. In the explanation, be concise and try to keep it below 100 characters)
* Partial snippets **SHOULD** link to a full runnable example or reference entry showing complete context. (Why: gives readers a path to working code.)
```rust
// Not runnable: replace EQC_REPLACE_WITH_ADDRESS with a real address.
let to = Address::from_str("EQC_REPLACE_WITH_ADDRESS").unwrap();
let amount = Coins::from_nano(1_000_000_000);
let body = build_transfer_body(to, amount);
```
### 10.3 Safety and secrets in code [#103-safety-and-secrets-in-code]
* Secrets (keys, mnemonics, API tokens) **MUST NOT** appear in examples. Use placeholders or test keys that are clearly invalid. (Why: prevents accidental leaks and unsafe copying.) \[HIGH]
* Commands that could cause loss of funds or data **MUST** be guarded by a Warning/Caution per [§11](#11-safety-critical-content-blockchain-specific) and **SHOULD** default to testnet. (Why: explicit risk labeling and safe defaults protect readers.) \[HIGH]
### 10.4 OS and language variants [#104-os-and-language-variants]
* When steps differ by OS or language, you **SHOULD** provide tabs or distinct subsections (e.g., Linux / macOS / Windows; JS / Python / Rust). (Why: separates platform differences so readers don’t mix instructions.)
* If only one variant is provided, the page **MUST** state that limitation. (Why: sets expectations and avoids readers searching for missing variants.)
### 10.5 Comments and omissions [#105-comments-and-omissions]
* Use language-appropriate comments to mark omissions (`// …`); **MUST NOT** use literal ellipses that change syntax. (Why: literal ellipses can create invalid code.) \[HIGH]
* Explanatory comments in examples **MUST** appear on their own line immediately above the code they describe; **MUST NOT** use trailing end-of-line comments such as `foo(42); // sends a test message` in documentation snippets. (Why: stacked comment-then-code is easier to scan and keeps copy-pasted lines clean.) \[HIGH]
* Exception: Fift and TVM assembly stack comments **MAY** appear as trailing end-of-line comments to show the stack state at that point (e.g., `1 2 + // 3`). This is idiomatic in stack-based languages and aids comprehension. (Why: stack comments are a well-established convention in Fift and TVM assembly; forcing them to a separate line would harm readability.)
* Keep comments minimal and instructional; avoid commentary or humor. (Why: extraneous remarks distract from the task and age poorly.)
## Safety-critical content (blockchain-specific) [#11-safety-critical-content-blockchain-specific]
Objective. Prevent reader harm when funds, keys, or validator/network state are involved. (Why: mistakes here can cause irreversible loss or outages.)
### 11.1 When a safety callout is required [#111-when-a-safety-callout-is-required]
A Caution or Warning **MUST** appear when a page or step: (Why: visible callouts make risk obvious before a reader runs a command.) \[HIGH]
* moves funds or changes fee/withdrawal behavior; (Why: users can lose money or block withdrawals.) \[HIGH]
* exposes, stores, or transmits private keys/mnemonics; (Why: leaked secrets allow account takeover and theft.) \[HIGH]
* modifies validator configuration, networking, or consensus-affecting parameters; (Why: misconfiguration can halt or fork nodes and degrade the network.) \[HIGH]
* performs chain-affecting operations (e.g., resharding, pruning, halting, replay). (Why: these actions can corrupt the state, reduce availability, or cause data loss.) \[HIGH]
If page has many actions potentially requiring a safety callout, you **MAY** combine these into a page-level safety summary plus short local callouts instead of repeating full details every time. (Why: a shared summary avoids repetition while still making risks visible.)
### 11.2 How to write the callout [#112-how-to-write-the-callout]
A page that contains safety-critical actions **MUST** clearly communicate all of the following, either in a page-level safety summary, in local callouts near each step, or in combination: (Why: readers need to know the risk, scope, recovery, and safe environment before proceeding.) \[HIGH]
1. Risk (what can go wrong), (Why: sets severity and helps decide whether to proceed.)
2. Scope (what the command affects), (Why: clarifies blast radius—single node, wallet, or network.)
3. Rollback/mitigation steps where feasible, and (Why: gives a path to recovery or damage control.)
4. Environment label (testnet vs mainnet) with safer default instructions first. (Why: testnet reduces harm; explicit labels prevent accidental mainnet use.)
* These elements describe the information the reader needs; they are **NOT** required as literal labels such as “Risk:” or “Scope:”. Safety callouts **SHOULD** read as concise, natural prose rather than templated checklists. (Why: natural language is easier to read and avoids robotic, placeholder-style warnings.)
Common patterns:
* Page-level safety summary. Place a single `` near the top of the guide that describes overall risk, scope, rollback/mitigation strategy, and testnet/mainnet expectations for the full set of commands. (Why: one visible summary prevents readers from missing critical context.)
* Local step-level warnings. Add short `` elements next to each hazardous step that call out the specific risk or environment for that step and, when needed, refer back to the page-level summary instead of repeating full details (for example, “See the safety note at the top of this page before running this on mainnet.”). (Why: local notes tie the warning to the exact action without duplicating the whole summary.)
Rendering (component) \[HIGH]
* Safety callouts **MUST** use the `` component; **MUST NOT** use Markdown blockquotes (`>`) or headings to simulate warnings. (Why: a single component keeps appearance, accessibility, and behavior consistent.)
* Mapping: use `type="caution"` for Caution; use `type="danger"` for Warning. Set an explicit `title` when needed (e.g., `title="Funds at risk"`). (Why: consistent severity mapping aligns wording with visual severity.)
* Allowed types: The only supported `` `type` values are `"note"`, `"tip"`, `"caution"`, and `"danger"`. Do not use other values (e.g., `"important"`, `"warning"`). To display those labels, set `title` (e.g., `title="Important"`) while keeping a supported `type`. (Why: keeping to the supported set ensures consistent rendering and avoids runtime fallbacks.)
Example (MDX)
````mdx
Sending TON on mainnet is irreversible. Start with a small transfer on TON Testnet, then repeat on TON Mainnet only after checking the address and network carefully; there is no rollback on mainnet.
```bash
jetton transfer --to --amount --network testnet
```
````
### 11.3 Safer defaults [#113-safer-defaults]
* Task pages **SHOULD** use testnet endpoints by default and mention the switch to mainnet explicitly. (Why: safe defaults prevent costly mistakes.)
* Destructive flags (e.g., `--purge`, `--force`) **MUST** be opt-in and accompanied by a callout. (Why: explicit opt-in and warnings reduce accidental data loss.) \[HIGH]
### 11.4 Key handling and storage [#114-key-handling-and-storage]
* Keys **MUST** be represented as placeholders or generated ephemeral testing artifacts. (Why: prevents real secrets from being copied into scripts or screenshots.) \[HIGH]
* In guides, prefer environment variables or keystores; never inline secrets. (Why: avoids persisting secrets in history, logs, or source control.) \[HIGH]
* Reference pages **MAY** document secure storage options but **MUST NOT** encourage unsafe patterns. (Why: guidance is helpful, but normalizing bad practices leads to leaks.) \[HIGH]
## Links and cross-references [#12-links-and-cross-references]
Objective. Reduce duplication and let readers jump straight to detail. (Why: direct links cut search time and prevent restating facts in multiple places.)
### 12.1 Link text [#121-link-text]
* Link text **MUST** be descriptive and indicate the destination. You **MUST NOT** use generic labels like "click here", "here", "this", "this link", "this page", or bare URLs as link text. \[HIGH] (Why: meaningful text lets readers scan quickly to determine where a link leads; generic labels force readers to examine surrounding context.)
* You **MUST NOT** use mechanics-focused verbs like "click", "tap", "follow", or "go to" as part of link text. Focus on content, not interaction mechanics. \[HIGH] (Why: drawing attention to the clicking action distracts from the content; not all users click — some tap, use keyboards, or use assistive technology.)
* Link text **SHOULD** describe the destination, not the action of navigating. One effective technique: use the title or topic of the target page as the link text and integrate it into the sentence.
* Bad: `"To learn about fees, click [here](https://docs.ton.org/llms/fees/content.md)."`
* Bad: `"Click [here](https://docs.ton.org/llms/fees/content.md) for fee information."`
* Bad: `"[This page](https://docs.ton.org/llms/fees/content.md) explains fees."`
* Good: `"The [fee structure](https://docs.ton.org/llms/fees/content.md) determines transaction costs."`
* Good: `"Transaction costs depend on the [fee structure](https://docs.ton.org/llms/fees/content.md)."`
* When a link must stand alone (e.g., at the end of a sentence or after a colon), make the link text self-explanatory:
* Bad: `"For more details, see [here](https://docs.ton.org/llms/validator-setup/content.md)."`
* Good: `"For more details, see [Validator setup](https://docs.ton.org/llms/validator-setup/content.md)."`
* Good: `"Related guide: [Set up a validator](https://docs.ton.org/llms/validator-setup/content.md)."`
* Link labels **SHOULD** be plain text or inline code for identifiers (see [§6.2](#6-2-quotation-marks-and-emphasis) for emphasis restrictions on link text). (Why: unstyled labels keep links readable and avoid redundant visual emphasis.)
* Standalone "stub" sentences whose only job is to say "See …" or "Read here …" followed by a link (for example, `[Read here](https://docs.ton.org/llms/contracts/standard/wallets/mnemonics/content.md) to learn more.` or `See [mnemonics](https://docs.ton.org/llms/contracts/standard/wallets/mnemonics/content.md) for more details.`) **MUST NOT** appear in running prose. Instead, attach the link to the relevant term or phrase in a normal sentence (for example, `The [mnemonics guide](https://docs.ton.org/llms/contracts/standard/wallets/mnemonics/content.md) explains why.`). (Why: inline links keep the text flowing and avoid postponing useful links to trailing meta-sentences.) \[HIGH]
* Accessibility and SEO note: Screen readers often present links out of context (e.g., a list of all links on a page). Generic link text like "here" or "click here" becomes meaningless when read in isolation. Search engines also use link text to understand page relationships. Descriptive link text improves both accessibility and discoverability. (Why: links must make sense without surrounding prose.)
### 12.2 What to link (and what not) [#122-what-to-link-and-what-not]
* In a guide, the first useful mention of a flag, parameter, error code, or data type on the page **MUST** link to the canonical reference anchor. You **MAY** also link its first mention in other H2/H3 sections on long pages that are frequently deep-linked or read out of order. (Why: readers see the spec at the moment they need it, even when entering mid-page.) \[HIGH]
* This rule explicitly includes TVM exit codes (e.g., `-13`, `37`), send modes (e.g., `mode 64`, `mode 128`), reserve modes, and similar numeric constants that have documented meanings. These **MUST** be linked to their corresponding reference anchors on first mention, not left as bare code spans. (Why: numeric constants are opaque without context; links let readers understand them instantly.) \[HIGH]
* Within a single H2/H3 section, link only the first meaningful mention of an important term or reference target. When the same term appears in a different H2/H3 section, you **MAY** link its first mention again there. Avoid linking every occurrence inside one section; add a repeated link only when separated by many screens and it clearly helps the reader. (Why: per-section first links help when deep-linking to a subsection without turning the page into a link farm.)
* Link concepts judiciously: if the reader is likely to wonder “what does that mean?”, link the term on its first useful mention in that H2/H3 section. Subsequent mentions in the same section **SHOULD** be plain text unless the gap is large and a repeated link clearly helps. (Why: section-local first links help readers who land on a deep link without over-linking common words.)
* On the first useful mention of a core TON term on a page, you **SHOULD** link to the Glossary (Foundations → Glossary), unless the page itself defines it. On long pages, you **MAY** also link the first mention of that term in other H2/H3 sections, following the per-section rules above. (Why: keeps definitions consistent and easy to find while still helping readers who enter mid-page.)
* Over-linking common words is discouraged; link what is plausibly useful. (Why: excessive links slow reading and distract from the task.)
* Guides **MUST NOT** duplicate reference tables; summarize and link instead. (Why: duplication drifts and creates conflicting sources of truth.)
* Internal first. When both an internal TON Docs page and an external source exist, you **MUST** link the internal page by default (including instead of the TEPs repository). Exception: pages whose purpose is to document a standard contract/TEP **MAY** also link the corresponding TEP as the canonical spec. If no relevant internal page exists, linking to the external source is acceptable. (Why: internal pages are newcomer-friendly; TEPs are normative but hard to parse for new readers.)
Example (good)
Start the node with `--threads` (see [validator flags → `--threads`](https://docs.ton.org/llms/nodes/overview/content.md)) to increase parallelism.
### 12.3 Link targets and format [#123-link-targets-and-format]
* Internal links **MUST** be root-absolute and stable (start with `/`), yet relative to the `content/` directory; anchors **MUST** resolve correctly. **MUST NOT** use relative segments like `./` or `../` in Markdown/MDX link URLs or HTML/JSX. (Why: files and folders move frequently; root-absolute links remain correct across moves; relative segments are brittle and costly to maintain.) \[HIGH]
* Cross-section links **SHOULD** deep-link to the exact section or anchor instead of the page top. (Why: deep links land readers on the exact answer.)
* A See also section **MAY** close a page with 1–3 essential links; prefer a linear path that needs none. (Why: minimal exits keep readers on task while still offering critical follow-ups.)
* When linking to the same internal target multiple times on a page, you **SHOULD** prefer reference-style Markdown links so the URL appears once in a shared definition block. For example:
```md
Use the [jetton wallet][jetton-wallet] contract where applicable; the [jetton wallet reference][jetton-wallet] describes all fields.
[jetton-wallet]: https://docs.ton.org/llms/content/standard/jettons/wallet/content.md
```
This keeps body text readable and makes URL updates cheaper, while still requiring root-absolute URLs in the reference definition. (Why: shared link definitions reduce visual noise and simplify maintenance.)
### 12.4 Avoid circularity and drift [#124-avoid-circularity-and-drift]
* Each fact **MUST** have a single canonical home. If you need the same fact elsewhere, link to it. (Why: one source avoids conflicting copies and simplifies updates.)
* **MUST NOT** link to outdated or superseded pages except when documenting historical behavior. (Why: stale links propagate errors and erode trust.) \[HIGH]
### 12.5 Images and media [#125-images-and-media]
* Images **MUST** be embedded using the `` MDX component. Markdown image syntax `` and raw `![]()
` are **PROHIBITED**. (Why: the component provides dark-theme control, consistent sizing/zoom, and stable rendering.) \[HIGH]
* Image sources **MUST** be root-absolute and live under `/public/images/`, yet be given without `/public` in the URL (for example, `` is the logical image category and `` is the filename). **MUST NOT** use relative `src` such as `./` or `../`. (Why: content moves often; root-absolute paths remain valid.) \[HIGH]
* Provide a `darkSrc` when contrast or readability differs in dark mode. Keep aspect ratios consistent across a page to avoid layout shift. (Why: visual stability improves reading flow.)
* SVG note: if `src` points to an SVG and `darkSrc` is omitted, the dark-theme image is auto-inverted. Supply an explicit `darkSrc` when inversion is not desired. (Why: ensures accurate colors and legibility.)
* Provide meaningful, non-empty `alt` text for every image; `alt` **MUST NOT** be empty. (Why: screen readers rely on `alt` to convey image meaning; empty `alt` hides content from assistive tech.) \[HIGH]
* When using ``, prefer the `width`/`height` props for predictable layout; avoid arbitrary inline styling. (Why: predictable dimensions prevent layout shift and maintain consistency.)
### 12.6 External references [#126-external-references]
Objective. Use authoritative, stable sources and deep links; avoid volatile or non-authoritative pages. (Why: reliable links reduce drift, link rot, and conflicting guidance.)
* Authority order. You **MUST** prefer: (1) official project documentation/specs/standards (link internal TON Docs when available before external repos); (2) vendor documentation for tools used; (3) primary sources (RFCs, papers). Community wikis/blogs **MAY** be linked only when no official source exists and **MUST** be labeled as background. (Why: authoritative sources change less and carry clearer guarantees; internal docs are optimized for comprehension.)
* Wikipedia and crowd-edited sources. Wikipedia **MAY** be linked for general, well-known non-TON concepts when the link is informational and not supporting a requirement or API/behavior semantics. For normative claims or when precision matters, **MUST** link a spec or official docs (e.g., RFC 8032 for Ed25519). (Why: Wikipedia is useful for broad context; specs are stable for requirements.)
* Q/A forums and social posts. Stack Overflow, Reddit, and personal blogs **MUST NOT** be used as normative references. They **MAY** appear as background in the Explanation pages when no official source exists. (Why: anecdotal content is volatile and easily outdated.)
* TEPs specifics. Prefer the internal TON Docs page that explains a standard over linking directly to the TEPs repository. On pages that are themselves standards or reference docs (e.g., standard contracts), you **MAY** include a precise deep link to the corresponding TEP as the canonical spec. Avoid linking the repository root; link the exact TEP and section. (Why: TEPs are normative but difficult for newcomers; internal docs provide context while still letting experts reach the spec.)
* Stable permalinks (situation-aware). When linking to specific code/files/lines or exact doc sections where content must remain reproducible, you **SHOULD** use a versioned or permanent URL (e.g., GitHub tag/commit permalink; versioned docs; DOI). If a versioned URL exists and the reference is normative or precision-critical, you **MUST NOT** link to moving targets like “main”, “HEAD”, or “latest”. For general project references (homepage or repo root), you **MAY** use the canonical current URL. (Why: permalinks keep exact references stable; simple links are fine when versioning adds no value.) \[HIGH]
* Deep links. You **SHOULD** link to the exact section/anchor that holds the needed fact, not the page top. (Why: deep links land readers on the answer and reduce scanning.)
* Clean URLs. Links **MUST** use HTTPS, **MUST NOT** include shorteners or tracking parameters (e.g., `utm_*`), and **MUST NOT** point to unofficial mirrors/gists when an official location exists. (Why: clean, canonical URLs are trustworthy and durable.) \[HIGH]
* Language and availability. Link to the English source by default. If the authoritative page is non-English, **MUST** label the link with the language (e.g., “(in Russian)”). Avoid paywalled sources as primary; if unavoidable, **SHOULD** provide an open alternative or summarize key facts locally. (Why: sets expectations and preserves access.)
## Terminology and naming [#13-terminology-and-naming]
Objective. Enforce a single source of truth for terms and casing. (Why: one authoritative lexicon prevents confusion, reduces review churn, and keeps search/indexing consistent.)
### 13.1 Term bank (canonical source) [#131-term-bank-canonical-source]
* A project term bank **MUST** define canonical terms, spellings, hyphenation, casing, and banned variants with replacements (e.g., allowlist/denylist for whitelist/blacklist). (Why: clear entries stop ad-hoc wording and mixed casing from spreading.)
* You **MUST** consult the term bank before introducing new names; additions **SHOULD** be reviewed by editors. (Why: gatekeeping new terms prevents drift and conflicting synonyms.)
* The term bank **SHOULD** mark which terms are link-worthy for first-use cross-links and record their canonical doc URLs. First-use linking rules in [§12.2](#12-2-what-to-link-and-what-not) **SHOULD** apply only to terms above this importance threshold to avoid over-linking minor notions. (Why: a curated set of link-worthy terms keeps pages readable while still making key concepts discoverable.)
* Flags, parameters, error codes, and data types documented in guides **MUST** be included in this link-worthy set so first-use links in [§12.2](#12-2-what-to-link-and-what-not) always have a canonical target. This includes TVM exit codes, send modes, reserve modes, and other numeric constants with documented semantics. (Why: treating these technical items as link-worthy ensures readers can jump straight to their reference definitions.) \[HIGH]
### 13.2 General casing rules [#132-general-casing-rules]
* Generic concepts **MUST NOT** be capitalized mid-sentence (use "smart contract," not "Smart Contract"). (Why: random caps imply proper nouns and slow reading.) \[HIGH]
* Proper nouns and official product/feature names **MUST** follow the term bank (e.g., TON, TON Connect). (Why: consistent branding and accurate references.)
* Code identifiers (types, fields, flags) **MUST** appear in code font with exact case. (Why: preserves copy/paste fidelity and distinguishes code from prose.) \[HIGH]
### 13.3 Hyphenation and abbreviations [#133-hyphenation-and-abbreviations]
* Multi-word mechanism names are common nouns and **SHOULD** be hyphenated: proof-of-stake, zero-knowledge. (Why: hyphenation clarifies compounds and matches industry norms.)
* Abbreviated forms **MUST** follow the project style: ZK-proof, ZK-rollup (uppercase ZK, hyphenated compound). (Why: consistent abbreviation improves recognition and search.)
* Use mainnet as a common noun; use TON Mainnet (or just "mainnet") when referring to the proper name of the network. (Declare this explicitly in the term bank.) (Why: distinguishes generic network type from the named network.)
* Use testnet as a common noun; use TON Testnet (or just "testnet") when referring to the proper name of the network. (Why: same distinction as mainnet; avoids mixed casing.)
### 13.4 TON-specific examples [#134-ton-specific-examples]
Non-exhaustive; finalize in the term bank. (Why: examples guide writers now, while the term bank remains the single source of truth.)
* TON, TON Blockchain, TON Ecosystem (proper nouns).
* The native TON currency is called `Gram` (**NOT** `Toncoin`), and its ticker is `GRAM` (**NOT** `TON`).
* Do **NOT** use "TON" when meaning the currency, not the blockchain. Instead, use "Gram" as the currency and "GRAM" as the token ticker.
* Do **NOT** use "GRAM" when meaning the blockchain, not the currency ticker.
* smart contract, wallet, account, message, jetton, nominator, validator, collator, node, liteserver (common nouns, lowercase mid-sentence).
* accountchain, shardchain, workchain, masterchain, basechain — common nouns; use lowercase mid-sentence. **MUST NOT** use CamelCase forms (`ShardChain`, `WorkChain`, `MasterChain`, `BaseChain`, `AccountChain`) or spaced variants (e.g., “Shard Chain”).
* BoC (abbrev.) / bag of cells (common noun). Abbreviation **MUST** be “BoC” (not “BOC”).
Note: Do **NOT** introduce “master/slave” metaphors in new text; use primary/replica or similar. (Why: maintains inclusive language.)
### 13.5 Placeholder names [#135-placeholder-names]
* In commands and prose, placeholders **MUST** be `` with descriptive names: ``, ``, ``. (Why: a single, visible pattern reduces copy/paste mistakes.)
* In programming-language code, placeholders **MAY** use `UPPER_SNAKE` without angle brackets when `< >` would clash with syntax (see [§10.1](#10-1-general-rules)). (Why: avoids syntax errors while keeping placeholders obvious.)
* **MUST NOT** use `{curly}` or `[square]` placeholder syntax in copy-pasteable commands, as they are easy to misread as literal characters. (Why: braces/brackets are often treated as literals by shells and new users.) \[HIGH]
### 13.6 Banned and preferred terms [#136-banned-and-preferred-terms]
* Banned (inclusive/biased): whitelist/blacklist; master/slave; sanity check. \[HIGH]
* Banned (filler/tone): simply, just, obviously, clearly, please note.
* Banned (outdated): Toncoin (use Gram instead).
* Preferred: (omit filler); allowlist/denylist; primary/replica; smoke check or basic check.
Rationale: clarity, inclusivity, and reduced ambiguity.
## Numbers, units, date, and time [#14-numbers-units-date-and-time]
Objective. Present quantitative information unambiguously for a global developer audience. (Why: consistent formats prevent locale-based misreads and implementation errors.)
### 14.1 Numerals and separators [#141-numerals-and-separators]
* You **MUST** use numerals for all technical quantities (latency, memory, fees, block heights, versions, ports), regardless of size. (Why: digits are faster to scan and less ambiguous than words in technical contexts.)
* Good: “Set the fee to 0.2 GRAM.”
* For general prose without units, you **MAY** spell out zero–nine and use numerals for 10+, but prefer numerals whenever a value matters to a task. (Why: numbers highlight actionable values and make comparisons obvious.)
* You **SHOULD** use thousands separators for numbers ≥ 10,000: 10,000, 1,234,567. (Why: separators improve readability and reduce digit-counting mistakes.)
* **MUST NOT** add separators to codes/IDs (e.g., block hashes, transaction IDs, addresses), even if they contain digits; keep copyable values intact. (Why: added punctuation breaks copy/paste and changes identifiers.) \[HIGH]
* Decimal separator **MUST** be a dot: 3.1415. (Why: a single convention avoids comma/dot confusion across locales and matches most APIs.)
### 14.2 Units and conventions [#142-units-and-conventions]
* Use binary units (KiB, MiB, GiB) for memory/storage sizes and SI units (kB, MB, Gbps, ms) for network throughput, latency, and timing. Be consistent within each category. (Why: binary vs SI units have different meanings; consistency prevents 2× errors.)
* Currency amounts **MUST** specify the unit (e.g., GRAM, USDT). When precision matters, show decimals explicitly (e.g., 0.000001 GRAM). (Why: omitting units or precision leads to costly misinterpretation.) \[HIGH]
* Address/hash values **MUST NOT** be silently truncated. If truncation aids readability, use a consistent truncation pattern (e.g., first 4 / last 4 with an ellipsis: `EQC…9gA`) and state clearly that the value is truncated. (Why: silent truncation causes copy/paste failures and verification mistakes.) \[HIGH]
### 14.3 Dates and times [#143-dates-and-times]
* Dates **MUST** use ISO-8601 format YYYY-MM-DD (e.g., 2025-02-11). (Why: ISO is unambiguous and sorts correctly.)
* Times **SHOULD** be 24-hour and, where relevant, UTC (e.g., 14:30 UTC). (Why: avoids AM/PM ambiguity and timezone drift.)
* Use UTC for timestamps that might be compared across regions (e.g., transactions, block times, cron examples). (Why: a single timezone ensures consistent ordering and comparison.)
* Ranges **MUST** be explicit: 2025-02-11 14:30–15:00 UTC. (Why: clear start/end with timezone prevents misaligned windows.)
* **MUST NOT** use ambiguous forms like `11/2/2025`. (Why: day/month order varies by locale and leads to errors.)
* Changelogs **SHOULD** include a date stamp in ISO format. (Why: stable, sortable dates aid release tracking.)
### 14.4 Magnitudes and math [#144-magnitudes-and-math]
* Prefer engineering prefixes for readability: 1.2 GiB, 250 ms, 500 kB/s. (Why: normalized units make scale comparisons quick and reduce cognitive load.)
* Inline math **SHOULD** use KaTeX/LaTeX components when formulas help clarity. (Why: consistent rendering and accessibility across themes and locales.)
Rationale: Consistent numeric style reduces misreads and eases localization.
## Accessibility and internationalization [#15-accessibility-and-internationalization]
Objective. Ensure content is usable by all readers and easy to localize. (Why: accessible, localization-ready text works for non-native readers, assistive technologies, and translations without rewrites.)
### 15.1 Language and reading [#151-language-and-reading]
* Content **MUST** use plain, international English; avoid idioms, slang, and culture-specific metaphors. (Why: idioms and slang do not translate well and confuse global readers.)
* Link text and headings **MUST** be descriptive (screen-reader friendly). Avoid “click here” (see [§12](#12-links-and-cross-references)). (Why: descriptive text improves scanning and is meaningful when read aloud by assistive tech.)
* Avoid gendered or ableist terms; use inclusive alternatives (see [Appendix B](#b-banned-and-preferred-terms)). (Why: inclusive language prevents exclusion and avoids unnecessary friction.)
### 15.2 Structure and tables [#152-structure-and-tables]
* Tables **SHOULD** include header rows; keep cell content short and scannable. (Why: headers provide context for readers and screen readers; brief cells are easier to parse.)
* Units **MUST** be shown in headers or cells (e.g., “Latency (ms)”, “Size — MiB”). (Why: explicit units prevent misinterpretation of values.)
* Columns whose cells are primarily numeric values (for example, counts, sizes, fees, percentages, timings) **MUST** be right-aligned so digits line up vertically. (Why: aligned digits make numeric comparisons easier and reduce misreads.) \[HIGH]
* Columns whose cells contain identifiers such as addresses, hashes, transaction IDs, or error codes are not numeric columns and **MAY** remain left-aligned. (Why: identifier strings are scanned, copied, and compared differently than numeric quantities.)
* Cells **SHOULD NOT** contain multi-paragraph text; move extended explanations below the table. (Why: long prose in tables is hard to read and harms accessibility/layout.)
* Long lists inside cells **SHOULD** be converted to bullet lists placed below the table. (Why: lists outside tables are easier to scan and navigate.)
* Provide text alternatives for complex figures when feasible. (Why: alt or adjacent text lets screen-reader users and translators access the content.)
* Keyboard-only navigation **SHOULD** be considered when adding interactive elements. (Why: some users cannot use a mouse; keyboard support is a basic accessibility need.)
* Emojis **MAY** appear in compact tables as secondary indicators only when they follow a widely understood convention (e.g., `✅ Supported`, `❌ Not supported`) and are paired with clear text in the same cell. **MUST NOT** rely on emojis alone to encode meaning or status, and **MUST NOT** use decorative pictograms or one-off icons that do not have a clear, conventional meaning. (Why: paired, conventional indicators remain accessible and understandable when emojis do not render or in translation.)
### 15.3 Localization readiness [#153-localization-readiness]
* Prefer stable terminology from the term bank ([Appendix B](#b-banned-and-preferred-terms) references) to minimize translation drift. (Why: consistent terms reduce rework and inconsistent translations.)
* Dates/times already follow ISO conventions (see [§14.3](#14-3-dates-and-times)), which **SHOULD** simplify localization. (Why: ISO formats are unambiguous across locales and require minimal adaptation.)
Rationale: Clear, inclusive writing and accessible assets improve comprehension for global audiences and translation tools.
## File, navigation, and frontmatter conventions [#16-file-navigation-and-frontmatter-conventions]
Content of this section mostly describes contents of `.mdx` files and `[...](...)` markdown links in `.mdx` files.
### 16.1 Sidebar groups and ordering [#161-sidebar-groups-and-ordering]
Objective. Keep navigation predictable and reduce decision points. (Why: consistent ordering helps readers find the right kind of page without scanning the whole section.)
Rules (binding).
* The onboarding path **SHOULD** be a dedicated “Step by step” group near the top of the sidebar. Keep it linear and link out for depth. (Why: newcomers progress faster with one clear path.)
* Within every topical group (e.g., Ecosystem, Language reference, Standard contracts, TVM, Foundations, Smart-contract patterns, Contribute; Integrate when present), pages **MUST** be ordered: Explanation → How-to → Reference. (Why: readers scan “why” first, then “how”, then exact details.)
* The Explanation page **SHOULD** be the group’s overview (often `overview.mdx`). Keep it conceptual and brief, and link to How-to/Reference as needed. (Why: one conceptual entry frames the section and reduces duplication.)
* Reference pages **MUST** be the canonical source for flags/fields/errors/types. Guides **MUST NOT** duplicate tables; they **SHOULD** deep-link to anchors. (Why: single source of truth stays accurate and reduces maintenance.)
Objective. Keep repository structure and UI labels consistent. (Why: predictable structure speeds editing, improves search/TOC behavior, and reduces merge and build issues.)
### 16.2 Files and titles [#162-files-and-titles]
* Filenames **MUST** use kebab-case.md or kebab-case.mdx (e.g., `validator-setup.mdx`). (Why: kebab-case avoids case-sensitivity bugs, reads well in URLs, and is easy to grep.) \[HIGH]
* Filenames **MUST NOT** have uppercase characters, i.e. `foo-bAR.mdx`. \[HIGH]
* Filenames **MUST NOT** have cyrillic characters, i.e. `сhoice.mdx`. \[HIGH]
### 16.3 Navigation labels [#163-navigation-labels]
* Sidebar and nav labels **SHOULD** be short (2–4 words), unique, and mirror in-page headings. (Why: short, unique labels prevent truncation and speed scanning.)
* Sidebar labels **MAY** be concise aliases of the page title; they **SHOULD** preserve the title’s meaning even if wording is shortened. (Why: sidebars have less space; preserving meaning avoids confusion.)
* Child pages inside a sidebar group **MUST NOT** repeat the group name in `sidebarTitle` when that word adds no new meaning. Rely on the group label as context and choose a short, distinct label instead. (Why: avoiding redundant group nouns keeps nested labels concise and scannable.) \[HIGH]
* Example: in a group `Addresses`, prefer `sidebarTitle: "Overview"` or `sidebarTitle: "Deriving"` over `sidebarTitle: "Addresses overview"` or `sidebarTitle: "Deriving addresses"`.
* Avoid duplicate “Introduction” labels—make them specific (e.g., “Intro to sharding”). (Why: generic labels create indistinguishable TOC items and weak deep links.)
* Frontmatter keys. Use only page metadata supported by Mintlify (see project docs) and `noindex: true` when a page must be excluded from search indexing. **MUST NOT** introduce custom frontmatter keys for internal taxonomy (e.g., `doc_type`, `audience`, custom `status`). Represent such information in the page content or navigation instead. (Why: unsupported keys add maintenance burden, break tooling, and confuse contributors.)
* Length cap. If the frontmatter `title` exceeds 30 characters, the page **MUST** set `sidebarTitle`, and the `sidebarTitle` **MUST** be ≤ 30 characters. If the `title` is ≤ 30 characters, `sidebarTitle` is OPTIONAL; when provided, it **SHOULD** be ≤ 30 characters. Prefer removing non-essential words over truncation; labels **MUST NOT** end with ellipses; preserve meaning and proper-noun/case accuracy. (Why: short, clear labels fit sidebars and remain scannable.)
Example
```mdx
---
title: "How to troubleshoot validator connectivity issues on restrictive firewalls"
sidebarTitle: "Validator connectivity"
---
```
* How-to frontmatter pattern. How-to pages **MUST** set `title: "How to X"` and **MUST** set `sidebarTitle` to either `X` or a shorter alias of X that relies on the sidebar group for context and does not repeat the group name needlessly, where X is the task phrased in sentence case. If X begins with a letter, capitalize its first character; preserve exact casing for proper nouns and code tokens inside X. (Why: consistent titles match “how to …” searches; concise sidebar labels aid scanning while avoiding redundant group nouns and keeping identifiers accurate.) \[HIGH]
* Title vs sidebar semantics. The frontmatter `title` **MUST** be context-free and self-describing for search and deep links; the `sidebarTitle` **SHOULD** be concise and rely on the current navigation context. One-word generic titles (e.g., “Overview”, “Introduction”) **MUST NOT** be used as `title` except on top-level pages (`/the-page`) or when the page is a proper name/term (e.g., “MyTonWallet”, “TON Center”). In those cases, a one-word `title` **MAY** be used. Otherwise, the `title` **SHOULD** replicate or expand the section/folder name (e.g., “Sharding overview”), and the `sidebarTitle` **MAY** be “Overview”. (Why: descriptive titles improve discoverability and stand alone; short sidebar labels read better in context.)
Example
```mdx
---
title: "Sharding overview"
sidebarTitle: "Overview"
---
```
Example
```mdx
---
title: "How to get testnet Gram"
sidebarTitle: "Get testnet Gram"
---
```
### 16.4 Links and anchors [#164-links-and-anchors]
* Internal links **MUST** be root-absolute (start with `/`) and **MUST NOT** include `./` or `../`; ensure anchors are stable. (Why: root-absolute links survive file moves and changes to the information architecture; relative segments break during reorganizations.) \[HIGH]
* Trailing slashes: Follow a single repo-wide policy set by the site generator, and apply it consistently across all internal links. (Why: consistency prevents duplicate routes, cache misses, and SEO issues.)
* Cross-section links **SHOULD** target specific anchors rather than page tops. (Why: deep links land readers directly on the needed detail.)
### 16.5 Status labels [#165-status-labels]
* Pages and features **MAY** declare a status in content at the top of the page using an `` with a clear title (e.g., `title="Deprecated"` or `title="Experimental"`). Do not introduce custom frontmatter keys for status. (Why: status is visible to readers and does not require unsupported metadata.)
* If deprecated, the page **MUST** include the replacement (link to successor) and the removal timeline (date or version) in the callout. You **MAY** set `noindex: true` in frontmatter to exclude the page from search when appropriate. (Why: clear migration guidance reduces breakage; de-indexing avoids surfacing outdated pages.)
* If experimental, briefly state scope and limitations; link to the stable alternative when available. (Why: scope limits misuse and points to the dependable path.)
* Status labels (experimental/deprecated) are independent of safety callouts (see [§11](#11-safety-critical-content-blockchain-specific)). Apply both when applicable. (Why: status communicates lifecycle; safety communicates risk—readers need both.)
### 16.6 Components used in content [#166-components-used-in-content]
* On normal documentation pages, **SHOULD NOT** use `` components; prefer headings, lists, and inline links for navigation and structure. (Why: cards add visual chrome that is rarely needed for comprehension.)
* Existing `` usages **SHOULD** be confined to top-level index or overview pages where the card layout clearly improves navigation. Over time, simplify or remove cards that do not provide a clear navigation benefit. (Why: keeping cards to a few deliberate entry pages avoids fragmenting the visual style.)
* When an index-style page genuinely needs card-like tiles, you **MAY** use ``; keep the content inside each card minimal and avoid duplicating information from the linked pages. (Why: cards should support navigation, not introduce a second layer of prose.)
* More generally, follow the “minimal styling” workflow from [§6.2](#6-2-quotation-marks-and-emphasis): components such as ``, ``, ``, or tab containers **SHOULD** appear only when they improve comprehension or navigation, not as decoration. (Why: reduced decorative chrome makes structure and behavior stand out.)
## Content hygiene and timeless writing [#17-content-hygiene-and-timeless-writing]
Objective. Reduce staleness, duplication, and maintenance costs. (Why: fresh, non-duplicated content is cheaper to maintain and more trustworthy for readers.)
### 17.1 Single source of truth [#171-single-source-of-truth]
* Each fact **MUST** have a canonical home. If you need the same fact elsewhere, link to it (see [§12](#12-links-and-cross-references)). (Why: one source prevents contradictions and simplifies updates.)
* Guides **MUST NOT** replicate reference tables; summarize and link. (Why: duplicated tables drift and become incorrect.)
### 17.2 Timelessness [#172-timelessness]
* You **SHOULD NOT** use words like “currently”, “new”, or “soon”. (Why: time-relative words stale quickly and lose meaning.)
* Prefer durable phrasing: “Since v2.3, X is supported,” not “newly added.” (Why: version-based phrasing stays accurate over time.)
* Remove version qualifiers once they’re no longer useful. (Why: eliminates outdated noise and keeps prose evergreen.)
### 17.3 Freshness and updates [#173-freshness-and-updates]
* When behavior changes, the relevant pages **MUST** be updated promptly. (Why: outdated steps cause failures and support load.)
* Large refactors **SHOULD** include redirects and update cross-links. (Why: preserves deep links and prevents 404s.)
* Avoid re-documenting external tools; link to official docs and focus on TON-specific usage. (Why: external details change often; linking reduces churn.)
### 17.4 Proofread [#174-proofread]
* Read aloud or skim with a “scanner’s eye”; long sentences **SHOULD** be split (see [§8](#8-readability-and-scannability)). (Why: catches awkward phrasing and improves scannability.)
* Check terms against the term bank; enforce casing and spelling consistently. (Why: consistent terminology improves comprehension and search.)
Rationale: “Timeless” style and a canonical home for facts keep the docs trustworthy and maintainable.
## Style exceptions and edge cases [#18-style-exceptions-and-edge-cases]
Objective. Provide a controlled escape hatch without eroding consistency. (Why: limited, trackable exceptions solve real edge cases without letting the style drift.)
* Any deviation from this guide **MUST** document: the rule being overridden, the reason, the scope (pages affected), the owner, and an expiry or review date. (Why: documentation, ownership, and a sunset make exceptions accountable and reversible.)
* Exceptions **SHOULD** be rare, time-boxed, and revisited. (Why: scarcity prevents precedent; time limits force cleanup.)
* For audience-critical reasons (e.g., highly advanced research notes), a page **MAY** relax sentence-length norms ([§8](#8-readability-and-scannability)) or include extra theory in a how-to ([§3](#3-documentation-framework-content-types)), but the page **MUST** clearly state the rationale at the top (e.g., Audience: Advanced). (Why: transparency lets readers self-select and prevents surprise.)
* When quoting external code or configuration verbatim for legal or technical reasons, formatting **MAY** violate some house rules if changing it would misrepresent the original. Such cases **SHOULD** be rare and, for large or recurring examples, **SHOULD** be documented as style exceptions with scope and owner. (Why: fidelity to external sources sometimes takes priority over local formatting rules.)
* A safety requirement ([§11](#11-safety-critical-content-blockchain-specific)) **MUST NOT** be waived. (Why: reader safety outweighs convenience.) \[HIGH]
Rationale: Exceptions exist to serve clarity, not convenience. They are documented so future editors can normalize them later.
## Appendices [#19-appendices]
### A. Admonition levels and usage [#a-admonition-levels-and-usage]
Use the least severe callout that communicates the point; overuse reduces impact. (Why: calibrated severity keeps important warnings noticeable; overuse leads to alert fatigue.)
Implementation. Render callouts with the `` component (see `/src/components/mdx/callout.tsx`). **MUST NOT** use Markdown blockquotes (`>`) to simulate callouts. The only supported `type` values are `note`, `tip`, `caution`, and `danger`. Map levels to types: Note → `type="note"`; Tip → `type="tip"`; Caution → `type="caution"`; Warning → `type="danger"`. Use `title` to set the visible label when needed (e.g., `title="Important"`). (Why: consistent components and a fixed type set keep callouts accessible and visually coherent.) \[HIGH]
* On pages with multiple hazardous actions, combine a page-level safety `` at the top (describing overall risk, scope, rollback/mitigation where feasible, and environment) with short local `` elements near each dangerous step that can refer back to the summary instead of repeating it. (Why: the combination keeps risks visible without duplicating long warnings at every step.)
| Level | When to use | MUST include |
| --------- | -------------------------------------------------------- | ----------------------------------------------- |
| Note | Auxiliary info or minor edge cases | Short, actionable text only |
| Tip | Productivity boosters, shortcuts | A clear benefit (“Saves time by …”) |
| Important | Prerequisites, state assumptions, gotchas | The condition and its effect |
| Caution | Potential data loss or non-recoverable state | Risk + mitigation/rollback |
| Warning | Security, funds/keys/validator risk, chain-affecting ops | Risk + scope + rollback + testnet/mainnet label |
(Why: the “MUST include” fields ensure every callout contains the minimum information a reader needs to act safely.)
Examples
* Important — prerequisite
“This guide requires a funded testnet wallet.”
* Caution — data loss
“`--purge-ledger` removes local data. Back up `` before running.”
* Warning — funds at risk
“Transfers on mainnet are final.”
* Warning — page with many risky steps
“Read the safety note at the top of this page before running any mainnet commands.”
(Admonition usage aligns with the safety requirements in [§11](#11-safety-critical-content-blockchain-specific).)
### B. Banned and preferred terms [#b-banned-and-preferred-terms]
Use this list in combination with the project term bank (see [§13](#13-terminology-and-naming)). Editors **MUST** expand it over time. (Why: the lexicon evolves; keeping it current prevents drift and inconsistency.)
Filler/tone (ban outright) (Why: filler adds no information and can sound condescending.)
* Banned: simply, just, obviously, clearly, please note, super-, ASAP
* Use instead: omit or state the concrete action/effect
Marketing/promotional (ban outright) (Why: marketing language erodes trust, adds no actionable information, and ages poorly.)
* Banned superlatives: blazingly fast, revolutionary, world-class, seamless, best-in-class, powerful, cutting-edge, game-changing, next-generation
* Banned vague adjectives (without measurable criteria): reliable, robust, essential, elegant, intuitive, flexible, comprehensive, scalable, efficient, optimal, superior
* Banned dramatic/emotional words: elusive, challenging (as drama), painful, frustrating, nightmare, perfectly, beautifully, amazing, incredible, stunning
* Banned intensity words: instantly (unless literal), immediately (unless literal), extremely, incredibly, massive, huge (for non-quantified values)
* Banned storytelling openers: "Imagine…", "Picture this…", "Have you ever…", "What if…"
* Use instead: measurable facts, specific numbers, concrete conditions, or omit entirely
Inclusivity (Why: inclusive terms are clearer for everyone and avoid excluding readers.)
* Banned: whitelist/blacklist → Preferred: allowlist/denylist
* Banned: master/slave → Preferred: primary/replica (or leader/follower, depending on context)
* Banned: sanity check → Preferred: basic check / smoke check
* Banned: dummy value → Preferred: sample value / placeholder
* Banned: crazy/insane → Preferred: unexpected / invalid
Clarity (Why: simpler words are read and translated more reliably.)
* Avoid: utilize → Use: use
* Avoid: prior to → Use: before
* Avoid: in order to → Use: to
* Avoid: leverage (as verb) → Use: use/apply
* Avoid: handle → Use: process/manage (be specific)
TON-specific casing (selected; see [§13](#13-terminology-and-naming) for more) (Why: exact casing improves search, recognition, and copy/paste fidelity.)
* Correct: TON, TON Mainnet (or just "mainnet"); smart contract; bag of cells; BoC; accountchain, shardchain, workchain, masterchain, basechain; ZK-proof, ZK-rollup.
* Incorrect: Ton; ton mainnet; Smart Contract; BOC; ShardChain; Shard Chain; WorkChain.
1. Blockchain config 2. Node source code
### Contract is not precompiled [#1-contract-is-not-precompiled]
The contract code hash is not in `ConfigParam 45`. TVM executes normally with standard gas accounting.
[`GETPRECOMPILEDGAS`](#accessing-precompiled-gas-value) returns `null`. Transaction result: `gas_used` reflects actual TVM consumption.
### Contract is precompiled [#2-contract-is-precompiled]
The contract code hash exists in `ConfigParam 45`. The validator checks the contract balance against the configured `gas_usage`. If insufficient, the compute phase fails with `cskip_no_gas`.
Otherwise, execution proceeds via one of two paths.
#### Contract has native C++ implementation [#contract-has-native-c-implementation]
The native C++ implementation is available and enabled in the validator node. The validator executes the C++ code directly without invoking TVM.
Transaction [result](https://docs.ton.org/llms/foundations/phases/content.md):
* `gas_used` set to the value from `ConfigParam 45`
* `vm_steps`, `vm_init_state_hash`, `vm_final_state_hash` set to zero
#### Contract has no native C++ implementation [#contract-has-no-native-c-implementation]
The native C++ implementation is disabled or unavailable in the validator node. TVM executes the contract code normally.
[`GETPRECOMPILEDGAS`](#accessing-precompiled-gas-value) returns the configured gas value during execution.
After execution completes, the validator overrides the compute phase values.
Transaction result:
* `gas_used` set to the value from `ConfigParam 45`
* `vm_steps`, `vm_init_state_hash`, `vm_final_state_hash` set to zero
The override ensures that both execution paths produce identical transaction results. This allows validators with and without native C++ implementations to coexist in the network and enables gradual adoption when adding new entries to `ConfigParam 45`.
#### Trustless vs. custodial bridges [#1-trustless-vs-custodial-bridges]
Trustless bridges:
* Use smart contracts and cryptographic proofs for validation
* No single point of failure
* Decentralized verification mechanisms
Centralized bridges:
* Rely on trusted entities or multi-signature wallets
* Single point of failure risk
* Generally, they are easier to implement
#### Asset transfer methods [#2-asset-transfer-methods]
Lock-and-Mint bridges:
* Lock original assets on the source chain
* Mint wrapped tokens on the destination chain
* Most common bridge type
Burn-and-Mint bridges:
* Burn tokens on the source chain
* Mint new tokens on the destination chain
* Used for native multi-chain tokens
`cc:uint8` | `26` | 8-bit prefix, 8-bit operand | | [`PUSHINT_LONG`](https://docs.ton.org/llms/tvm/instructions/content.md) | `#82`
`l:(## 5)`
`xxx:(int (8 * l + 19))` | `23` | 8-bit prefix, 5-bit operand, length of `xxx` depends on `l`, so it is not included | | [`STSLICE_CONST`](https://docs.ton.org/llms/tvm/instructions/content.md) | `#CFC0_`
`x:(## 2)`
`y:(## 3)`
`c:(x * ^Cell)`
`sss:((8 * y + 2) * Bit)` | `24` | 9-bit prefix (`CF` is 8 bits, `C0_` is `C_`, which is just bit `1`), 2-bit and 3-bit operands, refs `c` and variable-length `sss` are not included | ## Cell operations [#cell-operations] When any instruction internally finalizes a `Builder` to a `Cell`, it consumes `500` gas. When a `Cell` is loaded as a `Slice`, it consumes `100` gas for the first access in current smart contract invocation, and `25` gas for each subsequent load from cache. Cells are identified by representation hash, e.g., loading cell with the same hash for the second time will always cost `25` gas. This applies to all instructions that internally operate with cells (including dictionary operations). The only exceptions are: * `BTOS` converts a `Builder` to a `Slice` without consuming gas for cell operations. * `HASHBU` computes hash without consuming gas for converting `Builder` to a `Cell` ## Exceptions [#exceptions] TVM consumes `50` gas when any exception is thrown, both explicitly by [`THROW`](https://docs.ton.org/llms/tvm/instructions/content.md)-like instructions or implicitly during execution of other instructions. This happens before the jump to the exception handler `c2`. ## Implicit jumps and returns [#implicit-jumps-and-returns] When the current continuation ends and there is a remaining reference, TVM jumps to it and consumes `10` gas. When there are no instructions to execute and references to jump to, implicit return to `c0` occurs, which consumes `5` gas. ## Nested continuations [#nested-continuations] Calling more than `8` extraordinary continuations in a chain consumes `1` gas for each subsequent continuation. ## Tuple operations [#tuple-operations] [`TUPLE`](https://docs.ton.org/llms/tvm/instructions/content.md), [`TUPLEVAR`](https://docs.ton.org/llms/tvm/instructions/content.md), [`UNTUPLE`](https://docs.ton.org/llms/tvm/instructions/content.md), [`UNTUPLEVAR`](https://docs.ton.org/llms/tvm/instructions/content.md), [`UNPACKFIRST`](https://docs.ton.org/llms/tvm/instructions/content.md), [`UNPACKFIRSTVAR`](https://docs.ton.org/llms/tvm/instructions/content.md), [`EXPLODE`](https://docs.ton.org/llms/tvm/instructions/content.md), [`EXPLODEVAR`](https://docs.ton.org/llms/tvm/instructions/content.md) consumes `1` gas for each entry been pushed or popped into a tuple. [`TPUSH`](https://docs.ton.org/llms/tvm/instructions/content.md), [`TPOP`](https://docs.ton.org/llms/tvm/instructions/content.md), [`SETINDEX`](https://docs.ton.org/llms/tvm/instructions/content.md), [`SETINDEXVAR`](https://docs.ton.org/llms/tvm/instructions/content.md), [`SETINDEXQ`](https://docs.ton.org/llms/tvm/instructions/content.md)/[`SETINDEXVARQ`](https://docs.ton.org/llms/tvm/instructions/content.md) consumes `len(tuple)` gas for the resulting tuple size after push/pop/set. Same applies to instructions operating with `c7`: [`SETGLOB`](https://docs.ton.org/llms/tvm/instructions/content.md)/[`SETGLOBVAR`](https://docs.ton.org/llms/tvm/instructions/content.md), [`RANDU256`](https://docs.ton.org/llms/tvm/instructions/content.md)/[`RAND`](https://docs.ton.org/llms/tvm/instructions/content.md), [`SETRAND`](https://docs.ton.org/llms/tvm/instructions/content.md), [`ADDRAND`](https://docs.ton.org/llms/tvm/instructions/content.md). ## Stack operations [#stack-operations] TVM consumes 1 gas for each stack element deeper than 32 elements inside the resulting new stack each time stack gets copied: when calling or jumping to a continuation with a non-empty argument number, an initial stack, or both, when extending a continuation stack using [`SETCONTARGS`](https://docs.ton.org/llms/tvm/instructions/content.md) and similar instructions, when using [`RUNVM`](https://docs.ton.org/llms/tvm/instructions/content.md) (both for initial and resulting stacks of the vm). ## Extra currency [#extra-currency] The first `5` executions of `GETEXTRABALANCE` consume at most `26 + 200` gas each. The subsequent executions incur the full gas cost of `26` (normal instruction cost) plus gas for loading cells (up to `3300` if the dictionary has maximum depth). ## RUNVM [#runvm] [`RUNVM`](https://docs.ton.org/llms/tvm/instructions/content.md) and [`RUNVMX`](https://docs.ton.org/llms/tvm/instructions/content.md) consume `40` extra gas before starting a VM. ## Cryptography [#cryptography] ### CHKSIGNS/CHKSIGNU [#chksignschksignu] [`CHKSIGNS`](https://docs.ton.org/llms/tvm/instructions/content.md) and [`CHKSIGNU`](https://docs.ton.org/llms/tvm/instructions/content.md) can be invoked `10` times without extra gas cost. Next checks will cost `4000` gas each. ### HASHEXT [#hashext] `HASHEXT*` instructions always consume `1` extra gas for each part of the input. Additionally, the following gas is consumed for each hashed byte: | Algorithm | Gas consumed | | --------- | ------------- | | SHA256 | 1/33 per byte | | SHA512 | 1/16 per byte | | BLAKE2B | 1/19 per byte | | KECCAK256 | 1/11 per byte | | KECCAK512 | 1/6 per byte | Only the integer part of the gas is consumed; for example, 0-32 bytes of SHA256 cost 0 gas, 33-64 bytes cost 1 gas, and so on. ### RIST255 [#rist255] Instructions consume constant extra gas. | Instruction | Extra gas | | ------------------------------------------------------------- | --------- | | [`RIST255_FROMHASH`](https://docs.ton.org/llms/tvm/instructions/content.md) | 600 | | [`RIST255_VALIDATE`](https://docs.ton.org/llms/tvm/instructions/content.md) | 200 | | [`RIST255_ADD`](https://docs.ton.org/llms/tvm/instructions/content.md) | 600 | | [`RIST255_MUL`](https://docs.ton.org/llms/tvm/instructions/content.md) | 2000 | | [`RIST255_MULBASE`](https://docs.ton.org/llms/tvm/instructions/content.md) | 750 | ### Other instructions [#other-instructions] [`ECRECOVER`](https://docs.ton.org/llms/tvm/instructions/content.md) consumes 1500 extra gas. `SECP256K1_XONLY_PUBKEY_TWEAK_ADD` consumes 1250 extra gas. [`P256_CHKSIGNU`](https://docs.ton.org/llms/tvm/instructions/content.md) and [`P256_CHKSIGNS`](https://docs.ton.org/llms/tvm/instructions/content.md) consume 3500 extra gas. ### BLS [#bls] #### Signature verification and aggregation [#signature-verification-and-aggregation] | Instruction | Gas consumed | Notes | | ----------------------------------------------------------------------------- | ------------------- | --------------------------------------------------------------------------------- | | [`BLS_VERIFY`](https://docs.ton.org/llms/tvm/instructions/content.md) | `61000` | | | [`BLS_AGGREGATE`](https://docs.ton.org/llms/tvm/instructions/content.md) | `-2650 + 4350 * n` | `n` is the number of signatures aggregated. | | [`BLS_FASTAGGREGATEVERIFY`](https://docs.ton.org/llms/tvm/instructions/content.md) | `58000 + 3000 * n` | `n` is the number of public keys verified against one message/signature pair. | | [`BLS_AGGREGATEVERIFY`](https://docs.ton.org/llms/tvm/instructions/content.md) | `38500 + 22500 * n` | `n` is the number of `(public key, message)` pairs checked against one signature. | #### G1 group helpers [#g1-group-helpers] | Instruction | Gas consumed | | --------------------------------------------------------------------------------------------------------- | ------------ | | [`BLS_G1_ADD`](https://docs.ton.org/llms/tvm/instructions/content.md) / [`BLS_G1_SUB`](https://docs.ton.org/llms/tvm/instructions/content.md) | `3900` | | [`BLS_G1_NEG`](https://docs.ton.org/llms/tvm/instructions/content.md) | `750` | | [`BLS_G1_MUL`](https://docs.ton.org/llms/tvm/instructions/content.md) | `5200` | | [`BLS_MAP_TO_G1`](https://docs.ton.org/llms/tvm/instructions/content.md) | `2350` | | [`BLS_G1_INGROUP`](https://docs.ton.org/llms/tvm/instructions/content.md) | `2950` | [`BLS_G1_MULTIEXP`](https://docs.ton.org/llms/tvm/instructions/content.md) consumes `11375 + 630 * n + (8820 * n) / max(log₂ n, 4)` extra gas, where `n` is the number of `(point, scalar)` pairs. Instructions [`BLS_G1_ZERO`](https://docs.ton.org/llms/tvm/instructions/content.md) and [`BLS_G1_ISZERO`](https://docs.ton.org/llms/tvm/instructions/content.md) do not charge additional gas. #### G2 group helpers [#g2-group-helpers] | Instruction | Gas consumed | | --------------------------------------------------------------------------------------------------------- | ------------ | | [`BLS_G2_ADD`](https://docs.ton.org/llms/tvm/instructions/content.md) / [`BLS_G2_SUB`](https://docs.ton.org/llms/tvm/instructions/content.md) | `6100` | | [`BLS_G2_NEG`](https://docs.ton.org/llms/tvm/instructions/content.md) | `1550` | | [`BLS_G2_MUL`](https://docs.ton.org/llms/tvm/instructions/content.md) | `10550` | | [`BLS_MAP_TO_G2`](https://docs.ton.org/llms/tvm/instructions/content.md) | `7950` | | [`BLS_G2_INGROUP`](https://docs.ton.org/llms/tvm/instructions/content.md) | `4250` | [`BLS_G2_MULTIEXP`](https://docs.ton.org/llms/tvm/instructions/content.md) consumes `30388 + 1280 * n + (22840 * n) / max(log₂ n, 4)` gas, where `n` is the number of `(point, scalar)` pairs. Instructions [`BLS_G2_ZERO`](https://docs.ton.org/llms/tvm/instructions/content.md) and [`BLS_G2_ISZERO`](https://docs.ton.org/llms/tvm/instructions/content.md) do not charge additional gas. #### Pairing and constants [#pairing-and-constants] | Instruction | Gas consumed | Notes | | ----------------------------------------------------- | ------------------- | ----------------------------------------------------------------------------- | | [`BLS_PAIRING`](https://docs.ton.org/llms/tvm/instructions/content.md) | `20000 + 11800 * n` | `n` is the number of `(G1, G2)` pairs supplied for the pairing product check. | [`BLS_PUSHR`](https://docs.ton.org/llms/tvm/instructions/content.md) do not charge additional gas. ## `GasLimits` structure [#gaslimits-structure] TVM has inner structure `GasLimits` for gas manipulations. Its fields are: * `gas_max`: the equivalent of contract's balance at the start of the compute phase in gas units. * `gas_limit`: the amount of gas that can be consumed during the virtual machine execution. At the start of the execution, it equals: * minimum of `gas_max` and the amount of gas that can be bought with the incoming message value (i.e., the amount of GRAM coins attached to the message) in the case of an internal message; * `0` in the case of an external message. * `gas_credit`: the amount of free gas that can be spent during the execution before accepting an external message. At the start of the execution, it equals: * minimum of `gas_max` and corresponding value in configuration parameter `20` for masterchain and `21` for basechain in the case of an external message; * `0` in the case of an internal message. * `gas_remaining`: the amount of available but not spent gas. At the start of the execution, it equals `gas_limit + gas_credit`. It decreases after each instruction execution by the amount of gas consumed by the instruction. * `gas_base`: an auxiliary parameter that is necessary for rebasing and shows the initial value of `gas_remaining`. At the start of the execution, it equals `gas_remaining`. Instructions `SETGASLIMIT` and `ACCEPT` change all above values except `gas_max`: * `SETGASLIMIT` sets `gas_limit` to the minimum of the indicated value and `gas_max`, `gas_credit` to zero, `gas_base` to the new `gas_limit`, and `gas_remaining` to `gas_remaining + (new gas_base - old gas_base)`. * `ACCEPT` is equivalent to `SETGASLIMIT` with the new gas limit equal to `2**63 - 1` (the maximum value of a signed 64-bits integer). The final value (in gas units) that will be deducted from contract's balance after the execution is `gas_base - gas_remaining`. Note that this value will be deducted if and only if after the execution `gas_credit` is zero, i.e. if `SETGASLIMIT` or `ACCEPT` was called at least once during the execution in the case of incoming external message. Without condition `gas_credit == 0`, there will be no commit of the new code and data. # Get methods (https://docs.ton.org/llms/tvm/get-method/content.md) Get methods are smart contract methods that are supposed to be executed off-chain. They are useful for structured retrieval of data from a smart contract ([`get_collection_data` get-method on an NFT collection](https://docs.ton.org/llms/contracts/standard/tokens/nft/nft-reference/content.md)), and for any logic that is a part of a smart contract but is needed off-chain ([`get_nft_address_by_index` get-method on an NFT collection](https://docs.ton.org/llms/contracts/standard/tokens/nft/nft-reference/content.md)). Under the hood of APIs, this happens by fetching the actual state of the smart contract from the blockchain and executing TVM to get the result. This process is purely read-only and does not modify the blockchain state in any way. ## Defining [#defining] Get methods are processed by the [function selector](https://docs.ton.org/llms/tvm/registers/content.md). By convention, the ID of a get method is calculated as `crc16("name") | 0x10000` where `name` is set by the developer. This simplifies practical usage because a human-readable name has to be used instead of some arbitrary number.
#### `00` NOP [#00-nop]
Does nothing.
**Category:** Stack Basic (stack\_basic)
```fift title="Fift" NOP ``` #### `0i` XCHG\_0I [#0i-xchg_0i] Interchanges `s0` with `s[i]`, `1 <= i <= 15`.
**Category:** Stack Basic (stack\_basic)
```fift title="Fift" s[i] XCHG0 ``` **Aliases**: * `SWAP`
Same as `s1 XCHG0`. #### `10ij` XCHG\_IJ [#10ij-xchg_ij] Interchanges `s[i]` with `s[j]`, `1 <= i < j <= 15`.
**Category:** Stack Basic (stack\_basic)
```fift title="Fift" s[i] s[j] XCHG ``` #### `11ii` XCHG\_0I\_LONG [#11ii-xchg_0i_long] Interchanges `s0` with `s[ii]`, `0 <= ii <= 255`.
**Category:** Stack Basic (stack\_basic)
```fift title="Fift" s0 [ii] s() XCHG ``` #### `1i` XCHG\_1I [#1i-xchg_1i] Interchanges `s1` with `s[i]`, `2 <= i <= 15`.
**Category:** Stack Basic (stack\_basic)
```fift title="Fift" s1 s[i] XCHG ``` #### `2i` PUSH [#2i-push] Pushes a copy of the old `s[i]` into the stack.
**Category:** Stack Basic (stack\_basic)
```fift title="Fift" s[i] PUSH ``` **Aliases**: * `DUP`
Same as `s0 PUSH`. * `OVER`
Same as `s1 PUSH`. #### `3i` POP [#3i-pop] Pops the old `s0` value into the old `s[i]`.
**Category:** Stack Basic (stack\_basic)
```fift title="Fift" s[i] POP ``` **Aliases**: * `DROP`
Same as `s0 POP`, discards the top-of-stack value. * `NIP`
Same as `s1 POP`. #### `4ijk` XCHG3 [#4ijk-xchg3] Equivalent to `s2 s[i] XCHG` `s1 s[j] XCHG` `s[k] XCHG0`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" s[i] s[j] s[k] XCHG3 ``` #### `50ij` XCHG2 [#50ij-xchg2] Equivalent to `s1 s[i] XCHG` `s[j] XCHG0`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" s[i] s[j] XCHG2 ``` #### `51ij` XCPU [#51ij-xcpu] Equivalent to `s[i] XCHG0` `s[j] PUSH`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" s[i] s[j] XCPU ``` #### `52ij` PUXC [#52ij-puxc] Equivalent to `s[i] PUSH` `SWAP` `s[j] XCHG0`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" s[i] s[j-1] PUXC ``` #### `53ij` PUSH2 [#53ij-push2] Equivalent to `s[i] PUSH` `s[j+1] PUSH`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" s[i] s[j] PUSH2 ``` #### `540ijk` XCHG3\_ALT [#540ijk-xchg3_alt] Long form of `XCHG3`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" s[i] s[j] s[k] XCHG3_l ``` #### `541ijk` XC2PU [#541ijk-xc2pu] Equivalent to `s[i] s[j] XCHG2` `s[k] PUSH`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" s[i] s[j] s[k] XC2PU ``` #### `542ijk` XCPUXC [#542ijk-xcpuxc] Equivalent to `s1 s[i] XCHG` `s[j] s[k-1] PUXC`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" s[i] s[j] s[k-1] XCPUXC ``` #### `543ijk` XCPU2 [#543ijk-xcpu2] Equivalent to `s[i] XCHG0` `s[j] s[k] PUSH2`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" s[i] s[j] s[k] XCPU2 ``` #### `544ijk` PUXC2 [#544ijk-puxc2] Equivalent to `s[i] PUSH` `s2 XCHG0` `s[j] s[k] XCHG2`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" s[i] s[j-1] s[k-1] PUXC2 ``` #### `545ijk` PUXCPU [#545ijk-puxcpu] Equivalent to `s[i] s[j-1] PUXC` `s[k] PUSH`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" s[i] s[j-1] s[k-1] PUXCPU ``` #### `546ijk` PU2XC [#546ijk-pu2xc] Equivalent to `s[i] PUSH` `SWAP` `s[j] s[k-1] PUXC`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" s[i] s[j-1] s[k-2] PU2XC ``` #### `547ijk` PUSH3 [#547ijk-push3] Equivalent to `s[i] PUSH` `s[j+1] s[k+1] PUSH2`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" s[i] s[j] s[k] PUSH3 ``` #### `55ij` BLKSWAP [#55ij-blkswap] Permutes two blocks `s[j+i+1] ... s[j+1]` and `s[j] ... s0`.
`0 <= i,j <= 15`
Equivalent to `[i+1] [j+1] REVERSE` `[j+1] 0 REVERSE` `[i+j+2] 0 REVERSE`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" [i+1] [j+1] BLKSWAP ``` **Aliases**: * `ROT2`
Rotates the three topmost pairs of stack entries. * `ROLL`
Rotates the top `i+1` stack entries.
Equivalent to `1 [i+1] BLKSWAP`. * `ROLLREV`
Rotates the top `i+1` stack entries in the other direction.
Equivalent to `[i+1] 1 BLKSWAP`. #### `56ii` PUSH\_LONG [#56ii-push_long] Pushes a copy of the old `s[ii]` into the stack.
`0 <= ii <= 255`
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" [ii] s() PUSH ``` #### `57ii` POP\_LONG [#57ii-pop_long] Pops the old `s0` value into the old `s[ii]`.
`0 <= ii <= 255`
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" [ii] s() POP ``` #### `58` ROT [#58-rot] Equivalent to `1 2 BLKSWAP` or to `s2 s1 XCHG2`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" ROT ``` #### `59` ROTREV [#59-rotrev] Equivalent to `2 1 BLKSWAP` or to `s2 s2 XCHG2`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" ROTREV -ROT ``` #### `5A` SWAP2 [#5a-swap2] Equivalent to `2 2 BLKSWAP` or to `s3 s2 XCHG2`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" SWAP2 2SWAP ``` #### `5B` DROP2 [#5b-drop2] Equivalent to `DROP` `DROP`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" DROP2 2DROP ``` #### `5C` DUP2 [#5c-dup2] Equivalent to `s1 s0 PUSH2`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" DUP2 2DUP ``` #### `5D` OVER2 [#5d-over2] Equivalent to `s3 s2 PUSH2`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" OVER2 2OVER ``` #### `5Eij` REVERSE [#5eij-reverse] Reverses the order of `s[j+i+1] ... s[j]`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" [i+2] [j] REVERSE ``` #### `5F0i` BLKDROP [#5f0i-blkdrop] Equivalent to `DROP` performed `i` times.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" [i] BLKDROP ``` #### `5Fij` BLKPUSH [#5fij-blkpush] Equivalent to `PUSH s(j)` performed `i` times.
`1 <= i <= 15`, `0 <= j <= 15`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" [i] [j] BLKPUSH ``` #### `60` PICK [#60-pick] Pops integer `i` from the stack, then performs `s[i] PUSH`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" PICK PUSHX ``` #### `61` ROLLX [#61-rollx] Pops integer `i` from the stack, then performs `1 [i] BLKSWAP`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" ROLLX ``` #### `62` -ROLLX [#62--rollx] Pops integer `i` from the stack, then performs `[i] 1 BLKSWAP`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" -ROLLX ROLLREVX ``` #### `63` BLKSWX [#63-blkswx] Pops integers `i`,`j` from the stack, then performs `[i] [j] BLKSWAP`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" BLKSWX ``` #### `64` REVX [#64-revx] Pops integers `i`,`j` from the stack, then performs `[i] [j] REVERSE`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" REVX ``` #### `65` DROPX [#65-dropx] Pops integer `i` from the stack, then performs `[i] BLKDROP`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" DROPX ``` #### `66` TUCK [#66-tuck] Equivalent to `SWAP` `OVER` or to `s1 s1 XCPU`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" TUCK ``` #### `67` XCHGX [#67-xchgx] Pops integer `i` from the stack, then performs `s[i] XCHG`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" XCHGX ``` #### `68` DEPTH [#68-depth] Pushes the current depth of the stack.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" DEPTH ``` #### `69` CHKDEPTH [#69-chkdepth] Pops integer `i` from the stack, then checks whether there are at least `i` elements, generating a stack underflow exception otherwise.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" CHKDEPTH ``` #### `6A` ONLYTOPX [#6a-onlytopx] Pops integer `i` from the stack, then removes all but the top `i` elements.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" ONLYTOPX ``` #### `6B` ONLYX [#6b-onlyx] Pops integer `i` from the stack, then leaves only the bottom `i` elements. Approximately equivalent to `DEPTH` `SWAP` `SUB` `DROPX`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" ONLYX ``` #### `6Cij` BLKDROP2 [#6cij-blkdrop2] Drops `i` stack elements under the top `j` elements.
`1 <= i <= 15`, `0 <= j <= 15`
Equivalent to `[i+j] 0 REVERSE` `[i] BLKDROP` `[j] 0 REVERSE`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" [i] [j] BLKDROP2 ``` #### `6D` NULL [#6d-null] Pushes the only value of type *Null*.
**Category:** Tuple (tuple)
```fift title="Fift" NULL PUSHNULL ``` **Aliases**: * `NEWDICT`
Returns a new empty dictionary.
It is an alternative mnemonics for `PUSHNULL`. #### `6E` ISNULL [#6e-isnull] Checks whether `x` is a *Null*, and returns `-1` or `0` accordingly.
**Category:** Tuple (tuple)
```fift title="Fift" ISNULL ``` **Aliases**: * `DICTEMPTY`
Checks whether dictionary `D` is empty, and returns `-1` or `0` accordingly.
It is an alternative mnemonics for `ISNULL`. #### `6F0n` TUPLE [#6f0n-tuple] Creates a new *Tuple* `t=(x_1, ... ,x_n)` containing `n` values `x_1`,..., `x_n`.
`0 <= n <= 15`
**Category:** Tuple (tuple)
```fift title="Fift" [n] TUPLE ``` **Aliases**: * `NIL`
Pushes the only *Tuple* `t=()` of length zero. * `SINGLE`
Creates a singleton `t:=(x)`, i.e., a *Tuple* of length one. * `PAIR`
Creates pair `t:=(x,y)`. * `TRIPLE`
Creates triple `t:=(x,y,z)`. #### `6F1k` INDEX [#6f1k-index] Returns the `k`-th element of a *Tuple* `t`.
`0 <= k <= 15`.
**Category:** Tuple (tuple)
```fift title="Fift" [k] INDEX ``` **Aliases**: * `FIRST`
Returns the first element of a *Tuple*. * `SECOND`
Returns the second element of a *Tuple*. * `THIRD`
Returns the third element of a *Tuple*. #### `6F2n` UNTUPLE [#6f2n-untuple] Unpacks a *Tuple* `t=(x_1,...,x_n)` of length equal to `0 <= n <= 15`.
If `t` is not a *Tuple*, or if `|t| != n`, a type check exception is thrown.
**Category:** Tuple (tuple)
```fift title="Fift" [n] UNTUPLE ``` **Aliases**: * `UNSINGLE`
Unpacks a singleton `t=(x)`. * `UNPAIR`
Unpacks a pair `t=(x,y)`. * `UNTRIPLE`
Unpacks a triple `t=(x,y,z)`. #### `6F3k` UNPACKFIRST [#6f3k-unpackfirst] Unpacks first `0 <= k <= 15` elements of a *Tuple* `t`.
If `|t|
```fift title="Fift" [k] UNPACKFIRST ``` **Aliases**: * `CHKTUPLE`
Checks whether `t` is a *Tuple*. If not, throws a type check exception. #### `6F4n` EXPLODE [#6f4n-explode] Unpacks a *Tuple* `t=(x_1,...,x_m)` and returns its length `m`, but only if `m <= n <= 15`. Otherwise throws a type check exception.
**Category:** Tuple (tuple)
```fift title="Fift" [n] EXPLODE ``` #### `6F5k` SETINDEX [#6f5k-setindex] Computes *Tuple* `t'` that differs from `t` only at position `t'_{k+1}`, which is set to `x`.
`0 <= k <= 15`
If `k >= |t|`, throws a range check exception.
**Category:** Tuple (tuple)
```fift title="Fift" [k] SETINDEX ``` **Aliases**: * `SETFIRST`
Sets the first component of *Tuple* `t` to `x` and returns the resulting *Tuple* `t'`. * `SETSECOND`
Sets the second component of *Tuple* `t` to `x` and returns the resulting *Tuple* `t'`. * `SETTHIRD`
Sets the third component of *Tuple* `t` to `x` and returns the resulting *Tuple* `t'`. #### `6F6k` INDEXQ [#6f6k-indexq] Returns the `k`-th element of a *Tuple* `t`, where `0 <= k <= 15`. In other words, returns `x_{k+1}` if `t=(x_1,...,x_n)`. If `k>=n`, or if `t` is *Null*, returns a *Null* instead of `x`.
**Category:** Tuple (tuple)
```fift title="Fift" [k] INDEXQ ``` **Aliases**: * `FIRSTQ`
Returns the first element of a *Tuple*. * `SECONDQ`
Returns the second element of a *Tuple*. * `THIRDQ`
Returns the third element of a *Tuple*. #### `6F7k` SETINDEXQ [#6f7k-setindexq] Sets the `k`-th component of *Tuple* `t` to `x`, where `0 <= k < 16`, and returns the resulting *Tuple* `t'`.
If `|t| <= k`, first extends the original *Tuple* to length `n'=k+1` by setting all new components to *Null*. If the original value of `t` is *Null*, treats it as an empty *Tuple*. If `t` is not *Null* or *Tuple*, throws an exception. If `x` is *Null* and either `|t| <= k` or `t` is *Null*, then always returns `t'=t` (and does not consume tuple creation gas).
**Category:** Tuple (tuple)
```fift title="Fift" [k] SETINDEXQ ``` **Aliases**: * `SETFIRSTQ`
Sets the first component of *Tuple* `t` to `x` and returns the resulting *Tuple* `t'`. * `SETSECONDQ`
Sets the second component of *Tuple* `t` to `x` and returns the resulting *Tuple* `t'`. * `SETTHIRDQ`
Sets the third component of *Tuple* `t` to `x` and returns the resulting *Tuple* `t'`. #### `6F80` TUPLEVAR [#6f80-tuplevar] Creates a new *Tuple* `t` of length `n` similarly to `TUPLE`, but with `0 <= n <= 255` taken from the stack.
**Category:** Tuple (tuple)
```fift title="Fift" TUPLEVAR ``` #### `6F81` INDEXVAR [#6f81-indexvar] Similar to `k INDEX`, but with `0 <= k <= 254` taken from the stack.
**Category:** Tuple (tuple)
```fift title="Fift" INDEXVAR ``` #### `6F82` UNTUPLEVAR [#6f82-untuplevar] Similar to `n UNTUPLE`, but with `0 <= n <= 255` taken from the stack.
**Category:** Tuple (tuple)
```fift title="Fift" UNTUPLEVAR ``` #### `6F83` UNPACKFIRSTVAR [#6f83-unpackfirstvar] Similar to `n UNPACKFIRST`, but with `0 <= n <= 255` taken from the stack.
**Category:** Tuple (tuple)
```fift title="Fift" UNPACKFIRSTVAR ``` #### `6F84` EXPLODEVAR [#6f84-explodevar] Similar to `n EXPLODE`, but with `0 <= n <= 255` taken from the stack.
**Category:** Tuple (tuple)
```fift title="Fift" EXPLODEVAR ``` #### `6F85` SETINDEXVAR [#6f85-setindexvar] Similar to `k SETINDEX`, but with `0 <= k <= 254` taken from the stack.
**Category:** Tuple (tuple)
```fift title="Fift" SETINDEXVAR ``` #### `6F86` INDEXVARQ [#6f86-indexvarq] Similar to `n INDEXQ`, but with `0 <= k <= 254` taken from the stack.
**Category:** Tuple (tuple)
```fift title="Fift" INDEXVARQ ``` #### `6F87` SETINDEXVARQ [#6f87-setindexvarq] Similar to `k SETINDEXQ`, but with `0 <= k <= 254` taken from the stack.
**Category:** Tuple (tuple)
```fift title="Fift" SETINDEXVARQ ``` #### `6F88` TLEN [#6f88-tlen] Returns the length of a *Tuple*.
**Category:** Tuple (tuple)
```fift title="Fift" TLEN ``` #### `6F89` QTLEN [#6f89-qtlen] Similar to `TLEN`, but returns `-1` if `t` is not a *Tuple*.
**Category:** Tuple (tuple)
```fift title="Fift" QTLEN ``` #### `6F8A` ISTUPLE [#6f8a-istuple] Returns `-1` or `0` depending on whether `t` is a *Tuple*.
**Category:** Tuple (tuple)
```fift title="Fift" ISTUPLE ``` #### `6F8B` LAST [#6f8b-last] Returns the last element of a non-empty *Tuple* `t`.
**Category:** Tuple (tuple)
```fift title="Fift" LAST ``` #### `6F8C` TPUSH [#6f8c-tpush] Appends a value `x` to a *Tuple* `t=(x_1,...,x_n)`, but only if the resulting *Tuple* `t'=(x_1,...,x_n,x)` is of length at most 255. Otherwise throws a type check exception.
**Category:** Tuple (tuple)
```fift title="Fift" TPUSH COMMA ``` #### `6F8D` TPOP [#6f8d-tpop] Detaches the last element `x=x_n` from a non-empty *Tuple* `t=(x_1,...,x_n)`, and returns both the resulting *Tuple* `t'=(x_1,...,x_{n-1})` and the original last element `x`.
**Category:** Tuple (tuple)
```fift title="Fift" TPOP ``` #### `6FA0` NULLSWAPIF [#6fa0-nullswapif] Pushes a *Null* under the topmost *Integer* `x`, but only if `x!=0`.
**Category:** Tuple (tuple)
```fift title="Fift" NULLSWAPIF ``` #### `6FA1` NULLSWAPIFNOT [#6fa1-nullswapifnot] Pushes a *Null* under the topmost *Integer* `x`, but only if `x=0`. May be used for stack alignment after quiet primitives such as `PLDUXQ`.
**Category:** Tuple (tuple)
```fift title="Fift" NULLSWAPIFNOT ``` #### `6FA2` NULLROTRIF [#6fa2-nullrotrif] Pushes a *Null* under the second stack entry from the top, but only if the topmost *Integer* `y` is non-zero.
**Category:** Tuple (tuple)
```fift title="Fift" NULLROTRIF ``` #### `6FA3` NULLROTRIFNOT [#6fa3-nullrotrifnot] Pushes a *Null* under the second stack entry from the top, but only if the topmost *Integer* `y` is zero. May be used for stack alignment after quiet primitives such as `LDUXQ`.
**Category:** Tuple (tuple)
```fift title="Fift" NULLROTRIFNOT ``` #### `6FA4` NULLSWAPIF2 [#6fa4-nullswapif2] Pushes two nulls under the topmost *Integer* `x`, but only if `x!=0`.
Equivalent to `NULLSWAPIF` `NULLSWAPIF`.
**Category:** Tuple (tuple)
```fift title="Fift" NULLSWAPIF2 ``` #### `6FA5` NULLSWAPIFNOT2 [#6fa5-nullswapifnot2] Pushes two nulls under the topmost *Integer* `x`, but only if `x=0`.
Equivalent to `NULLSWAPIFNOT` `NULLSWAPIFNOT`.
**Category:** Tuple (tuple)
```fift title="Fift" NULLSWAPIFNOT2 ``` #### `6FA6` NULLROTRIF2 [#6fa6-nullrotrif2] Pushes two nulls under the second stack entry from the top, but only if the topmost *Integer* `y` is non-zero.
Equivalent to `NULLROTRIF` `NULLROTRIF`.
**Category:** Tuple (tuple)
```fift title="Fift" NULLROTRIF2 ``` #### `6FA7` NULLROTRIFNOT2 [#6fa7-nullrotrifnot2] Pushes two nulls under the second stack entry from the top, but only if the topmost *Integer* `y` is zero.
Equivalent to `NULLROTRIFNOT` `NULLROTRIFNOT`.
**Category:** Tuple (tuple)
```fift title="Fift" NULLROTRIFNOT2 ``` #### `6FBij` INDEX2 [#6fbij-index2] Recovers `x=(t_{i+1})_{j+1}` for `0 <= i,j <= 3`.
Equivalent to `[i] INDEX` `[j] INDEX`.
**Category:** Tuple (tuple)
```fift title="Fift" [i] [j] INDEX2 ``` **Aliases**: * `CADR`
Recovers `x=(t_2)_1`. * `CDDR`
Recovers `x=(t_2)_2`. #### `6FE_ijk` INDEX3 [#6fe_ijk-index3] Recovers `x=t_{i+1}_{j+1}_{k+1}`.
`0 <= i,j,k <= 3`
Equivalent to `[i] [j] INDEX2` `[k] INDEX`.
**Category:** Tuple (tuple)
```fift title="Fift" [i] [j] [k] INDEX3 ``` **Aliases**: * `CADDR`
Recovers `x=t_2_2_1`. * `CDDDR`
Recovers `x=t_2_2_2`. #### `7i` PUSHINT\_4 [#7i-pushint_4] Pushes integer `x` into the stack. `-5 <= x <= 10`.
Here `i` equals four lower-order bits of `x` (`i=x mod 16`).
**Category:** Const Int (const\_int)
```fift title="Fift" [x] PUSHINT [x] INT ``` **Aliases**: * `ZERO`
* `ONE`
* `TWO`
* `TEN`
* `TRUE`
#### `80xx` PUSHINT\_8 [#80xx-pushint_8] Pushes integer `xx`. `-128 <= xx <= 127`.
**Category:** Const Int (const\_int)
```fift title="Fift" [xx] PUSHINT [xx] INT ``` #### `81xxxx` PUSHINT\_16 [#81xxxx-pushint_16] Pushes integer `xxxx`. `-2^15 <= xx < 2^15`.
**Category:** Const Int (const\_int)
```fift title="Fift" [xxxx] PUSHINT [xxxx] INT ``` #### `82lxxx` PUSHINT\_LONG [#82lxxx-pushint_long] Pushes integer `xxx`.
*Details:* 5-bit `0 <= l <= 30` determines the length `n=8l+19` of signed big-endian integer `xxx`.
The total length of this instruction is `l+4` bytes or `n+13=8l+32` bits.
**Category:** Const Int (const\_int)
```fift title="Fift" [xxx] PUSHINT [xxx] INT ``` #### `83xx` PUSHPOW2 [#83xx-pushpow2] (Quietly) pushes `2^(xx+1)` for `0 <= xx <= 255`.
`2^256` is a `NaN`.
**Category:** Const Int (const\_int)
```fift title="Fift" [xx+1] PUSHPOW2 ``` #### `83FF` PUSHNAN [#83ff-pushnan] Pushes a `NaN`.
**Category:** Const Int (const\_int)
```fift title="Fift" PUSHNAN ``` #### `84xx` PUSHPOW2DEC [#84xx-pushpow2dec] Pushes `2^(xx+1)-1` for `0 <= xx <= 255`.
**Category:** Const Int (const\_int)
```fift title="Fift" [xx+1] PUSHPOW2DEC ``` #### `85xx` PUSHNEGPOW2 [#85xx-pushnegpow2] Pushes `-2^(xx+1)` for `0 <= xx <= 255`.
**Category:** Const Int (const\_int)
```fift title="Fift" [xx+1] PUSHNEGPOW2 ``` #### `88` PUSHREF [#88-pushref] Pushes the reference `ref` into the stack.
*Details:* Pushes the first reference of `cc.code` into the stack as a *Cell* (and removes this reference from the current continuation).
**Category:** Const Data (const\_data)
```fift title="Fift" [ref] PUSHREF ``` #### `89` PUSHREFSLICE [#89-pushrefslice] Similar to `PUSHREF`, but converts the cell into a *Slice*.
**Category:** Const Data (const\_data)
```fift title="Fift" [ref] PUSHREFSLICE ``` #### `8A` PUSHREFCONT [#8a-pushrefcont] Similar to `PUSHREFSLICE`, but makes a simple ordinary *Continuation* out of the cell.
**Category:** Const Data (const\_data)
```fift title="Fift" [ref] PUSHREFCONT ``` #### `8Bxsss` PUSHSLICE [#8bxsss-pushslice] Pushes the slice `slice` into the stack.
*Details:* Pushes the (prefix) subslice of `cc.code` consisting of its first `8x+4` bits and no references (i.e., essentially a bitstring), where `0 <= x <= 15`.
A completion tag is assumed, meaning that all trailing zeroes and the last binary one (if present) are removed from this bitstring.
If the original bitstring consists only of zeroes, an empty slice will be pushed.
**Category:** Const Data (const\_data)
```fift title="Fift" [slice] PUSHSLICE [slice] SLICE ``` #### `8Crxxssss` PUSHSLICE\_REFS [#8crxxssss-pushslice_refs] Pushes the slice `slice` into the stack.
*Details:* Pushes the (prefix) subslice of `cc.code` consisting of its first `1 <= r+1 <= 4` references and up to first `8xx+1` bits of data, with `0 <= xx <= 31`.
A completion tag is also assumed.
**Category:** Const Data (const\_data)
```fift title="Fift" [slice] PUSHSLICE [slice] SLICE ``` #### `8Drxxsssss` PUSHSLICE\_LONG [#8drxxsssss-pushslice_long] Pushes the slice `slice` into the stack.
*Details:* Pushes the subslice of `cc.code` consisting of `0 <= r <= 4` references and up to `8xx+6` bits of data, with `0 <= xx <= 127`.
A completion tag is assumed.
**Category:** Const Data (const\_data)
```fift title="Fift" [slice] PUSHSLICE [slice] SLICE ``` #### `8F_rxxcccc` PUSHCONT [#8f_rxxcccc-pushcont] Pushes a continuation made from `builder`.
*Details:* Pushes the simple ordinary continuation `cccc` made from the first `0 <= r <= 3` references and the first `0 <= xx <= 127` bytes of `cc.code`.
**Category:** Const Data (const\_data)
```fift title="Fift" [builder] PUSHCONT [builder] CONT ``` #### `9xccc` PUSHCONT\_SHORT [#9xccc-pushcont_short] Pushes a continuation made from `builder`.
*Details:* Pushes an `x`-byte continuation for `0 <= x <= 15`.
**Category:** Const Data (const\_data)
```fift title="Fift" [builder] PUSHCONT [builder] CONT ``` #### `A0` ADD [#a0-add]
**Category:** Arithm Basic (arithm\_basic)
```fift title="Fift" ADD ``` #### `A1` SUB [#a1-sub]
**Category:** Arithm Basic (arithm\_basic)
```fift title="Fift" SUB ``` #### `A2` SUBR [#a2-subr] Equivalent to `SWAP` `SUB`.
**Category:** Arithm Basic (arithm\_basic)
```fift title="Fift" SUBR ``` #### `A3` NEGATE [#a3-negate] Equivalent to `-1 MULCONST` or to `ZERO SUBR`.
Notice that it triggers an integer overflow exception if `x=-2^256`.
**Category:** Arithm Basic (arithm\_basic)
```fift title="Fift" NEGATE ``` #### `A4` INC [#a4-inc] Equivalent to `1 ADDCONST`.
**Category:** Arithm Basic (arithm\_basic)
```fift title="Fift" INC ``` #### `A5` DEC [#a5-dec] Equivalent to `-1 ADDCONST`.
**Category:** Arithm Basic (arithm\_basic)
```fift title="Fift" DEC ``` #### `A6cc` ADDCONST [#a6cc-addconst] `-128 <= cc <= 127`.
**Category:** Arithm Basic (arithm\_basic)
```fift title="Fift" [cc] ADDCONST [cc] ADDINT [-cc] SUBCONST [-cc] SUBINT ``` #### `A7cc` MULCONST [#a7cc-mulconst] `-128 <= cc <= 127`.
**Category:** Arithm Basic (arithm\_basic)
```fift title="Fift" [cc] MULCONST [cc] MULINT ``` #### `A8` MUL [#a8-mul]
**Category:** Arithm Basic (arithm\_basic)
```fift title="Fift" MUL ``` #### `A900` ADDDIVMOD [#a900-adddivmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" ADDDIVMOD ``` #### `A901` ADDDIVMODR [#a901-adddivmodr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" ADDDIVMODR ``` #### `A902` ADDDIVMODC [#a902-adddivmodc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" ADDDIVMODC ``` #### `A904` DIV [#a904-div] `q=floor(x/y)`, `r=x-y*q`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" DIV ``` #### `A905` DIVR [#a905-divr] `q'=round(x/y)`, `r'=x-y*q'`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" DIVR ``` #### `A906` DIVC [#a906-divc] `q''=ceil(x/y)`, `r''=x-y*q''`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" DIVC ``` #### `A908` MOD [#a908-mod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MOD ``` #### `A909` MODR [#a909-modr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MODR ``` #### `A90A` MODC [#a90a-modc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MODC ``` #### `A90C` DIVMOD [#a90c-divmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" DIVMOD ``` #### `A90D` DIVMODR [#a90d-divmodr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" DIVMODR ``` #### `A90E` DIVMODC [#a90e-divmodc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" DIVMODC ``` #### `A920` ADDRSHIFTMOD\_VAR [#a920-addrshiftmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" ADDRSHIFTMOD ``` #### `A921` ADDRSHIFTMODR [#a921-addrshiftmodr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" ADDRSHIFTMODR ``` #### `A922` ADDRSHIFTMODC [#a922-addrshiftmodc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" ADDRSHIFTMODC ``` #### `A925` RSHIFTR\_VAR [#a925-rshiftr_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" RSHIFTR ``` #### `A926` RSHIFTC\_VAR [#a926-rshiftc_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" RSHIFTC ``` #### `A928` MODPOW2\_VAR [#a928-modpow2_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MODPOW2 ``` #### `A929` MODPOW2R\_VAR [#a929-modpow2r_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MODPOW2R ``` #### `A92A` MODPOW2C\_VAR [#a92a-modpow2c_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MODPOW2C ``` #### `A92C` RSHIFTMOD\_VAR [#a92c-rshiftmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" RSHIFTMOD ``` #### `A92D` RSHIFTMODR\_VAR [#a92d-rshiftmodr_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" RSHIFTMODR ``` #### `A92E` RSHIFTMODC\_VAR [#a92e-rshiftmodc_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" RSHIFTMODC ``` #### `A930tt` ADDRSHIFTMOD [#a930tt-addrshiftmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] ADDRSHIFT#MOD ``` #### `A931tt` ADDRSHIFTRMOD [#a931tt-addrshiftrmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] ADDRSHIFTR#MOD ``` #### `A932tt` ADDRSHIFTCMOD [#a932tt-addrshiftcmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] ADDRSHIFTC#MOD ``` #### `A935tt` RSHIFTR [#a935tt-rshiftr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] RSHIFTR# ``` #### `A936tt` RSHIFTC [#a936tt-rshiftc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] RSHIFTC# ``` #### `A938tt` MODPOW2 [#a938tt-modpow2]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] MODPOW2# ``` #### `A939tt` MODPOW2R [#a939tt-modpow2r]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] MODPOW2R# ``` #### `A93Att` MODPOW2C [#a93att-modpow2c]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] MODPOW2C# ``` #### `A93Ctt` RSHIFTMOD [#a93ctt-rshiftmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] RSHIFT#MOD ``` #### `A93Dtt` RSHIFTRMOD [#a93dtt-rshiftrmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] RSHIFTR#MOD ``` #### `A93Ett` RSHIFTCMOD [#a93ett-rshiftcmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] RSHIFTC#MOD ``` #### `A980` MULADDDIVMOD [#a980-muladddivmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULADDDIVMOD ``` #### `A981` MULADDDIVMODR [#a981-muladddivmodr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULADDDIVMODR ``` #### `A982` MULADDDIVMODC [#a982-muladddivmodc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULADDDIVMODC ``` #### `A984` MULDIV [#a984-muldiv] `q=floor(x*y/z)`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULDIV ``` #### `A985` MULDIVR [#a985-muldivr] `q'=round(x*y/z)`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULDIVR ``` #### `A986` MULDIVC [#a986-muldivc] `q'=ceil(x*y/z)`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULDIVC ``` #### `A988` MULMOD [#a988-mulmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULMOD ``` #### `A989` MULMODR [#a989-mulmodr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULMODR ``` #### `A98A` MULMODC [#a98a-mulmodc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULMODC ``` #### `A98C` MULDIVMOD [#a98c-muldivmod] `q=floor(x*y/z)`, `r=x*y-z*q`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULDIVMOD ``` #### `A98D` MULDIVMODR [#a98d-muldivmodr] `q=round(x*y/z)`, `r=x*y-z*q`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULDIVMODR ``` #### `A98E` MULDIVMODC [#a98e-muldivmodc] `q=ceil(x*y/z)`, `r=x*y-z*q`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULDIVMODC ``` #### `A9A0` MULADDRSHIFTMOD\_VAR [#a9a0-muladdrshiftmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULADDRSHIFTMOD ``` #### `A9A1` MULADDRSHIFTRMOD\_VAR [#a9a1-muladdrshiftrmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULADDRSHIFTRMOD ``` #### `A9A2` MULADDRSHIFTCMOD\_VAR [#a9a2-muladdrshiftcmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULADDRSHIFTCMOD ``` #### `A9A4` MULRSHIFT\_VAR [#a9a4-mulrshift_var] `0 <= z <= 256`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULRSHIFT ``` #### `A9A5` MULRSHIFTR\_VAR [#a9a5-mulrshiftr_var] `0 <= z <= 256`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULRSHIFTR ``` #### `A9A6` MULRSHIFTC\_VAR [#a9a6-mulrshiftc_var] `0 <= z <= 256`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULRSHIFTC ``` #### `A9A8` MULMODPOW2\_VAR [#a9a8-mulmodpow2_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULMODPOW2_VAR ``` #### `A9A9` MULMODPOW2R\_VAR [#a9a9-mulmodpow2r_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULMODPOW2R_VAR ``` #### `A9AA` MULMODPOW2C\_VAR [#a9aa-mulmodpow2c_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULMODPOW2C_VAR ``` #### `A9AC` MULRSHIFTMOD\_VAR [#a9ac-mulrshiftmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULRSHIFTMOD_VAR ``` #### `A9AD` MULRSHIFTRMOD\_VAR [#a9ad-mulrshiftrmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULRSHIFTRMOD_VAR ``` #### `A9AE` MULRSHIFTCMOD\_VAR [#a9ae-mulrshiftcmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULRSHIFTCMOD_VAR ``` #### `A9B0tt` MULADDRSHIFTMOD [#a9b0tt-muladdrshiftmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] MULADDRSHIFT#MOD ``` #### `A9B1tt` MULADDRSHIFTRMOD [#a9b1tt-muladdrshiftrmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] MULADDRSHIFTR#MOD ``` #### `A9B2tt` MULADDRSHIFTCMOD [#a9b2tt-muladdrshiftcmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] MULADDRSHIFTC#MOD ``` #### `A9B4tt` MULRSHIFT [#a9b4tt-mulrshift]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] MULRSHIFT# ``` #### `A9B5tt` MULRSHIFTR [#a9b5tt-mulrshiftr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] MULRSHIFTR# ``` #### `A9B6tt` MULRSHIFTC [#a9b6tt-mulrshiftc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] MULRSHIFTC# ``` #### `A9B8tt` MULMODPOW2 [#a9b8tt-mulmodpow2]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] MULMODPOW2# ``` #### `A9B9tt` MULMODPOW2R [#a9b9tt-mulmodpow2r]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] MULMODPOW2R# ``` #### `A9BAtt` MULMODPOW2C [#a9batt-mulmodpow2c]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] MULMODPOW2C# ``` #### `A9BC` MULRSHIFTMOD [#a9bc-mulrshiftmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULRSHIFT#MOD ``` #### `A9BD` MULRSHIFTRMOD [#a9bd-mulrshiftrmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULRSHIFTR#MOD ``` #### `A9BE` MULRSHIFTCMOD [#a9be-mulrshiftcmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULRSHIFTC#MOD ``` #### `A9C0` LSHIFTADDDIVMOD\_VAR [#a9c0-lshiftadddivmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" LSHIFTADDDIVMOD ``` #### `A9C1` LSHIFTADDDIVMODR\_VAR [#a9c1-lshiftadddivmodr_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" LSHIFTADDDIVMODR ``` #### `A9C2` LSHIFTADDDIVMODC\_VAR [#a9c2-lshiftadddivmodc_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" LSHIFTADDDIVMODC ``` #### `A9C4` LSHIFTDIV\_VAR [#a9c4-lshiftdiv_var] `0 <= z <= 256`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" LSHIFTDIV ``` #### `A9C5` LSHIFTDIVR\_VAR [#a9c5-lshiftdivr_var] `0 <= z <= 256`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" LSHIFTDIVR ``` #### `A9C6` LSHIFTDIVC\_VAR [#a9c6-lshiftdivc_var] `0 <= z <= 256`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" LSHIFTDIVC ``` #### `A9C8` LSHIFTMOD\_VAR [#a9c8-lshiftmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" LSHIFTMOD ``` #### `A9C9` LSHIFTMODR\_VAR [#a9c9-lshiftmodr_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" LSHIFTMODR ``` #### `A9CA` LSHIFTMODC\_VAR [#a9ca-lshiftmodc_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" LSHIFTMODC ``` #### `A9CC` LSHIFTDIVMOD\_VAR [#a9cc-lshiftdivmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" LSHIFTDIVMOD ``` #### `A9CD` LSHIFTDIVMODR\_VAR [#a9cd-lshiftdivmodr_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" LSHIFTDIVMODR ``` #### `A9CE` LSHIFTDIVMODC\_VAR [#a9ce-lshiftdivmodc_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" LSHIFTDIVMODC ``` #### `A9D0tt` LSHIFTADDDIVMOD [#a9d0tt-lshiftadddivmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] LSHIFT#ADDDIVMOD ``` #### `A9D1tt` LSHIFTADDDIVMODR [#a9d1tt-lshiftadddivmodr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] LSHIFT#ADDDIVMODR ``` #### `A9D2tt` LSHIFTADDDIVMODC [#a9d2tt-lshiftadddivmodc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] LSHIFT#ADDDIVMODC ``` #### `A9D4tt` LSHIFTDIV [#a9d4tt-lshiftdiv]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] LSHIFT#DIV ``` #### `A9D5tt` LSHIFTDIVR [#a9d5tt-lshiftdivr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] LSHIFT#DIVR ``` #### `A9D6tt` LSHIFTDIVC [#a9d6tt-lshiftdivc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] LSHIFT#DIVC ``` #### `A9D8tt` LSHIFTMOD [#a9d8tt-lshiftmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] LSHIFT#MOD ``` #### `A9D9tt` LSHIFTMODR [#a9d9tt-lshiftmodr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] LSHIFT#MODR ``` #### `A9DAtt` LSHIFTMODC [#a9datt-lshiftmodc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] LSHIFT#MODC ``` #### `A9DCtt` LSHIFTDIVMOD [#a9dctt-lshiftdivmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] LSHIFT#DIVMOD ``` #### `A9DDtt` LSHIFTDIVMODR [#a9ddtt-lshiftdivmodr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] LSHIFT#DIVMODR ``` #### `A9DEtt` LSHIFTDIVMODC [#a9dett-lshiftdivmodc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] LSHIFT#DIVMODC ``` #### `AAcc` LSHIFT [#aacc-lshift] `0 <= cc <= 255`
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" [cc+1] LSHIFT# ``` #### `ABcc` RSHIFT [#abcc-rshift] `0 <= cc <= 255`
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" [cc+1] RSHIFT# ``` #### `AC` LSHIFT\_VAR [#ac-lshift_var] `0 <= y <= 1023`
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" LSHIFT ``` #### `AD` RSHIFT\_VAR [#ad-rshift_var] `0 <= y <= 1023`
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" RSHIFT ``` #### `AE` POW2 [#ae-pow2] `0 <= y <= 1023`
Equivalent to `ONE` `SWAP` `LSHIFT`.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" POW2 ``` #### `B0` AND [#b0-and] Bitwise and of two signed integers `x` and `y`, sign-extended to infinity.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" AND ``` #### `B1` OR [#b1-or] Bitwise or of two integers.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" OR ``` #### `B2` XOR [#b2-xor] Bitwise xor of two integers.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" XOR ``` #### `B3` NOT [#b3-not] Bitwise not of an integer.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" NOT ``` #### `B4cc` FITS [#b4cc-fits] Checks whether `x` is a `cc+1`-bit signed integer for `0 <= cc <= 255` (i.e., whether `-2^cc <= x < 2^cc`).
If not, either triggers an integer overflow exception, or replaces `x` with a `NaN` (quiet version).
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" [cc+1] FITS ``` **Aliases**: * `CHKBOOL`
Checks whether `x` is a ''boolean value'' (i.e., either 0 or -1). #### `B5cc` UFITS [#b5cc-ufits] Checks whether `x` is a `cc+1`-bit unsigned integer for `0 <= cc <= 255` (i.e., whether `0 <= x < 2^(cc+1)`).
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" [cc+1] UFITS ``` **Aliases**: * `CHKBIT`
Checks whether `x` is a binary digit (i.e., zero or one). #### `B600` FITSX [#b600-fitsx] Checks whether `x` is a `c`-bit signed integer for `0 <= c <= 1023`.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" FITSX ``` #### `B601` UFITSX [#b601-ufitsx] Checks whether `x` is a `c`-bit unsigned integer for `0 <= c <= 1023`.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" UFITSX ``` #### `B602` BITSIZE [#b602-bitsize] Computes smallest `c >= 0` such that `x` fits into a `c`-bit signed integer (`-2^(c-1) <= c < 2^(c-1)`).
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" BITSIZE ``` #### `B603` UBITSIZE [#b603-ubitsize] Computes smallest `c >= 0` such that `x` fits into a `c`-bit unsigned integer (`0 <= x < 2^c`), or throws a range check exception.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" UBITSIZE ``` #### `B608` MIN [#b608-min] Computes the minimum of two integers `x` and `y`.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" MIN ``` #### `B609` MAX [#b609-max] Computes the maximum of two integers `x` and `y`.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" MAX ``` #### `B60A` MINMAX [#b60a-minmax] Sorts two integers. Quiet version of this operation returns two `NaN`s if any of the arguments are `NaN`s.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" MINMAX INTSORT2 ``` #### `B60B` ABS [#b60b-abs] Computes the absolute value of an integer `x`.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" ABS ``` #### `B7A0` QADD [#b7a0-qadd]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QADD ``` #### `B7A1` QSUB [#b7a1-qsub]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QSUB ``` #### `B7A2` QSUBR [#b7a2-qsubr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QSUBR ``` #### `B7A3` QNEGATE [#b7a3-qnegate]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QNEGATE ``` #### `B7A4` QINC [#b7a4-qinc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QINC ``` #### `B7A5` QDEC [#b7a5-qdec]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QDEC ``` #### `B7A8` QMUL [#b7a8-qmul]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMUL ``` #### `B7A900` QADDDIVMOD [#b7a900-qadddivmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QADDDIVMOD ``` #### `B7A901` QADDDIVMODR [#b7a901-qadddivmodr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QADDDIVMODR ``` #### `B7A902` QADDDIVMODC [#b7a902-qadddivmodc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QADDDIVMODC ``` #### `B7A904` QDIV [#b7a904-qdiv] Division returns `NaN` if `y=0`.
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QDIV ``` #### `B7A905` QDIVR [#b7a905-qdivr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QDIVR ``` #### `B7A906` QDIVC [#b7a906-qdivc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QDIVC ``` #### `B7A908` QMOD [#b7a908-qmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMOD ``` #### `B7A909` QMODR [#b7a909-qmodr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMODR ``` #### `B7A90A` QMODC [#b7a90a-qmodc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMODC ``` #### `B7A90C` QDIVMOD [#b7a90c-qdivmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QDIVMOD ``` #### `B7A90D` QDIVMODR [#b7a90d-qdivmodr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QDIVMODR ``` #### `B7A90E` QDIVMODC [#b7a90e-qdivmodc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QDIVMODC ``` #### `B7A920` QADDRSHIFTMOD [#b7a920-qaddrshiftmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QADDRSHIFTMOD ``` #### `B7A921` QADDRSHIFTMODR [#b7a921-qaddrshiftmodr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QADDRSHIFTMODR ``` #### `B7A922` QADDRSHIFTMODC [#b7a922-qaddrshiftmodc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QADDRSHIFTMODC ``` #### `B7A925` QRSHIFTR\_VAR [#b7a925-qrshiftr_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QRSHIFTR ``` #### `B7A926` QRSHIFTC\_VAR [#b7a926-qrshiftc_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QRSHIFTC ``` #### `B7A928` QMODPOW2\_VAR [#b7a928-qmodpow2_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMODPOW2 ``` #### `B7A929` QMODPOW2R\_VAR [#b7a929-qmodpow2r_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMODPOW2R ``` #### `B7A92A` QMODPOW2C\_VAR [#b7a92a-qmodpow2c_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMODPOW2C ``` #### `B7A92C` QRSHIFTMOD\_VAR [#b7a92c-qrshiftmod_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QRSHIFTMOD ``` #### `B7A92D` QRSHIFTMODR\_VAR [#b7a92d-qrshiftmodr_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QRSHIFTMODR ``` #### `B7A92E` QRSHIFTMODC\_VAR [#b7a92e-qrshiftmodc_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QRSHIFTMODC ``` #### `B7A930tt` QADDRSHIFTMOD [#b7a930tt-qaddrshiftmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QADDRSHIFT#MOD ``` #### `B7A931tt` QADDRSHIFTRMOD [#b7a931tt-qaddrshiftrmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QADDRSHIFTR#MOD ``` #### `B7A932tt` QADDRSHIFTCMOD [#b7a932tt-qaddrshiftcmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QADDRSHIFTC#MOD ``` #### `B7A935tt` QRSHIFTR [#b7a935tt-qrshiftr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QRSHIFTR# ``` #### `B7A936tt` QRSHIFTC [#b7a936tt-qrshiftc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QRSHIFTC# ``` #### `B7A938tt` QMODPOW2 [#b7a938tt-qmodpow2]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QMODPOW2# ``` #### `B7A939tt` QMODPOW2R [#b7a939tt-qmodpow2r]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QMODPOW2R# ``` #### `B7A93Att` QMODPOW2C [#b7a93att-qmodpow2c]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QMODPOW2C# ``` #### `B7A93Ctt` QRSHIFTMOD [#b7a93ctt-qrshiftmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QRSHIFT#MOD ``` #### `B7A93Dtt` QRSHIFTRMOD [#b7a93dtt-qrshiftrmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QRSHIFTR#MOD ``` #### `B7A93Ett` QRSHIFTCMOD [#b7a93ett-qrshiftcmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QRSHIFTC#MOD ``` #### `B7A980` QMULADDDIVMOD [#b7a980-qmuladddivmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULADDDIVMOD ``` #### `B7A981` QMULADDDIVMODR [#b7a981-qmuladddivmodr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULADDDIVMODR ``` #### `B7A982` QMULADDDIVMODC [#b7a982-qmuladddivmodc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULADDDIVMODC ``` #### `B7A984` QMULDIV [#b7a984-qmuldiv] `q=floor(x*y/z)`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULDIV ``` #### `B7A985` QMULDIVR [#b7a985-qmuldivr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULDIVR ``` #### `B7A986` QMULDIVC [#b7a986-qmuldivc] `q'=ceil(x*y/z)`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULDIVC ``` #### `B7A988` QMULMOD [#b7a988-qmulmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULMOD ``` #### `B7A989` QMULMODR [#b7a989-qmulmodr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULMODR ``` #### `B7A98A` QMULMODC [#b7a98a-qmulmodc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULMODC ``` #### `B7A98C` QMULDIVMOD [#b7a98c-qmuldivmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULDIVMOD ``` #### `B7A98D` QMULDIVMODR [#b7a98d-qmuldivmodr] `q=round(x*y/z)`, `r=x*y-z*q`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULDIVMODR ``` #### `B7A98E` QMULDIVMODC [#b7a98e-qmuldivmodc] `q=ceil(x*y/z)`, `r=x*y-z*q`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULDIVMODC ``` #### `B7A9A0` QMULADDRSHIFTMOD\_VAR [#b7a9a0-qmuladdrshiftmod_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULADDRSHIFTMOD ``` #### `B7A9A1` QMULADDRSHIFTRMOD\_VAR [#b7a9a1-qmuladdrshiftrmod_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULADDRSHIFTRMOD ``` #### `B7A9A2` QMULADDRSHIFTCMOD\_VAR [#b7a9a2-qmuladdrshiftcmod_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULADDRSHIFTCMOD ``` #### `B7A9A4` QMULRSHIFT\_VAR [#b7a9a4-qmulrshift_var] `0 <= z <= 256`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULRSHIFT ``` #### `B7A9A5` QMULRSHIFTR\_VAR [#b7a9a5-qmulrshiftr_var] `0 <= z <= 256`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULRSHIFTR ``` #### `B7A9A6` QMULRSHIFTC\_VAR [#b7a9a6-qmulrshiftc_var] `0 <= z <= 256`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULRSHIFTC ``` #### `B7A9A8` QMULMODPOW2\_VAR [#b7a9a8-qmulmodpow2_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULMODPOW2_VAR ``` #### `B7A9A9` QMULMODPOW2R\_VAR [#b7a9a9-qmulmodpow2r_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULMODPOW2R_VAR ``` #### `B7A9AA` QMULMODPOW2C\_VAR [#b7a9aa-qmulmodpow2c_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULMODPOW2C_VAR ``` #### `B7A9AC` QMULRSHIFTMOD\_VAR [#b7a9ac-qmulrshiftmod_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULRSHIFTMOD_VAR ``` #### `B7A9AD` QMULRSHIFTRMOD\_VAR [#b7a9ad-qmulrshiftrmod_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULRSHIFTRMOD_VAR ``` #### `B7A9AE` QMULRSHIFTCMOD\_VAR [#b7a9ae-qmulrshiftcmod_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULRSHIFTCMOD_VAR ``` #### `B7A9B0tt` QMULADDRSHIFTMOD [#b7a9b0tt-qmuladdrshiftmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QMULADDRSHIFT#MOD ``` #### `B7A9B1tt` QMULADDRSHIFTRMOD [#b7a9b1tt-qmuladdrshiftrmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QMULADDRSHIFTR#MOD ``` #### `B7A9B2tt` QMULADDRSHIFTCMOD [#b7a9b2tt-qmuladdrshiftcmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QMULADDRSHIFTC#MOD ``` #### `B7A9B4tt` QMULRSHIFT [#b7a9b4tt-qmulrshift]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QMULRSHIFT# ``` #### `B7A9B5tt` QMULRSHIFTR [#b7a9b5tt-qmulrshiftr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QMULRSHIFTR# ``` #### `B7A9B6tt` QMULRSHIFTC [#b7a9b6tt-qmulrshiftc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QMULRSHIFTC# ``` #### `B7A9B8tt` QMULMODPOW2 [#b7a9b8tt-qmulmodpow2]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QMULMODPOW2# ``` #### `B7A9B9tt` QMULMODPOW2R [#b7a9b9tt-qmulmodpow2r]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QMULMODPOW2R# ``` #### `B7A9BAtt` QMULMODPOW2C [#b7a9batt-qmulmodpow2c]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QMULMODPOW2C# ``` #### `B7A9BC` QMULRSHIFTMOD [#b7a9bc-qmulrshiftmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULRSHIFT#MOD ``` #### `B7A9BD` QMULRSHIFTRMOD [#b7a9bd-qmulrshiftrmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULRSHIFTR#MOD ``` #### `B7A9BE` QMULRSHIFTCMOD [#b7a9be-qmulrshiftcmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULRSHIFTC#MOD ``` #### `B7A9C0` QLSHIFTADDDIVMOD\_VAR [#b7a9c0-qlshiftadddivmod_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QLSHIFTADDDIVMOD ``` #### `B7A9C1` QLSHIFTADDDIVMODR\_VAR [#b7a9c1-qlshiftadddivmodr_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QLSHIFTADDDIVMODR ``` #### `B7A9C2` QLSHIFTADDDIVMODC\_VAR [#b7a9c2-qlshiftadddivmodc_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QLSHIFTADDDIVMODC ``` #### `B7A9C4` QLSHIFTDIV\_VAR [#b7a9c4-qlshiftdiv_var] `0 <= z <= 256`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QLSHIFTDIV ``` #### `B7A9C5` QLSHIFTDIVR\_VAR [#b7a9c5-qlshiftdivr_var] `0 <= z <= 256`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QLSHIFTDIVR ``` #### `B7A9C6` QLSHIFTDIVC\_VAR [#b7a9c6-qlshiftdivc_var] `0 <= z <= 256`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QLSHIFTDIVC ``` #### `B7A9C8` QLSHIFTMOD\_VAR [#b7a9c8-qlshiftmod_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QLSHIFTMOD ``` #### `B7A9C9` QLSHIFTMODR\_VAR [#b7a9c9-qlshiftmodr_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QLSHIFTMODR ``` #### `B7A9CA` QLSHIFTMODC\_VAR [#b7a9ca-qlshiftmodc_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QLSHIFTMODC ``` #### `B7A9CC` QLSHIFTDIVMOD\_VAR [#b7a9cc-qlshiftdivmod_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QLSHIFTDIVMOD ``` #### `B7A9CD` QLSHIFTDIVMODR\_VAR [#b7a9cd-qlshiftdivmodr_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QLSHIFTDIVMODR ``` #### `B7A9CE` QLSHIFTDIVMODC\_VAR [#b7a9ce-qlshiftdivmodc_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QLSHIFTDIVMODC ``` #### `B7A9D0tt` QLSHIFTADDDIVMOD [#b7a9d0tt-qlshiftadddivmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QLSHIFT#ADDDIVMOD ``` #### `B7A9D1tt` QLSHIFTADDDIVMODR [#b7a9d1tt-qlshiftadddivmodr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QLSHIFT#ADDDIVMODR ``` #### `B7A9D2tt` QLSHIFTADDDIVMODC [#b7a9d2tt-qlshiftadddivmodc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QLSHIFT#ADDDIVMODC ``` #### `B7A9D4tt` QLSHIFTDIV [#b7a9d4tt-qlshiftdiv]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QLSHIFT#DIV ``` #### `B7A9D5tt` QLSHIFTDIVR [#b7a9d5tt-qlshiftdivr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QLSHIFT#DIVR ``` #### `B7A9D6tt` QLSHIFTDIVC [#b7a9d6tt-qlshiftdivc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QLSHIFT#DIVC ``` #### `B7A9D8tt` QLSHIFTMOD [#b7a9d8tt-qlshiftmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QLSHIFT#MOD ``` #### `B7A9D9tt` QLSHIFTMODR [#b7a9d9tt-qlshiftmodr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QLSHIFT#MODR ``` #### `B7A9DAtt` QLSHIFTMODC [#b7a9datt-qlshiftmodc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QLSHIFT#MODC ``` #### `B7A9DCtt` QLSHIFTDIVMOD [#b7a9dctt-qlshiftdivmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QLSHIFT#DIVMOD ``` #### `B7A9DDtt` QLSHIFTDIVMODR [#b7a9ddtt-qlshiftdivmodr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QLSHIFT#DIVMODR ``` #### `B7A9DEtt` QLSHIFTDIVMODC [#b7a9dett-qlshiftdivmodc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QLSHIFT#DIVMODC ``` #### `B7AAcc` QLSHIFT [#b7aacc-qlshift] `0 <= cc <= 255`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [cc+1] QLSHIFT# ``` #### `B7ABcc` QRSHIFT [#b7abcc-qrshift] `0 <= cc <= 255`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [cc+1] QRSHIFT# ``` #### `B7AC` QLSHIFT\_VAR [#b7ac-qlshift_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QLSHIFT ``` #### `B7AD` QRSHIFT\_VAR [#b7ad-qrshift_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QRSHIFT ``` #### `B7AE` QPOW2 [#b7ae-qpow2]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QPOW2 ``` #### `B7B0` QAND [#b7b0-qand]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QAND ``` #### `B7B1` QOR [#b7b1-qor]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QOR ``` #### `B7B2` QXOR [#b7b2-qxor]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QXOR ``` #### `B7B3` QNOT [#b7b3-qnot]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QNOT ``` #### `B7B4cc` QFITS [#b7b4cc-qfits] Replaces `x` with a `NaN` if x is not a `cc+1`-bit signed integer, leaves it intact otherwise.
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [cc+1] QFITS ``` #### `B7B5cc` QUFITS [#b7b5cc-qufits] Replaces `x` with a `NaN` if x is not a `cc+1`-bit unsigned integer, leaves it intact otherwise.
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [cc+1] QUFITS ``` #### `B7B600` QFITSX [#b7b600-qfitsx] Replaces `x` with a `NaN` if x is not a c-bit signed integer, leaves it intact otherwise.
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QFITSX ``` #### `B7B601` QUFITSX [#b7b601-qufitsx] Replaces `x` with a `NaN` if x is not a c-bit unsigned integer, leaves it intact otherwise.
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QUFITSX ``` #### `B8` SGN [#b8-sgn] Computes the sign of an integer `x`:
`-1` if `x<0`, `0` if `x=0`, `1` if `x>0`.
**Category:** Compare Int (compare\_int)
```fift title="Fift" SGN ``` #### `B9` LESS [#b9-less] Returns `-1` if `x
```fift title="Fift" LESS ``` #### `BA` EQUAL [#ba-equal] Returns `-1` if `x=y`, `0` otherwise.
**Category:** Compare Int (compare\_int)
```fift title="Fift" EQUAL ``` #### `BB` LEQ [#bb-leq]
**Category:** Compare Int (compare\_int)
```fift title="Fift" LEQ ``` #### `BC` GREATER [#bc-greater]
**Category:** Compare Int (compare\_int)
```fift title="Fift" GREATER ``` #### `BD` NEQ [#bd-neq] Equivalent to `EQUAL` `NOT`.
**Category:** Compare Int (compare\_int)
```fift title="Fift" NEQ ``` #### `BE` GEQ [#be-geq] Equivalent to `LESS` `NOT`.
**Category:** Compare Int (compare\_int)
```fift title="Fift" GEQ ``` #### `BF` CMP [#bf-cmp] Computes the sign of `x-y`:
`-1` if `xy`.
No integer overflow can occur here unless `x` or `y` is a `NaN`.
**Category:** Compare Int (compare\_int)
```fift title="Fift" CMP ``` #### `C0yy` EQINT [#c0yy-eqint] Returns `-1` if `x=yy`, `0` otherwise.
`-2^7 <= yy < 2^7`.
**Category:** Compare Int (compare\_int)
```fift title="Fift" [yy] EQINT ``` **Aliases**: * `ISZERO`
Checks whether an integer is zero. Corresponds to Forth's `0=`. #### `C1yy` LESSINT [#c1yy-lessint] Returns `-1` if `x
**Category:** Compare Int (compare\_int)
```fift title="Fift" [yy] LESSINT [yy-1] LEQINT ``` **Aliases**: * `ISNEG`
Checks whether an integer is negative. Corresponds to Forth's `0<`. * `ISNPOS`
Checks whether an integer is non-positive. #### `C2yy` GTINT [#c2yy-gtint] Returns `-1` if `x>yy`, `0` otherwise.
`-2^7 <= yy < 2^7`.
**Category:** Compare Int (compare\_int)
```fift title="Fift" [yy] GTINT [yy+1] GEQINT ``` **Aliases**: * `ISPOS`
Checks whether an integer is positive. Corresponds to Forth's `0>`. * `ISNNEG`
Checks whether an integer is non-negative. #### `C3yy` NEQINT [#c3yy-neqint] Returns `-1` if `x!=yy`, `0` otherwise.
`-2^7 <= yy < 2^7`.
**Category:** Compare Int (compare\_int)
```fift title="Fift" [yy] NEQINT ``` #### `C4` ISNAN [#c4-isnan] Checks whether `x` is a `NaN`.
**Category:** Compare Int (compare\_int)
```fift title="Fift" ISNAN ``` #### `C5` CHKNAN [#c5-chknan] Throws an arithmetic overflow exception if `x` is a `NaN`.
**Category:** Compare Int (compare\_int)
```fift title="Fift" CHKNAN ``` #### `C700` SEMPTY [#c700-sempty] Checks whether a *Slice* `s` is empty (i.e., contains no bits of data and no cell references).
**Category:** Compare Other (compare\_other)
```fift title="Fift" SEMPTY ``` #### `C701` SDEMPTY [#c701-sdempty] Checks whether *Slice* `s` has no bits of data.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDEMPTY ``` #### `C702` SREMPTY [#c702-srempty] Checks whether *Slice* `s` has no references.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SREMPTY ``` #### `C703` SDFIRST [#c703-sdfirst] Checks whether the first bit of *Slice* `s` is a one.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDFIRST ``` #### `C704` SDLEXCMP [#c704-sdlexcmp] Compares the data of `s` lexicographically with the data of `s'`, returning `-1`, 0, or 1 depending on the result.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDLEXCMP ``` #### `C705` SDEQ [#c705-sdeq] Checks whether the data parts of `s` and `s'` coincide, equivalent to `SDLEXCMP` `ISZERO`.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDEQ ``` #### `C708` SDPFX [#c708-sdpfx] Checks whether `s` is a prefix of `s'`.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDPFX ``` #### `C709` SDPFXREV [#c709-sdpfxrev] Checks whether `s'` is a prefix of `s`, equivalent to `SWAP` `SDPFX`.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDPFXREV ``` #### `C70A` SDPPFX [#c70a-sdppfx] Checks whether `s` is a proper prefix of `s'` (i.e., a prefix distinct from `s'`).
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDPPFX ``` #### `C70B` SDPPFXREV [#c70b-sdppfxrev] Checks whether `s'` is a proper prefix of `s`.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDPPFXREV ``` #### `C70C` SDSFX [#c70c-sdsfx] Checks whether `s` is a suffix of `s'`.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDSFX ``` #### `C70D` SDSFXREV [#c70d-sdsfxrev] Checks whether `s'` is a suffix of `s`.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDSFXREV ``` #### `C70E` SDPSFX [#c70e-sdpsfx] Checks whether `s` is a proper suffix of `s'`.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDPSFX ``` #### `C70F` SDPSFXREV [#c70f-sdpsfxrev] Checks whether `s'` is a proper suffix of `s`.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDPSFXREV ``` #### `C710` SDCNTLEAD0 [#c710-sdcntlead0] Returns the number of leading zeroes in `s`.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDCNTLEAD0 ``` #### `C711` SDCNTLEAD1 [#c711-sdcntlead1] Returns the number of leading ones in `s`.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDCNTLEAD1 ``` #### `C712` SDCNTTRAIL0 [#c712-sdcnttrail0] Returns the number of trailing zeroes in `s`.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDCNTTRAIL0 ``` #### `C713` SDCNTTRAIL1 [#c713-sdcnttrail1] Returns the number of trailing ones in `s`.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDCNTTRAIL1 ``` #### `C8` NEWC [#c8-newc] Creates a new empty *Builder*.
**Category:** Cell Build (cell\_build)
```fift title="Fift" NEWC ``` #### `C9` ENDC [#c9-endc] Converts a *Builder* into an ordinary *Cell*.
**Category:** Cell Build (cell\_build)
```fift title="Fift" ENDC ``` #### `CAcc` STI [#cacc-sti] Stores a signed `cc+1`-bit integer `x` into *Builder* `b` for `0 <= cc <= 255`, throws a range check exception if `x` does not fit into `cc+1` bits.
**Category:** Cell Build (cell\_build)
```fift title="Fift" [cc+1] STI ``` #### `CBcc` STU [#cbcc-stu] Stores an unsigned `cc+1`-bit integer `x` into *Builder* `b`. In all other respects it is similar to `STI`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" [cc+1] STU ``` #### `CC` STREF [#cc-stref] Stores a reference to *Cell* `c` into *Builder* `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STREF ``` #### `CD` STBREFR [#cd-stbrefr] Equivalent to `ENDC` `SWAP` `STREF`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STBREFR ENDCST ``` #### `CE` STSLICE [#ce-stslice] Stores *Slice* `s` into *Builder* `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STSLICE ``` **Aliases**: * `STDICTS`
Stores a *Slice*-represented dictionary `s` into *Builder* `b`.
It is actually a synonym for `STSLICE`. #### `CF00` STIX [#cf00-stix] Stores a signed `l`-bit integer `x` into `b` for `0 <= l <= 257`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STIX ``` #### `CF01` STUX [#cf01-stux] Stores an unsigned `l`-bit integer `x` into `b` for `0 <= l <= 256`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STUX ``` #### `CF02` STIXR [#cf02-stixr] Similar to `STIX`, but with arguments in a different order.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STIXR ``` #### `CF03` STUXR [#cf03-stuxr] Similar to `STUX`, but with arguments in a different order.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STUXR ``` #### `CF04` STIXQ [#cf04-stixq] A quiet version of `STIX`. If there is no space in `b`, sets `b'=b` and `f=-1`.
If `x` does not fit into `l` bits, sets `b'=b` and `f=1`.
If the operation succeeds, `b'` is the new *Builder* and `f=0`.
However, `0 <= l <= 257`, with a range check exception if this is not so.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STIXQ ``` #### `CF05` STUXQ [#cf05-stuxq] A quiet version of `STUX`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STUXQ ``` #### `CF06` STIXRQ [#cf06-stixrq] A quiet version of `STIXR`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STIXRQ ``` #### `CF07` STUXRQ [#cf07-stuxrq] A quiet version of `STUXR`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STUXRQ ``` #### `CF08cc` STI\_ALT [#cf08cc-sti_alt] A longer version of `[cc+1] STI`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" [cc+1] STI_l ``` #### `CF09cc` STU\_ALT [#cf09cc-stu_alt] A longer version of `[cc+1] STU`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" [cc+1] STU_l ``` #### `CF0Acc` STIR [#cf0acc-stir] Equivalent to `SWAP` `[cc+1] STI`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" [cc+1] STIR ``` #### `CF0Bcc` STUR [#cf0bcc-stur] Equivalent to `SWAP` `[cc+1] STU`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" [cc+1] STUR ``` #### `CF0Ccc` STIQ [#cf0ccc-stiq] A quiet version of `STI`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" [cc+1] STIQ ``` #### `CF0Dcc` STUQ [#cf0dcc-stuq] A quiet version of `STU`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" [cc+1] STUQ ``` #### `CF0Ecc` STIRQ [#cf0ecc-stirq] A quiet version of `STIR`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" [cc+1] STIRQ ``` #### `CF0Fcc` STURQ [#cf0fcc-sturq] A quiet version of `STUR`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" [cc+1] STURQ ``` #### `CF10` STREF\_ALT [#cf10-stref_alt] A longer version of `STREF`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STREF_l ``` #### `CF11` STBREF [#cf11-stbref] Equivalent to `SWAP` `STBREFR`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STBREF ``` #### `CF12` STSLICE\_ALT [#cf12-stslice_alt] A longer version of `STSLICE`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STSLICE_l ``` #### `CF13` STB [#cf13-stb] Appends all data from *Builder* `b'` to *Builder* `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STB ``` #### `CF14` STREFR [#cf14-strefr] Equivalent to `SWAP` `STREF`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STREFR ``` #### `CF15` STBREFR\_ALT [#cf15-stbrefr_alt] A longer encoding of `STBREFR`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STBREFR_l ``` #### `CF16` STSLICER [#cf16-stslicer] Equivalent to `SWAP` `STSLICE`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STSLICER ``` #### `CF17` STBR [#cf17-stbr] Concatenates two builders.
Equivalent to `SWAP` `STB`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STBR BCONCAT ``` #### `CF18` STREFQ [#cf18-strefq] Quiet version of `STREF`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STREFQ ``` #### `CF19` STBREFQ [#cf19-stbrefq] Quiet version of `STBREF`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STBREFQ ``` #### `CF1A` STSLICEQ [#cf1a-stsliceq] Quiet version of `STSLICE`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STSLICEQ ``` #### `CF1B` STBQ [#cf1b-stbq] Quiet version of `STB`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STBQ ``` #### `CF1C` STREFRQ [#cf1c-strefrq] Quiet version of `STREFR`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STREFRQ ``` #### `CF1D` STBREFRQ [#cf1d-stbrefrq] Quiet version of `STBREFR`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STBREFRQ ``` #### `CF1E` STSLICERQ [#cf1e-stslicerq] Quiet version of `STSLICER`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STSLICERQ ``` #### `CF1F` STBRQ [#cf1f-stbrq] Quiet version of `STBR`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STBRQ BCONCATQ ``` #### `CF20` STREFCONST [#cf20-strefconst] Equivalent to `PUSHREF` `STREFR`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" [ref] STREFCONST ``` #### `CF21` STREF2CONST [#cf21-stref2const] Equivalent to `STREFCONST` `STREFCONST`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" [ref] [ref] STREF2CONST ``` #### `CF23` ENDXC [#cf23-endxc] If `x!=0`, creates a *special* or *exotic* cell from *Builder* `b`.
The type of the exotic cell must be stored in the first 8 bits of `b`.
If `x=0`, it is equivalent to `ENDC`. Otherwise some validity checks on the data and references of `b` are performed before creating the exotic cell.
**Category:** Cell Build (cell\_build)
```fift title="Fift" ENDXC ``` #### `CF28` STILE4 [#cf28-stile4] Stores a little-endian signed 32-bit integer.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STILE4 ``` #### `CF29` STULE4 [#cf29-stule4] Stores a little-endian unsigned 32-bit integer.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STULE4 ``` #### `CF2A` STILE8 [#cf2a-stile8] Stores a little-endian signed 64-bit integer.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STILE8 ``` #### `CF2B` STULE8 [#cf2b-stule8] Stores a little-endian unsigned 64-bit integer.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STULE8 ``` #### `CF30` BDEPTH [#cf30-bdepth] Returns the depth of *Builder* `b`. If no cell references are stored in `b`, then `x=0`; otherwise `x` is one plus the maximum of depths of cells referred to from `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" BDEPTH ``` #### `CF31` BBITS [#cf31-bbits] Returns the number of data bits already stored in *Builder* `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" BBITS ``` #### `CF32` BREFS [#cf32-brefs] Returns the number of cell references already stored in `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" BREFS ``` #### `CF33` BBITREFS [#cf33-bbitrefs] Returns the numbers of both data bits and cell references in `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" BBITREFS ``` #### `CF35` BREMBITS [#cf35-brembits] Returns the number of data bits that can still be stored in `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" BREMBITS ``` #### `CF36` BREMREFS [#cf36-bremrefs] Returns the number of references that can still be stored in `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" BREMREFS ``` #### `CF37` BREMBITREFS [#cf37-brembitrefs] Returns the numbers of both data bits and references that can still be stored in `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" BREMBITREFS ``` #### `CF38cc` BCHKBITS [#cf38cc-bchkbits] Checks whether `cc+1` bits can be stored into `b`, where `0 <= cc <= 255`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" [cc+1] BCHKBITS# ``` #### `CF39` BCHKBITS\_VAR [#cf39-bchkbits_var] Checks whether `x` bits can be stored into `b`, `0 <= x <= 1023`. If there is no space for `x` more bits in `b`, or if `x` is not within the range `0...1023`, throws an exception.
**Category:** Cell Build (cell\_build)
```fift title="Fift" BCHKBITS ``` #### `CF3A` BCHKREFS [#cf3a-bchkrefs] Checks whether `y` references can be stored into `b`, `0 <= y <= 7`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" BCHKREFS ``` #### `CF3B` BCHKBITREFS [#cf3b-bchkbitrefs] Checks whether `x` bits and `y` references can be stored into `b`, `0 <= x <= 1023`, `0 <= y <= 7`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" BCHKBITREFS ``` #### `CF3Ccc` BCHKBITSQ [#cf3ccc-bchkbitsq] Checks whether `cc+1` bits can be stored into `b`, where `0 <= cc <= 255`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" [cc+1] BCHKBITSQ# ``` #### `CF3D` BCHKBITSQ\_VAR [#cf3d-bchkbitsq_var] Checks whether `x` bits can be stored into `b`, `0 <= x <= 1023`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" BCHKBITSQ ``` #### `CF3E` BCHKREFSQ [#cf3e-bchkrefsq] Checks whether `y` references can be stored into `b`, `0 <= y <= 7`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" BCHKREFSQ ``` #### `CF3F` BCHKBITREFSQ [#cf3f-bchkbitrefsq] Checks whether `x` bits and `y` references can be stored into `b`, `0 <= x <= 1023`, `0 <= y <= 7`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" BCHKBITREFSQ ``` #### `CF40` STZEROES [#cf40-stzeroes] Stores `n` binary zeroes into *Builder* `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STZEROES ``` #### `CF41` STONES [#cf41-stones] Stores `n` binary ones into *Builder* `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STONES ``` #### `CF42` STSAME [#cf42-stsame] Stores `n` binary `x`es (`0 <= x <= 1`) into *Builder* `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STSAME ``` #### `CF50` BTOS [#cf50-btos] Same as `ENDC CTOS`, but without gas cost for cell creation and loading.
**Category:** Cell Build (cell\_build)
```fift title="Fift" BTOS ``` #### `CFC_xysss` STSLICECONST [#cfc_xysss-stsliceconst] Stores a constant subslice `sss`.
*Details:* `sss` consists of `0 <= x <= 3` references and up to `8y+2` data bits, with `0 <= y <= 7`. Completion bit is assumed.
Note that the assembler can replace `STSLICECONST` with `PUSHSLICE` `STSLICER` if the slice is too big.
**Category:** Cell Build (cell\_build)
```fift title="Fift" [slice] STSLICECONST ``` **Aliases**: * `STZERO`
Stores one binary zero. * `STONE`
Stores one binary one. #### `D0` CTOS [#d0-ctos] Converts a *Cell* into a *Slice*. Notice that `c` must be either an ordinary cell, or an exotic cell which is automatically *loaded* to yield an ordinary cell `c'`, converted into a *Slice* afterwards.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" CTOS ``` #### `D1` ENDS [#d1-ends] Removes a *Slice* `s` from the stack, and throws an exception if it is not empty.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" ENDS ``` #### `D2cc` LDI [#d2cc-ldi] Loads (i.e., parses) a signed `cc+1`-bit integer `x` from *Slice* `s`, and returns the remainder of `s` as `s'`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [cc+1] LDI ``` #### `D3cc` LDU [#d3cc-ldu] Loads an unsigned `cc+1`-bit integer `x` from *Slice* `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [cc+1] LDU ``` #### `D4` LDREF [#d4-ldref] Loads a cell reference `c` from `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDREF ``` #### `D5` LDREFRTOS [#d5-ldrefrtos] Equivalent to `LDREF` `SWAP` `CTOS`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDREFRTOS ``` #### `D6cc` LDSLICE [#d6cc-ldslice] Cuts the next `cc+1` bits of `s` into a separate *Slice* `s''`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [cc+1] LDSLICE ``` #### `D700` LDIX [#d700-ldix] Loads a signed `l`-bit (`0 <= l <= 257`) integer `x` from *Slice* `s`, and returns the remainder of `s` as `s'`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDIX ``` #### `D701` LDUX [#d701-ldux] Loads an unsigned `l`-bit integer `x` from (the first `l` bits of) `s`, with `0 <= l <= 256`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDUX ``` #### `D702` PLDIX [#d702-pldix] Preloads a signed `l`-bit integer from *Slice* `s`, for `0 <= l <= 257`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" PLDIX ``` #### `D703` PLDUX [#d703-pldux] Preloads an unsigned `l`-bit integer from `s`, for `0 <= l <= 256`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" PLDUX ``` #### `D704` LDIXQ [#d704-ldixq] Quiet version of `LDIX`: loads a signed `l`-bit integer from `s` similarly to `LDIX`, but returns a success flag, equal to `-1` on success or to `0` on failure (if `s` does not have `l` bits), instead of throwing a cell underflow exception.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDIXQ ``` #### `D705` LDUXQ [#d705-lduxq] Quiet version of `LDUX`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDUXQ ``` #### `D706` PLDIXQ [#d706-pldixq] Quiet version of `PLDIX`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" PLDIXQ ``` #### `D707` PLDUXQ [#d707-plduxq] Quiet version of `PLDUX`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" PLDUXQ ``` #### `D708cc` LDI\_ALT [#d708cc-ldi_alt] A longer encoding for `LDI`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [cc+1] LDI_l ``` #### `D709cc` LDU\_ALT [#d709cc-ldu_alt] A longer encoding for `LDU`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [cc+1] LDU_l ``` #### `D70Acc` PLDI [#d70acc-pldi] Preloads a signed `cc+1`-bit integer from *Slice* `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [cc+1] PLDI ``` #### `D70Bcc` PLDU [#d70bcc-pldu] Preloads an unsigned `cc+1`-bit integer from `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [cc+1] PLDU ``` #### `D70Ccc` LDIQ [#d70ccc-ldiq] A quiet version of `LDI`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [cc+1] LDIQ ``` #### `D70Dcc` LDUQ [#d70dcc-lduq] A quiet version of `LDU`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [cc+1] LDUQ ``` #### `D70Ecc` PLDIQ [#d70ecc-pldiq] A quiet version of `PLDI`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [cc+1] PLDIQ ``` #### `D70Fcc` PLDUQ [#d70fcc-plduq] A quiet version of `PLDU`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [cc+1] PLDUQ ``` #### `D714_c` PLDUZ [#d714_c-plduz] Preloads the first `32(c+1)` bits of *Slice* `s` into an unsigned integer `x`, for `0 <= c <= 7`. If `s` is shorter than necessary, missing bits are assumed to be zero. This operation is intended to be used along with `IFBITJMP` and similar instructions.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [32(c+1)] PLDUZ ``` #### `D718` LDSLICEX [#d718-ldslicex] Loads the first `0 <= l <= 1023` bits from *Slice* `s` into a separate *Slice* `s''`, returning the remainder of `s` as `s'`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDSLICEX ``` #### `D719` PLDSLICEX [#d719-pldslicex] Returns the first `0 <= l <= 1023` bits of `s` as `s''`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" PLDSLICEX ``` #### `D71A` LDSLICEXQ [#d71a-ldslicexq] A quiet version of `LDSLICEX`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDSLICEXQ ``` #### `D71B` PLDSLICEXQ [#d71b-pldslicexq] A quiet version of `LDSLICEXQ`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" PLDSLICEXQ ``` #### `D71Ccc` LDSLICE\_ALT [#d71ccc-ldslice_alt] A longer encoding for `LDSLICE`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [cc+1] LDSLICE_l ``` #### `D71Dcc` PLDSLICE [#d71dcc-pldslice] Returns the first `0 < cc+1 <= 256` bits of `s` as `s''`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [cc+1] PLDSLICE ``` #### `D71Ecc` LDSLICEQ [#d71ecc-ldsliceq] A quiet version of `LDSLICE`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [cc+1] LDSLICEQ ``` #### `D71Fcc` PLDSLICEQ [#d71fcc-pldsliceq] A quiet version of `PLDSLICE`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [cc+1] PLDSLICEQ ``` #### `D720` SDCUTFIRST [#d720-sdcutfirst] Returns the first `0 <= l <= 1023` bits of `s`. It is equivalent to `PLDSLICEX`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SDCUTFIRST ``` #### `D721` SDSKIPFIRST [#d721-sdskipfirst] Returns all but the first `0 <= l <= 1023` bits of `s`. It is equivalent to `LDSLICEX` `NIP`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SDSKIPFIRST ``` #### `D722` SDCUTLAST [#d722-sdcutlast] Returns the last `0 <= l <= 1023` bits of `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SDCUTLAST ``` #### `D723` SDSKIPLAST [#d723-sdskiplast] Returns all but the last `0 <= l <= 1023` bits of `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SDSKIPLAST ``` #### `D724` SDSUBSTR [#d724-sdsubstr] Returns `0 <= l' <= 1023` bits of `s` starting from offset `0 <= l <= 1023`, thus extracting a bit substring out of the data of `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SDSUBSTR ``` #### `D726` SDBEGINSX [#d726-sdbeginsx] Checks whether `s` begins with (the data bits of) `s'`, and removes `s'` from `s` on success. On failure throws a cell deserialization exception. Primitive `SDPFXREV` can be considered a quiet version of `SDBEGINSX`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SDBEGINSX ``` #### `D727` SDBEGINSXQ [#d727-sdbeginsxq] A quiet version of `SDBEGINSX`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SDBEGINSXQ ``` #### `D72A_xsss` SDBEGINS [#d72a_xsss-sdbegins] Checks whether `s` begins with constant bitstring `sss` of length `8x+3` (with continuation bit assumed), where `0 <= x <= 127`, and removes `sss` from `s` on success.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [slice] SDBEGINS ``` #### `D72E_xsss` SDBEGINSQ [#d72e_xsss-sdbeginsq] A quiet version of `SDBEGINS`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [slice] SDBEGINSQ ``` #### `D730` SCUTFIRST [#d730-scutfirst] Returns the first `0 <= l <= 1023` bits and first `0 <= r <= 4` references of `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SCUTFIRST ``` #### `D731` SSKIPFIRST [#d731-sskipfirst] Returns all but the first `l` bits of `s` and `r` references of `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SSKIPFIRST ``` #### `D732` SCUTLAST [#d732-scutlast] Returns the last `0 <= l <= 1023` data bits and last `0 <= r <= 4` references of `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SCUTLAST ``` #### `D733` SSKIPLAST [#d733-sskiplast] Returns all but the last `l` bits of `s` and `r` references of `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SSKIPLAST ``` #### `D734` SUBSLICE [#d734-subslice] Returns `0 <= l' <= 1023` bits and `0 <= r' <= 4` references from *Slice* `s`, after skipping the first `0 <= l <= 1023` bits and first `0 <= r <= 4` references.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SUBSLICE ``` #### `D736` SPLIT [#d736-split] Splits the first `0 <= l <= 1023` data bits and first `0 <= r <= 4` references from `s` into `s'`, returning the remainder of `s` as `s''`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SPLIT ``` #### `D737` SPLITQ [#d737-splitq] A quiet version of `SPLIT`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SPLITQ ``` #### `D739` XCTOS [#d739-xctos] Transforms an ordinary or exotic cell into a *Slice*, as if it were an ordinary cell. A flag is returned indicating whether `c` is exotic. If that be the case, its type can later be deserialized from the first eight bits of `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" XCTOS ``` #### `D73A` XLOAD [#d73a-xload] Loads an exotic cell `c` and returns an ordinary cell `c'`. If `c` is already ordinary, does nothing. If `c` cannot be loaded, throws an exception.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" XLOAD ``` #### `D73B` XLOADQ [#d73b-xloadq] Loads an exotic cell `c` and returns an ordinary cell `c'`. If `c` is already ordinary, does nothing. If `c` cannot be loaded, returns 0.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" XLOADQ ``` #### `D741` SCHKBITS [#d741-schkbits] Checks whether there are at least `l` data bits in *Slice* `s`. If this is not the case, throws a cell deserialisation (i.e., cell underflow) exception.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SCHKBITS ``` #### `D742` SCHKREFS [#d742-schkrefs] Checks whether there are at least `r` references in *Slice* `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SCHKREFS ``` #### `D743` SCHKBITREFS [#d743-schkbitrefs] Checks whether there are at least `l` data bits and `r` references in *Slice* `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SCHKBITREFS ``` #### `D745` SCHKBITSQ [#d745-schkbitsq] Checks whether there are at least `l` data bits in *Slice* `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SCHKBITSQ ``` #### `D746` SCHKREFSQ [#d746-schkrefsq] Checks whether there are at least `r` references in *Slice* `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SCHKREFSQ ``` #### `D747` SCHKBITREFSQ [#d747-schkbitrefsq] Checks whether there are at least `l` data bits and `r` references in *Slice* `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SCHKBITREFSQ ``` #### `D748` PLDREFVAR [#d748-pldrefvar] Returns the `n`-th cell reference of *Slice* `s` for `0 <= n <= 3`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" PLDREFVAR ``` #### `D749` SBITS [#d749-sbits] Returns the number of data bits in *Slice* `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SBITS ``` #### `D74A` SREFS [#d74a-srefs] Returns the number of references in *Slice* `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SREFS ``` #### `D74B` SBITREFS [#d74b-sbitrefs] Returns both the number of data bits and the number of references in `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SBITREFS ``` #### `D74E_n` PLDREFIDX [#d74e_n-pldrefidx] Returns the `n`-th cell reference of *Slice* `s`, where `0 <= n <= 3`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [n] PLDREFIDX ``` **Aliases**: * `PLDREF`
Preloads the first cell reference of a *Slice*. #### `D750` LDILE4 [#d750-ldile4] Loads a little-endian signed 32-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDILE4 ``` #### `D751` LDULE4 [#d751-ldule4] Loads a little-endian unsigned 32-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDULE4 ``` #### `D752` LDILE8 [#d752-ldile8] Loads a little-endian signed 64-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDILE8 ``` #### `D753` LDULE8 [#d753-ldule8] Loads a little-endian unsigned 64-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDULE8 ``` #### `D754` PLDILE4 [#d754-pldile4] Preloads a little-endian signed 32-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" PLDILE4 ``` #### `D755` PLDULE4 [#d755-pldule4] Preloads a little-endian unsigned 32-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" PLDULE4 ``` #### `D756` PLDILE8 [#d756-pldile8] Preloads a little-endian signed 64-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" PLDILE8 ``` #### `D757` PLDULE8 [#d757-pldule8] Preloads a little-endian unsigned 64-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" PLDULE8 ``` #### `D758` LDILE4Q [#d758-ldile4q] Quietly loads a little-endian signed 32-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDILE4Q ``` #### `D759` LDULE4Q [#d759-ldule4q] Quietly loads a little-endian unsigned 32-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDULE4Q ``` #### `D75A` LDILE8Q [#d75a-ldile8q] Quietly loads a little-endian signed 64-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDILE8Q ``` #### `D75B` LDULE8Q [#d75b-ldule8q] Quietly loads a little-endian unsigned 64-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDULE8Q ``` #### `D75C` PLDILE4Q [#d75c-pldile4q] Quietly preloads a little-endian signed 32-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" PLDILE4Q ``` #### `D75D` PLDULE4Q [#d75d-pldule4q] Quietly preloads a little-endian unsigned 32-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" PLDULE4Q ``` #### `D75E` PLDILE8Q [#d75e-pldile8q] Quietly preloads a little-endian signed 64-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" PLDILE8Q ``` #### `D75F` PLDULE8Q [#d75f-pldule8q] Quietly preloads a little-endian unsigned 64-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" PLDULE8Q ``` #### `D760` LDZEROES [#d760-ldzeroes] Returns the count `n` of leading zero bits in `s`, and removes these bits from `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDZEROES ``` #### `D761` LDONES [#d761-ldones] Returns the count `n` of leading one bits in `s`, and removes these bits from `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDONES ``` #### `D762` LDSAME [#d762-ldsame] Returns the count `n` of leading bits equal to `0 <= x <= 1` in `s`, and removes these bits from `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDSAME ``` #### `D764` SDEPTH [#d764-sdepth] Returns the depth of *Slice* `s`. If `s` has no references, then `x=0`; otherwise `x` is one plus the maximum of depths of cells referred to from `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SDEPTH ``` #### `D765` CDEPTH [#d765-cdepth] Returns the depth of *Cell* `c`. If `c` has no references, then `x=0`; otherwise `x` is one plus the maximum of depths of cells referred to from `c`. If `c` is a *Null* instead of a *Cell*, returns zero.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" CDEPTH ``` #### `D766` CLEVEL [#d766-clevel] Returns level of the cell.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" CLEVEL ``` #### `D767` CLEVELMASK [#d767-clevelmask] Returns level mask of the cell.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" CLEVELMASK ``` #### `D76A_` CHASHI [#d76a_-chashi] Returns `i`th hash of the cell.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [i] CHASHI ``` #### `D76E_` CDEPTHI [#d76e_-cdepthi] Returns `i`th depth of the cell.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [i] CDEPTHI ``` #### `D770` CHASHIX [#d770-chashix] Returns `i`th hash of the cell.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" CHASHIX ``` #### `D771` CDEPTHIX [#d771-cdepthix] Returns `i`th depth of the cell.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" CDEPTHIX ``` #### `D8` EXECUTE [#d8-execute] *Calls*, or *executes*, continuation `c`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" EXECUTE CALLX ``` #### `D9` JMPX [#d9-jmpx] *Jumps*, or transfers control, to continuation `c`.
The remainder of the previous current continuation `cc` is discarded.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" JMPX ``` #### `DApr` CALLXARGS [#dapr-callxargs] *Calls* continuation `c` with `p` parameters and expecting `r` return values
`0 <= p <= 15`, `0 <= r <= 15`
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" [p] [r] CALLXARGS ``` #### `DB0p` CALLXARGS\_VAR [#db0p-callxargs_var] *Calls* continuation `c` with `0 <= p <= 15` parameters, expecting an arbitrary number of return values.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" [p] -1 CALLXARGS ``` #### `DB1p` JMPXARGS [#db1p-jmpxargs] *Jumps* to continuation `c`, passing only the top `0 <= p <= 15` values from the current stack to it (the remainder of the current stack is discarded).
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" [p] JMPXARGS ``` #### `DB2r` RETARGS [#db2r-retargs] *Returns* to `c0`, with `0 <= r <= 15` return values taken from the current stack.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" [r] RETARGS ``` #### `DB30` RET [#db30-ret] *Returns* to the continuation at `c0`. The remainder of the current continuation `cc` is discarded.
Approximately equivalent to `c0 PUSHCTR` `JMPX`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" RET RETTRUE ``` #### `DB31` RETALT [#db31-retalt] *Returns* to the continuation at `c1`.
Approximately equivalent to `c1 PUSHCTR` `JMPX`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" RETALT RETFALSE ``` #### `DB32` BRANCH [#db32-branch] Performs `RETTRUE` if integer `f!=0`, or `RETFALSE` if `f=0`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" BRANCH RETBOOL ``` #### `DB34` CALLCC [#db34-callcc] *Call with current continuation*, transfers control to `c`, pushing the old value of `cc` into `c`'s stack (instead of discarding it or writing it into new `c0`).
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" CALLCC ``` #### `DB35` JMPXDATA [#db35-jmpxdata] Similar to `CALLCC`, but the remainder of the current continuation (the old value of `cc`) is converted into a *Slice* before pushing it into the stack of `c`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" JMPXDATA ``` #### `DB36pr` CALLCCARGS [#db36pr-callccargs] Similar to `CALLXARGS`, but pushes the old value of `cc` (along with the top `0 <= p <= 15` values from the original stack) into the stack of newly-invoked continuation `c`, setting `cc.nargs` to `-1 <= r <= 14`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" [p] [r] CALLCCARGS ``` #### `DB38` CALLXVARARGS [#db38-callxvarargs] Similar to `CALLXARGS`, but takes `-1 <= p,r <= 254` from the stack. The next three operations also take `p` and `r` from the stack, both in the range `-1...254`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" CALLXVARARGS ``` #### `DB39` RETVARARGS [#db39-retvarargs] Similar to `RETARGS`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" RETVARARGS ``` #### `DB3A` JMPXVARARGS [#db3a-jmpxvarargs] Similar to `JMPXARGS`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" JMPXVARARGS ``` #### `DB3B` CALLCCVARARGS [#db3b-callccvarargs] Similar to `CALLCCARGS`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" CALLCCVARARGS ``` #### `DB3C` CALLREF [#db3c-callref] Equivalent to `PUSHREFCONT` `CALLX`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" [ref] CALLREF ``` #### `DB3D` JMPREF [#db3d-jmpref] Equivalent to `PUSHREFCONT` `JMPX`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" [ref] JMPREF ``` #### `DB3E` JMPREFDATA [#db3e-jmprefdata] Equivalent to `PUSHREFCONT` `JMPXDATA`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" [ref] JMPREFDATA ``` #### `DB3F` RETDATA [#db3f-retdata] Equivalent to `c0 PUSHCTR` `JMPXDATA`. In this way, the remainder of the current continuation is converted into a *Slice* and returned to the caller.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" RETDATA ``` #### `DB4fff` RUNVM [#db4fff-runvm] Runs child VM with code `code` and stack `x_1...x_n`. Returns the resulting stack `x'_1...x'_m` and exitcode. Other arguments and return values are enabled by flags.
Flags operate similarly to `RUNVMX` in Fift:
- `+1`: sets `c3` to code.
- `+2`: pushes an implicit `0` before executing the code.
- `+4`: takes persistent data `c4` from the stack and returns its final value.
- `+8`: takes the gas limit `g_l` from the stack and returns the consumed gas `g_c`.
- `+16`: takes `c7` (smart contract context) from the stack.
- `+32`: returns the final value of `c5` (actions).
- `+64`: pops the hard gas limit `g_m` enabled by `ACCEPT` from the stack.
- `+128`: enables "isolated gas consumption", meaning the child VM maintains a separate set of visited cells and a `chksgn` counter.
- `+256`: pops an integer `r` and ensures exactly `r` values are returned from the top of the stack:
- If `RUNVM` call succeeds and `r` is set, it returns `r` elements. If `r` is not set, it returns all available elements.
- If `RUNVM` is successful but lacks elements on the stack, meaning the stack depth is less than `r`, it is treated as an exception in the child VM. The `exit_code` is set to `-3`, and `exit_arg` is set to `0`, so `0` is returned as the only stack element.
- If `RUNVM` fails with an exception, only one element is returned, `exit_arg`, which should not be confused with `exit_code`.
- In the case of running out of gas, `exit_code` is set to `-14`, and `exit_arg` contains the amount of gas.
Gas cost:
- 66 gas;
- 1 gas for each stack element passed to the child VM (the first 32 elements are free);
- 1 gas for each stack element returned from the child VM (the first 32 elements are free).
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" flags RUNVM ``` #### `DB50` RUNVMX [#db50-runvmx] Runs child VM with code `code` and stack `x_1...x_n`. Returns the resulting stack `x'_1...x'_m` and exitcode. Other arguments and return values are enabled by flags.
Flags operate similarly to `RUNVMX` in Fift:
- `+1`: sets `c3` to code.
- `+2`: pushes an implicit `0` before executing the code.
- `+4`: takes persistent data `c4` from the stack and returns its final value.
- `+8`: takes the gas limit `g_l` from the stack and returns the consumed gas `g_c`.
- `+16`: takes `c7` (smart contract context) from the stack.
- `+32`: returns the final value of `c5` (actions).
- `+64`: pops the hard gas limit `g_m` enabled by `ACCEPT` from the stack.
- `+128`: enables "isolated gas consumption", meaning the child VM maintains a separate set of visited cells and a `chksgn` counter.
- `+256`: pops an integer `r` and ensures exactly `r` values are returned from the top of the stack:
- If `RUNVM` call succeeds and `r` is set, it returns `r` elements. If `r` is not set, it returns all available elements.
- If `RUNVM` is successful but lacks elements on the stack, meaning the stack depth is less than `r`, it is treated as an exception in the child VM. The `exit_code` is set to `-3`, and `exit_arg` is set to `0`, so `0` is returned as the only stack element.
- If `RUNVM` fails with an exception, only one element is returned, `exit_arg`, which should not be confused with `exit_code`.
- In the case of running out of gas, `exit_code` is set to `-14`, and `exit_arg` contains the amount of gas.
Gas cost:
- 66 gas;
- 1 gas for each stack element passed to the child VM (the first 32 elements are free);
- 1 gas for each stack element returned from the child VM (the first 32 elements are free).
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" RUNVMX ``` #### `DC` IFRET [#dc-ifret] Performs a `RET`, but only if integer `f` is non-zero. If `f` is a `NaN`, throws an integer overflow exception.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" IFRET IFNOT: ``` #### `DD` IFNOTRET [#dd-ifnotret] Performs a `RET`, but only if integer `f` is zero.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" IFNOTRET IF: ``` #### `DE` IF [#de-if] Performs `EXECUTE` for `c` (i.e., *executes* `c`), but only if integer `f` is non-zero. Otherwise simply discards both values.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" IF ``` #### `DF` IFNOT [#df-ifnot] Executes continuation `c`, but only if integer `f` is zero. Otherwise simply discards both values.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" IFNOT ``` #### `E0` IFJMP [#e0-ifjmp] Jumps to `c` (similarly to `JMPX`), but only if `f` is non-zero.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" IFJMP ``` #### `E1` IFNOTJMP [#e1-ifnotjmp] Jumps to `c` (similarly to `JMPX`), but only if `f` is zero.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" IFNOTJMP ``` #### `E2` IFELSE [#e2-ifelse] If integer `f` is non-zero, executes `c`, otherwise executes `c'`. Equivalent to `CONDSELCHK` `EXECUTE`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" IFELSE ``` #### `E300` IFREF [#e300-ifref] Equivalent to `PUSHREFCONT` `IF`, with the optimization that the cell reference is not actually loaded into a *Slice* and then converted into an ordinary *Continuation* if `f=0`.
Gas consumption of this primitive depends on whether `f=0` and whether the reference was loaded before.
Similar remarks apply other primitives that accept a continuation as a reference.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" [ref] IFREF ``` #### `E301` IFNOTREF [#e301-ifnotref] Equivalent to `PUSHREFCONT` `IFNOT`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" [ref] IFNOTREF ``` #### `E302` IFJMPREF [#e302-ifjmpref] Equivalent to `PUSHREFCONT` `IFJMP`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" [ref] IFJMPREF ``` #### `E303` IFNOTJMPREF [#e303-ifnotjmpref] Equivalent to `PUSHREFCONT` `IFNOTJMP`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" [ref] IFNOTJMPREF ``` #### `E304` CONDSEL [#e304-condsel] If integer `f` is non-zero, returns `x`, otherwise returns `y`. Notice that no type checks are performed on `x` and `y`; as such, it is more like a conditional stack operation. Roughly equivalent to `ROT` `ISZERO` `INC` `ROLLX` `NIP`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" CONDSEL ``` #### `E305` CONDSELCHK [#e305-condselchk] Same as `CONDSEL`, but first checks whether `x` and `y` have the same type.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" CONDSELCHK ``` #### `E308` IFRETALT [#e308-ifretalt] Performs `RETALT` if integer `f!=0`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" IFRETALT ``` #### `E309` IFNOTRETALT [#e309-ifnotretalt] Performs `RETALT` if integer `f=0`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" IFNOTRETALT ``` #### `E30D` IFREFELSE [#e30d-ifrefelse] Equivalent to `PUSHREFCONT` `SWAP` `IFELSE`, with the optimization that the cell reference is not actually loaded into a *Slice* and then converted into an ordinary *Continuation* if `f=0`. Similar remarks apply to the next two primitives: cells are converted into continuations only when necessary.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" [ref] IFREFELSE ``` #### `E30E` IFELSEREF [#e30e-ifelseref] Equivalent to `PUSHREFCONT` `IFELSE`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" [ref] IFELSEREF ``` #### `E30F` IFREFELSEREF [#e30f-ifrefelseref] Equivalent to `PUSHREFCONT` `PUSHREFCONT` `IFELSE`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" [ref] [ref] IFREFELSEREF ``` #### `E39_n` IFBITJMP [#e39_n-ifbitjmp] Checks whether bit `0 <= n <= 31` is set in integer `x`, and if so, performs `JMPX` to continuation `c`. Value `x` is left in the stack.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" [n] IFBITJMP ``` #### `E3B_n` IFNBITJMP [#e3b_n-ifnbitjmp] Jumps to `c` if bit `0 <= n <= 31` is not set in integer `x`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" [n] IFNBITJMP ``` #### `E3D_n` IFBITJMPREF [#e3d_n-ifbitjmpref] Performs a `JMPREF` if bit `0 <= n <= 31` is set in integer `x`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" [ref] [n] IFBITJMPREF ``` #### `E3F_n` IFNBITJMPREF [#e3f_n-ifnbitjmpref] Performs a `JMPREF` if bit `0 <= n <= 31` is not set in integer `x`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" [ref] [n] IFNBITJMPREF ``` #### `E4` REPEAT [#e4-repeat] Executes continuation `c` `n` times, if integer `n` is non-negative. If `n>=2^31` or `n<-2^31`, generates a range check exception.
Notice that a `RET` inside the code of `c` works as a `continue`, not as a `break`. One should use either alternative (experimental) loops or alternative `RETALT` (along with a `SETEXITALT` before the loop) to `break` out of a loop.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" REPEAT ``` #### `E5` REPEATEND [#e5-repeatend] Similar to `REPEAT`, but it is applied to the current continuation `cc`.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" REPEATEND REPEAT: ``` #### `E6` UNTIL [#e6-until] Executes continuation `c`, then pops an integer `x` from the resulting stack. If `x` is zero, performs another iteration of this loop. The actual implementation of this primitive involves an extraordinary continuation `ec_until` with its arguments set to the body of the loop (continuation `c`) and the original current continuation `cc`. This extraordinary continuation is then saved into the savelist of `c` as `c.c0` and the modified `c` is then executed. The other loop primitives are implemented similarly with the aid of suitable extraordinary continuations.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" UNTIL ``` #### `E7` UNTILEND [#e7-untilend] Similar to `UNTIL`, but executes the current continuation `cc` in a loop. When the loop exit condition is satisfied, performs a `RET`.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" UNTILEND UNTIL: ``` #### `E8` WHILE [#e8-while] Executes `c'` and pops an integer `x` from the resulting stack. If `x` is zero, exists the loop and transfers control to the original `cc`. If `x` is non-zero, executes `c`, and then begins a new iteration.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" WHILE ``` #### `E9` WHILEEND [#e9-whileend] Similar to `WHILE`, but uses the current continuation `cc` as the loop body.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" WHILEEND ``` #### `EA` AGAIN [#ea-again] Similar to `REPEAT`, but executes `c` infinitely many times. A `RET` only begins a new iteration of the infinite loop, which can be exited only by an exception, or a `RETALT` (or an explicit `JMPX`).
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" AGAIN ``` #### `EB` AGAINEND [#eb-againend] Similar to `AGAIN`, but performed with respect to the current continuation `cc`.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" AGAINEND AGAIN: ``` #### `E314` REPEATBRK [#e314-repeatbrk] Similar to `REPEAT`, but also sets `c1` to the original `cc` after saving the old value of `c1` into the savelist of the original `cc`. In this way `RETALT` could be used to break out of the loop body.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" REPEATBRK ``` #### `E315` REPEATENDBRK [#e315-repeatendbrk] Similar to `REPEATEND`, but also sets `c1` to the original `c0` after saving the old value of `c1` into the savelist of the original `c0`. Equivalent to `SAMEALTSAVE` `REPEATEND`.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" REPEATENDBRK ``` #### `E316` UNTILBRK [#e316-untilbrk] Similar to `UNTIL`, but also modifies `c1` in the same way as `REPEATBRK`.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" UNTILBRK ``` #### `E317` UNTILENDBRK [#e317-untilendbrk] Equivalent to `SAMEALTSAVE` `UNTILEND`.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" UNTILENDBRK UNTILBRK: ``` #### `E318` WHILEBRK [#e318-whilebrk] Similar to `WHILE`, but also modifies `c1` in the same way as `REPEATBRK`.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" WHILEBRK ``` #### `E319` WHILEENDBRK [#e319-whileendbrk] Equivalent to `SAMEALTSAVE` `WHILEEND`.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" WHILEENDBRK ``` #### `E31A` AGAINBRK [#e31a-againbrk] Similar to `AGAIN`, but also modifies `c1` in the same way as `REPEATBRK`.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" AGAINBRK ``` #### `E31B` AGAINENDBRK [#e31b-againendbrk] Equivalent to `SAMEALTSAVE` `AGAINEND`.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" AGAINENDBRK AGAINBRK: ``` #### `ECrn` SETCONTARGS\_N [#ecrn-setcontargs_n] Pushes `0 <= r <= 15` values `x_1...x_r` into the stack of (a copy of) the continuation `c`, starting with `x_1`. When `n` is 15 (-1 in Fift notation), does nothing with `c.nargs`. For `0 <= n <= 14`, sets `c.nargs` to the final size of the stack of `c'` plus `n`. In other words, transforms `c` into a *closure* or a *partially applied function*, with `0 <= n <= 14` arguments missing.
**Category:** Cont Stack (cont\_stack)
```fift title="Fift" [r] [n] SETCONTARGS ``` **Aliases**: * `SETNUMARGS`
Sets `c.nargs` to `n` plus the current depth of `c`'s stack, where `0 <= n <= 14`. If `c.nargs` is already set to a non-negative value, does nothing. * `SETCONTARGS`
Pushes `0 <= r <= 15` values `x_1...x_r` into the stack of (a copy of) the continuation `c`, starting with `x_1`. If the final depth of `c`'s stack turns out to be greater than `c.nargs`, a stack overflow exception is generated. #### `ED0p` RETURNARGS [#ed0p-returnargs] Leaves only the top `0 <= p <= 15` values in the current stack (somewhat similarly to `ONLYTOPX`), with all the unused bottom values not discarded, but saved into continuation `c0` in the same way as `SETCONTARGS` does.
**Category:** Cont Stack (cont\_stack)
```fift title="Fift" [p] RETURNARGS ``` #### `ED10` RETURNVARARGS [#ed10-returnvarargs] Similar to `RETURNARGS`, but with Integer `0 <= p <= 255` taken from the stack.
**Category:** Cont Stack (cont\_stack)
```fift title="Fift" RETURNVARARGS ``` #### `ED11` SETCONTVARARGS [#ed11-setcontvarargs] Similar to `SETCONTARGS`, but with `0 <= r <= 255` and `-1 <= n <= 255` taken from the stack.
**Category:** Cont Stack (cont\_stack)
```fift title="Fift" SETCONTVARARGS ``` #### `ED12` SETNUMVARARGS [#ed12-setnumvarargs] `-1 <= n <= 255`
If `n=-1`, this operation does nothing (`c'=c`).
Otherwise its action is similar to `[n] SETNUMARGS`, but with `n` taken from the stack.
**Category:** Cont Stack (cont\_stack)
```fift title="Fift" SETNUMVARARGS ``` #### `ED1E` BLESS [#ed1e-bless] Transforms a *Slice* `s` into a simple ordinary continuation `c`, with `c.code=s` and an empty stack and savelist.
**Category:** Cont Create (cont\_create)
```fift title="Fift" BLESS ``` #### `ED1F` BLESSVARARGS [#ed1f-blessvarargs] Equivalent to `ROT` `BLESS` `ROTREV` `SETCONTVARARGS`.
**Category:** Cont Create (cont\_create)
```fift title="Fift" BLESSVARARGS ``` #### `EErn` BLESSARGS [#eern-blessargs] `0 <= r <= 15`, `-1 <= n <= 14`
Equivalent to `BLESS` `[r] [n] SETCONTARGS`.
The value of `n` is represented inside the instruction by the 4-bit integer `n mod 16`.
**Category:** Cont Create (cont\_create)
```fift title="Fift" [r] [n] BLESSARGS ``` **Aliases**: * `BLESSNUMARGS`
Also transforms a *Slice* `s` into a *Continuation* `c`, but sets `c.nargs` to `0 <= n <= 14`. #### `ED4i` PUSHCTR [#ed4i-pushctr] Pushes the current value of control register `c(i)`. If the control register is not supported in the current codepage, or if it does not have a value, an exception is triggered.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" c[i] PUSHCTR c[i] PUSH ``` **Aliases**: * `PUSHROOT`
Pushes the ''global data root'' cell reference, thus enabling access to persistent smart-contract data. #### `ED5i` POPCTR [#ed5i-popctr] Pops a value `x` from the stack and stores it into control register `c(i)`, if supported in the current codepage. Notice that if a control register accepts only values of a specific type, a type-checking exception may occur.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" c[i] POPCTR c[i] POP ``` **Aliases**: * `POPROOT`
Sets the ''global data root'' cell reference, thus allowing modification of persistent smart-contract data. #### `ED6i` SETCONTCTR [#ed6i-setcontctr] Stores `x` into the savelist of continuation `c` as `c(i)`, and returns the resulting continuation `c'`. Almost all operations with continuations may be expressed in terms of `SETCONTCTR`, `POPCTR`, and `PUSHCTR`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" c[i] SETCONT c[i] SETCONTCTR ``` #### `ED7i` SETRETCTR [#ed7i-setretctr] Equivalent to `c0 PUSHCTR` `c[i] SETCONTCTR` `c0 POPCTR`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" c[i] SETRETCTR ``` #### `ED8i` SETALTCTR [#ed8i-setaltctr] Equivalent to `c1 PUSHCTR` `c[i] SETCONTCTR` `c1 POPCTR`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" c[i] SETALTCTR ``` #### `ED9i` POPSAVE [#ed9i-popsave] Similar to `c[i] POPCTR`, but also saves the old value of `c[i]` into continuation `c0`.
Equivalent (up to exceptions) to `c[i] SAVECTR` `c[i] POPCTR`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" c[i] POPSAVE c[i] POPCTRSAVE ``` #### `EDAi` SAVE [#edai-save] Saves the current value of `c(i)` into the savelist of continuation `c0`. If an entry for `c[i]` is already present in the savelist of `c0`, nothing is done. Equivalent to `c[i] PUSHCTR` `c[i] SETRETCTR`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" c[i] SAVE c[i] SAVECTR ``` #### `EDBi` SAVEALT [#edbi-savealt] Similar to `c[i] SAVE`, but saves the current value of `c[i]` into the savelist of `c1`, not `c0`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" c[i] SAVEALT c[i] SAVEALTCTR ``` #### `EDCi` SAVEBOTH [#edci-saveboth] Equivalent to `c[i] SAVE` `c[i] SAVEALT`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" c[i] SAVEBOTH c[i] SAVEBOTHCTR ``` #### `EDE0` PUSHCTRX [#ede0-pushctrx] Similar to `c[i] PUSHCTR`, but with `i`, `0 <= i <= 255`, taken from the stack.
Notice that this primitive is one of the few ''exotic'' primitives, which are not polymorphic like stack manipulation primitives, and at the same time do not have well-defined types of parameters and return values, because the type of `x` depends on `i`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" PUSHCTRX ``` #### `EDE1` POPCTRX [#ede1-popctrx] Similar to `c[i] POPCTR`, but with `0 <= i <= 255` from the stack.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" POPCTRX ``` #### `EDE2` SETCONTCTRX [#ede2-setcontctrx] Similar to `c[i] SETCONTCTR`, but with `0 <= i <= 255` from the stack.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" SETCONTCTRX ``` #### `EDE3mm` SETCONTCTRMANY [#ede3mm-setcontctrmany] Takes continuation, performs the equivalent of `c[i] PUSHCTR SWAP c[i] SETCONTCNR` for each `i` that is set in `mask` (mask is in `0..255`).
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" SETCONTCTRMANY SETCONTMANY ``` #### `EDE4` SETCONTCTRMANYX [#ede4-setcontctrmanyx] Takes continuation, performs the equivalent of `c[i] PUSHCTR SWAP c[i] SETCONTCNR` for each `i` that is set in `mask` (mask is in `0..255`).
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" SETCONTCTRMANYX SETCONTMANYX ``` #### `EDF0` COMPOS [#edf0-compos] Computes the composition `compose0(c, c')`, which has the meaning of ''perform `c`, and, if successful, perform `c'`'' (if `c` is a boolean circuit) or simply ''perform `c`, then `c'`''. Equivalent to `SWAP` `c0 SETCONT`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" COMPOS BOOLAND ``` #### `EDF1` COMPOSALT [#edf1-composalt] Computes the alternative composition `compose1(c, c')`, which has the meaning of ''perform `c`, and, if not successful, perform `c'`'' (if `c` is a boolean circuit). Equivalent to `SWAP` `c1 SETCONT`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" COMPOSALT BOOLOR ``` #### `EDF2` COMPOSBOTH [#edf2-composboth] Computes composition `compose1(compose0(c, c'), c')`, which has the meaning of ''compute boolean circuit `c`, then compute `c'`, regardless of the result of `c`''.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" COMPOSBOTH ``` #### `EDF3` ATEXIT [#edf3-atexit] Sets `c0` to `compose0(c, c0)`. In other words, `c` will be executed before exiting current subroutine.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" ATEXIT ``` #### `EDF4` ATEXITALT [#edf4-atexitalt] Sets `c1` to `compose1(c, c1)`. In other words, `c` will be executed before exiting current subroutine by its alternative return path.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" ATEXITALT ``` #### `EDF5` SETEXITALT [#edf5-setexitalt] Sets `c1` to `compose1(compose0(c, c0), c1)`,
In this way, a subsequent `RETALT` will first execute `c`, then transfer control to the original `c0`. This can be used, for instance, to exit from nested loops.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" SETEXITALT ``` #### `EDF6` THENRET [#edf6-thenret] Computes `compose0(c, c0)`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" THENRET ``` #### `EDF7` THENRETALT [#edf7-thenretalt] Computes `compose0(c, c1)`
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" THENRETALT ``` #### `EDF8` INVERT [#edf8-invert] Interchanges `c0` and `c1`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" INVERT ``` #### `EDF9` BOOLEVAL [#edf9-booleval] Performs `cc:=compose1(compose0(c, compose0(-1 PUSHINT, cc)), compose0(0 PUSHINT, cc))`. If `c` represents a boolean circuit, the net effect is to evaluate it and push either `-1` or `0` into the stack before continuing.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" BOOLEVAL ``` #### `EDFA` SAMEALT [#edfa-samealt] Sets `c1` to `c0`. Equivalent to `c0 PUSHCTR` `c1 POPCTR`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" SAMEALT ``` #### `EDFB` SAMEALTSAVE [#edfb-samealtsave] Sets `c1` to `c0`, but first saves the old value of `c1` into the savelist of `c0`.
Equivalent to `c1 SAVE` `SAMEALT`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" SAMEALTSAVE ``` #### `F0nn` CALLDICT [#f0nn-calldict] Calls the continuation in `c3`, pushing integer `0 <= nn <= 255` into its stack as an argument.
Approximately equivalent to `[nn] PUSHINT` `c3 PUSHCTR` `EXECUTE`.
**Category:** Cont Dict (cont\_dict)
```fift title="Fift" [nn] CALL [nn] CALLDICT ``` #### `F12_n` CALLDICT\_LONG [#f12_n-calldict_long] For `0 <= n < 2^14`, an encoding of `[n] CALL` for larger values of `n`.
**Category:** Cont Dict (cont\_dict)
```fift title="Fift" [n] CALL [n] CALLDICT ``` #### `F16_n` JMPDICT [#f16_n-jmpdict] Jumps to the continuation in `c3`, pushing integer `0 <= n < 2^14` as its argument.
Approximately equivalent to `n PUSHINT` `c3 PUSHCTR` `JMPX`.
**Category:** Cont Dict (cont\_dict)
```fift title="Fift" [n] JMP ``` #### `F1A_n` PREPAREDICT [#f1a_n-preparedict] Equivalent to `n PUSHINT` `c3 PUSHCTR`, for `0 <= n < 2^14`.
In this way, `[n] CALL` is approximately equivalent to `[n] PREPARE` `EXECUTE`, and `[n] JMP` is approximately equivalent to `[n] PREPARE` `JMPX`.
One might use, for instance, `CALLXARGS` or `CALLCC` instead of `EXECUTE` here.
**Category:** Cont Dict (cont\_dict)
```fift title="Fift" [n] PREPARE [n] PREPAREDICT ``` #### `F22_n` THROW\_SHORT [#f22_n-throw_short] Throws exception `0 <= n <= 63` with parameter zero.
In other words, it transfers control to the continuation in `c2`, pushing `0` and `n` into its stack, and discarding the old stack altogether.
**Category:** Exceptions (exceptions)
```fift title="Fift" [n] THROW ``` #### `F26_n` THROWIF\_SHORT [#f26_n-throwif_short] Throws exception `0 <= n <= 63` with parameter zero only if integer `f!=0`.
**Category:** Exceptions (exceptions)
```fift title="Fift" [n] THROWIF ``` #### `F2A_n` THROWIFNOT\_SHORT [#f2a_n-throwifnot_short] Throws exception `0 <= n <= 63` with parameter zero only if integer `f=0`.
**Category:** Exceptions (exceptions)
```fift title="Fift" [n] THROWIFNOT ``` #### `F2C4_n` THROW [#f2c4_n-throw] For `0 <= n < 2^11`, an encoding of `[n] THROW` for larger values of `n`.
**Category:** Exceptions (exceptions)
```fift title="Fift" [n] THROW ``` #### `F2CC_n` THROWARG [#f2cc_n-throwarg] Throws exception `0 <= n < 2^11` with parameter `x`, by copying `x` and `n` into the stack of `c2` and transferring control to `c2`.
**Category:** Exceptions (exceptions)
```fift title="Fift" [n] THROWARG ``` #### `F2D4_n` THROWIF [#f2d4_n-throwif] For `0 <= n < 2^11`, an encoding of `[n] THROWIF` for larger values of `n`.
**Category:** Exceptions (exceptions)
```fift title="Fift" [n] THROWIF ``` #### `F2DC_n` THROWARGIF [#f2dc_n-throwargif] Throws exception `0 <= nn < 2^11` with parameter `x` only if integer `f!=0`.
**Category:** Exceptions (exceptions)
```fift title="Fift" [n] THROWARGIF ``` #### `F2E4_n` THROWIFNOT [#f2e4_n-throwifnot] For `0 <= n < 2^11`, an encoding of `[n] THROWIFNOT` for larger values of `n`.
**Category:** Exceptions (exceptions)
```fift title="Fift" [n] THROWIFNOT ``` #### `F2EC_n` THROWARGIFNOT [#f2ec_n-throwargifnot] Throws exception `0 <= n < 2^11` with parameter `x` only if integer `f=0`.
**Category:** Exceptions (exceptions)
```fift title="Fift" [n] THROWARGIFNOT ``` #### `F2F0` THROWANY [#f2f0-throwany] Throws exception `0 <= n < 2^16` with parameter zero.
Approximately equivalent to `ZERO` `SWAP` `THROWARGANY`.
**Category:** Exceptions (exceptions)
```fift title="Fift" THROWANY ``` #### `F2F1` THROWARGANY [#f2f1-throwargany] Throws exception `0 <= n < 2^16` with parameter `x`, transferring control to the continuation in `c2`.
Approximately equivalent to `c2 PUSHCTR` `2 JMPXARGS`.
**Category:** Exceptions (exceptions)
```fift title="Fift" THROWARGANY ``` #### `F2F2` THROWANYIF [#f2f2-throwanyif] Throws exception `0 <= n < 2^16` with parameter zero only if `f!=0`.
**Category:** Exceptions (exceptions)
```fift title="Fift" THROWANYIF ``` #### `F2F3` THROWARGANYIF [#f2f3-throwarganyif] Throws exception `0 <= n<2^16` with parameter `x` only if `f!=0`.
**Category:** Exceptions (exceptions)
```fift title="Fift" THROWARGANYIF ``` #### `F2F4` THROWANYIFNOT [#f2f4-throwanyifnot] Throws exception `0 <= n<2^16` with parameter zero only if `f=0`.
**Category:** Exceptions (exceptions)
```fift title="Fift" THROWANYIFNOT ``` #### `F2F5` THROWARGANYIFNOT [#f2f5-throwarganyifnot] Throws exception `0 <= n<2^16` with parameter `x` only if `f=0`.
**Category:** Exceptions (exceptions)
```fift title="Fift" THROWARGANYIFNOT ``` #### `F2FF` TRY [#f2ff-try] Sets `c2` to `c'`, first saving the old value of `c2` both into the savelist of `c'` and into the savelist of the current continuation, which is stored into `c.c0` and `c'.c0`. Then runs `c` similarly to `EXECUTE`. If `c` does not throw any exceptions, the original value of `c2` is automatically restored on return from `c`. If an exception occurs, the execution is transferred to `c'`, but the original value of `c2` is restored in the process, so that `c'` can re-throw the exception by `THROWANY` if it cannot handle it by itself.
**Category:** Exceptions (exceptions)
```fift title="Fift" TRY ``` #### `F3pr` TRYARGS [#f3pr-tryargs] Similar to `TRY`, but with `[p] [r] CALLXARGS` internally used instead of `EXECUTE`.
In this way, all but the top `0 <= p <= 15` stack elements will be saved into current continuation's stack, and then restored upon return from either `c` or `c'`, with the top `0 <= r <= 15` values of the resulting stack of `c` or `c'` copied as return values.
**Category:** Exceptions (exceptions)
```fift title="Fift" [p] [r] TRYARGS ``` #### `F400` STDICT [#f400-stdict] Stores dictionary `D` into *Builder* `b`, returning the resulting *Builder* `b'`.
In other words, if `D` is a cell, performs `STONE` and `STREF`; if `D` is *Null*, performs `NIP` and `STZERO`; otherwise throws a type checking exception.
**Category:** Dict Serial (dict\_serial)
```fift title="Fift" STDICT STOPTREF ``` #### `F401` SKIPDICT [#f401-skipdict] Equivalent to `LDDICT` `NIP`.
**Category:** Dict Serial (dict\_serial)
```fift title="Fift" SKIPDICT SKIPOPTREF ``` #### `F402` LDDICTS [#f402-lddicts] Loads (parses) a (*Slice*-represented) dictionary `s'` from *Slice* `s`, and returns the remainder of `s` as `s''`.
This is a ''split function'' for all `HashmapE(n,X)` dictionary types.
**Category:** Dict Serial (dict\_serial)
```fift title="Fift" LDDICTS ``` #### `F403` PLDDICTS [#f403-plddicts] Preloads a (*Slice*-represented) dictionary `s'` from *Slice* `s`.
Approximately equivalent to `LDDICTS` `DROP`.
**Category:** Dict Serial (dict\_serial)
```fift title="Fift" PLDDICTS ``` #### `F404` LDDICT [#f404-lddict] Loads (parses) a dictionary `D` from *Slice* `s`, and returns the remainder of `s` as `s'`. May be applied to dictionaries or to values of arbitrary `(^Y)?` types.
**Category:** Dict Serial (dict\_serial)
```fift title="Fift" LDDICT LDOPTREF ``` #### `F405` PLDDICT [#f405-plddict] Preloads a dictionary `D` from *Slice* `s`.
Approximately equivalent to `LDDICT` `DROP`.
**Category:** Dict Serial (dict\_serial)
```fift title="Fift" PLDDICT PLDOPTREF ``` #### `F406` LDDICTQ [#f406-lddictq] A quiet version of `LDDICT`.
**Category:** Dict Serial (dict\_serial)
```fift title="Fift" LDDICTQ ``` #### `F407` PLDDICTQ [#f407-plddictq] A quiet version of `PLDDICT`.
**Category:** Dict Serial (dict\_serial)
```fift title="Fift" PLDDICTQ ``` #### `F40A` DICTGET [#f40a-dictget] Looks up key `k` (represented by a *Slice*, the first `0 <= n <= 1023` data bits of which are used as a key) in dictionary `D` of type `HashmapE(n,X)` with `n`-bit keys.
On success, returns the value found as a *Slice* `x`.
**Category:** Dict Get (dict\_get)
```fift title="Fift" DICTGET ``` #### `F40B` DICTGETREF [#f40b-dictgetref] Similar to `DICTGET`, but with a `LDREF` `ENDS` applied to `x` on success.
This operation is useful for dictionaries of type `HashmapE(n,^Y)`.
**Category:** Dict Get (dict\_get)
```fift title="Fift" DICTGETREF ``` #### `F40C` DICTIGET [#f40c-dictiget] Similar to `DICTGET`, but with a signed (big-endian) `n`-bit *Integer* `i` as a key. If `i` does not fit into `n` bits, returns `0`. If `i` is a `NaN`, throws an integer overflow exception.
**Category:** Dict Get (dict\_get)
```fift title="Fift" DICTIGET ``` #### `F40D` DICTIGETREF [#f40d-dictigetref] Combines `DICTIGET` with `DICTGETREF`: it uses signed `n`-bit *Integer* `i` as a key and returns a *Cell* instead of a *Slice* on success.
**Category:** Dict Get (dict\_get)
```fift title="Fift" DICTIGETREF ``` #### `F40E` DICTUGET [#f40e-dictuget] Similar to `DICTIGET`, but with *unsigned* (big-endian) `n`-bit *Integer* `i` used as a key.
**Category:** Dict Get (dict\_get)
```fift title="Fift" DICTUGET ``` #### `F40F` DICTUGETREF [#f40f-dictugetref] Similar to `DICTIGETREF`, but with an unsigned `n`-bit *Integer* key `i`.
**Category:** Dict Get (dict\_get)
```fift title="Fift" DICTUGETREF ``` #### `F412` DICTSET [#f412-dictset] Sets the value associated with `n`-bit key `k` (represented by a *Slice* as in `DICTGET`) in dictionary `D` (also represented by a *Slice*) to value `x` (again a *Slice*), and returns the resulting dictionary as `D'`.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTSET ``` #### `F413` DICTSETREF [#f413-dictsetref] Similar to `DICTSET`, but with the value set to a reference to *Cell* `c`.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTSETREF ``` #### `F414` DICTISET [#f414-dictiset] Similar to `DICTSET`, but with the key represented by a (big-endian) signed `n`-bit integer `i`. If `i` does not fit into `n` bits, a range check exception is generated.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTISET ``` #### `F415` DICTISETREF [#f415-dictisetref] Similar to `DICTSETREF`, but with the key a signed `n`-bit integer as in `DICTISET`.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTISETREF ``` #### `F416` DICTUSET [#f416-dictuset] Similar to `DICTISET`, but with `i` an *unsigned* `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTUSET ``` #### `F417` DICTUSETREF [#f417-dictusetref] Similar to `DICTISETREF`, but with `i` unsigned.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTUSETREF ``` #### `F41A` DICTSETGET [#f41a-dictsetget] Combines `DICTSET` with `DICTGET`: it sets the value corresponding to key `k` to `x`, but also returns the old value `y` associated with the key in question, if present.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTSETGET ``` #### `F41B` DICTSETGETREF [#f41b-dictsetgetref] Combines `DICTSETREF` with `DICTGETREF` similarly to `DICTSETGET`.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTSETGETREF ``` #### `F41C` DICTISETGET [#f41c-dictisetget] `DICTISETGET`, but with `i` a signed `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTISETGET ``` #### `F41D` DICTISETGETREF [#f41d-dictisetgetref] `DICTISETGETREF`, but with `i` a signed `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTISETGETREF ``` #### `F41E` DICTUSETGET [#f41e-dictusetget] `DICTISETGET`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTUSETGET ``` #### `F41F` DICTUSETGETREF [#f41f-dictusetgetref] `DICTISETGETREF`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTUSETGETREF ``` #### `F422` DICTREPLACE [#f422-dictreplace] A *Replace* operation, which is similar to `DICTSET`, but sets the value of key `k` in dictionary `D` to `x` only if the key `k` was already present in `D`.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTREPLACE ``` #### `F423` DICTREPLACEREF [#f423-dictreplaceref] A *Replace* counterpart of `DICTSETREF`.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTREPLACEREF ``` #### `F424` DICTIREPLACE [#f424-dictireplace] `DICTREPLACE`, but with `i` a signed `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTIREPLACE ``` #### `F425` DICTIREPLACEREF [#f425-dictireplaceref] `DICTREPLACEREF`, but with `i` a signed `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTIREPLACEREF ``` #### `F426` DICTUREPLACE [#f426-dictureplace] `DICTREPLACE`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTUREPLACE ``` #### `F427` DICTUREPLACEREF [#f427-dictureplaceref] `DICTREPLACEREF`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTUREPLACEREF ``` #### `F42A` DICTREPLACEGET [#f42a-dictreplaceget] A *Replace* counterpart of `DICTSETGET`: on success, also returns the old value associated with the key in question.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTREPLACEGET ``` #### `F42B` DICTREPLACEGETREF [#f42b-dictreplacegetref] A *Replace* counterpart of `DICTSETGETREF`.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTREPLACEGETREF ``` #### `F42C` DICTIREPLACEGET [#f42c-dictireplaceget] `DICTREPLACEGET`, but with `i` a signed `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTIREPLACEGET ``` #### `F42D` DICTIREPLACEGETREF [#f42d-dictireplacegetref] `DICTREPLACEGETREF`, but with `i` a signed `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTIREPLACEGETREF ``` #### `F42E` DICTUREPLACEGET [#f42e-dictureplaceget] `DICTREPLACEGET`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTUREPLACEGET ``` #### `F42F` DICTUREPLACEGETREF [#f42f-dictureplacegetref] `DICTREPLACEGETREF`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTUREPLACEGETREF ``` #### `F432` DICTADD [#f432-dictadd] An *Add* counterpart of `DICTSET`: sets the value associated with key `k` in dictionary `D` to `x`, but only if it is not already present in `D`.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTADD ``` #### `F433` DICTADDREF [#f433-dictaddref] An *Add* counterpart of `DICTSETREF`.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTADDREF ``` #### `F434` DICTIADD [#f434-dictiadd] `DICTADD`, but with `i` a signed `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTIADD ``` #### `F435` DICTIADDREF [#f435-dictiaddref] `DICTADDREF`, but with `i` a signed `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTIADDREF ``` #### `F436` DICTUADD [#f436-dictuadd] `DICTADD`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTUADD ``` #### `F437` DICTUADDREF [#f437-dictuaddref] `DICTADDREF`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTUADDREF ``` #### `F43A` DICTADDGET [#f43a-dictaddget] An *Add* counterpart of `DICTSETGET`: sets the value associated with key `k` in dictionary `D` to `x`, but only if key `k` is not already present in `D`. Otherwise, just returns the old value `y` without changing the dictionary.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTADDGET ``` #### `F43B` DICTADDGETREF [#f43b-dictaddgetref] An *Add* counterpart of `DICTSETGETREF`.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTADDGETREF ``` #### `F43C` DICTIADDGET [#f43c-dictiaddget] `DICTADDGET`, but with `i` a signed `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTIADDGET ``` #### `F43D` DICTIADDGETREF [#f43d-dictiaddgetref] `DICTADDGETREF`, but with `i` a signed `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTIADDGETREF ``` #### `F43E` DICTUADDGET [#f43e-dictuaddget] `DICTADDGET`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTUADDGET ``` #### `F43F` DICTUADDGETREF [#f43f-dictuaddgetref] `DICTADDGETREF`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTUADDGETREF ``` #### `F441` DICTSETB [#f441-dictsetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTSETB ``` #### `F442` DICTISETB [#f442-dictisetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTISETB ``` #### `F443` DICTUSETB [#f443-dictusetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTUSETB ``` #### `F445` DICTSETGETB [#f445-dictsetgetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTSETGETB ``` #### `F446` DICTISETGETB [#f446-dictisetgetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTISETGETB ``` #### `F447` DICTUSETGETB [#f447-dictusetgetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTUSETGETB ``` #### `F449` DICTREPLACEB [#f449-dictreplaceb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTREPLACEB ``` #### `F44A` DICTIREPLACEB [#f44a-dictireplaceb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTIREPLACEB ``` #### `F44B` DICTUREPLACEB [#f44b-dictureplaceb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTUREPLACEB ``` #### `F44D` DICTREPLACEGETB [#f44d-dictreplacegetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTREPLACEGETB ``` #### `F44E` DICTIREPLACEGETB [#f44e-dictireplacegetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTIREPLACEGETB ``` #### `F44F` DICTUREPLACEGETB [#f44f-dictureplacegetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTUREPLACEGETB ``` #### `F451` DICTADDB [#f451-dictaddb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTADDB ``` #### `F452` DICTIADDB [#f452-dictiaddb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTIADDB ``` #### `F453` DICTUADDB [#f453-dictuaddb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTUADDB ``` #### `F455` DICTADDGETB [#f455-dictaddgetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTADDGETB ``` #### `F456` DICTIADDGETB [#f456-dictiaddgetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTIADDGETB ``` #### `F457` DICTUADDGETB [#f457-dictuaddgetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTUADDGETB ``` #### `F459` DICTDEL [#f459-dictdel] Deletes `n`-bit key, represented by a *Slice* `k`, from dictionary `D`. If the key is present, returns the modified dictionary `D'` and the success flag `-1`. Otherwise, returns the original dictionary `D` and `0`.
**Category:** Dict Delete (dict\_delete)
```fift title="Fift" DICTDEL ``` #### `F45A` DICTIDEL [#f45a-dictidel] A version of `DICTDEL` with the key represented by a signed `n`-bit *Integer* `i`. If `i` does not fit into `n` bits, simply returns `D` `0` (''key not found, dictionary unmodified'').
**Category:** Dict Delete (dict\_delete)
```fift title="Fift" DICTIDEL ``` #### `F45B` DICTUDEL [#f45b-dictudel] Similar to `DICTIDEL`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Delete (dict\_delete)
```fift title="Fift" DICTUDEL ``` #### `F462` DICTDELGET [#f462-dictdelget] Deletes `n`-bit key, represented by a *Slice* `k`, from dictionary `D`. If the key is present, returns the modified dictionary `D'`, the original value `x` associated with the key `k` (represented by a *Slice*), and the success flag `-1`. Otherwise, returns the original dictionary `D` and `0`.
**Category:** Dict Delete (dict\_delete)
```fift title="Fift" DICTDELGET ``` #### `F463` DICTDELGETREF [#f463-dictdelgetref] Similar to `DICTDELGET`, but with `LDREF` `ENDS` applied to `x` on success, so that the value returned `c` is a *Cell*.
**Category:** Dict Delete (dict\_delete)
```fift title="Fift" DICTDELGETREF ``` #### `F464` DICTIDELGET [#f464-dictidelget] `DICTDELGET`, but with `i` a signed `n`-bit integer.
**Category:** Dict Delete (dict\_delete)
```fift title="Fift" DICTIDELGET ``` #### `F465` DICTIDELGETREF [#f465-dictidelgetref] `DICTDELGETREF`, but with `i` a signed `n`-bit integer.
**Category:** Dict Delete (dict\_delete)
```fift title="Fift" DICTIDELGETREF ``` #### `F466` DICTUDELGET [#f466-dictudelget] `DICTDELGET`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Delete (dict\_delete)
```fift title="Fift" DICTUDELGET ``` #### `F467` DICTUDELGETREF [#f467-dictudelgetref] `DICTDELGETREF`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Delete (dict\_delete)
```fift title="Fift" DICTUDELGETREF ``` #### `F469` DICTGETOPTREF [#f469-dictgetoptref] A variant of `DICTGETREF` that returns *Null* instead of the value `c^?` if the key `k` is absent from dictionary `D`.
**Category:** Dict Mayberef (dict\_mayberef)
```fift title="Fift" DICTGETOPTREF ``` #### `F46A` DICTIGETOPTREF [#f46a-dictigetoptref] `DICTGETOPTREF`, but with `i` a signed `n`-bit integer. If the key `i` is out of range, also returns *Null*.
**Category:** Dict Mayberef (dict\_mayberef)
```fift title="Fift" DICTIGETOPTREF ``` #### `F46B` DICTUGETOPTREF [#f46b-dictugetoptref] `DICTGETOPTREF`, but with `i` an unsigned `n`-bit integer. If the key `i` is out of range, also returns *Null*.
**Category:** Dict Mayberef (dict\_mayberef)
```fift title="Fift" DICTUGETOPTREF ``` #### `F46D` DICTSETGETOPTREF [#f46d-dictsetgetoptref] A variant of both `DICTGETOPTREF` and `DICTSETGETREF` that sets the value corresponding to key `k` in dictionary `D` to `c^?` (if `c^?` is *Null*, then the key is deleted instead), and returns the old value `~c^?` (if the key `k` was absent before, returns *Null* instead).
**Category:** Dict Mayberef (dict\_mayberef)
```fift title="Fift" DICTSETGETOPTREF ``` #### `F46E` DICTISETGETOPTREF [#f46e-dictisetgetoptref] Similar to primitive `DICTSETGETOPTREF`, but using signed `n`-bit *Integer* `i` as a key. If `i` does not fit into `n` bits, throws a range checking exception.
**Category:** Dict Mayberef (dict\_mayberef)
```fift title="Fift" DICTISETGETOPTREF ``` #### `F46F` DICTUSETGETOPTREF [#f46f-dictusetgetoptref] Similar to primitive `DICTSETGETOPTREF`, but using unsigned `n`-bit *Integer* `i` as a key.
**Category:** Dict Mayberef (dict\_mayberef)
```fift title="Fift" DICTUSETGETOPTREF ``` #### `F470` PFXDICTSET [#f470-pfxdictset]
**Category:** Dict Prefix (dict\_prefix)
```fift title="Fift" PFXDICTSET ``` #### `F471` PFXDICTREPLACE [#f471-pfxdictreplace]
**Category:** Dict Prefix (dict\_prefix)
```fift title="Fift" PFXDICTREPLACE ``` #### `F472` PFXDICTADD [#f472-pfxdictadd]
**Category:** Dict Prefix (dict\_prefix)
```fift title="Fift" PFXDICTADD ``` #### `F473` PFXDICTDEL [#f473-pfxdictdel]
**Category:** Dict Prefix (dict\_prefix)
```fift title="Fift" PFXDICTDEL ``` #### `F474` DICTGETNEXT [#f474-dictgetnext] Computes the minimal key `k'` in dictionary `D` that is lexicographically greater than `k`, and returns `k'` (represented by a *Slice*) along with associated value `x'` (also represented by a *Slice*).
**Category:** Dict Next (dict\_next)
```fift title="Fift" DICTGETNEXT ``` #### `F475` DICTGETNEXTEQ [#f475-dictgetnexteq] Similar to `DICTGETNEXT`, but computes the minimal key `k'` that is lexicographically greater than or equal to `k`.
**Category:** Dict Next (dict\_next)
```fift title="Fift" DICTGETNEXTEQ ``` #### `F476` DICTGETPREV [#f476-dictgetprev] Similar to `DICTGETNEXT`, but computes the maximal key `k'` lexicographically smaller than `k`.
**Category:** Dict Next (dict\_next)
```fift title="Fift" DICTGETPREV ``` #### `F477` DICTGETPREVEQ [#f477-dictgetpreveq] Similar to `DICTGETPREV`, but computes the maximal key `k'` lexicographically smaller than or equal to `k`.
**Category:** Dict Next (dict\_next)
```fift title="Fift" DICTGETPREVEQ ``` #### `F478` DICTIGETNEXT [#f478-dictigetnext] Similar to `DICTGETNEXT`, but interprets all keys in dictionary `D` as big-endian signed `n`-bit integers, and computes the minimal key `i'` that is larger than *Integer* `i` (which does not necessarily fit into `n` bits).
**Category:** Dict Next (dict\_next)
```fift title="Fift" DICTIGETNEXT ``` #### `F479` DICTIGETNEXTEQ [#f479-dictigetnexteq] Similar to `DICTGETNEXTEQ`, but interprets keys as signed `n`-bit integers.
**Category:** Dict Next (dict\_next)
```fift title="Fift" DICTIGETNEXTEQ ``` #### `F47A` DICTIGETPREV [#f47a-dictigetprev] Similar to `DICTGETPREV`, but interprets keys as signed `n`-bit integers.
**Category:** Dict Next (dict\_next)
```fift title="Fift" DICTIGETPREV ``` #### `F47B` DICTIGETPREVEQ [#f47b-dictigetpreveq] Similar to `DICTGETPREVEQ`, but interprets keys as signed `n`-bit integers.
**Category:** Dict Next (dict\_next)
```fift title="Fift" DICTIGETPREVEQ ``` #### `F47C` DICTUGETNEXT [#f47c-dictugetnext] Similar to `DICTGETNEXT`, but interprets all keys in dictionary `D` as big-endian unsigned `n`-bit integers, and computes the minimal key `i'` that is larger than *Integer* `i` (which does not necessarily fit into `n` bits, and is not necessarily non-negative).
**Category:** Dict Next (dict\_next)
```fift title="Fift" DICTUGETNEXT ``` #### `F47D` DICTUGETNEXTEQ [#f47d-dictugetnexteq] Similar to `DICTGETNEXTEQ`, but interprets keys as unsigned `n`-bit integers.
**Category:** Dict Next (dict\_next)
```fift title="Fift" DICTUGETNEXTEQ ``` #### `F47E` DICTUGETPREV [#f47e-dictugetprev] Similar to `DICTGETPREV`, but interprets keys as unsigned `n`-bit integers.
**Category:** Dict Next (dict\_next)
```fift title="Fift" DICTUGETPREV ``` #### `F47F` DICTUGETPREVEQ [#f47f-dictugetpreveq] Similar to `DICTGETPREVEQ`, but interprets keys a unsigned `n`-bit integers.
**Category:** Dict Next (dict\_next)
```fift title="Fift" DICTUGETPREVEQ ``` #### `F482` DICTMIN [#f482-dictmin] Computes the minimal key `k` (represented by a *Slice* with `n` data bits) in dictionary `D`, and returns `k` along with the associated value `x`.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTMIN ``` #### `F483` DICTMINREF [#f483-dictminref] Similar to `DICTMIN`, but returns the only reference in the value as a *Cell* `c`.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTMINREF ``` #### `F484` DICTIMIN [#f484-dictimin] Similar to `DICTMIN`, but computes the minimal key `i` under the assumption that all keys are big-endian signed `n`-bit integers. Notice that the key and value returned may differ from those computed by `DICTMIN` and `DICTUMIN`.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTIMIN ``` #### `F485` DICTIMINREF [#f485-dictiminref] Similar to `DICTIMIN`, but returns the only reference in the value.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTIMINREF ``` #### `F486` DICTUMIN [#f486-dictumin] Similar to `DICTMIN`, but returns the key as an unsigned `n`-bit *Integer* `i`.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTUMIN ``` #### `F487` DICTUMINREF [#f487-dictuminref] Similar to `DICTUMIN`, but returns the only reference in the value.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTUMINREF ``` #### `F48A` DICTMAX [#f48a-dictmax] Computes the maximal key `k` (represented by a *Slice* with `n` data bits) in dictionary `D`, and returns `k` along with the associated value `x`.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTMAX ``` #### `F48B` DICTMAXREF [#f48b-dictmaxref] Similar to `DICTMAX`, but returns the only reference in the value.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTMAXREF ``` #### `F48C` DICTIMAX [#f48c-dictimax] Similar to `DICTMAX`, but computes the maximal key `i` under the assumption that all keys are big-endian signed `n`-bit integers. Notice that the key and value returned may differ from those computed by `DICTMAX` and `DICTUMAX`.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTIMAX ``` #### `F48D` DICTIMAXREF [#f48d-dictimaxref] Similar to `DICTIMAX`, but returns the only reference in the value.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTIMAXREF ``` #### `F48E` DICTUMAX [#f48e-dictumax] Similar to `DICTMAX`, but returns the key as an unsigned `n`-bit *Integer* `i`.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTUMAX ``` #### `F48F` DICTUMAXREF [#f48f-dictumaxref] Similar to `DICTUMAX`, but returns the only reference in the value.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTUMAXREF ``` #### `F492` DICTREMMIN [#f492-dictremmin] Computes the minimal key `k` (represented by a *Slice* with `n` data bits) in dictionary `D`, removes `k` from the dictionary, and returns `k` along with the associated value `x` and the modified dictionary `D'`.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTREMMIN ``` #### `F493` DICTREMMINREF [#f493-dictremminref] Similar to `DICTREMMIN`, but returns the only reference in the value as a *Cell* `c`.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTREMMINREF ``` #### `F494` DICTIREMMIN [#f494-dictiremmin] Similar to `DICTREMMIN`, but computes the minimal key `i` under the assumption that all keys are big-endian signed `n`-bit integers. Notice that the key and value returned may differ from those computed by `DICTREMMIN` and `DICTUREMMIN`.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTIREMMIN ``` #### `F495` DICTIREMMINREF [#f495-dictiremminref] Similar to `DICTIREMMIN`, but returns the only reference in the value.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTIREMMINREF ``` #### `F496` DICTUREMMIN [#f496-dicturemmin] Similar to `DICTREMMIN`, but returns the key as an unsigned `n`-bit *Integer* `i`.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTUREMMIN ``` #### `F497` DICTUREMMINREF [#f497-dicturemminref] Similar to `DICTUREMMIN`, but returns the only reference in the value.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTUREMMINREF ``` #### `F49A` DICTREMMAX [#f49a-dictremmax] Computes the maximal key `k` (represented by a *Slice* with `n` data bits) in dictionary `D`, removes `k` from the dictionary, and returns `k` along with the associated value `x` and the modified dictionary `D'`.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTREMMAX ``` #### `F49B` DICTREMMAXREF [#f49b-dictremmaxref] Similar to `DICTREMMAX`, but returns the only reference in the value as a *Cell* `c`.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTREMMAXREF ``` #### `F49C` DICTIREMMAX [#f49c-dictiremmax] Similar to `DICTREMMAX`, but computes the minimal key `i` under the assumption that all keys are big-endian signed `n`-bit integers. Notice that the key and value returned may differ from those computed by `DICTREMMAX` and `DICTUREMMAX`.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTIREMMAX ``` #### `F49D` DICTIREMMAXREF [#f49d-dictiremmaxref] Similar to `DICTIREMMAX`, but returns the only reference in the value.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTIREMMAXREF ``` #### `F49E` DICTUREMMAX [#f49e-dicturemmax] Similar to `DICTREMMAX`, but returns the key as an unsigned `n`-bit *Integer* `i`.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTUREMMAX ``` #### `F49F` DICTUREMMAXREF [#f49f-dicturemmaxref] Similar to `DICTUREMMAX`, but returns the only reference in the value.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTUREMMAXREF ``` #### `F4A0` DICTIGETJMP [#f4a0-dictigetjmp] Similar to `DICTIGET`, but with `x` `BLESS`ed into a continuation with a subsequent `JMPX` to it on success. On failure, does nothing. This is useful for implementing `switch`/`case` constructions.
**Category:** Dict Special (dict\_special)
```fift title="Fift" DICTIGETJMP ``` #### `F4A1` DICTUGETJMP [#f4a1-dictugetjmp] Similar to `DICTIGETJMP`, but performs `DICTUGET` instead of `DICTIGET`.
**Category:** Dict Special (dict\_special)
```fift title="Fift" DICTUGETJMP ``` #### `F4A2` DICTIGETEXEC [#f4a2-dictigetexec] Similar to `DICTIGETJMP`, but with `EXECUTE` instead of `JMPX`.
**Category:** Dict Special (dict\_special)
```fift title="Fift" DICTIGETEXEC ``` #### `F4A3` DICTUGETEXEC [#f4a3-dictugetexec] Similar to `DICTUGETJMP`, but with `EXECUTE` instead of `JMPX`.
**Category:** Dict Special (dict\_special)
```fift title="Fift" DICTUGETEXEC ``` #### `F4A6_n` DICTPUSHCONST [#f4a6_n-dictpushconst] Pushes a non-empty constant dictionary `D` (as a `Cell^?`) along with its key length `0 <= n <= 1023`, stored as a part of the instruction. The dictionary itself is created from the first of remaining references of the current continuation. In this way, the complete `DICTPUSHCONST` instruction can be obtained by first serializing `xF4A4_`, then the non-empty dictionary itself (one `1` bit and a cell reference), and then the unsigned 10-bit integer `n` (as if by a `STU 10` instruction). An empty dictionary can be pushed by a `NEWDICT` primitive instead.
**Category:** Dict Special (dict\_special)
```fift title="Fift" [ref] [n] DICTPUSHCONST ``` #### `F4A8` PFXDICTGETQ [#f4a8-pfxdictgetq] Looks up the unique prefix of *Slice* `s` present in the prefix code dictionary represented by `Cell^?` `D` and `0 <= n <= 1023`. If found, the prefix of `s` is returned as `s'`, and the corresponding value (also a *Slice*) as `x`. The remainder of `s` is returned as a *Slice* `s''`. If no prefix of `s` is a key in prefix code dictionary `D`, returns the unchanged `s` and a zero flag to indicate failure.
**Category:** Dict Special (dict\_special)
```fift title="Fift" PFXDICTGETQ ``` #### `F4A9` PFXDICTGET [#f4a9-pfxdictget] Similar to `PFXDICTGET`, but throws a cell deserialization failure exception on failure.
**Category:** Dict Special (dict\_special)
```fift title="Fift" PFXDICTGET ``` #### `F4AA` PFXDICTGETJMP [#f4aa-pfxdictgetjmp] Similar to `PFXDICTGETQ`, but on success `BLESS`es the value `x` into a *Continuation* and transfers control to it as if by a `JMPX`. On failure, returns `s` unchanged and continues execution.
**Category:** Dict Special (dict\_special)
```fift title="Fift" PFXDICTGETJMP ``` #### `F4AB` PFXDICTGETEXEC [#f4ab-pfxdictgetexec] Similar to `PFXDICTGETJMP`, but `EXEC`utes the continuation found instead of jumping to it. On failure, throws a cell deserialization exception.
**Category:** Dict Special (dict\_special)
```fift title="Fift" PFXDICTGETEXEC ``` #### `F4AE_n` PFXDICTCONSTGETJMP [#f4ae_n-pfxdictconstgetjmp] Combines `[n] DICTPUSHCONST` for `0 <= n <= 1023` with `PFXDICTGETJMP`.
**Category:** Dict Special (dict\_special)
```fift title="Fift" [ref] [n] PFXDICTCONSTGETJMP [ref] [n] PFXDICTSWITCH ``` #### `F4BC` DICTIGETJMPZ [#f4bc-dictigetjmpz] A variant of `DICTIGETJMP` that returns index `i` on failure.
**Category:** Dict Special (dict\_special)
```fift title="Fift" DICTIGETJMPZ ``` #### `F4BD` DICTUGETJMPZ [#f4bd-dictugetjmpz] A variant of `DICTUGETJMP` that returns index `i` on failure.
**Category:** Dict Special (dict\_special)
```fift title="Fift" DICTUGETJMPZ ``` #### `F4BE` DICTIGETEXECZ [#f4be-dictigetexecz] A variant of `DICTIGETEXEC` that returns index `i` on failure.
**Category:** Dict Special (dict\_special)
```fift title="Fift" DICTIGETEXECZ ``` #### `F4BF` DICTUGETEXECZ [#f4bf-dictugetexecz] A variant of `DICTUGETEXEC` that returns index `i` on failure.
**Category:** Dict Special (dict\_special)
```fift title="Fift" DICTUGETEXECZ ``` #### `F4B1` SUBDICTGET [#f4b1-subdictget] Constructs a subdictionary consisting of all keys beginning with prefix `k` (represented by a *Slice*, the first `0 <= l <= n <= 1023` data bits of which are used as a key) of length `l` in dictionary `D` of type `HashmapE(n,X)` with `n`-bit keys. On success, returns the new subdictionary of the same type `HashmapE(n,X)` as a *Slice* `D'`.
**Category:** Dict Sub (dict\_sub)
```fift title="Fift" SUBDICTGET ``` #### `F4B2` SUBDICTIGET [#f4b2-subdictiget] Variant of `SUBDICTGET` with the prefix represented by a signed big-endian `l`-bit *Integer* `x`, where necessarily `l <= 257`.
**Category:** Dict Sub (dict\_sub)
```fift title="Fift" SUBDICTIGET ``` #### `F4B3` SUBDICTUGET [#f4b3-subdictuget] Variant of `SUBDICTGET` with the prefix represented by an unsigned big-endian `l`-bit *Integer* `x`, where necessarily `l <= 256`.
**Category:** Dict Sub (dict\_sub)
```fift title="Fift" SUBDICTUGET ``` #### `F4B5` SUBDICTRPGET [#f4b5-subdictrpget] Similar to `SUBDICTGET`, but removes the common prefix `k` from all keys of the new dictionary `D'`, which becomes of type `HashmapE(n-l,X)`.
**Category:** Dict Sub (dict\_sub)
```fift title="Fift" SUBDICTRPGET ``` #### `F4B6` SUBDICTIRPGET [#f4b6-subdictirpget] Variant of `SUBDICTRPGET` with the prefix represented by a signed big-endian `l`-bit *Integer* `x`, where necessarily `l <= 257`.
**Category:** Dict Sub (dict\_sub)
```fift title="Fift" SUBDICTIRPGET ``` #### `F4B7` SUBDICTURPGET [#f4b7-subdicturpget] Variant of `SUBDICTRPGET` with the prefix represented by an unsigned big-endian `l`-bit *Integer* `x`, where necessarily `l <= 256`.
**Category:** Dict Sub (dict\_sub)
```fift title="Fift" SUBDICTURPGET ``` #### `F800` ACCEPT [#f800-accept] Sets current gas limit `g_l` to its maximal allowed value `g_m`, and resets the gas credit `g_c` to zero, decreasing the value of `g_r` by `g_c` in the process.
In other words, the current smart contract agrees to buy some gas to finish the current transaction. This action is required to process external messages, which bring no value (hence no gas) with themselves.
**Category:** App Gas (app\_gas)
```fift title="Fift" ACCEPT ``` #### `F801` SETGASLIMIT [#f801-setgaslimit] Sets current gas limit `g_l` to the minimum of `g` and `g_m`, and resets the gas credit `g_c` to zero. If the gas consumed so far (including the present instruction) exceeds the resulting value of `g_l`, an (unhandled) out of gas exception is thrown before setting new gas limits. Notice that `SETGASLIMIT` with an argument `g >= 2^63-1` is equivalent to `ACCEPT`.
**Category:** App Gas (app\_gas)
```fift title="Fift" SETGASLIMIT ``` #### `F807` GASCONSUMED [#f807-gasconsumed] Returns gas consumed by VM so far (including this instruction).
**Category:** App Gas (app\_gas)
```fift title="Fift" GASCONSUMED ``` #### `F80F` COMMIT [#f80f-commit] Commits the current state of registers `c4` (''persistent data'') and `c5` (''actions'') so that the current execution is considered ''successful'' with the saved values even if an exception is thrown later.
**Category:** App Gas (app\_gas)
```fift title="Fift" COMMIT ``` #### `F810` RANDU256 [#f810-randu256] Generates a new pseudo-random unsigned 256-bit *Integer* `x`. The algorithm is as follows: if `r` is the old value of the random seed, considered as a 32-byte array (by constructing the big-endian representation of an unsigned 256-bit integer), then its `sha512(r)` is computed; the first 32 bytes of this hash are stored as the new value `r'` of the random seed, and the remaining 32 bytes are returned as the next random value `x`.
**Category:** App Rnd (app\_rnd)
```fift title="Fift" RANDU256 ``` #### `F811` RAND [#f811-rand] Generates a new pseudo-random integer `z` in the range `0...y-1` (or `y...-1`, if `y<0`). More precisely, an unsigned random value `x` is generated as in `RAND256U`; then `z:=floor(x*y/2^256)` is computed.
Equivalent to `RANDU256` `256 MULRSHIFT`.
**Category:** App Rnd (app\_rnd)
```fift title="Fift" RAND ``` #### `F814` SETRAND [#f814-setrand] Sets the random seed to unsigned 256-bit *Integer* `x`.
**Category:** App Rnd (app\_rnd)
```fift title="Fift" SETRAND ``` #### `F815` ADDRAND [#f815-addrand] Mixes unsigned 256-bit *Integer* `x` into the random seed `r` by setting the random seed to `Sha` of the concatenation of two 32-byte strings: the first with the big-endian representation of the old seed `r`, and the second with the big-endian representation of `x`.
**Category:** App Rnd (app\_rnd)
```fift title="Fift" ADDRAND RANDOMIZE ``` #### `F82i` GETPARAM [#f82i-getparam] Returns the `i`-th parameter from the *Tuple* provided at `c7` for `0 <= i <= 15`. Equivalent to `c7 PUSHCTR` `FIRST` `[i] INDEX`.
If one of these internal operations fails, throws an appropriate type checking or range checking exception.
**Category:** App Config (app\_config)
```fift title="Fift" [i] GETPARAM ``` **Aliases**: * `NOW`
Returns the current Unix time as an *Integer*. If it is impossible to recover the requested value starting from `c7`, throws a type checking or range checking exception as appropriate.
Equivalent to `3 GETPARAM`. * `BLOCKLT`
Returns the starting logical time of the current block.
Equivalent to `4 GETPARAM`. * `LTIME`
Returns the logical time of the current transaction.
Equivalent to `5 GETPARAM`. * `RANDSEED`
Returns the current random seed as an unsigned 256-bit *Integer*.
Equivalent to `6 GETPARAM`. * `BALANCE`
Returns the remaining balance of the smart contract as a *Tuple* consisting of an *Integer* (the remaining Gram balance in nanograms) and a *Maybe Cell* (a dictionary with 32-bit keys representing the balance of ''extra currencies'').
Equivalent to `7 GETPARAM`.
Note that `RAW` primitives such as `SENDRAWMSG` do not update this field. * `MYADDR`
Returns the internal address of the current smart contract as a *Slice* with a `MsgAddressInt`. If necessary, it can be parsed further using primitives such as `PARSEMSGADDR` or `REWRITESTDADDR`.
Equivalent to `8 GETPARAM`. * `CONFIGROOT`
Returns the *Maybe Cell* `D` with the current global configuration dictionary. Equivalent to `9 GETPARAM `. * `MYCODE`
Retrieves code of smart-contract from c7. Equivalent to `10 GETPARAM `. * `INCOMINGVALUE`
Retrieves value of incoming message from c7. Equivalent to `11 GETPARAM `. * `STORAGEFEES`
Retrieves value of storage phase fees from c7. Equivalent to `12 GETPARAM `. * `PREVBLOCKSINFOTUPLE`
Retrives PrevBlocksInfo: `[last_mc_blocks, prev_key_block]` from c7. Equivalent to `13 GETPARAM `. * `UNPACKEDCONFIGTUPLE`
Retrives tuple that contains some config parameters as cell slices. If the parameter is absent from the config, the value is null. Values:
\* **0**: `StoragePrices` from `ConfigParam 18`. Not the whole dict, but only the one StoragePrices entry (one which corresponds to the current time).
\* **1**: `ConfigParam 19` (global id).
\* **2**: `ConfigParam 20` (mc gas prices).
\* **3**: `ConfigParam 21` (gas prices).
\* **4**: `ConfigParam 24` (mc fwd fees).
\* **5**: `ConfigParam 25` (fwd fees).
\* **6**: `ConfigParam 43` (size limits). * `DUEPAYMENT`
Retrives current debt for storage fee (nanograms). #### `F830` CONFIGDICT [#f830-configdict] Returns the global configuration dictionary along with its key length (32).
Equivalent to `CONFIGROOT` `32 PUSHINT`.
**Category:** App Config (app\_config)
```fift title="Fift" CONFIGDICT ``` #### `F832` CONFIGPARAM [#f832-configparam] Returns the value of the global configuration parameter with integer index `i` as a *Cell* `c`, and a flag to indicate success.
Equivalent to `CONFIGDICT` `DICTIGETREF`.
**Category:** App Config (app\_config)
```fift title="Fift" CONFIGPARAM ``` #### `F833` CONFIGOPTPARAM [#f833-configoptparam] Returns the value of the global configuration parameter with integer index `i` as a *Maybe Cell* `c^?`.
Equivalent to `CONFIGDICT` `DICTIGETOPTREF`.
**Category:** App Config (app\_config)
```fift title="Fift" CONFIGOPTPARAM ``` #### `F83400` PREVMCBLOCKS [#f83400-prevmcblocks] Retrives `last_mc_blocks` part of PrevBlocksInfo from c7 (parameter 13).
**Category:** App Config (app\_config)
```fift title="Fift" PREVMCBLOCKS ``` #### `F83401` PREVKEYBLOCK [#f83401-prevkeyblock] Retrives `prev_key_block` part of PrevBlocksInfo from c7 (parameter 13).
**Category:** App Config (app\_config)
```fift title="Fift" PREVKEYBLOCK ``` #### `F83402` PREVMCBLOCKS\_100 [#f83402-prevmcblocks_100] Retrives `last_mc_blocks_divisible_by_100` part of PrevBlocksInfo from c7 (parameter 13).
**Category:** App Config (app\_config)
```fift title="Fift" PREVMCBLOCKS_100 ``` #### `F835` GLOBALID [#f835-globalid] Retrieves `global_id` from 19 network config.
**Category:** App Config (app\_config)
```fift title="Fift" GLOBALID ``` #### `F836` GETGASFEE [#f836-getgasfee] Calculates gas fee
**Category:** App Config (app\_config)
```fift title="Fift" GETGASFEE ``` #### `F837` GETSTORAGEFEE [#f837-getstoragefee] Calculates storage fees (only current StoragePrices entry is used).
**Category:** App Config (app\_config)
```fift title="Fift" GETSTORAGEFEE ``` #### `F838` GETFORWARDFEE [#f838-getforwardfee] Calculates forward fee.
**Category:** App Config (app\_config)
```fift title="Fift" GETFORWARDFEE ``` #### `F839` GETPRECOMPILEDGAS [#f839-getprecompiledgas] Returns gas usage for the current contract if it is precompiled, `null` otherwise.
**Category:** App Config (app\_config)
```fift title="Fift" GETPRECOMPILEDGAS ``` #### `F83A` GETORIGINALFWDFEE [#f83a-getoriginalfwdfee] Calculate `(fwd_fee * 2^16) / (2^16 - first_frac)`. Can be used to get the original `fwd_fee` of the message.
**Category:** App Config (app\_config)
```fift title="Fift" GETORIGINALFWDFEE ``` #### `F83B` GETGASFEESIMPLE [#f83b-getgasfeesimple] Same as `GETGASFEE`, but without flat price (just `(gas_used * price) / 2^16)`.
**Category:** App Config (app\_config)
```fift title="Fift" GETGASFEESIMPLE ``` #### `F83C` GETFORWARDFEESIMPLE [#f83c-getforwardfeesimple] Same as `GETFORWARDFEE`, but without lump price (just (`bits*bit_price + cells*cell_price) / 2^16`).
**Category:** App Config (app\_config)
```fift title="Fift" GETFORWARDFEESIMPLE ``` #### `F840` GETGLOBVAR [#f840-getglobvar] Returns the `k`-th global variable for `0 <= k < 255`.
Equivalent to `c7 PUSHCTR` `SWAP` `INDEXVARQ`.
**Category:** App Global (app\_global)
```fift title="Fift" GETGLOBVAR ``` #### `F85_k` GETGLOB [#f85_k-getglob] Returns the `k`-th global variable for `1 <= k <= 31`.
Equivalent to `c7 PUSHCTR` `[k] INDEXQ`.
**Category:** App Global (app\_global)
```fift title="Fift" [k] GETGLOB ``` #### `F860` SETGLOBVAR [#f860-setglobvar] Assigns `x` to the `k`-th global variable for `0 <= k < 255`.
Equivalent to `c7 PUSHCTR` `ROTREV` `SETINDEXVARQ` `c7 POPCTR`.
**Category:** App Global (app\_global)
```fift title="Fift" SETGLOBVAR ``` #### `F87_k` SETGLOB [#f87_k-setglob] Assigns `x` to the `k`-th global variable for `1 <= k <= 31`.
Equivalent to `c7 PUSHCTR` `SWAP` `k SETINDEXQ` `c7 POPCTR`.
**Category:** App Global (app\_global)
```fift title="Fift" [k] SETGLOB ``` #### `F880` GETEXTRABALANCE [#f880-getextrabalance] Takes id of the extra currency (integer in range `0..2^32-1`), returns the amount of this extra currency on the account balance. The first `5` executions of `GETEXTRABALANCE` consume at most `26 + 200` gas each. The subsequent executions incur the full gas cost of `26` (normal instruction cost) plus gas for loading cells (up to `3300` if the dictionary has maximum depth).
**Category:** App Global (app\_global)
```fift title="Fift" GETEXTRABALANCE ``` #### `F881ii` GETPARAMLONG [#f881ii-getparamlong] Returns the `i`-th parameter from the *Tuple* provided at `c7` for `0 <= i <= 255`. Equivalent to `c7 PUSHCTR` `FIRST` `[i] INDEX`.
If one of these internal operations fails, throws an appropriate type checking or range checking exception.
**Category:** App Config (app\_config)
```fift title="Fift" [i] GETPARAMLONG ``` #### `F89i` INMSGPARAM [#f89i-inmsgparam] Equivalent to `INMSGPARAMS` `i INDEX`
**Category:** App Config (app\_config)
```fift title="Fift" [i] INMSGPARAM ``` **Aliases**: * `INMSG_BOUNCE`
Retrives `bounce` flag of incoming message. * `INMSG_BOUNCED`
Retrives `bounced` flag of incoming message. * `INMSG_SRC`
Retrives `src` flag of incoming message. * `INMSG_FWDFEE`
Retrives `fwd_fee` field of incoming message. * `INMSG_LT`
Retrives `lt` field of incoming message. * `INMSG_UTIME`
Retrives `utime` field of incoming message. * `INMSG_ORIGVALUE`
Retrives original value of the message. This is sometimes different from the value in `INCOMINGVALUE` and TVM stack because of storage fees. * `INMSG_VALUE`
Retrives value of the message after deducting storage fees. This is same as in `INCOMINGVALUE` and TVM stack. * `INMSG_VALUEEXTRA`
Same as in `INCOMINGVALUE`. * `INMSG_STATEINIT`
Retrieves `init` field of the incoming message. #### `F900` HASHCU [#f900-hashcu] Computes the representation hash of a *Cell* `c` and returns it as a 256-bit unsigned integer `x`. Useful for signing and checking signatures of arbitrary entities represented by a tree of cells.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHCU ``` #### `F901` HASHSU [#f901-hashsu] Computes the hash of a *Slice* `s` and returns it as a 256-bit unsigned integer `x`. The result is the same as if an ordinary cell containing only data and references from `s` had been created and its hash computed by `HASHCU`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHSU ``` #### `F902` SHA256U [#f902-sha256u] Computes `Sha` of the data bits of *Slice* `s`. If the bit length of `s` is not divisible by eight, throws a cell underflow exception. The hash value is returned as a 256-bit unsigned integer `x`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" SHA256U ``` #### `F90400` HASHEXT\_SHA256 [#f90400-hashext_sha256] Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXT_SHA256 ``` #### `F90401` HASHEXT\_SHA512 [#f90401-hashext_sha512] Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXT_SHA512 ``` #### `F90402` HASHEXT\_BLAKE2B [#f90402-hashext_blake2b] Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXT_BLAKE2B ``` #### `F90403` HASHEXT\_KECCAK256 [#f90403-hashext_keccak256] Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXT_KECCAK256 ``` #### `F90404` HASHEXT\_KECCAK512 [#f90404-hashext_keccak512] Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXT_KECCAK512 ``` #### `F90500` HASHEXTR\_SHA256 [#f90500-hashextr_sha256] Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXTR_SHA256 ``` #### `F90501` HASHEXTR\_SHA512 [#f90501-hashextr_sha512] Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXTR_SHA512 ``` #### `F90502` HASHEXTR\_BLAKE2B [#f90502-hashextr_blake2b] Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXTR_BLAKE2B ``` #### `F90503` HASHEXTR\_KECCAK256 [#f90503-hashextr_keccak256] Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXTR_KECCAK256 ``` #### `F90504` HASHEXTR\_KECCAK512 [#f90504-hashextr_keccak512] Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXTR_KECCAK512 ``` #### `F90600` HASHEXTA\_SHA256 [#f90600-hashexta_sha256] Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXTA_SHA256 ``` #### `F90601` HASHEXTA\_SHA512 [#f90601-hashexta_sha512] Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXTA_SHA512 ``` #### `F90602` HASHEXTA\_BLAKE2B [#f90602-hashexta_blake2b] Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXTA_BLAKE2B ``` #### `F90603` HASHEXTA\_KECCAK256 [#f90603-hashexta_keccak256] Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXTA_KECCAK256 ``` #### `F90604` HASHEXTA\_KECCAK512 [#f90604-hashexta_keccak512] Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXTA_KECCAK512 ``` #### `F90700` HASHEXTAR\_SHA256 [#f90700-hashextar_sha256] Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXTAR_SHA256 ``` #### `F90701` HASHEXTAR\_SHA512 [#f90701-hashextar_sha512] Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXTAR_SHA512 ``` #### `F90702` HASHEXTAR\_BLAKE2B [#f90702-hashextar_blake2b] Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXTAR_BLAKE2B ``` #### `F90703` HASHEXTAR\_KECCAK256 [#f90703-hashextar_keccak256] Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXTAR_KECCAK256 ``` #### `F90704` HASHEXTAR\_KECCAK512 [#f90704-hashextar_keccak512] Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXTAR_KECCAK512 ``` #### `F910` CHKSIGNU [#f910-chksignu] Checks the Ed25519-signature `s` of a hash `h` (a 256-bit unsigned integer, usually computed as the hash of some data) using public key `k` (also represented by a 256-bit unsigned integer).
The signature `s` must be a *Slice* containing at least 512 data bits; only the first 512 bits are used. The result is `-1` if the signature is valid, `0` otherwise.
Notice that `CHKSIGNU` is equivalent to `ROT` `NEWC` `256 STU` `ENDC` `ROTREV` `CHKSIGNS`, i.e., to `CHKSIGNS` with the first argument `d` set to 256-bit *Slice* containing `h`. Therefore, if `h` is computed as the hash of some data, these data are hashed *twice*, the second hashing occurring inside `CHKSIGNS`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" CHKSIGNU ``` #### `F911` CHKSIGNS [#f911-chksigns] Checks whether `s` is a valid Ed25519-signature of the data portion of *Slice* `d` using public key `k`, similarly to `CHKSIGNU`. If the bit length of *Slice* `d` is not divisible by eight, throws a cell underflow exception. The verification of Ed25519 signatures is the standard one, with `Sha` used to reduce `d` to the 256-bit number that is actually signed.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" CHKSIGNS ``` #### `F912` ECRECOVER [#f912-ecrecover] Recovers the public key from a secp256k1 signature, identical to Bitcoin/Ethereum operations. Takes a 32-byte hash as `uint256 hash` and a 65-byte signature as `uint8 v`, `uint256 r`, and `uint256 s`. In TON, the `v` value is strictly 0 or 1; no extra flags or extended values are supported. If the public key cannot be recovered, the instruction returns `0`. On success, it returns the recovered 65-byte public key as `uint8 h`, `uint256 x1`, and `uint256 x2`, followed by `-1`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" ECRECOVER ``` #### `F913` SECP256K1\_XONLY\_PUBKEY\_TWEAK\_ADD [#f913-secp256k1_xonly_pubkey_tweak_add] performs [`secp256k1_xonly_pubkey_tweak_add`](https://github.com/bitcoin-core/secp256k1/blob/master/include/secp256k1_extrakeys.h#L120). `key` and `tweak` are 256-bit unsigned integers. 65-byte public key is returned as `uint8 f`, `uint256 x, y` (as in `ECRECOVER`).
**Category:** App Crypto (app\_crypto)
```fift title="Fift" SECP256K1_XONLY_PUBKEY_TWEAK_ADD ``` #### `F914` P256\_CHKSIGNU [#f914-p256_chksignu] Checks seck256r1-signature `sig` of a number `h` (a 256-bit unsigned integer, usually computed as the hash of some data) and public key `k`. Returns -1 on success, 0 on failure. Public key is a 33-byte slice (encoded according to Sec. 2.3.4 point 2 of [SECG SEC 1](https://www.secg.org/sec1-v2.pdf)). Signature `sig` is a 64-byte slice (two 256-bit unsigned integers `r` and `s`).
**Category:** App Crypto (app\_crypto)
```fift title="Fift" P256_CHKSIGNU ``` #### `F915` P256\_CHKSIGNS [#f915-p256_chksigns] Checks seck256r1-signature `sig` of data portion of slice `d` and public key `k`. Returns -1 on success, 0 on failure. Public key is a 33-byte slice (encoded according to Sec. 2.3.4 point 2 of [SECG SEC 1](https://www.secg.org/sec1-v2.pdf)). Signature `sig` is a 64-byte slice (two 256-bit unsigned integers `r` and `s`).
**Category:** App Crypto (app\_crypto)
```fift title="Fift" P256_CHKSIGNS ``` #### `F916` HASHBU [#f916-hashbu] Same as `ENDC HASHCU`, but without gas cost for cell creation.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHBU ``` #### `F920` RIST255\_FROMHASH [#f920-rist255_fromhash] Deterministically generates a valid point `x` from a 512-bit hash (given as two 256-bit integers).
**Category:** App Crypto (app\_crypto)
```fift title="Fift" RIST255_FROMHASH ``` #### `F921` RIST255\_VALIDATE [#f921-rist255_validate] Checks that integer `x` is a valid representation of some curve point. Throws range\_chk on error.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" RIST255_VALIDATE ``` #### `F922` RIST255\_ADD [#f922-rist255_add] Addition of two points on a curve.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" RIST255_ADD ``` #### `F923` RIST255\_SUB [#f923-rist255_sub] Subtraction of two points on curve.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" RIST255_SUB ``` #### `F924` RIST255\_MUL [#f924-rist255_mul] Multiplies point `x` by a scalar `n`. Any `n` is valid, including negative.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" RIST255_MUL ``` #### `F925` RIST255\_MULBASE [#f925-rist255_mulbase] Multiplies the generator point `g` by a scalar `n`. Any `n` is valid, including negative.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" RIST255_MULBASE ``` #### `F926` RIST255\_PUSHL [#f926-rist255_pushl] Pushes integer l=2^252+27742317777372353535851937790883648493, which is the order of the group.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" RIST255_PUSHL ``` #### `B7F921` RIST255\_QVALIDATE [#b7f921-rist255_qvalidate] Checks that integer `x` is a valid representation of some curve point. Returns -1 on success and 0 on failure.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" RIST255_QVALIDATE ``` #### `B7F922` RIST255\_QADD [#b7f922-rist255_qadd] Addition of two points on a curve. Returns -1 on success and 0 on failure.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" RIST255_QADD ``` #### `B7F923` RIST255\_QSUB [#b7f923-rist255_qsub] Subtraction of two points on curve. Returns -1 on success and 0 on failure.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" RIST255_QSUB ``` #### `B7F924` RIST255\_QMUL [#b7f924-rist255_qmul] Multiplies point `x` by a scalar `n`. Any `n` is valid, including negative. Returns -1 on success and 0 on failure.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" RIST255_QMUL ``` #### `B7F925` RIST255\_QMULBASE [#b7f925-rist255_qmulbase] Multiplies the generator point `g` by a scalar `n`. Any `n` is valid, including negative.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" RIST255_QMULBASE ``` #### `F93000` BLS\_VERIFY [#f93000-bls_verify] Checks BLS signature, return true on success, false otherwise.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_VERIFY ``` #### `F93001` BLS\_AGGREGATE [#f93001-bls_aggregate] Aggregates signatures. `n>0`. Throw exception if `n=0` or if some `sig_i` is not a valid signature.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_AGGREGATE ``` #### `F93002` BLS\_FASTAGGREGATEVERIFY [#f93002-bls_fastaggregateverify] Checks aggregated BLS signature for keys `pk_1...pk_n` and message `msg`. Return true on success, false otherwise. Return false if `n=0`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_FASTAGGREGATEVERIFY ``` #### `F93003` BLS\_AGGREGATEVERIFY [#f93003-bls_aggregateverify] Checks aggregated BLS signature for key-message pairs `pk_1 msg_1...pk_n msg_n`. Return true on success, false otherwise. Return false if `n=0`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_AGGREGATEVERIFY ``` #### `F93010` BLS\_G1\_ADD [#f93010-bls_g1_add] Addition on G1.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G1_ADD ``` #### `F93011` BLS\_G1\_SUB [#f93011-bls_g1_sub] Subtraction on G1.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G1_SUB ``` #### `F93012` BLS\_G1\_NEG [#f93012-bls_g1_neg] Negation on G1.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G1_NEG ``` #### `F93013` BLS\_G1\_MUL [#f93013-bls_g1_mul] Multiplies G1 point `x` by scalar `s`. Any `s` is valid, including negative.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G1_MUL ``` #### `F93014` BLS\_G1\_MULTIEXP [#f93014-bls_g1_multiexp] Calculates `x_1*s_1+...+x_n*s_n` for G1 points `x_i` and scalars `s_i`. Returns zero point if `n=0`. Any `s_i` is valid, including negative.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G1_MULTIEXP ``` #### `F93015` BLS\_G1\_ZERO [#f93015-bls_g1_zero] Pushes zero point in G1.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G1_ZERO ``` #### `F93016` BLS\_MAP\_TO\_G1 [#f93016-bls_map_to_g1] Converts FP element `f` to a G1 point.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_MAP_TO_G1 ``` #### `F93017` BLS\_G1\_INGROUP [#f93017-bls_g1_ingroup] Checks that slice `x` represents a valid element of G1.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G1_INGROUP ``` #### `F93018` BLS\_G1\_ISZERO [#f93018-bls_g1_iszero] Checks that G1 point `x` is equal to zero.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G1_ISZERO ``` #### `F93020` BLS\_G2\_ADD [#f93020-bls_g2_add] Addition on G2.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G2_ADD ``` #### `F93021` BLS\_G2\_SUB [#f93021-bls_g2_sub] Subtraction on G2.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G2_SUB ``` #### `F93022` BLS\_G2\_NEG [#f93022-bls_g2_neg] Negation on G2.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G2_NEG ``` #### `F93023` BLS\_G2\_MUL [#f93023-bls_g2_mul] Multiplies G2 point `x` by scalar `s`. Any `s` is valid, including negative.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G2_MUL ``` #### `F93024` BLS\_G2\_MULTIEXP [#f93024-bls_g2_multiexp] Calculates `x_1*s_1+...+x_n*s_n` for G2 points `x_i` and scalars `s_i`. Returns zero point if `n=0`. Any `s_i` is valid, including negative.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G2_MULTIEXP ``` #### `F93025` BLS\_G2\_ZERO [#f93025-bls_g2_zero] Pushes zero point in G2.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G2_ZERO ``` #### `F93026` BLS\_MAP\_TO\_G2 [#f93026-bls_map_to_g2] Converts FP2 element `f` to a G2 point.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_MAP_TO_G2 ``` #### `F93027` BLS\_G2\_INGROUP [#f93027-bls_g2_ingroup] Checks that slice `x` represents a valid element of G2.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G2_INGROUP ``` #### `F93028` BLS\_G2\_ISZERO [#f93028-bls_g2_iszero] Checks that G2 point `x` is equal to zero.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G2_ISZERO ``` #### `F93030` BLS\_PAIRING [#f93030-bls_pairing] Given G1 points `x_i` and G2 points `y_i`, calculates and multiply pairings of `x_i,y_i`. Returns true if the result is the multiplicative identity in FP12, false otherwise. Returns false if `n=0`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_PAIRING ``` #### `F93031` BLS\_PUSHR [#f93031-bls_pushr] Pushes the order of G1 and G2 (approx. `2^255`).
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_PUSHR ``` #### `F940` CDATASIZEQ [#f940-cdatasizeq] Recursively computes the count of distinct cells `x`, data bits `y`, and cell references `z` in the dag rooted at *Cell* `c`, effectively returning the total storage used by this dag taking into account the identification of equal cells. The values of `x`, `y`, and `z` are computed by a depth-first traversal of this dag, with a hash table of visited cell hashes used to prevent visits of already-visited cells. The total count of visited cells `x` cannot exceed non-negative *Integer* `n`; otherwise the computation is aborted before visiting the `(n+1)`-st cell and a zero is returned to indicate failure. If `c` is *Null*, returns `x=y=z=0`.
**Category:** App Misc (app\_misc)
```fift title="Fift" CDATASIZEQ ``` #### `F941` CDATASIZE [#f941-cdatasize] A non-quiet version of `CDATASIZEQ` that throws a cell overflow exception (8) on failure.
**Category:** App Misc (app\_misc)
```fift title="Fift" CDATASIZE ``` #### `F942` SDATASIZEQ [#f942-sdatasizeq] Similar to `CDATASIZEQ`, but accepting a *Slice* `s` instead of a *Cell*. The returned value of `x` does not take into account the cell that contains the slice `s` itself; however, the data bits and the cell references of `s` are accounted for in `y` and `z`.
**Category:** App Misc (app\_misc)
```fift title="Fift" SDATASIZEQ ``` #### `F943` SDATASIZE [#f943-sdatasize] A non-quiet version of `SDATASIZEQ` that throws a cell overflow exception (8) on failure.
**Category:** App Misc (app\_misc)
```fift title="Fift" SDATASIZE ``` #### `FA00` LDGRAMS [#fa00-ldgrams] Loads (deserializes) a `Gram` or `VarUInteger 16` amount from *Slice* `s`, and returns the amount as *Integer* `x` along with the remainder `s'` of `s`. The expected serialization of `x` consists of a 4-bit unsigned big-endian integer `l`, followed by an `8l`-bit unsigned big-endian representation of `x`.
The net effect is approximately equivalent to `4 LDU` `SWAP` `3 LSHIFT#` `LDUX`.
**Category:** App Currency (app\_currency)
```fift title="Fift" LDGRAMS LDVARUINT16 ``` #### `FA01` LDVARINT16 [#fa01-ldvarint16] Similar to `LDVARUINT16`, but loads a *signed* *Integer* `x`.
Approximately equivalent to `4 LDU` `SWAP` `3 LSHIFT#` `LDIX`.
**Category:** App Currency (app\_currency)
```fift title="Fift" LDVARINT16 ``` #### `FA02` STGRAMS [#fa02-stgrams] Stores (serializes) an *Integer* `x` in the range `0...2^120-1` into *Builder* `b`, and returns the resulting *Builder* `b'`. The serialization of `x` consists of a 4-bit unsigned big-endian integer `l`, which is the smallest integer `l>=0`, such that `x<2^(8l)`, followed by an `8l`-bit unsigned big-endian representation of `x`. If `x` does not belong to the supported range, a range check exception is thrown.
**Category:** App Currency (app\_currency)
```fift title="Fift" STGRAMS STVARUINT16 ``` #### `FA03` STVARINT16 [#fa03-stvarint16] Similar to `STVARUINT16`, but serializes a *signed* *Integer* `x` in the range `-2^119...2^119-1`.
**Category:** App Currency (app\_currency)
```fift title="Fift" STVARINT16 ``` #### `FA04` LDVARUINT32 [#fa04-ldvaruint32] Loads (deserializes) a `VarUInteger 32` amount from *Slice* `s`, and returns the amount as *Integer* `x` along with the remainder `s'` of `s`. The expected serialization of `x` consists of a 5-bit unsigned big-endian integer `l`, followed by an `8l`-bit unsigned big-endian representation of `x`.
The net effect is approximately equivalent to `4 LDU` `SWAP` `3 LSHIFT#` `LDUX`.
**Category:** App Currency (app\_currency)
```fift title="Fift" LDVARUINT32 ``` #### `FA05` LDVARINT32 [#fa05-ldvarint32] Similar to `LDVARUINT32`, but loads a *signed* *Integer* `x`.
Approximately equivalent to `5 LDU` `SWAP` `3 LSHIFT#` `LDIX`.
**Category:** App Currency (app\_currency)
```fift title="Fift" LDVARINT32 ``` #### `FA06` STVARUINT32 [#fa06-stvaruint32] Stores (serializes) an *Integer* `x` in the range `0...2^248-1` into *Builder* `b`, and returns the resulting *Builder* `b'`. The serialization of `x` consists of a 5-bit unsigned big-endian integer `l`, which is the smallest integer `l>=0`, such that `x<2^(8l)`, followed by an `8l`-bit unsigned big-endian representation of `x`. If `x` does not belong to the supported range, a range check exception is thrown.
**Category:** App Currency (app\_currency)
```fift title="Fift" STVARUINT32 ``` #### `FA07` STVARINT32 [#fa07-stvarint32] Similar to `STVARUINT32`, but serializes a *signed* *Integer* `x` in the range `-2^247...2^247-1`.
**Category:** App Currency (app\_currency)
```fift title="Fift" STVARINT32 ``` #### `FA40` LDMSGADDR [#fa40-ldmsgaddr] Loads from *Slice* `s` the only prefix that is a valid `MsgAddress`, and returns both this prefix `s'` and the remainder `s''` of `s` as slices.
**Category:** App Addr (app\_addr)
```fift title="Fift" LDMSGADDR ``` #### `FA41` LDMSGADDRQ [#fa41-ldmsgaddrq] A quiet version of `LDMSGADDR`: on success, pushes an extra `-1`; on failure, pushes the original `s` and a zero.
**Category:** App Addr (app\_addr)
```fift title="Fift" LDMSGADDRQ ``` #### `FA42` PARSEMSGADDR [#fa42-parsemsgaddr] Decomposes *Slice* `s` containing a valid `MsgAddress` into a *Tuple* `t` with separate fields of this `MsgAddress`. If `s` is not a valid `MsgAddress`, a cell deserialization exception is thrown.
**Category:** App Addr (app\_addr)
```fift title="Fift" PARSEMSGADDR ``` #### `FA43` PARSEMSGADDRQ [#fa43-parsemsgaddrq] A quiet version of `PARSEMSGADDR`: returns a zero on error instead of throwing an exception.
**Category:** App Addr (app\_addr)
```fift title="Fift" PARSEMSGADDRQ ``` #### `FA44` REWRITESTDADDR [#fa44-rewritestdaddr] Parses *Slice* `s` containing a valid `MsgAddressInt` (usually a `msg_addr_std`), applies rewriting from the `anycast` (if present) to the same-length prefix of the address, and returns both the workchain `x` and the 256-bit address `y` as integers. If the address is not 256-bit, or if `s` is not a valid serialization of `MsgAddressInt`, throws a cell deserialization exception.
**Category:** App Addr (app\_addr)
```fift title="Fift" REWRITESTDADDR ``` #### `FA45` REWRITESTDADDRQ [#fa45-rewritestdaddrq] A quiet version of primitive `REWRITESTDADDR`.
**Category:** App Addr (app\_addr)
```fift title="Fift" REWRITESTDADDRQ ``` #### `FA46` REWRITEVARADDR [#fa46-rewritevaraddr] `msg_addr_var` not allowed since TVM v10, so it behaves like `REWRITESTDADDR`, but returns account id in `Slice`, not `Integer`: parses address `s` into workchain `x` and account id `s`.
**Category:** App Addr (app\_addr)
```fift title="Fift" REWRITEVARADDR ``` #### `FA47` REWRITEVARADDRQ [#fa47-rewritevaraddrq] A quiet version of primitive `REWRITEVARADDR`.
**Category:** App Addr (app\_addr)
```fift title="Fift" REWRITEVARADDRQ ``` #### `FA48` LDSTDADDR [#fa48-ldstdaddr] Loads `addr_std$10`, if address is not `addr_std`, throws an error 9 (`cannot load a MsgAddressInt`).
**Category:** App Addr (app\_addr)
```fift title="Fift" LDSTDADDR ``` #### `FA49` LDSTDADDRQ [#fa49-ldstdaddrq] A quiet version of primitive `LDSTDADDR`.
**Category:** App Addr (app\_addr)
```fift title="Fift" LDSTDADDRQ ``` #### `FA50` LDOPTSTDADDR [#fa50-ldoptstdaddr] Loads `addr_std$10` or `addr_none$00`, if address is `addr_none$00` pushes a Null, if address is not `addr_std` or `addr_none`, throws an error 9 (`cannot load a MsgAddressInt`).
**Category:** App Addr (app\_addr)
```fift title="Fift" LDOPTSTDADDR ``` #### `FA51` LDOPTSTDADDRQ [#fa51-ldoptstdaddrq] A quiet version of primitive `LDOPTSTDADDR`.
**Category:** App Addr (app\_addr)
```fift title="Fift" LDOPTSTDADDRQ ``` #### `FA52` STSTDADDR [#fa52-ststdaddr] Stores `addr_std$10`, if address is not `addr_std`, throws an error 9 (`cannot load a MsgAddressInt`).
**Category:** App Addr (app\_addr)
```fift title="Fift" STSTDADDR ``` #### `FA53` STSTDADDRQ [#fa53-ststdaddrq] A quiet version of primitive `STSTDADDR`.
**Category:** App Addr (app\_addr)
```fift title="Fift" STSTDADDRQ ``` #### `FA54` STOPTSTDADDR [#fa54-stoptstdaddr] stores `addr_std$10` or Null. Null is stored as `addr_none$00`, if address is not `addr_std`, throws an error 9 (`cannot load a MsgAddressInt`).
**Category:** App Addr (app\_addr)
```fift title="Fift" STOPTSTDADDR ``` #### `FA55` STOPTSTDADDRQ [#fa55-stoptstdaddrq] A quiet version of primitive `STOPTSTDADDR`.
**Category:** App Addr (app\_addr)
```fift title="Fift" STOPTSTDADDRQ ``` #### `FB00` SENDRAWMSG [#fb00-sendrawmsg] Sends a raw message contained in *Cell `c`*, which should contain a correctly serialized object `Message X`, with the only exception that the source address is allowed to have dummy value `addr_none` (to be automatically replaced with the current smart-contract address), and `ihr_fee`, `fwd_fee`, `created_lt` and `created_at` fields can have arbitrary values (to be rewritten with correct values during the action phase of the current transaction). Integer parameter `x` contains the flags. Currently `x=0` is used for ordinary messages; `x=128` is used for messages that are to carry all the remaining balance of the current smart contract (instead of the value originally indicated in the message); `x=64` is used for messages that carry all the remaining value of the inbound message in addition to the value initially indicated in the new message (if bit 0 is not set, the gas fees are deducted from this amount); `x'=x+1` means that the sender wants to pay transfer fees separately; `x'=x+2` means that any errors arising while processing this message during the action phase should be ignored. Finally, `x'=x+32` means that the current account must be destroyed if its resulting balance is zero. This flag is usually employed together with `+128`.
**Category:** App Actions (app\_actions)
```fift title="Fift" SENDRAWMSG ``` #### `FB02` RAWRESERVE [#fb02-rawreserve] Creates an output action which would reserve exactly `x` nanograms (if `y=0`), at most `x` nanograms (if `y=2`), or all but `x` nanograms (if `y=1` or `y=3`), from the remaining balance of the account. It is roughly equivalent to creating an outbound message carrying `x` nanograms (or `b-x` nanograms, where `b` is the remaining balance) to oneself, so that the subsequent output actions would not be able to spend more money than the remainder. Bit `+2` in `y` means that the external action does not fail if the specified amount cannot be reserved; instead, all remaining balance is reserved. Bit `+8` in `y` means `x:=-x` before performing any further actions. Bit `+4` in `y` means that `x` is increased by the original balance of the current account (before the compute phase), including all extra currencies, before performing any other checks and actions. Currently `x` must be a non-negative integer, and `y` must be in the range `0...15`.
**Category:** App Actions (app\_actions)
```fift title="Fift" RAWRESERVE ``` #### `FB03` RAWRESERVEX [#fb03-rawreservex] Similar to `RAWRESERVE`, but also accepts a dictionary `D` (represented by a *Cell* or *Null*) with extra currencies. In this way currencies other than Grams can be reserved.
**Category:** App Actions (app\_actions)
```fift title="Fift" RAWRESERVEX ``` #### `FB04` SETCODE [#fb04-setcode] Creates an output action that would change this smart contract code to that given by *Cell* `c`. Notice that this change will take effect only after the successful termination of the current run of the smart contract.
**Category:** App Actions (app\_actions)
```fift title="Fift" SETCODE ``` #### `FB06` SETLIBCODE [#fb06-setlibcode] Creates an output action that would modify the collection of this smart contract libraries by adding or removing library with code given in *Cell* `c`. If `x=0`, the library is actually removed if it was previously present in the collection (if not, this action does nothing). If `x=1`, the library is added as a private library, and if `x=2`, the library is added as a public library (and becomes available to all smart contracts if the current smart contract resides in the masterchain); if the library was present in the collection before, its public/private status is changed according to `x`. Values of `x` other than `0...2` are invalid.
**Category:** App Actions (app\_actions)
```fift title="Fift" SETLIBCODE ``` #### `FB07` CHANGELIB [#fb07-changelib] Creates an output action similarly to `SETLIBCODE`, but instead of the library code accepts its hash as an unsigned 256-bit integer `h`. If `x!=0` and the library with hash `h` is absent from the library collection of this smart contract, this output action will fail.
**Category:** App Actions (app\_actions)
```fift title="Fift" CHANGELIB ``` #### `FB08` SENDMSG [#fb08-sendmsg] Creates an output action and returns a fee for creating a message. Mode has the same effect as in the case of `SENDRAWMSG`. Additionally `+1024` means - do not create an action, only estimate fee. Other modes affect the fee calculation as follows: `+64` substitutes the entire balance of the incoming message as an outcoming value (slightly inaccurate, gas expenses that cannot be estimated before the computation is completed are not taken into account), `+128` substitutes the value of the entire balance of the contract before the start of the computation phase (slightly inaccurate, since gas expenses that cannot be estimated before the completion of the computation phase are not taken into account).
**Category:** App Actions (app\_actions)
```fift title="Fift" SENDMSG ``` #### `FEij` DEBUG [#feij-debug]
**Category:** Debug (debug)
```fift title="Fift" {i*16+j} DEBUG ``` **Aliases**: * `DUMPSTK`
Dumps the stack (at most the top 255 values) and shows the total stack depth. Does nothing on production versions of TVM. * `STRDUMP`
Dumps slice with length divisible by 8 from top of stack as a string. Does nothing on production versions of TVM. * `DUMP`
Dumps slice with length divisible by 8 from top of stack as a string. Does nothing on production versions of TVM. #### `FEFnssss` DEBUGSTR [#fefnssss-debugstr] `0 <= n < 16`. Length of `ssss` is `n+1` bytes.
`{string}` is a [string literal](https://github.com/Piterden/TON-docs/blob/master/Fift.%20A%20Brief%20Introduction.md#user-content-29-string-literals).
`DEBUGSTR`: `ssss` is the given string.
`DEBUGSTRI`: `ssss` is one-byte integer `0 <= x <= 255` followed by the given string.
**Category:** Debug (debug)
```fift title="Fift" {string} DEBUGSTR {string} {x} DEBUGSTRI ``` #### `FFnn` SETCP [#ffnn-setcp] Selects TVM codepage `0 <= nn < 240`. If the codepage is not supported, throws an invalid opcode exception.
**Category:** Codepage (codepage)
```fift title="Fift" [nn] SETCP ``` **Aliases**: * `SETCP0`
Selects TVM (test) codepage zero as described in this document. #### `FFFz` SETCP\_SPECIAL [#fffz-setcp_special] Selects TVM codepage `z-16` for `1 <= z <= 15`. Negative codepages `-13...-1` are reserved for restricted versions of TVM needed to validate runs of TVM in other codepages. Negative codepage `-14` is reserved for experimental codepages, not necessarily compatible between different TVM implementations, and should be disabled in the production versions of TVM.
**Category:** Codepage (codepage)
```fift title="Fift" [z-16] SETCP ``` #### `FFF0` SETCPX [#fff0-setcpx] Selects codepage `c` with `-2^15 <= c < 2^15` passed in the top of the stack.
**Category:** Codepage (codepage)
```fift title="Fift" SETCPX ```
# TVM overview (https://docs.ton.org/llms/tvm/overview/content.md)
TON Virtual Machine (TVM) is a [stack-based](https://en.wikipedia.org/wiki/Stack_machine) virtual machine which executes smart contracts on TON blockchain.
TVM is invoked when a message is sent to an account that has deployed contract code, when a get method is called on an account, and in some [more rare cases](https://docs.ton.org/llms/tvm/initialization/content.md).
Executing code on same inputs and prior state deterministically produces same outputs, so that validators can agree on whether code was executed correctly.
Every instruction consumes [gas](https://docs.ton.org/llms/tvm/gas/content.md). Gas exhaustion stops execution. This limit is imposed so that expensive computations (i.e. infinite loops) cannot be used to exhaust validators' computation resources, causing [denial of service](https://en.wikipedia.org/wiki/Denial-of-service_attack).
## Data model [#data-model]
* TVM has no [random-access memory](https://en.wikipedia.org/wiki/Random-access_memory). Instead it uses a stack of values as a scratchpad.
* There are no memory addresses. Most instructions either store their parameters directly in the code, or take them from the top of the stack.
* All values are [immutable](https://en.wikipedia.org/wiki/Immutable_object).
Most of the data is stored as immutable tree of [cells](https://docs.ton.org/llms/foundations/serialization/cells/content.md).
* Reading and writing of cells is done with [slices and builders](https://docs.ton.org/llms/tvm/builders-and-slices/content.md).
* There are no function addresses or function pointers. Code is executed from bitcode inside [continuations](https://docs.ton.org/llms/tvm/continuations/content.md).
## TVM state [#tvm-state]
On incoming messages or get method call, a new instance of TVM is started, with a new state. Derivation of the initial state from the message is described in [its own article](https://docs.ton.org/llms/tvm/initialization/content.md).
The total state of TVM consists of the following components:
* **Stack**. A regular [stack data structure](https://en.wikipedia.org/wiki/Stack_\(abstract_data_type\)). The vast majority of instructions `pop()` operands from the top and `push()` results back.
* [**Control registers**](https://docs.ton.org/llms/tvm/registers/content.md). A small fixed set of special registers, denoted as `c0`, `c1`, ..., `c5`, and `c7` (`c6` does not exist).
* [**Gas counter**](https://docs.ton.org/llms/tvm/gas/content.md). Tracks remaining computation budget. Each instruction decrements gas. When counter hits zero/negative value, an exception is raised, and the run aborts.
* **Current continuation (`cc`)**. A special register that stores a list of the next instructions to execute. Similar to the instruction pointer in traditional architectures.
* **Current codepage (`cp`)**. Determines how to decode the next instruction in `cc`. Different codepages may implement different instruction sets, allowing for adding new features to TVM without affecting old smart contracts. Currently, only codepage `0` (`cp0`) is implemented. Smart contract runs [`SETCP0`](https://docs.ton.org/llms/tvm/instructions/content.md) instruction to explicitly use codepage `0`.
## TVM data types [#tvm-data-types]
Values on the stack and inside of registers are of one of the following seven types:
| Type | Description |
| ------------ | --------------------------------------------------------------------------------------------------------------------------- |
| Integer | 257-bit signed integer. Has the special `NaN` value representing arithmetic faults. |
| Cell | Node of a tree with bit string on it (\<= 1023 bits), and up to 4 arrows (refs). |
| Slice | Read cursor over a Cell. |
| Builder | Write cursor to construct a new Cell. |
| Tuple | List of 0..255 elements of any of seven types. Types of elements can be distinct. |
| Continuation | Executable Slice with TVM bitcode. [Continuations](https://en.wikipedia.org/wiki/Continuation) are callable like functions. |
| Null | Empty value. |
## Example of a smart contract: counter [#example-of-a-smart-contract-counter]
Here is a sample contract, written in [Fift](https://docs.ton.org/llms/languages/fift/overview/content.md). It implements the following logic:
* If an event is not an internal message, stop execution.
* Read 32-bit number (`msg_counter`) from internal message's body.
* Check that it is equal to the 32-bit number stored in `c4` (persistent account storage).
* Increment it.
* Save it back to `c4`.
When an account with this code gets an internal message, TVM stack [is initialized](https://docs.ton.org/llms/tvm/initialization/content.md) with these values:
1. `s0` (top of the stack), function selector, is `0`. For other events, e.g., external messages or get method calls, selector will be non-zero.
2. `s1`, message body. The example contract expects exactly 32 bits here.
3. Three more values `s2`, `s3`, `s4` [are pushed](https://docs.ton.org/llms/tvm/initialization/content.md) by TVM onto a stack. They won't be used in the example. After execution finishes, they'll still be on the stack, and will be silently ignored.
In `Current stack` comments, we represent stack at that moment of execution, keeping its top to the right (e.g., `s2 s1 s0`, where `s0` is the top of the stack).
```fift title="Fift"
<{
// Current stack: msg_body selector
// Use codepage 0. Picks the only available instruction set.
SETCP0
// This instruction does not affect the stack.
// Current stack: msg_body selector
// Consume `selector` from the top of the stack.
// Stop execution if `selector != 0`,
// i.e. "is not an internal message".
IFRET
// Continue execution if we received an internal message.
// Current stack: msg_body
// Load (LD) unsigned (U) 32-bit integer from a slice.
// This instruction pops (consumes) a slice from the stack,
// pushes an integer, and then pushes a new slice with
// 32 bits cut from it
32 LDU
// Current stack: msg_counter msg_body'
// msg_body' is a slice whose read cursor was moved by 32 bits
// when we loaded a 32-bit integer.
// For example, if we had slice x{00000001} on the stack and
// then invoked 32 LDU, there will be integer `1` and `x{}`
// (empty slice) on the stack
// Assert the END of a slice (S).
// These instructions consume a slice and check that it is
// empty (no more data to read), otherwise it throws an
// exception, because there was more data than we expected.
ENDS
// Current stack: msg_counter
// Push c4 (persistent storage) on the stack.
// `storage` is a cell
c4 PUSH
// Current stack: msg_counter storage
// Convert Cell to a Slice, i.e. make it readable
CTOS
// Current stack: msg_counter storage_slice
// Read 32-bit unsigned integer from `storage_slice`
32 LDU
// Current stack: msg_counter storage_counter storage_slice'
// Assert there is no more data in the storage
ENDS
// Current stack: msg_counter storage_counter
// Duplicate s0 (top of stack) under two top values
TUCK
// Current stack: storage_counter msg_counter storage_counter
// Check counters are equal
EQUAL
// Current stack: storage_counter msg_counter==storage_counter?
// Throw an exception with code 33 if it is not equal
33 THROWIFNOT
// Current stack: storage_counter
// Increase counter
INC
// Current stack: storage_counter+1
// Create an empty Builder
NEWC
// Current stack: storage_counter+1 builder
// Store (ST) unsigned (U) 32-bit integer `storage_counter+1` to a builder
32 STU
// Current stack: builder'
// Finalize Builder to a Cell
ENDC
// Current stack: new_storage
// Save `new_storage` to c4 (persistent storage)
c4 POP
// Current stack: (no values)
}>
```
# TVM registers (https://docs.ton.org/llms/tvm/registers/content.md)
TVM registers hold special values, such as contract storage, list of output actions, or exception handler.
Only `c4` (new state) and `c5` (final actions) represent durable effects of a successful on-chain run. Everything else is transient.
## `c0` — return continuation [#c0--return-continuation]
**Type**: `Continuation`
**Initial value**: `Quit` — extraordinary continuation which terminates TVM with exit code `0`.
When [`RET`](https://docs.ton.org/llms/tvm/instructions/content.md) is called or the current continuation remains no instructions (*implicit ret*), `c0` is invoked. Call-like instructions use it to store the current continuation in order to return to it after executing the inner function.
## `c1` — alternative return continuation [#c1--alternative-return-continuation]
**Type**: Continuation
**Initial value**: `Quit` — extraordinary continuation which terminates TVM with exit code `1`. Both exit codes `0` and `1` are considered successful terminations of TVM.
Same as `c0`, but invoked only in special control flow instructions, such as [`RETALT`](https://docs.ton.org/llms/tvm/instructions/content.md), [`IFRETALT`](https://docs.ton.org/llms/tvm/instructions/content.md), and others.
## `c2` — exception handler [#c2--exception-handler]
**Type**: Continuation
**Initial value**: `ExcQuit` — extraordinary continuation which terminates TVM with an exception. In this case, the exit code is an exception number.
Invoked implicitly on any exception that occurs during TVM execution. Can be invoked explicitly by [`THROW`](https://docs.ton.org/llms/tvm/instructions/content.md)-like instructions. To set a custom exception handler, use [TRY](https://docs.ton.org/llms/tvm/instructions/content.md).
## `c3` — function selector [#c3--function-selector]
**Type**: Continuation
**Initial value**: Root cell of code currently executing in TVM.
Invoked by [`CALLDICT`](https://docs.ton.org/llms/tvm/instructions/content.md) instruction with a function ID (integer) passed on the stack. The function selector should jump to a function with that ID.
Fift-ASM assembler constructs following function selector ([`Asm.fif`:1624](https://github.com/ton-blockchain/ton/blob/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/fift/lib/Asm.fif#L1624)):
```fift title=Fift"
SETCP0
<{
// a dictionary which maps 19-bit function id (integer) => function code (slice)
}> DICTPUSHCONST
DICTIGETJMPZ // get a function with given id from dictionary and execute it
11 THROWARG // if no function found, throw with exit code 11 and function id as additional argument
```
## `c4` — persistent account storage [#c4--persistent-account-storage]
**Type**: Cell
**Initial value**: Root cell of account data.
This register helps to store some information between smart contract invocations. When the transaction succeeds, the final value of `c4` is saved as new account data.
## `c5` — outbound actions accumulator [#c5--outbound-actions-accumulator]
**Type**: Cell
**Initial value**: Empty cell.
List of actions to perform in the action phase after TVM execution: send a message, reserve funds, update code, and install libraries.
`c5` has an `OutList` structure:
```tlb title="TL-B"
out_list_empty$_ = OutList 0;
out_list$_ {n:#} prev:^(OutList n) action:OutAction = OutList (n + 1);
action_send_msg#0ec3c86d mode:(## 8) out_msg:^(MessageRelaxed Any) = OutAction;
action_set_code#ad4de08e new_code:^Cell = OutAction;
action_reserve_currency#36e6b809 mode:(## 8) currency:CurrencyCollection = OutAction;
libref_hash$0 lib_hash:bits256 = LibRef;
libref_ref$1 library:^Cell = LibRef;
action_change_library#26fa1dd4 mode:(## 7) libref:LibRef = OutAction;
```
The previous action is always the first reference of the next one. If action itself has a reference, it is stored as the second reference in the list. At the beginning of the list, an empty cell is stored as the first reference of the first action.
## `c7` — environment information and global variables [#c7--environment-information-and-global-variables]
**Type**: Tuple
**Initial value**: `Tuple[Tuple[0x076ef1ea, 0, 0, ...]]`.
The zero element of the `c7` tuple is an environment information (which itself is also a tuple). The remaining 255 slots are used for global variables. [`[i] SETGLOB`](https://docs.ton.org/llms/tvm/instructions/content.md) modifies `c7`, inserting an element with index `i`, [`[i] GETGLOB`](https://docs.ton.org/llms/tvm/instructions/content.md) reads `i`-th element from `c7`.
### Structure of environment information tuple [#structure-of-environment-information-tuple]
**Category:** Stack Basic (stack\_basic)
```fift title="Fift" NOP ``` #### `0i` XCHG\_0I [#0i-xchg_0i] Interchanges `s0` with `s[i]`, `1 <= i <= 15`.
**Category:** Stack Basic (stack\_basic)
```fift title="Fift" s[i] XCHG0 ``` **Aliases**: * `SWAP`
Same as `s1 XCHG0`. #### `10ij` XCHG\_IJ [#10ij-xchg_ij] Interchanges `s[i]` with `s[j]`, `1 <= i < j <= 15`.
**Category:** Stack Basic (stack\_basic)
```fift title="Fift" s[i] s[j] XCHG ``` #### `11ii` XCHG\_0I\_LONG [#11ii-xchg_0i_long] Interchanges `s0` with `s[ii]`, `0 <= ii <= 255`.
**Category:** Stack Basic (stack\_basic)
```fift title="Fift" s0 [ii] s() XCHG ``` #### `1i` XCHG\_1I [#1i-xchg_1i] Interchanges `s1` with `s[i]`, `2 <= i <= 15`.
**Category:** Stack Basic (stack\_basic)
```fift title="Fift" s1 s[i] XCHG ``` #### `2i` PUSH [#2i-push] Pushes a copy of the old `s[i]` into the stack.
**Category:** Stack Basic (stack\_basic)
```fift title="Fift" s[i] PUSH ``` **Aliases**: * `DUP`
Same as `s0 PUSH`. * `OVER`
Same as `s1 PUSH`. #### `3i` POP [#3i-pop] Pops the old `s0` value into the old `s[i]`.
**Category:** Stack Basic (stack\_basic)
```fift title="Fift" s[i] POP ``` **Aliases**: * `DROP`
Same as `s0 POP`, discards the top-of-stack value. * `NIP`
Same as `s1 POP`. #### `4ijk` XCHG3 [#4ijk-xchg3] Equivalent to `s2 s[i] XCHG` `s1 s[j] XCHG` `s[k] XCHG0`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" s[i] s[j] s[k] XCHG3 ``` #### `50ij` XCHG2 [#50ij-xchg2] Equivalent to `s1 s[i] XCHG` `s[j] XCHG0`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" s[i] s[j] XCHG2 ``` #### `51ij` XCPU [#51ij-xcpu] Equivalent to `s[i] XCHG0` `s[j] PUSH`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" s[i] s[j] XCPU ``` #### `52ij` PUXC [#52ij-puxc] Equivalent to `s[i] PUSH` `SWAP` `s[j] XCHG0`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" s[i] s[j-1] PUXC ``` #### `53ij` PUSH2 [#53ij-push2] Equivalent to `s[i] PUSH` `s[j+1] PUSH`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" s[i] s[j] PUSH2 ``` #### `540ijk` XCHG3\_ALT [#540ijk-xchg3_alt] Long form of `XCHG3`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" s[i] s[j] s[k] XCHG3_l ``` #### `541ijk` XC2PU [#541ijk-xc2pu] Equivalent to `s[i] s[j] XCHG2` `s[k] PUSH`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" s[i] s[j] s[k] XC2PU ``` #### `542ijk` XCPUXC [#542ijk-xcpuxc] Equivalent to `s1 s[i] XCHG` `s[j] s[k-1] PUXC`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" s[i] s[j] s[k-1] XCPUXC ``` #### `543ijk` XCPU2 [#543ijk-xcpu2] Equivalent to `s[i] XCHG0` `s[j] s[k] PUSH2`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" s[i] s[j] s[k] XCPU2 ``` #### `544ijk` PUXC2 [#544ijk-puxc2] Equivalent to `s[i] PUSH` `s2 XCHG0` `s[j] s[k] XCHG2`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" s[i] s[j-1] s[k-1] PUXC2 ``` #### `545ijk` PUXCPU [#545ijk-puxcpu] Equivalent to `s[i] s[j-1] PUXC` `s[k] PUSH`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" s[i] s[j-1] s[k-1] PUXCPU ``` #### `546ijk` PU2XC [#546ijk-pu2xc] Equivalent to `s[i] PUSH` `SWAP` `s[j] s[k-1] PUXC`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" s[i] s[j-1] s[k-2] PU2XC ``` #### `547ijk` PUSH3 [#547ijk-push3] Equivalent to `s[i] PUSH` `s[j+1] s[k+1] PUSH2`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" s[i] s[j] s[k] PUSH3 ``` #### `55ij` BLKSWAP [#55ij-blkswap] Permutes two blocks `s[j+i+1] ... s[j+1]` and `s[j] ... s0`.
`0 <= i,j <= 15`
Equivalent to `[i+1] [j+1] REVERSE` `[j+1] 0 REVERSE` `[i+j+2] 0 REVERSE`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" [i+1] [j+1] BLKSWAP ``` **Aliases**: * `ROT2`
Rotates the three topmost pairs of stack entries. * `ROLL`
Rotates the top `i+1` stack entries.
Equivalent to `1 [i+1] BLKSWAP`. * `ROLLREV`
Rotates the top `i+1` stack entries in the other direction.
Equivalent to `[i+1] 1 BLKSWAP`. #### `56ii` PUSH\_LONG [#56ii-push_long] Pushes a copy of the old `s[ii]` into the stack.
`0 <= ii <= 255`
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" [ii] s() PUSH ``` #### `57ii` POP\_LONG [#57ii-pop_long] Pops the old `s0` value into the old `s[ii]`.
`0 <= ii <= 255`
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" [ii] s() POP ``` #### `58` ROT [#58-rot] Equivalent to `1 2 BLKSWAP` or to `s2 s1 XCHG2`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" ROT ``` #### `59` ROTREV [#59-rotrev] Equivalent to `2 1 BLKSWAP` or to `s2 s2 XCHG2`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" ROTREV -ROT ``` #### `5A` SWAP2 [#5a-swap2] Equivalent to `2 2 BLKSWAP` or to `s3 s2 XCHG2`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" SWAP2 2SWAP ``` #### `5B` DROP2 [#5b-drop2] Equivalent to `DROP` `DROP`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" DROP2 2DROP ``` #### `5C` DUP2 [#5c-dup2] Equivalent to `s1 s0 PUSH2`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" DUP2 2DUP ``` #### `5D` OVER2 [#5d-over2] Equivalent to `s3 s2 PUSH2`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" OVER2 2OVER ``` #### `5Eij` REVERSE [#5eij-reverse] Reverses the order of `s[j+i+1] ... s[j]`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" [i+2] [j] REVERSE ``` #### `5F0i` BLKDROP [#5f0i-blkdrop] Equivalent to `DROP` performed `i` times.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" [i] BLKDROP ``` #### `5Fij` BLKPUSH [#5fij-blkpush] Equivalent to `PUSH s(j)` performed `i` times.
`1 <= i <= 15`, `0 <= j <= 15`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" [i] [j] BLKPUSH ``` #### `60` PICK [#60-pick] Pops integer `i` from the stack, then performs `s[i] PUSH`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" PICK PUSHX ``` #### `61` ROLLX [#61-rollx] Pops integer `i` from the stack, then performs `1 [i] BLKSWAP`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" ROLLX ``` #### `62` -ROLLX [#62--rollx] Pops integer `i` from the stack, then performs `[i] 1 BLKSWAP`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" -ROLLX ROLLREVX ``` #### `63` BLKSWX [#63-blkswx] Pops integers `i`,`j` from the stack, then performs `[i] [j] BLKSWAP`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" BLKSWX ``` #### `64` REVX [#64-revx] Pops integers `i`,`j` from the stack, then performs `[i] [j] REVERSE`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" REVX ``` #### `65` DROPX [#65-dropx] Pops integer `i` from the stack, then performs `[i] BLKDROP`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" DROPX ``` #### `66` TUCK [#66-tuck] Equivalent to `SWAP` `OVER` or to `s1 s1 XCPU`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" TUCK ``` #### `67` XCHGX [#67-xchgx] Pops integer `i` from the stack, then performs `s[i] XCHG`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" XCHGX ``` #### `68` DEPTH [#68-depth] Pushes the current depth of the stack.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" DEPTH ``` #### `69` CHKDEPTH [#69-chkdepth] Pops integer `i` from the stack, then checks whether there are at least `i` elements, generating a stack underflow exception otherwise.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" CHKDEPTH ``` #### `6A` ONLYTOPX [#6a-onlytopx] Pops integer `i` from the stack, then removes all but the top `i` elements.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" ONLYTOPX ``` #### `6B` ONLYX [#6b-onlyx] Pops integer `i` from the stack, then leaves only the bottom `i` elements. Approximately equivalent to `DEPTH` `SWAP` `SUB` `DROPX`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" ONLYX ``` #### `6Cij` BLKDROP2 [#6cij-blkdrop2] Drops `i` stack elements under the top `j` elements.
`1 <= i <= 15`, `0 <= j <= 15`
Equivalent to `[i+j] 0 REVERSE` `[i] BLKDROP` `[j] 0 REVERSE`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift" [i] [j] BLKDROP2 ``` #### `6D` NULL [#6d-null] Pushes the only value of type *Null*.
**Category:** Tuple (tuple)
```fift title="Fift" NULL PUSHNULL ``` **Aliases**: * `NEWDICT`
Returns a new empty dictionary.
It is an alternative mnemonics for `PUSHNULL`. #### `6E` ISNULL [#6e-isnull] Checks whether `x` is a *Null*, and returns `-1` or `0` accordingly.
**Category:** Tuple (tuple)
```fift title="Fift" ISNULL ``` **Aliases**: * `DICTEMPTY`
Checks whether dictionary `D` is empty, and returns `-1` or `0` accordingly.
It is an alternative mnemonics for `ISNULL`. #### `6F0n` TUPLE [#6f0n-tuple] Creates a new *Tuple* `t=(x_1, ... ,x_n)` containing `n` values `x_1`,..., `x_n`.
`0 <= n <= 15`
**Category:** Tuple (tuple)
```fift title="Fift" [n] TUPLE ``` **Aliases**: * `NIL`
Pushes the only *Tuple* `t=()` of length zero. * `SINGLE`
Creates a singleton `t:=(x)`, i.e., a *Tuple* of length one. * `PAIR`
Creates pair `t:=(x,y)`. * `TRIPLE`
Creates triple `t:=(x,y,z)`. #### `6F1k` INDEX [#6f1k-index] Returns the `k`-th element of a *Tuple* `t`.
`0 <= k <= 15`.
**Category:** Tuple (tuple)
```fift title="Fift" [k] INDEX ``` **Aliases**: * `FIRST`
Returns the first element of a *Tuple*. * `SECOND`
Returns the second element of a *Tuple*. * `THIRD`
Returns the third element of a *Tuple*. #### `6F2n` UNTUPLE [#6f2n-untuple] Unpacks a *Tuple* `t=(x_1,...,x_n)` of length equal to `0 <= n <= 15`.
If `t` is not a *Tuple*, or if `|t| != n`, a type check exception is thrown.
**Category:** Tuple (tuple)
```fift title="Fift" [n] UNTUPLE ``` **Aliases**: * `UNSINGLE`
Unpacks a singleton `t=(x)`. * `UNPAIR`
Unpacks a pair `t=(x,y)`. * `UNTRIPLE`
Unpacks a triple `t=(x,y,z)`. #### `6F3k` UNPACKFIRST [#6f3k-unpackfirst] Unpacks first `0 <= k <= 15` elements of a *Tuple* `t`.
If `|t|
```fift title="Fift" [k] UNPACKFIRST ``` **Aliases**: * `CHKTUPLE`
Checks whether `t` is a *Tuple*. If not, throws a type check exception. #### `6F4n` EXPLODE [#6f4n-explode] Unpacks a *Tuple* `t=(x_1,...,x_m)` and returns its length `m`, but only if `m <= n <= 15`. Otherwise throws a type check exception.
**Category:** Tuple (tuple)
```fift title="Fift" [n] EXPLODE ``` #### `6F5k` SETINDEX [#6f5k-setindex] Computes *Tuple* `t'` that differs from `t` only at position `t'_{k+1}`, which is set to `x`.
`0 <= k <= 15`
If `k >= |t|`, throws a range check exception.
**Category:** Tuple (tuple)
```fift title="Fift" [k] SETINDEX ``` **Aliases**: * `SETFIRST`
Sets the first component of *Tuple* `t` to `x` and returns the resulting *Tuple* `t'`. * `SETSECOND`
Sets the second component of *Tuple* `t` to `x` and returns the resulting *Tuple* `t'`. * `SETTHIRD`
Sets the third component of *Tuple* `t` to `x` and returns the resulting *Tuple* `t'`. #### `6F6k` INDEXQ [#6f6k-indexq] Returns the `k`-th element of a *Tuple* `t`, where `0 <= k <= 15`. In other words, returns `x_{k+1}` if `t=(x_1,...,x_n)`. If `k>=n`, or if `t` is *Null*, returns a *Null* instead of `x`.
**Category:** Tuple (tuple)
```fift title="Fift" [k] INDEXQ ``` **Aliases**: * `FIRSTQ`
Returns the first element of a *Tuple*. * `SECONDQ`
Returns the second element of a *Tuple*. * `THIRDQ`
Returns the third element of a *Tuple*. #### `6F7k` SETINDEXQ [#6f7k-setindexq] Sets the `k`-th component of *Tuple* `t` to `x`, where `0 <= k < 16`, and returns the resulting *Tuple* `t'`.
If `|t| <= k`, first extends the original *Tuple* to length `n'=k+1` by setting all new components to *Null*. If the original value of `t` is *Null*, treats it as an empty *Tuple*. If `t` is not *Null* or *Tuple*, throws an exception. If `x` is *Null* and either `|t| <= k` or `t` is *Null*, then always returns `t'=t` (and does not consume tuple creation gas).
**Category:** Tuple (tuple)
```fift title="Fift" [k] SETINDEXQ ``` **Aliases**: * `SETFIRSTQ`
Sets the first component of *Tuple* `t` to `x` and returns the resulting *Tuple* `t'`. * `SETSECONDQ`
Sets the second component of *Tuple* `t` to `x` and returns the resulting *Tuple* `t'`. * `SETTHIRDQ`
Sets the third component of *Tuple* `t` to `x` and returns the resulting *Tuple* `t'`. #### `6F80` TUPLEVAR [#6f80-tuplevar] Creates a new *Tuple* `t` of length `n` similarly to `TUPLE`, but with `0 <= n <= 255` taken from the stack.
**Category:** Tuple (tuple)
```fift title="Fift" TUPLEVAR ``` #### `6F81` INDEXVAR [#6f81-indexvar] Similar to `k INDEX`, but with `0 <= k <= 254` taken from the stack.
**Category:** Tuple (tuple)
```fift title="Fift" INDEXVAR ``` #### `6F82` UNTUPLEVAR [#6f82-untuplevar] Similar to `n UNTUPLE`, but with `0 <= n <= 255` taken from the stack.
**Category:** Tuple (tuple)
```fift title="Fift" UNTUPLEVAR ``` #### `6F83` UNPACKFIRSTVAR [#6f83-unpackfirstvar] Similar to `n UNPACKFIRST`, but with `0 <= n <= 255` taken from the stack.
**Category:** Tuple (tuple)
```fift title="Fift" UNPACKFIRSTVAR ``` #### `6F84` EXPLODEVAR [#6f84-explodevar] Similar to `n EXPLODE`, but with `0 <= n <= 255` taken from the stack.
**Category:** Tuple (tuple)
```fift title="Fift" EXPLODEVAR ``` #### `6F85` SETINDEXVAR [#6f85-setindexvar] Similar to `k SETINDEX`, but with `0 <= k <= 254` taken from the stack.
**Category:** Tuple (tuple)
```fift title="Fift" SETINDEXVAR ``` #### `6F86` INDEXVARQ [#6f86-indexvarq] Similar to `n INDEXQ`, but with `0 <= k <= 254` taken from the stack.
**Category:** Tuple (tuple)
```fift title="Fift" INDEXVARQ ``` #### `6F87` SETINDEXVARQ [#6f87-setindexvarq] Similar to `k SETINDEXQ`, but with `0 <= k <= 254` taken from the stack.
**Category:** Tuple (tuple)
```fift title="Fift" SETINDEXVARQ ``` #### `6F88` TLEN [#6f88-tlen] Returns the length of a *Tuple*.
**Category:** Tuple (tuple)
```fift title="Fift" TLEN ``` #### `6F89` QTLEN [#6f89-qtlen] Similar to `TLEN`, but returns `-1` if `t` is not a *Tuple*.
**Category:** Tuple (tuple)
```fift title="Fift" QTLEN ``` #### `6F8A` ISTUPLE [#6f8a-istuple] Returns `-1` or `0` depending on whether `t` is a *Tuple*.
**Category:** Tuple (tuple)
```fift title="Fift" ISTUPLE ``` #### `6F8B` LAST [#6f8b-last] Returns the last element of a non-empty *Tuple* `t`.
**Category:** Tuple (tuple)
```fift title="Fift" LAST ``` #### `6F8C` TPUSH [#6f8c-tpush] Appends a value `x` to a *Tuple* `t=(x_1,...,x_n)`, but only if the resulting *Tuple* `t'=(x_1,...,x_n,x)` is of length at most 255. Otherwise throws a type check exception.
**Category:** Tuple (tuple)
```fift title="Fift" TPUSH COMMA ``` #### `6F8D` TPOP [#6f8d-tpop] Detaches the last element `x=x_n` from a non-empty *Tuple* `t=(x_1,...,x_n)`, and returns both the resulting *Tuple* `t'=(x_1,...,x_{n-1})` and the original last element `x`.
**Category:** Tuple (tuple)
```fift title="Fift" TPOP ``` #### `6FA0` NULLSWAPIF [#6fa0-nullswapif] Pushes a *Null* under the topmost *Integer* `x`, but only if `x!=0`.
**Category:** Tuple (tuple)
```fift title="Fift" NULLSWAPIF ``` #### `6FA1` NULLSWAPIFNOT [#6fa1-nullswapifnot] Pushes a *Null* under the topmost *Integer* `x`, but only if `x=0`. May be used for stack alignment after quiet primitives such as `PLDUXQ`.
**Category:** Tuple (tuple)
```fift title="Fift" NULLSWAPIFNOT ``` #### `6FA2` NULLROTRIF [#6fa2-nullrotrif] Pushes a *Null* under the second stack entry from the top, but only if the topmost *Integer* `y` is non-zero.
**Category:** Tuple (tuple)
```fift title="Fift" NULLROTRIF ``` #### `6FA3` NULLROTRIFNOT [#6fa3-nullrotrifnot] Pushes a *Null* under the second stack entry from the top, but only if the topmost *Integer* `y` is zero. May be used for stack alignment after quiet primitives such as `LDUXQ`.
**Category:** Tuple (tuple)
```fift title="Fift" NULLROTRIFNOT ``` #### `6FA4` NULLSWAPIF2 [#6fa4-nullswapif2] Pushes two nulls under the topmost *Integer* `x`, but only if `x!=0`.
Equivalent to `NULLSWAPIF` `NULLSWAPIF`.
**Category:** Tuple (tuple)
```fift title="Fift" NULLSWAPIF2 ``` #### `6FA5` NULLSWAPIFNOT2 [#6fa5-nullswapifnot2] Pushes two nulls under the topmost *Integer* `x`, but only if `x=0`.
Equivalent to `NULLSWAPIFNOT` `NULLSWAPIFNOT`.
**Category:** Tuple (tuple)
```fift title="Fift" NULLSWAPIFNOT2 ``` #### `6FA6` NULLROTRIF2 [#6fa6-nullrotrif2] Pushes two nulls under the second stack entry from the top, but only if the topmost *Integer* `y` is non-zero.
Equivalent to `NULLROTRIF` `NULLROTRIF`.
**Category:** Tuple (tuple)
```fift title="Fift" NULLROTRIF2 ``` #### `6FA7` NULLROTRIFNOT2 [#6fa7-nullrotrifnot2] Pushes two nulls under the second stack entry from the top, but only if the topmost *Integer* `y` is zero.
Equivalent to `NULLROTRIFNOT` `NULLROTRIFNOT`.
**Category:** Tuple (tuple)
```fift title="Fift" NULLROTRIFNOT2 ``` #### `6FBij` INDEX2 [#6fbij-index2] Recovers `x=(t_{i+1})_{j+1}` for `0 <= i,j <= 3`.
Equivalent to `[i] INDEX` `[j] INDEX`.
**Category:** Tuple (tuple)
```fift title="Fift" [i] [j] INDEX2 ``` **Aliases**: * `CADR`
Recovers `x=(t_2)_1`. * `CDDR`
Recovers `x=(t_2)_2`. #### `6FE_ijk` INDEX3 [#6fe_ijk-index3] Recovers `x=t_{i+1}_{j+1}_{k+1}`.
`0 <= i,j,k <= 3`
Equivalent to `[i] [j] INDEX2` `[k] INDEX`.
**Category:** Tuple (tuple)
```fift title="Fift" [i] [j] [k] INDEX3 ``` **Aliases**: * `CADDR`
Recovers `x=t_2_2_1`. * `CDDDR`
Recovers `x=t_2_2_2`. #### `7i` PUSHINT\_4 [#7i-pushint_4] Pushes integer `x` into the stack. `-5 <= x <= 10`.
Here `i` equals four lower-order bits of `x` (`i=x mod 16`).
**Category:** Const Int (const\_int)
```fift title="Fift" [x] PUSHINT [x] INT ``` **Aliases**: * `ZERO`
* `ONE`
* `TWO`
* `TEN`
* `TRUE`
#### `80xx` PUSHINT\_8 [#80xx-pushint_8] Pushes integer `xx`. `-128 <= xx <= 127`.
**Category:** Const Int (const\_int)
```fift title="Fift" [xx] PUSHINT [xx] INT ``` #### `81xxxx` PUSHINT\_16 [#81xxxx-pushint_16] Pushes integer `xxxx`. `-2^15 <= xx < 2^15`.
**Category:** Const Int (const\_int)
```fift title="Fift" [xxxx] PUSHINT [xxxx] INT ``` #### `82lxxx` PUSHINT\_LONG [#82lxxx-pushint_long] Pushes integer `xxx`.
*Details:* 5-bit `0 <= l <= 30` determines the length `n=8l+19` of signed big-endian integer `xxx`.
The total length of this instruction is `l+4` bytes or `n+13=8l+32` bits.
**Category:** Const Int (const\_int)
```fift title="Fift" [xxx] PUSHINT [xxx] INT ``` #### `83xx` PUSHPOW2 [#83xx-pushpow2] (Quietly) pushes `2^(xx+1)` for `0 <= xx <= 255`.
`2^256` is a `NaN`.
**Category:** Const Int (const\_int)
```fift title="Fift" [xx+1] PUSHPOW2 ``` #### `83FF` PUSHNAN [#83ff-pushnan] Pushes a `NaN`.
**Category:** Const Int (const\_int)
```fift title="Fift" PUSHNAN ``` #### `84xx` PUSHPOW2DEC [#84xx-pushpow2dec] Pushes `2^(xx+1)-1` for `0 <= xx <= 255`.
**Category:** Const Int (const\_int)
```fift title="Fift" [xx+1] PUSHPOW2DEC ``` #### `85xx` PUSHNEGPOW2 [#85xx-pushnegpow2] Pushes `-2^(xx+1)` for `0 <= xx <= 255`.
**Category:** Const Int (const\_int)
```fift title="Fift" [xx+1] PUSHNEGPOW2 ``` #### `88` PUSHREF [#88-pushref] Pushes the reference `ref` into the stack.
*Details:* Pushes the first reference of `cc.code` into the stack as a *Cell* (and removes this reference from the current continuation).
**Category:** Const Data (const\_data)
```fift title="Fift" [ref] PUSHREF ``` #### `89` PUSHREFSLICE [#89-pushrefslice] Similar to `PUSHREF`, but converts the cell into a *Slice*.
**Category:** Const Data (const\_data)
```fift title="Fift" [ref] PUSHREFSLICE ``` #### `8A` PUSHREFCONT [#8a-pushrefcont] Similar to `PUSHREFSLICE`, but makes a simple ordinary *Continuation* out of the cell.
**Category:** Const Data (const\_data)
```fift title="Fift" [ref] PUSHREFCONT ``` #### `8Bxsss` PUSHSLICE [#8bxsss-pushslice] Pushes the slice `slice` into the stack.
*Details:* Pushes the (prefix) subslice of `cc.code` consisting of its first `8x+4` bits and no references (i.e., essentially a bitstring), where `0 <= x <= 15`.
A completion tag is assumed, meaning that all trailing zeroes and the last binary one (if present) are removed from this bitstring.
If the original bitstring consists only of zeroes, an empty slice will be pushed.
**Category:** Const Data (const\_data)
```fift title="Fift" [slice] PUSHSLICE [slice] SLICE ``` #### `8Crxxssss` PUSHSLICE\_REFS [#8crxxssss-pushslice_refs] Pushes the slice `slice` into the stack.
*Details:* Pushes the (prefix) subslice of `cc.code` consisting of its first `1 <= r+1 <= 4` references and up to first `8xx+1` bits of data, with `0 <= xx <= 31`.
A completion tag is also assumed.
**Category:** Const Data (const\_data)
```fift title="Fift" [slice] PUSHSLICE [slice] SLICE ``` #### `8Drxxsssss` PUSHSLICE\_LONG [#8drxxsssss-pushslice_long] Pushes the slice `slice` into the stack.
*Details:* Pushes the subslice of `cc.code` consisting of `0 <= r <= 4` references and up to `8xx+6` bits of data, with `0 <= xx <= 127`.
A completion tag is assumed.
**Category:** Const Data (const\_data)
```fift title="Fift" [slice] PUSHSLICE [slice] SLICE ``` #### `8F_rxxcccc` PUSHCONT [#8f_rxxcccc-pushcont] Pushes a continuation made from `builder`.
*Details:* Pushes the simple ordinary continuation `cccc` made from the first `0 <= r <= 3` references and the first `0 <= xx <= 127` bytes of `cc.code`.
**Category:** Const Data (const\_data)
```fift title="Fift" [builder] PUSHCONT [builder] CONT ``` #### `9xccc` PUSHCONT\_SHORT [#9xccc-pushcont_short] Pushes a continuation made from `builder`.
*Details:* Pushes an `x`-byte continuation for `0 <= x <= 15`.
**Category:** Const Data (const\_data)
```fift title="Fift" [builder] PUSHCONT [builder] CONT ``` #### `A0` ADD [#a0-add]
**Category:** Arithm Basic (arithm\_basic)
```fift title="Fift" ADD ``` #### `A1` SUB [#a1-sub]
**Category:** Arithm Basic (arithm\_basic)
```fift title="Fift" SUB ``` #### `A2` SUBR [#a2-subr] Equivalent to `SWAP` `SUB`.
**Category:** Arithm Basic (arithm\_basic)
```fift title="Fift" SUBR ``` #### `A3` NEGATE [#a3-negate] Equivalent to `-1 MULCONST` or to `ZERO SUBR`.
Notice that it triggers an integer overflow exception if `x=-2^256`.
**Category:** Arithm Basic (arithm\_basic)
```fift title="Fift" NEGATE ``` #### `A4` INC [#a4-inc] Equivalent to `1 ADDCONST`.
**Category:** Arithm Basic (arithm\_basic)
```fift title="Fift" INC ``` #### `A5` DEC [#a5-dec] Equivalent to `-1 ADDCONST`.
**Category:** Arithm Basic (arithm\_basic)
```fift title="Fift" DEC ``` #### `A6cc` ADDCONST [#a6cc-addconst] `-128 <= cc <= 127`.
**Category:** Arithm Basic (arithm\_basic)
```fift title="Fift" [cc] ADDCONST [cc] ADDINT [-cc] SUBCONST [-cc] SUBINT ``` #### `A7cc` MULCONST [#a7cc-mulconst] `-128 <= cc <= 127`.
**Category:** Arithm Basic (arithm\_basic)
```fift title="Fift" [cc] MULCONST [cc] MULINT ``` #### `A8` MUL [#a8-mul]
**Category:** Arithm Basic (arithm\_basic)
```fift title="Fift" MUL ``` #### `A900` ADDDIVMOD [#a900-adddivmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" ADDDIVMOD ``` #### `A901` ADDDIVMODR [#a901-adddivmodr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" ADDDIVMODR ``` #### `A902` ADDDIVMODC [#a902-adddivmodc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" ADDDIVMODC ``` #### `A904` DIV [#a904-div] `q=floor(x/y)`, `r=x-y*q`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" DIV ``` #### `A905` DIVR [#a905-divr] `q'=round(x/y)`, `r'=x-y*q'`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" DIVR ``` #### `A906` DIVC [#a906-divc] `q''=ceil(x/y)`, `r''=x-y*q''`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" DIVC ``` #### `A908` MOD [#a908-mod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MOD ``` #### `A909` MODR [#a909-modr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MODR ``` #### `A90A` MODC [#a90a-modc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MODC ``` #### `A90C` DIVMOD [#a90c-divmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" DIVMOD ``` #### `A90D` DIVMODR [#a90d-divmodr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" DIVMODR ``` #### `A90E` DIVMODC [#a90e-divmodc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" DIVMODC ``` #### `A920` ADDRSHIFTMOD\_VAR [#a920-addrshiftmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" ADDRSHIFTMOD ``` #### `A921` ADDRSHIFTMODR [#a921-addrshiftmodr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" ADDRSHIFTMODR ``` #### `A922` ADDRSHIFTMODC [#a922-addrshiftmodc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" ADDRSHIFTMODC ``` #### `A925` RSHIFTR\_VAR [#a925-rshiftr_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" RSHIFTR ``` #### `A926` RSHIFTC\_VAR [#a926-rshiftc_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" RSHIFTC ``` #### `A928` MODPOW2\_VAR [#a928-modpow2_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MODPOW2 ``` #### `A929` MODPOW2R\_VAR [#a929-modpow2r_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MODPOW2R ``` #### `A92A` MODPOW2C\_VAR [#a92a-modpow2c_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MODPOW2C ``` #### `A92C` RSHIFTMOD\_VAR [#a92c-rshiftmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" RSHIFTMOD ``` #### `A92D` RSHIFTMODR\_VAR [#a92d-rshiftmodr_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" RSHIFTMODR ``` #### `A92E` RSHIFTMODC\_VAR [#a92e-rshiftmodc_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" RSHIFTMODC ``` #### `A930tt` ADDRSHIFTMOD [#a930tt-addrshiftmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] ADDRSHIFT#MOD ``` #### `A931tt` ADDRSHIFTRMOD [#a931tt-addrshiftrmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] ADDRSHIFTR#MOD ``` #### `A932tt` ADDRSHIFTCMOD [#a932tt-addrshiftcmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] ADDRSHIFTC#MOD ``` #### `A935tt` RSHIFTR [#a935tt-rshiftr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] RSHIFTR# ``` #### `A936tt` RSHIFTC [#a936tt-rshiftc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] RSHIFTC# ``` #### `A938tt` MODPOW2 [#a938tt-modpow2]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] MODPOW2# ``` #### `A939tt` MODPOW2R [#a939tt-modpow2r]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] MODPOW2R# ``` #### `A93Att` MODPOW2C [#a93att-modpow2c]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] MODPOW2C# ``` #### `A93Ctt` RSHIFTMOD [#a93ctt-rshiftmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] RSHIFT#MOD ``` #### `A93Dtt` RSHIFTRMOD [#a93dtt-rshiftrmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] RSHIFTR#MOD ``` #### `A93Ett` RSHIFTCMOD [#a93ett-rshiftcmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] RSHIFTC#MOD ``` #### `A980` MULADDDIVMOD [#a980-muladddivmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULADDDIVMOD ``` #### `A981` MULADDDIVMODR [#a981-muladddivmodr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULADDDIVMODR ``` #### `A982` MULADDDIVMODC [#a982-muladddivmodc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULADDDIVMODC ``` #### `A984` MULDIV [#a984-muldiv] `q=floor(x*y/z)`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULDIV ``` #### `A985` MULDIVR [#a985-muldivr] `q'=round(x*y/z)`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULDIVR ``` #### `A986` MULDIVC [#a986-muldivc] `q'=ceil(x*y/z)`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULDIVC ``` #### `A988` MULMOD [#a988-mulmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULMOD ``` #### `A989` MULMODR [#a989-mulmodr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULMODR ``` #### `A98A` MULMODC [#a98a-mulmodc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULMODC ``` #### `A98C` MULDIVMOD [#a98c-muldivmod] `q=floor(x*y/z)`, `r=x*y-z*q`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULDIVMOD ``` #### `A98D` MULDIVMODR [#a98d-muldivmodr] `q=round(x*y/z)`, `r=x*y-z*q`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULDIVMODR ``` #### `A98E` MULDIVMODC [#a98e-muldivmodc] `q=ceil(x*y/z)`, `r=x*y-z*q`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULDIVMODC ``` #### `A9A0` MULADDRSHIFTMOD\_VAR [#a9a0-muladdrshiftmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULADDRSHIFTMOD ``` #### `A9A1` MULADDRSHIFTRMOD\_VAR [#a9a1-muladdrshiftrmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULADDRSHIFTRMOD ``` #### `A9A2` MULADDRSHIFTCMOD\_VAR [#a9a2-muladdrshiftcmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULADDRSHIFTCMOD ``` #### `A9A4` MULRSHIFT\_VAR [#a9a4-mulrshift_var] `0 <= z <= 256`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULRSHIFT ``` #### `A9A5` MULRSHIFTR\_VAR [#a9a5-mulrshiftr_var] `0 <= z <= 256`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULRSHIFTR ``` #### `A9A6` MULRSHIFTC\_VAR [#a9a6-mulrshiftc_var] `0 <= z <= 256`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULRSHIFTC ``` #### `A9A8` MULMODPOW2\_VAR [#a9a8-mulmodpow2_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULMODPOW2_VAR ``` #### `A9A9` MULMODPOW2R\_VAR [#a9a9-mulmodpow2r_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULMODPOW2R_VAR ``` #### `A9AA` MULMODPOW2C\_VAR [#a9aa-mulmodpow2c_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULMODPOW2C_VAR ``` #### `A9AC` MULRSHIFTMOD\_VAR [#a9ac-mulrshiftmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULRSHIFTMOD_VAR ``` #### `A9AD` MULRSHIFTRMOD\_VAR [#a9ad-mulrshiftrmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULRSHIFTRMOD_VAR ``` #### `A9AE` MULRSHIFTCMOD\_VAR [#a9ae-mulrshiftcmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULRSHIFTCMOD_VAR ``` #### `A9B0tt` MULADDRSHIFTMOD [#a9b0tt-muladdrshiftmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] MULADDRSHIFT#MOD ``` #### `A9B1tt` MULADDRSHIFTRMOD [#a9b1tt-muladdrshiftrmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] MULADDRSHIFTR#MOD ``` #### `A9B2tt` MULADDRSHIFTCMOD [#a9b2tt-muladdrshiftcmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] MULADDRSHIFTC#MOD ``` #### `A9B4tt` MULRSHIFT [#a9b4tt-mulrshift]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] MULRSHIFT# ``` #### `A9B5tt` MULRSHIFTR [#a9b5tt-mulrshiftr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] MULRSHIFTR# ``` #### `A9B6tt` MULRSHIFTC [#a9b6tt-mulrshiftc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] MULRSHIFTC# ``` #### `A9B8tt` MULMODPOW2 [#a9b8tt-mulmodpow2]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] MULMODPOW2# ``` #### `A9B9tt` MULMODPOW2R [#a9b9tt-mulmodpow2r]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] MULMODPOW2R# ``` #### `A9BAtt` MULMODPOW2C [#a9batt-mulmodpow2c]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] MULMODPOW2C# ``` #### `A9BC` MULRSHIFTMOD [#a9bc-mulrshiftmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULRSHIFT#MOD ``` #### `A9BD` MULRSHIFTRMOD [#a9bd-mulrshiftrmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULRSHIFTR#MOD ``` #### `A9BE` MULRSHIFTCMOD [#a9be-mulrshiftcmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" MULRSHIFTC#MOD ``` #### `A9C0` LSHIFTADDDIVMOD\_VAR [#a9c0-lshiftadddivmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" LSHIFTADDDIVMOD ``` #### `A9C1` LSHIFTADDDIVMODR\_VAR [#a9c1-lshiftadddivmodr_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" LSHIFTADDDIVMODR ``` #### `A9C2` LSHIFTADDDIVMODC\_VAR [#a9c2-lshiftadddivmodc_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" LSHIFTADDDIVMODC ``` #### `A9C4` LSHIFTDIV\_VAR [#a9c4-lshiftdiv_var] `0 <= z <= 256`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" LSHIFTDIV ``` #### `A9C5` LSHIFTDIVR\_VAR [#a9c5-lshiftdivr_var] `0 <= z <= 256`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" LSHIFTDIVR ``` #### `A9C6` LSHIFTDIVC\_VAR [#a9c6-lshiftdivc_var] `0 <= z <= 256`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" LSHIFTDIVC ``` #### `A9C8` LSHIFTMOD\_VAR [#a9c8-lshiftmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" LSHIFTMOD ``` #### `A9C9` LSHIFTMODR\_VAR [#a9c9-lshiftmodr_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" LSHIFTMODR ``` #### `A9CA` LSHIFTMODC\_VAR [#a9ca-lshiftmodc_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" LSHIFTMODC ``` #### `A9CC` LSHIFTDIVMOD\_VAR [#a9cc-lshiftdivmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" LSHIFTDIVMOD ``` #### `A9CD` LSHIFTDIVMODR\_VAR [#a9cd-lshiftdivmodr_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" LSHIFTDIVMODR ``` #### `A9CE` LSHIFTDIVMODC\_VAR [#a9ce-lshiftdivmodc_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" LSHIFTDIVMODC ``` #### `A9D0tt` LSHIFTADDDIVMOD [#a9d0tt-lshiftadddivmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] LSHIFT#ADDDIVMOD ``` #### `A9D1tt` LSHIFTADDDIVMODR [#a9d1tt-lshiftadddivmodr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] LSHIFT#ADDDIVMODR ``` #### `A9D2tt` LSHIFTADDDIVMODC [#a9d2tt-lshiftadddivmodc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] LSHIFT#ADDDIVMODC ``` #### `A9D4tt` LSHIFTDIV [#a9d4tt-lshiftdiv]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] LSHIFT#DIV ``` #### `A9D5tt` LSHIFTDIVR [#a9d5tt-lshiftdivr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] LSHIFT#DIVR ``` #### `A9D6tt` LSHIFTDIVC [#a9d6tt-lshiftdivc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] LSHIFT#DIVC ``` #### `A9D8tt` LSHIFTMOD [#a9d8tt-lshiftmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] LSHIFT#MOD ``` #### `A9D9tt` LSHIFTMODR [#a9d9tt-lshiftmodr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] LSHIFT#MODR ``` #### `A9DAtt` LSHIFTMODC [#a9datt-lshiftmodc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] LSHIFT#MODC ``` #### `A9DCtt` LSHIFTDIVMOD [#a9dctt-lshiftdivmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] LSHIFT#DIVMOD ``` #### `A9DDtt` LSHIFTDIVMODR [#a9ddtt-lshiftdivmodr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] LSHIFT#DIVMODR ``` #### `A9DEtt` LSHIFTDIVMODC [#a9dett-lshiftdivmodc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift" [tt+1] LSHIFT#DIVMODC ``` #### `AAcc` LSHIFT [#aacc-lshift] `0 <= cc <= 255`
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" [cc+1] LSHIFT# ``` #### `ABcc` RSHIFT [#abcc-rshift] `0 <= cc <= 255`
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" [cc+1] RSHIFT# ``` #### `AC` LSHIFT\_VAR [#ac-lshift_var] `0 <= y <= 1023`
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" LSHIFT ``` #### `AD` RSHIFT\_VAR [#ad-rshift_var] `0 <= y <= 1023`
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" RSHIFT ``` #### `AE` POW2 [#ae-pow2] `0 <= y <= 1023`
Equivalent to `ONE` `SWAP` `LSHIFT`.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" POW2 ``` #### `B0` AND [#b0-and] Bitwise and of two signed integers `x` and `y`, sign-extended to infinity.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" AND ``` #### `B1` OR [#b1-or] Bitwise or of two integers.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" OR ``` #### `B2` XOR [#b2-xor] Bitwise xor of two integers.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" XOR ``` #### `B3` NOT [#b3-not] Bitwise not of an integer.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" NOT ``` #### `B4cc` FITS [#b4cc-fits] Checks whether `x` is a `cc+1`-bit signed integer for `0 <= cc <= 255` (i.e., whether `-2^cc <= x < 2^cc`).
If not, either triggers an integer overflow exception, or replaces `x` with a `NaN` (quiet version).
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" [cc+1] FITS ``` **Aliases**: * `CHKBOOL`
Checks whether `x` is a ''boolean value'' (i.e., either 0 or -1). #### `B5cc` UFITS [#b5cc-ufits] Checks whether `x` is a `cc+1`-bit unsigned integer for `0 <= cc <= 255` (i.e., whether `0 <= x < 2^(cc+1)`).
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" [cc+1] UFITS ``` **Aliases**: * `CHKBIT`
Checks whether `x` is a binary digit (i.e., zero or one). #### `B600` FITSX [#b600-fitsx] Checks whether `x` is a `c`-bit signed integer for `0 <= c <= 1023`.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" FITSX ``` #### `B601` UFITSX [#b601-ufitsx] Checks whether `x` is a `c`-bit unsigned integer for `0 <= c <= 1023`.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" UFITSX ``` #### `B602` BITSIZE [#b602-bitsize] Computes smallest `c >= 0` such that `x` fits into a `c`-bit signed integer (`-2^(c-1) <= c < 2^(c-1)`).
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" BITSIZE ``` #### `B603` UBITSIZE [#b603-ubitsize] Computes smallest `c >= 0` such that `x` fits into a `c`-bit unsigned integer (`0 <= x < 2^c`), or throws a range check exception.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" UBITSIZE ``` #### `B608` MIN [#b608-min] Computes the minimum of two integers `x` and `y`.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" MIN ``` #### `B609` MAX [#b609-max] Computes the maximum of two integers `x` and `y`.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" MAX ``` #### `B60A` MINMAX [#b60a-minmax] Sorts two integers. Quiet version of this operation returns two `NaN`s if any of the arguments are `NaN`s.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" MINMAX INTSORT2 ``` #### `B60B` ABS [#b60b-abs] Computes the absolute value of an integer `x`.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift" ABS ``` #### `B7A0` QADD [#b7a0-qadd]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QADD ``` #### `B7A1` QSUB [#b7a1-qsub]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QSUB ``` #### `B7A2` QSUBR [#b7a2-qsubr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QSUBR ``` #### `B7A3` QNEGATE [#b7a3-qnegate]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QNEGATE ``` #### `B7A4` QINC [#b7a4-qinc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QINC ``` #### `B7A5` QDEC [#b7a5-qdec]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QDEC ``` #### `B7A8` QMUL [#b7a8-qmul]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMUL ``` #### `B7A900` QADDDIVMOD [#b7a900-qadddivmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QADDDIVMOD ``` #### `B7A901` QADDDIVMODR [#b7a901-qadddivmodr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QADDDIVMODR ``` #### `B7A902` QADDDIVMODC [#b7a902-qadddivmodc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QADDDIVMODC ``` #### `B7A904` QDIV [#b7a904-qdiv] Division returns `NaN` if `y=0`.
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QDIV ``` #### `B7A905` QDIVR [#b7a905-qdivr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QDIVR ``` #### `B7A906` QDIVC [#b7a906-qdivc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QDIVC ``` #### `B7A908` QMOD [#b7a908-qmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMOD ``` #### `B7A909` QMODR [#b7a909-qmodr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMODR ``` #### `B7A90A` QMODC [#b7a90a-qmodc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMODC ``` #### `B7A90C` QDIVMOD [#b7a90c-qdivmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QDIVMOD ``` #### `B7A90D` QDIVMODR [#b7a90d-qdivmodr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QDIVMODR ``` #### `B7A90E` QDIVMODC [#b7a90e-qdivmodc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QDIVMODC ``` #### `B7A920` QADDRSHIFTMOD [#b7a920-qaddrshiftmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QADDRSHIFTMOD ``` #### `B7A921` QADDRSHIFTMODR [#b7a921-qaddrshiftmodr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QADDRSHIFTMODR ``` #### `B7A922` QADDRSHIFTMODC [#b7a922-qaddrshiftmodc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QADDRSHIFTMODC ``` #### `B7A925` QRSHIFTR\_VAR [#b7a925-qrshiftr_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QRSHIFTR ``` #### `B7A926` QRSHIFTC\_VAR [#b7a926-qrshiftc_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QRSHIFTC ``` #### `B7A928` QMODPOW2\_VAR [#b7a928-qmodpow2_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMODPOW2 ``` #### `B7A929` QMODPOW2R\_VAR [#b7a929-qmodpow2r_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMODPOW2R ``` #### `B7A92A` QMODPOW2C\_VAR [#b7a92a-qmodpow2c_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMODPOW2C ``` #### `B7A92C` QRSHIFTMOD\_VAR [#b7a92c-qrshiftmod_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QRSHIFTMOD ``` #### `B7A92D` QRSHIFTMODR\_VAR [#b7a92d-qrshiftmodr_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QRSHIFTMODR ``` #### `B7A92E` QRSHIFTMODC\_VAR [#b7a92e-qrshiftmodc_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QRSHIFTMODC ``` #### `B7A930tt` QADDRSHIFTMOD [#b7a930tt-qaddrshiftmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QADDRSHIFT#MOD ``` #### `B7A931tt` QADDRSHIFTRMOD [#b7a931tt-qaddrshiftrmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QADDRSHIFTR#MOD ``` #### `B7A932tt` QADDRSHIFTCMOD [#b7a932tt-qaddrshiftcmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QADDRSHIFTC#MOD ``` #### `B7A935tt` QRSHIFTR [#b7a935tt-qrshiftr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QRSHIFTR# ``` #### `B7A936tt` QRSHIFTC [#b7a936tt-qrshiftc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QRSHIFTC# ``` #### `B7A938tt` QMODPOW2 [#b7a938tt-qmodpow2]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QMODPOW2# ``` #### `B7A939tt` QMODPOW2R [#b7a939tt-qmodpow2r]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QMODPOW2R# ``` #### `B7A93Att` QMODPOW2C [#b7a93att-qmodpow2c]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QMODPOW2C# ``` #### `B7A93Ctt` QRSHIFTMOD [#b7a93ctt-qrshiftmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QRSHIFT#MOD ``` #### `B7A93Dtt` QRSHIFTRMOD [#b7a93dtt-qrshiftrmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QRSHIFTR#MOD ``` #### `B7A93Ett` QRSHIFTCMOD [#b7a93ett-qrshiftcmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QRSHIFTC#MOD ``` #### `B7A980` QMULADDDIVMOD [#b7a980-qmuladddivmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULADDDIVMOD ``` #### `B7A981` QMULADDDIVMODR [#b7a981-qmuladddivmodr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULADDDIVMODR ``` #### `B7A982` QMULADDDIVMODC [#b7a982-qmuladddivmodc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULADDDIVMODC ``` #### `B7A984` QMULDIV [#b7a984-qmuldiv] `q=floor(x*y/z)`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULDIV ``` #### `B7A985` QMULDIVR [#b7a985-qmuldivr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULDIVR ``` #### `B7A986` QMULDIVC [#b7a986-qmuldivc] `q'=ceil(x*y/z)`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULDIVC ``` #### `B7A988` QMULMOD [#b7a988-qmulmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULMOD ``` #### `B7A989` QMULMODR [#b7a989-qmulmodr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULMODR ``` #### `B7A98A` QMULMODC [#b7a98a-qmulmodc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULMODC ``` #### `B7A98C` QMULDIVMOD [#b7a98c-qmuldivmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULDIVMOD ``` #### `B7A98D` QMULDIVMODR [#b7a98d-qmuldivmodr] `q=round(x*y/z)`, `r=x*y-z*q`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULDIVMODR ``` #### `B7A98E` QMULDIVMODC [#b7a98e-qmuldivmodc] `q=ceil(x*y/z)`, `r=x*y-z*q`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULDIVMODC ``` #### `B7A9A0` QMULADDRSHIFTMOD\_VAR [#b7a9a0-qmuladdrshiftmod_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULADDRSHIFTMOD ``` #### `B7A9A1` QMULADDRSHIFTRMOD\_VAR [#b7a9a1-qmuladdrshiftrmod_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULADDRSHIFTRMOD ``` #### `B7A9A2` QMULADDRSHIFTCMOD\_VAR [#b7a9a2-qmuladdrshiftcmod_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULADDRSHIFTCMOD ``` #### `B7A9A4` QMULRSHIFT\_VAR [#b7a9a4-qmulrshift_var] `0 <= z <= 256`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULRSHIFT ``` #### `B7A9A5` QMULRSHIFTR\_VAR [#b7a9a5-qmulrshiftr_var] `0 <= z <= 256`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULRSHIFTR ``` #### `B7A9A6` QMULRSHIFTC\_VAR [#b7a9a6-qmulrshiftc_var] `0 <= z <= 256`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULRSHIFTC ``` #### `B7A9A8` QMULMODPOW2\_VAR [#b7a9a8-qmulmodpow2_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULMODPOW2_VAR ``` #### `B7A9A9` QMULMODPOW2R\_VAR [#b7a9a9-qmulmodpow2r_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULMODPOW2R_VAR ``` #### `B7A9AA` QMULMODPOW2C\_VAR [#b7a9aa-qmulmodpow2c_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULMODPOW2C_VAR ``` #### `B7A9AC` QMULRSHIFTMOD\_VAR [#b7a9ac-qmulrshiftmod_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULRSHIFTMOD_VAR ``` #### `B7A9AD` QMULRSHIFTRMOD\_VAR [#b7a9ad-qmulrshiftrmod_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULRSHIFTRMOD_VAR ``` #### `B7A9AE` QMULRSHIFTCMOD\_VAR [#b7a9ae-qmulrshiftcmod_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULRSHIFTCMOD_VAR ``` #### `B7A9B0tt` QMULADDRSHIFTMOD [#b7a9b0tt-qmuladdrshiftmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QMULADDRSHIFT#MOD ``` #### `B7A9B1tt` QMULADDRSHIFTRMOD [#b7a9b1tt-qmuladdrshiftrmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QMULADDRSHIFTR#MOD ``` #### `B7A9B2tt` QMULADDRSHIFTCMOD [#b7a9b2tt-qmuladdrshiftcmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QMULADDRSHIFTC#MOD ``` #### `B7A9B4tt` QMULRSHIFT [#b7a9b4tt-qmulrshift]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QMULRSHIFT# ``` #### `B7A9B5tt` QMULRSHIFTR [#b7a9b5tt-qmulrshiftr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QMULRSHIFTR# ``` #### `B7A9B6tt` QMULRSHIFTC [#b7a9b6tt-qmulrshiftc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QMULRSHIFTC# ``` #### `B7A9B8tt` QMULMODPOW2 [#b7a9b8tt-qmulmodpow2]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QMULMODPOW2# ``` #### `B7A9B9tt` QMULMODPOW2R [#b7a9b9tt-qmulmodpow2r]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QMULMODPOW2R# ``` #### `B7A9BAtt` QMULMODPOW2C [#b7a9batt-qmulmodpow2c]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QMULMODPOW2C# ``` #### `B7A9BC` QMULRSHIFTMOD [#b7a9bc-qmulrshiftmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULRSHIFT#MOD ``` #### `B7A9BD` QMULRSHIFTRMOD [#b7a9bd-qmulrshiftrmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULRSHIFTR#MOD ``` #### `B7A9BE` QMULRSHIFTCMOD [#b7a9be-qmulrshiftcmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QMULRSHIFTC#MOD ``` #### `B7A9C0` QLSHIFTADDDIVMOD\_VAR [#b7a9c0-qlshiftadddivmod_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QLSHIFTADDDIVMOD ``` #### `B7A9C1` QLSHIFTADDDIVMODR\_VAR [#b7a9c1-qlshiftadddivmodr_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QLSHIFTADDDIVMODR ``` #### `B7A9C2` QLSHIFTADDDIVMODC\_VAR [#b7a9c2-qlshiftadddivmodc_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QLSHIFTADDDIVMODC ``` #### `B7A9C4` QLSHIFTDIV\_VAR [#b7a9c4-qlshiftdiv_var] `0 <= z <= 256`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QLSHIFTDIV ``` #### `B7A9C5` QLSHIFTDIVR\_VAR [#b7a9c5-qlshiftdivr_var] `0 <= z <= 256`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QLSHIFTDIVR ``` #### `B7A9C6` QLSHIFTDIVC\_VAR [#b7a9c6-qlshiftdivc_var] `0 <= z <= 256`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QLSHIFTDIVC ``` #### `B7A9C8` QLSHIFTMOD\_VAR [#b7a9c8-qlshiftmod_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QLSHIFTMOD ``` #### `B7A9C9` QLSHIFTMODR\_VAR [#b7a9c9-qlshiftmodr_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QLSHIFTMODR ``` #### `B7A9CA` QLSHIFTMODC\_VAR [#b7a9ca-qlshiftmodc_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QLSHIFTMODC ``` #### `B7A9CC` QLSHIFTDIVMOD\_VAR [#b7a9cc-qlshiftdivmod_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QLSHIFTDIVMOD ``` #### `B7A9CD` QLSHIFTDIVMODR\_VAR [#b7a9cd-qlshiftdivmodr_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QLSHIFTDIVMODR ``` #### `B7A9CE` QLSHIFTDIVMODC\_VAR [#b7a9ce-qlshiftdivmodc_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QLSHIFTDIVMODC ``` #### `B7A9D0tt` QLSHIFTADDDIVMOD [#b7a9d0tt-qlshiftadddivmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QLSHIFT#ADDDIVMOD ``` #### `B7A9D1tt` QLSHIFTADDDIVMODR [#b7a9d1tt-qlshiftadddivmodr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QLSHIFT#ADDDIVMODR ``` #### `B7A9D2tt` QLSHIFTADDDIVMODC [#b7a9d2tt-qlshiftadddivmodc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QLSHIFT#ADDDIVMODC ``` #### `B7A9D4tt` QLSHIFTDIV [#b7a9d4tt-qlshiftdiv]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QLSHIFT#DIV ``` #### `B7A9D5tt` QLSHIFTDIVR [#b7a9d5tt-qlshiftdivr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QLSHIFT#DIVR ``` #### `B7A9D6tt` QLSHIFTDIVC [#b7a9d6tt-qlshiftdivc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QLSHIFT#DIVC ``` #### `B7A9D8tt` QLSHIFTMOD [#b7a9d8tt-qlshiftmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QLSHIFT#MOD ``` #### `B7A9D9tt` QLSHIFTMODR [#b7a9d9tt-qlshiftmodr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QLSHIFT#MODR ``` #### `B7A9DAtt` QLSHIFTMODC [#b7a9datt-qlshiftmodc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QLSHIFT#MODC ``` #### `B7A9DCtt` QLSHIFTDIVMOD [#b7a9dctt-qlshiftdivmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QLSHIFT#DIVMOD ``` #### `B7A9DDtt` QLSHIFTDIVMODR [#b7a9ddtt-qlshiftdivmodr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QLSHIFT#DIVMODR ``` #### `B7A9DEtt` QLSHIFTDIVMODC [#b7a9dett-qlshiftdivmodc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [tt+1] QLSHIFT#DIVMODC ``` #### `B7AAcc` QLSHIFT [#b7aacc-qlshift] `0 <= cc <= 255`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [cc+1] QLSHIFT# ``` #### `B7ABcc` QRSHIFT [#b7abcc-qrshift] `0 <= cc <= 255`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [cc+1] QRSHIFT# ``` #### `B7AC` QLSHIFT\_VAR [#b7ac-qlshift_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QLSHIFT ``` #### `B7AD` QRSHIFT\_VAR [#b7ad-qrshift_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QRSHIFT ``` #### `B7AE` QPOW2 [#b7ae-qpow2]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QPOW2 ``` #### `B7B0` QAND [#b7b0-qand]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QAND ``` #### `B7B1` QOR [#b7b1-qor]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QOR ``` #### `B7B2` QXOR [#b7b2-qxor]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QXOR ``` #### `B7B3` QNOT [#b7b3-qnot]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QNOT ``` #### `B7B4cc` QFITS [#b7b4cc-qfits] Replaces `x` with a `NaN` if x is not a `cc+1`-bit signed integer, leaves it intact otherwise.
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [cc+1] QFITS ``` #### `B7B5cc` QUFITS [#b7b5cc-qufits] Replaces `x` with a `NaN` if x is not a `cc+1`-bit unsigned integer, leaves it intact otherwise.
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" [cc+1] QUFITS ``` #### `B7B600` QFITSX [#b7b600-qfitsx] Replaces `x` with a `NaN` if x is not a c-bit signed integer, leaves it intact otherwise.
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QFITSX ``` #### `B7B601` QUFITSX [#b7b601-qufitsx] Replaces `x` with a `NaN` if x is not a c-bit unsigned integer, leaves it intact otherwise.
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift" QUFITSX ``` #### `B8` SGN [#b8-sgn] Computes the sign of an integer `x`:
`-1` if `x<0`, `0` if `x=0`, `1` if `x>0`.
**Category:** Compare Int (compare\_int)
```fift title="Fift" SGN ``` #### `B9` LESS [#b9-less] Returns `-1` if `x
```fift title="Fift" LESS ``` #### `BA` EQUAL [#ba-equal] Returns `-1` if `x=y`, `0` otherwise.
**Category:** Compare Int (compare\_int)
```fift title="Fift" EQUAL ``` #### `BB` LEQ [#bb-leq]
**Category:** Compare Int (compare\_int)
```fift title="Fift" LEQ ``` #### `BC` GREATER [#bc-greater]
**Category:** Compare Int (compare\_int)
```fift title="Fift" GREATER ``` #### `BD` NEQ [#bd-neq] Equivalent to `EQUAL` `NOT`.
**Category:** Compare Int (compare\_int)
```fift title="Fift" NEQ ``` #### `BE` GEQ [#be-geq] Equivalent to `LESS` `NOT`.
**Category:** Compare Int (compare\_int)
```fift title="Fift" GEQ ``` #### `BF` CMP [#bf-cmp] Computes the sign of `x-y`:
`-1` if `x
No integer overflow can occur here unless `x` or `y` is a `NaN`.
**Category:** Compare Int (compare\_int)
```fift title="Fift" CMP ``` #### `C0yy` EQINT [#c0yy-eqint] Returns `-1` if `x=yy`, `0` otherwise.
`-2^7 <= yy < 2^7`.
**Category:** Compare Int (compare\_int)
```fift title="Fift" [yy] EQINT ``` **Aliases**: * `ISZERO`
Checks whether an integer is zero. Corresponds to Forth's `0=`. #### `C1yy` LESSINT [#c1yy-lessint] Returns `-1` if `x
**Category:** Compare Int (compare\_int)
```fift title="Fift" [yy] LESSINT [yy-1] LEQINT ``` **Aliases**: * `ISNEG`
Checks whether an integer is negative. Corresponds to Forth's `0<`. * `ISNPOS`
Checks whether an integer is non-positive. #### `C2yy` GTINT [#c2yy-gtint] Returns `-1` if `x>yy`, `0` otherwise.
`-2^7 <= yy < 2^7`.
**Category:** Compare Int (compare\_int)
```fift title="Fift" [yy] GTINT [yy+1] GEQINT ``` **Aliases**: * `ISPOS`
Checks whether an integer is positive. Corresponds to Forth's `0>`. * `ISNNEG`
Checks whether an integer is non-negative. #### `C3yy` NEQINT [#c3yy-neqint] Returns `-1` if `x!=yy`, `0` otherwise.
`-2^7 <= yy < 2^7`.
**Category:** Compare Int (compare\_int)
```fift title="Fift" [yy] NEQINT ``` #### `C4` ISNAN [#c4-isnan] Checks whether `x` is a `NaN`.
**Category:** Compare Int (compare\_int)
```fift title="Fift" ISNAN ``` #### `C5` CHKNAN [#c5-chknan] Throws an arithmetic overflow exception if `x` is a `NaN`.
**Category:** Compare Int (compare\_int)
```fift title="Fift" CHKNAN ``` #### `C700` SEMPTY [#c700-sempty] Checks whether a *Slice* `s` is empty (i.e., contains no bits of data and no cell references).
**Category:** Compare Other (compare\_other)
```fift title="Fift" SEMPTY ``` #### `C701` SDEMPTY [#c701-sdempty] Checks whether *Slice* `s` has no bits of data.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDEMPTY ``` #### `C702` SREMPTY [#c702-srempty] Checks whether *Slice* `s` has no references.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SREMPTY ``` #### `C703` SDFIRST [#c703-sdfirst] Checks whether the first bit of *Slice* `s` is a one.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDFIRST ``` #### `C704` SDLEXCMP [#c704-sdlexcmp] Compares the data of `s` lexicographically with the data of `s'`, returning `-1`, 0, or 1 depending on the result.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDLEXCMP ``` #### `C705` SDEQ [#c705-sdeq] Checks whether the data parts of `s` and `s'` coincide, equivalent to `SDLEXCMP` `ISZERO`.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDEQ ``` #### `C708` SDPFX [#c708-sdpfx] Checks whether `s` is a prefix of `s'`.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDPFX ``` #### `C709` SDPFXREV [#c709-sdpfxrev] Checks whether `s'` is a prefix of `s`, equivalent to `SWAP` `SDPFX`.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDPFXREV ``` #### `C70A` SDPPFX [#c70a-sdppfx] Checks whether `s` is a proper prefix of `s'` (i.e., a prefix distinct from `s'`).
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDPPFX ``` #### `C70B` SDPPFXREV [#c70b-sdppfxrev] Checks whether `s'` is a proper prefix of `s`.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDPPFXREV ``` #### `C70C` SDSFX [#c70c-sdsfx] Checks whether `s` is a suffix of `s'`.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDSFX ``` #### `C70D` SDSFXREV [#c70d-sdsfxrev] Checks whether `s'` is a suffix of `s`.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDSFXREV ``` #### `C70E` SDPSFX [#c70e-sdpsfx] Checks whether `s` is a proper suffix of `s'`.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDPSFX ``` #### `C70F` SDPSFXREV [#c70f-sdpsfxrev] Checks whether `s'` is a proper suffix of `s`.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDPSFXREV ``` #### `C710` SDCNTLEAD0 [#c710-sdcntlead0] Returns the number of leading zeroes in `s`.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDCNTLEAD0 ``` #### `C711` SDCNTLEAD1 [#c711-sdcntlead1] Returns the number of leading ones in `s`.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDCNTLEAD1 ``` #### `C712` SDCNTTRAIL0 [#c712-sdcnttrail0] Returns the number of trailing zeroes in `s`.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDCNTTRAIL0 ``` #### `C713` SDCNTTRAIL1 [#c713-sdcnttrail1] Returns the number of trailing ones in `s`.
**Category:** Compare Other (compare\_other)
```fift title="Fift" SDCNTTRAIL1 ``` #### `C8` NEWC [#c8-newc] Creates a new empty *Builder*.
**Category:** Cell Build (cell\_build)
```fift title="Fift" NEWC ``` #### `C9` ENDC [#c9-endc] Converts a *Builder* into an ordinary *Cell*.
**Category:** Cell Build (cell\_build)
```fift title="Fift" ENDC ``` #### `CAcc` STI [#cacc-sti] Stores a signed `cc+1`-bit integer `x` into *Builder* `b` for `0 <= cc <= 255`, throws a range check exception if `x` does not fit into `cc+1` bits.
**Category:** Cell Build (cell\_build)
```fift title="Fift" [cc+1] STI ``` #### `CBcc` STU [#cbcc-stu] Stores an unsigned `cc+1`-bit integer `x` into *Builder* `b`. In all other respects it is similar to `STI`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" [cc+1] STU ``` #### `CC` STREF [#cc-stref] Stores a reference to *Cell* `c` into *Builder* `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STREF ``` #### `CD` STBREFR [#cd-stbrefr] Equivalent to `ENDC` `SWAP` `STREF`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STBREFR ENDCST ``` #### `CE` STSLICE [#ce-stslice] Stores *Slice* `s` into *Builder* `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STSLICE ``` **Aliases**: * `STDICTS`
Stores a *Slice*-represented dictionary `s` into *Builder* `b`.
It is actually a synonym for `STSLICE`. #### `CF00` STIX [#cf00-stix] Stores a signed `l`-bit integer `x` into `b` for `0 <= l <= 257`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STIX ``` #### `CF01` STUX [#cf01-stux] Stores an unsigned `l`-bit integer `x` into `b` for `0 <= l <= 256`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STUX ``` #### `CF02` STIXR [#cf02-stixr] Similar to `STIX`, but with arguments in a different order.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STIXR ``` #### `CF03` STUXR [#cf03-stuxr] Similar to `STUX`, but with arguments in a different order.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STUXR ``` #### `CF04` STIXQ [#cf04-stixq] A quiet version of `STIX`. If there is no space in `b`, sets `b'=b` and `f=-1`.
If `x` does not fit into `l` bits, sets `b'=b` and `f=1`.
If the operation succeeds, `b'` is the new *Builder* and `f=0`.
However, `0 <= l <= 257`, with a range check exception if this is not so.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STIXQ ``` #### `CF05` STUXQ [#cf05-stuxq] A quiet version of `STUX`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STUXQ ``` #### `CF06` STIXRQ [#cf06-stixrq] A quiet version of `STIXR`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STIXRQ ``` #### `CF07` STUXRQ [#cf07-stuxrq] A quiet version of `STUXR`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STUXRQ ``` #### `CF08cc` STI\_ALT [#cf08cc-sti_alt] A longer version of `[cc+1] STI`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" [cc+1] STI_l ``` #### `CF09cc` STU\_ALT [#cf09cc-stu_alt] A longer version of `[cc+1] STU`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" [cc+1] STU_l ``` #### `CF0Acc` STIR [#cf0acc-stir] Equivalent to `SWAP` `[cc+1] STI`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" [cc+1] STIR ``` #### `CF0Bcc` STUR [#cf0bcc-stur] Equivalent to `SWAP` `[cc+1] STU`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" [cc+1] STUR ``` #### `CF0Ccc` STIQ [#cf0ccc-stiq] A quiet version of `STI`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" [cc+1] STIQ ``` #### `CF0Dcc` STUQ [#cf0dcc-stuq] A quiet version of `STU`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" [cc+1] STUQ ``` #### `CF0Ecc` STIRQ [#cf0ecc-stirq] A quiet version of `STIR`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" [cc+1] STIRQ ``` #### `CF0Fcc` STURQ [#cf0fcc-sturq] A quiet version of `STUR`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" [cc+1] STURQ ``` #### `CF10` STREF\_ALT [#cf10-stref_alt] A longer version of `STREF`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STREF_l ``` #### `CF11` STBREF [#cf11-stbref] Equivalent to `SWAP` `STBREFR`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STBREF ``` #### `CF12` STSLICE\_ALT [#cf12-stslice_alt] A longer version of `STSLICE`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STSLICE_l ``` #### `CF13` STB [#cf13-stb] Appends all data from *Builder* `b'` to *Builder* `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STB ``` #### `CF14` STREFR [#cf14-strefr] Equivalent to `SWAP` `STREF`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STREFR ``` #### `CF15` STBREFR\_ALT [#cf15-stbrefr_alt] A longer encoding of `STBREFR`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STBREFR_l ``` #### `CF16` STSLICER [#cf16-stslicer] Equivalent to `SWAP` `STSLICE`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STSLICER ``` #### `CF17` STBR [#cf17-stbr] Concatenates two builders.
Equivalent to `SWAP` `STB`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STBR BCONCAT ``` #### `CF18` STREFQ [#cf18-strefq] Quiet version of `STREF`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STREFQ ``` #### `CF19` STBREFQ [#cf19-stbrefq] Quiet version of `STBREF`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STBREFQ ``` #### `CF1A` STSLICEQ [#cf1a-stsliceq] Quiet version of `STSLICE`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STSLICEQ ``` #### `CF1B` STBQ [#cf1b-stbq] Quiet version of `STB`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STBQ ``` #### `CF1C` STREFRQ [#cf1c-strefrq] Quiet version of `STREFR`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STREFRQ ``` #### `CF1D` STBREFRQ [#cf1d-stbrefrq] Quiet version of `STBREFR`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STBREFRQ ``` #### `CF1E` STSLICERQ [#cf1e-stslicerq] Quiet version of `STSLICER`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STSLICERQ ``` #### `CF1F` STBRQ [#cf1f-stbrq] Quiet version of `STBR`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STBRQ BCONCATQ ``` #### `CF20` STREFCONST [#cf20-strefconst] Equivalent to `PUSHREF` `STREFR`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" [ref] STREFCONST ``` #### `CF21` STREF2CONST [#cf21-stref2const] Equivalent to `STREFCONST` `STREFCONST`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" [ref] [ref] STREF2CONST ``` #### `CF23` ENDXC [#cf23-endxc] If `x!=0`, creates a *special* or *exotic* cell from *Builder* `b`.
The type of the exotic cell must be stored in the first 8 bits of `b`.
If `x=0`, it is equivalent to `ENDC`. Otherwise some validity checks on the data and references of `b` are performed before creating the exotic cell.
**Category:** Cell Build (cell\_build)
```fift title="Fift" ENDXC ``` #### `CF28` STILE4 [#cf28-stile4] Stores a little-endian signed 32-bit integer.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STILE4 ``` #### `CF29` STULE4 [#cf29-stule4] Stores a little-endian unsigned 32-bit integer.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STULE4 ``` #### `CF2A` STILE8 [#cf2a-stile8] Stores a little-endian signed 64-bit integer.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STILE8 ``` #### `CF2B` STULE8 [#cf2b-stule8] Stores a little-endian unsigned 64-bit integer.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STULE8 ``` #### `CF30` BDEPTH [#cf30-bdepth] Returns the depth of *Builder* `b`. If no cell references are stored in `b`, then `x=0`; otherwise `x` is one plus the maximum of depths of cells referred to from `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" BDEPTH ``` #### `CF31` BBITS [#cf31-bbits] Returns the number of data bits already stored in *Builder* `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" BBITS ``` #### `CF32` BREFS [#cf32-brefs] Returns the number of cell references already stored in `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" BREFS ``` #### `CF33` BBITREFS [#cf33-bbitrefs] Returns the numbers of both data bits and cell references in `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" BBITREFS ``` #### `CF35` BREMBITS [#cf35-brembits] Returns the number of data bits that can still be stored in `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" BREMBITS ``` #### `CF36` BREMREFS [#cf36-bremrefs] Returns the number of references that can still be stored in `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" BREMREFS ``` #### `CF37` BREMBITREFS [#cf37-brembitrefs] Returns the numbers of both data bits and references that can still be stored in `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" BREMBITREFS ``` #### `CF38cc` BCHKBITS [#cf38cc-bchkbits] Checks whether `cc+1` bits can be stored into `b`, where `0 <= cc <= 255`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" [cc+1] BCHKBITS# ``` #### `CF39` BCHKBITS\_VAR [#cf39-bchkbits_var] Checks whether `x` bits can be stored into `b`, `0 <= x <= 1023`. If there is no space for `x` more bits in `b`, or if `x` is not within the range `0...1023`, throws an exception.
**Category:** Cell Build (cell\_build)
```fift title="Fift" BCHKBITS ``` #### `CF3A` BCHKREFS [#cf3a-bchkrefs] Checks whether `y` references can be stored into `b`, `0 <= y <= 7`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" BCHKREFS ``` #### `CF3B` BCHKBITREFS [#cf3b-bchkbitrefs] Checks whether `x` bits and `y` references can be stored into `b`, `0 <= x <= 1023`, `0 <= y <= 7`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" BCHKBITREFS ``` #### `CF3Ccc` BCHKBITSQ [#cf3ccc-bchkbitsq] Checks whether `cc+1` bits can be stored into `b`, where `0 <= cc <= 255`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" [cc+1] BCHKBITSQ# ``` #### `CF3D` BCHKBITSQ\_VAR [#cf3d-bchkbitsq_var] Checks whether `x` bits can be stored into `b`, `0 <= x <= 1023`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" BCHKBITSQ ``` #### `CF3E` BCHKREFSQ [#cf3e-bchkrefsq] Checks whether `y` references can be stored into `b`, `0 <= y <= 7`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" BCHKREFSQ ``` #### `CF3F` BCHKBITREFSQ [#cf3f-bchkbitrefsq] Checks whether `x` bits and `y` references can be stored into `b`, `0 <= x <= 1023`, `0 <= y <= 7`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" BCHKBITREFSQ ``` #### `CF40` STZEROES [#cf40-stzeroes] Stores `n` binary zeroes into *Builder* `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STZEROES ``` #### `CF41` STONES [#cf41-stones] Stores `n` binary ones into *Builder* `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STONES ``` #### `CF42` STSAME [#cf42-stsame] Stores `n` binary `x`es (`0 <= x <= 1`) into *Builder* `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift" STSAME ``` #### `CF50` BTOS [#cf50-btos] Same as `ENDC CTOS`, but without gas cost for cell creation and loading.
**Category:** Cell Build (cell\_build)
```fift title="Fift" BTOS ``` #### `CFC_xysss` STSLICECONST [#cfc_xysss-stsliceconst] Stores a constant subslice `sss`.
*Details:* `sss` consists of `0 <= x <= 3` references and up to `8y+2` data bits, with `0 <= y <= 7`. Completion bit is assumed.
Note that the assembler can replace `STSLICECONST` with `PUSHSLICE` `STSLICER` if the slice is too big.
**Category:** Cell Build (cell\_build)
```fift title="Fift" [slice] STSLICECONST ``` **Aliases**: * `STZERO`
Stores one binary zero. * `STONE`
Stores one binary one. #### `D0` CTOS [#d0-ctos] Converts a *Cell* into a *Slice*. Notice that `c` must be either an ordinary cell, or an exotic cell which is automatically *loaded* to yield an ordinary cell `c'`, converted into a *Slice* afterwards.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" CTOS ``` #### `D1` ENDS [#d1-ends] Removes a *Slice* `s` from the stack, and throws an exception if it is not empty.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" ENDS ``` #### `D2cc` LDI [#d2cc-ldi] Loads (i.e., parses) a signed `cc+1`-bit integer `x` from *Slice* `s`, and returns the remainder of `s` as `s'`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [cc+1] LDI ``` #### `D3cc` LDU [#d3cc-ldu] Loads an unsigned `cc+1`-bit integer `x` from *Slice* `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [cc+1] LDU ``` #### `D4` LDREF [#d4-ldref] Loads a cell reference `c` from `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDREF ``` #### `D5` LDREFRTOS [#d5-ldrefrtos] Equivalent to `LDREF` `SWAP` `CTOS`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDREFRTOS ``` #### `D6cc` LDSLICE [#d6cc-ldslice] Cuts the next `cc+1` bits of `s` into a separate *Slice* `s''`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [cc+1] LDSLICE ``` #### `D700` LDIX [#d700-ldix] Loads a signed `l`-bit (`0 <= l <= 257`) integer `x` from *Slice* `s`, and returns the remainder of `s` as `s'`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDIX ``` #### `D701` LDUX [#d701-ldux] Loads an unsigned `l`-bit integer `x` from (the first `l` bits of) `s`, with `0 <= l <= 256`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDUX ``` #### `D702` PLDIX [#d702-pldix] Preloads a signed `l`-bit integer from *Slice* `s`, for `0 <= l <= 257`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" PLDIX ``` #### `D703` PLDUX [#d703-pldux] Preloads an unsigned `l`-bit integer from `s`, for `0 <= l <= 256`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" PLDUX ``` #### `D704` LDIXQ [#d704-ldixq] Quiet version of `LDIX`: loads a signed `l`-bit integer from `s` similarly to `LDIX`, but returns a success flag, equal to `-1` on success or to `0` on failure (if `s` does not have `l` bits), instead of throwing a cell underflow exception.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDIXQ ``` #### `D705` LDUXQ [#d705-lduxq] Quiet version of `LDUX`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDUXQ ``` #### `D706` PLDIXQ [#d706-pldixq] Quiet version of `PLDIX`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" PLDIXQ ``` #### `D707` PLDUXQ [#d707-plduxq] Quiet version of `PLDUX`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" PLDUXQ ``` #### `D708cc` LDI\_ALT [#d708cc-ldi_alt] A longer encoding for `LDI`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [cc+1] LDI_l ``` #### `D709cc` LDU\_ALT [#d709cc-ldu_alt] A longer encoding for `LDU`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [cc+1] LDU_l ``` #### `D70Acc` PLDI [#d70acc-pldi] Preloads a signed `cc+1`-bit integer from *Slice* `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [cc+1] PLDI ``` #### `D70Bcc` PLDU [#d70bcc-pldu] Preloads an unsigned `cc+1`-bit integer from `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [cc+1] PLDU ``` #### `D70Ccc` LDIQ [#d70ccc-ldiq] A quiet version of `LDI`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [cc+1] LDIQ ``` #### `D70Dcc` LDUQ [#d70dcc-lduq] A quiet version of `LDU`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [cc+1] LDUQ ``` #### `D70Ecc` PLDIQ [#d70ecc-pldiq] A quiet version of `PLDI`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [cc+1] PLDIQ ``` #### `D70Fcc` PLDUQ [#d70fcc-plduq] A quiet version of `PLDU`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [cc+1] PLDUQ ``` #### `D714_c` PLDUZ [#d714_c-plduz] Preloads the first `32(c+1)` bits of *Slice* `s` into an unsigned integer `x`, for `0 <= c <= 7`. If `s` is shorter than necessary, missing bits are assumed to be zero. This operation is intended to be used along with `IFBITJMP` and similar instructions.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [32(c+1)] PLDUZ ``` #### `D718` LDSLICEX [#d718-ldslicex] Loads the first `0 <= l <= 1023` bits from *Slice* `s` into a separate *Slice* `s''`, returning the remainder of `s` as `s'`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDSLICEX ``` #### `D719` PLDSLICEX [#d719-pldslicex] Returns the first `0 <= l <= 1023` bits of `s` as `s''`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" PLDSLICEX ``` #### `D71A` LDSLICEXQ [#d71a-ldslicexq] A quiet version of `LDSLICEX`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDSLICEXQ ``` #### `D71B` PLDSLICEXQ [#d71b-pldslicexq] A quiet version of `LDSLICEXQ`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" PLDSLICEXQ ``` #### `D71Ccc` LDSLICE\_ALT [#d71ccc-ldslice_alt] A longer encoding for `LDSLICE`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [cc+1] LDSLICE_l ``` #### `D71Dcc` PLDSLICE [#d71dcc-pldslice] Returns the first `0 < cc+1 <= 256` bits of `s` as `s''`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [cc+1] PLDSLICE ``` #### `D71Ecc` LDSLICEQ [#d71ecc-ldsliceq] A quiet version of `LDSLICE`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [cc+1] LDSLICEQ ``` #### `D71Fcc` PLDSLICEQ [#d71fcc-pldsliceq] A quiet version of `PLDSLICE`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [cc+1] PLDSLICEQ ``` #### `D720` SDCUTFIRST [#d720-sdcutfirst] Returns the first `0 <= l <= 1023` bits of `s`. It is equivalent to `PLDSLICEX`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SDCUTFIRST ``` #### `D721` SDSKIPFIRST [#d721-sdskipfirst] Returns all but the first `0 <= l <= 1023` bits of `s`. It is equivalent to `LDSLICEX` `NIP`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SDSKIPFIRST ``` #### `D722` SDCUTLAST [#d722-sdcutlast] Returns the last `0 <= l <= 1023` bits of `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SDCUTLAST ``` #### `D723` SDSKIPLAST [#d723-sdskiplast] Returns all but the last `0 <= l <= 1023` bits of `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SDSKIPLAST ``` #### `D724` SDSUBSTR [#d724-sdsubstr] Returns `0 <= l' <= 1023` bits of `s` starting from offset `0 <= l <= 1023`, thus extracting a bit substring out of the data of `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SDSUBSTR ``` #### `D726` SDBEGINSX [#d726-sdbeginsx] Checks whether `s` begins with (the data bits of) `s'`, and removes `s'` from `s` on success. On failure throws a cell deserialization exception. Primitive `SDPFXREV` can be considered a quiet version of `SDBEGINSX`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SDBEGINSX ``` #### `D727` SDBEGINSXQ [#d727-sdbeginsxq] A quiet version of `SDBEGINSX`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SDBEGINSXQ ``` #### `D72A_xsss` SDBEGINS [#d72a_xsss-sdbegins] Checks whether `s` begins with constant bitstring `sss` of length `8x+3` (with continuation bit assumed), where `0 <= x <= 127`, and removes `sss` from `s` on success.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [slice] SDBEGINS ``` #### `D72E_xsss` SDBEGINSQ [#d72e_xsss-sdbeginsq] A quiet version of `SDBEGINS`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [slice] SDBEGINSQ ``` #### `D730` SCUTFIRST [#d730-scutfirst] Returns the first `0 <= l <= 1023` bits and first `0 <= r <= 4` references of `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SCUTFIRST ``` #### `D731` SSKIPFIRST [#d731-sskipfirst] Returns all but the first `l` bits of `s` and `r` references of `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SSKIPFIRST ``` #### `D732` SCUTLAST [#d732-scutlast] Returns the last `0 <= l <= 1023` data bits and last `0 <= r <= 4` references of `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SCUTLAST ``` #### `D733` SSKIPLAST [#d733-sskiplast] Returns all but the last `l` bits of `s` and `r` references of `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SSKIPLAST ``` #### `D734` SUBSLICE [#d734-subslice] Returns `0 <= l' <= 1023` bits and `0 <= r' <= 4` references from *Slice* `s`, after skipping the first `0 <= l <= 1023` bits and first `0 <= r <= 4` references.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SUBSLICE ``` #### `D736` SPLIT [#d736-split] Splits the first `0 <= l <= 1023` data bits and first `0 <= r <= 4` references from `s` into `s'`, returning the remainder of `s` as `s''`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SPLIT ``` #### `D737` SPLITQ [#d737-splitq] A quiet version of `SPLIT`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SPLITQ ``` #### `D739` XCTOS [#d739-xctos] Transforms an ordinary or exotic cell into a *Slice*, as if it were an ordinary cell. A flag is returned indicating whether `c` is exotic. If that be the case, its type can later be deserialized from the first eight bits of `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" XCTOS ``` #### `D73A` XLOAD [#d73a-xload] Loads an exotic cell `c` and returns an ordinary cell `c'`. If `c` is already ordinary, does nothing. If `c` cannot be loaded, throws an exception.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" XLOAD ``` #### `D73B` XLOADQ [#d73b-xloadq] Loads an exotic cell `c` and returns an ordinary cell `c'`. If `c` is already ordinary, does nothing. If `c` cannot be loaded, returns 0.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" XLOADQ ``` #### `D741` SCHKBITS [#d741-schkbits] Checks whether there are at least `l` data bits in *Slice* `s`. If this is not the case, throws a cell deserialisation (i.e., cell underflow) exception.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SCHKBITS ``` #### `D742` SCHKREFS [#d742-schkrefs] Checks whether there are at least `r` references in *Slice* `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SCHKREFS ``` #### `D743` SCHKBITREFS [#d743-schkbitrefs] Checks whether there are at least `l` data bits and `r` references in *Slice* `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SCHKBITREFS ``` #### `D745` SCHKBITSQ [#d745-schkbitsq] Checks whether there are at least `l` data bits in *Slice* `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SCHKBITSQ ``` #### `D746` SCHKREFSQ [#d746-schkrefsq] Checks whether there are at least `r` references in *Slice* `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SCHKREFSQ ``` #### `D747` SCHKBITREFSQ [#d747-schkbitrefsq] Checks whether there are at least `l` data bits and `r` references in *Slice* `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SCHKBITREFSQ ``` #### `D748` PLDREFVAR [#d748-pldrefvar] Returns the `n`-th cell reference of *Slice* `s` for `0 <= n <= 3`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" PLDREFVAR ``` #### `D749` SBITS [#d749-sbits] Returns the number of data bits in *Slice* `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SBITS ``` #### `D74A` SREFS [#d74a-srefs] Returns the number of references in *Slice* `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SREFS ``` #### `D74B` SBITREFS [#d74b-sbitrefs] Returns both the number of data bits and the number of references in `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SBITREFS ``` #### `D74E_n` PLDREFIDX [#d74e_n-pldrefidx] Returns the `n`-th cell reference of *Slice* `s`, where `0 <= n <= 3`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [n] PLDREFIDX ``` **Aliases**: * `PLDREF`
Preloads the first cell reference of a *Slice*. #### `D750` LDILE4 [#d750-ldile4] Loads a little-endian signed 32-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDILE4 ``` #### `D751` LDULE4 [#d751-ldule4] Loads a little-endian unsigned 32-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDULE4 ``` #### `D752` LDILE8 [#d752-ldile8] Loads a little-endian signed 64-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDILE8 ``` #### `D753` LDULE8 [#d753-ldule8] Loads a little-endian unsigned 64-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDULE8 ``` #### `D754` PLDILE4 [#d754-pldile4] Preloads a little-endian signed 32-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" PLDILE4 ``` #### `D755` PLDULE4 [#d755-pldule4] Preloads a little-endian unsigned 32-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" PLDULE4 ``` #### `D756` PLDILE8 [#d756-pldile8] Preloads a little-endian signed 64-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" PLDILE8 ``` #### `D757` PLDULE8 [#d757-pldule8] Preloads a little-endian unsigned 64-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" PLDULE8 ``` #### `D758` LDILE4Q [#d758-ldile4q] Quietly loads a little-endian signed 32-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDILE4Q ``` #### `D759` LDULE4Q [#d759-ldule4q] Quietly loads a little-endian unsigned 32-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDULE4Q ``` #### `D75A` LDILE8Q [#d75a-ldile8q] Quietly loads a little-endian signed 64-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDILE8Q ``` #### `D75B` LDULE8Q [#d75b-ldule8q] Quietly loads a little-endian unsigned 64-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDULE8Q ``` #### `D75C` PLDILE4Q [#d75c-pldile4q] Quietly preloads a little-endian signed 32-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" PLDILE4Q ``` #### `D75D` PLDULE4Q [#d75d-pldule4q] Quietly preloads a little-endian unsigned 32-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" PLDULE4Q ``` #### `D75E` PLDILE8Q [#d75e-pldile8q] Quietly preloads a little-endian signed 64-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" PLDILE8Q ``` #### `D75F` PLDULE8Q [#d75f-pldule8q] Quietly preloads a little-endian unsigned 64-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" PLDULE8Q ``` #### `D760` LDZEROES [#d760-ldzeroes] Returns the count `n` of leading zero bits in `s`, and removes these bits from `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDZEROES ``` #### `D761` LDONES [#d761-ldones] Returns the count `n` of leading one bits in `s`, and removes these bits from `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDONES ``` #### `D762` LDSAME [#d762-ldsame] Returns the count `n` of leading bits equal to `0 <= x <= 1` in `s`, and removes these bits from `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" LDSAME ``` #### `D764` SDEPTH [#d764-sdepth] Returns the depth of *Slice* `s`. If `s` has no references, then `x=0`; otherwise `x` is one plus the maximum of depths of cells referred to from `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" SDEPTH ``` #### `D765` CDEPTH [#d765-cdepth] Returns the depth of *Cell* `c`. If `c` has no references, then `x=0`; otherwise `x` is one plus the maximum of depths of cells referred to from `c`. If `c` is a *Null* instead of a *Cell*, returns zero.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" CDEPTH ``` #### `D766` CLEVEL [#d766-clevel] Returns level of the cell.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" CLEVEL ``` #### `D767` CLEVELMASK [#d767-clevelmask] Returns level mask of the cell.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" CLEVELMASK ``` #### `D76A_` CHASHI [#d76a_-chashi] Returns `i`th hash of the cell.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [i] CHASHI ``` #### `D76E_` CDEPTHI [#d76e_-cdepthi] Returns `i`th depth of the cell.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" [i] CDEPTHI ``` #### `D770` CHASHIX [#d770-chashix] Returns `i`th hash of the cell.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" CHASHIX ``` #### `D771` CDEPTHIX [#d771-cdepthix] Returns `i`th depth of the cell.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift" CDEPTHIX ``` #### `D8` EXECUTE [#d8-execute] *Calls*, or *executes*, continuation `c`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" EXECUTE CALLX ``` #### `D9` JMPX [#d9-jmpx] *Jumps*, or transfers control, to continuation `c`.
The remainder of the previous current continuation `cc` is discarded.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" JMPX ``` #### `DApr` CALLXARGS [#dapr-callxargs] *Calls* continuation `c` with `p` parameters and expecting `r` return values
`0 <= p <= 15`, `0 <= r <= 15`
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" [p] [r] CALLXARGS ``` #### `DB0p` CALLXARGS\_VAR [#db0p-callxargs_var] *Calls* continuation `c` with `0 <= p <= 15` parameters, expecting an arbitrary number of return values.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" [p] -1 CALLXARGS ``` #### `DB1p` JMPXARGS [#db1p-jmpxargs] *Jumps* to continuation `c`, passing only the top `0 <= p <= 15` values from the current stack to it (the remainder of the current stack is discarded).
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" [p] JMPXARGS ``` #### `DB2r` RETARGS [#db2r-retargs] *Returns* to `c0`, with `0 <= r <= 15` return values taken from the current stack.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" [r] RETARGS ``` #### `DB30` RET [#db30-ret] *Returns* to the continuation at `c0`. The remainder of the current continuation `cc` is discarded.
Approximately equivalent to `c0 PUSHCTR` `JMPX`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" RET RETTRUE ``` #### `DB31` RETALT [#db31-retalt] *Returns* to the continuation at `c1`.
Approximately equivalent to `c1 PUSHCTR` `JMPX`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" RETALT RETFALSE ``` #### `DB32` BRANCH [#db32-branch] Performs `RETTRUE` if integer `f!=0`, or `RETFALSE` if `f=0`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" BRANCH RETBOOL ``` #### `DB34` CALLCC [#db34-callcc] *Call with current continuation*, transfers control to `c`, pushing the old value of `cc` into `c`'s stack (instead of discarding it or writing it into new `c0`).
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" CALLCC ``` #### `DB35` JMPXDATA [#db35-jmpxdata] Similar to `CALLCC`, but the remainder of the current continuation (the old value of `cc`) is converted into a *Slice* before pushing it into the stack of `c`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" JMPXDATA ``` #### `DB36pr` CALLCCARGS [#db36pr-callccargs] Similar to `CALLXARGS`, but pushes the old value of `cc` (along with the top `0 <= p <= 15` values from the original stack) into the stack of newly-invoked continuation `c`, setting `cc.nargs` to `-1 <= r <= 14`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" [p] [r] CALLCCARGS ``` #### `DB38` CALLXVARARGS [#db38-callxvarargs] Similar to `CALLXARGS`, but takes `-1 <= p,r <= 254` from the stack. The next three operations also take `p` and `r` from the stack, both in the range `-1...254`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" CALLXVARARGS ``` #### `DB39` RETVARARGS [#db39-retvarargs] Similar to `RETARGS`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" RETVARARGS ``` #### `DB3A` JMPXVARARGS [#db3a-jmpxvarargs] Similar to `JMPXARGS`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" JMPXVARARGS ``` #### `DB3B` CALLCCVARARGS [#db3b-callccvarargs] Similar to `CALLCCARGS`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" CALLCCVARARGS ``` #### `DB3C` CALLREF [#db3c-callref] Equivalent to `PUSHREFCONT` `CALLX`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" [ref] CALLREF ``` #### `DB3D` JMPREF [#db3d-jmpref] Equivalent to `PUSHREFCONT` `JMPX`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" [ref] JMPREF ``` #### `DB3E` JMPREFDATA [#db3e-jmprefdata] Equivalent to `PUSHREFCONT` `JMPXDATA`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" [ref] JMPREFDATA ``` #### `DB3F` RETDATA [#db3f-retdata] Equivalent to `c0 PUSHCTR` `JMPXDATA`. In this way, the remainder of the current continuation is converted into a *Slice* and returned to the caller.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" RETDATA ``` #### `DB4fff` RUNVM [#db4fff-runvm] Runs child VM with code `code` and stack `x_1...x_n`. Returns the resulting stack `x'_1...x'_m` and exitcode. Other arguments and return values are enabled by flags.
Flags operate similarly to `RUNVMX` in Fift:
- `+1`: sets `c3` to code.
- `+2`: pushes an implicit `0` before executing the code.
- `+4`: takes persistent data `c4` from the stack and returns its final value.
- `+8`: takes the gas limit `g_l` from the stack and returns the consumed gas `g_c`.
- `+16`: takes `c7` (smart contract context) from the stack.
- `+32`: returns the final value of `c5` (actions).
- `+64`: pops the hard gas limit `g_m` enabled by `ACCEPT` from the stack.
- `+128`: enables "isolated gas consumption", meaning the child VM maintains a separate set of visited cells and a `chksgn` counter.
- `+256`: pops an integer `r` and ensures exactly `r` values are returned from the top of the stack:
- If `RUNVM` call succeeds and `r` is set, it returns `r` elements. If `r` is not set, it returns all available elements.
- If `RUNVM` is successful but lacks elements on the stack, meaning the stack depth is less than `r`, it is treated as an exception in the child VM. The `exit_code` is set to `-3`, and `exit_arg` is set to `0`, so `0` is returned as the only stack element.
- If `RUNVM` fails with an exception, only one element is returned, `exit_arg`, which should not be confused with `exit_code`.
- In the case of running out of gas, `exit_code` is set to `-14`, and `exit_arg` contains the amount of gas.
Gas cost:
- 66 gas;
- 1 gas for each stack element passed to the child VM (the first 32 elements are free);
- 1 gas for each stack element returned from the child VM (the first 32 elements are free).
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" flags RUNVM ``` #### `DB50` RUNVMX [#db50-runvmx] Runs child VM with code `code` and stack `x_1...x_n`. Returns the resulting stack `x'_1...x'_m` and exitcode. Other arguments and return values are enabled by flags.
Flags operate similarly to `RUNVMX` in Fift:
- `+1`: sets `c3` to code.
- `+2`: pushes an implicit `0` before executing the code.
- `+4`: takes persistent data `c4` from the stack and returns its final value.
- `+8`: takes the gas limit `g_l` from the stack and returns the consumed gas `g_c`.
- `+16`: takes `c7` (smart contract context) from the stack.
- `+32`: returns the final value of `c5` (actions).
- `+64`: pops the hard gas limit `g_m` enabled by `ACCEPT` from the stack.
- `+128`: enables "isolated gas consumption", meaning the child VM maintains a separate set of visited cells and a `chksgn` counter.
- `+256`: pops an integer `r` and ensures exactly `r` values are returned from the top of the stack:
- If `RUNVM` call succeeds and `r` is set, it returns `r` elements. If `r` is not set, it returns all available elements.
- If `RUNVM` is successful but lacks elements on the stack, meaning the stack depth is less than `r`, it is treated as an exception in the child VM. The `exit_code` is set to `-3`, and `exit_arg` is set to `0`, so `0` is returned as the only stack element.
- If `RUNVM` fails with an exception, only one element is returned, `exit_arg`, which should not be confused with `exit_code`.
- In the case of running out of gas, `exit_code` is set to `-14`, and `exit_arg` contains the amount of gas.
Gas cost:
- 66 gas;
- 1 gas for each stack element passed to the child VM (the first 32 elements are free);
- 1 gas for each stack element returned from the child VM (the first 32 elements are free).
**Category:** Cont Basic (cont\_basic)
```fift title="Fift" RUNVMX ``` #### `DC` IFRET [#dc-ifret] Performs a `RET`, but only if integer `f` is non-zero. If `f` is a `NaN`, throws an integer overflow exception.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" IFRET IFNOT: ``` #### `DD` IFNOTRET [#dd-ifnotret] Performs a `RET`, but only if integer `f` is zero.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" IFNOTRET IF: ``` #### `DE` IF [#de-if] Performs `EXECUTE` for `c` (i.e., *executes* `c`), but only if integer `f` is non-zero. Otherwise simply discards both values.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" IF ``` #### `DF` IFNOT [#df-ifnot] Executes continuation `c`, but only if integer `f` is zero. Otherwise simply discards both values.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" IFNOT ``` #### `E0` IFJMP [#e0-ifjmp] Jumps to `c` (similarly to `JMPX`), but only if `f` is non-zero.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" IFJMP ``` #### `E1` IFNOTJMP [#e1-ifnotjmp] Jumps to `c` (similarly to `JMPX`), but only if `f` is zero.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" IFNOTJMP ``` #### `E2` IFELSE [#e2-ifelse] If integer `f` is non-zero, executes `c`, otherwise executes `c'`. Equivalent to `CONDSELCHK` `EXECUTE`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" IFELSE ``` #### `E300` IFREF [#e300-ifref] Equivalent to `PUSHREFCONT` `IF`, with the optimization that the cell reference is not actually loaded into a *Slice* and then converted into an ordinary *Continuation* if `f=0`.
Gas consumption of this primitive depends on whether `f=0` and whether the reference was loaded before.
Similar remarks apply other primitives that accept a continuation as a reference.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" [ref] IFREF ``` #### `E301` IFNOTREF [#e301-ifnotref] Equivalent to `PUSHREFCONT` `IFNOT`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" [ref] IFNOTREF ``` #### `E302` IFJMPREF [#e302-ifjmpref] Equivalent to `PUSHREFCONT` `IFJMP`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" [ref] IFJMPREF ``` #### `E303` IFNOTJMPREF [#e303-ifnotjmpref] Equivalent to `PUSHREFCONT` `IFNOTJMP`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" [ref] IFNOTJMPREF ``` #### `E304` CONDSEL [#e304-condsel] If integer `f` is non-zero, returns `x`, otherwise returns `y`. Notice that no type checks are performed on `x` and `y`; as such, it is more like a conditional stack operation. Roughly equivalent to `ROT` `ISZERO` `INC` `ROLLX` `NIP`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" CONDSEL ``` #### `E305` CONDSELCHK [#e305-condselchk] Same as `CONDSEL`, but first checks whether `x` and `y` have the same type.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" CONDSELCHK ``` #### `E308` IFRETALT [#e308-ifretalt] Performs `RETALT` if integer `f!=0`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" IFRETALT ``` #### `E309` IFNOTRETALT [#e309-ifnotretalt] Performs `RETALT` if integer `f=0`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" IFNOTRETALT ``` #### `E30D` IFREFELSE [#e30d-ifrefelse] Equivalent to `PUSHREFCONT` `SWAP` `IFELSE`, with the optimization that the cell reference is not actually loaded into a *Slice* and then converted into an ordinary *Continuation* if `f=0`. Similar remarks apply to the next two primitives: cells are converted into continuations only when necessary.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" [ref] IFREFELSE ``` #### `E30E` IFELSEREF [#e30e-ifelseref] Equivalent to `PUSHREFCONT` `IFELSE`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" [ref] IFELSEREF ``` #### `E30F` IFREFELSEREF [#e30f-ifrefelseref] Equivalent to `PUSHREFCONT` `PUSHREFCONT` `IFELSE`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" [ref] [ref] IFREFELSEREF ``` #### `E39_n` IFBITJMP [#e39_n-ifbitjmp] Checks whether bit `0 <= n <= 31` is set in integer `x`, and if so, performs `JMPX` to continuation `c`. Value `x` is left in the stack.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" [n] IFBITJMP ``` #### `E3B_n` IFNBITJMP [#e3b_n-ifnbitjmp] Jumps to `c` if bit `0 <= n <= 31` is not set in integer `x`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" [n] IFNBITJMP ``` #### `E3D_n` IFBITJMPREF [#e3d_n-ifbitjmpref] Performs a `JMPREF` if bit `0 <= n <= 31` is set in integer `x`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" [ref] [n] IFBITJMPREF ``` #### `E3F_n` IFNBITJMPREF [#e3f_n-ifnbitjmpref] Performs a `JMPREF` if bit `0 <= n <= 31` is not set in integer `x`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift" [ref] [n] IFNBITJMPREF ``` #### `E4` REPEAT [#e4-repeat] Executes continuation `c` `n` times, if integer `n` is non-negative. If `n>=2^31` or `n<-2^31`, generates a range check exception.
Notice that a `RET` inside the code of `c` works as a `continue`, not as a `break`. One should use either alternative (experimental) loops or alternative `RETALT` (along with a `SETEXITALT` before the loop) to `break` out of a loop.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" REPEAT ``` #### `E5` REPEATEND [#e5-repeatend] Similar to `REPEAT`, but it is applied to the current continuation `cc`.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" REPEATEND REPEAT: ``` #### `E6` UNTIL [#e6-until] Executes continuation `c`, then pops an integer `x` from the resulting stack. If `x` is zero, performs another iteration of this loop. The actual implementation of this primitive involves an extraordinary continuation `ec_until` with its arguments set to the body of the loop (continuation `c`) and the original current continuation `cc`. This extraordinary continuation is then saved into the savelist of `c` as `c.c0` and the modified `c` is then executed. The other loop primitives are implemented similarly with the aid of suitable extraordinary continuations.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" UNTIL ``` #### `E7` UNTILEND [#e7-untilend] Similar to `UNTIL`, but executes the current continuation `cc` in a loop. When the loop exit condition is satisfied, performs a `RET`.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" UNTILEND UNTIL: ``` #### `E8` WHILE [#e8-while] Executes `c'` and pops an integer `x` from the resulting stack. If `x` is zero, exists the loop and transfers control to the original `cc`. If `x` is non-zero, executes `c`, and then begins a new iteration.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" WHILE ``` #### `E9` WHILEEND [#e9-whileend] Similar to `WHILE`, but uses the current continuation `cc` as the loop body.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" WHILEEND ``` #### `EA` AGAIN [#ea-again] Similar to `REPEAT`, but executes `c` infinitely many times. A `RET` only begins a new iteration of the infinite loop, which can be exited only by an exception, or a `RETALT` (or an explicit `JMPX`).
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" AGAIN ``` #### `EB` AGAINEND [#eb-againend] Similar to `AGAIN`, but performed with respect to the current continuation `cc`.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" AGAINEND AGAIN: ``` #### `E314` REPEATBRK [#e314-repeatbrk] Similar to `REPEAT`, but also sets `c1` to the original `cc` after saving the old value of `c1` into the savelist of the original `cc`. In this way `RETALT` could be used to break out of the loop body.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" REPEATBRK ``` #### `E315` REPEATENDBRK [#e315-repeatendbrk] Similar to `REPEATEND`, but also sets `c1` to the original `c0` after saving the old value of `c1` into the savelist of the original `c0`. Equivalent to `SAMEALTSAVE` `REPEATEND`.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" REPEATENDBRK ``` #### `E316` UNTILBRK [#e316-untilbrk] Similar to `UNTIL`, but also modifies `c1` in the same way as `REPEATBRK`.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" UNTILBRK ``` #### `E317` UNTILENDBRK [#e317-untilendbrk] Equivalent to `SAMEALTSAVE` `UNTILEND`.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" UNTILENDBRK UNTILBRK: ``` #### `E318` WHILEBRK [#e318-whilebrk] Similar to `WHILE`, but also modifies `c1` in the same way as `REPEATBRK`.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" WHILEBRK ``` #### `E319` WHILEENDBRK [#e319-whileendbrk] Equivalent to `SAMEALTSAVE` `WHILEEND`.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" WHILEENDBRK ``` #### `E31A` AGAINBRK [#e31a-againbrk] Similar to `AGAIN`, but also modifies `c1` in the same way as `REPEATBRK`.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" AGAINBRK ``` #### `E31B` AGAINENDBRK [#e31b-againendbrk] Equivalent to `SAMEALTSAVE` `AGAINEND`.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift" AGAINENDBRK AGAINBRK: ``` #### `ECrn` SETCONTARGS\_N [#ecrn-setcontargs_n] Pushes `0 <= r <= 15` values `x_1...x_r` into the stack of (a copy of) the continuation `c`, starting with `x_1`. When `n` is 15 (-1 in Fift notation), does nothing with `c.nargs`. For `0 <= n <= 14`, sets `c.nargs` to the final size of the stack of `c'` plus `n`. In other words, transforms `c` into a *closure* or a *partially applied function*, with `0 <= n <= 14` arguments missing.
**Category:** Cont Stack (cont\_stack)
```fift title="Fift" [r] [n] SETCONTARGS ``` **Aliases**: * `SETNUMARGS`
Sets `c.nargs` to `n` plus the current depth of `c`'s stack, where `0 <= n <= 14`. If `c.nargs` is already set to a non-negative value, does nothing. * `SETCONTARGS`
Pushes `0 <= r <= 15` values `x_1...x_r` into the stack of (a copy of) the continuation `c`, starting with `x_1`. If the final depth of `c`'s stack turns out to be greater than `c.nargs`, a stack overflow exception is generated. #### `ED0p` RETURNARGS [#ed0p-returnargs] Leaves only the top `0 <= p <= 15` values in the current stack (somewhat similarly to `ONLYTOPX`), with all the unused bottom values not discarded, but saved into continuation `c0` in the same way as `SETCONTARGS` does.
**Category:** Cont Stack (cont\_stack)
```fift title="Fift" [p] RETURNARGS ``` #### `ED10` RETURNVARARGS [#ed10-returnvarargs] Similar to `RETURNARGS`, but with Integer `0 <= p <= 255` taken from the stack.
**Category:** Cont Stack (cont\_stack)
```fift title="Fift" RETURNVARARGS ``` #### `ED11` SETCONTVARARGS [#ed11-setcontvarargs] Similar to `SETCONTARGS`, but with `0 <= r <= 255` and `-1 <= n <= 255` taken from the stack.
**Category:** Cont Stack (cont\_stack)
```fift title="Fift" SETCONTVARARGS ``` #### `ED12` SETNUMVARARGS [#ed12-setnumvarargs] `-1 <= n <= 255`
If `n=-1`, this operation does nothing (`c'=c`).
Otherwise its action is similar to `[n] SETNUMARGS`, but with `n` taken from the stack.
**Category:** Cont Stack (cont\_stack)
```fift title="Fift" SETNUMVARARGS ``` #### `ED1E` BLESS [#ed1e-bless] Transforms a *Slice* `s` into a simple ordinary continuation `c`, with `c.code=s` and an empty stack and savelist.
**Category:** Cont Create (cont\_create)
```fift title="Fift" BLESS ``` #### `ED1F` BLESSVARARGS [#ed1f-blessvarargs] Equivalent to `ROT` `BLESS` `ROTREV` `SETCONTVARARGS`.
**Category:** Cont Create (cont\_create)
```fift title="Fift" BLESSVARARGS ``` #### `EErn` BLESSARGS [#eern-blessargs] `0 <= r <= 15`, `-1 <= n <= 14`
Equivalent to `BLESS` `[r] [n] SETCONTARGS`.
The value of `n` is represented inside the instruction by the 4-bit integer `n mod 16`.
**Category:** Cont Create (cont\_create)
```fift title="Fift" [r] [n] BLESSARGS ``` **Aliases**: * `BLESSNUMARGS`
Also transforms a *Slice* `s` into a *Continuation* `c`, but sets `c.nargs` to `0 <= n <= 14`. #### `ED4i` PUSHCTR [#ed4i-pushctr] Pushes the current value of control register `c(i)`. If the control register is not supported in the current codepage, or if it does not have a value, an exception is triggered.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" c[i] PUSHCTR c[i] PUSH ``` **Aliases**: * `PUSHROOT`
Pushes the ''global data root'' cell reference, thus enabling access to persistent smart-contract data. #### `ED5i` POPCTR [#ed5i-popctr] Pops a value `x` from the stack and stores it into control register `c(i)`, if supported in the current codepage. Notice that if a control register accepts only values of a specific type, a type-checking exception may occur.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" c[i] POPCTR c[i] POP ``` **Aliases**: * `POPROOT`
Sets the ''global data root'' cell reference, thus allowing modification of persistent smart-contract data. #### `ED6i` SETCONTCTR [#ed6i-setcontctr] Stores `x` into the savelist of continuation `c` as `c(i)`, and returns the resulting continuation `c'`. Almost all operations with continuations may be expressed in terms of `SETCONTCTR`, `POPCTR`, and `PUSHCTR`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" c[i] SETCONT c[i] SETCONTCTR ``` #### `ED7i` SETRETCTR [#ed7i-setretctr] Equivalent to `c0 PUSHCTR` `c[i] SETCONTCTR` `c0 POPCTR`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" c[i] SETRETCTR ``` #### `ED8i` SETALTCTR [#ed8i-setaltctr] Equivalent to `c1 PUSHCTR` `c[i] SETCONTCTR` `c1 POPCTR`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" c[i] SETALTCTR ``` #### `ED9i` POPSAVE [#ed9i-popsave] Similar to `c[i] POPCTR`, but also saves the old value of `c[i]` into continuation `c0`.
Equivalent (up to exceptions) to `c[i] SAVECTR` `c[i] POPCTR`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" c[i] POPSAVE c[i] POPCTRSAVE ``` #### `EDAi` SAVE [#edai-save] Saves the current value of `c(i)` into the savelist of continuation `c0`. If an entry for `c[i]` is already present in the savelist of `c0`, nothing is done. Equivalent to `c[i] PUSHCTR` `c[i] SETRETCTR`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" c[i] SAVE c[i] SAVECTR ``` #### `EDBi` SAVEALT [#edbi-savealt] Similar to `c[i] SAVE`, but saves the current value of `c[i]` into the savelist of `c1`, not `c0`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" c[i] SAVEALT c[i] SAVEALTCTR ``` #### `EDCi` SAVEBOTH [#edci-saveboth] Equivalent to `c[i] SAVE` `c[i] SAVEALT`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" c[i] SAVEBOTH c[i] SAVEBOTHCTR ``` #### `EDE0` PUSHCTRX [#ede0-pushctrx] Similar to `c[i] PUSHCTR`, but with `i`, `0 <= i <= 255`, taken from the stack.
Notice that this primitive is one of the few ''exotic'' primitives, which are not polymorphic like stack manipulation primitives, and at the same time do not have well-defined types of parameters and return values, because the type of `x` depends on `i`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" PUSHCTRX ``` #### `EDE1` POPCTRX [#ede1-popctrx] Similar to `c[i] POPCTR`, but with `0 <= i <= 255` from the stack.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" POPCTRX ``` #### `EDE2` SETCONTCTRX [#ede2-setcontctrx] Similar to `c[i] SETCONTCTR`, but with `0 <= i <= 255` from the stack.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" SETCONTCTRX ``` #### `EDE3mm` SETCONTCTRMANY [#ede3mm-setcontctrmany] Takes continuation, performs the equivalent of `c[i] PUSHCTR SWAP c[i] SETCONTCNR` for each `i` that is set in `mask` (mask is in `0..255`).
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" SETCONTCTRMANY SETCONTMANY ``` #### `EDE4` SETCONTCTRMANYX [#ede4-setcontctrmanyx] Takes continuation, performs the equivalent of `c[i] PUSHCTR SWAP c[i] SETCONTCNR` for each `i` that is set in `mask` (mask is in `0..255`).
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" SETCONTCTRMANYX SETCONTMANYX ``` #### `EDF0` COMPOS [#edf0-compos] Computes the composition `compose0(c, c')`, which has the meaning of ''perform `c`, and, if successful, perform `c'`'' (if `c` is a boolean circuit) or simply ''perform `c`, then `c'`''. Equivalent to `SWAP` `c0 SETCONT`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" COMPOS BOOLAND ``` #### `EDF1` COMPOSALT [#edf1-composalt] Computes the alternative composition `compose1(c, c')`, which has the meaning of ''perform `c`, and, if not successful, perform `c'`'' (if `c` is a boolean circuit). Equivalent to `SWAP` `c1 SETCONT`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" COMPOSALT BOOLOR ``` #### `EDF2` COMPOSBOTH [#edf2-composboth] Computes composition `compose1(compose0(c, c'), c')`, which has the meaning of ''compute boolean circuit `c`, then compute `c'`, regardless of the result of `c`''.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" COMPOSBOTH ``` #### `EDF3` ATEXIT [#edf3-atexit] Sets `c0` to `compose0(c, c0)`. In other words, `c` will be executed before exiting current subroutine.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" ATEXIT ``` #### `EDF4` ATEXITALT [#edf4-atexitalt] Sets `c1` to `compose1(c, c1)`. In other words, `c` will be executed before exiting current subroutine by its alternative return path.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" ATEXITALT ``` #### `EDF5` SETEXITALT [#edf5-setexitalt] Sets `c1` to `compose1(compose0(c, c0), c1)`,
In this way, a subsequent `RETALT` will first execute `c`, then transfer control to the original `c0`. This can be used, for instance, to exit from nested loops.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" SETEXITALT ``` #### `EDF6` THENRET [#edf6-thenret] Computes `compose0(c, c0)`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" THENRET ``` #### `EDF7` THENRETALT [#edf7-thenretalt] Computes `compose0(c, c1)`
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" THENRETALT ``` #### `EDF8` INVERT [#edf8-invert] Interchanges `c0` and `c1`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" INVERT ``` #### `EDF9` BOOLEVAL [#edf9-booleval] Performs `cc:=compose1(compose0(c, compose0(-1 PUSHINT, cc)), compose0(0 PUSHINT, cc))`. If `c` represents a boolean circuit, the net effect is to evaluate it and push either `-1` or `0` into the stack before continuing.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" BOOLEVAL ``` #### `EDFA` SAMEALT [#edfa-samealt] Sets `c1` to `c0`. Equivalent to `c0 PUSHCTR` `c1 POPCTR`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" SAMEALT ``` #### `EDFB` SAMEALTSAVE [#edfb-samealtsave] Sets `c1` to `c0`, but first saves the old value of `c1` into the savelist of `c0`.
Equivalent to `c1 SAVE` `SAMEALT`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift" SAMEALTSAVE ``` #### `F0nn` CALLDICT [#f0nn-calldict] Calls the continuation in `c3`, pushing integer `0 <= nn <= 255` into its stack as an argument.
Approximately equivalent to `[nn] PUSHINT` `c3 PUSHCTR` `EXECUTE`.
**Category:** Cont Dict (cont\_dict)
```fift title="Fift" [nn] CALL [nn] CALLDICT ``` #### `F12_n` CALLDICT\_LONG [#f12_n-calldict_long] For `0 <= n < 2^14`, an encoding of `[n] CALL` for larger values of `n`.
**Category:** Cont Dict (cont\_dict)
```fift title="Fift" [n] CALL [n] CALLDICT ``` #### `F16_n` JMPDICT [#f16_n-jmpdict] Jumps to the continuation in `c3`, pushing integer `0 <= n < 2^14` as its argument.
Approximately equivalent to `n PUSHINT` `c3 PUSHCTR` `JMPX`.
**Category:** Cont Dict (cont\_dict)
```fift title="Fift" [n] JMP ``` #### `F1A_n` PREPAREDICT [#f1a_n-preparedict] Equivalent to `n PUSHINT` `c3 PUSHCTR`, for `0 <= n < 2^14`.
In this way, `[n] CALL` is approximately equivalent to `[n] PREPARE` `EXECUTE`, and `[n] JMP` is approximately equivalent to `[n] PREPARE` `JMPX`.
One might use, for instance, `CALLXARGS` or `CALLCC` instead of `EXECUTE` here.
**Category:** Cont Dict (cont\_dict)
```fift title="Fift" [n] PREPARE [n] PREPAREDICT ``` #### `F22_n` THROW\_SHORT [#f22_n-throw_short] Throws exception `0 <= n <= 63` with parameter zero.
In other words, it transfers control to the continuation in `c2`, pushing `0` and `n` into its stack, and discarding the old stack altogether.
**Category:** Exceptions (exceptions)
```fift title="Fift" [n] THROW ``` #### `F26_n` THROWIF\_SHORT [#f26_n-throwif_short] Throws exception `0 <= n <= 63` with parameter zero only if integer `f!=0`.
**Category:** Exceptions (exceptions)
```fift title="Fift" [n] THROWIF ``` #### `F2A_n` THROWIFNOT\_SHORT [#f2a_n-throwifnot_short] Throws exception `0 <= n <= 63` with parameter zero only if integer `f=0`.
**Category:** Exceptions (exceptions)
```fift title="Fift" [n] THROWIFNOT ``` #### `F2C4_n` THROW [#f2c4_n-throw] For `0 <= n < 2^11`, an encoding of `[n] THROW` for larger values of `n`.
**Category:** Exceptions (exceptions)
```fift title="Fift" [n] THROW ``` #### `F2CC_n` THROWARG [#f2cc_n-throwarg] Throws exception `0 <= n < 2^11` with parameter `x`, by copying `x` and `n` into the stack of `c2` and transferring control to `c2`.
**Category:** Exceptions (exceptions)
```fift title="Fift" [n] THROWARG ``` #### `F2D4_n` THROWIF [#f2d4_n-throwif] For `0 <= n < 2^11`, an encoding of `[n] THROWIF` for larger values of `n`.
**Category:** Exceptions (exceptions)
```fift title="Fift" [n] THROWIF ``` #### `F2DC_n` THROWARGIF [#f2dc_n-throwargif] Throws exception `0 <= nn < 2^11` with parameter `x` only if integer `f!=0`.
**Category:** Exceptions (exceptions)
```fift title="Fift" [n] THROWARGIF ``` #### `F2E4_n` THROWIFNOT [#f2e4_n-throwifnot] For `0 <= n < 2^11`, an encoding of `[n] THROWIFNOT` for larger values of `n`.
**Category:** Exceptions (exceptions)
```fift title="Fift" [n] THROWIFNOT ``` #### `F2EC_n` THROWARGIFNOT [#f2ec_n-throwargifnot] Throws exception `0 <= n < 2^11` with parameter `x` only if integer `f=0`.
**Category:** Exceptions (exceptions)
```fift title="Fift" [n] THROWARGIFNOT ``` #### `F2F0` THROWANY [#f2f0-throwany] Throws exception `0 <= n < 2^16` with parameter zero.
Approximately equivalent to `ZERO` `SWAP` `THROWARGANY`.
**Category:** Exceptions (exceptions)
```fift title="Fift" THROWANY ``` #### `F2F1` THROWARGANY [#f2f1-throwargany] Throws exception `0 <= n < 2^16` with parameter `x`, transferring control to the continuation in `c2`.
Approximately equivalent to `c2 PUSHCTR` `2 JMPXARGS`.
**Category:** Exceptions (exceptions)
```fift title="Fift" THROWARGANY ``` #### `F2F2` THROWANYIF [#f2f2-throwanyif] Throws exception `0 <= n < 2^16` with parameter zero only if `f!=0`.
**Category:** Exceptions (exceptions)
```fift title="Fift" THROWANYIF ``` #### `F2F3` THROWARGANYIF [#f2f3-throwarganyif] Throws exception `0 <= n<2^16` with parameter `x` only if `f!=0`.
**Category:** Exceptions (exceptions)
```fift title="Fift" THROWARGANYIF ``` #### `F2F4` THROWANYIFNOT [#f2f4-throwanyifnot] Throws exception `0 <= n<2^16` with parameter zero only if `f=0`.
**Category:** Exceptions (exceptions)
```fift title="Fift" THROWANYIFNOT ``` #### `F2F5` THROWARGANYIFNOT [#f2f5-throwarganyifnot] Throws exception `0 <= n<2^16` with parameter `x` only if `f=0`.
**Category:** Exceptions (exceptions)
```fift title="Fift" THROWARGANYIFNOT ``` #### `F2FF` TRY [#f2ff-try] Sets `c2` to `c'`, first saving the old value of `c2` both into the savelist of `c'` and into the savelist of the current continuation, which is stored into `c.c0` and `c'.c0`. Then runs `c` similarly to `EXECUTE`. If `c` does not throw any exceptions, the original value of `c2` is automatically restored on return from `c`. If an exception occurs, the execution is transferred to `c'`, but the original value of `c2` is restored in the process, so that `c'` can re-throw the exception by `THROWANY` if it cannot handle it by itself.
**Category:** Exceptions (exceptions)
```fift title="Fift" TRY ``` #### `F3pr` TRYARGS [#f3pr-tryargs] Similar to `TRY`, but with `[p] [r] CALLXARGS` internally used instead of `EXECUTE`.
In this way, all but the top `0 <= p <= 15` stack elements will be saved into current continuation's stack, and then restored upon return from either `c` or `c'`, with the top `0 <= r <= 15` values of the resulting stack of `c` or `c'` copied as return values.
**Category:** Exceptions (exceptions)
```fift title="Fift" [p] [r] TRYARGS ``` #### `F400` STDICT [#f400-stdict] Stores dictionary `D` into *Builder* `b`, returning the resulting *Builder* `b'`.
In other words, if `D` is a cell, performs `STONE` and `STREF`; if `D` is *Null*, performs `NIP` and `STZERO`; otherwise throws a type checking exception.
**Category:** Dict Serial (dict\_serial)
```fift title="Fift" STDICT STOPTREF ``` #### `F401` SKIPDICT [#f401-skipdict] Equivalent to `LDDICT` `NIP`.
**Category:** Dict Serial (dict\_serial)
```fift title="Fift" SKIPDICT SKIPOPTREF ``` #### `F402` LDDICTS [#f402-lddicts] Loads (parses) a (*Slice*-represented) dictionary `s'` from *Slice* `s`, and returns the remainder of `s` as `s''`.
This is a ''split function'' for all `HashmapE(n,X)` dictionary types.
**Category:** Dict Serial (dict\_serial)
```fift title="Fift" LDDICTS ``` #### `F403` PLDDICTS [#f403-plddicts] Preloads a (*Slice*-represented) dictionary `s'` from *Slice* `s`.
Approximately equivalent to `LDDICTS` `DROP`.
**Category:** Dict Serial (dict\_serial)
```fift title="Fift" PLDDICTS ``` #### `F404` LDDICT [#f404-lddict] Loads (parses) a dictionary `D` from *Slice* `s`, and returns the remainder of `s` as `s'`. May be applied to dictionaries or to values of arbitrary `(^Y)?` types.
**Category:** Dict Serial (dict\_serial)
```fift title="Fift" LDDICT LDOPTREF ``` #### `F405` PLDDICT [#f405-plddict] Preloads a dictionary `D` from *Slice* `s`.
Approximately equivalent to `LDDICT` `DROP`.
**Category:** Dict Serial (dict\_serial)
```fift title="Fift" PLDDICT PLDOPTREF ``` #### `F406` LDDICTQ [#f406-lddictq] A quiet version of `LDDICT`.
**Category:** Dict Serial (dict\_serial)
```fift title="Fift" LDDICTQ ``` #### `F407` PLDDICTQ [#f407-plddictq] A quiet version of `PLDDICT`.
**Category:** Dict Serial (dict\_serial)
```fift title="Fift" PLDDICTQ ``` #### `F40A` DICTGET [#f40a-dictget] Looks up key `k` (represented by a *Slice*, the first `0 <= n <= 1023` data bits of which are used as a key) in dictionary `D` of type `HashmapE(n,X)` with `n`-bit keys.
On success, returns the value found as a *Slice* `x`.
**Category:** Dict Get (dict\_get)
```fift title="Fift" DICTGET ``` #### `F40B` DICTGETREF [#f40b-dictgetref] Similar to `DICTGET`, but with a `LDREF` `ENDS` applied to `x` on success.
This operation is useful for dictionaries of type `HashmapE(n,^Y)`.
**Category:** Dict Get (dict\_get)
```fift title="Fift" DICTGETREF ``` #### `F40C` DICTIGET [#f40c-dictiget] Similar to `DICTGET`, but with a signed (big-endian) `n`-bit *Integer* `i` as a key. If `i` does not fit into `n` bits, returns `0`. If `i` is a `NaN`, throws an integer overflow exception.
**Category:** Dict Get (dict\_get)
```fift title="Fift" DICTIGET ``` #### `F40D` DICTIGETREF [#f40d-dictigetref] Combines `DICTIGET` with `DICTGETREF`: it uses signed `n`-bit *Integer* `i` as a key and returns a *Cell* instead of a *Slice* on success.
**Category:** Dict Get (dict\_get)
```fift title="Fift" DICTIGETREF ``` #### `F40E` DICTUGET [#f40e-dictuget] Similar to `DICTIGET`, but with *unsigned* (big-endian) `n`-bit *Integer* `i` used as a key.
**Category:** Dict Get (dict\_get)
```fift title="Fift" DICTUGET ``` #### `F40F` DICTUGETREF [#f40f-dictugetref] Similar to `DICTIGETREF`, but with an unsigned `n`-bit *Integer* key `i`.
**Category:** Dict Get (dict\_get)
```fift title="Fift" DICTUGETREF ``` #### `F412` DICTSET [#f412-dictset] Sets the value associated with `n`-bit key `k` (represented by a *Slice* as in `DICTGET`) in dictionary `D` (also represented by a *Slice*) to value `x` (again a *Slice*), and returns the resulting dictionary as `D'`.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTSET ``` #### `F413` DICTSETREF [#f413-dictsetref] Similar to `DICTSET`, but with the value set to a reference to *Cell* `c`.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTSETREF ``` #### `F414` DICTISET [#f414-dictiset] Similar to `DICTSET`, but with the key represented by a (big-endian) signed `n`-bit integer `i`. If `i` does not fit into `n` bits, a range check exception is generated.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTISET ``` #### `F415` DICTISETREF [#f415-dictisetref] Similar to `DICTSETREF`, but with the key a signed `n`-bit integer as in `DICTISET`.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTISETREF ``` #### `F416` DICTUSET [#f416-dictuset] Similar to `DICTISET`, but with `i` an *unsigned* `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTUSET ``` #### `F417` DICTUSETREF [#f417-dictusetref] Similar to `DICTISETREF`, but with `i` unsigned.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTUSETREF ``` #### `F41A` DICTSETGET [#f41a-dictsetget] Combines `DICTSET` with `DICTGET`: it sets the value corresponding to key `k` to `x`, but also returns the old value `y` associated with the key in question, if present.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTSETGET ``` #### `F41B` DICTSETGETREF [#f41b-dictsetgetref] Combines `DICTSETREF` with `DICTGETREF` similarly to `DICTSETGET`.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTSETGETREF ``` #### `F41C` DICTISETGET [#f41c-dictisetget] `DICTISETGET`, but with `i` a signed `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTISETGET ``` #### `F41D` DICTISETGETREF [#f41d-dictisetgetref] `DICTISETGETREF`, but with `i` a signed `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTISETGETREF ``` #### `F41E` DICTUSETGET [#f41e-dictusetget] `DICTISETGET`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTUSETGET ``` #### `F41F` DICTUSETGETREF [#f41f-dictusetgetref] `DICTISETGETREF`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTUSETGETREF ``` #### `F422` DICTREPLACE [#f422-dictreplace] A *Replace* operation, which is similar to `DICTSET`, but sets the value of key `k` in dictionary `D` to `x` only if the key `k` was already present in `D`.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTREPLACE ``` #### `F423` DICTREPLACEREF [#f423-dictreplaceref] A *Replace* counterpart of `DICTSETREF`.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTREPLACEREF ``` #### `F424` DICTIREPLACE [#f424-dictireplace] `DICTREPLACE`, but with `i` a signed `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTIREPLACE ``` #### `F425` DICTIREPLACEREF [#f425-dictireplaceref] `DICTREPLACEREF`, but with `i` a signed `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTIREPLACEREF ``` #### `F426` DICTUREPLACE [#f426-dictureplace] `DICTREPLACE`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTUREPLACE ``` #### `F427` DICTUREPLACEREF [#f427-dictureplaceref] `DICTREPLACEREF`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTUREPLACEREF ``` #### `F42A` DICTREPLACEGET [#f42a-dictreplaceget] A *Replace* counterpart of `DICTSETGET`: on success, also returns the old value associated with the key in question.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTREPLACEGET ``` #### `F42B` DICTREPLACEGETREF [#f42b-dictreplacegetref] A *Replace* counterpart of `DICTSETGETREF`.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTREPLACEGETREF ``` #### `F42C` DICTIREPLACEGET [#f42c-dictireplaceget] `DICTREPLACEGET`, but with `i` a signed `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTIREPLACEGET ``` #### `F42D` DICTIREPLACEGETREF [#f42d-dictireplacegetref] `DICTREPLACEGETREF`, but with `i` a signed `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTIREPLACEGETREF ``` #### `F42E` DICTUREPLACEGET [#f42e-dictureplaceget] `DICTREPLACEGET`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTUREPLACEGET ``` #### `F42F` DICTUREPLACEGETREF [#f42f-dictureplacegetref] `DICTREPLACEGETREF`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTUREPLACEGETREF ``` #### `F432` DICTADD [#f432-dictadd] An *Add* counterpart of `DICTSET`: sets the value associated with key `k` in dictionary `D` to `x`, but only if it is not already present in `D`.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTADD ``` #### `F433` DICTADDREF [#f433-dictaddref] An *Add* counterpart of `DICTSETREF`.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTADDREF ``` #### `F434` DICTIADD [#f434-dictiadd] `DICTADD`, but with `i` a signed `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTIADD ``` #### `F435` DICTIADDREF [#f435-dictiaddref] `DICTADDREF`, but with `i` a signed `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTIADDREF ``` #### `F436` DICTUADD [#f436-dictuadd] `DICTADD`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTUADD ``` #### `F437` DICTUADDREF [#f437-dictuaddref] `DICTADDREF`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTUADDREF ``` #### `F43A` DICTADDGET [#f43a-dictaddget] An *Add* counterpart of `DICTSETGET`: sets the value associated with key `k` in dictionary `D` to `x`, but only if key `k` is not already present in `D`. Otherwise, just returns the old value `y` without changing the dictionary.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTADDGET ``` #### `F43B` DICTADDGETREF [#f43b-dictaddgetref] An *Add* counterpart of `DICTSETGETREF`.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTADDGETREF ``` #### `F43C` DICTIADDGET [#f43c-dictiaddget] `DICTADDGET`, but with `i` a signed `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTIADDGET ``` #### `F43D` DICTIADDGETREF [#f43d-dictiaddgetref] `DICTADDGETREF`, but with `i` a signed `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTIADDGETREF ``` #### `F43E` DICTUADDGET [#f43e-dictuaddget] `DICTADDGET`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTUADDGET ``` #### `F43F` DICTUADDGETREF [#f43f-dictuaddgetref] `DICTADDGETREF`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift" DICTUADDGETREF ``` #### `F441` DICTSETB [#f441-dictsetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTSETB ``` #### `F442` DICTISETB [#f442-dictisetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTISETB ``` #### `F443` DICTUSETB [#f443-dictusetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTUSETB ``` #### `F445` DICTSETGETB [#f445-dictsetgetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTSETGETB ``` #### `F446` DICTISETGETB [#f446-dictisetgetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTISETGETB ``` #### `F447` DICTUSETGETB [#f447-dictusetgetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTUSETGETB ``` #### `F449` DICTREPLACEB [#f449-dictreplaceb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTREPLACEB ``` #### `F44A` DICTIREPLACEB [#f44a-dictireplaceb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTIREPLACEB ``` #### `F44B` DICTUREPLACEB [#f44b-dictureplaceb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTUREPLACEB ``` #### `F44D` DICTREPLACEGETB [#f44d-dictreplacegetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTREPLACEGETB ``` #### `F44E` DICTIREPLACEGETB [#f44e-dictireplacegetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTIREPLACEGETB ``` #### `F44F` DICTUREPLACEGETB [#f44f-dictureplacegetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTUREPLACEGETB ``` #### `F451` DICTADDB [#f451-dictaddb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTADDB ``` #### `F452` DICTIADDB [#f452-dictiaddb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTIADDB ``` #### `F453` DICTUADDB [#f453-dictuaddb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTUADDB ``` #### `F455` DICTADDGETB [#f455-dictaddgetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTADDGETB ``` #### `F456` DICTIADDGETB [#f456-dictiaddgetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTIADDGETB ``` #### `F457` DICTUADDGETB [#f457-dictuaddgetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift" DICTUADDGETB ``` #### `F459` DICTDEL [#f459-dictdel] Deletes `n`-bit key, represented by a *Slice* `k`, from dictionary `D`. If the key is present, returns the modified dictionary `D'` and the success flag `-1`. Otherwise, returns the original dictionary `D` and `0`.
**Category:** Dict Delete (dict\_delete)
```fift title="Fift" DICTDEL ``` #### `F45A` DICTIDEL [#f45a-dictidel] A version of `DICTDEL` with the key represented by a signed `n`-bit *Integer* `i`. If `i` does not fit into `n` bits, simply returns `D` `0` (''key not found, dictionary unmodified'').
**Category:** Dict Delete (dict\_delete)
```fift title="Fift" DICTIDEL ``` #### `F45B` DICTUDEL [#f45b-dictudel] Similar to `DICTIDEL`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Delete (dict\_delete)
```fift title="Fift" DICTUDEL ``` #### `F462` DICTDELGET [#f462-dictdelget] Deletes `n`-bit key, represented by a *Slice* `k`, from dictionary `D`. If the key is present, returns the modified dictionary `D'`, the original value `x` associated with the key `k` (represented by a *Slice*), and the success flag `-1`. Otherwise, returns the original dictionary `D` and `0`.
**Category:** Dict Delete (dict\_delete)
```fift title="Fift" DICTDELGET ``` #### `F463` DICTDELGETREF [#f463-dictdelgetref] Similar to `DICTDELGET`, but with `LDREF` `ENDS` applied to `x` on success, so that the value returned `c` is a *Cell*.
**Category:** Dict Delete (dict\_delete)
```fift title="Fift" DICTDELGETREF ``` #### `F464` DICTIDELGET [#f464-dictidelget] `DICTDELGET`, but with `i` a signed `n`-bit integer.
**Category:** Dict Delete (dict\_delete)
```fift title="Fift" DICTIDELGET ``` #### `F465` DICTIDELGETREF [#f465-dictidelgetref] `DICTDELGETREF`, but with `i` a signed `n`-bit integer.
**Category:** Dict Delete (dict\_delete)
```fift title="Fift" DICTIDELGETREF ``` #### `F466` DICTUDELGET [#f466-dictudelget] `DICTDELGET`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Delete (dict\_delete)
```fift title="Fift" DICTUDELGET ``` #### `F467` DICTUDELGETREF [#f467-dictudelgetref] `DICTDELGETREF`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Delete (dict\_delete)
```fift title="Fift" DICTUDELGETREF ``` #### `F469` DICTGETOPTREF [#f469-dictgetoptref] A variant of `DICTGETREF` that returns *Null* instead of the value `c^?` if the key `k` is absent from dictionary `D`.
**Category:** Dict Mayberef (dict\_mayberef)
```fift title="Fift" DICTGETOPTREF ``` #### `F46A` DICTIGETOPTREF [#f46a-dictigetoptref] `DICTGETOPTREF`, but with `i` a signed `n`-bit integer. If the key `i` is out of range, also returns *Null*.
**Category:** Dict Mayberef (dict\_mayberef)
```fift title="Fift" DICTIGETOPTREF ``` #### `F46B` DICTUGETOPTREF [#f46b-dictugetoptref] `DICTGETOPTREF`, but with `i` an unsigned `n`-bit integer. If the key `i` is out of range, also returns *Null*.
**Category:** Dict Mayberef (dict\_mayberef)
```fift title="Fift" DICTUGETOPTREF ``` #### `F46D` DICTSETGETOPTREF [#f46d-dictsetgetoptref] A variant of both `DICTGETOPTREF` and `DICTSETGETREF` that sets the value corresponding to key `k` in dictionary `D` to `c^?` (if `c^?` is *Null*, then the key is deleted instead), and returns the old value `~c^?` (if the key `k` was absent before, returns *Null* instead).
**Category:** Dict Mayberef (dict\_mayberef)
```fift title="Fift" DICTSETGETOPTREF ``` #### `F46E` DICTISETGETOPTREF [#f46e-dictisetgetoptref] Similar to primitive `DICTSETGETOPTREF`, but using signed `n`-bit *Integer* `i` as a key. If `i` does not fit into `n` bits, throws a range checking exception.
**Category:** Dict Mayberef (dict\_mayberef)
```fift title="Fift" DICTISETGETOPTREF ``` #### `F46F` DICTUSETGETOPTREF [#f46f-dictusetgetoptref] Similar to primitive `DICTSETGETOPTREF`, but using unsigned `n`-bit *Integer* `i` as a key.
**Category:** Dict Mayberef (dict\_mayberef)
```fift title="Fift" DICTUSETGETOPTREF ``` #### `F470` PFXDICTSET [#f470-pfxdictset]
**Category:** Dict Prefix (dict\_prefix)
```fift title="Fift" PFXDICTSET ``` #### `F471` PFXDICTREPLACE [#f471-pfxdictreplace]
**Category:** Dict Prefix (dict\_prefix)
```fift title="Fift" PFXDICTREPLACE ``` #### `F472` PFXDICTADD [#f472-pfxdictadd]
**Category:** Dict Prefix (dict\_prefix)
```fift title="Fift" PFXDICTADD ``` #### `F473` PFXDICTDEL [#f473-pfxdictdel]
**Category:** Dict Prefix (dict\_prefix)
```fift title="Fift" PFXDICTDEL ``` #### `F474` DICTGETNEXT [#f474-dictgetnext] Computes the minimal key `k'` in dictionary `D` that is lexicographically greater than `k`, and returns `k'` (represented by a *Slice*) along with associated value `x'` (also represented by a *Slice*).
**Category:** Dict Next (dict\_next)
```fift title="Fift" DICTGETNEXT ``` #### `F475` DICTGETNEXTEQ [#f475-dictgetnexteq] Similar to `DICTGETNEXT`, but computes the minimal key `k'` that is lexicographically greater than or equal to `k`.
**Category:** Dict Next (dict\_next)
```fift title="Fift" DICTGETNEXTEQ ``` #### `F476` DICTGETPREV [#f476-dictgetprev] Similar to `DICTGETNEXT`, but computes the maximal key `k'` lexicographically smaller than `k`.
**Category:** Dict Next (dict\_next)
```fift title="Fift" DICTGETPREV ``` #### `F477` DICTGETPREVEQ [#f477-dictgetpreveq] Similar to `DICTGETPREV`, but computes the maximal key `k'` lexicographically smaller than or equal to `k`.
**Category:** Dict Next (dict\_next)
```fift title="Fift" DICTGETPREVEQ ``` #### `F478` DICTIGETNEXT [#f478-dictigetnext] Similar to `DICTGETNEXT`, but interprets all keys in dictionary `D` as big-endian signed `n`-bit integers, and computes the minimal key `i'` that is larger than *Integer* `i` (which does not necessarily fit into `n` bits).
**Category:** Dict Next (dict\_next)
```fift title="Fift" DICTIGETNEXT ``` #### `F479` DICTIGETNEXTEQ [#f479-dictigetnexteq] Similar to `DICTGETNEXTEQ`, but interprets keys as signed `n`-bit integers.
**Category:** Dict Next (dict\_next)
```fift title="Fift" DICTIGETNEXTEQ ``` #### `F47A` DICTIGETPREV [#f47a-dictigetprev] Similar to `DICTGETPREV`, but interprets keys as signed `n`-bit integers.
**Category:** Dict Next (dict\_next)
```fift title="Fift" DICTIGETPREV ``` #### `F47B` DICTIGETPREVEQ [#f47b-dictigetpreveq] Similar to `DICTGETPREVEQ`, but interprets keys as signed `n`-bit integers.
**Category:** Dict Next (dict\_next)
```fift title="Fift" DICTIGETPREVEQ ``` #### `F47C` DICTUGETNEXT [#f47c-dictugetnext] Similar to `DICTGETNEXT`, but interprets all keys in dictionary `D` as big-endian unsigned `n`-bit integers, and computes the minimal key `i'` that is larger than *Integer* `i` (which does not necessarily fit into `n` bits, and is not necessarily non-negative).
**Category:** Dict Next (dict\_next)
```fift title="Fift" DICTUGETNEXT ``` #### `F47D` DICTUGETNEXTEQ [#f47d-dictugetnexteq] Similar to `DICTGETNEXTEQ`, but interprets keys as unsigned `n`-bit integers.
**Category:** Dict Next (dict\_next)
```fift title="Fift" DICTUGETNEXTEQ ``` #### `F47E` DICTUGETPREV [#f47e-dictugetprev] Similar to `DICTGETPREV`, but interprets keys as unsigned `n`-bit integers.
**Category:** Dict Next (dict\_next)
```fift title="Fift" DICTUGETPREV ``` #### `F47F` DICTUGETPREVEQ [#f47f-dictugetpreveq] Similar to `DICTGETPREVEQ`, but interprets keys a unsigned `n`-bit integers.
**Category:** Dict Next (dict\_next)
```fift title="Fift" DICTUGETPREVEQ ``` #### `F482` DICTMIN [#f482-dictmin] Computes the minimal key `k` (represented by a *Slice* with `n` data bits) in dictionary `D`, and returns `k` along with the associated value `x`.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTMIN ``` #### `F483` DICTMINREF [#f483-dictminref] Similar to `DICTMIN`, but returns the only reference in the value as a *Cell* `c`.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTMINREF ``` #### `F484` DICTIMIN [#f484-dictimin] Similar to `DICTMIN`, but computes the minimal key `i` under the assumption that all keys are big-endian signed `n`-bit integers. Notice that the key and value returned may differ from those computed by `DICTMIN` and `DICTUMIN`.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTIMIN ``` #### `F485` DICTIMINREF [#f485-dictiminref] Similar to `DICTIMIN`, but returns the only reference in the value.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTIMINREF ``` #### `F486` DICTUMIN [#f486-dictumin] Similar to `DICTMIN`, but returns the key as an unsigned `n`-bit *Integer* `i`.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTUMIN ``` #### `F487` DICTUMINREF [#f487-dictuminref] Similar to `DICTUMIN`, but returns the only reference in the value.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTUMINREF ``` #### `F48A` DICTMAX [#f48a-dictmax] Computes the maximal key `k` (represented by a *Slice* with `n` data bits) in dictionary `D`, and returns `k` along with the associated value `x`.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTMAX ``` #### `F48B` DICTMAXREF [#f48b-dictmaxref] Similar to `DICTMAX`, but returns the only reference in the value.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTMAXREF ``` #### `F48C` DICTIMAX [#f48c-dictimax] Similar to `DICTMAX`, but computes the maximal key `i` under the assumption that all keys are big-endian signed `n`-bit integers. Notice that the key and value returned may differ from those computed by `DICTMAX` and `DICTUMAX`.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTIMAX ``` #### `F48D` DICTIMAXREF [#f48d-dictimaxref] Similar to `DICTIMAX`, but returns the only reference in the value.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTIMAXREF ``` #### `F48E` DICTUMAX [#f48e-dictumax] Similar to `DICTMAX`, but returns the key as an unsigned `n`-bit *Integer* `i`.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTUMAX ``` #### `F48F` DICTUMAXREF [#f48f-dictumaxref] Similar to `DICTUMAX`, but returns the only reference in the value.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTUMAXREF ``` #### `F492` DICTREMMIN [#f492-dictremmin] Computes the minimal key `k` (represented by a *Slice* with `n` data bits) in dictionary `D`, removes `k` from the dictionary, and returns `k` along with the associated value `x` and the modified dictionary `D'`.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTREMMIN ``` #### `F493` DICTREMMINREF [#f493-dictremminref] Similar to `DICTREMMIN`, but returns the only reference in the value as a *Cell* `c`.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTREMMINREF ``` #### `F494` DICTIREMMIN [#f494-dictiremmin] Similar to `DICTREMMIN`, but computes the minimal key `i` under the assumption that all keys are big-endian signed `n`-bit integers. Notice that the key and value returned may differ from those computed by `DICTREMMIN` and `DICTUREMMIN`.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTIREMMIN ``` #### `F495` DICTIREMMINREF [#f495-dictiremminref] Similar to `DICTIREMMIN`, but returns the only reference in the value.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTIREMMINREF ``` #### `F496` DICTUREMMIN [#f496-dicturemmin] Similar to `DICTREMMIN`, but returns the key as an unsigned `n`-bit *Integer* `i`.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTUREMMIN ``` #### `F497` DICTUREMMINREF [#f497-dicturemminref] Similar to `DICTUREMMIN`, but returns the only reference in the value.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTUREMMINREF ``` #### `F49A` DICTREMMAX [#f49a-dictremmax] Computes the maximal key `k` (represented by a *Slice* with `n` data bits) in dictionary `D`, removes `k` from the dictionary, and returns `k` along with the associated value `x` and the modified dictionary `D'`.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTREMMAX ``` #### `F49B` DICTREMMAXREF [#f49b-dictremmaxref] Similar to `DICTREMMAX`, but returns the only reference in the value as a *Cell* `c`.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTREMMAXREF ``` #### `F49C` DICTIREMMAX [#f49c-dictiremmax] Similar to `DICTREMMAX`, but computes the minimal key `i` under the assumption that all keys are big-endian signed `n`-bit integers. Notice that the key and value returned may differ from those computed by `DICTREMMAX` and `DICTUREMMAX`.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTIREMMAX ``` #### `F49D` DICTIREMMAXREF [#f49d-dictiremmaxref] Similar to `DICTIREMMAX`, but returns the only reference in the value.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTIREMMAXREF ``` #### `F49E` DICTUREMMAX [#f49e-dicturemmax] Similar to `DICTREMMAX`, but returns the key as an unsigned `n`-bit *Integer* `i`.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTUREMMAX ``` #### `F49F` DICTUREMMAXREF [#f49f-dicturemmaxref] Similar to `DICTUREMMAX`, but returns the only reference in the value.
**Category:** Dict Min (dict\_min)
```fift title="Fift" DICTUREMMAXREF ``` #### `F4A0` DICTIGETJMP [#f4a0-dictigetjmp] Similar to `DICTIGET`, but with `x` `BLESS`ed into a continuation with a subsequent `JMPX` to it on success. On failure, does nothing. This is useful for implementing `switch`/`case` constructions.
**Category:** Dict Special (dict\_special)
```fift title="Fift" DICTIGETJMP ``` #### `F4A1` DICTUGETJMP [#f4a1-dictugetjmp] Similar to `DICTIGETJMP`, but performs `DICTUGET` instead of `DICTIGET`.
**Category:** Dict Special (dict\_special)
```fift title="Fift" DICTUGETJMP ``` #### `F4A2` DICTIGETEXEC [#f4a2-dictigetexec] Similar to `DICTIGETJMP`, but with `EXECUTE` instead of `JMPX`.
**Category:** Dict Special (dict\_special)
```fift title="Fift" DICTIGETEXEC ``` #### `F4A3` DICTUGETEXEC [#f4a3-dictugetexec] Similar to `DICTUGETJMP`, but with `EXECUTE` instead of `JMPX`.
**Category:** Dict Special (dict\_special)
```fift title="Fift" DICTUGETEXEC ``` #### `F4A6_n` DICTPUSHCONST [#f4a6_n-dictpushconst] Pushes a non-empty constant dictionary `D` (as a `Cell^?`) along with its key length `0 <= n <= 1023`, stored as a part of the instruction. The dictionary itself is created from the first of remaining references of the current continuation. In this way, the complete `DICTPUSHCONST` instruction can be obtained by first serializing `xF4A4_`, then the non-empty dictionary itself (one `1` bit and a cell reference), and then the unsigned 10-bit integer `n` (as if by a `STU 10` instruction). An empty dictionary can be pushed by a `NEWDICT` primitive instead.
**Category:** Dict Special (dict\_special)
```fift title="Fift" [ref] [n] DICTPUSHCONST ``` #### `F4A8` PFXDICTGETQ [#f4a8-pfxdictgetq] Looks up the unique prefix of *Slice* `s` present in the prefix code dictionary represented by `Cell^?` `D` and `0 <= n <= 1023`. If found, the prefix of `s` is returned as `s'`, and the corresponding value (also a *Slice*) as `x`. The remainder of `s` is returned as a *Slice* `s''`. If no prefix of `s` is a key in prefix code dictionary `D`, returns the unchanged `s` and a zero flag to indicate failure.
**Category:** Dict Special (dict\_special)
```fift title="Fift" PFXDICTGETQ ``` #### `F4A9` PFXDICTGET [#f4a9-pfxdictget] Similar to `PFXDICTGET`, but throws a cell deserialization failure exception on failure.
**Category:** Dict Special (dict\_special)
```fift title="Fift" PFXDICTGET ``` #### `F4AA` PFXDICTGETJMP [#f4aa-pfxdictgetjmp] Similar to `PFXDICTGETQ`, but on success `BLESS`es the value `x` into a *Continuation* and transfers control to it as if by a `JMPX`. On failure, returns `s` unchanged and continues execution.
**Category:** Dict Special (dict\_special)
```fift title="Fift" PFXDICTGETJMP ``` #### `F4AB` PFXDICTGETEXEC [#f4ab-pfxdictgetexec] Similar to `PFXDICTGETJMP`, but `EXEC`utes the continuation found instead of jumping to it. On failure, throws a cell deserialization exception.
**Category:** Dict Special (dict\_special)
```fift title="Fift" PFXDICTGETEXEC ``` #### `F4AE_n` PFXDICTCONSTGETJMP [#f4ae_n-pfxdictconstgetjmp] Combines `[n] DICTPUSHCONST` for `0 <= n <= 1023` with `PFXDICTGETJMP`.
**Category:** Dict Special (dict\_special)
```fift title="Fift" [ref] [n] PFXDICTCONSTGETJMP [ref] [n] PFXDICTSWITCH ``` #### `F4BC` DICTIGETJMPZ [#f4bc-dictigetjmpz] A variant of `DICTIGETJMP` that returns index `i` on failure.
**Category:** Dict Special (dict\_special)
```fift title="Fift" DICTIGETJMPZ ``` #### `F4BD` DICTUGETJMPZ [#f4bd-dictugetjmpz] A variant of `DICTUGETJMP` that returns index `i` on failure.
**Category:** Dict Special (dict\_special)
```fift title="Fift" DICTUGETJMPZ ``` #### `F4BE` DICTIGETEXECZ [#f4be-dictigetexecz] A variant of `DICTIGETEXEC` that returns index `i` on failure.
**Category:** Dict Special (dict\_special)
```fift title="Fift" DICTIGETEXECZ ``` #### `F4BF` DICTUGETEXECZ [#f4bf-dictugetexecz] A variant of `DICTUGETEXEC` that returns index `i` on failure.
**Category:** Dict Special (dict\_special)
```fift title="Fift" DICTUGETEXECZ ``` #### `F4B1` SUBDICTGET [#f4b1-subdictget] Constructs a subdictionary consisting of all keys beginning with prefix `k` (represented by a *Slice*, the first `0 <= l <= n <= 1023` data bits of which are used as a key) of length `l` in dictionary `D` of type `HashmapE(n,X)` with `n`-bit keys. On success, returns the new subdictionary of the same type `HashmapE(n,X)` as a *Slice* `D'`.
**Category:** Dict Sub (dict\_sub)
```fift title="Fift" SUBDICTGET ``` #### `F4B2` SUBDICTIGET [#f4b2-subdictiget] Variant of `SUBDICTGET` with the prefix represented by a signed big-endian `l`-bit *Integer* `x`, where necessarily `l <= 257`.
**Category:** Dict Sub (dict\_sub)
```fift title="Fift" SUBDICTIGET ``` #### `F4B3` SUBDICTUGET [#f4b3-subdictuget] Variant of `SUBDICTGET` with the prefix represented by an unsigned big-endian `l`-bit *Integer* `x`, where necessarily `l <= 256`.
**Category:** Dict Sub (dict\_sub)
```fift title="Fift" SUBDICTUGET ``` #### `F4B5` SUBDICTRPGET [#f4b5-subdictrpget] Similar to `SUBDICTGET`, but removes the common prefix `k` from all keys of the new dictionary `D'`, which becomes of type `HashmapE(n-l,X)`.
**Category:** Dict Sub (dict\_sub)
```fift title="Fift" SUBDICTRPGET ``` #### `F4B6` SUBDICTIRPGET [#f4b6-subdictirpget] Variant of `SUBDICTRPGET` with the prefix represented by a signed big-endian `l`-bit *Integer* `x`, where necessarily `l <= 257`.
**Category:** Dict Sub (dict\_sub)
```fift title="Fift" SUBDICTIRPGET ``` #### `F4B7` SUBDICTURPGET [#f4b7-subdicturpget] Variant of `SUBDICTRPGET` with the prefix represented by an unsigned big-endian `l`-bit *Integer* `x`, where necessarily `l <= 256`.
**Category:** Dict Sub (dict\_sub)
```fift title="Fift" SUBDICTURPGET ``` #### `F800` ACCEPT [#f800-accept] Sets current gas limit `g_l` to its maximal allowed value `g_m`, and resets the gas credit `g_c` to zero, decreasing the value of `g_r` by `g_c` in the process.
In other words, the current smart contract agrees to buy some gas to finish the current transaction. This action is required to process external messages, which bring no value (hence no gas) with themselves.
**Category:** App Gas (app\_gas)
```fift title="Fift" ACCEPT ``` #### `F801` SETGASLIMIT [#f801-setgaslimit] Sets current gas limit `g_l` to the minimum of `g` and `g_m`, and resets the gas credit `g_c` to zero. If the gas consumed so far (including the present instruction) exceeds the resulting value of `g_l`, an (unhandled) out of gas exception is thrown before setting new gas limits. Notice that `SETGASLIMIT` with an argument `g >= 2^63-1` is equivalent to `ACCEPT`.
**Category:** App Gas (app\_gas)
```fift title="Fift" SETGASLIMIT ``` #### `F807` GASCONSUMED [#f807-gasconsumed] Returns gas consumed by VM so far (including this instruction).
**Category:** App Gas (app\_gas)
```fift title="Fift" GASCONSUMED ``` #### `F80F` COMMIT [#f80f-commit] Commits the current state of registers `c4` (''persistent data'') and `c5` (''actions'') so that the current execution is considered ''successful'' with the saved values even if an exception is thrown later.
**Category:** App Gas (app\_gas)
```fift title="Fift" COMMIT ``` #### `F810` RANDU256 [#f810-randu256] Generates a new pseudo-random unsigned 256-bit *Integer* `x`. The algorithm is as follows: if `r` is the old value of the random seed, considered as a 32-byte array (by constructing the big-endian representation of an unsigned 256-bit integer), then its `sha512(r)` is computed; the first 32 bytes of this hash are stored as the new value `r'` of the random seed, and the remaining 32 bytes are returned as the next random value `x`.
**Category:** App Rnd (app\_rnd)
```fift title="Fift" RANDU256 ``` #### `F811` RAND [#f811-rand] Generates a new pseudo-random integer `z` in the range `0...y-1` (or `y...-1`, if `y<0`). More precisely, an unsigned random value `x` is generated as in `RAND256U`; then `z:=floor(x*y/2^256)` is computed.
Equivalent to `RANDU256` `256 MULRSHIFT`.
**Category:** App Rnd (app\_rnd)
```fift title="Fift" RAND ``` #### `F814` SETRAND [#f814-setrand] Sets the random seed to unsigned 256-bit *Integer* `x`.
**Category:** App Rnd (app\_rnd)
```fift title="Fift" SETRAND ``` #### `F815` ADDRAND [#f815-addrand] Mixes unsigned 256-bit *Integer* `x` into the random seed `r` by setting the random seed to `Sha` of the concatenation of two 32-byte strings: the first with the big-endian representation of the old seed `r`, and the second with the big-endian representation of `x`.
**Category:** App Rnd (app\_rnd)
```fift title="Fift" ADDRAND RANDOMIZE ``` #### `F82i` GETPARAM [#f82i-getparam] Returns the `i`-th parameter from the *Tuple* provided at `c7` for `0 <= i <= 15`. Equivalent to `c7 PUSHCTR` `FIRST` `[i] INDEX`.
If one of these internal operations fails, throws an appropriate type checking or range checking exception.
**Category:** App Config (app\_config)
```fift title="Fift" [i] GETPARAM ``` **Aliases**: * `NOW`
Returns the current Unix time as an *Integer*. If it is impossible to recover the requested value starting from `c7`, throws a type checking or range checking exception as appropriate.
Equivalent to `3 GETPARAM`. * `BLOCKLT`
Returns the starting logical time of the current block.
Equivalent to `4 GETPARAM`. * `LTIME`
Returns the logical time of the current transaction.
Equivalent to `5 GETPARAM`. * `RANDSEED`
Returns the current random seed as an unsigned 256-bit *Integer*.
Equivalent to `6 GETPARAM`. * `BALANCE`
Returns the remaining balance of the smart contract as a *Tuple* consisting of an *Integer* (the remaining Gram balance in nanograms) and a *Maybe Cell* (a dictionary with 32-bit keys representing the balance of ''extra currencies'').
Equivalent to `7 GETPARAM`.
Note that `RAW` primitives such as `SENDRAWMSG` do not update this field. * `MYADDR`
Returns the internal address of the current smart contract as a *Slice* with a `MsgAddressInt`. If necessary, it can be parsed further using primitives such as `PARSEMSGADDR` or `REWRITESTDADDR`.
Equivalent to `8 GETPARAM`. * `CONFIGROOT`
Returns the *Maybe Cell* `D` with the current global configuration dictionary. Equivalent to `9 GETPARAM `. * `MYCODE`
Retrieves code of smart-contract from c7. Equivalent to `10 GETPARAM `. * `INCOMINGVALUE`
Retrieves value of incoming message from c7. Equivalent to `11 GETPARAM `. * `STORAGEFEES`
Retrieves value of storage phase fees from c7. Equivalent to `12 GETPARAM `. * `PREVBLOCKSINFOTUPLE`
Retrives PrevBlocksInfo: `[last_mc_blocks, prev_key_block]` from c7. Equivalent to `13 GETPARAM `. * `UNPACKEDCONFIGTUPLE`
Retrives tuple that contains some config parameters as cell slices. If the parameter is absent from the config, the value is null. Values:
\* **0**: `StoragePrices` from `ConfigParam 18`. Not the whole dict, but only the one StoragePrices entry (one which corresponds to the current time).
\* **1**: `ConfigParam 19` (global id).
\* **2**: `ConfigParam 20` (mc gas prices).
\* **3**: `ConfigParam 21` (gas prices).
\* **4**: `ConfigParam 24` (mc fwd fees).
\* **5**: `ConfigParam 25` (fwd fees).
\* **6**: `ConfigParam 43` (size limits). * `DUEPAYMENT`
Retrives current debt for storage fee (nanograms). #### `F830` CONFIGDICT [#f830-configdict] Returns the global configuration dictionary along with its key length (32).
Equivalent to `CONFIGROOT` `32 PUSHINT`.
**Category:** App Config (app\_config)
```fift title="Fift" CONFIGDICT ``` #### `F832` CONFIGPARAM [#f832-configparam] Returns the value of the global configuration parameter with integer index `i` as a *Cell* `c`, and a flag to indicate success.
Equivalent to `CONFIGDICT` `DICTIGETREF`.
**Category:** App Config (app\_config)
```fift title="Fift" CONFIGPARAM ``` #### `F833` CONFIGOPTPARAM [#f833-configoptparam] Returns the value of the global configuration parameter with integer index `i` as a *Maybe Cell* `c^?`.
Equivalent to `CONFIGDICT` `DICTIGETOPTREF`.
**Category:** App Config (app\_config)
```fift title="Fift" CONFIGOPTPARAM ``` #### `F83400` PREVMCBLOCKS [#f83400-prevmcblocks] Retrives `last_mc_blocks` part of PrevBlocksInfo from c7 (parameter 13).
**Category:** App Config (app\_config)
```fift title="Fift" PREVMCBLOCKS ``` #### `F83401` PREVKEYBLOCK [#f83401-prevkeyblock] Retrives `prev_key_block` part of PrevBlocksInfo from c7 (parameter 13).
**Category:** App Config (app\_config)
```fift title="Fift" PREVKEYBLOCK ``` #### `F83402` PREVMCBLOCKS\_100 [#f83402-prevmcblocks_100] Retrives `last_mc_blocks_divisible_by_100` part of PrevBlocksInfo from c7 (parameter 13).
**Category:** App Config (app\_config)
```fift title="Fift" PREVMCBLOCKS_100 ``` #### `F835` GLOBALID [#f835-globalid] Retrieves `global_id` from 19 network config.
**Category:** App Config (app\_config)
```fift title="Fift" GLOBALID ``` #### `F836` GETGASFEE [#f836-getgasfee] Calculates gas fee
**Category:** App Config (app\_config)
```fift title="Fift" GETGASFEE ``` #### `F837` GETSTORAGEFEE [#f837-getstoragefee] Calculates storage fees (only current StoragePrices entry is used).
**Category:** App Config (app\_config)
```fift title="Fift" GETSTORAGEFEE ``` #### `F838` GETFORWARDFEE [#f838-getforwardfee] Calculates forward fee.
**Category:** App Config (app\_config)
```fift title="Fift" GETFORWARDFEE ``` #### `F839` GETPRECOMPILEDGAS [#f839-getprecompiledgas] Returns gas usage for the current contract if it is precompiled, `null` otherwise.
**Category:** App Config (app\_config)
```fift title="Fift" GETPRECOMPILEDGAS ``` #### `F83A` GETORIGINALFWDFEE [#f83a-getoriginalfwdfee] Calculate `(fwd_fee * 2^16) / (2^16 - first_frac)`. Can be used to get the original `fwd_fee` of the message.
**Category:** App Config (app\_config)
```fift title="Fift" GETORIGINALFWDFEE ``` #### `F83B` GETGASFEESIMPLE [#f83b-getgasfeesimple] Same as `GETGASFEE`, but without flat price (just `(gas_used * price) / 2^16)`.
**Category:** App Config (app\_config)
```fift title="Fift" GETGASFEESIMPLE ``` #### `F83C` GETFORWARDFEESIMPLE [#f83c-getforwardfeesimple] Same as `GETFORWARDFEE`, but without lump price (just (`bits*bit_price + cells*cell_price) / 2^16`).
**Category:** App Config (app\_config)
```fift title="Fift" GETFORWARDFEESIMPLE ``` #### `F840` GETGLOBVAR [#f840-getglobvar] Returns the `k`-th global variable for `0 <= k < 255`.
Equivalent to `c7 PUSHCTR` `SWAP` `INDEXVARQ`.
**Category:** App Global (app\_global)
```fift title="Fift" GETGLOBVAR ``` #### `F85_k` GETGLOB [#f85_k-getglob] Returns the `k`-th global variable for `1 <= k <= 31`.
Equivalent to `c7 PUSHCTR` `[k] INDEXQ`.
**Category:** App Global (app\_global)
```fift title="Fift" [k] GETGLOB ``` #### `F860` SETGLOBVAR [#f860-setglobvar] Assigns `x` to the `k`-th global variable for `0 <= k < 255`.
Equivalent to `c7 PUSHCTR` `ROTREV` `SETINDEXVARQ` `c7 POPCTR`.
**Category:** App Global (app\_global)
```fift title="Fift" SETGLOBVAR ``` #### `F87_k` SETGLOB [#f87_k-setglob] Assigns `x` to the `k`-th global variable for `1 <= k <= 31`.
Equivalent to `c7 PUSHCTR` `SWAP` `k SETINDEXQ` `c7 POPCTR`.
**Category:** App Global (app\_global)
```fift title="Fift" [k] SETGLOB ``` #### `F880` GETEXTRABALANCE [#f880-getextrabalance] Takes id of the extra currency (integer in range `0..2^32-1`), returns the amount of this extra currency on the account balance. The first `5` executions of `GETEXTRABALANCE` consume at most `26 + 200` gas each. The subsequent executions incur the full gas cost of `26` (normal instruction cost) plus gas for loading cells (up to `3300` if the dictionary has maximum depth).
**Category:** App Global (app\_global)
```fift title="Fift" GETEXTRABALANCE ``` #### `F881ii` GETPARAMLONG [#f881ii-getparamlong] Returns the `i`-th parameter from the *Tuple* provided at `c7` for `0 <= i <= 255`. Equivalent to `c7 PUSHCTR` `FIRST` `[i] INDEX`.
If one of these internal operations fails, throws an appropriate type checking or range checking exception.
**Category:** App Config (app\_config)
```fift title="Fift" [i] GETPARAMLONG ``` #### `F89i` INMSGPARAM [#f89i-inmsgparam] Equivalent to `INMSGPARAMS` `i INDEX`
**Category:** App Config (app\_config)
```fift title="Fift" [i] INMSGPARAM ``` **Aliases**: * `INMSG_BOUNCE`
Retrives `bounce` flag of incoming message. * `INMSG_BOUNCED`
Retrives `bounced` flag of incoming message. * `INMSG_SRC`
Retrives `src` flag of incoming message. * `INMSG_FWDFEE`
Retrives `fwd_fee` field of incoming message. * `INMSG_LT`
Retrives `lt` field of incoming message. * `INMSG_UTIME`
Retrives `utime` field of incoming message. * `INMSG_ORIGVALUE`
Retrives original value of the message. This is sometimes different from the value in `INCOMINGVALUE` and TVM stack because of storage fees. * `INMSG_VALUE`
Retrives value of the message after deducting storage fees. This is same as in `INCOMINGVALUE` and TVM stack. * `INMSG_VALUEEXTRA`
Same as in `INCOMINGVALUE`. * `INMSG_STATEINIT`
Retrieves `init` field of the incoming message. #### `F900` HASHCU [#f900-hashcu] Computes the representation hash of a *Cell* `c` and returns it as a 256-bit unsigned integer `x`. Useful for signing and checking signatures of arbitrary entities represented by a tree of cells.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHCU ``` #### `F901` HASHSU [#f901-hashsu] Computes the hash of a *Slice* `s` and returns it as a 256-bit unsigned integer `x`. The result is the same as if an ordinary cell containing only data and references from `s` had been created and its hash computed by `HASHCU`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHSU ``` #### `F902` SHA256U [#f902-sha256u] Computes `Sha` of the data bits of *Slice* `s`. If the bit length of `s` is not divisible by eight, throws a cell underflow exception. The hash value is returned as a 256-bit unsigned integer `x`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" SHA256U ``` #### `F90400` HASHEXT\_SHA256 [#f90400-hashext_sha256] Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXT_SHA256 ``` #### `F90401` HASHEXT\_SHA512 [#f90401-hashext_sha512] Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXT_SHA512 ``` #### `F90402` HASHEXT\_BLAKE2B [#f90402-hashext_blake2b] Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXT_BLAKE2B ``` #### `F90403` HASHEXT\_KECCAK256 [#f90403-hashext_keccak256] Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXT_KECCAK256 ``` #### `F90404` HASHEXT\_KECCAK512 [#f90404-hashext_keccak512] Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXT_KECCAK512 ``` #### `F90500` HASHEXTR\_SHA256 [#f90500-hashextr_sha256] Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXTR_SHA256 ``` #### `F90501` HASHEXTR\_SHA512 [#f90501-hashextr_sha512] Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXTR_SHA512 ``` #### `F90502` HASHEXTR\_BLAKE2B [#f90502-hashextr_blake2b] Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXTR_BLAKE2B ``` #### `F90503` HASHEXTR\_KECCAK256 [#f90503-hashextr_keccak256] Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXTR_KECCAK256 ``` #### `F90504` HASHEXTR\_KECCAK512 [#f90504-hashextr_keccak512] Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXTR_KECCAK512 ``` #### `F90600` HASHEXTA\_SHA256 [#f90600-hashexta_sha256] Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXTA_SHA256 ``` #### `F90601` HASHEXTA\_SHA512 [#f90601-hashexta_sha512] Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXTA_SHA512 ``` #### `F90602` HASHEXTA\_BLAKE2B [#f90602-hashexta_blake2b] Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXTA_BLAKE2B ``` #### `F90603` HASHEXTA\_KECCAK256 [#f90603-hashexta_keccak256] Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXTA_KECCAK256 ``` #### `F90604` HASHEXTA\_KECCAK512 [#f90604-hashexta_keccak512] Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXTA_KECCAK512 ``` #### `F90700` HASHEXTAR\_SHA256 [#f90700-hashextar_sha256] Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXTAR_SHA256 ``` #### `F90701` HASHEXTAR\_SHA512 [#f90701-hashextar_sha512] Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXTAR_SHA512 ``` #### `F90702` HASHEXTAR\_BLAKE2B [#f90702-hashextar_blake2b] Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXTAR_BLAKE2B ``` #### `F90703` HASHEXTAR\_KECCAK256 [#f90703-hashextar_keccak256] Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXTAR_KECCAK256 ``` #### `F90704` HASHEXTAR\_KECCAK512 [#f90704-hashextar_keccak512] Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHEXTAR_KECCAK512 ``` #### `F910` CHKSIGNU [#f910-chksignu] Checks the Ed25519-signature `s` of a hash `h` (a 256-bit unsigned integer, usually computed as the hash of some data) using public key `k` (also represented by a 256-bit unsigned integer).
The signature `s` must be a *Slice* containing at least 512 data bits; only the first 512 bits are used. The result is `-1` if the signature is valid, `0` otherwise.
Notice that `CHKSIGNU` is equivalent to `ROT` `NEWC` `256 STU` `ENDC` `ROTREV` `CHKSIGNS`, i.e., to `CHKSIGNS` with the first argument `d` set to 256-bit *Slice* containing `h`. Therefore, if `h` is computed as the hash of some data, these data are hashed *twice*, the second hashing occurring inside `CHKSIGNS`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" CHKSIGNU ``` #### `F911` CHKSIGNS [#f911-chksigns] Checks whether `s` is a valid Ed25519-signature of the data portion of *Slice* `d` using public key `k`, similarly to `CHKSIGNU`. If the bit length of *Slice* `d` is not divisible by eight, throws a cell underflow exception. The verification of Ed25519 signatures is the standard one, with `Sha` used to reduce `d` to the 256-bit number that is actually signed.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" CHKSIGNS ``` #### `F912` ECRECOVER [#f912-ecrecover] Recovers the public key from a secp256k1 signature, identical to Bitcoin/Ethereum operations. Takes a 32-byte hash as `uint256 hash` and a 65-byte signature as `uint8 v`, `uint256 r`, and `uint256 s`. In TON, the `v` value is strictly 0 or 1; no extra flags or extended values are supported. If the public key cannot be recovered, the instruction returns `0`. On success, it returns the recovered 65-byte public key as `uint8 h`, `uint256 x1`, and `uint256 x2`, followed by `-1`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" ECRECOVER ``` #### `F913` SECP256K1\_XONLY\_PUBKEY\_TWEAK\_ADD [#f913-secp256k1_xonly_pubkey_tweak_add] performs [`secp256k1_xonly_pubkey_tweak_add`](https://github.com/bitcoin-core/secp256k1/blob/master/include/secp256k1_extrakeys.h#L120). `key` and `tweak` are 256-bit unsigned integers. 65-byte public key is returned as `uint8 f`, `uint256 x, y` (as in `ECRECOVER`).
**Category:** App Crypto (app\_crypto)
```fift title="Fift" SECP256K1_XONLY_PUBKEY_TWEAK_ADD ``` #### `F914` P256\_CHKSIGNU [#f914-p256_chksignu] Checks seck256r1-signature `sig` of a number `h` (a 256-bit unsigned integer, usually computed as the hash of some data) and public key `k`. Returns -1 on success, 0 on failure. Public key is a 33-byte slice (encoded according to Sec. 2.3.4 point 2 of [SECG SEC 1](https://www.secg.org/sec1-v2.pdf)). Signature `sig` is a 64-byte slice (two 256-bit unsigned integers `r` and `s`).
**Category:** App Crypto (app\_crypto)
```fift title="Fift" P256_CHKSIGNU ``` #### `F915` P256\_CHKSIGNS [#f915-p256_chksigns] Checks seck256r1-signature `sig` of data portion of slice `d` and public key `k`. Returns -1 on success, 0 on failure. Public key is a 33-byte slice (encoded according to Sec. 2.3.4 point 2 of [SECG SEC 1](https://www.secg.org/sec1-v2.pdf)). Signature `sig` is a 64-byte slice (two 256-bit unsigned integers `r` and `s`).
**Category:** App Crypto (app\_crypto)
```fift title="Fift" P256_CHKSIGNS ``` #### `F916` HASHBU [#f916-hashbu] Same as `ENDC HASHCU`, but without gas cost for cell creation.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" HASHBU ``` #### `F920` RIST255\_FROMHASH [#f920-rist255_fromhash] Deterministically generates a valid point `x` from a 512-bit hash (given as two 256-bit integers).
**Category:** App Crypto (app\_crypto)
```fift title="Fift" RIST255_FROMHASH ``` #### `F921` RIST255\_VALIDATE [#f921-rist255_validate] Checks that integer `x` is a valid representation of some curve point. Throws range\_chk on error.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" RIST255_VALIDATE ``` #### `F922` RIST255\_ADD [#f922-rist255_add] Addition of two points on a curve.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" RIST255_ADD ``` #### `F923` RIST255\_SUB [#f923-rist255_sub] Subtraction of two points on curve.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" RIST255_SUB ``` #### `F924` RIST255\_MUL [#f924-rist255_mul] Multiplies point `x` by a scalar `n`. Any `n` is valid, including negative.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" RIST255_MUL ``` #### `F925` RIST255\_MULBASE [#f925-rist255_mulbase] Multiplies the generator point `g` by a scalar `n`. Any `n` is valid, including negative.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" RIST255_MULBASE ``` #### `F926` RIST255\_PUSHL [#f926-rist255_pushl] Pushes integer l=2^252+27742317777372353535851937790883648493, which is the order of the group.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" RIST255_PUSHL ``` #### `B7F921` RIST255\_QVALIDATE [#b7f921-rist255_qvalidate] Checks that integer `x` is a valid representation of some curve point. Returns -1 on success and 0 on failure.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" RIST255_QVALIDATE ``` #### `B7F922` RIST255\_QADD [#b7f922-rist255_qadd] Addition of two points on a curve. Returns -1 on success and 0 on failure.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" RIST255_QADD ``` #### `B7F923` RIST255\_QSUB [#b7f923-rist255_qsub] Subtraction of two points on curve. Returns -1 on success and 0 on failure.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" RIST255_QSUB ``` #### `B7F924` RIST255\_QMUL [#b7f924-rist255_qmul] Multiplies point `x` by a scalar `n`. Any `n` is valid, including negative. Returns -1 on success and 0 on failure.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" RIST255_QMUL ``` #### `B7F925` RIST255\_QMULBASE [#b7f925-rist255_qmulbase] Multiplies the generator point `g` by a scalar `n`. Any `n` is valid, including negative.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" RIST255_QMULBASE ``` #### `F93000` BLS\_VERIFY [#f93000-bls_verify] Checks BLS signature, return true on success, false otherwise.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_VERIFY ``` #### `F93001` BLS\_AGGREGATE [#f93001-bls_aggregate] Aggregates signatures. `n>0`. Throw exception if `n=0` or if some `sig_i` is not a valid signature.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_AGGREGATE ``` #### `F93002` BLS\_FASTAGGREGATEVERIFY [#f93002-bls_fastaggregateverify] Checks aggregated BLS signature for keys `pk_1...pk_n` and message `msg`. Return true on success, false otherwise. Return false if `n=0`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_FASTAGGREGATEVERIFY ``` #### `F93003` BLS\_AGGREGATEVERIFY [#f93003-bls_aggregateverify] Checks aggregated BLS signature for key-message pairs `pk_1 msg_1...pk_n msg_n`. Return true on success, false otherwise. Return false if `n=0`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_AGGREGATEVERIFY ``` #### `F93010` BLS\_G1\_ADD [#f93010-bls_g1_add] Addition on G1.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G1_ADD ``` #### `F93011` BLS\_G1\_SUB [#f93011-bls_g1_sub] Subtraction on G1.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G1_SUB ``` #### `F93012` BLS\_G1\_NEG [#f93012-bls_g1_neg] Negation on G1.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G1_NEG ``` #### `F93013` BLS\_G1\_MUL [#f93013-bls_g1_mul] Multiplies G1 point `x` by scalar `s`. Any `s` is valid, including negative.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G1_MUL ``` #### `F93014` BLS\_G1\_MULTIEXP [#f93014-bls_g1_multiexp] Calculates `x_1*s_1+...+x_n*s_n` for G1 points `x_i` and scalars `s_i`. Returns zero point if `n=0`. Any `s_i` is valid, including negative.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G1_MULTIEXP ``` #### `F93015` BLS\_G1\_ZERO [#f93015-bls_g1_zero] Pushes zero point in G1.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G1_ZERO ``` #### `F93016` BLS\_MAP\_TO\_G1 [#f93016-bls_map_to_g1] Converts FP element `f` to a G1 point.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_MAP_TO_G1 ``` #### `F93017` BLS\_G1\_INGROUP [#f93017-bls_g1_ingroup] Checks that slice `x` represents a valid element of G1.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G1_INGROUP ``` #### `F93018` BLS\_G1\_ISZERO [#f93018-bls_g1_iszero] Checks that G1 point `x` is equal to zero.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G1_ISZERO ``` #### `F93020` BLS\_G2\_ADD [#f93020-bls_g2_add] Addition on G2.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G2_ADD ``` #### `F93021` BLS\_G2\_SUB [#f93021-bls_g2_sub] Subtraction on G2.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G2_SUB ``` #### `F93022` BLS\_G2\_NEG [#f93022-bls_g2_neg] Negation on G2.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G2_NEG ``` #### `F93023` BLS\_G2\_MUL [#f93023-bls_g2_mul] Multiplies G2 point `x` by scalar `s`. Any `s` is valid, including negative.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G2_MUL ``` #### `F93024` BLS\_G2\_MULTIEXP [#f93024-bls_g2_multiexp] Calculates `x_1*s_1+...+x_n*s_n` for G2 points `x_i` and scalars `s_i`. Returns zero point if `n=0`. Any `s_i` is valid, including negative.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G2_MULTIEXP ``` #### `F93025` BLS\_G2\_ZERO [#f93025-bls_g2_zero] Pushes zero point in G2.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G2_ZERO ``` #### `F93026` BLS\_MAP\_TO\_G2 [#f93026-bls_map_to_g2] Converts FP2 element `f` to a G2 point.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_MAP_TO_G2 ``` #### `F93027` BLS\_G2\_INGROUP [#f93027-bls_g2_ingroup] Checks that slice `x` represents a valid element of G2.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G2_INGROUP ``` #### `F93028` BLS\_G2\_ISZERO [#f93028-bls_g2_iszero] Checks that G2 point `x` is equal to zero.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_G2_ISZERO ``` #### `F93030` BLS\_PAIRING [#f93030-bls_pairing] Given G1 points `x_i` and G2 points `y_i`, calculates and multiply pairings of `x_i,y_i`. Returns true if the result is the multiplicative identity in FP12, false otherwise. Returns false if `n=0`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_PAIRING ``` #### `F93031` BLS\_PUSHR [#f93031-bls_pushr] Pushes the order of G1 and G2 (approx. `2^255`).
**Category:** App Crypto (app\_crypto)
```fift title="Fift" BLS_PUSHR ``` #### `F940` CDATASIZEQ [#f940-cdatasizeq] Recursively computes the count of distinct cells `x`, data bits `y`, and cell references `z` in the dag rooted at *Cell* `c`, effectively returning the total storage used by this dag taking into account the identification of equal cells. The values of `x`, `y`, and `z` are computed by a depth-first traversal of this dag, with a hash table of visited cell hashes used to prevent visits of already-visited cells. The total count of visited cells `x` cannot exceed non-negative *Integer* `n`; otherwise the computation is aborted before visiting the `(n+1)`-st cell and a zero is returned to indicate failure. If `c` is *Null*, returns `x=y=z=0`.
**Category:** App Misc (app\_misc)
```fift title="Fift" CDATASIZEQ ``` #### `F941` CDATASIZE [#f941-cdatasize] A non-quiet version of `CDATASIZEQ` that throws a cell overflow exception (8) on failure.
**Category:** App Misc (app\_misc)
```fift title="Fift" CDATASIZE ``` #### `F942` SDATASIZEQ [#f942-sdatasizeq] Similar to `CDATASIZEQ`, but accepting a *Slice* `s` instead of a *Cell*. The returned value of `x` does not take into account the cell that contains the slice `s` itself; however, the data bits and the cell references of `s` are accounted for in `y` and `z`.
**Category:** App Misc (app\_misc)
```fift title="Fift" SDATASIZEQ ``` #### `F943` SDATASIZE [#f943-sdatasize] A non-quiet version of `SDATASIZEQ` that throws a cell overflow exception (8) on failure.
**Category:** App Misc (app\_misc)
```fift title="Fift" SDATASIZE ``` #### `FA00` LDGRAMS [#fa00-ldgrams] Loads (deserializes) a `Gram` or `VarUInteger 16` amount from *Slice* `s`, and returns the amount as *Integer* `x` along with the remainder `s'` of `s`. The expected serialization of `x` consists of a 4-bit unsigned big-endian integer `l`, followed by an `8l`-bit unsigned big-endian representation of `x`.
The net effect is approximately equivalent to `4 LDU` `SWAP` `3 LSHIFT#` `LDUX`.
**Category:** App Currency (app\_currency)
```fift title="Fift" LDGRAMS LDVARUINT16 ``` #### `FA01` LDVARINT16 [#fa01-ldvarint16] Similar to `LDVARUINT16`, but loads a *signed* *Integer* `x`.
Approximately equivalent to `4 LDU` `SWAP` `3 LSHIFT#` `LDIX`.
**Category:** App Currency (app\_currency)
```fift title="Fift" LDVARINT16 ``` #### `FA02` STGRAMS [#fa02-stgrams] Stores (serializes) an *Integer* `x` in the range `0...2^120-1` into *Builder* `b`, and returns the resulting *Builder* `b'`. The serialization of `x` consists of a 4-bit unsigned big-endian integer `l`, which is the smallest integer `l>=0`, such that `x<2^(8l)`, followed by an `8l`-bit unsigned big-endian representation of `x`. If `x` does not belong to the supported range, a range check exception is thrown.
**Category:** App Currency (app\_currency)
```fift title="Fift" STGRAMS STVARUINT16 ``` #### `FA03` STVARINT16 [#fa03-stvarint16] Similar to `STVARUINT16`, but serializes a *signed* *Integer* `x` in the range `-2^119...2^119-1`.
**Category:** App Currency (app\_currency)
```fift title="Fift" STVARINT16 ``` #### `FA04` LDVARUINT32 [#fa04-ldvaruint32] Loads (deserializes) a `VarUInteger 32` amount from *Slice* `s`, and returns the amount as *Integer* `x` along with the remainder `s'` of `s`. The expected serialization of `x` consists of a 5-bit unsigned big-endian integer `l`, followed by an `8l`-bit unsigned big-endian representation of `x`.
The net effect is approximately equivalent to `4 LDU` `SWAP` `3 LSHIFT#` `LDUX`.
**Category:** App Currency (app\_currency)
```fift title="Fift" LDVARUINT32 ``` #### `FA05` LDVARINT32 [#fa05-ldvarint32] Similar to `LDVARUINT32`, but loads a *signed* *Integer* `x`.
Approximately equivalent to `5 LDU` `SWAP` `3 LSHIFT#` `LDIX`.
**Category:** App Currency (app\_currency)
```fift title="Fift" LDVARINT32 ``` #### `FA06` STVARUINT32 [#fa06-stvaruint32] Stores (serializes) an *Integer* `x` in the range `0...2^248-1` into *Builder* `b`, and returns the resulting *Builder* `b'`. The serialization of `x` consists of a 5-bit unsigned big-endian integer `l`, which is the smallest integer `l>=0`, such that `x<2^(8l)`, followed by an `8l`-bit unsigned big-endian representation of `x`. If `x` does not belong to the supported range, a range check exception is thrown.
**Category:** App Currency (app\_currency)
```fift title="Fift" STVARUINT32 ``` #### `FA07` STVARINT32 [#fa07-stvarint32] Similar to `STVARUINT32`, but serializes a *signed* *Integer* `x` in the range `-2^247...2^247-1`.
**Category:** App Currency (app\_currency)
```fift title="Fift" STVARINT32 ``` #### `FA40` LDMSGADDR [#fa40-ldmsgaddr] Loads from *Slice* `s` the only prefix that is a valid `MsgAddress`, and returns both this prefix `s'` and the remainder `s''` of `s` as slices.
**Category:** App Addr (app\_addr)
```fift title="Fift" LDMSGADDR ``` #### `FA41` LDMSGADDRQ [#fa41-ldmsgaddrq] A quiet version of `LDMSGADDR`: on success, pushes an extra `-1`; on failure, pushes the original `s` and a zero.
**Category:** App Addr (app\_addr)
```fift title="Fift" LDMSGADDRQ ``` #### `FA42` PARSEMSGADDR [#fa42-parsemsgaddr] Decomposes *Slice* `s` containing a valid `MsgAddress` into a *Tuple* `t` with separate fields of this `MsgAddress`. If `s` is not a valid `MsgAddress`, a cell deserialization exception is thrown.
**Category:** App Addr (app\_addr)
```fift title="Fift" PARSEMSGADDR ``` #### `FA43` PARSEMSGADDRQ [#fa43-parsemsgaddrq] A quiet version of `PARSEMSGADDR`: returns a zero on error instead of throwing an exception.
**Category:** App Addr (app\_addr)
```fift title="Fift" PARSEMSGADDRQ ``` #### `FA44` REWRITESTDADDR [#fa44-rewritestdaddr] Parses *Slice* `s` containing a valid `MsgAddressInt` (usually a `msg_addr_std`), applies rewriting from the `anycast` (if present) to the same-length prefix of the address, and returns both the workchain `x` and the 256-bit address `y` as integers. If the address is not 256-bit, or if `s` is not a valid serialization of `MsgAddressInt`, throws a cell deserialization exception.
**Category:** App Addr (app\_addr)
```fift title="Fift" REWRITESTDADDR ``` #### `FA45` REWRITESTDADDRQ [#fa45-rewritestdaddrq] A quiet version of primitive `REWRITESTDADDR`.
**Category:** App Addr (app\_addr)
```fift title="Fift" REWRITESTDADDRQ ``` #### `FA46` REWRITEVARADDR [#fa46-rewritevaraddr] `msg_addr_var` not allowed since TVM v10, so it behaves like `REWRITESTDADDR`, but returns account id in `Slice`, not `Integer`: parses address `s` into workchain `x` and account id `s`.
**Category:** App Addr (app\_addr)
```fift title="Fift" REWRITEVARADDR ``` #### `FA47` REWRITEVARADDRQ [#fa47-rewritevaraddrq] A quiet version of primitive `REWRITEVARADDR`.
**Category:** App Addr (app\_addr)
```fift title="Fift" REWRITEVARADDRQ ``` #### `FA48` LDSTDADDR [#fa48-ldstdaddr] Loads `addr_std$10`, if address is not `addr_std`, throws an error 9 (`cannot load a MsgAddressInt`).
**Category:** App Addr (app\_addr)
```fift title="Fift" LDSTDADDR ``` #### `FA49` LDSTDADDRQ [#fa49-ldstdaddrq] A quiet version of primitive `LDSTDADDR`.
**Category:** App Addr (app\_addr)
```fift title="Fift" LDSTDADDRQ ``` #### `FA50` LDOPTSTDADDR [#fa50-ldoptstdaddr] Loads `addr_std$10` or `addr_none$00`, if address is `addr_none$00` pushes a Null, if address is not `addr_std` or `addr_none`, throws an error 9 (`cannot load a MsgAddressInt`).
**Category:** App Addr (app\_addr)
```fift title="Fift" LDOPTSTDADDR ``` #### `FA51` LDOPTSTDADDRQ [#fa51-ldoptstdaddrq] A quiet version of primitive `LDOPTSTDADDR`.
**Category:** App Addr (app\_addr)
```fift title="Fift" LDOPTSTDADDRQ ``` #### `FA52` STSTDADDR [#fa52-ststdaddr] Stores `addr_std$10`, if address is not `addr_std`, throws an error 9 (`cannot load a MsgAddressInt`).
**Category:** App Addr (app\_addr)
```fift title="Fift" STSTDADDR ``` #### `FA53` STSTDADDRQ [#fa53-ststdaddrq] A quiet version of primitive `STSTDADDR`.
**Category:** App Addr (app\_addr)
```fift title="Fift" STSTDADDRQ ``` #### `FA54` STOPTSTDADDR [#fa54-stoptstdaddr] stores `addr_std$10` or Null. Null is stored as `addr_none$00`, if address is not `addr_std`, throws an error 9 (`cannot load a MsgAddressInt`).
**Category:** App Addr (app\_addr)
```fift title="Fift" STOPTSTDADDR ``` #### `FA55` STOPTSTDADDRQ [#fa55-stoptstdaddrq] A quiet version of primitive `STOPTSTDADDR`.
**Category:** App Addr (app\_addr)
```fift title="Fift" STOPTSTDADDRQ ``` #### `FB00` SENDRAWMSG [#fb00-sendrawmsg] Sends a raw message contained in *Cell `c`*, which should contain a correctly serialized object `Message X`, with the only exception that the source address is allowed to have dummy value `addr_none` (to be automatically replaced with the current smart-contract address), and `ihr_fee`, `fwd_fee`, `created_lt` and `created_at` fields can have arbitrary values (to be rewritten with correct values during the action phase of the current transaction). Integer parameter `x` contains the flags. Currently `x=0` is used for ordinary messages; `x=128` is used for messages that are to carry all the remaining balance of the current smart contract (instead of the value originally indicated in the message); `x=64` is used for messages that carry all the remaining value of the inbound message in addition to the value initially indicated in the new message (if bit 0 is not set, the gas fees are deducted from this amount); `x'=x+1` means that the sender wants to pay transfer fees separately; `x'=x+2` means that any errors arising while processing this message during the action phase should be ignored. Finally, `x'=x+32` means that the current account must be destroyed if its resulting balance is zero. This flag is usually employed together with `+128`.
**Category:** App Actions (app\_actions)
```fift title="Fift" SENDRAWMSG ``` #### `FB02` RAWRESERVE [#fb02-rawreserve] Creates an output action which would reserve exactly `x` nanograms (if `y=0`), at most `x` nanograms (if `y=2`), or all but `x` nanograms (if `y=1` or `y=3`), from the remaining balance of the account. It is roughly equivalent to creating an outbound message carrying `x` nanograms (or `b-x` nanograms, where `b` is the remaining balance) to oneself, so that the subsequent output actions would not be able to spend more money than the remainder. Bit `+2` in `y` means that the external action does not fail if the specified amount cannot be reserved; instead, all remaining balance is reserved. Bit `+8` in `y` means `x:=-x` before performing any further actions. Bit `+4` in `y` means that `x` is increased by the original balance of the current account (before the compute phase), including all extra currencies, before performing any other checks and actions. Currently `x` must be a non-negative integer, and `y` must be in the range `0...15`.
**Category:** App Actions (app\_actions)
```fift title="Fift" RAWRESERVE ``` #### `FB03` RAWRESERVEX [#fb03-rawreservex] Similar to `RAWRESERVE`, but also accepts a dictionary `D` (represented by a *Cell* or *Null*) with extra currencies. In this way currencies other than Grams can be reserved.
**Category:** App Actions (app\_actions)
```fift title="Fift" RAWRESERVEX ``` #### `FB04` SETCODE [#fb04-setcode] Creates an output action that would change this smart contract code to that given by *Cell* `c`. Notice that this change will take effect only after the successful termination of the current run of the smart contract.
**Category:** App Actions (app\_actions)
```fift title="Fift" SETCODE ``` #### `FB06` SETLIBCODE [#fb06-setlibcode] Creates an output action that would modify the collection of this smart contract libraries by adding or removing library with code given in *Cell* `c`. If `x=0`, the library is actually removed if it was previously present in the collection (if not, this action does nothing). If `x=1`, the library is added as a private library, and if `x=2`, the library is added as a public library (and becomes available to all smart contracts if the current smart contract resides in the masterchain); if the library was present in the collection before, its public/private status is changed according to `x`. Values of `x` other than `0...2` are invalid.
**Category:** App Actions (app\_actions)
```fift title="Fift" SETLIBCODE ``` #### `FB07` CHANGELIB [#fb07-changelib] Creates an output action similarly to `SETLIBCODE`, but instead of the library code accepts its hash as an unsigned 256-bit integer `h`. If `x!=0` and the library with hash `h` is absent from the library collection of this smart contract, this output action will fail.
**Category:** App Actions (app\_actions)
```fift title="Fift" CHANGELIB ``` #### `FB08` SENDMSG [#fb08-sendmsg] Creates an output action and returns a fee for creating a message. Mode has the same effect as in the case of `SENDRAWMSG`. Additionally `+1024` means - do not create an action, only estimate fee. Other modes affect the fee calculation as follows: `+64` substitutes the entire balance of the incoming message as an outcoming value (slightly inaccurate, gas expenses that cannot be estimated before the computation is completed are not taken into account), `+128` substitutes the value of the entire balance of the contract before the start of the computation phase (slightly inaccurate, since gas expenses that cannot be estimated before the completion of the computation phase are not taken into account).
**Category:** App Actions (app\_actions)
```fift title="Fift" SENDMSG ``` #### `FEij` DEBUG [#feij-debug]
**Category:** Debug (debug)
```fift title="Fift" {i*16+j} DEBUG ``` **Aliases**: * `DUMPSTK`
Dumps the stack (at most the top 255 values) and shows the total stack depth. Does nothing on production versions of TVM. * `STRDUMP`
Dumps slice with length divisible by 8 from top of stack as a string. Does nothing on production versions of TVM. * `DUMP`
Dumps slice with length divisible by 8 from top of stack as a string. Does nothing on production versions of TVM. #### `FEFnssss` DEBUGSTR [#fefnssss-debugstr] `0 <= n < 16`. Length of `ssss` is `n+1` bytes.
`{string}` is a [string literal](https://github.com/Piterden/TON-docs/blob/master/Fift.%20A%20Brief%20Introduction.md#user-content-29-string-literals).
`DEBUGSTR`: `ssss` is the given string.
`DEBUGSTRI`: `ssss` is one-byte integer `0 <= x <= 255` followed by the given string.
**Category:** Debug (debug)
```fift title="Fift" {string} DEBUGSTR {string} {x} DEBUGSTRI ``` #### `FFnn` SETCP [#ffnn-setcp] Selects TVM codepage `0 <= nn < 240`. If the codepage is not supported, throws an invalid opcode exception.
**Category:** Codepage (codepage)
```fift title="Fift" [nn] SETCP ``` **Aliases**: * `SETCP0`
Selects TVM (test) codepage zero as described in this document. #### `FFFz` SETCP\_SPECIAL [#fffz-setcp_special] Selects TVM codepage `z-16` for `1 <= z <= 15`. Negative codepages `-13...-1` are reserved for restricted versions of TVM needed to validate runs of TVM in other codepages. Negative codepage `-14` is reserved for experimental codepages, not necessarily compatible between different TVM implementations, and should be disabled in the production versions of TVM.
**Category:** Codepage (codepage)
```fift title="Fift" [z-16] SETCP ``` #### `FFF0` SETCPX [#fff0-setcpx] Selects codepage `c` with `-2^15 <= c < 2^15` passed in the top of the stack.
**Category:** Codepage (codepage)
```fift title="Fift" SETCPX ```
| \# | Instruction | Field | Type | Description |
|---|---|---|---|---|
| 0 | \- | 0x076ef1ea | integer |
tag of the
SmartContractInfo
TL-B structure
|
| 1 | \- | actions count | integer | increments when new action is pushed to `c5` . |
| 2 | \- | messages sent | integer | increments when new `action_send_msg` is pushed to `c5` |
| 3 | NOW | unix time | integer | current time (timestamp of block collation) |
| 4 | BLOCKLT | current block LT (logical time) | integer | |
| 5 | LTIME | current transaction LT | integer | |
| 6 | RANDSEED | random seed | integer | `sha256(block_rand_seed . account_address)` |
| 7 | BALANCE | smart contract balance | tuple | tuple of integer (GRAM balance) and cell or `null` (extra currencies dictionary) |
| 8 | MYADDR | smart contract address | slice | |
| 9 | CONFIGROOT | global blockchain configuration | cell or `null` (dictionary) | |
| 10 | MYCODE | smart contract code | cell | |
| 11 | INCOMINGVALUE | value of incoming message | tuple | tuple of integer (GRAM value) and cell or `null` (extra currencies dictionary) |
| 12 | STORAGEFEES | fees collected during storage phase | integer | |
| 13 | PREVBLOCKSINFOTUPLE, PREVMCBLOCKS_100 | last 16 masterchain blocks, last keyblock, and last 16 masterchain blocks with seqno divisible by 100 | tuple | tuple has following `PrevBlocksInfo` structure: ```tlb [ wc:Integer shard:Integer seqno:Integer root_hash:Integer file_hash:Integer ] = BlockId; [ last_mc_blocks:BlockId[] prev_key_block:BlockId last_mc_blocks_divisible_by_100:BlockId[] ] = PrevBlocksInfo; ``` |
| 14 | UNPACKEDCONFIGTUPLE | unpacked config values | tuple | * 0: `StoragePrices` from the `ConfigParam 18` — not the whole dictionary, but only the one `StoragePrices` entry which corresponds to the current time * 1: `ConfigParam 19`, global ID * 2: `ConfigParam 20`, masterchain gas prices * 3: `ConfigParam 21`, non-masterchain gas prices * 4: `ConfigParam 24`, masterchain forward fees * 5: `ConfigParam 25`, non-masterchain forward fees * 6: `ConfigParam 43`, size limits |
| 15 | DUEPAYMENT | current debt for storage fee in nanograms | integer | |
| 16 | GETPRECOMPILEDGAS |
gas usage for the current contract if it is precompiled,
null
otherwise
|
integer or `null` | see `ConfigParam 45` |
| 17 | INMSGPARAMS | inbound message parameters | tuple |
* 0: `bounce: boolean` — can bounce
* 1: `bounced: boolean` — did bounce
* 2: `src_addr: slice` — sender
* 3: `fwd_fee: int`
* 4: `created_lt: int`
* 5: `created_at: int`
* 6: `orig_value: int` — this is sometimes different from the value in `INCOMINGVALUE` and TVM stack because of storage fees
* 7: `value: int` — same as in `INCOMINGVALUE` and on the initial TVM stack
* 8: `value_extra: cell or null` — same as in `INCOMINGVALUE`
* 9: `state_init: cell or null`
For external messages, tick-tock transactions and get methods: `bounce`, `bounced`, `fwd_fee`, `created_lt`, `created_at`, `orig_value`, `value` are 0, `value_extra` is null. For tick-tock transactions and get methods, `src_addr` is `addr_none`. |
## Clone and build Bicycle [#1-clone-and-build-bicycle]
```bash
git clone https://github.com/gobicycle/bicycle.git
cd bicycle
make -f Makefile
```
The existing Bicycle `docker-compose.yml` can start PostgreSQL, the processor, Grafana, Prometheus, and RabbitMQ. For a minimal production-like setup, start only PostgreSQL and `payment-processor`.
## Choose a liteserver [#2-choose-a-liteserver]
Bicycle connects to a liteserver over Abstract Datagram Network Layer (ADNL). Either use a [public liteserver with proof verification enabled](#option-a-public-liteserver-with-proofs), or run a [self-hosted liteserver](#option-b-local-liteserver-with-official-docker-image) next to Bicycle.
### Option A: Public liteserver with proofs [#option-a-public-liteserver-with-proofs]
Use this path for a short setup. Fetch the current public liteserver list from the network config and extract one endpoint into the Bicycle `.env` file:
```bash
curl -fsSL https://ton-blockchain.github.io/global.config.json \
| jq -r '
def ntoa:
(if . < 0 then . + 4294967296 else . end) as $ip
| [($ip / 16777216 | floor) % 256,
($ip / 65536 | floor) % 256,
($ip / 256 | floor) % 256,
$ip % 256]
| join(".");
.liteservers[0]
| "LITESERVER=\(.ip | ntoa):\(.port)\nLITESERVER_KEY='\''\(.id.key)'\''"
' >> .env
```
Then enable proof checking:
```bash
cat >> .env <<'EOF'
PROOF_CHECK_ENABLED=true
NETWORK_CONFIG_URL=https://ton-blockchain.github.io/global.config.json
EOF
```
For testnet, use `https://ton-blockchain.github.io/testnet-global.config.json` and set `IS_TESTNET=true`.
Public liteservers are shared infrastructure. Keep `PROOF_CHECK_ENABLED=true` and set a conservative `LITESERVER_RATE_LIMIT`.
Consider setting up a [dedicated liteserver](#option-b-local-liteserver-with-official-docker-image) for production payment volume.
### Option B: Local liteserver with official Docker image [#option-b-local-liteserver-with-official-docker-image]
Ensure the server meets the [minimal hardware requirements](https://docs.ton.org/llms/nodes/cpp/run-liteserver/content.md) for running a liteserver node.
Use this path to run Bicycle and the liteserver on the same host. Put this compose file next to Bicycle's `docker-compose.yml`:
```yaml title="docker-compose.liteserver.yml"
services:
ton-node:
image: ghcr.io/ton-blockchain/ton:latest
container_name: ton_liteserver
restart: unless-stopped
network_mode: host
volumes:
- /var/ton-work/db:/var/ton-work/db
environment:
PUBLIC_IP: ${PUBLIC_IP}
GLOBAL_CONFIG_URL: https://ton-blockchain.github.io/global.config.json
DUMP_URL: https://dump.ton.org/dumps/latest.tar.lz
LITESERVER: "true"
LITE_PORT: "30003"
VALIDATOR_PORT: "30001"
QUIC_PORT: "31001"
CONSOLE_PORT: "30002"
STATE_TTL: "86400"
ARCHIVE_TTL: "2592000"
```
Start it:
```bash
# One of the ways to check the public IP of the server.
# If it is known ahead of time, manually specify it here.
export PUBLIC_IP=$(curl -4 -fsSL ifconfig.me)
docker compose -f docker-compose.liteserver.yml up -d ton-node
# Follow the logs to check the status.
docker logs -f ton_liteserver
```
After `/var/ton-work/db/config.json` is created, append the local liteserver endpoint to Bicycle's `.env`:
```bash
jq -r '
.liteservers[0]
| "LITESERVER=host.docker.internal:\(.port)\nLITESERVER_KEY='\''\(.id.key)'\''"
' /var/ton-work/db/config.json >> .env
```
Add host access to the `payment-processor` service in Bicycle's compose file when Bicycle uses Docker's bridge network:
```yaml title="docker-compose.yml"
services:
payment-processor:
extra_hosts:
- "host.docker.internal:host-gateway"
```
For node setup, hardware requirements, firewall, sync, and maintenance details, see [Run a liteserver](https://docs.ton.org/llms/nodes/cpp/run-liteserver/content.md). The official Docker image uses the same node software. The key settings above are `LITESERVER=true`, `LITE_PORT`, a public `PUBLIC_IP`, and persistent `/var/ton-work/db` storage.
## Configure assets [#3-configure-assets]
Create `.env` file in the Bicycle directory:
```bash title=".env"
# PostgreSQL setup
POSTGRES_DB=payment_processor
POSTGRES_USER=payment_processor
POSTGRES_PASSWORD=
POSTGRES_READONLY_PASSWORD=
DB_URI=postgres://payment_processor:@payment_processor_db:5432/payment_processor
# Bicycle's REST API port
API_PORT=8081
# Bicycle's Bearer token for REST API
API_TOKEN=
# Seed phrase for the main hot wallet, 12 or 24 word mnemonic compatible with standard TON wallets
SEED=
# TON address of the cold wallet
COLD_WALLET=
# Cutoffs in nanograms format:
# hot_wallet_min_balance:hot_wallet_max_balance:min_withdrawal_amount:hot_wallet_residual_balance
TON_CUTOFFS=1000000000:100000000000:1000000000:95000000000
# List of jettons to be processed by the service; set to USDTs only
JETTONS=USDT:EQCxE6mUtQJKFnGfaROTKOt1lZbDiiX1kCixRv7Nw2Id_sDs:100000000000:10000000:95000000000
# USDTs only exist on mainnet!
IS_TESTNET=false
# Miscellaneous, refer to Bicycle's README.md for details
DEPOSIT_SIDE_BALANCE=true
FORWARD_TON_AMOUNT=1
LITESERVER_RATE_LIMIT=25
LITESERVER_MAX_RETRIES=10
LITESERVER_BASE_RETRY_DELAY=100
ALLOWABLE_LAG=40
```
Configure the processor container to receive all Bicycle `.env` vars, not only the variables already listed in the upstream compose file:
```yaml title="docker-compose.yml"
services:
payment-processor:
env_file:
- .env
```
`TON_CUTOFFS` uses nanograms:
| Position | Meaning |
| ----------------------------- | --------------------------------------------------------- |
| `hot_wallet_min_balance` | Minimum hot-wallet Gram balance required on startup |
| `hot_wallet_max_balance` | Balance that triggers a cold-wallet sweep |
| `minimum_withdrawal_amount` | Minimum deposit-wallet balance to sweep to the hot wallet |
| `hot_wallet_residual_balance` | Balance left after a cold-wallet sweep |
`JETTONS` uses jetton base units. USDT on TON has 6 decimals, so `1000000` means 1 USDT:
| Position | Meaning |
| -------------------- | ------------------------------------------------------- |
| `USDT` | Currency code used in Bicycle API requests |
| [`EQCx...sDs`][usdt] | [USDT jetton master address][usdt] on mainnet |
| `100000000000` | Sweep hot-wallet excess above 100,000 USDT |
| `10000000` | Sweep a deposit wallet after it holds more than 10 USDT |
| `95000000000` | Leave 95,000 USDT after a cold-wallet sweep |
Never accept jettons by symbol or metadata alone — only accept an allow-listed master contract address. Verify the USDT jetton master address before mainnet launch.
USDTs only exist on the mainnet.
For information about the other environment variables, refer to the Bicycle's `README.md` file.
## Start Bicycle [#4-start-bicycle]
For a minimal production setup, start only `payment-postgres` (PostgreSQL) and `payment-processor` (Bicycle itself):
```bash
docker compose up -d payment-postgres
docker compose up -d payment-processor
```
Optional available services include: `payment-grafana` (Grafana), `payment-prometheus` (Prometheus), and `payment-rabbitmq` (RabbitMQ).
Check sync:
```bash
curl -sS http://127.0.0.1:8081/v1/system/sync | jq
```
Example of an expected response when Bicycle is caught up:
```json
{
"is_synced": true,
"last_block_gen_utime": 1719306580
}
```
## Create deposit addresses [#5-create-deposit-addresses]
Create one Gram deposit address for a user:
```bash
curl -sS http://127.0.0.1:8081/v1/address/new \
-H "Authorization: Bearer $API_TOKEN" \
-H "Content-Type: application/json" \
-d '{"user_id":"user-1001","currency":"TON"}' | jq
```
Create one USDT deposit address for the same user:
```bash
curl -sS http://127.0.0.1:8081/v1/address/new \
-H "Authorization: Bearer $API_TOKEN" \
-H "Content-Type: application/json" \
-d '{"user_id":"user-1001","currency":"USDT"}' | jq
```
Store the returned address in the application database and show it to the user. Users do not need to enter comments or invoice IDs.
To list all addresses later:
```bash
curl -sS "http://127.0.0.1:8081/v1/address/all?user_id=user-1001" \
-H "Authorization: Bearer $API_TOKEN" | jq
```
## Credit deposits [#6-credit-deposits]
If `DEPOSIT_SIDE_BALANCE=true`, Bicycle credits deposits when it observes income on the deposit address. Query the user's total credited income:
```bash
curl -sS "http://127.0.0.1:8081/v1/income?user_id=user-1001" \
-H "Authorization: Bearer $API_TOKEN" | jq
```
Fetch deposit history for reconciliation:
```bash
curl -sS "http://127.0.0.1:8081/v1/deposit/history?user_id=user-1001¤cy=USDT&limit=20&offset=0&sort_order=desc" \
-H "Authorization: Bearer $API_TOKEN" | jq
```
Look up a deposit by transaction hash when handling support tickets:
```bash
curl -sS "http://127.0.0.1:8081/v1/deposit/income?tx_hash=" \
-H "Authorization: Bearer $API_TOKEN" | jq
```
## Send manual withdrawals [#7-send-manual-withdrawals]
Bicycle controls a hot wallet from `SEED`. Do **not** withdraw manually from this hot wallet **outside** Bicycle. The processor tracks balances, internal sweeps, and withdrawal state in its database — bypassing it can make the service state inconsistent.
Use a unique `query_id` per user withdrawal. Bicycle rejects duplicate `(user_id, query_id)` pairs.
Withdraw 1 Gram:
```bash
# Replace with desired TON wallet address
curl -sS http://127.0.0.1:8081/v1/withdrawal/send \
-H "Authorization: Bearer $API_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"user_id": "user-1001",
"query_id": "wd-ton-000001",
"currency": "TON",
"amount": 1000000000,
"destination": "",
"comment": "withdrawal wd-ton-000001"
}' | jq
```
Withdraw 25 USDT:
```bash
# Replace with desired TON wallet address
curl -sS http://127.0.0.1:8081/v1/withdrawal/send \
-H "Authorization: Bearer $API_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"user_id": "user-1001",
"query_id": "wd-usdt-000001",
"currency": "USDT",
"amount": 25000000,
"destination": "",
"comment": "withdrawal wd-usdt-000001"
}' | jq
```
Check the withdrawal status:
```bash
# Replace with the `query_id` previously submitted to `/v1/withdrawal/send`
curl -sS "http://127.0.0.1:8081/v1/withdrawal/status?id=" \
-H "Authorization: Bearer $API_TOKEN" | jq
```
Statuses are `pending`, `processing`, `processed`, and `failed`. Treat `processed` as the terminal success state in the application ledger.
## Enable notifications [#8-enable-notifications]
### Option A: Webhook endpoint [#option-a-webhook-endpoint]
Extend the `.env` file with webhook variables before starting the `payment-processor` service:
```bash
cat >> .env <<'EOF'
# When set, Bicycle will send webhooks to the specified endpoint
WEBHOOK_ENDPOINT=https://payments.example.com/ton/bicycle/webhook
# Bearer token for the webhook requests — leave unset when unused
# WEBHOOK_TOKEN=
EOF
```
Start or restart the service:
```bash
docker compose up -d payment-processor
```
Bicycle sends deposit notifications as JSON:
```json
{
"deposit_address": "",
"time": 1719306580,
"amount": "25000000",
"source_address": "",
"comment": "optional comment",
"tx_hash": "f9b9e7efd3a38da318a894576499f0b6af5ca2da97ccd15c5f1d291a808a0ebf",
"user_id": "user-1001"
}
```
The webhook handler should be idempotent by `tx_hash`, verify `user_id` and `deposit_address` against application records, credit the internal ledger once, and return HTTP `200` with an empty body. Bicycle stops after repeated unsuccessful webhook delivery, so monitor processor logs and alerts.
### Option B: RabbitMQ [#option-b-rabbitmq]
Extend the `.env` file with RabbitMQ variables and start the `payment-rabbitmq` service before starting the `payment-processor`:
```bash
cat >> .env <<'EOF'
# When true, Bicycle will send incoming notiications to the RabbitMQ queue
QUEUE_ENABLED=true
# URI for client connections to the queue
QUEUE_URI=amqp://guest:guest@payment_rabbitmq:5672/
# Name of the exchange
QUEUE_NAME=
EOF
```
Start or restart the services:
```bash
docker compose up -d payment-rabbitmq
docker compose up -d payment-processor
```
### Prepare the manifest [#1-prepare-the-manifest]
Prepare `tonconnect-manifest.json` — the JSON file the wallet fetches to learn your app's name, icon, and policy URLs. The wallet shows this metadata to the user before approving the connection.
The minimum:
```json
{
"url": "https://yourapp.com",
"name": "Your App",
"iconUrl": "https://yourapp.com/icon-180.png"
}
```
Optional:
```json
{
"termsOfUseUrl": "https://yourapp.com/terms",
"privacyPolicyUrl": "https://yourapp.com/privacy"
}
```
#### Hosting requirements: [#hosting-requirements]
The manifest must be publicly accessible by the time wallets connect to your app:
* The file must be reachable with a `GET` from any origin, without CORS restrictions, without auth and without a Cloudflare-style proxy challenge.
* The icon at the URL listed in `iconUrl` must be PNG or ICO. SVG is not supported. Use a 180×180 px PNG.
* The manifest must be served over HTTPS. Wallets do not guarantee they will fetch a manifest served over plain HTTP.
* Any reachable HTTPS URL is valid. Hosting the manifest at the root of your domain (e.g. `https://yourapp.com/tonconnect-manifest.json`) keeps access simple.
If the wallet cannot fetch the manifest, the connect flow returns `MANIFEST_NOT_FOUND_ERROR` (code 2) or `MANIFEST_CONTENT_ERROR` (code 3). See [Manifest 404 and CORS](https://docs.ton.org/llms/applications/ton-connect/troubleshooting/content.md).
For the full field reference, see [Manifest](https://docs.ton.org/llms/applications/ton-connect/core-concepts/content.md).
### Pick an SDK [#2-pick-an-sdk]
There are three dApp-facing packages, all published from [`ton-connect/sdk`](https://github.com/ton-connect/sdk):
| Package | When to use |
| ---------------------- | ---------------------------------------------------------------------------- |
| `@tonconnect/ui-react` | React or Next.js dApps. **Recommended.** Hooks, prebuilt button, modal. |
| `@tonconnect/ui` | Vanilla JS or non-React frameworks. Same UI components, no React bindings. |
| `@tonconnect/sdk` | Headless integrations — server-side flows, custom UI from scratch. |
Pick `ui-react` if your app is React. Pick `ui` if it is not. Reach for `sdk` only when you need low-level control.
### Install [#1-install]
```bash
npm i @tonconnect/ui-react
```
### Host the manifest [#2-host-the-manifest]
Place `tonconnect-manifest.json` at the root of your app's domain. See [What you need](#1-prepare-the-manifest) for the full requirements.
### Wrap the app in `TonConnectUIProvider` [#3-wrap-the-app-in-tonconnectuiprovider]
```tsx
import { TonConnectUIProvider } from '@tonconnect/ui-react';
export function App() {
return (
);
}
```
### Add the connect button [#4-add-the-connect-button]
```tsx
import { TonConnectButton } from '@tonconnect/ui-react';
export function Header() {
return (
);
}
```
The button toggles between "Connect Wallet" and the connected account state automatically.
You can pass a `className` or `style` prop:
```tsx
### Read connection state [#5-read-connection-state]
```tsx
import {
useIsConnectionRestored,
useTonAddress,
useTonWallet,
} from '@tonconnect/ui-react';
function Status() {
const address = useTonAddress();
const wallet = useTonWallet();
const restored = useIsConnectionRestored();
if (!restored) return Restoring…;
if (!wallet) return Not connected;
return Connected as {address};
}
```
### Send a transaction [#6-send-a-transaction]
The destination here is the connected wallet's own address, returned by `useTonAddress()` in user-friendly form. Replace it with your recipient.
```tsx
import { useTonAddress, useTonConnectUI, useTonWallet } from '@tonconnect/ui-react';
function PayButton() {
const [tonConnectUi] = useTonConnectUI();
const wallet = useTonWallet();
const address = useTonAddress();
const handlePay = async () => {
if (!address) return;
try {
await tonConnectUi.sendTransaction({
validUntil: Math.floor(Date.now() / 1000) + 300,
network: '-239', // mainnet
messages: [
{ address, amount: '100000000' }, // 0.1 Gram
],
});
} catch (e) {
console.error(e);
}
};
return (
);
}
```
`address` must be in user-friendly format (base64url with the bounce flag — `EQ…` for bounceable, `UQ…` for non-bounceable). Wallets reject raw `0:` addresses. To convert one, use `toUserFriendlyAddress` from `@tonconnect/ui-react`. Each `message` also accepts optional `payload`, `stateInit`, and `extraCurrency` fields. Amounts use **nanograms**: `1 Gram = 10⁹ nanogram`. Send `100000000` for 0.1 Gram.
### Install [#1-install-1]
```bash
npm i @tonconnect/ui-react
```
### Host the manifest [#2-host-the-manifest-1]
Drop `tonconnect-manifest.json` into your project's `public/` directory:
```text
public/tonconnect-manifest.json
```
Next.js serves the file at `https://yourapp.com/tonconnect-manifest.json`. Make sure your hosting layer does not add CORS or auth gates — see [Manifest 404 and CORS](https://docs.ton.org/llms/applications/ton-connect/troubleshooting/content.md).
### Set up App Router [#3-set-up-app-router]
`TonConnectUIProvider` reads from local storage and opens modals — both browser-only. Mount it in a client component:
```tsx
// app/providers.tsx
'use client';
import { TonConnectUIProvider } from '@tonconnect/ui-react';
export function Providers({ children }: { children: React.ReactNode }) {
return (
{children}
);
}
```
Then wrap the root layout:
```tsx
// app/layout.tsx
import { Providers } from './providers';
export default function RootLayout({ children }: { children: React.ReactNode }) {
return (
{children}
);
}
```
Components that use `useTonWallet`, `useTonConnectUI`, etc. must also start with `'use client'`.
### Set up Pages Router [#4-set-up-pages-router]
Dynamic-import the provider with SSR off so it does not run on the server:
```tsx
import dynamic from 'next/dynamic';
import type { AppProps } from 'next/app';
const TonConnectUIProvider = dynamic(
() => import('@tonconnect/ui-react').then(m => m.TonConnectUIProvider),
{ ssr: false }
);
function MyApp({ Component, pageProps }: AppProps) {
return (
);
}
export default MyApp;
```
### Install [#1-install-2]
Via npm:
```bash
npm i @tonconnect/ui
```
Or via CDN:
```html
```
The CDN bundle exposes the API on `window.TON_CONNECT_UI`.
### Host the manifest [#2-host-the-manifest-2]
Place `tonconnect-manifest.json` at the root of your domain. Hosting rules in [What you need](#1-prepare-the-manifest).
### Mark up a connect-button container [#3-mark-up-a-connect-button-container]
```html
```
### Initialize the UI [#4-initialize-the-ui]
```javascript
const ui = new TON_CONNECT_UI.TonConnectUI({
manifestUrl: 'https://yourapp.com/tonconnect-manifest.json',
buttonRootId: 'ton-connect',
});
```
The library renders the connect button into `#ton-connect`. Tapping it opens the wallet picker.
If you imported via npm:
```javascript
import { TonConnectUI } from '@tonconnect/ui';
const ui = new TonConnectUI({ /* same options */ });
```
### Subscribe to connection status [#5-subscribe-to-connection-status]
```javascript
ui.onStatusChange(wallet => {
document.getElementById('send').disabled = !wallet;
});
```
`wallet` is `null` when disconnected, or a connected `Wallet` (with `device`, `account`, and optional `connectItems`) otherwise.
### Send a transaction [#6-send-a-transaction-1]
```javascript
import { toUserFriendlyAddress } from '@tonconnect/ui';
document.getElementById('send').onclick = async () => {
const wallet = ui.wallet;
if (!wallet) return;
const address = toUserFriendlyAddress(wallet.account.address); // or window.TON_CONNECT_UI.toUserFriendlyAddress
try {
await ui.sendTransaction({
validUntil: Math.floor(Date.now() / 1000) + 300,
network: '-239',
messages: [
{ address, amount: '100000000' }, // 0.1 Gram
],
});
} catch (error) {
console.error('Transaction failed:', error);
}
};
```
The destination `address` must be in user-friendly format; see the note in the [React example](#6-send-a-transaction). Amounts are in **nanograms**: `1 Gram = 10⁹ nanograms`.
### Install [#1-install-3]
```bash
npm i @tonconnect/sdk
```
### Create a connector [#2-create-a-connector]
```ts
import TonConnect from '@tonconnect/sdk';
const connector = new TonConnect({
manifestUrl: 'https://yourapp.com/tonconnect-manifest.json',
storage: myStorage,
});
await connector.restoreConnection();
```
`manifestUrl` is the public URL of your `tonconnect-manifest.json`. The wallet fetches it during connect and shows the metadata to the user. See [What you need](#1-prepare-the-manifest) for hosting rules.
`storage` is an `IStorage` implementation. In a browser, the SDK falls back to `window.localStorage` if you omit it. Anywhere else — Node.js, a worker — supply your own. `restoreConnection()` reads from storage and wires the connector back to the bridge if a session is already there. Call it once per instance, not on every request.
### Custom storage [#3-custom-storage]
```ts
interface IStorage {
setItem(key: string, value: string): Promise;
getItem(key: string): Promise;
removeItem(key: string): Promise;
}
```
A trivial in-memory implementation suits one-shot flows:
```ts
class MemoryStorage implements IStorage {
private data = new Map();
async setItem(key: string, value: string) { this.data.set(key, value); }
async getItem(key: string) { return this.data.get(key) ?? null; }
async removeItem(key: string) { this.data.delete(key); }
}
```
For long-running servers, back `IStorage` with a per-user record in your database (Postgres, Redis, etc.) keyed by your user ID. See [Long-lived servers](#long-lived-servers).
### Discover wallets [#4-discover-wallets]
```ts
const wallets = await connector.getWallets();
```
Each entry is a `WalletInfo` with the fields a custom UI needs to render a picker and start a connect:
```ts
interface WalletInfoBase {
name: string; // human-readable display name
appName: string; // stable identifier
imageUrl: string;
aboutUrl: string;
tondns?: string;
platforms: ('ios' | 'android' | 'macos' | 'windows'
| 'linux' | 'chrome' | 'firefox' | 'safari')[];
features?: Feature[];
}
interface WalletInfoRemote extends WalletInfoBase {
universalLink: string;
bridgeUrl: string;
deepLink?: string;
}
interface WalletInfoInjectable extends WalletInfoBase {
jsBridgeKey: string;
injected: boolean;
embedded: boolean;
}
type WalletInfo =
| WalletInfoRemote
| WalletInfoInjectable
| (WalletInfoRemote & WalletInfoInjectable);
```
A wallet that supports both transports satisfies the intersection. Narrow with `'universalLink' in wallet` for HTTP wallets and `'jsBridgeKey' in wallet` for injected ones.
### Connect [#5-connect]
For an HTTP wallet, `connect()` returns a universal link. Show it to the user as a clickable URL, a deep link, or a QR code:
```ts
const link = connector.connect({
universalLink: 'https://connect.mytonwallet.org',
bridgeUrl: 'https://tonconnectbridge.mytonwallet.org/bridge/',
});
```
For a JS-injected wallet (browser extension or in-wallet browser), pass the bridge key. The wallet handles the handoff in-page, so `connect()` returns `void`:
```ts
connector.connect({ jsBridgeKey: 'mytonwallet' });
```
To request `ton_proof` alongside the address, pass it under `request`:
```ts
connector.connect(
{ universalLink, bridgeUrl },
{ request: { tonProof: nonce } },
);
```
See [Connect a wallet](https://docs.ton.org/llms/applications/ton-connect/how-to/connect/content.md) for the proof-verification flow.
### Listen for status changes [#6-listen-for-status-changes]
```ts
const unsubscribe = connector.onStatusChange(wallet => {
if (wallet) {
// wallet.account.address — raw 0: (convert to user-friendly before passing to sendTransaction)
// wallet.account.publicKey — hex string without 0x, optional (some wallets omit it)
// wallet.connectItems?.tonProof — TonProofItemReply, may carry proof or error
} else {
// disconnected — by the user or by the wallet
}
});
```
The same callback fires for connects, restores, and wallet-initiated disconnects. Call `unsubscribe()` when you no longer need it.
### Send a transaction [#7-send-a-transaction]
```ts
const result = await connector.sendTransaction({
validUntil: Math.floor(Date.now() / 1000) + 300,
network: '-239', // mainnet (use '-3' for testnet)
messages: [
{ address: 'UQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJKZ', // burn address
amount: '20000000' },
],
});
console.log(result.boc); // base64 BoC of the signed external message
```
Each wallet advertises its own per-call limit on the `SendTransaction` feature entry: `wallet.device.features.find(f => typeof f === 'object' && f.name === 'SendTransaction')?.maxMessages`.