> ## Documentation Index
> Fetch the complete documentation index at: https://docs.ton.org/llms.txt
> Use this file to discover all available pages before exploring further.

<AgentInstructions>

## Submitting Feedback

If you encounter incorrect, outdated, or confusing documentation on this page, submit feedback:

POST https://docs.ton.org/feedback

```json
{
  "path": "/tvm/instructions",
  "feedback": "Description of the issue"
}
```

Only submit feedback when you have something specific and actionable to report.

</AgentInstructions>

# Instructions

> Interactive reference for TVM instructions

export const TvmInstructionTable = () => {
  const {useCallback, useEffect, useMemo, useRef, useState} = React;
  const PERSIST_KEY = "tvm-instruction-table::filters";
  const SPEC_URL = "/resources/tvm/cp0.txt";
  const CATEGORY_MAP = {
    stack_basic: "Stack basics",
    stack_complex: "Stack (complex)",
    arithm_basic: "Arithmetic (basic)",
    arithm_div: "Arithmetic (division)",
    arithm_logical: "Arithmetic (logical)",
    arithm_quiet: "Arithmetic (quiet)",
    cell_build: "Cell builders",
    cell_parse: "Cell parsers",
    codepage: "Codepage management",
    compare_int: "Comparisons (integers)",
    compare_other: "Comparisons (other)",
    const_data: "Constants (data)",
    const_int: "Constants (integers)",
    cont_basic: "Continuations (basic)",
    cont_conditional: "Continuations (conditional)",
    cont_create: "Continuations (creation)",
    cont_dict: "Continuations (dictionary)",
    cont_loops: "Continuations (loops)",
    cont_registers: "Continuations (registers)",
    cont_stack: "Continuations (stack)",
    dict_delete: "Dictionaries (delete)",
    dict_get: "Dictionaries (lookup)",
    dict_mayberef: "Dictionaries (maybe ref)",
    dict_min: "Dictionaries (min/max)",
    dict_next: "Dictionaries (iteration)",
    dict_prefix: "Dictionaries (prefix)",
    dict_serial: "Dictionaries (serialization)",
    dict_set: "Dictionaries (store)",
    dict_set_builder: "Dictionaries (builder)",
    dict_special: "Dictionaries (special)",
    dict_sub: "Dictionaries (sub-dictionaries)",
    app_actions: "Actions",
    app_addr: "Addresses",
    app_config: "Blockchain configuration",
    app_crypto: "Cryptography",
    app_currency: "Currency",
    app_gas: "Gas & fees",
    app_global: "Global variables",
    app_misc: "Misc",
    app_rnd: "Randomness",
    app_gaslimits: "Gas limits",
    app_storage: "Contract storage",
    exceptions: "Exceptions & control",
    debug: "Debugging",
    tuple: "Tuples"
  };
  const CATEGORY_GROUPS = [{
    key: "stack",
    label: "Stack",
    patterns: [/^stack_/]
  }, {
    key: "continuations",
    label: "Continuations & Control Flow",
    patterns: [/^cont_/, /^codepage$/]
  }, {
    key: "arithmetic",
    label: "Arithmetic & Logic",
    patterns: [/^arithm_/, /^compare_/]
  }, {
    key: "cells",
    label: "Cells & Tuples",
    patterns: [/^cell_/, /^tuple$/]
  }, {
    key: "dictionaries",
    label: "Dictionaries",
    patterns: [/^dict_/]
  }, {
    key: "constants",
    label: "Constants",
    patterns: [/^const_/]
  }, {
    key: "crypto",
    label: "Crypto",
    patterns: [/^app_crypto/]
  }, {
    key: "applications",
    label: "Blockchain",
    patterns: [/^app_(?!crypto)/]
  }, {
    key: "exceptions",
    label: "Exceptions",
    patterns: [/^exceptions$/]
  }, {
    key: "debug",
    label: "Debugging",
    patterns: [/^debug$/]
  }];
  const CATEGORY_GROUP_KEYS = new Set(CATEGORY_GROUPS.map(group => group.key));
  function resolveCategoryGroup(categoryKey) {
    const normalized = (categoryKey || "").toLowerCase();
    for (const group of CATEGORY_GROUPS) {
      if (Array.isArray(group.patterns) && group.patterns.length > 0 && group.patterns.some(pattern => pattern.test(normalized))) {
        return group;
      }
    }
    return CATEGORY_GROUPS[CATEGORY_GROUPS.length - 1];
  }
  function humanizeCategoryKey(key) {
    if (!key) return "Uncategorized";
    if (CATEGORY_MAP[key]) return CATEGORY_MAP[key];
    return key.split(/[_\s]+/).filter(Boolean).map(part => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
  }
  function formatGasDisplay(gas) {
    if (Array.isArray(gas)) {
      return gas.length > 0 ? gas.join(" / ") : "N/A";
    }
    if (typeof gas === "number") {
      return gas.toLocaleString();
    }
    if (typeof gas === "string") {
      const value = gas.trim();
      if (!value) return "N/A";
      return value.replace(/\//g, " / ").replace(/\s+/g, " ");
    }
    return "N/A";
  }
  function formatOperandSummary(operand) {
    if (!operand) return "";
    const name = typeof operand.name === "string" && operand.name ? operand.name : "?";
    const type = typeof operand.type === "string" ? operand.type : "";
    const size = typeof operand.size === "number" ? operand.size : typeof operand.bits === "number" ? operand.bits : undefined;
    const hasRange = operand.min_value !== undefined && operand.min_value !== null && operand.max_value !== undefined && operand.max_value !== null;
    const range = hasRange ? ` [${operand.min_value}; ${operand.max_value}]` : "";
    const sizePart = size !== undefined ? `(${size})` : "";
    return `${name}${type ? `:${type}` : ""}${sizePart}${range}`;
  }
  function formatInlineMarkdown(text) {
    if (typeof text !== "string") return "";
    const trimmed = text.trim();
    if (!trimmed) return "";
    const escaped = trimmed.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
    const withCode = escaped.replace(/`([^`]+)`/g, (_match, code) => {
      return `<code>${code}</code>`;
    });
    const withLinks = withCode.replace(/\[([^\]]+)\]\((https?:[^)\s]+)\)/g, (_match, label, url) => `<a href="${url}" target="_blank" rel="noreferrer">${label}</a>`);
    return withLinks.replace(/\n/g, "<br />");
  }
  function compareOpcodes(a, b) {
    const sanitize = value => (value || "").replace(/[^0-9a-f]/gi, "");
    const ax = Number.parseInt(sanitize(a), 16);
    const bx = Number.parseInt(sanitize(b), 16);
    if (!Number.isNaN(ax) && !Number.isNaN(bx) && ax !== bx) {
      return ax - bx;
    }
    return (a || "").localeCompare(b || "");
  }
  function createSearchTokens(query) {
    if (typeof query !== "string") return [];
    return query.toLowerCase().split(/\s+/).map(t => t.trim()).filter(t => t.length >= 2);
  }
  function escapeRegExp(value) {
    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
  }
  function highlightMatches(text, tokens) {
    if (typeof text !== "string") return text;
    const safeTokens = Array.isArray(tokens) ? tokens.filter(token => token && token.length > 0) : [];
    if (safeTokens.length === 0) return text;
    const pattern = safeTokens.map(escapeRegExp).join("|");
    const regex = new RegExp(`(${pattern})`, "gi");
    const parts = text.split(regex);
    return parts.map((part, idx) => idx % 2 === 1 ? <span key={`highlight-${idx}`} className="tvm-highlight">
          {part}
        </span> : part);
  }
  function highlightHtmlContent(html, tokens) {
    if (typeof html !== "string") return html || "";
    const safeTokens = Array.isArray(tokens) ? tokens.filter(token => token && token.length > 0) : [];
    if (safeTokens.length === 0) return html;
    const pattern = safeTokens.map(escapeRegExp).join("|");
    if (!pattern) return html;
    const regex = new RegExp(`(${pattern})`, "gi");
    return html.split(/(<[^>]+>)/g).map(segment => {
      if (segment.startsWith("<")) return segment;
      return segment.replace(regex, '<span class="tvm-highlight">$1</span>');
    }).join("");
  }
  function getItemSearchFields(item) {
    const aliasMnemonics = Array.isArray(item.aliases) ? item.aliases.map(alias => typeof alias.mnemonic === "string" ? alias.mnemonic : "").filter(Boolean) : [];
    return {
      mnemonic: String(item.mnemonic || "").toLowerCase(),
      opcode: String(item.opcode || "").toLowerCase(),
      fift: String(item.fift || "").toLowerCase(),
      aliases: aliasMnemonics.map(s => s.toLowerCase())
    };
  }
  function computeFieldMatchScore(field, token) {
    if (!token) return null;
    if (!field) return null;
    if (field === token) return 0;
    if (field.startsWith(token)) return 3;
    if (field.includes(token)) return 7;
    return null;
  }
  function computeBestAliasMatchScore(aliases, token) {
    if (!Array.isArray(aliases) || aliases.length === 0) return null;
    let best = null;
    for (const a of aliases) {
      const s = computeFieldMatchScore(a, token);
      if (s === 0) return 1;
      if (s !== null) best = best === null ? s + 1 : Math.min(best, s + 1);
    }
    return best;
  }
  function itemRelevanceScore(item, tokens) {
    if (!Array.isArray(tokens) || tokens.length === 0) return 1000;
    const {mnemonic, opcode, fift, aliases} = getItemSearchFields(item);
    let total = 0;
    for (const token of tokens) {
      const scores = [computeFieldMatchScore(mnemonic, token), computeBestAliasMatchScore(aliases, token), computeFieldMatchScore(opcode, token) !== null ? computeFieldMatchScore(opcode, token) + 2 : null, computeFieldMatchScore(fift, token) !== null ? computeFieldMatchScore(fift, token) + 5 : null].filter(s => s !== null);
      if (scores.length === 0) return Infinity;
      total += Math.min(...scores);
    }
    return total;
  }
  function buildAnchorId(instruction) {
    const opcodeText = String(instruction.opcode || "").trim().toLowerCase();
    const titleText = `${instruction.mnemonic}`.trim().toLowerCase();
    const raw = `${opcodeText} ${titleText}`.trim();
    const slug = raw.replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
    return encodeURIComponent(slug);
  }
  function copyAnchorUrl(anchorId) {
    try {
      const {location, navigator} = window;
      const base = location ? `${location.origin}${location.pathname}` : "";
      const url = `${base}#${anchorId}`;
      if (navigator && navigator.clipboard && navigator.clipboard.writeText) {
        return navigator.clipboard.writeText(url);
      }
      const ta = document.createElement("textarea");
      ta.value = url;
      ta.setAttribute("readonly", "");
      ta.style.position = "absolute";
      ta.style.left = "-9999px";
      document.body.appendChild(ta);
      ta.select();
      document.execCommand("copy");
      document.body.removeChild(ta);
      return Promise.resolve();
    } catch (err) {
      return Promise.reject(err);
    }
  }
  function copyPlainText(value) {
    try {
      const {navigator, document} = window;
      if (navigator?.clipboard?.writeText) {
        return navigator.clipboard.writeText(value);
      }
      const ta = document.createElement("textarea");
      ta.value = value;
      ta.setAttribute("readonly", "");
      ta.style.position = "absolute";
      ta.style.left = "-9999px";
      document.body.appendChild(ta);
      ta.select();
      document.execCommand("copy");
      document.body.removeChild(ta);
      return Promise.resolve();
    } catch (err) {
      return Promise.reject(err);
    }
  }
  function formatAliasOperands(operands) {
    return Object.entries(operands).map(([name, value]) => `${name}=${value}`).join(", ");
  }
  function cleanAliasDescription(html) {
    if (typeof html !== "string") return "";
    let output = html.trim();
    if (!output) return "";
    output = output.replace(/^<p>/i, "").replace(/<\/p>$/i, "");
    output = output.replace(/\.+$/g, "");
    return output.trim();
  }
  function extractImplementationRefs(implementation) {
    if (!Array.isArray(implementation)) return [];
    return implementation.map(item => {
      if (!item || typeof item !== "object") return null;
      const file = typeof item.file === "string" ? item.file : "";
      const functionName = typeof item.function_name === "string" ? item.function_name : "";
      const line = typeof item.line === "number" ? item.line : undefined;
      const path = typeof item.path === "string" ? item.path : "";
      if (!file && !functionName && !path) return null;
      return {
        file,
        functionName,
        line,
        path
      };
    }).filter(Boolean);
  }
  function buildGitHubLineUrl(rawUrl, line) {
    if (typeof rawUrl !== "string" || !rawUrl) return "";
    let url = rawUrl;
    const RAW_PREFIX = "https://raw.githubusercontent.com/";
    if (rawUrl.startsWith(RAW_PREFIX)) {
      const parts = rawUrl.slice(RAW_PREFIX.length).split("/");
      if (parts.length >= 4) {
        const owner = parts[0];
        const repo = parts[1];
        const commit = parts[2];
        const filePath = parts.slice(3).join("/");
        url = `https://github.com/${owner}/${repo}/blob/${commit}/${filePath}`;
      } else {
        url = rawUrl.replace(RAW_PREFIX, "https://github.com/");
      }
    }
    if (typeof line === "number" && Number.isFinite(line) && line > 0) {
      url = url.split("#")[0] + `#L${line}`;
    }
    return url;
  }
  function renderControlFlowSummary(controlFlow) {
    if (!controlFlow || typeof controlFlow !== "object") {
      return <p className="tvm-missing-placeholder">
          Control flow details are not available.
        </p>;
    }
    const branches = Array.isArray(controlFlow.branches) ? controlFlow.branches.filter(Boolean) : [];
    const nobranch = Boolean(controlFlow.nobranch);
    const isContinuationObject = value => Boolean(value && typeof value === "object" && typeof value.type === "string");
    const formatPrimitiveValue = value => {
      if (value === null || value === undefined) return "";
      if (Array.isArray(value)) {
        return value.map(item => formatPrimitiveValue(item)).filter(Boolean).join(", ");
      }
      if (typeof value === "object") {
        return "";
      }
      if (typeof value === "boolean") {
        return value ? "true" : "false";
      }
      return String(value);
    };
    const describeContinuation = node => {
      if (!isContinuationObject(node)) {
        return {
          typeLabel: "unknown",
          valueLabel: "?",
          detailLabel: "",
          text: "unknown ?"
        };
      }
      const type = String(node.type || "").toLowerCase();
      let typeLabel = "unknown";
      let valueLabel = "";
      switch (type) {
        case "variable":
          typeLabel = "var";
          valueLabel = typeof node.var_name === "string" ? node.var_name : "?";
          break;
        case "register":
          typeLabel = "register";
          if (typeof node.index === "number") {
            valueLabel = `c${node.index}`;
          } else if (typeof node.var_name === "string") {
            valueLabel = `c{${node.var_name}}`;
          } else {
            valueLabel = "c?";
          }
          break;
        case "cc":
          typeLabel = "cc";
          valueLabel = "";
          break;
        case "special":
          typeLabel = "special";
          valueLabel = typeof node.name === "string" && node.name ? node.name : "?";
          break;
        default:
          typeLabel = node.type ? String(node.type) : "unknown";
          valueLabel = "";
          break;
      }
      const detailParts = [];
      if (type === "special") {
        const args = node.args && typeof node.args === "object" ? node.args : {};
        Object.entries(args).forEach(([argKey, argValue]) => {
          if (!isContinuationObject(argValue)) {
            const formatted = formatPrimitiveValue(argValue);
            if (formatted) {
              detailParts.push(`${argKey}=${formatted}`);
            }
          }
        });
      }
      const knownKeys = new Set(["type", "var_name", "index", "name", "args", "save"]);
      Object.entries(node).forEach(([key, value]) => {
        if (knownKeys.has(key)) return;
        const formatted = formatPrimitiveValue(value);
        if (formatted) {
          detailParts.push(`${key}=${formatted}`);
        }
      });
      const detailLabel = detailParts.length > 0 ? `(${detailParts.join(", ")})` : "";
      const text = [typeLabel, valueLabel, detailLabel].filter(Boolean).join(" ").replace(/\s+/g, " ").trim();
      return {
        typeLabel,
        valueLabel,
        detailLabel,
        text
      };
    };
    const gatherChildContinuations = node => {
      if (!isContinuationObject(node)) return [];
      const type = String(node.type || "").toLowerCase();
      const children = [];
      const saveEntries = node.save && typeof node.save === "object" ? Object.entries(node.save).filter(([, value]) => isContinuationObject(value)) : [];
      saveEntries.sort(([aKey], [bKey]) => aKey.localeCompare(bKey)).forEach(([slot, value]) => {
        children.push({
          label: String(slot),
          node: value
        });
      });
      if (type === "special") {
        const args = node.args && typeof node.args === "object" ? node.args : {};
        Object.entries(args).forEach(([argKey, argValue]) => {
          if (isContinuationObject(argValue)) {
            children.push({
              label: argKey,
              node: argValue
            });
          }
        });
      }
      return children.map(child => {
        const raw = child.label ? String(child.label) : "";
        const cleaned = raw.replace(/^(arg|save)\s+/i, "").trim();
        return {
          label: cleaned,
          node: child.node
        };
      });
    };
    const buildContinuationTree = (node, path = "root") => {
      const summary = describeContinuation(node);
      const children = gatherChildContinuations(node).map((child, idx) => ({
        label: child.label,
        tree: buildContinuationTree(child.node, `${path}.${idx}`)
      }));
      return {
        id: path,
        summary,
        children
      };
    };
    const splitEdgeLabel = label => {
      if (!label) {
        return {
          primary: "",
          secondary: ""
        };
      }
      const text = label.trim();
      if (!text) {
        return {
          primary: "",
          secondary: ""
        };
      }
      const tokens = text.split(/\s+/);
      if (tokens.length <= 1) {
        return {
          primary: text,
          secondary: ""
        };
      }
      return {
        primary: tokens[0],
        secondary: tokens.slice(1).join(" ")
      };
    };
    const computeSpan = tree => {
      if (!tree.children || tree.children.length === 0) {
        tree.span = 1;
        return 1;
      }
      let total = 0;
      tree.children.forEach(child => {
        total += computeSpan(child.tree);
      });
      tree.span = Math.max(total, 1);
      return tree.span;
    };
    const H_SPACING = 200;
    const V_SPACING = 110;
    const NODE_HEIGHT = 42;
    const NODE_MIN_WIDTH = 140;
    const PADDING_X = 60;
    const PADDING_Y = 60;
    let canvasMeasureCtx = null;
    const measureNodeWidth = summary => {
      if (typeof document !== "undefined") {
        if (!canvasMeasureCtx) {
          const canvas = document.createElement("canvas");
          canvasMeasureCtx = canvas.getContext("2d");
        }
        if (canvasMeasureCtx) {
          canvasMeasureCtx.font = "600 13px 'JetBrains Mono', 'Menlo', 'Monaco', monospace";
          const typeText = (summary.typeLabel || "").toUpperCase();
          const parts = [typeText];
          if (summary.valueLabel) parts.push(summary.valueLabel);
          if (summary.detailLabel) parts.push(summary.detailLabel);
          const text = parts.join(" ").trim();
          const metrics = canvasMeasureCtx.measureText(text || "node");
          return Math.max(metrics.width + 48, NODE_MIN_WIDTH);
        }
      }
      const fallbackLength = (summary.typeLabel || "").length + (summary.valueLabel || "").length + (summary.detailLabel || "").length;
      return Math.max(fallbackLength * 7 + 48, NODE_MIN_WIDTH);
    };
    const assignPositions = (tree, nodes, nodeMap, edges, depth = 0, offsetSpan = 0) => {
      const span = Math.max(tree.span || 1, 1);
      const spanWidth = span * H_SPACING;
      const x = PADDING_X + offsetSpan + spanWidth / 2;
      const y = PADDING_Y + depth * V_SPACING;
      const width = measureNodeWidth(tree.summary);
      const nodeEntry = {
        id: tree.id,
        summary: tree.summary,
        x,
        y,
        width,
        height: NODE_HEIGHT
      };
      nodes.push(nodeEntry);
      nodeMap.set(tree.id, nodeEntry);
      let childOffset = offsetSpan;
      tree.children.forEach(child => {
        assignPositions(child.tree, nodes, nodeMap, edges, depth + 1, childOffset);
        edges.push({
          from: tree.id,
          to: child.tree.id,
          label: child.label
        });
        childOffset += Math.max(child.tree.span || 1, 1) * H_SPACING;
      });
    };
    return <div>
        {branches.length > 0 || !nobranch ? <div><b>Falls through: </b>{nobranch ? "Yes" : "No"}</div> : null}
        {branches.length > 0 ? <div className="tvm-control-flow-branches">
            {branches.map((branch, index) => {
      const rootSummary = describeContinuation(branch);
      const branchType = (rootSummary.typeLabel || "").toUpperCase();
      const branchTitleText = `Branch -> ${branchType}${rootSummary.valueLabel ? ` ${rootSummary.valueLabel}` : ""}`;
      const tree = buildContinuationTree(branch, `branch-${index}`);
      computeSpan(tree);
      const nodes = [];
      const nodeMap = new Map();
      const edges = [];
      assignPositions(tree, nodes, nodeMap, edges);
      let minX = Infinity;
      let maxX = -Infinity;
      let minY = Infinity;
      let maxY = -Infinity;
      nodes.forEach(node => {
        minX = Math.min(minX, node.x - node.width / 2);
        maxX = Math.max(maxX, node.x + node.width / 2);
        minY = Math.min(minY, node.y - node.height / 2);
        maxY = Math.max(maxY, node.y + node.height / 2);
      });
      const shiftX = Number.isFinite(minX) ? PADDING_X - minX : 0;
      const shiftY = Number.isFinite(minY) ? PADDING_Y - minY : 0;
      if (shiftX || shiftY) {
        nodes.forEach(node => {
          node.x += shiftX;
          node.y += shiftY;
        });
      }
      const canvasWidth = Math.max(maxX - minX + PADDING_X * 2, 260);
      const canvasHeight = Math.max(maxY - minY + PADDING_Y * 2, NODE_HEIGHT + PADDING_Y * 2);
      const edgeLayouts = edges.map((edge, edgeIdx) => {
        const from = nodeMap.get(edge.from);
        const to = nodeMap.get(edge.to);
        if (!from || !to) return null;
        const fromX = from.x;
        const fromY = from.y + from.height / 2;
        const toX = to.x;
        const toY = to.y - to.height / 2;
        const midY = fromY + (toY - fromY) / 2;
        const path = `M ${fromX} ${fromY} C ${fromX} ${midY}, ${toX} ${midY}, ${toX} ${toY}`;
        const labelX = (fromX + toX) / 2;
        const labelY = midY;
        const segments = splitEdgeLabel(edge.label);
        const hasSecondary = Boolean(segments.secondary);
        return {
          id: `${edge.from}->${edge.to}-${edgeIdx}`,
          path,
          labelX,
          labelY,
          segments,
          hasSecondary
        };
      }).filter(Boolean);
      return <div key={`branch-${index}`} className="tvm-control-flow-branch">
                  <div className="tvm-control-flow-branch-header">
                    <span className="tvm-control-flow-branch-title">
                      {highlightMatches(branchTitleText, searchTokens)}
                    </span>
                  </div>
                  <div className="tvm-flow-graph-wrapper">
                    <div className="tvm-flow-canvas" style={{
        width: `${canvasWidth}px`,
        height: `${canvasHeight}px`
      }}>
                      <svg className="tvm-flow-canvas-svg" width={canvasWidth} height={canvasHeight} viewBox={`0 0 ${canvasWidth} ${canvasHeight}`} preserveAspectRatio="xMinYMin meet">
                        <defs>
                          <marker id="tvm-flow-arrowhead" markerWidth="8" markerHeight="8" refX="6" refY="4" orient="auto" markerUnits="strokeWidth">
                            <path d="M1 1 L7 4 L1 7 Z" fill="currentColor" />
                          </marker>
                        </defs>
                        {edgeLayouts.map(edge => <path key={`edge-path-${edge.id}`} d={edge.path} className="tvm-flow-graph-line" markerEnd="url(#tvm-flow-arrowhead)" />)}
                      </svg>
                      {edgeLayouts.map(edge => edge.segments.primary ? <div key={`edge-label-${edge.id}`} className={`tvm-flow-edge-label${edge.hasSecondary ? ' has-secondary' : ''}`} style={{
        left: `${edge.labelX}px`,
        top: `${edge.labelY}px`
      }}>
                        <span className="tvm-flow-edge-label-primary">
                          {highlightMatches(edge.segments.primary.toUpperCase(), searchTokens)}
                        </span>
                        {edge.segments.secondary && <span className="tvm-flow-edge-label-secondary">
                            {highlightMatches(edge.segments.secondary.toUpperCase(), searchTokens)}
                          </span>}
                      </div> : null)}
                      {nodes.map(node => <div key={node.id} className="tvm-flow-node" style={{
        left: `${node.x}px`,
        top: `${node.y}px`
      }}>
                          <span className="tvm-control-flow-node-pill" style={{
        minWidth: `${node.width}px`
      }}>
                            <span className="tvm-control-flow-node-type">
                              {highlightMatches((node.summary.typeLabel || "").toUpperCase(), searchTokens)}
                            </span>
                            {node.summary.valueLabel && <span className="tvm-control-flow-node-value">
                                {highlightMatches(node.summary.valueLabel, searchTokens)}
                              </span>}
                            {node.summary.detailLabel && <span className="tvm-control-flow-node-extra">
                                {highlightMatches(node.summary.detailLabel, searchTokens)}
                              </span>}
                          </span>
                        </div>)}
                    </div>
                  </div>
                </div>;
    })}
          </div> : <p className="tvm-detail-muted">
            {nobranch ? "Instruction does not modify the current continuation." : "Control flow branches are not documented in the specification."}
          </p>}
      </div>;
  }
  function renderStackEntry(entry, key, mode) {
    if (!entry) return null;
    if (entry.type === "conditional") {
      if (mode === "compact" || mode === "detail-inline") {
        return <span key={key} className="tvm-stack-pill tvm-stack-pill--conditional">
            Conditional: {highlightMatches(String(entry.name || "?"), searchTokens)}
          </span>;
      }
      return <div key={key} className="tvm-stack-conditional">
          <span className="tvm-stack-conditional-name">
            Conditional: {highlightMatches(String(entry.name || "?"), searchTokens)}
          </span>
          {Array.isArray(entry.match) && entry.match.length > 0 ? entry.match.map((matchArm, idx) => <div key={`${key}-match-${idx}`} className="tvm-stack-conditional-branch">
                <span className="tvm-stack-conditional-label">
                  = {highlightMatches(String(matchArm.value ?? ""), searchTokens)}
                </span>
                <div className="tvm-stack-conditional-values">
                  {Array.isArray(matchArm.stack) && matchArm.stack.length > 0 ? matchArm.stack.slice().reverse().map((nested, nestedIdx) => renderStackEntry(nested, `${key}-match-${idx}-item-${nestedIdx}`, "detail-inline")) : <span className="tvm-stack-pill tvm-stack-pill--empty">
                      Empty
                    </span>}
                </div>
              </div>) : <span className="tvm-stack-pill tvm-stack-pill--empty">
              Empty branches
            </span>}
          {Array.isArray(entry.else) && <div className="tvm-stack-conditional-branch">
              <span className="tvm-stack-conditional-label">else</span>
              <div className="tvm-stack-conditional-values">
                {entry.else.length > 0 ? entry.else.slice().reverse().map((nested, nestedIdx) => renderStackEntry(nested, `${key}-else-${nestedIdx}`, "detail-inline")) : <span className="tvm-stack-pill tvm-stack-pill--empty">
                    Empty
                  </span>}
              </div>
            </div>}
        </div>;
    }
    if (entry.type === "array") {
      const label = `${entry.name || "items"}[${entry.length_var ?? ""}]`;
      return <span key={key} className="tvm-stack-pill tvm-stack-pill--array">
          {highlightMatches(label, searchTokens)}
        </span>;
    }
    if (entry.type === "const") {
      const value = entry.value === null ? "null" : entry.value === undefined ? "?" : entry.value;
      return <span key={key} className="tvm-stack-pill tvm-stack-pill--const">
          {highlightMatches(String(value), searchTokens)}: {highlightMatches(String(entry.value_type || "Const"), searchTokens)}
        </span>;
    }
    const valueTypes = Array.isArray(entry.value_types) && entry.value_types.length > 0 ? entry.value_types.join("/") : entry.value_type || "Any";
    const label = entry.name ? `${entry.name}: ${valueTypes}` : valueTypes;
    return <span key={key} className="tvm-stack-pill tvm-stack-pill--simple">
        {highlightMatches(label, searchTokens)}
      </span>;
  }
  function renderStackColumn(title, items, mode = "detail") {
    const safeItems = Array.isArray(items) ? items : [];
    const reversed = safeItems.slice().reverse();
    const limit = mode === "compact" ? 4 : reversed.length;
    const shown = reversed.slice(0, limit);
    const truncated = mode === "compact" && reversed.length > shown.length;
    return <div className={`tvm-stack-column ${mode === "compact" ? "tvm-stack-column--compact" : ""}`}>
        <div className="tvm-stack-column-title">{title}</div>
        <div className="tvm-stack-top">TOP</div>
        <div className="tvm-stack-list">
          {shown.length === 0 && <span className="tvm-stack-empty">Empty</span>}
          {shown.map((entry, idx) => renderStackEntry(entry, `${title}-${idx}`, mode))}
          {truncated && <span className="tvm-stack-pill tvm-stack-pill--more">
              +{reversed.length - shown.length} more
            </span>}
        </div>
      </div>;
  }
  function renderStackColumns(instruction, mode = "detail") {
    const inputs = instruction?.valueFlow?.inputs ?? [];
    const outputs = instruction?.valueFlow?.outputs ?? [];
    return <div className={`tvm-stack-columns ${mode === "compact" ? "tvm-stack-columns--compact" : ""}`}>
        {renderStackColumn("Inputs", inputs, mode)}
        {renderStackColumn("Outputs", outputs, mode)}
      </div>;
  }
  function renderInstructionDetail(instruction, options = {}) {
    const {isAnchorTarget = false, onOpenRawJson = () => {}} = options;
    const hasAliases = Array.isArray(instruction.aliases) && instruction.aliases.length > 0;
    const readsRegisters = Array.isArray(instruction.registers?.inputs) ? instruction.registers.inputs : [];
    const writesRegisters = Array.isArray(instruction.registers?.outputs) ? instruction.registers.outputs : [];
    const hasRegisterInfo = readsRegisters.length > 0 || writesRegisters.length > 0;
    const hasStackData = !instruction.missing.inputs || !instruction.missing.outputs;
    const hasFiftExamples = Array.isArray(instruction.fiftExamples) && instruction.fiftExamples.length > 0;
    const descriptionHtml = highlightHtmlContent(instruction.descriptionHtml || instruction.description || "", searchTokens);
    const implementationRefs = Array.isArray(instruction.implementationRefs) ? instruction.implementationRefs.filter(Boolean) : [];
    const hasImplementation = implementationRefs.length > 0;
    const renderRegisterList = (list, keyPrefix) => {
      const tokens = Array.isArray(list) ? list.map((register, idx) => {
        if (!register) return null;
        if (register.type === "special" && register.name) {
          return <span key={`${keyPrefix}-special-${idx}`} className="tvm-register-token tvm-register-token--special">
                    {register.name}
                  </span>;
        }
        const sub = register.type === "variable" ? register.var_name || "i" : typeof register.index === "number" ? register.index : register.var_name || "?";
        return <span key={`${keyPrefix}-const-${idx}`} className="tvm-register-token">
                  c<sub>{sub}</sub>
                </span>;
      }).filter(Boolean) : [];
      return tokens.flatMap((token, idx) => idx === 0 ? [token] : [<span key={`${keyPrefix}-sep-${idx}`} className="tvm-register-sep">
                ,{" "}
              </span>, token]);
    };
    const badgeNodes = [<span key="gas" className="tvm-detail-badge">
        <span className="tvm-detail-badge-label">Gas</span>{" "}
        <span className="tvm-detail-badge-value">
          {highlightMatches(String(instruction.gasDisplay || "N/A"), searchTokens)}
        </span>
      </span>, <span key="version" className="tvm-detail-badge">
        <span className="tvm-detail-badge-label">TVM</span>{" "}
        <span className="tvm-detail-badge-value">
          {highlightMatches(instruction.since > 0 ? `v${instruction.since}` : "v0", searchTokens)}
        </span>
      </span>];
    if (hasRegisterInfo) {
      if (readsRegisters.length > 0) {
        badgeNodes.push(<span key="registers-read" className="tvm-detail-badge tvm-detail-badge--register">
            <span className="tvm-detail-badge-label">Read registers</span>{" "}
            <span className="tvm-detail-badge-value">
              {renderRegisterList(readsRegisters, "read")}
            </span>
          </span>);
      }
      if (writesRegisters.length > 0) {
        badgeNodes.push(<span key="registers-write" className="tvm-detail-badge tvm-detail-badge--register">
            <span className="tvm-detail-badge-label">Write registers</span>{" "}
            <span className="tvm-detail-badge-value">
              {renderRegisterList(writesRegisters, "write")}
            </span>
          </span>);
      }
    }
    const panelClassName = `tvm-detail-panel${isAnchorTarget ? " is-anchor-target" : ""}`;
    return <div className={panelClassName}>
        <div className="tvm-detail-header">
          <div className="tvm-detail-heading">
            <div className="tvm-detail-header-main">
              <h4 className="tvm-detail-title">{instruction.mnemonic}</h4>
            </div>
          </div>
          <div className="tvm-detail-actions">
            <button type="button" className="tvm-button tvm-button--ghost" onClick={() => onOpenRawJson(instruction)}>
              Raw JSON
            </button>
          </div>
        </div>

        <div className="tvm-detail-columns">
          <div className="tvm-detail-main">
            {descriptionHtml ? <div className="tvm-description" dangerouslySetInnerHTML={{
      __html: descriptionHtml
    }} /> : <p className="tvm-missing-placeholder">Description not available.</p>}

            <div className="tvm-detail-badges">{badgeNodes}</div>

            <div className="tvm-detail-block">
              <span className="tvm-detail-subtitle">Fift command</span>
              {instruction.fift ? <code className="tvm-detail-code tvm-detail-code--inline">
                  {highlightMatches(String(instruction.fift), searchTokens)}
                </code> : <span className="tvm-detail-muted">Not documented.</span>}
            </div>

            <div className="tvm-detail-block">
              <span className="tvm-detail-subtitle">Control flow</span>
              {renderControlFlowSummary(instruction.controlFlow)}
            </div>

            {hasImplementation && <div className="tvm-detail-block">
                <span className="tvm-detail-subtitle">Implementation</span>
                <div className="tvm-impl-badges">
                  {implementationRefs.map((ref, idx) => {
      const filename = ref.file || "source";
      const linePart = typeof ref.line === "number" && ref.line > 0 ? `:${ref.line}` : "";
      const href = buildGitHubLineUrl(ref.path, ref.line);
      return <a key={`${instruction.mnemonic}-impl-${idx}`} className="tvm-detail-badge tvm-detail-badge--link" href={href} target="_blank" rel="noreferrer">
                        {filename}
                        {linePart}
                      </a>;
    })}
                </div>
              </div>}

            {hasFiftExamples && <section className="tvm-detail-section tvm-detail-section--wide">
                <h4 className="tvm-detail-title">Fift examples</h4>
                <div className="tvm-example-list">
                  {instruction.fiftExamples.map((example, idx) => {
      const description = typeof example.description === "string" ? example.description : "";
      const fiftCode = typeof example.fift === "string" ? example.fift : "";
      return <div key={`${instruction.mnemonic}-example-${idx}`} className="tvm-example-item">
                        {description && <p className="tvm-example-description" dangerouslySetInnerHTML={{
        __html: formatInlineMarkdown(description)
      }} />}
                        {fiftCode && <code className="tvm-detail-code tvm-example-code">{fiftCode}</code>}
                      </div>;
    })}
                </div>
              </section>}

            {hasAliases && <section className="tvm-detail-section tvm-detail-section--wide">
                <h4 className="tvm-detail-title">Aliases</h4>
                <div className="tvm-alias-list">
                  {instruction.aliases.map(alias => {
      const aliasDescriptionHtml = cleanAliasDescription(alias.description || "");
      const hasAliasMeta = Boolean(alias.doc_fift) || alias.operands && Object.keys(alias.operands).length > 0;
      return <div key={alias.mnemonic} className="tvm-alias-item">
                        <div className="tvm-alias-headline">
                          <code>{alias.mnemonic}</code>
                          <span className="tvm-alias-meta">
                            alias of <code>{alias.alias_of}</code>
                          </span>
                        </div>
                        {aliasDescriptionHtml && <div className="tvm-alias-description" dangerouslySetInnerHTML={{
        __html: aliasDescriptionHtml
      }} />}
                        {hasAliasMeta && <div className="tvm-alias-meta-row">
                            {alias.doc_fift && <span className="tvm-alias-pill">
                                Fift <code>{alias.doc_fift}</code>
                              </span>}
                            {alias.operands && Object.keys(alias.operands).length > 0 && <span className="tvm-alias-pill">
                                Operands {formatAliasOperands(alias.operands)}
                              </span>}
                          </div>}
                      </div>;
    })}
                </div>
              </section>}
          </div>

          <aside className="tvm-detail-side">
            <div className="tvm-side-block">
              <span className="tvm-side-title">Opcode</span>
              {instruction.tlb ? <code className="tvm-detail-code">
                  {highlightMatches(String(instruction.tlb), searchTokens)}
                </code> : <p className="tvm-missing-placeholder">TL-B layout not available.</p>}
            </div>

            <div className="tvm-side-block">
              <span className="tvm-side-title">Category</span>
              <div className="tvm-side-category-value">
                {highlightMatches(instruction.rawCategoryLabel, searchTokens)}
              </div>
            </div>

            <div className="tvm-side-block">
              <span className="tvm-side-title">Operands</span>
              {Array.isArray(instruction.operands) && instruction.operands.length > 0 ? <div className="tvm-operands-list">
                  {instruction.operands.map((operand, idx) => {
      if (!operand || typeof operand !== "object") return null;
      const summary = highlightMatches(formatOperandSummary(operand), searchTokens);
      const hasRange = operand.min_value !== undefined || operand.max_value !== undefined;
      return <div key={`operand-${idx}`} className="tvm-operands-item">
                        <div className="tvm-operands-line">{summary}</div>
                        {hasRange && <div className="tvm-operands-detail">
                            Range {highlightMatches(String(operand.min_value ?? "?"), searchTokens)} – {highlightMatches(String(operand.max_value ?? "?"), searchTokens)}
                          </div>}
                      </div>;
    })}
                </div> : <p className="tvm-detail-muted">No operands.</p>}
            </div>

            <div className="tvm-side-block">
              <span className="tvm-side-title">Stack</span>
              {hasStackData ? renderStackColumns(instruction, "detail") : <p className="tvm-missing-placeholder">Stack effects not available.</p>}
            </div>
          </aside>
        </div>

        
      </div>;
  }
  const [spec, setSpec] = useState(null);
  const [error, setError] = useState(null);
  const [loading, setLoading] = useState(true);
  const [search, setSearch] = useState("");
  const [category, setCategory] = useState("All");
  const [subcategory, setSubcategory] = useState("All");
  const [sortMode, setSortMode] = useState("opcode");
  const [expanded, setExpanded] = useState({});
  const [copied, setCopied] = useState({});
  const [activeAnchorId, setActiveAnchorId] = useState(null);
  const [rawModalInstruction, setRawModalInstruction] = useState(null);
  const [rawModalCopied, setRawModalCopied] = useState(false);
  const searchInputRef = useRef(null);
  const rawModalCopyTimeoutRef = useRef(null);
  const tableStyles = useMemo(() => `
.tvm-instruction-app {
  --tvm-border: var(--mint-border-color, rgb(var(--gray-400) / 0.24));
  --tvm-border-strong: rgb(var(--gray-400) / 0.32);
  --tvm-surface: var(--mint-surface-elevated, rgb(var(--background-light)));
  --tvm-surface-secondary: rgb(var(--gray-50) / 0.65);
  --tvm-text-primary: var(--mint-text-primary, rgb(var(--gray-800)));
  --tvm-text-secondary: var(--mint-text-secondary, rgb(var(--gray-600) / 0.85));
  --tvm-text-muted: var(--mint-text-tertiary, rgb(var(--gray-400) / 0.68));
  --tvm-accent: rgb(var(--primary));
  --tvm-accent-soft: rgb(var(--primary) / 0.16);
  --tvm-accent-strong: rgb(var(--primary-light));
  --tvm-accent-subtle: rgb(var(--primary-dark));
  --tvm-callout-bg: var(--callout-bg-color, rgb(var(--primary) / 0.12));
  --tvm-callout-border: var(--callout-border-color, rgb(var(--primary) / 0.2));
  --tvm-callout-text: var(--callout-text-color, rgb(var(--primary)));
  --tvm-stack-simple-bg: var(--tvm-accent-soft);
  --tvm-stack-simple-text: var(--tvm-accent-subtle);
  --tvm-stack-const-bg: rgb(var(--primary) / 0.2);
  --tvm-stack-const-text: var(--tvm-accent-subtle);
  --tvm-stack-array-bg: rgb(var(--primary) / 0.2);
  --tvm-stack-array-text: var(--tvm-text-primary);
  --tvm-stack-conditional-bg: rgb(var(--primary-dark) / 0.22);
  --tvm-stack-conditional-text: var(--tvm-accent-subtle);
  --tvm-stack-conditional-border: rgb(var(--primary-dark) / 0.32);
  --tvm-stack-label: var(--mint-text-tertiary, rgb(var(--gray-600) / 0.65));
  --tvm-pill-muted-bg: rgb(var(--gray-400) / 0.12);
  --tvm-row-padding-y: 0.85rem;
  --tvm-row-padding-x: 1rem;
  --tvm-chip-padding-y: 0.2rem;
  --tvm-chip-padding-x: 0.6rem;
  --tvm-control-height: 2.75rem;
  color: var(--tvm-text-primary);
  background: var(--tvm-surface);
  border: 1px solid var(--tvm-border);
  border-radius: 14px;
  padding: 1.5rem;
  box-shadow: 0 24px 60px -40px rgb(var(--gray-900) / 0.9);
}

:where(.dark) .tvm-instruction-app {
  --tvm-border: rgb(var(--gray-800) / 0.65);
  --tvm-border-strong: rgb(var(--gray-600) / 0.85);
  --tvm-surface: rgb(var(--gray-950));
  --tvm-surface-secondary: rgb(var(--gray-900) / 0.85);
  --tvm-text-primary: rgb(var(--gray-100));
  --tvm-text-secondary: rgb(var(--gray-300));
  --tvm-text-muted: rgb(var(--gray-400) / 0.9);
  --tvm-accent: rgb(var(--primary-light));
  --tvm-accent-soft: rgb(var(--primary) / 0.22);
  --tvm-accent-strong: rgb(var(--primary));
  --tvm-accent-subtle: rgb(var(--primary-light));
  --tvm-callout-bg: rgb(var(--primary) / 0.24);
  --tvm-callout-border: rgb(var(--primary-light) / 0.35);
  --tvm-callout-text: rgb(var(--primary-light));
  --tvm-stack-simple-bg: rgb(var(--primary) / 0.25);
  --tvm-stack-simple-text: rgb(var(--primary-light));
  --tvm-stack-const-bg: rgb(var(--primary-dark) / 0.4);
  --tvm-stack-const-text: rgb(var(--primary-light));
  --tvm-stack-array-bg: rgb(var(--primary) / 0.25);
  --tvm-stack-array-text: rgb(var(--gray-50));
  --tvm-stack-conditional-bg: rgb(var(--primary-dark) / 0.38);
  --tvm-stack-conditional-text: rgb(var(--primary-light));
  --tvm-stack-conditional-border: rgb(var(--primary) / 0.5);
  --tvm-stack-label: rgb(var(--gray-400) / 0.85);
  --tvm-pill-muted-bg: rgb(var(--gray-800) / 0.85);
  box-shadow: 0 24px 80px -60px rgb(0 0 0 / 0.65);
  color-scheme: dark;
}

.tvm-instruction-toolbar {
  display: flex;
  flex-direction: column;
  gap: 1rem;
  margin-bottom: 1.25rem;
}

.tvm-toolbar-search {
  display: flex;
}

.tvm-toolbar-search .tvm-field--search {
  flex: 1 1 auto;
}

.tvm-search-row {
  display: flex;
  align-items: stretch;
  gap: 0.75rem;
}

.tvm-search-row .tvm-search-input {
  flex: 1 1 auto;
}

.tvm-search-row .tvm-toolbar-utilities {
  position: static;
  width: auto;
  align-self: stretch;
  align-items: stretch;
}

.tvm-search-row .tvm-toolbar-utilities .tvm-button {
  height: 100%;
}

.tvm-toolbar-utilities {
  display: flex;
  gap: 0.5rem;
  align-items: center;
  justify-content: flex-end;
  justify-self: end;
  align-self: end;
  width: max-content;
}

.tvm-toolbar-filters {
  display: grid;
  grid-template-columns: repeat(auto-fit, minmax(220px, max-content));
  gap: 0.75rem;
  align-items: end;
  justify-content: flex-start;
}

.tvm-toolbar-filters .tvm-field {
  min-width: 0;
  width: min(280px, 100%);
}

.tvm-field--sort {
  width: min(240px, 100%);
}

.tvm-field--category {
  width: min(280px, 100%);
}

.tvm-field--subcategory {
  width: min(300px, 100%);
}



.tvm-field {
  display: flex;
  flex-direction: column;
  gap: 0.35rem;
  min-width: 190px;
  flex: 1;
}

.tvm-field label {
  font-size: 0.72rem;
  font-weight: 600;
  color: var(--tvm-text-secondary);
  text-transform: uppercase;
  letter-spacing: 0.08em;
}

.tvm-field input,
.tvm-field select {
  width: 100%;
  border-radius: 8px;
  border: 1px solid var(--tvm-border);
  padding: 0.55rem 0.75rem;
  background: var(--tvm-surface-secondary);
  color: var(--tvm-text-primary);
  font-size: 0.95rem;
  min-height: var(--tvm-control-height);
}

.tvm-field--search {
  min-width: min(260px, 100%);
}

.tvm-search-input {
  position: relative;
  display: flex;
  align-items: center;
}

.tvm-field--search input {
  padding-left: 2.2rem;
}

.tvm-search-icon {
  position: absolute;
  left: 0.75rem;
  width: 1rem;
  height: 1rem;
  color: var(--tvm-text-secondary);
  display: inline-flex;
  align-items: center;
  justify-content: center;
}

.tvm-search-icon svg {
  width: 100%;
  height: 100%;
}

.tvm-clear-search {
  position: absolute;
  right: 0.5rem;
  border: none;
  background: none;
  color: var(--tvm-text-secondary);
  display: inline-flex;
  align-items: center;
  justify-content: center;
  padding: 0.2rem;
  cursor: pointer;
  transition: color 0.2s ease-in-out;
}

.tvm-clear-search svg {
  width: 14px;
  height: 14px;
}

.tvm-clear-search:hover {
  color: var(--tvm-accent-strong);
}

.tvm-button {
  display: inline-flex;
  align-items: center;
  gap: 0.35rem;
  border-radius: 8px;
  border: 1px solid var(--tvm-border);
  background: var(--tvm-surface-secondary);
  color: var(--tvm-text-primary);
  font-size: 0.82rem;
  padding: 0 0.95rem;
  min-height: var(--tvm-control-height);
  font-weight: 500;
  cursor: pointer;
  transition: background 0.2s ease-in-out, border-color 0.2s ease-in-out, color 0.2s ease-in-out;
}

.tvm-button svg {
  width: 16px;
  height: 16px;
}

.tvm-button:disabled {
  opacity: 0.55;
  cursor: not-allowed;
}

.tvm-button:not(:disabled):hover {
  border-color: var(--tvm-border-strong);
  background: rgb(var(--gray-200) / 0.12);
}

:where(.dark) .tvm-instruction-app .tvm-button:not(:disabled):hover {
  background: rgb(var(--gray-800) / 0.55);
  border-color: var(--tvm-border-strong);
}

.tvm-button--ghost {
  background: transparent;
  color: var(--tvm-text-secondary);
}

.tvm-button--ghost:not(:disabled):hover {
  color: var(--tvm-text-primary);
  background: rgb(var(--gray-200) / 0.1);
}

:where(.dark) .tvm-instruction-app .tvm-button--ghost:not(:disabled):hover {
  background: rgb(var(--gray-800) / 0.4);
  color: var(--tvm-text-primary);
}

.tvm-instruction-meta {
  margin-bottom: 1rem;
  font-size: 0.85rem;
  color: var(--tvm-text-secondary);
  display: flex;
  flex-direction: column;
  gap: 0.75rem;
}

.tvm-meta-items {
  display: flex;
  flex-wrap: wrap;
  gap: 0.75rem;
  align-items: center;
}

.tvm-meta-item {
  display: inline-flex;
  align-items: center;
  gap: 0.35rem;
}

.tvm-meta-link {
  display: inline-flex;
  align-items: center;
  color: var(--tvm-accent-subtle);
  font-weight: 500;
  text-decoration: none;
  gap: 0.3rem;
}

.tvm-meta-link:hover {
  text-decoration: underline;
}

.tvm-meta-chips {
  display: flex;
  flex-wrap: wrap;
  gap: 0.35rem;
}

.tvm-meta-chip {
  display: inline-flex;
  align-items: center;
  gap: 0.25rem;
  border-radius: 999px;
  padding: var(--tvm-chip-padding-y) var(--tvm-chip-padding-x);
  font-size: 0.72rem;
  color: var(--tvm-text-secondary);
  background: var(--tvm-pill-muted-bg);
  border: 1px solid transparent;
  appearance: none;
  cursor: pointer;
  transition: border-color 0.2s ease-in-out, color 0.2s ease-in-out, background 0.2s ease-in-out;
}

.tvm-meta-chip:hover {
  border-color: var(--tvm-border-strong);
  color: var(--tvm-text-primary);
}

.tvm-meta-chip:focus-visible {
  outline: 2px solid var(--tvm-accent-strong);
  outline-offset: 2px;
}

.tvm-meta-chip-label {
  white-space: nowrap;
}

.tvm-meta-chip-close {
  font-size: 0.85em;
  line-height: 1;
}

.tvm-highlight {
  display: inline;
  background: rgb(var(--primary) / 0.22);
  color: inherit;
  border-radius: 4px;
  padding: 0 0.08em;
  line-height: inherit;
  box-decoration-break: clone;
}

.tvm-spec-grid-container {
  border: 1px solid var(--tvm-border);
  border-radius: 12px;
  background: var(--tvm-surface-secondary);
  box-shadow: inset 0 1px 0 rgb(var(--gray-400) / 0.08);
}

.tvm-spec-grid-scroll {
  overflow-x: auto;
}

.tvm-spec-grid-scroll::-webkit-scrollbar {
  height: 6px;
}

.tvm-spec-grid-scroll::-webkit-scrollbar-thumb {
  background: var(--tvm-border-strong);
  border-radius: 999px;
}

.tvm-spec-header,
.tvm-spec-row {
  --tvm-grid-template: 60px 110px 260px minmax(320px, 2fr);
  display: grid;
  grid-template-columns: var(--tvm-grid-template);
  min-width: 860px;
}

.tvm-spec-header {
  background: rgb(var(--gray-400) / 0.12);
  text-transform: uppercase;
  letter-spacing: 0.08em;
  font-size: 0.7rem;
  color: var(--tvm-text-secondary);
}

:where(.dark) .tvm-instruction-app .tvm-spec-header {
  background: rgb(var(--gray-800) / 0.65);
  color: var(--tvm-text-muted);
}

.tvm-spec-header > div {
  padding: calc(var(--tvm-row-padding-y) - 0.1rem) var(--tvm-row-padding-x);
  font-weight: 600;
}

.tvm-spec-row {
  border-top: 1px solid var(--tvm-border);
  transition: background 0.2s ease-in-out;
  cursor: pointer;
  align-items: center;
}

.tvm-spec-row:hover {
  background: rgb(var(--primary) / 0.08);
}

.tvm-spec-row.is-expanded {
  background: rgb(var(--primary) / 0.12);
}

:where(.dark) .tvm-instruction-app .tvm-spec-row:hover {
  background: rgb(var(--primary) / 0.18);
}

:where(.dark) .tvm-instruction-app .tvm-spec-row.is-expanded {
  background: rgb(var(--primary) / 0.26);
}

.tvm-spec-row.is-anchor-target {
  background: rgb(var(--primary) / 0.16);
  box-shadow: inset 0 0 0 1px var(--tvm-accent-strong);
}

.tvm-spec-row--detail.is-anchor-target {
  background: rgb(var(--primary) / 0.1);
}

.tvm-spec-row--detail {
  cursor: default;
  background: var(--tvm-surface-secondary);
  align-items: stretch;
}

.tvm-spec-cell {
  padding: var(--tvm-row-padding-y) var(--tvm-row-padding-x);
  display: flex;
  flex-direction: column;
  gap: 0.35rem;
  min-width: 0;
  color: var(--tvm-text-primary);
}

.tvm-spec-cell--full {
  grid-column: 1 / -1;
}

.tvm-spec-cell--opcode {
  font-family: 'JetBrains Mono', 'Menlo', 'Monaco', monospace;
  font-size: 0.85rem;
  justify-content: center;
  align-items: center;
}

.tvm-spec-cell--anchor {
  justify-content: center;
  align-items: center;
}

.tvm-spec-cell--name {
  gap: 0.4rem;
}

.tvm-name-line {
  position: relative;
}

.tvm-copy-link {
  display: inline-flex;
  align-items: center;
  justify-content: center;
  width: 22px;
  height: 22px;
  border-radius: 6px;
  border: 1px solid var(--tvm-border);
  background: var(--tvm-surface-secondary);
  color: var(--tvm-text-secondary);
  cursor: pointer;
}

.tvm-copy-link:hover {
  border-color: var(--tvm-border-strong);
}

.tvm-copy-link svg {
  width: 14px;
  height: 14px;
}

.tvm-copy-link.is-copied {
  border-color: var(--tvm-accent-strong);
  background: var(--tvm-accent-soft);
  color: var(--tvm-accent-strong);
}

.tvm-name-line {
  display: flex;
  align-items: baseline;
  flex-wrap: wrap;
  gap: 0.5rem;
}

.tvm-row-indicator {
  margin-left: auto;
  display: inline-flex;
  align-items: center;
  justify-content: center;
  width: 24px;
  height: 24px;
  border-radius: 50%;
  color: var(--tvm-text-muted);
  transition: transform 0.2s ease-in-out, color 0.2s ease-in-out, background 0.2s ease-in-out;
  pointer-events: none;
}

.tvm-row-indicator svg {
  width: 14px;
  height: 14px;
}

.tvm-spec-row:hover .tvm-row-indicator {
  background: var(--tvm-pill-muted-bg);
  color: var(--tvm-text-secondary);
}

.tvm-spec-row.is-anchor-target .tvm-row-indicator {
  color: var(--tvm-accent-strong);
}

.tvm-row-indicator.is-expanded {
  transform: rotate(180deg);
  color: var(--tvm-accent-strong);
}

.tvm-mnemonic {
  font-family: 'JetBrains Mono', 'Menlo', 'Monaco', monospace;
  font-size: 1rem;
  font-weight: 600;
  color: var(--tvm-text-primary);
  white-space: pre;
}

.tvm-spec-cell--gas {
  font-family: 'JetBrains Mono', 'Menlo', 'Monaco', monospace;
  font-size: 0.85rem;
  justify-content: center;
  color: var(--tvm-text-secondary);
}

.tvm-spec-cell--description p {
  margin: 0;
}

.tvm-description p {
  margin: 0;
}

.tvm-description {
  font-size: 0.92rem;
  line-height: 1.45;
  color: var(--tvm-text-secondary);
  display: -webkit-box;
  -webkit-line-clamp: 3;
  -webkit-box-orient: vertical;
  overflow: hidden;
}

.tvm-description-meta {
  display: flex;
  flex-wrap: wrap;
  gap: 0.35rem;
}

.tvm-category-pill {
  display: inline-flex;
  align-items: center;
  padding: 0.2rem 0.55rem;
  border-radius: 999px;
  background: var(--tvm-accent-soft);
  color: var(--tvm-accent-subtle);
  font-size: 0.72rem;
  letter-spacing: 0.03em;
}

.tvm-inline-badge {
  display: inline-flex;
  align-items: center;
  padding: 0.18rem 0.45rem;
  border-radius: 999px;
  font-size: 0.7rem;
  letter-spacing: 0.05em;
  text-transform: uppercase;
  background: var(--tvm-accent-soft);
  color: var(--tvm-accent-subtle);
}

.tvm-inline-badge--muted {
  background: var(--tvm-pill-muted-bg);
  color: var(--tvm-text-secondary);
}

.tvm-fift {
  font-size: 0.78rem;
  color: var(--tvm-text-secondary);
  font-family: 'JetBrains Mono', 'Menlo', 'Monaco', monospace;
}

.tvm-operands {
  display: flex;
  flex-wrap: wrap;
  gap: 0.35rem;
}

.tvm-operand-chip {
  display: inline-flex;
  align-items: center;
  padding: 0.18rem 0.45rem;
  border-radius: 6px;
  border: 1px solid var(--tvm-border);
  background: var(--tvm-pill-muted-bg);
  font-size: 0.72rem;
  font-family: 'JetBrains Mono', 'Menlo', 'Monaco', monospace;
  color: var(--tvm-text-secondary);
}

.tvm-stack-columns {
  display: grid;
  grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
  gap: 0.6rem;
}

.tvm-stack-column {
  background: var(--tvm-surface-secondary);
  border: 1px solid rgb(var(--gray-400) / 0.35);
  border-radius: 10px;
  padding: 0.6rem 0.65rem;
  min-width: 0;
}

.tvm-stack-column--compact {
  padding: 0.5rem 0.55rem;
}

.tvm-stack-column-title {
  font-size: 0.7rem;
  text-transform: uppercase;
  letter-spacing: 0.08em;
  color: var(--tvm-text-secondary);
  margin-bottom: 0.35rem;
}

.tvm-stack-top {
  font-size: 0.7rem;
  color: var(--tvm-text-muted);
  margin-bottom: 0.35rem;
}

.tvm-stack-list {
  display: flex;
  flex-direction: column;
  gap: 0.35rem;
}

.tvm-stack-pill {
  display: inline-flex;
  align-items: center;
  padding: 0.18rem 0.45rem;
  border-radius: 6px;
  font-size: 0.75rem;
  font-family: 'JetBrains Mono', 'Menlo', 'Monaco', monospace;
  width: fit-content;
}

.tvm-instruction-app.is-density-compact .tvm-stack-pill {
  font-size: 0.7rem;
  padding: 0.14rem 0.35rem;
}

.tvm-stack-pill--simple {
  background: var(--tvm-stack-simple-bg);
  color: var(--tvm-stack-simple-text);
}

.tvm-stack-pill--const {
  background: var(--tvm-stack-const-bg);
  color: var(--tvm-stack-const-text);
}

.tvm-stack-pill--array {
  background: var(--tvm-stack-array-bg);
  color: var(--tvm-stack-array-text);
}

.tvm-stack-pill--conditional {
  background: var(--tvm-stack-conditional-bg);
  color: var(--tvm-stack-conditional-text);
}

.tvm-stack-pill--empty {
  background: var(--tvm-pill-muted-bg);
  color: var(--tvm-text-secondary);
}

.tvm-stack-pill--more {
  background: rgb(var(--gray-400) / 0.18);
  color: var(--tvm-text-secondary);
}

:where(.dark) .tvm-instruction-app .tvm-stack-pill--more {
  background: rgb(var(--gray-700) / 0.5);
  color: var(--tvm-text-secondary);
}

.tvm-stack-footnote {
  display: inline-block;
  font-family: 'JetBrains Mono', 'Menlo', 'Monaco', monospace;
  font-size: 0.75rem;
  background: rgb(var(--gray-200) / 0.12);
  border: 1px solid var(--tvm-border);
  border-radius: 6px;
  padding: 0.3rem 0.45rem;
  color: var(--tvm-text-secondary);
  max-width: 100%;
  overflow-wrap: anywhere;
}

:where(.dark) .tvm-instruction-app .tvm-stack-footnote {
  background: rgb(var(--gray-900) / 0.6);
  border-color: var(--tvm-border);
  color: var(--tvm-text-secondary);
}

.tvm-stack-conditional {
  border-left: 2px solid var(--tvm-stack-conditional-border);
  padding-left: 0.55rem;
  display: flex;
  flex-direction: column;
  gap: 0.35rem;
}

.tvm-stack-conditional-name {
  font-size: 0.78rem;
  font-weight: 600;
  color: var(--tvm-stack-conditional-text);
}

.tvm-stack-conditional-branch {
  display: flex;
  flex-direction: column;
  gap: 0.25rem;
}

.tvm-stack-conditional-label {
  font-size: 0.7rem;
  text-transform: uppercase;
  letter-spacing: 0.05em;
  color: var(--tvm-stack-label);
}

.tvm-stack-conditional-values {
  display: flex;
  flex-wrap: wrap;
  gap: 0.3rem;
}

.tvm-stack-array {
  display: flex;
  flex-direction: column;
  gap: 0.3rem;
}

.tvm-stack-array-preview {
  display: flex;
  flex-wrap: wrap;
  gap: 0.3rem;
  padding-left: 0.4rem;
}

.tvm-stack-empty {
  font-size: 0.78rem;
  color: var(--tvm-text-secondary);
}

.tvm-detail-panel {
  background: var(--tvm-surface);
  border: 1px solid var(--tvm-border);
  border-radius: 14px;
  padding: 1rem 1.15rem 1.25rem;
  box-shadow: 0 18px 40px -30px rgb(var(--gray-900) / 0.7);
}

.tvm-detail-panel.is-anchor-target {
  border-color: var(--tvm-accent-strong);
  box-shadow: 0 0 0 2px var(--tvm-accent-soft), 0 18px 40px -30px rgb(var(--gray-900) / 0.7);
}

.tvm-detail-header {
  display: flex;
  justify-content: space-between;
  align-items: flex-start;
  gap: 1rem;
  flex-wrap: wrap;
  margin-bottom: 1rem;
}

.tvm-detail-header-main {
  display: flex;
  align-items: baseline;
  gap: 0.45rem;
  flex-wrap: wrap;
}

.tvm-detail-heading {
  display: flex;
  flex-direction: column;
  gap: 0.55rem;
  align-items: flex-start;
  flex: 1 1 auto;
}

.tvm-detail-actions {
  display: flex;
  gap: 0.5rem;
  flex-wrap: wrap;
  align-items: center;
  justify-content: flex-end;
}

.tvm-detail-title {
  margin: 0;
  font-size: 0.78rem;
  letter-spacing: 0.05em;
  text-transform: uppercase;
  color: var(--tvm-text-secondary);
}

.tvm-detail-badges {
  display: flex;
  flex-wrap: wrap;
  gap: 0.45rem;
}

.tvm-detail-badge {
  display: inline-flex;
  align-items: center;
  gap: 0.35rem;
  border: 1px solid var(--tvm-border);
  border-radius: 999px;
  background: var(--tvm-surface-secondary);
  padding: 0.28rem 0.7rem;
  font-size: 0.78rem;
  color: var(--tvm-text-primary);
}

.tvm-detail-badge-label {
  font-size: 0.68rem;
  text-transform: uppercase;
  letter-spacing: 0.08em;
  color: var(--tvm-text-secondary);
}

.tvm-detail-badge-value {
  font-weight: 600;
  display: inline-flex;
  gap: 0.2rem;
  color: var(--tvm-text-primary);
}

.tvm-detail-badge--register {
  background: rgb(var(--primary) / 0.08);
  border-color: rgb(var(--primary) / 0.2);
}

.tvm-register-token {
  font-family: 'JetBrains Mono', 'Menlo', 'Monaco', monospace;
  font-size: 0.82rem;
  color: var(--tvm-text-primary);
}

.tvm-register-token sub {
  font-size: 0.7em;
}

.tvm-register-token--special {
  font-weight: 600;
  text-transform: uppercase;
}

.tvm-register-sep {
  color: var(--tvm-text-secondary);
}

.tvm-detail-columns {
  display: flex;
  flex-wrap: wrap;
  gap: clamp(1rem, 2.5vw, 1.6rem);
  align-items: flex-start;
  margin-bottom: 1.1rem;
}

.tvm-detail-main {
  flex: 1 1 320px;
  min-width: 0;
  display: flex;
  flex-direction: column;
  gap: 0.8rem;
}

.tvm-detail-block {
  display: flex;
  flex-direction: column;
  gap: 0.45rem;
  background: var(--tvm-surface-secondary);
  border: 1px solid var(--tvm-border);
  border-radius: 12px;
  padding: 0.85rem 0.95rem;
}

.tvm-detail-main .tvm-description {
  display: block;
  color: var(--tvm-text-primary);
  -webkit-line-clamp: initial;
  -webkit-box-orient: initial;
  overflow: visible;
}

.tvm-detail-subtitle {
  font-size: 0.7rem;
  letter-spacing: 0.04em;
  text-transform: uppercase;
  color: var(--tvm-text-secondary);
}

.tvm-detail-fift {
  display: flex;
  flex-direction: column;
  gap: 0.4rem;
}

.tvm-detail-code {
  display: block;
  font-family: 'JetBrains Mono', 'Menlo', 'Monaco', monospace;
  font-size: 0.78rem;
  line-height: 1.45;
  white-space: pre-wrap;
  background: rgb(var(--gray-200) / 0.08);
  border: 1px solid var(--tvm-border);
  border-radius: 8px;
  padding: 0.6rem 0.65rem;
  color: var(--tvm-text-primary);
  overflow-x: auto;
  max-width: 100%;
}

.tvm-detail-code--inline {
  display: block;
  padding: 0.5rem 0.6rem;
  word-break: break-word;
}

.tvm-detail-muted {
  margin: 0;
  font-size: 0.78rem;
  color: var(--tvm-text-secondary);
}

.tvm-detail-side {
  flex: 0 1 300px;
  display: flex;
  flex-direction: column;
  gap: 0.9rem;
}

.tvm-side-block {
  display: flex;
  flex-direction: column;
  gap: 0.5rem;
  background: var(--tvm-surface-secondary);
  border: 1px solid rgb(var(--gray-400) / 0.3);
  border-radius: 12px;
  padding: 0.85rem 0.95rem;
}

.tvm-side-category-value {
  font-size: 0.9rem;
  font-weight: 600;
  color: var(--tvm-text-primary);
}

.tvm-side-category-raw {
  font-size: 0.82rem;
  font-weight: 400;
  color: var(--tvm-text-secondary);
  margin-left: 0.3rem;
}

.tvm-side-title {
  font-size: 0.7rem;
  letter-spacing: 0.04em;
  text-transform: uppercase;
  color: var(--tvm-text-secondary);
}

.tvm-detail-section {
  display: flex;
  flex-direction: column;
  gap: 0.55rem;
  background: var(--tvm-surface-secondary);
  border: 1px solid rgb(var(--gray-400) / 0.3);
  border-radius: 12px;
  padding: 0.85rem 0.95rem;
  margin-bottom: 0.9rem;
}

.tvm-detail-section--wide {
  margin-bottom: 0.9rem;
}

.tvm-operands-list {
  display: flex;
  flex-direction: column;
  gap: 0.6rem;
}

.tvm-operands-item {
  background: var(--tvm-surface);
  border: 1px solid rgb(var(--gray-400) / 0.25);
  border-radius: 10px;
  padding: 0.65rem 0.75rem;
  display: flex;
  flex-direction: column;
  gap: 0.35rem;
}

.tvm-operands-line {
  font-weight: 600;
  font-size: 0.88rem;
  color: var(--tvm-text-primary);
}

.tvm-operands-detail {
  font-size: 0.78rem;
  color: var(--tvm-text-secondary);
}

.tvm-impl-badges {
  display: flex;
  flex-wrap: wrap;
  gap: 0.45rem;
}

.tvm-detail-badge--link {
  text-decoration: none;
  color: var(--tvm-text-primary);
  transition: border-color 0.2s ease-in-out, color 0.2s ease-in-out;
}

.tvm-detail-badge--link:hover {
  border-color: var(--tvm-accent);
  color: var(--tvm-accent);
}

.tvm-modal {
  position: fixed;
  inset: 0;
  z-index: 1000;
  display: flex;
  justify-content: center;
  align-items: center;
  padding: 1rem;
}

.tvm-modal-backdrop {
  position: absolute;
  inset: 0;
  background: rgb(var(--gray-900) / 0.45);
  backdrop-filter: blur(1px);
}

.tvm-modal-dialog {
  position: relative;
  background: var(--tvm-surface);
  border: 1px solid var(--tvm-border);
  border-radius: 14px;
  box-shadow: 0 32px 90px -40px rgb(var(--gray-900) / 0.9);
  width: min(720px, 100%);
  max-height: calc(100% - 2rem);
  overflow: hidden;
  display: flex;
  flex-direction: column;
  gap: 0.9rem;
  padding: 1.1rem 1.2rem 1.3rem;
  color: var(--tvm-text-primary);
}

.tvm-modal-header {
  display: flex;
  justify-content: space-between;
  align-items: flex-start;
  gap: 1rem;
}

.tvm-modal-header-text {
  display: flex;
  flex-direction: column;
  gap: 0.35rem;
}

.tvm-modal-header-text h3 {
  margin: 0;
  font-size: 1rem;
  color: var(--tvm-text-primary);
}

.tvm-modal-subtitle {
  margin: 0;
  font-size: 0.85rem;
  color: var(--tvm-text-secondary);
}

.tvm-modal-subtitle code {
  font-family: 'JetBrains Mono', 'Menlo', 'Monaco', monospace;
  font-size: 0.82rem;
  padding: 0.1rem 0.3rem;
  border-radius: 0.4rem;
  background: var(--tvm-pill-muted-bg);
  color: var(--tvm-text-primary);
}

.tvm-modal-actions {
  display: flex;
  flex-wrap: wrap;
  gap: 0.45rem;
  justify-content: flex-end;
}

.tvm-modal-code {
  flex: 1 1 auto;
  margin: 0;
  border: 1px solid var(--tvm-border-strong);
  border-radius: 10px;
  padding: 0.85rem 0.95rem;
  background: rgb(var(--gray-200) / 0.16);
  font-family: 'JetBrains Mono', 'Menlo', 'Monaco', monospace;
  font-size: 0.82rem;
  line-height: 1.55;
  overflow: auto;
  white-space: pre;
  color: var(--tvm-text-primary);
  tab-size: 2;
}

:where(.dark) .tvm-instruction-app .tvm-modal-code {
  background: rgb(var(--gray-900) / 0.7);
}

@media (max-width: 1040px) {
  .tvm-instruction-toolbar {
    flex-direction: column;
    align-items: stretch;
  }

  .tvm-toolbar-utilities {
    justify-content: flex-start;
    width: 100%;
  }
}

@media (max-width: 900px) {
  .tvm-spec-grid-scroll {
    overflow-x: visible;
  }

  .tvm-spec-header {
    display: none;
  }

  .tvm-spec-row,
  .tvm-spec-row--detail {
    --tvm-grid-template: 48px minmax(0, 1fr);
    grid-template-columns: var(--tvm-grid-template);
    min-width: 0;
    align-items: start;
  }

  .tvm-spec-row .tvm-spec-cell--anchor {
    grid-row: span 2;
  }

  .tvm-spec-row .tvm-spec-cell--opcode {
    grid-row: 1;
    grid-column: 2 / -1;
    justify-content: flex-start;
    align-items: baseline;
  }

  .tvm-spec-row .tvm-spec-cell--name {
    grid-column: 2 / -1;
  }

  .tvm-spec-row .tvm-spec-cell--description {
    grid-column: 1 / -1;
  }
}

@media (max-width: 960px) {
  .tvm-detail-header {
    align-items: stretch;
  }

  .tvm-detail-columns {
    flex-direction: column;
  }

  .tvm-detail-section {
    margin-bottom: 0.8rem;
  }
}

@media (max-width: 720px) {
  .tvm-detail-panel {
    padding: 0.95rem 1rem 1.1rem;
  }

  .tvm-side-block,
  .tvm-detail-section {
    padding: 0.85rem 0.9rem;
  }

  .tvm-detail-actions {
    width: 100%;
    justify-content: stretch;
  }

  .tvm-detail-actions .tvm-button {
    flex: 1 1 auto;
  }
}

@media (max-width: 640px) {
  .tvm-modal {
    padding: 0.75rem;
  }

  .tvm-modal-dialog {
    width: 100%;
    max-height: calc(100% - 1.5rem);
    padding: 1rem;
  }

  .tvm-modal-actions {
    width: 100%;
    justify-content: stretch;
  }

  .tvm-modal-actions .tvm-button {
    flex: 1 1 auto;
  }
}

.tvm-control-flow {
  display: flex;
  flex-direction: column;
  gap: 0.65rem;
  padding: 0.75rem 0.8rem;
  border-radius: 12px;
  border: 1px solid var(--tvm-border);
  background: var(--tvm-surface-secondary);
}

.tvm-control-flow-status {
  display: flex;
  align-items: center;
  gap: 0.75rem;
  font-size: 0.85rem;
  color: var(--tvm-text-secondary);
}

.tvm-control-flow-label {
  font-weight: 600;
  text-transform: uppercase;
  letter-spacing: 0.05em;
}

.tvm-control-flow-value {
  font-family: 'JetBrains Mono', 'Menlo', 'Monaco', monospace;
  font-size: 0.85rem;
  color: var(--tvm-text-primary);
}

.tvm-control-flow-branches {
  list-style: none;
  margin: 0;
  margin-top: 0.5rem;
  padding: 0;
  display: flex;
  flex-direction: column;
  gap: 0.55rem;
}

.tvm-control-flow-branch {
  background: var(--tvm-surface);
  border: 1px solid rgb(var(--gray-400) / 0.35);
  border-radius: 10px;
  padding: 0.65rem 0.75rem;
  display: flex;
  flex-direction: column;
  gap: 0.45rem;
}

.tvm-control-flow-branch-header {
  display: flex;
  flex-wrap: wrap;
  gap: 0.5rem;
  align-items: baseline;
}

.tvm-control-flow-branch-title {
  font-size: 0.84rem;
  font-weight: 600;
  color: var(--tvm-text-primary);
}

.tvm-control-flow-branch-condition {
  font-size: 0.76rem;
  color: var(--tvm-text-secondary);
}


.tvm-flow-graph-wrapper {
  position: relative;
  width: 100%;
  overflow-x: auto;
  padding: 0.35rem 0;
}

.tvm-flow-canvas {
  position: relative;
  display: inline-block;
  min-height: 120px;
  min-width: 100%;
}

.tvm-flow-canvas-svg {
  position: absolute;
  top: 0;
  left: 0;
  width: 100%;
  height: 100%;
  overflow: visible;
  pointer-events: none;
}

.tvm-flow-graph-line {
  fill: none;
  stroke: rgb(var(--primary) / 0.45);
  stroke-width: 1.6;
}


.tvm-flow-node {
  position: absolute;
  transform: translate(-50%, -50%);
  pointer-events: auto;
}

.tvm-flow-edge-label {
  position: absolute;
  transform: translate(-50%, -50%);
  pointer-events: none;
  display: flex;
  align-items: center;
  gap: 0.25rem;
  font-family: 'JetBrains Mono', 'Menlo', 'Monaco', monospace;
  font-size: 0.75rem;
  text-transform: uppercase;
  letter-spacing: 0.05em;
  padding: 0.08rem 0.45rem;
  border-radius: 999px;
  border: 1px solid rgb(var(--primary) / 0.2);
  background: var(--tvm-surface);
}

.tvm-flow-edge-label.has-secondary {
  background: linear-gradient(
    90deg,
    rgb(var(--primary) / 0.08) 0%,
    rgb(var(--primary) / 0.08) 50%,
    rgb(var(--primary) / 0.04) 50%,
    rgb(var(--primary) / 0.04) 100%
  );
}

.tvm-flow-edge-label-primary {
  color: rgb(var(--primary));
}

.tvm-flow-edge-label-secondary {
  color: rgb(var(--primary) / 0.55);
}

.tvm-control-flow-node-pill {
  display: inline-flex;
  align-items: center;
  gap: 0.35rem;
  border: 1px solid rgb(var(--primary) / 0.25);
  border-radius: 999px;
  padding: 0.18rem 0.65rem;
  background: rgb(var(--primary) / 0.05);
  white-space: nowrap;
}

.tvm-control-flow-node-type {
  text-transform: uppercase;
  letter-spacing: 0.08em;
  font-size: 0.66rem;
  font-weight: 600;
  color: rgb(var(--primary) / 0.9);
}

.tvm-control-flow-node-value {
  font-family: 'JetBrains Mono', 'Menlo', 'Monaco', monospace;
  font-size: 0.66rem;
  color: var(--tvm-text-primary);
}

.tvm-control-flow-node-extra {
  font-size: 0.72rem;
  color: var(--tvm-text-secondary);
}

.tvm-missing-placeholder {
  margin: 0;
  font-size: 0.78rem;
  color: var(--tvm-callout-text);
  background: rgb(var(--primary) / 0.04);
  border: 1px solid rgb(var(--primary) / 0.12);
  border-radius: 8px;
  padding: 0.35rem 0.55rem;
}

.tvm-example-list {
  list-style: none;
  margin: 0;
  padding: 0;
  display: flex;
  flex-direction: column;
  gap: 0.75rem;
}

.tvm-example-item {
  display: flex;
  flex-direction: column;
  gap: 0.35rem;
  background: var(--tvm-surface);
  border: 1px solid rgb(var(--gray-400) / 0.28);
  border-radius: 10px;
  padding: 0.7rem 0.85rem;
}

.tvm-example-description {
  margin: 0;
  font-size: 0.82rem;
  color: var(--tvm-text-primary);
}

.tvm-example-description a {
  color: var(--tvm-accent);
  text-decoration: none;
}

.tvm-example-description a:hover {
  text-decoration: underline;
}

.tvm-example-code {
  white-space: pre-wrap;
}



.tvm-alias-list {
  list-style: none;
  margin: 0;
  padding: 0;
  display: flex;
  flex-direction: column;
  gap: 0.6rem;
}

.tvm-alias-item {
  list-style: none;
  display: flex;
  flex-direction: column;
  gap: 0.4rem;
  background: var(--tvm-surface-secondary);
  border: 1px solid var(--tvm-border);
  border-radius: 8px;
  padding: 0.55rem 0.7rem;
}

.tvm-alias-headline {
  display: flex;
  align-items: baseline;
  gap: 0.4rem;
}

.tvm-alias-headline code {
  font-family: 'JetBrains Mono', 'Menlo', 'Monaco', monospace;
  font-size: 0.85rem;
  color: var(--tvm-text-primary);
}

.tvm-alias-meta {
  font-size: 0.75rem;
  color: var(--tvm-text-secondary);
}

.tvm-alias-description {
  margin: 0;
  font-size: 0.82rem;
  color: var(--tvm-text-secondary);
}

.tvm-alias-meta-row {
  display: flex;
  flex-wrap: wrap;
  gap: 0.35rem;
}

.tvm-alias-pill {
  display: inline-flex;
  align-items: center;
  gap: 0.3rem;
  padding: 0.18rem 0.45rem;
  border-radius: 6px;
  background: var(--tvm-pill-muted-bg);
  color: var(--tvm-text-secondary);
  font-size: 0.72rem;
}

.tvm-alias-pill code {
  font-family: 'JetBrains Mono', 'Menlo', 'Monaco', monospace;
}

.tvm-loading-row,
.tvm-empty-row,
.tvm-error-row {
  grid-column: 1 / -1;
  text-align: center;
  padding: 1.5rem 1rem;
  font-size: 0.92rem;
  color: var(--tvm-text-secondary);
}

.tvm-error-row {
  color: var(--tvm-accent-strong);
}

@media (max-width: 1024px) {
  .tvm-instruction-app {
    padding: 1.1rem;
  }

  .tvm-spec-header,
  .tvm-spec-row {
    --tvm-grid-template: 48px 95px 220px minmax(280px, 2fr);
    min-width: 720px;
  }
}

@media (max-width: 768px) {
  .tvm-field {
    width: 100%;
    min-width: 0;
  }

  .tvm-toolbar-filters {
    grid-template-columns: 1fr;
  }

  .tvm-toolbar-utilities {
    justify-self: stretch;
    justify-content: flex-start;
  }

  .tvm-toolbar-divider {
    display: none;
  }

  .tvm-meta-items {
    flex-direction: column;
    align-items: flex-start;
    gap: 0.5rem;
  }

  .tvm-stack-columns {
    flex-direction: column;
  }
}
`, []);
  const searchTokens = useMemo(() => createSearchTokens(search), [search]);
  useEffect(() => {
    let cancelled = false;
    async function load() {
      try {
        setLoading(true);
        setError(null);
        const response = await fetch(SPEC_URL);
        if (!response.ok) {
          throw new Error(`Failed to load spec (${response.status})`);
        }
        const payload = await response.json();
        if (!cancelled) {
          setSpec(payload);
          setLoading(false);
          return;
        }
      } catch (cause) {
        if (!cancelled) {
          setError(cause instanceof Error ? cause.message : "Unknown error");
        }
      } finally {
        if (!cancelled) {
          setLoading(false);
        }
      }
    }
    load();
    return () => {
      cancelled = true;
    };
  }, []);
  useEffect(() => {
    setExpanded({});
  }, [spec]);
  useEffect(() => {
    if (typeof window === "undefined") return;
    try {
      const raw = window.localStorage.getItem(PERSIST_KEY);
      if (!raw) return;
      const prefs = JSON.parse(raw);
      if (prefs && typeof prefs === "object") {
        if (typeof prefs.search === "string") setSearch(prefs.search);
        if (typeof prefs.category === "string" && (prefs.category === "All" || CATEGORY_GROUP_KEYS.has(prefs.category))) {
          setCategory(prefs.category);
        }
        if (typeof prefs.subcategory === "string") {
          setSubcategory(prefs.subcategory);
        }
        if (typeof prefs.sortMode === "string" && ["opcode", "name", "category", "since"].includes(prefs.sortMode)) {
          setSortMode(prefs.sortMode);
        }
      }
    } catch (err) {}
  }, []);
  useEffect(() => {
    if (typeof window === "undefined") return;
    try {
      const payload = JSON.stringify({
        search,
        category,
        subcategory,
        sortMode
      });
      window.localStorage.setItem(PERSIST_KEY, payload);
    } catch (err) {}
  }, [search, category, subcategory, sortMode]);
  useEffect(() => {
    if (typeof window === "undefined") return;
    const handler = event => {
      if (event.defaultPrevented || event.key !== "/") return;
      if (event.altKey || event.ctrlKey || event.metaKey) return;
      const active = document.activeElement;
      if (active) {
        const tagName = active.tagName ? active.tagName.toLowerCase() : "";
        if (tagName === "input" || tagName === "textarea" || active.isContentEditable) {
          return;
        }
      }
      event.preventDefault();
      if (searchInputRef.current && typeof searchInputRef.current.focus === "function") {
        searchInputRef.current.focus();
      }
    };
    window.addEventListener("keydown", handler);
    return () => window.removeEventListener("keydown", handler);
  }, []);
  useEffect(() => {
    if (typeof window === "undefined") return;
    const syncHash = () => {
      const hash = window.location.hash ? window.location.hash.slice(1) : "";
      if (!hash) {
        setActiveAnchorId(null);
        return;
      }
      try {
        setActiveAnchorId(decodeURIComponent(hash));
      } catch (_err) {
        setActiveAnchorId(hash);
      }
    };
    syncHash();
    window.addEventListener("hashchange", syncHash);
    return () => window.removeEventListener("hashchange", syncHash);
  }, []);
  const instructions = useMemo(() => {
    if (!spec) {
      return [];
    }
    const aliasByMnemonic = new Map();
    const aliases = Array.isArray(spec.aliases) ? spec.aliases : [];
    aliases.forEach(alias => {
      if (!alias || !alias.alias_of) return;
      const list = aliasByMnemonic.get(alias.alias_of) || [];
      list.push(alias);
      aliasByMnemonic.set(alias.alias_of, list);
    });
    return (Array.isArray(spec.instructions) ? spec.instructions : []).map((raw, idx) => {
      const doc = raw.doc || ({});
      const bytecode = raw.bytecode || ({});
      const valueFlow = raw.value_flow || ({});
      const inputs = Array.isArray(valueFlow.inputs?.stack) ? valueFlow.inputs.stack : [];
      const outputs = Array.isArray(valueFlow.outputs?.stack) ? valueFlow.outputs.stack : [];
      const registersIn = Array.isArray(valueFlow.inputs?.registers) ? valueFlow.inputs.registers : [];
      const registersOut = Array.isArray(valueFlow.outputs?.registers) ? valueFlow.outputs.registers : [];
      const categoryKeyRaw = doc.category || "uncategorized";
      const categoryGroup = resolveCategoryGroup(categoryKeyRaw);
      const categoryGroupKey = categoryGroup.key;
      const categoryGroupLabel = categoryGroup.label;
      const rawCategoryLabel = humanizeCategoryKey(categoryKeyRaw);
      const descriptionMissing = !doc.description;
      const stackDocMissing = !doc.stack;
      const gasMissing = !doc.gas;
      const tlbMissing = !bytecode.tlb;
      const inputsMissing = !Array.isArray(valueFlow.inputs?.stack);
      const outputsMissing = !Array.isArray(valueFlow.outputs?.stack);
      const implementationRefs = extractImplementationRefs(raw.implementation);
      const implementationMissing = implementationRefs.length === 0;
      const controlFlowMissing = !raw.control_flow || !Array.isArray(raw.control_flow.branches);
      const opcode = bytecode.prefix || "";
      const anchorId = buildAnchorId({
        opcode,
        mnemonic: raw.mnemonic
      });
      return {
        uid: `${raw.mnemonic}__${opcode || 'nop'}__${idx}`,
        mnemonic: raw.mnemonic,
        since: typeof raw.since_version === "number" ? raw.since_version : 0,
        anchorId,
        categoryKey: categoryGroupKey,
        categoryLabel: categoryGroupLabel,
        rawCategoryKey: categoryKeyRaw,
        rawCategoryLabel,
        description: doc.description || "",
        descriptionHtml: typeof doc.description_html === "string" ? doc.description_html : "",
        fift: doc.fift || "",
        fiftExamples: Array.isArray(doc.fift_examples) ? doc.fift_examples.map(example => example && typeof example === "object" ? {
          description: typeof example.description === "string" ? example.description : "",
          fift: typeof example.fift === "string" ? example.fift : ""
        } : null).filter(example => example && (example.description || example.fift)) : [],
        gas: doc.gas || "",
        gasDisplay: formatGasDisplay(doc.gas),
        stackDoc: doc.stack || "",
        opcode,
        tlb: bytecode.tlb || "",
        operands: Array.isArray(bytecode.operands) ? bytecode.operands : [],
        valueFlow: {
          inputs,
          outputs
        },
        registers: {
          inputs: registersIn,
          outputs: registersOut
        },
        controlFlow: raw.control_flow || null,
        implementationRefs,
        rawSpec: raw,
        aliases: aliasByMnemonic.get(raw.mnemonic) || [],
        missing: {
          description: descriptionMissing,
          gas: gasMissing,
          tlb: tlbMissing,
          stackDoc: stackDocMissing,
          inputs: inputsMissing,
          outputs: outputsMissing,
          implementation: implementationMissing,
          controlFlow: controlFlowMissing
        }
      };
    });
  }, [spec]);
  const anchorInstruction = useMemo(() => {
    if (!activeAnchorId) return null;
    return instructions.find(item => item.anchorId === activeAnchorId) || null;
  }, [instructions, activeAnchorId]);
  useEffect(() => {
    if (!anchorInstruction) return;
    setExpanded(prev => {
      if (prev[anchorInstruction.uid]) return prev;
      return {
        ...prev,
        [anchorInstruction.uid]: true
      };
    });
  }, [anchorInstruction]);
  useEffect(() => {
    if (!anchorInstruction) return;
    if (typeof document === "undefined" || typeof window === "undefined") return;
    if (!anchorInstruction.anchorId) return;
    const frame = typeof window.requestAnimationFrame === "function" ? window.requestAnimationFrame.bind(window) : cb => setTimeout(cb, 0);
    frame(() => {
      const element = document.getElementById(anchorInstruction.anchorId);
      if (element && typeof element.scrollIntoView === "function") {
        element.scrollIntoView({
          behavior: "smooth",
          block: "start"
        });
      }
    });
  }, [anchorInstruction]);
  const subcategoryMap = useMemo(() => {
    const groups = new Map();
    instructions.forEach(item => {
      if (!item || !item.categoryKey) return;
      const groupKey = item.categoryKey;
      const rawKey = item.rawCategoryKey || "uncategorized";
      const label = item.rawCategoryLabel || humanizeCategoryKey(rawKey);
      if (!groups.has(groupKey)) {
        groups.set(groupKey, new Map());
      }
      const entries = groups.get(groupKey);
      if (!entries.has(rawKey)) {
        entries.set(rawKey, {
          value: rawKey,
          label,
          count: 0
        });
      }
      const record = entries.get(rawKey);
      record.count += 1;
      if (!record.label && label) {
        record.label = label;
      }
    });
    const normalized = new Map();
    groups.forEach((entries, key) => {
      const list = Array.from(entries.values()).sort((a, b) => a.label.localeCompare(b.label));
      normalized.set(key, list);
    });
    return normalized;
  }, [instructions]);
  const categoryOptions = useMemo(() => {
    const present = new Set(subcategoryMap.keys());
    const ordered = CATEGORY_GROUPS.filter(group => present.has(group.key)).map(group => ({
      value: group.key,
      label: group.label
    }));
    return [{
      value: "All",
      label: "All categories"
    }, ...ordered];
  }, [subcategoryMap]);
  const currentSubcategoryOptions = useMemo(() => {
    if (category === "All") return [];
    return subcategoryMap.get(category) || [];
  }, [subcategoryMap, category]);
  const showSubcategorySelect = category !== "All" && currentSubcategoryOptions.length > 1;
  useEffect(() => {
    if (category === "All") return;
    const hasSelection = categoryOptions.some(option => option.value === category);
    if (!hasSelection) {
      setCategory("All");
    }
  }, [categoryOptions, category]);
  useEffect(() => {
    if (category === "All") {
      if (subcategory !== "All") {
        setSubcategory("All");
      }
      return;
    }
    const options = currentSubcategoryOptions;
    if (!options || options.length <= 1) {
      if (subcategory !== "All") {
        setSubcategory("All");
      }
      return;
    }
    const hasSubcategory = options.some(option => option.value === subcategory);
    if (!hasSubcategory) {
      setSubcategory("All");
    }
  }, [category, subcategory, currentSubcategoryOptions]);
  const filtered = useMemo(() => {
    const forcedUid = anchorInstruction?.uid ?? null;
    return instructions.filter(item => {
      if (forcedUid && item.uid === forcedUid) return true;
      if (category !== "All" && item.categoryKey !== category) return false;
      if (category !== "All" && subcategory !== "All" && item.rawCategoryKey !== subcategory) {
        return false;
      }
      return itemRelevanceScore(item, searchTokens) !== Infinity;
    });
  }, [instructions, category, subcategory, searchTokens, anchorInstruction]);
  const sorted = useMemo(() => {
    const copy = filtered.slice();
    const hasQuery = searchTokens.length > 0;
    if (hasQuery) {
      const tokens = searchTokens;
      copy.sort((a, b) => {
        const sa = itemRelevanceScore(a, tokens);
        const sb = itemRelevanceScore(b, tokens);
        if (sa !== sb) return sa - sb;
        return a.mnemonic.localeCompare(b.mnemonic) || compareOpcodes(a.opcode, b.opcode);
      });
    } else if (sortMode !== "opcode") {
      copy.sort((a, b) => {
        switch (sortMode) {
          case "name":
            return a.mnemonic.localeCompare(b.mnemonic);
          case "category":
            return a.categoryLabel.localeCompare(b.categoryLabel) || a.opcode.localeCompare(b.opcode);
          case "since":
            return (b.since == 9999 ? -1 : b.since) - (a.since == 9999 ? -1 : a.since);
          default:
            return compareOpcodes(a.opcode, b.opcode) || a.mnemonic.localeCompare(b.mnemonic);
        }
      });
    }
    const forcedUid = anchorInstruction?.uid ?? null;
    if (forcedUid) {
      let forcedItem = null;
      const forcedIndex = copy.findIndex(item => item.uid === forcedUid);
      if (forcedIndex >= 0) {
        [forcedItem] = copy.splice(forcedIndex, 1);
      } else if (anchorInstruction) {
        forcedItem = anchorInstruction;
      }
      if (forcedItem) {
        copy.unshift(forcedItem);
      }
    }
    return copy;
  }, [filtered, sortMode, searchTokens, anchorInstruction]);
  const hasActiveFilters = useMemo(() => searchTokens.length > 0 || category !== "All" || subcategory !== "All" || sortMode !== "opcode", [searchTokens, category, subcategory, sortMode]);
  const handleResetFilters = useCallback(() => {
    setSearch("");
    setCategory("All");
    setSubcategory("All");
    setSortMode("opcode");
  }, []);
  const activeFilters = useMemo(() => {
    const chips = [];
    const searchDisplay = search.trim();
    if (searchTokens.length > 0 && searchDisplay) {
      chips.push({
        key: "search",
        label: `Query: "${searchDisplay}"`,
        ariaLabel: `Remove search filter ${searchDisplay}`,
        onRemove: () => setSearch("")
      });
    }
    if (category !== "All") {
      const match = categoryOptions.find(option => option.value === category);
      const label = match ? match.label : humanizeCategoryKey(category);
      chips.push({
        key: "category",
        label: `Category: ${label}`,
        ariaLabel: `Remove category filter ${label}`,
        onRemove: () => setCategory("All")
      });
    }
    if (category !== "All" && subcategory !== "All") {
      const match = currentSubcategoryOptions.find(option => option.value === subcategory);
      const label = match ? match.label : humanizeCategoryKey(subcategory);
      chips.push({
        key: "subcategory",
        label: `Subcategory: ${label}`,
        ariaLabel: `Remove subcategory filter ${label}`,
        onRemove: () => setSubcategory("All")
      });
    }
    if (sortMode !== "opcode") {
      const sortLabels = {
        since: "Newest"
      };
      const label = sortLabels[sortMode] || "Opcode";
      chips.push({
        key: "sort",
        label: `Sort: ${label}`,
        ariaLabel: `Remove sort override ${label}`,
        onRemove: () => setSortMode("opcode")
      });
    }
    return chips;
  }, [searchTokens, search, category, subcategory, categoryOptions, currentSubcategoryOptions, sortMode, setSearch, setCategory, setSubcategory, setSortMode]);
  const toggleRow = useCallback(uid => {
    setExpanded(prev => ({
      ...prev,
      [uid]: !prev[uid]
    }));
  }, []);
  const openRawJsonModal = useCallback(instruction => {
    if (!instruction) return;
    const payload = {
      mnemonic: instruction.mnemonic,
      opcode: instruction.opcode,
      anchorId: instruction.anchorId,
      raw: instruction.rawSpec || instruction
    };
    setRawModalInstruction(payload);
    setRawModalCopied(false);
    if (rawModalCopyTimeoutRef.current) {
      clearTimeout(rawModalCopyTimeoutRef.current);
      rawModalCopyTimeoutRef.current = null;
    }
  }, []);
  const closeRawJsonModal = useCallback(() => {
    setRawModalInstruction(null);
    setRawModalCopied(false);
    if (rawModalCopyTimeoutRef.current) {
      clearTimeout(rawModalCopyTimeoutRef.current);
      rawModalCopyTimeoutRef.current = null;
    }
  }, []);
  const handleCopyRawJson = useCallback(jsonText => {
    copyPlainText(jsonText).then(() => {
      setRawModalCopied(true);
      if (rawModalCopyTimeoutRef.current) {
        clearTimeout(rawModalCopyTimeoutRef.current);
      }
      rawModalCopyTimeoutRef.current = setTimeout(() => {
        setRawModalCopied(false);
        rawModalCopyTimeoutRef.current = null;
      }, 1500);
    }).catch(() => {});
  }, []);
  useEffect(() => {
    if (!rawModalInstruction) return;
    if (typeof window === "undefined") return;
    const handleKeyDown = event => {
      if (event.defaultPrevented) return;
      if (event.key === "Escape") {
        event.preventDefault();
        closeRawJsonModal();
      }
    };
    window.addEventListener("keydown", handleKeyDown);
    return () => window.removeEventListener("keydown", handleKeyDown);
  }, [rawModalInstruction, closeRawJsonModal]);
  const rawModalJson = useMemo(() => {
    if (!rawModalInstruction) return "";
    try {
      return JSON.stringify(rawModalInstruction.raw ?? null, null, 2);
    } catch (err) {
      return "// Failed to serialize instruction";
    }
  }, [rawModalInstruction]);
  useEffect(() => {
    return () => {
      if (rawModalCopyTimeoutRef.current) {
        clearTimeout(rawModalCopyTimeoutRef.current);
        rawModalCopyTimeoutRef.current = null;
      }
    };
  }, []);
  return <div className="tvm-instruction-app">
      <style>{tableStyles}</style>

      <div className="tvm-instruction-toolbar">
        <div className="tvm-toolbar-search">
          <div className="tvm-field tvm-field--search">
            <label htmlFor="tvm-search">Search</label>
            <div className="tvm-search-row">
              <div className="tvm-search-input">
                <span className="tvm-search-icon" aria-hidden="true">
                  <svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
                    <circle cx="11" cy="11" r="6" stroke="currentColor" strokeWidth="2" />
                    <path d="M20 20l-3.5-3.5" stroke="currentColor" strokeWidth="2" strokeLinecap="round" />
                  </svg>
                </span>
                <input id="tvm-search" type="search" placeholder="Find by mnemonic, opcode, description…" value={search} onChange={event => setSearch(event.currentTarget.value)} ref={searchInputRef} />
                {search && <button type="button" className="tvm-clear-search" onClick={() => setSearch("")} aria-label="Clear search">
                    <svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
                      <path d="M15 9l-6 6" stroke="currentColor" strokeWidth="2" strokeLinecap="round" />
                      <path d="M9 9l6 6" stroke="currentColor" strokeWidth="2" strokeLinecap="round" />
                    </svg>
                  </button>}
              </div>
              <div className="tvm-toolbar-utilities">
                <button type="button" className="tvm-button tvm-button--ghost" onClick={handleResetFilters} disabled={!hasActiveFilters}>
                  Reset filters
                </button>
              </div>
            </div>
          </div>
        </div>

        <div className="tvm-toolbar-filters">
          <div className="tvm-field tvm-field--sort">
            <label htmlFor="tvm-sort">Sort</label>
            <select id="tvm-sort" value={sortMode} onChange={event => setSortMode(event.currentTarget.value)}>
              <option value="opcode">Opcode</option>
              <option value="since">Newest</option>
            </select>
          </div>

          <div className="tvm-field tvm-field--category">
            <label htmlFor="tvm-category">Category</label>
            <select id="tvm-category" value={category} onChange={event => setCategory(event.currentTarget.value)}>
              {categoryOptions.map(option => <option key={option.value} value={option.value}>
                  {option.label}
                </option>)}
            </select>
          </div>

          {showSubcategorySelect && <div className="tvm-field tvm-field--subcategory">
              <label htmlFor="tvm-subcategory">Subcategory</label>
              <select id="tvm-subcategory" value={subcategory} onChange={event => setSubcategory(event.currentTarget.value)}>
                <option value="All">All subcategories</option>
                {currentSubcategoryOptions.map(option => <option key={option.value} value={option.value}>
                    {option.label}
                  </option>)}
              </select>
            </div>}
        </div>
      </div>

      <div className="tvm-instruction-meta">
        <div className="tvm-meta-items">
          {loading && <span className="tvm-meta-item">Loading specification…</span>}
          {error && !loading && <span className="tvm-meta-item">Failed to load specification.</span>}
          {!loading && !error && <span className="tvm-meta-item">
              Showing {sorted.length} of {instructions.length} instructions
            </span>}
        </div>
        {activeFilters.length > 0 && <div className="tvm-meta-chips" aria-live="polite">
            {activeFilters.map(({key, label, ariaLabel, onRemove}) => <button key={key} type="button" className="tvm-meta-chip" onClick={onRemove} aria-label={ariaLabel || `Remove filter ${label}`} title={label}>
                <span className="tvm-meta-chip-label">{label}</span>
                <span className="tvm-meta-chip-close" aria-hidden="true">
                  ×
                </span>
              </button>)}
          </div>}
      </div>

      <div className="tvm-spec-grid-container">
        <div className="tvm-spec-grid-scroll">
          <div className="tvm-spec-header" role="row">
            <div>Link</div>
            <div>Opcode</div>
            <div>Instruction</div>
            <div>Description</div>
          </div>

          {error && <div className="tvm-error-row">{error}</div>}

          {!error && <>
              {loading && <div className="tvm-loading-row">Loading specification…</div>}
              {!loading && sorted.length === 0 && <div className="tvm-empty-row">
                  No instructions match the filters.
                </div>}
              {!loading && sorted.flatMap(instruction => {
    const isExpanded = Boolean(expanded[instruction.uid]);
    const aliasCount = Array.isArray(instruction.aliases) ? instruction.aliases.length : 0;
    const detailId = `tvm-detail-${instruction.uid}`;
    const anchorId = instruction.anchorId || buildAnchorId(instruction);
    const isAnchorTarget = anchorInstruction && anchorInstruction.uid === instruction.uid;
    const rowClassName = ["tvm-spec-row", isExpanded ? "is-expanded" : "", isAnchorTarget ? "is-anchor-target" : ""].filter(Boolean).join(" ");
    const descriptionHtml = highlightHtmlContent(instruction.descriptionHtml || instruction.description || "", searchTokens);
    const nodes = [<div key={instruction.uid} id={anchorId} className={rowClassName} role="button" tabIndex={0} aria-expanded={isExpanded} aria-controls={detailId} onClick={() => toggleRow(instruction.uid)} onKeyDown={event => {
      if (event.key === "Enter" || event.key === " ") {
        event.preventDefault();
        toggleRow(instruction.uid);
      }
    }}>
                      <div className="tvm-spec-cell tvm-spec-cell--anchor">
                        <button type="button" className={`tvm-copy-link ${copied[instruction.uid] ? "is-copied" : ""}`} aria-label={copied[instruction.uid] ? "Copied" : "Copy link to instruction"} onClick={e => {
      e.stopPropagation();
      copyAnchorUrl(anchorId).then(() => {
        setCopied(prev => ({
          ...prev,
          [instruction.uid]: true
        }));
        setTimeout(() => {
          setCopied(prev => {
            const {[instruction.uid]: _omit, ...rest} = prev;
            return rest;
          });
        }, 1500);
      }).catch(() => {});
    }} title={copied[instruction.uid] ? "Copied" : "Copy link"}>
                          {copied[instruction.uid] ? <svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg" aria-hidden="true">
                              <path d="M20 6L9 17l-5-5" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" />
                            </svg> : <svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg" aria-hidden="true">
                              <path d="M10.59 13.41a1.996 1.996 0 0 0 2.82 0l3.59-3.59a2 2 0 0 0-2.83-2.83l-1.17 1.17" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" />
                              <path d="M13.41 10.59a1.996 1.996 0 0 0-2.82 0L7 14.18a2 2 0 1 0 2.83 2.83l1.17-1.17" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" />
                            </svg>}
                        </button>
                      </div>
                      <div className="tvm-spec-cell tvm-spec-cell--opcode">
                        <code>
                          {highlightMatches(instruction.opcode || "—", searchTokens)}
                        </code>
                      </div>
                      <div className="tvm-spec-cell tvm-spec-cell--name">
                        <div className="tvm-name-line">
                          <span className="tvm-mnemonic">
                            {highlightMatches(instruction.mnemonic, searchTokens)}
                          </span>
                          {instruction.since > 0 && <span className="tvm-inline-badge">
                              {instruction.since != 9999 ? `since v${instruction.since}` : 'unimplemented yet'}
                            </span>}
                          {aliasCount > 0 && <span className="tvm-inline-badge tvm-inline-badge--muted">
                              {aliasCount} alias{aliasCount > 1 ? "es" : ""}
                            </span>}
                          <span className={`tvm-row-indicator ${isExpanded ? "is-expanded" : ""}`} aria-hidden="true">
                            <svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
                              <path d="M6 9l6 6 6-6" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" />
                            </svg>
                          </span>
                        </div>
                        {instruction.operands.length > 0 && <div className="tvm-operands">
                            {instruction.operands.map((operand, idx) => <span key={idx} className="tvm-operand-chip">
                                {highlightMatches(formatOperandSummary(operand), searchTokens)}
                              </span>)}
                          </div>}
                      </div>
                      <div className="tvm-spec-cell tvm-spec-cell--description">
                        {instruction.description || instruction.descriptionHtml ? <div className="tvm-description" dangerouslySetInnerHTML={{
      __html: descriptionHtml
    }} /> : null}
                        <div className="tvm-description-meta">
                          <span className="tvm-category-pill">
                            {instruction.categoryLabel}
                          </span>
                        </div>
                      </div>
                    </div>];
    if (isExpanded) {
      nodes.push(<div key={`${instruction.uid}-detail`} className={`tvm-spec-row tvm-spec-row--detail ${isAnchorTarget ? "is-anchor-target" : ""}`}>
                        <div className="tvm-spec-cell tvm-spec-cell--full" id={detailId}>
                          {renderInstructionDetail(instruction, {
        isAnchorTarget,
        onOpenRawJson: openRawJsonModal
      })}
                        </div>
                      </div>);
    }
    return nodes;
  })}
            </>}
      </div>
    </div>

      {rawModalInstruction && <div className="tvm-modal" role="dialog" aria-modal="true" aria-labelledby="tvm-raw-json-title">
          <div className="tvm-modal-backdrop" onClick={closeRawJsonModal} />
          <div className="tvm-modal-dialog" role="document" onClick={event => event.stopPropagation()}>
            <div className="tvm-modal-header">
              <div className="tvm-modal-header-text">
                <h3 id="tvm-raw-json-title">Raw instruction JSON</h3>
                <p className="tvm-modal-subtitle">
                  {rawModalInstruction.opcode ? <>
                      <code>{rawModalInstruction.opcode}</code>
                      {" "}
                    </> : null}
                  {rawModalInstruction.mnemonic}
                </p>
              </div>
              <div className="tvm-modal-actions">
                <button type="button" className="tvm-button tvm-button--ghost" onClick={() => handleCopyRawJson(rawModalJson)}>
                  {rawModalCopied ? "Copied" : "Copy JSON"}
                </button>
                <button type="button" className="tvm-button" onClick={closeRawJsonModal}>
                  Close
                </button>
              </div>
            </div>
            <pre className="tvm-modal-code">{rawModalJson}</pre>
          </div>
        </div>}
    </div>;
};

<TvmInstructionTable />

<div hidden>
  #### `00` NOP

  Does nothing.<br />
  **Category:** Stack Basic (stack\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  NOP
  ```

  #### `0i` XCHG\_0I

  Interchanges `s0` with `s[i]`, `1 <= i <= 15`.<br />
  **Category:** Stack Basic (stack\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  s[i] XCHG0
  ```

  **Aliases**:

  * `SWAP`<br />
    Same as `s1 XCHG0`.

  #### `10ij` XCHG\_IJ

  Interchanges `s[i]` with `s[j]`, `1 <= i < j <= 15`.<br />
  **Category:** Stack Basic (stack\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  s[i] s[j] XCHG
  ```

  #### `11ii` XCHG\_0I\_LONG

  Interchanges `s0` with `s[ii]`, `0 <= ii <= 255`.<br />
  **Category:** Stack Basic (stack\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  s0 [ii] s() XCHG
  ```

  #### `1i` XCHG\_1I

  Interchanges `s1` with `s[i]`, `2 <= i <= 15`.<br />
  **Category:** Stack Basic (stack\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  s1 s[i] XCHG
  ```

  #### `2i` PUSH

  Pushes a copy of the old `s[i]` into the stack.<br />
  **Category:** Stack Basic (stack\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  s[i] PUSH
  ```

  **Aliases**:

  * `DUP`<br />
    Same as `s0 PUSH`.
  * `OVER`<br />
    Same as `s1 PUSH`.

  #### `3i` POP

  Pops the old `s0` value into the old `s[i]`.<br />
  **Category:** Stack Basic (stack\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  s[i] POP
  ```

  **Aliases**:

  * `DROP`<br />
    Same as `s0 POP`, discards the top-of-stack value.
  * `NIP`<br />
    Same as `s1 POP`.

  #### `4ijk` XCHG3

  Equivalent to `s2 s[i] XCHG` `s1 s[j] XCHG` `s[k] XCHG0`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  s[i] s[j] s[k] XCHG3
  ```

  #### `50ij` XCHG2

  Equivalent to `s1 s[i] XCHG` `s[j] XCHG0`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  s[i] s[j] XCHG2
  ```

  #### `51ij` XCPU

  Equivalent to `s[i] XCHG0` `s[j] PUSH`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  s[i] s[j] XCPU
  ```

  #### `52ij` PUXC

  Equivalent to `s[i] PUSH` `SWAP` `s[j] XCHG0`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  s[i] s[j-1] PUXC
  ```

  #### `53ij` PUSH2

  Equivalent to `s[i] PUSH` `s[j+1] PUSH`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  s[i] s[j] PUSH2
  ```

  #### `540ijk` XCHG3\_ALT

  Long form of `XCHG3`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  s[i] s[j] s[k] XCHG3_l
  ```

  #### `541ijk` XC2PU

  Equivalent to `s[i] s[j] XCHG2` `s[k] PUSH`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  s[i] s[j] s[k] XC2PU
  ```

  #### `542ijk` XCPUXC

  Equivalent to `s1 s[i] XCHG` `s[j] s[k-1] PUXC`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  s[i] s[j] s[k-1] XCPUXC
  ```

  #### `543ijk` XCPU2

  Equivalent to `s[i] XCHG0` `s[j] s[k] PUSH2`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  s[i] s[j] s[k] XCPU2
  ```

  #### `544ijk` PUXC2

  Equivalent to `s[i] PUSH` `s2 XCHG0` `s[j] s[k] XCHG2`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  s[i] s[j-1] s[k-1] PUXC2
  ```

  #### `545ijk` PUXCPU

  Equivalent to `s[i] s[j-1] PUXC` `s[k] PUSH`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  s[i] s[j-1] s[k-1] PUXCPU
  ```

  #### `546ijk` PU2XC

  Equivalent to `s[i] PUSH` `SWAP` `s[j] s[k-1] PUXC`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  s[i] s[j-1] s[k-2] PU2XC
  ```

  #### `547ijk` PUSH3

  Equivalent to `s[i] PUSH` `s[j+1] s[k+1] PUSH2`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  s[i] s[j] s[k] PUSH3
  ```

  #### `55ij` BLKSWAP

  Permutes two blocks `s[j+i+1] ... s[j+1]` and `s[j] ... s0`.<br />`0 <= i,j <= 15`<br />Equivalent to `[i+1] [j+1] REVERSE` `[j+1] 0 REVERSE` `[i+j+2] 0 REVERSE`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [i+1] [j+1] BLKSWAP
  ```

  **Aliases**:

  * `ROT2`<br />
    Rotates the three topmost pairs of stack entries.
  * `ROLL`<br />
    Rotates the top `i+1` stack entries.<br />Equivalent to `1 [i+1] BLKSWAP`.
  * `ROLLREV`<br />
    Rotates the top `i+1` stack entries in the other direction.<br />Equivalent to `[i+1] 1 BLKSWAP`.

  #### `56ii` PUSH\_LONG

  Pushes a copy of the old `s[ii]` into the stack.<br />`0 <= ii <= 255`<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [ii] s() PUSH
  ```

  #### `57ii` POP\_LONG

  Pops the old `s0` value into the old `s[ii]`.<br />`0 <= ii <= 255`<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [ii] s() POP
  ```

  #### `58` ROT

  Equivalent to `1 2 BLKSWAP` or to `s2 s1 XCHG2`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  ROT
  ```

  #### `59` ROTREV

  Equivalent to `2 1 BLKSWAP` or to `s2 s2 XCHG2`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  ROTREV
  -ROT
  ```

  #### `5A` SWAP2

  Equivalent to `2 2 BLKSWAP` or to `s3 s2 XCHG2`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SWAP2
  2SWAP
  ```

  #### `5B` DROP2

  Equivalent to `DROP` `DROP`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DROP2
  2DROP
  ```

  #### `5C` DUP2

  Equivalent to `s1 s0 PUSH2`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DUP2
  2DUP
  ```

  #### `5D` OVER2

  Equivalent to `s3 s2 PUSH2`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  OVER2
  2OVER
  ```

  #### `5Eij` REVERSE

  Reverses the order of `s[j+i+1] ... s[j]`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [i+2] [j] REVERSE
  ```

  #### `5F0i` BLKDROP

  Equivalent to `DROP` performed `i` times.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [i] BLKDROP
  ```

  #### `5Fij` BLKPUSH

  Equivalent to `PUSH s(j)` performed `i` times.<br />`1 <= i <= 15`, `0 <= j <= 15`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [i] [j] BLKPUSH
  ```

  #### `60` PICK

  Pops integer `i` from the stack, then performs `s[i] PUSH`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PICK
  PUSHX
  ```

  #### `61` ROLLX

  Pops integer `i` from the stack, then performs `1 [i] BLKSWAP`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  ROLLX
  ```

  #### `62` -ROLLX

  Pops integer `i` from the stack, then performs `[i] 1 BLKSWAP`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  -ROLLX
  ROLLREVX
  ```

  #### `63` BLKSWX

  Pops integers `i`,`j` from the stack, then performs `[i] [j] BLKSWAP`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BLKSWX
  ```

  #### `64` REVX

  Pops integers `i`,`j` from the stack, then performs `[i] [j] REVERSE`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  REVX
  ```

  #### `65` DROPX

  Pops integer `i` from the stack, then performs `[i] BLKDROP`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DROPX
  ```

  #### `66` TUCK

  Equivalent to `SWAP` `OVER` or to `s1 s1 XCPU`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  TUCK
  ```

  #### `67` XCHGX

  Pops integer `i` from the stack, then performs `s[i] XCHG`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  XCHGX
  ```

  #### `68` DEPTH

  Pushes the current depth of the stack.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DEPTH
  ```

  #### `69` CHKDEPTH

  Pops integer `i` from the stack, then checks whether there are at least `i` elements, generating a stack underflow exception otherwise.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  CHKDEPTH
  ```

  #### `6A` ONLYTOPX

  Pops integer `i` from the stack, then removes all but the top `i` elements.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  ONLYTOPX
  ```

  #### `6B` ONLYX

  Pops integer `i` from the stack, then leaves only the bottom `i` elements. Approximately equivalent to `DEPTH` `SWAP` `SUB` `DROPX`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  ONLYX
  ```

  #### `6Cij` BLKDROP2

  Drops `i` stack elements under the top `j` elements.<br />`1 <= i <= 15`, `0 <= j <= 15`<br />Equivalent to `[i+j] 0 REVERSE` `[i] BLKDROP` `[j] 0 REVERSE`.<br />
  **Category:** Stack Complex (stack\_complex)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [i] [j] BLKDROP2
  ```

  #### `6D` NULL

  Pushes the only value of type *Null*.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  NULL
  PUSHNULL
  ```

  **Aliases**:

  * `NEWDICT`<br />
    Returns a new empty dictionary.<br />It is an alternative mnemonics for `PUSHNULL`.

  #### `6E` ISNULL

  Checks whether `x` is a *Null*, and returns `-1` or `0` accordingly.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  ISNULL
  ```

  **Aliases**:

  * `DICTEMPTY`<br />
    Checks whether dictionary `D` is empty, and returns `-1` or `0` accordingly.<br />It is an alternative mnemonics for `ISNULL`.

  #### `6F0n` TUPLE

  Creates a new *Tuple* `t=(x_1, ... ,x_n)` containing `n` values `x_1`,..., `x_n`.<br />`0 <= n <= 15`<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [n] TUPLE
  ```

  **Aliases**:

  * `NIL`<br />
    Pushes the only *Tuple* `t=()` of length zero.
  * `SINGLE`<br />
    Creates a singleton `t:=(x)`, i.e., a *Tuple* of length one.
  * `PAIR`<br />
    Creates pair `t:=(x,y)`.
  * `TRIPLE`<br />
    Creates triple `t:=(x,y,z)`.

  #### `6F1k` INDEX

  Returns the `k`-th element of a *Tuple* `t`.<br />`0 <= k <= 15`.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [k] INDEX
  ```

  **Aliases**:

  * `FIRST`<br />
    Returns the first element of a *Tuple*.
  * `SECOND`<br />
    Returns the second element of a *Tuple*.
  * `THIRD`<br />
    Returns the third element of a *Tuple*.

  #### `6F2n` UNTUPLE

  Unpacks a *Tuple* `t=(x_1,...,x_n)` of length equal to `0 <= n <= 15`.<br />If `t` is not a *Tuple*, or if `|t| != n`, a type check exception is thrown.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [n] UNTUPLE
  ```

  **Aliases**:

  * `UNSINGLE`<br />
    Unpacks a singleton `t=(x)`.
  * `UNPAIR`<br />
    Unpacks a pair `t=(x,y)`.
  * `UNTRIPLE`<br />
    Unpacks a triple `t=(x,y,z)`.

  #### `6F3k` UNPACKFIRST

  Unpacks first `0 <= k <= 15` elements of a *Tuple* `t`.<br />If `|t|<k`, throws a type check exception.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [k] UNPACKFIRST
  ```

  **Aliases**:

  * `CHKTUPLE`<br />
    Checks whether `t` is a *Tuple*. If not, throws a type check exception.

  #### `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.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [n] EXPLODE
  ```

  #### `6F5k` SETINDEX

  Computes *Tuple* `t'` that differs from `t` only at position `t'_{k+1}`, which is set to `x`.<br />`0 <= k <= 15`<br />If `k >= |t|`, throws a range check exception.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [k] SETINDEX
  ```

  **Aliases**:

  * `SETFIRST`<br />
    Sets the first component of *Tuple* `t` to `x` and returns the resulting *Tuple* `t'`.
  * `SETSECOND`<br />
    Sets the second component of *Tuple* `t` to `x` and returns the resulting *Tuple* `t'`.
  * `SETTHIRD`<br />
    Sets the third component of *Tuple* `t` to `x` and returns the resulting *Tuple* `t'`.

  #### `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`.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [k] INDEXQ
  ```

  **Aliases**:

  * `FIRSTQ`<br />
    Returns the first element of a *Tuple*.
  * `SECONDQ`<br />
    Returns the second element of a *Tuple*.
  * `THIRDQ`<br />
    Returns the third element of a *Tuple*.

  #### `6F7k` SETINDEXQ

  Sets the `k`-th component of *Tuple* `t` to `x`, where `0 <= k < 16`, and returns the resulting *Tuple* `t'`.<br />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).<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [k] SETINDEXQ
  ```

  **Aliases**:

  * `SETFIRSTQ`<br />
    Sets the first component of *Tuple* `t` to `x` and returns the resulting *Tuple* `t'`.
  * `SETSECONDQ`<br />
    Sets the second component of *Tuple* `t` to `x` and returns the resulting *Tuple* `t'`.
  * `SETTHIRDQ`<br />
    Sets the third component of *Tuple* `t` to `x` and returns the resulting *Tuple* `t'`.

  #### `6F80` TUPLEVAR

  Creates a new *Tuple* `t` of length `n` similarly to `TUPLE`, but with `0 <= n <= 255` taken from the stack.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  TUPLEVAR
  ```

  #### `6F81` INDEXVAR

  Similar to `k INDEX`, but with `0 <= k <= 254` taken from the stack.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  INDEXVAR
  ```

  #### `6F82` UNTUPLEVAR

  Similar to `n UNTUPLE`, but with `0 <= n <= 255` taken from the stack.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  UNTUPLEVAR
  ```

  #### `6F83` UNPACKFIRSTVAR

  Similar to `n UNPACKFIRST`, but with `0 <= n <= 255` taken from the stack.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  UNPACKFIRSTVAR
  ```

  #### `6F84` EXPLODEVAR

  Similar to `n EXPLODE`, but with `0 <= n <= 255` taken from the stack.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  EXPLODEVAR
  ```

  #### `6F85` SETINDEXVAR

  Similar to `k SETINDEX`, but with `0 <= k <= 254` taken from the stack.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SETINDEXVAR
  ```

  #### `6F86` INDEXVARQ

  Similar to `n INDEXQ`, but with `0 <= k <= 254` taken from the stack.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  INDEXVARQ
  ```

  #### `6F87` SETINDEXVARQ

  Similar to `k SETINDEXQ`, but with `0 <= k <= 254` taken from the stack.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SETINDEXVARQ
  ```

  #### `6F88` TLEN

  Returns the length of a *Tuple*.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  TLEN
  ```

  #### `6F89` QTLEN

  Similar to `TLEN`, but returns `-1` if `t` is not a *Tuple*.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QTLEN
  ```

  #### `6F8A` ISTUPLE

  Returns `-1` or `0` depending on whether `t` is a *Tuple*.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  ISTUPLE
  ```

  #### `6F8B` LAST

  Returns the last element of a non-empty *Tuple* `t`.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LAST
  ```

  #### `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.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  TPUSH
  COMMA
  ```

  #### `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`.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  TPOP
  ```

  #### `6FA0` NULLSWAPIF

  Pushes a *Null* under the topmost *Integer* `x`, but only if `x!=0`.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  NULLSWAPIF
  ```

  #### `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`.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  NULLSWAPIFNOT
  ```

  #### `6FA2` NULLROTRIF

  Pushes a *Null* under the second stack entry from the top, but only if the topmost *Integer* `y` is non-zero.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  NULLROTRIF
  ```

  #### `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`.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  NULLROTRIFNOT
  ```

  #### `6FA4` NULLSWAPIF2

  Pushes two nulls under the topmost *Integer* `x`, but only if `x!=0`.<br />Equivalent to `NULLSWAPIF` `NULLSWAPIF`.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  NULLSWAPIF2
  ```

  #### `6FA5` NULLSWAPIFNOT2

  Pushes two nulls under the topmost *Integer* `x`, but only if `x=0`.<br />Equivalent to `NULLSWAPIFNOT` `NULLSWAPIFNOT`.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  NULLSWAPIFNOT2
  ```

  #### `6FA6` NULLROTRIF2

  Pushes two nulls under the second stack entry from the top, but only if the topmost *Integer* `y` is non-zero.<br />Equivalent to `NULLROTRIF` `NULLROTRIF`.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  NULLROTRIF2
  ```

  #### `6FA7` NULLROTRIFNOT2

  Pushes two nulls under the second stack entry from the top, but only if the topmost *Integer* `y` is zero.<br />Equivalent to `NULLROTRIFNOT` `NULLROTRIFNOT`.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  NULLROTRIFNOT2
  ```

  #### `6FBij` INDEX2

  Recovers `x=(t_{i+1})_{j+1}` for `0 <= i,j <= 3`.<br />Equivalent to `[i] INDEX` `[j] INDEX`.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [i] [j] INDEX2
  ```

  **Aliases**:

  * `CADR`<br />
    Recovers `x=(t_2)_1`.
  * `CDDR`<br />
    Recovers `x=(t_2)_2`.

  #### `6FE_ijk` INDEX3

  Recovers `x=t_{i+1}_{j+1}_{k+1}`.<br />`0 <= i,j,k <= 3`<br />Equivalent to `[i] [j] INDEX2` `[k] INDEX`.<br />
  **Category:** Tuple (tuple)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [i] [j] [k] INDEX3
  ```

  **Aliases**:

  * `CADDR`<br />
    Recovers `x=t_2_2_1`.
  * `CDDDR`<br />
    Recovers `x=t_2_2_2`.

  #### `7i` PUSHINT\_4

  Pushes integer `x` into the stack. `-5 <= x <= 10`.<br />Here `i` equals four lower-order bits of `x` (`i=x mod 16`).<br />
  **Category:** Const Int (const\_int)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [x] PUSHINT
  [x] INT
  ```

  **Aliases**:

  * `ZERO`<br />
  * `ONE`<br />
  * `TWO`<br />
  * `TEN`<br />
  * `TRUE`<br />

  #### `80xx` PUSHINT\_8

  Pushes integer `xx`. `-128 <= xx <= 127`.<br />
  **Category:** Const Int (const\_int)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [xx] PUSHINT
  [xx] INT
  ```

  #### `81xxxx` PUSHINT\_16

  Pushes integer `xxxx`. `-2^15 <= xx < 2^15`.<br />
  **Category:** Const Int (const\_int)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [xxxx] PUSHINT
  [xxxx] INT
  ```

  #### `82lxxx` PUSHINT\_LONG

  Pushes integer `xxx`.<br />*Details:* 5-bit `0 <= l <= 30` determines the length `n=8l+19` of signed big-endian integer `xxx`.<br />The total length of this instruction is `l+4` bytes or `n+13=8l+32` bits.<br />
  **Category:** Const Int (const\_int)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [xxx] PUSHINT
  [xxx] INT
  ```

  #### `83xx` PUSHPOW2

  (Quietly) pushes `2^(xx+1)` for `0 <= xx <= 255`.<br />`2^256` is a `NaN`.<br />
  **Category:** Const Int (const\_int)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [xx+1] PUSHPOW2
  ```

  #### `83FF` PUSHNAN

  Pushes a `NaN`.<br />
  **Category:** Const Int (const\_int)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PUSHNAN
  ```

  #### `84xx` PUSHPOW2DEC

  Pushes `2^(xx+1)-1` for `0 <= xx <= 255`.<br />
  **Category:** Const Int (const\_int)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [xx+1] PUSHPOW2DEC
  ```

  #### `85xx` PUSHNEGPOW2

  Pushes `-2^(xx+1)` for `0 <= xx <= 255`.<br />
  **Category:** Const Int (const\_int)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [xx+1] PUSHNEGPOW2
  ```

  #### `88` PUSHREF

  Pushes the reference `ref` into the stack.<br />*Details:* Pushes the first reference of `cc.code` into the stack as a *Cell* (and removes this reference from the current continuation).<br />
  **Category:** Const Data (const\_data)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [ref] PUSHREF
  ```

  #### `89` PUSHREFSLICE

  Similar to `PUSHREF`, but converts the cell into a *Slice*.<br />
  **Category:** Const Data (const\_data)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [ref] PUSHREFSLICE
  ```

  #### `8A` PUSHREFCONT

  Similar to `PUSHREFSLICE`, but makes a simple ordinary *Continuation* out of the cell.<br />
  **Category:** Const Data (const\_data)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [ref] PUSHREFCONT
  ```

  #### `8Bxsss` PUSHSLICE

  Pushes the slice `slice` into the stack.<br />*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`.<br />A completion tag is assumed, meaning that all trailing zeroes and the last binary one (if present) are removed from this bitstring.<br />If the original bitstring consists only of zeroes, an empty slice will be pushed.<br />
  **Category:** Const Data (const\_data)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [slice] PUSHSLICE
  [slice] SLICE
  ```

  #### `8Crxxssss` PUSHSLICE\_REFS

  Pushes the slice `slice` into the stack.<br />*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`.<br />A completion tag is also assumed.<br />
  **Category:** Const Data (const\_data)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [slice] PUSHSLICE
  [slice] SLICE
  ```

  #### `8Drxxsssss` PUSHSLICE\_LONG

  Pushes the slice `slice` into the stack.<br />*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`.<br />A completion tag is assumed.<br />
  **Category:** Const Data (const\_data)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [slice] PUSHSLICE
  [slice] SLICE
  ```

  #### `8F_rxxcccc` PUSHCONT

  Pushes a continuation made from `builder`.<br />*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`.<br />
  **Category:** Const Data (const\_data)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [builder] PUSHCONT
  [builder] CONT
  ```

  #### `9xccc` PUSHCONT\_SHORT

  Pushes a continuation made from `builder`.<br />*Details:* Pushes an `x`-byte continuation for `0 <= x <= 15`.<br />
  **Category:** Const Data (const\_data)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [builder] PUSHCONT
  [builder] CONT
  ```

  #### `A0` ADD

  <br />

  **Category:** Arithm Basic (arithm\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  ADD
  ```

  #### `A1` SUB

  <br />

  **Category:** Arithm Basic (arithm\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SUB
  ```

  #### `A2` SUBR

  Equivalent to `SWAP` `SUB`.<br />
  **Category:** Arithm Basic (arithm\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SUBR
  ```

  #### `A3` NEGATE

  Equivalent to `-1 MULCONST` or to `ZERO SUBR`.<br />Notice that it triggers an integer overflow exception if `x=-2^256`.<br />
  **Category:** Arithm Basic (arithm\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  NEGATE
  ```

  #### `A4` INC

  Equivalent to `1 ADDCONST`.<br />
  **Category:** Arithm Basic (arithm\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  INC
  ```

  #### `A5` DEC

  Equivalent to `-1 ADDCONST`.<br />
  **Category:** Arithm Basic (arithm\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DEC
  ```

  #### `A6cc` ADDCONST

  `-128 <= cc <= 127`.<br />
  **Category:** Arithm Basic (arithm\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc] ADDCONST
  [cc] ADDINT
  [-cc] SUBCONST
  [-cc] SUBINT
  ```

  #### `A7cc` MULCONST

  `-128 <= cc <= 127`.<br />
  **Category:** Arithm Basic (arithm\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc] MULCONST
  [cc] MULINT
  ```

  #### `A8` MUL

  <br />

  **Category:** Arithm Basic (arithm\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MUL
  ```

  #### `A900` ADDDIVMOD

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  ADDDIVMOD
  ```

  #### `A901` ADDDIVMODR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  ADDDIVMODR
  ```

  #### `A902` ADDDIVMODC

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  ADDDIVMODC
  ```

  #### `A904` DIV

  `q=floor(x/y)`, `r=x-y*q`<br />
  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DIV
  ```

  #### `A905` DIVR

  `q'=round(x/y)`, `r'=x-y*q'`<br />
  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DIVR
  ```

  #### `A906` DIVC

  `q''=ceil(x/y)`, `r''=x-y*q''`<br />
  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DIVC
  ```

  #### `A908` MOD

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MOD
  ```

  #### `A909` MODR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MODR
  ```

  #### `A90A` MODC

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MODC
  ```

  #### `A90C` DIVMOD

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DIVMOD
  ```

  #### `A90D` DIVMODR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DIVMODR
  ```

  #### `A90E` DIVMODC

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DIVMODC
  ```

  #### `A920` ADDRSHIFTMOD\_VAR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  ADDRSHIFTMOD
  ```

  #### `A921` ADDRSHIFTMODR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  ADDRSHIFTMODR
  ```

  #### `A922` ADDRSHIFTMODC

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  ADDRSHIFTMODC
  ```

  #### `A925` RSHIFTR\_VAR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  RSHIFTR
  ```

  #### `A926` RSHIFTC\_VAR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  RSHIFTC
  ```

  #### `A928` MODPOW2\_VAR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MODPOW2
  ```

  #### `A929` MODPOW2R\_VAR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MODPOW2R
  ```

  #### `A92A` MODPOW2C\_VAR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MODPOW2C
  ```

  #### `A92C` RSHIFTMOD\_VAR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  RSHIFTMOD
  ```

  #### `A92D` RSHIFTMODR\_VAR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  RSHIFTMODR
  ```

  #### `A92E` RSHIFTMODC\_VAR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  RSHIFTMODC
  ```

  #### `A930tt` ADDRSHIFTMOD

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] ADDRSHIFT#MOD
  ```

  #### `A931tt` ADDRSHIFTRMOD

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] ADDRSHIFTR#MOD
  ```

  #### `A932tt` ADDRSHIFTCMOD

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] ADDRSHIFTC#MOD
  ```

  #### `A935tt` RSHIFTR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] RSHIFTR#
  ```

  #### `A936tt` RSHIFTC

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] RSHIFTC#
  ```

  #### `A938tt` MODPOW2

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] MODPOW2#
  ```

  #### `A939tt` MODPOW2R

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] MODPOW2R#
  ```

  #### `A93Att` MODPOW2C

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] MODPOW2C#
  ```

  #### `A93Ctt` RSHIFTMOD

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] RSHIFT#MOD
  ```

  #### `A93Dtt` RSHIFTRMOD

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] RSHIFTR#MOD
  ```

  #### `A93Ett` RSHIFTCMOD

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] RSHIFTC#MOD
  ```

  #### `A980` MULADDDIVMOD

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MULADDDIVMOD
  ```

  #### `A981` MULADDDIVMODR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MULADDDIVMODR
  ```

  #### `A982` MULADDDIVMODC

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MULADDDIVMODC
  ```

  #### `A984` MULDIV

  `q=floor(x*y/z)`<br />
  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MULDIV
  ```

  #### `A985` MULDIVR

  `q'=round(x*y/z)`<br />
  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MULDIVR
  ```

  #### `A986` MULDIVC

  `q'=ceil(x*y/z)`<br />
  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MULDIVC
  ```

  #### `A988` MULMOD

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MULMOD
  ```

  #### `A989` MULMODR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MULMODR
  ```

  #### `A98A` MULMODC

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MULMODC
  ```

  #### `A98C` MULDIVMOD

  `q=floor(x*y/z)`, `r=x*y-z*q`<br />
  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MULDIVMOD
  ```

  #### `A98D` MULDIVMODR

  `q=round(x*y/z)`, `r=x*y-z*q`<br />
  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MULDIVMODR
  ```

  #### `A98E` MULDIVMODC

  `q=ceil(x*y/z)`, `r=x*y-z*q`<br />
  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MULDIVMODC
  ```

  #### `A9A0` MULADDRSHIFTMOD\_VAR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MULADDRSHIFTMOD
  ```

  #### `A9A1` MULADDRSHIFTRMOD\_VAR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MULADDRSHIFTRMOD
  ```

  #### `A9A2` MULADDRSHIFTCMOD\_VAR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MULADDRSHIFTCMOD
  ```

  #### `A9A4` MULRSHIFT\_VAR

  `0 <= z <= 256`<br />
  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MULRSHIFT
  ```

  #### `A9A5` MULRSHIFTR\_VAR

  `0 <= z <= 256`<br />
  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MULRSHIFTR
  ```

  #### `A9A6` MULRSHIFTC\_VAR

  `0 <= z <= 256`<br />
  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MULRSHIFTC
  ```

  #### `A9A8` MULMODPOW2\_VAR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MULMODPOW2_VAR
  ```

  #### `A9A9` MULMODPOW2R\_VAR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MULMODPOW2R_VAR
  ```

  #### `A9AA` MULMODPOW2C\_VAR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MULMODPOW2C_VAR
  ```

  #### `A9AC` MULRSHIFTMOD\_VAR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MULRSHIFTMOD_VAR
  ```

  #### `A9AD` MULRSHIFTRMOD\_VAR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MULRSHIFTRMOD_VAR
  ```

  #### `A9AE` MULRSHIFTCMOD\_VAR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MULRSHIFTCMOD_VAR
  ```

  #### `A9B0tt` MULADDRSHIFTMOD

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] MULADDRSHIFT#MOD
  ```

  #### `A9B1tt` MULADDRSHIFTRMOD

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] MULADDRSHIFTR#MOD
  ```

  #### `A9B2tt` MULADDRSHIFTCMOD

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] MULADDRSHIFTC#MOD
  ```

  #### `A9B4tt` MULRSHIFT

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] MULRSHIFT#
  ```

  #### `A9B5tt` MULRSHIFTR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] MULRSHIFTR#
  ```

  #### `A9B6tt` MULRSHIFTC

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] MULRSHIFTC#
  ```

  #### `A9B8tt` MULMODPOW2

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] MULMODPOW2#
  ```

  #### `A9B9tt` MULMODPOW2R

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] MULMODPOW2R#
  ```

  #### `A9BAtt` MULMODPOW2C

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] MULMODPOW2C#
  ```

  #### `A9BC` MULRSHIFTMOD

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MULRSHIFT#MOD
  ```

  #### `A9BD` MULRSHIFTRMOD

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MULRSHIFTR#MOD
  ```

  #### `A9BE` MULRSHIFTCMOD

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MULRSHIFTC#MOD
  ```

  #### `A9C0` LSHIFTADDDIVMOD\_VAR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LSHIFTADDDIVMOD
  ```

  #### `A9C1` LSHIFTADDDIVMODR\_VAR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LSHIFTADDDIVMODR
  ```

  #### `A9C2` LSHIFTADDDIVMODC\_VAR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LSHIFTADDDIVMODC
  ```

  #### `A9C4` LSHIFTDIV\_VAR

  `0 <= z <= 256`<br />
  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LSHIFTDIV
  ```

  #### `A9C5` LSHIFTDIVR\_VAR

  `0 <= z <= 256`<br />
  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LSHIFTDIVR
  ```

  #### `A9C6` LSHIFTDIVC\_VAR

  `0 <= z <= 256`<br />
  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LSHIFTDIVC
  ```

  #### `A9C8` LSHIFTMOD\_VAR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LSHIFTMOD
  ```

  #### `A9C9` LSHIFTMODR\_VAR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LSHIFTMODR
  ```

  #### `A9CA` LSHIFTMODC\_VAR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LSHIFTMODC
  ```

  #### `A9CC` LSHIFTDIVMOD\_VAR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LSHIFTDIVMOD
  ```

  #### `A9CD` LSHIFTDIVMODR\_VAR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LSHIFTDIVMODR
  ```

  #### `A9CE` LSHIFTDIVMODC\_VAR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LSHIFTDIVMODC
  ```

  #### `A9D0tt` LSHIFTADDDIVMOD

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] LSHIFT#ADDDIVMOD
  ```

  #### `A9D1tt` LSHIFTADDDIVMODR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] LSHIFT#ADDDIVMODR
  ```

  #### `A9D2tt` LSHIFTADDDIVMODC

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] LSHIFT#ADDDIVMODC
  ```

  #### `A9D4tt` LSHIFTDIV

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] LSHIFT#DIV
  ```

  #### `A9D5tt` LSHIFTDIVR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] LSHIFT#DIVR
  ```

  #### `A9D6tt` LSHIFTDIVC

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] LSHIFT#DIVC
  ```

  #### `A9D8tt` LSHIFTMOD

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] LSHIFT#MOD
  ```

  #### `A9D9tt` LSHIFTMODR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] LSHIFT#MODR
  ```

  #### `A9DAtt` LSHIFTMODC

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] LSHIFT#MODC
  ```

  #### `A9DCtt` LSHIFTDIVMOD

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] LSHIFT#DIVMOD
  ```

  #### `A9DDtt` LSHIFTDIVMODR

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] LSHIFT#DIVMODR
  ```

  #### `A9DEtt` LSHIFTDIVMODC

  <br />

  **Category:** Arithm Div (arithm\_div)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] LSHIFT#DIVMODC
  ```

  #### `AAcc` LSHIFT

  `0 <= cc <= 255`<br />
  **Category:** Arithm Logical (arithm\_logical)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] LSHIFT#
  ```

  #### `ABcc` RSHIFT

  `0 <= cc <= 255`<br />
  **Category:** Arithm Logical (arithm\_logical)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] RSHIFT#
  ```

  #### `AC` LSHIFT\_VAR

  `0 <= y <= 1023`<br />
  **Category:** Arithm Logical (arithm\_logical)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LSHIFT
  ```

  #### `AD` RSHIFT\_VAR

  `0 <= y <= 1023`<br />
  **Category:** Arithm Logical (arithm\_logical)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  RSHIFT
  ```

  #### `AE` POW2

  `0 <= y <= 1023`<br />Equivalent to `ONE` `SWAP` `LSHIFT`.<br />
  **Category:** Arithm Logical (arithm\_logical)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  POW2
  ```

  #### `B0` AND

  Bitwise and of two signed integers `x` and `y`, sign-extended to infinity.<br />
  **Category:** Arithm Logical (arithm\_logical)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  AND
  ```

  #### `B1` OR

  Bitwise or of two integers.<br />
  **Category:** Arithm Logical (arithm\_logical)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  OR
  ```

  #### `B2` XOR

  Bitwise xor of two integers.<br />
  **Category:** Arithm Logical (arithm\_logical)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  XOR
  ```

  #### `B3` NOT

  Bitwise not of an integer.<br />
  **Category:** Arithm Logical (arithm\_logical)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  NOT
  ```

  #### `B4cc` FITS

  Checks whether `x` is a `cc+1`-bit signed integer for `0 <= cc <= 255` (i.e., whether `-2^cc <= x < 2^cc`).<br />If not, either triggers an integer overflow exception, or replaces `x` with a `NaN` (quiet version).<br />
  **Category:** Arithm Logical (arithm\_logical)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] FITS
  ```

  **Aliases**:

  * `CHKBOOL`<br />
    Checks whether `x` is a ''boolean value'' (i.e., either 0 or -1).

  #### `B5cc` UFITS

  Checks whether `x` is a `cc+1`-bit unsigned integer for `0 <= cc <= 255` (i.e., whether `0 <= x < 2^(cc+1)`).<br />
  **Category:** Arithm Logical (arithm\_logical)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] UFITS
  ```

  **Aliases**:

  * `CHKBIT`<br />
    Checks whether `x` is a binary digit (i.e., zero or one).

  #### `B600` FITSX

  Checks whether `x` is a `c`-bit signed integer for `0 <= c <= 1023`.<br />
  **Category:** Arithm Logical (arithm\_logical)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  FITSX
  ```

  #### `B601` UFITSX

  Checks whether `x` is a `c`-bit unsigned integer for `0 <= c <= 1023`.<br />
  **Category:** Arithm Logical (arithm\_logical)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  UFITSX
  ```

  #### `B602` BITSIZE

  Computes smallest `c >= 0` such that `x` fits into a `c`-bit signed integer (`-2^(c-1) <= c < 2^(c-1)`).<br />
  **Category:** Arithm Logical (arithm\_logical)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BITSIZE
  ```

  #### `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.<br />
  **Category:** Arithm Logical (arithm\_logical)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  UBITSIZE
  ```

  #### `B608` MIN

  Computes the minimum of two integers `x` and `y`.<br />
  **Category:** Arithm Logical (arithm\_logical)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MIN
  ```

  #### `B609` MAX

  Computes the maximum of two integers `x` and `y`.<br />
  **Category:** Arithm Logical (arithm\_logical)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MAX
  ```

  #### `B60A` MINMAX

  Sorts two integers. Quiet version of this operation returns two `NaN`s if any of the arguments are `NaN`s.<br />
  **Category:** Arithm Logical (arithm\_logical)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  MINMAX
  INTSORT2
  ```

  #### `B60B` ABS

  Computes the absolute value of an integer `x`.<br />
  **Category:** Arithm Logical (arithm\_logical)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  ABS
  ```

  #### `B7A0` QADD

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QADD
  ```

  #### `B7A1` QSUB

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QSUB
  ```

  #### `B7A2` QSUBR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QSUBR
  ```

  #### `B7A3` QNEGATE

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QNEGATE
  ```

  #### `B7A4` QINC

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QINC
  ```

  #### `B7A5` QDEC

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QDEC
  ```

  #### `B7A8` QMUL

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMUL
  ```

  #### `B7A900` QADDDIVMOD

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QADDDIVMOD
  ```

  #### `B7A901` QADDDIVMODR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QADDDIVMODR
  ```

  #### `B7A902` QADDDIVMODC

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QADDDIVMODC
  ```

  #### `B7A904` QDIV

  Division returns `NaN` if `y=0`.<br />
  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QDIV
  ```

  #### `B7A905` QDIVR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QDIVR
  ```

  #### `B7A906` QDIVC

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QDIVC
  ```

  #### `B7A908` QMOD

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMOD
  ```

  #### `B7A909` QMODR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMODR
  ```

  #### `B7A90A` QMODC

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMODC
  ```

  #### `B7A90C` QDIVMOD

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QDIVMOD
  ```

  #### `B7A90D` QDIVMODR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QDIVMODR
  ```

  #### `B7A90E` QDIVMODC

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QDIVMODC
  ```

  #### `B7A920` QADDRSHIFTMOD

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QADDRSHIFTMOD
  ```

  #### `B7A921` QADDRSHIFTMODR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QADDRSHIFTMODR
  ```

  #### `B7A922` QADDRSHIFTMODC

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QADDRSHIFTMODC
  ```

  #### `B7A925` QRSHIFTR\_VAR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QRSHIFTR
  ```

  #### `B7A926` QRSHIFTC\_VAR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QRSHIFTC
  ```

  #### `B7A928` QMODPOW2\_VAR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMODPOW2
  ```

  #### `B7A929` QMODPOW2R\_VAR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMODPOW2R
  ```

  #### `B7A92A` QMODPOW2C\_VAR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMODPOW2C
  ```

  #### `B7A92C` QRSHIFTMOD\_VAR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QRSHIFTMOD
  ```

  #### `B7A92D` QRSHIFTMODR\_VAR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QRSHIFTMODR
  ```

  #### `B7A92E` QRSHIFTMODC\_VAR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QRSHIFTMODC
  ```

  #### `B7A930tt` QADDRSHIFTMOD

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QADDRSHIFT#MOD
  ```

  #### `B7A931tt` QADDRSHIFTRMOD

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QADDRSHIFTR#MOD
  ```

  #### `B7A932tt` QADDRSHIFTCMOD

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QADDRSHIFTC#MOD
  ```

  #### `B7A935tt` QRSHIFTR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QRSHIFTR#
  ```

  #### `B7A936tt` QRSHIFTC

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QRSHIFTC#
  ```

  #### `B7A938tt` QMODPOW2

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QMODPOW2#
  ```

  #### `B7A939tt` QMODPOW2R

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QMODPOW2R#
  ```

  #### `B7A93Att` QMODPOW2C

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QMODPOW2C#
  ```

  #### `B7A93Ctt` QRSHIFTMOD

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QRSHIFT#MOD
  ```

  #### `B7A93Dtt` QRSHIFTRMOD

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QRSHIFTR#MOD
  ```

  #### `B7A93Ett` QRSHIFTCMOD

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QRSHIFTC#MOD
  ```

  #### `B7A980` QMULADDDIVMOD

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMULADDDIVMOD
  ```

  #### `B7A981` QMULADDDIVMODR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMULADDDIVMODR
  ```

  #### `B7A982` QMULADDDIVMODC

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMULADDDIVMODC
  ```

  #### `B7A984` QMULDIV

  `q=floor(x*y/z)`<br />
  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMULDIV
  ```

  #### `B7A985` QMULDIVR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMULDIVR
  ```

  #### `B7A986` QMULDIVC

  `q'=ceil(x*y/z)`<br />
  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMULDIVC
  ```

  #### `B7A988` QMULMOD

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMULMOD
  ```

  #### `B7A989` QMULMODR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMULMODR
  ```

  #### `B7A98A` QMULMODC

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMULMODC
  ```

  #### `B7A98C` QMULDIVMOD

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMULDIVMOD
  ```

  #### `B7A98D` QMULDIVMODR

  `q=round(x*y/z)`, `r=x*y-z*q`<br />
  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMULDIVMODR
  ```

  #### `B7A98E` QMULDIVMODC

  `q=ceil(x*y/z)`, `r=x*y-z*q`<br />
  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMULDIVMODC
  ```

  #### `B7A9A0` QMULADDRSHIFTMOD\_VAR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMULADDRSHIFTMOD
  ```

  #### `B7A9A1` QMULADDRSHIFTRMOD\_VAR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMULADDRSHIFTRMOD
  ```

  #### `B7A9A2` QMULADDRSHIFTCMOD\_VAR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMULADDRSHIFTCMOD
  ```

  #### `B7A9A4` QMULRSHIFT\_VAR

  `0 <= z <= 256`<br />
  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMULRSHIFT
  ```

  #### `B7A9A5` QMULRSHIFTR\_VAR

  `0 <= z <= 256`<br />
  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMULRSHIFTR
  ```

  #### `B7A9A6` QMULRSHIFTC\_VAR

  `0 <= z <= 256`<br />
  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMULRSHIFTC
  ```

  #### `B7A9A8` QMULMODPOW2\_VAR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMULMODPOW2_VAR
  ```

  #### `B7A9A9` QMULMODPOW2R\_VAR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMULMODPOW2R_VAR
  ```

  #### `B7A9AA` QMULMODPOW2C\_VAR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMULMODPOW2C_VAR
  ```

  #### `B7A9AC` QMULRSHIFTMOD\_VAR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMULRSHIFTMOD_VAR
  ```

  #### `B7A9AD` QMULRSHIFTRMOD\_VAR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMULRSHIFTRMOD_VAR
  ```

  #### `B7A9AE` QMULRSHIFTCMOD\_VAR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMULRSHIFTCMOD_VAR
  ```

  #### `B7A9B0tt` QMULADDRSHIFTMOD

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QMULADDRSHIFT#MOD
  ```

  #### `B7A9B1tt` QMULADDRSHIFTRMOD

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QMULADDRSHIFTR#MOD
  ```

  #### `B7A9B2tt` QMULADDRSHIFTCMOD

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QMULADDRSHIFTC#MOD
  ```

  #### `B7A9B4tt` QMULRSHIFT

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QMULRSHIFT#
  ```

  #### `B7A9B5tt` QMULRSHIFTR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QMULRSHIFTR#
  ```

  #### `B7A9B6tt` QMULRSHIFTC

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QMULRSHIFTC#
  ```

  #### `B7A9B8tt` QMULMODPOW2

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QMULMODPOW2#
  ```

  #### `B7A9B9tt` QMULMODPOW2R

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QMULMODPOW2R#
  ```

  #### `B7A9BAtt` QMULMODPOW2C

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QMULMODPOW2C#
  ```

  #### `B7A9BC` QMULRSHIFTMOD

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMULRSHIFT#MOD
  ```

  #### `B7A9BD` QMULRSHIFTRMOD

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMULRSHIFTR#MOD
  ```

  #### `B7A9BE` QMULRSHIFTCMOD

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QMULRSHIFTC#MOD
  ```

  #### `B7A9C0` QLSHIFTADDDIVMOD\_VAR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QLSHIFTADDDIVMOD
  ```

  #### `B7A9C1` QLSHIFTADDDIVMODR\_VAR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QLSHIFTADDDIVMODR
  ```

  #### `B7A9C2` QLSHIFTADDDIVMODC\_VAR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QLSHIFTADDDIVMODC
  ```

  #### `B7A9C4` QLSHIFTDIV\_VAR

  `0 <= z <= 256`<br />
  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QLSHIFTDIV
  ```

  #### `B7A9C5` QLSHIFTDIVR\_VAR

  `0 <= z <= 256`<br />
  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QLSHIFTDIVR
  ```

  #### `B7A9C6` QLSHIFTDIVC\_VAR

  `0 <= z <= 256`<br />
  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QLSHIFTDIVC
  ```

  #### `B7A9C8` QLSHIFTMOD\_VAR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QLSHIFTMOD
  ```

  #### `B7A9C9` QLSHIFTMODR\_VAR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QLSHIFTMODR
  ```

  #### `B7A9CA` QLSHIFTMODC\_VAR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QLSHIFTMODC
  ```

  #### `B7A9CC` QLSHIFTDIVMOD\_VAR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QLSHIFTDIVMOD
  ```

  #### `B7A9CD` QLSHIFTDIVMODR\_VAR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QLSHIFTDIVMODR
  ```

  #### `B7A9CE` QLSHIFTDIVMODC\_VAR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QLSHIFTDIVMODC
  ```

  #### `B7A9D0tt` QLSHIFTADDDIVMOD

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QLSHIFT#ADDDIVMOD
  ```

  #### `B7A9D1tt` QLSHIFTADDDIVMODR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QLSHIFT#ADDDIVMODR
  ```

  #### `B7A9D2tt` QLSHIFTADDDIVMODC

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QLSHIFT#ADDDIVMODC
  ```

  #### `B7A9D4tt` QLSHIFTDIV

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QLSHIFT#DIV
  ```

  #### `B7A9D5tt` QLSHIFTDIVR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QLSHIFT#DIVR
  ```

  #### `B7A9D6tt` QLSHIFTDIVC

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QLSHIFT#DIVC
  ```

  #### `B7A9D8tt` QLSHIFTMOD

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QLSHIFT#MOD
  ```

  #### `B7A9D9tt` QLSHIFTMODR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QLSHIFT#MODR
  ```

  #### `B7A9DAtt` QLSHIFTMODC

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QLSHIFT#MODC
  ```

  #### `B7A9DCtt` QLSHIFTDIVMOD

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QLSHIFT#DIVMOD
  ```

  #### `B7A9DDtt` QLSHIFTDIVMODR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QLSHIFT#DIVMODR
  ```

  #### `B7A9DEtt` QLSHIFTDIVMODC

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [tt+1] QLSHIFT#DIVMODC
  ```

  #### `B7AAcc` QLSHIFT

  `0 <= cc <= 255`<br />
  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] QLSHIFT#
  ```

  #### `B7ABcc` QRSHIFT

  `0 <= cc <= 255`<br />
  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] QRSHIFT#
  ```

  #### `B7AC` QLSHIFT\_VAR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QLSHIFT
  ```

  #### `B7AD` QRSHIFT\_VAR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QRSHIFT
  ```

  #### `B7AE` QPOW2

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QPOW2
  ```

  #### `B7B0` QAND

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QAND
  ```

  #### `B7B1` QOR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QOR
  ```

  #### `B7B2` QXOR

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QXOR
  ```

  #### `B7B3` QNOT

  <br />

  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QNOT
  ```

  #### `B7B4cc` QFITS

  Replaces `x` with a `NaN` if x is not a `cc+1`-bit signed integer, leaves it intact otherwise.<br />
  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] QFITS
  ```

  #### `B7B5cc` QUFITS

  Replaces `x` with a `NaN` if x is not a `cc+1`-bit unsigned integer, leaves it intact otherwise.<br />
  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] QUFITS
  ```

  #### `B7B600` QFITSX

  Replaces `x` with a `NaN` if x is not a c-bit signed integer, leaves it intact otherwise.<br />
  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QFITSX
  ```

  #### `B7B601` QUFITSX

  Replaces `x` with a `NaN` if x is not a c-bit unsigned integer, leaves it intact otherwise.<br />
  **Category:** Arithm Quiet (arithm\_quiet)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  QUFITSX
  ```

  #### `B8` SGN

  Computes the sign of an integer `x`:<br />`-1` if `x<0`, `0` if `x=0`, `1` if `x>0`.<br />
  **Category:** Compare Int (compare\_int)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SGN
  ```

  #### `B9` LESS

  Returns `-1` if `x<y`, `0` otherwise.<br />
  **Category:** Compare Int (compare\_int)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LESS
  ```

  #### `BA` EQUAL

  Returns `-1` if `x=y`, `0` otherwise.<br />
  **Category:** Compare Int (compare\_int)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  EQUAL
  ```

  #### `BB` LEQ

  <br />

  **Category:** Compare Int (compare\_int)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LEQ
  ```

  #### `BC` GREATER

  <br />

  **Category:** Compare Int (compare\_int)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  GREATER
  ```

  #### `BD` NEQ

  Equivalent to `EQUAL` `NOT`.<br />
  **Category:** Compare Int (compare\_int)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  NEQ
  ```

  #### `BE` GEQ

  Equivalent to `LESS` `NOT`.<br />
  **Category:** Compare Int (compare\_int)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  GEQ
  ```

  #### `BF` CMP

  Computes the sign of `x-y`:<br />`-1` if `x<y`, `0` if `x=y`, `1` if `x>y`.<br />No integer overflow can occur here unless `x` or `y` is a `NaN`.<br />
  **Category:** Compare Int (compare\_int)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  CMP
  ```

  #### `C0yy` EQINT

  Returns `-1` if `x=yy`, `0` otherwise.<br />`-2^7 <= yy < 2^7`.<br />
  **Category:** Compare Int (compare\_int)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [yy] EQINT
  ```

  **Aliases**:

  * `ISZERO`<br />
    Checks whether an integer is zero. Corresponds to Forth's `0=`.

  #### `C1yy` LESSINT

  Returns `-1` if `x<yy`, `0` otherwise.<br />`-2^7 <= yy < 2^7`.<br />
  **Category:** Compare Int (compare\_int)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [yy] LESSINT
  [yy-1] LEQINT
  ```

  **Aliases**:

  * `ISNEG`<br />
    Checks whether an integer is negative. Corresponds to Forth's `0<`.
  * `ISNPOS`<br />
    Checks whether an integer is non-positive.

  #### `C2yy` GTINT

  Returns `-1` if `x>yy`, `0` otherwise.<br />`-2^7 <= yy < 2^7`.<br />
  **Category:** Compare Int (compare\_int)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [yy] GTINT
  [yy+1] GEQINT
  ```

  **Aliases**:

  * `ISPOS`<br />
    Checks whether an integer is positive. Corresponds to Forth's `0>`.
  * `ISNNEG`<br />
    Checks whether an integer is non-negative.

  #### `C3yy` NEQINT

  Returns `-1` if `x!=yy`, `0` otherwise.<br />`-2^7 <= yy < 2^7`.<br />
  **Category:** Compare Int (compare\_int)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [yy] NEQINT
  ```

  #### `C4` ISNAN

  Checks whether `x` is a `NaN`.<br />
  **Category:** Compare Int (compare\_int)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  ISNAN
  ```

  #### `C5` CHKNAN

  Throws an arithmetic overflow exception if `x` is a `NaN`.<br />
  **Category:** Compare Int (compare\_int)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  CHKNAN
  ```

  #### `C700` SEMPTY

  Checks whether a *Slice* `s` is empty (i.e., contains no bits of data and no cell references).<br />
  **Category:** Compare Other (compare\_other)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SEMPTY
  ```

  #### `C701` SDEMPTY

  Checks whether *Slice* `s` has no bits of data.<br />
  **Category:** Compare Other (compare\_other)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SDEMPTY
  ```

  #### `C702` SREMPTY

  Checks whether *Slice* `s` has no references.<br />
  **Category:** Compare Other (compare\_other)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SREMPTY
  ```

  #### `C703` SDFIRST

  Checks whether the first bit of *Slice* `s` is a one.<br />
  **Category:** Compare Other (compare\_other)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SDFIRST
  ```

  #### `C704` SDLEXCMP

  Compares the data of `s` lexicographically with the data of `s'`, returning `-1`, 0, or 1 depending on the result.<br />
  **Category:** Compare Other (compare\_other)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SDLEXCMP
  ```

  #### `C705` SDEQ

  Checks whether the data parts of `s` and `s'` coincide, equivalent to `SDLEXCMP` `ISZERO`.<br />
  **Category:** Compare Other (compare\_other)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SDEQ
  ```

  #### `C708` SDPFX

  Checks whether `s` is a prefix of `s'`.<br />
  **Category:** Compare Other (compare\_other)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SDPFX
  ```

  #### `C709` SDPFXREV

  Checks whether `s'` is a prefix of `s`, equivalent to `SWAP` `SDPFX`.<br />
  **Category:** Compare Other (compare\_other)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SDPFXREV
  ```

  #### `C70A` SDPPFX

  Checks whether `s` is a proper prefix of `s'` (i.e., a prefix distinct from `s'`).<br />
  **Category:** Compare Other (compare\_other)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SDPPFX
  ```

  #### `C70B` SDPPFXREV

  Checks whether `s'` is a proper prefix of `s`.<br />
  **Category:** Compare Other (compare\_other)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SDPPFXREV
  ```

  #### `C70C` SDSFX

  Checks whether `s` is a suffix of `s'`.<br />
  **Category:** Compare Other (compare\_other)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SDSFX
  ```

  #### `C70D` SDSFXREV

  Checks whether `s'` is a suffix of `s`.<br />
  **Category:** Compare Other (compare\_other)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SDSFXREV
  ```

  #### `C70E` SDPSFX

  Checks whether `s` is a proper suffix of `s'`.<br />
  **Category:** Compare Other (compare\_other)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SDPSFX
  ```

  #### `C70F` SDPSFXREV

  Checks whether `s'` is a proper suffix of `s`.<br />
  **Category:** Compare Other (compare\_other)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SDPSFXREV
  ```

  #### `C710` SDCNTLEAD0

  Returns the number of leading zeroes in `s`.<br />
  **Category:** Compare Other (compare\_other)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SDCNTLEAD0
  ```

  #### `C711` SDCNTLEAD1

  Returns the number of leading ones in `s`.<br />
  **Category:** Compare Other (compare\_other)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SDCNTLEAD1
  ```

  #### `C712` SDCNTTRAIL0

  Returns the number of trailing zeroes in `s`.<br />
  **Category:** Compare Other (compare\_other)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SDCNTTRAIL0
  ```

  #### `C713` SDCNTTRAIL1

  Returns the number of trailing ones in `s`.<br />
  **Category:** Compare Other (compare\_other)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SDCNTTRAIL1
  ```

  #### `C8` NEWC

  Creates a new empty *Builder*.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  NEWC
  ```

  #### `C9` ENDC

  Converts a *Builder* into an ordinary *Cell*.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  ENDC
  ```

  #### `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.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] STI
  ```

  #### `CBcc` STU

  Stores an unsigned `cc+1`-bit integer `x` into *Builder* `b`. In all other respects it is similar to `STI`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] STU
  ```

  #### `CC` STREF

  Stores a reference to *Cell* `c` into *Builder* `b`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STREF
  ```

  #### `CD` STBREFR

  Equivalent to `ENDC` `SWAP` `STREF`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STBREFR
  ENDCST
  ```

  #### `CE` STSLICE

  Stores *Slice* `s` into *Builder* `b`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STSLICE
  ```

  **Aliases**:

  * `STDICTS`<br />
    Stores a *Slice*-represented dictionary `s` into *Builder* `b`.<br />It is actually a synonym for `STSLICE`.

  #### `CF00` STIX

  Stores a signed `l`-bit integer `x` into `b` for `0 <= l <= 257`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STIX
  ```

  #### `CF01` STUX

  Stores an unsigned `l`-bit integer `x` into `b` for `0 <= l <= 256`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STUX
  ```

  #### `CF02` STIXR

  Similar to `STIX`, but with arguments in a different order.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STIXR
  ```

  #### `CF03` STUXR

  Similar to `STUX`, but with arguments in a different order.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STUXR
  ```

  #### `CF04` STIXQ

  A quiet version of `STIX`. If there is no space in `b`, sets `b'=b` and `f=-1`.<br />If `x` does not fit into `l` bits, sets `b'=b` and `f=1`.<br />If the operation succeeds, `b'` is the new *Builder* and `f=0`.<br />However, `0 <= l <= 257`, with a range check exception if this is not so.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STIXQ
  ```

  #### `CF05` STUXQ

  A quiet version of `STUX`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STUXQ
  ```

  #### `CF06` STIXRQ

  A quiet version of `STIXR`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STIXRQ
  ```

  #### `CF07` STUXRQ

  A quiet version of `STUXR`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STUXRQ
  ```

  #### `CF08cc` STI\_ALT

  A longer version of `[cc+1] STI`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] STI_l
  ```

  #### `CF09cc` STU\_ALT

  A longer version of `[cc+1] STU`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] STU_l
  ```

  #### `CF0Acc` STIR

  Equivalent to `SWAP` `[cc+1] STI`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] STIR
  ```

  #### `CF0Bcc` STUR

  Equivalent to `SWAP` `[cc+1] STU`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] STUR
  ```

  #### `CF0Ccc` STIQ

  A quiet version of `STI`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] STIQ
  ```

  #### `CF0Dcc` STUQ

  A quiet version of `STU`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] STUQ
  ```

  #### `CF0Ecc` STIRQ

  A quiet version of `STIR`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] STIRQ
  ```

  #### `CF0Fcc` STURQ

  A quiet version of `STUR`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] STURQ
  ```

  #### `CF10` STREF\_ALT

  A longer version of `STREF`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STREF_l
  ```

  #### `CF11` STBREF

  Equivalent to `SWAP` `STBREFR`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STBREF
  ```

  #### `CF12` STSLICE\_ALT

  A longer version of `STSLICE`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STSLICE_l
  ```

  #### `CF13` STB

  Appends all data from *Builder* `b'` to *Builder* `b`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STB
  ```

  #### `CF14` STREFR

  Equivalent to `SWAP` `STREF`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STREFR
  ```

  #### `CF15` STBREFR\_ALT

  A longer encoding of `STBREFR`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STBREFR_l
  ```

  #### `CF16` STSLICER

  Equivalent to `SWAP` `STSLICE`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STSLICER
  ```

  #### `CF17` STBR

  Concatenates two builders.<br />Equivalent to `SWAP` `STB`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STBR
  BCONCAT
  ```

  #### `CF18` STREFQ

  Quiet version of `STREF`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STREFQ
  ```

  #### `CF19` STBREFQ

  Quiet version of `STBREF`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STBREFQ
  ```

  #### `CF1A` STSLICEQ

  Quiet version of `STSLICE`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STSLICEQ
  ```

  #### `CF1B` STBQ

  Quiet version of `STB`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STBQ
  ```

  #### `CF1C` STREFRQ

  Quiet version of `STREFR`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STREFRQ
  ```

  #### `CF1D` STBREFRQ

  Quiet version of `STBREFR`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STBREFRQ
  ```

  #### `CF1E` STSLICERQ

  Quiet version of `STSLICER`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STSLICERQ
  ```

  #### `CF1F` STBRQ

  Quiet version of `STBR`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STBRQ
  BCONCATQ
  ```

  #### `CF20` STREFCONST

  Equivalent to `PUSHREF` `STREFR`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [ref] STREFCONST
  ```

  #### `CF21` STREF2CONST

  Equivalent to `STREFCONST` `STREFCONST`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [ref] [ref] STREF2CONST
  ```

  #### `CF23` ENDXC

  If `x!=0`, creates a *special* or *exotic* cell from *Builder* `b`.<br />The type of the exotic cell must be stored in the first 8 bits of `b`.<br />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.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  ENDXC
  ```

  #### `CF28` STILE4

  Stores a little-endian signed 32-bit integer.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STILE4
  ```

  #### `CF29` STULE4

  Stores a little-endian unsigned 32-bit integer.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STULE4
  ```

  #### `CF2A` STILE8

  Stores a little-endian signed 64-bit integer.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STILE8
  ```

  #### `CF2B` STULE8

  Stores a little-endian unsigned 64-bit integer.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STULE8
  ```

  #### `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`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BDEPTH
  ```

  #### `CF31` BBITS

  Returns the number of data bits already stored in *Builder* `b`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BBITS
  ```

  #### `CF32` BREFS

  Returns the number of cell references already stored in `b`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BREFS
  ```

  #### `CF33` BBITREFS

  Returns the numbers of both data bits and cell references in `b`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BBITREFS
  ```

  #### `CF35` BREMBITS

  Returns the number of data bits that can still be stored in `b`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BREMBITS
  ```

  #### `CF36` BREMREFS

  Returns the number of references that can still be stored in `b`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BREMREFS
  ```

  #### `CF37` BREMBITREFS

  Returns the numbers of both data bits and references that can still be stored in `b`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BREMBITREFS
  ```

  #### `CF38cc` BCHKBITS

  Checks whether `cc+1` bits can be stored into `b`, where `0 <= cc <= 255`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] BCHKBITS#
  ```

  #### `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.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BCHKBITS
  ```

  #### `CF3A` BCHKREFS

  Checks whether `y` references can be stored into `b`, `0 <= y <= 7`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BCHKREFS
  ```

  #### `CF3B` BCHKBITREFS

  Checks whether `x` bits and `y` references can be stored into `b`, `0 <= x <= 1023`, `0 <= y <= 7`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BCHKBITREFS
  ```

  #### `CF3Ccc` BCHKBITSQ

  Checks whether `cc+1` bits can be stored into `b`, where `0 <= cc <= 255`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] BCHKBITSQ#
  ```

  #### `CF3D` BCHKBITSQ\_VAR

  Checks whether `x` bits can be stored into `b`, `0 <= x <= 1023`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BCHKBITSQ
  ```

  #### `CF3E` BCHKREFSQ

  Checks whether `y` references can be stored into `b`, `0 <= y <= 7`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BCHKREFSQ
  ```

  #### `CF3F` BCHKBITREFSQ

  Checks whether `x` bits and `y` references can be stored into `b`, `0 <= x <= 1023`, `0 <= y <= 7`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BCHKBITREFSQ
  ```

  #### `CF40` STZEROES

  Stores `n` binary zeroes into *Builder* `b`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STZEROES
  ```

  #### `CF41` STONES

  Stores `n` binary ones into *Builder* `b`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STONES
  ```

  #### `CF42` STSAME

  Stores `n` binary `x`es (`0 <= x <= 1`) into *Builder* `b`.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STSAME
  ```

  #### `CF50` BTOS

  Same as `ENDC CTOS`, but without gas cost for cell creation and loading.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BTOS
  ```

  #### `CFC_xysss` STSLICECONST

  Stores a constant subslice `sss`.<br />*Details:* `sss` consists of `0 <= x <= 3` references and up to `8y+2` data bits, with `0 <= y <= 7`. Completion bit is assumed.<br />Note that the assembler can replace `STSLICECONST` with `PUSHSLICE` `STSLICER` if the slice is too big.<br />
  **Category:** Cell Build (cell\_build)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [slice] STSLICECONST
  ```

  **Aliases**:

  * `STZERO`<br />
    Stores one binary zero.
  * `STONE`<br />
    Stores one binary one.

  #### `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.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  CTOS
  ```

  #### `D1` ENDS

  Removes a *Slice* `s` from the stack, and throws an exception if it is not empty.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  ENDS
  ```

  #### `D2cc` LDI

  Loads (i.e., parses) a signed `cc+1`-bit integer `x` from *Slice* `s`, and returns the remainder of `s` as `s'`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] LDI
  ```

  #### `D3cc` LDU

  Loads an unsigned `cc+1`-bit integer `x` from *Slice* `s`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] LDU
  ```

  #### `D4` LDREF

  Loads a cell reference `c` from `s`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDREF
  ```

  #### `D5` LDREFRTOS

  Equivalent to `LDREF` `SWAP` `CTOS`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDREFRTOS
  ```

  #### `D6cc` LDSLICE

  Cuts the next `cc+1` bits of `s` into a separate *Slice* `s''`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] LDSLICE
  ```

  #### `D700` LDIX

  Loads a signed `l`-bit (`0 <= l <= 257`) integer `x` from *Slice* `s`, and returns the remainder of `s` as `s'`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDIX
  ```

  #### `D701` LDUX

  Loads an unsigned `l`-bit integer `x` from (the first `l` bits of) `s`, with `0 <= l <= 256`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDUX
  ```

  #### `D702` PLDIX

  Preloads a signed `l`-bit integer from *Slice* `s`, for `0 <= l <= 257`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PLDIX
  ```

  #### `D703` PLDUX

  Preloads an unsigned `l`-bit integer from `s`, for `0 <= l <= 256`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PLDUX
  ```

  #### `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.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDIXQ
  ```

  #### `D705` LDUXQ

  Quiet version of `LDUX`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDUXQ
  ```

  #### `D706` PLDIXQ

  Quiet version of `PLDIX`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PLDIXQ
  ```

  #### `D707` PLDUXQ

  Quiet version of `PLDUX`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PLDUXQ
  ```

  #### `D708cc` LDI\_ALT

  A longer encoding for `LDI`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] LDI_l
  ```

  #### `D709cc` LDU\_ALT

  A longer encoding for `LDU`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] LDU_l
  ```

  #### `D70Acc` PLDI

  Preloads a signed `cc+1`-bit integer from *Slice* `s`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] PLDI
  ```

  #### `D70Bcc` PLDU

  Preloads an unsigned `cc+1`-bit integer from `s`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] PLDU
  ```

  #### `D70Ccc` LDIQ

  A quiet version of `LDI`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] LDIQ
  ```

  #### `D70Dcc` LDUQ

  A quiet version of `LDU`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] LDUQ
  ```

  #### `D70Ecc` PLDIQ

  A quiet version of `PLDI`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] PLDIQ
  ```

  #### `D70Fcc` PLDUQ

  A quiet version of `PLDU`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] PLDUQ
  ```

  #### `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.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [32(c+1)] PLDUZ
  ```

  #### `D718` LDSLICEX

  Loads the first `0 <= l <= 1023` bits from *Slice* `s` into a separate *Slice* `s''`, returning the remainder of `s` as `s'`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDSLICEX
  ```

  #### `D719` PLDSLICEX

  Returns the first `0 <= l <= 1023` bits of `s` as `s''`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PLDSLICEX
  ```

  #### `D71A` LDSLICEXQ

  A quiet version of `LDSLICEX`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDSLICEXQ
  ```

  #### `D71B` PLDSLICEXQ

  A quiet version of `LDSLICEXQ`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PLDSLICEXQ
  ```

  #### `D71Ccc` LDSLICE\_ALT

  A longer encoding for `LDSLICE`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] LDSLICE_l
  ```

  #### `D71Dcc` PLDSLICE

  Returns the first `0 < cc+1 <= 256` bits of `s` as `s''`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] PLDSLICE
  ```

  #### `D71Ecc` LDSLICEQ

  A quiet version of `LDSLICE`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] LDSLICEQ
  ```

  #### `D71Fcc` PLDSLICEQ

  A quiet version of `PLDSLICE`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [cc+1] PLDSLICEQ
  ```

  #### `D720` SDCUTFIRST

  Returns the first `0 <= l <= 1023` bits of `s`. It is equivalent to `PLDSLICEX`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SDCUTFIRST
  ```

  #### `D721` SDSKIPFIRST

  Returns all but the first `0 <= l <= 1023` bits of `s`. It is equivalent to `LDSLICEX` `NIP`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SDSKIPFIRST
  ```

  #### `D722` SDCUTLAST

  Returns the last `0 <= l <= 1023` bits of `s`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SDCUTLAST
  ```

  #### `D723` SDSKIPLAST

  Returns all but the last `0 <= l <= 1023` bits of `s`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SDSKIPLAST
  ```

  #### `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`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SDSUBSTR
  ```

  #### `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`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SDBEGINSX
  ```

  #### `D727` SDBEGINSXQ

  A quiet version of `SDBEGINSX`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SDBEGINSXQ
  ```

  #### `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.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [slice] SDBEGINS
  ```

  #### `D72E_xsss` SDBEGINSQ

  A quiet version of `SDBEGINS`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [slice] SDBEGINSQ
  ```

  #### `D730` SCUTFIRST

  Returns the first `0 <= l <= 1023` bits and first `0 <= r <= 4` references of `s`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SCUTFIRST
  ```

  #### `D731` SSKIPFIRST

  Returns all but the first `l` bits of `s` and `r` references of `s`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SSKIPFIRST
  ```

  #### `D732` SCUTLAST

  Returns the last `0 <= l <= 1023` data bits and last `0 <= r <= 4` references of `s`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SCUTLAST
  ```

  #### `D733` SSKIPLAST

  Returns all but the last `l` bits of `s` and `r` references of `s`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SSKIPLAST
  ```

  #### `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.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SUBSLICE
  ```

  #### `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''`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SPLIT
  ```

  #### `D737` SPLITQ

  A quiet version of `SPLIT`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SPLITQ
  ```

  #### `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`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  XCTOS
  ```

  #### `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.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  XLOAD
  ```

  #### `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.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  XLOADQ
  ```

  #### `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.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SCHKBITS
  ```

  #### `D742` SCHKREFS

  Checks whether there are at least `r` references in *Slice* `s`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SCHKREFS
  ```

  #### `D743` SCHKBITREFS

  Checks whether there are at least `l` data bits and `r` references in *Slice* `s`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SCHKBITREFS
  ```

  #### `D745` SCHKBITSQ

  Checks whether there are at least `l` data bits in *Slice* `s`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SCHKBITSQ
  ```

  #### `D746` SCHKREFSQ

  Checks whether there are at least `r` references in *Slice* `s`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SCHKREFSQ
  ```

  #### `D747` SCHKBITREFSQ

  Checks whether there are at least `l` data bits and `r` references in *Slice* `s`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SCHKBITREFSQ
  ```

  #### `D748` PLDREFVAR

  Returns the `n`-th cell reference of *Slice* `s` for `0 <= n <= 3`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PLDREFVAR
  ```

  #### `D749` SBITS

  Returns the number of data bits in *Slice* `s`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SBITS
  ```

  #### `D74A` SREFS

  Returns the number of references in *Slice* `s`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SREFS
  ```

  #### `D74B` SBITREFS

  Returns both the number of data bits and the number of references in `s`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SBITREFS
  ```

  #### `D74E_n` PLDREFIDX

  Returns the `n`-th cell reference of *Slice* `s`, where `0 <= n <= 3`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [n] PLDREFIDX
  ```

  **Aliases**:

  * `PLDREF`<br />
    Preloads the first cell reference of a *Slice*.

  #### `D750` LDILE4

  Loads a little-endian signed 32-bit integer.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDILE4
  ```

  #### `D751` LDULE4

  Loads a little-endian unsigned 32-bit integer.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDULE4
  ```

  #### `D752` LDILE8

  Loads a little-endian signed 64-bit integer.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDILE8
  ```

  #### `D753` LDULE8

  Loads a little-endian unsigned 64-bit integer.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDULE8
  ```

  #### `D754` PLDILE4

  Preloads a little-endian signed 32-bit integer.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PLDILE4
  ```

  #### `D755` PLDULE4

  Preloads a little-endian unsigned 32-bit integer.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PLDULE4
  ```

  #### `D756` PLDILE8

  Preloads a little-endian signed 64-bit integer.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PLDILE8
  ```

  #### `D757` PLDULE8

  Preloads a little-endian unsigned 64-bit integer.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PLDULE8
  ```

  #### `D758` LDILE4Q

  Quietly loads a little-endian signed 32-bit integer.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDILE4Q
  ```

  #### `D759` LDULE4Q

  Quietly loads a little-endian unsigned 32-bit integer.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDULE4Q
  ```

  #### `D75A` LDILE8Q

  Quietly loads a little-endian signed 64-bit integer.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDILE8Q
  ```

  #### `D75B` LDULE8Q

  Quietly loads a little-endian unsigned 64-bit integer.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDULE8Q
  ```

  #### `D75C` PLDILE4Q

  Quietly preloads a little-endian signed 32-bit integer.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PLDILE4Q
  ```

  #### `D75D` PLDULE4Q

  Quietly preloads a little-endian unsigned 32-bit integer.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PLDULE4Q
  ```

  #### `D75E` PLDILE8Q

  Quietly preloads a little-endian signed 64-bit integer.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PLDILE8Q
  ```

  #### `D75F` PLDULE8Q

  Quietly preloads a little-endian unsigned 64-bit integer.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PLDULE8Q
  ```

  #### `D760` LDZEROES

  Returns the count `n` of leading zero bits in `s`, and removes these bits from `s`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDZEROES
  ```

  #### `D761` LDONES

  Returns the count `n` of leading one bits in `s`, and removes these bits from `s`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDONES
  ```

  #### `D762` LDSAME

  Returns the count `n` of leading bits equal to `0 <= x <= 1` in `s`, and removes these bits from `s`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDSAME
  ```

  #### `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`.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SDEPTH
  ```

  #### `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.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  CDEPTH
  ```

  #### `D766` CLEVEL

  Returns level of the cell.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  CLEVEL
  ```

  #### `D767` CLEVELMASK

  Returns level mask of the cell.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  CLEVELMASK
  ```

  #### `D76A_` CHASHI

  Returns `i`th hash of the cell.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [i] CHASHI
  ```

  #### `D76E_` CDEPTHI

  Returns `i`th depth of the cell.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [i] CDEPTHI
  ```

  #### `D770` CHASHIX

  Returns `i`th hash of the cell.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  CHASHIX
  ```

  #### `D771` CDEPTHIX

  Returns `i`th depth of the cell.<br />
  **Category:** Cell Parse (cell\_parse)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  CDEPTHIX
  ```

  #### `D8` EXECUTE

  *Calls*, or *executes*, continuation `c`.<br />
  **Category:** Cont Basic (cont\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  EXECUTE
  CALLX
  ```

  #### `D9` JMPX

  *Jumps*, or transfers control, to continuation `c`.<br />The remainder of the previous current continuation `cc` is discarded.<br />
  **Category:** Cont Basic (cont\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  JMPX
  ```

  #### `DApr` CALLXARGS

  *Calls* continuation `c` with `p` parameters and expecting `r` return values<br />`0 <= p <= 15`, `0 <= r <= 15`<br />
  **Category:** Cont Basic (cont\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [p] [r] CALLXARGS
  ```

  #### `DB0p` CALLXARGS\_VAR

  *Calls* continuation `c` with `0 <= p <= 15` parameters, expecting an arbitrary number of return values.<br />
  **Category:** Cont Basic (cont\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [p] -1 CALLXARGS
  ```

  #### `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).<br />
  **Category:** Cont Basic (cont\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [p] JMPXARGS
  ```

  #### `DB2r` RETARGS

  *Returns* to `c0`, with `0 <= r <= 15` return values taken from the current stack.<br />
  **Category:** Cont Basic (cont\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [r] RETARGS
  ```

  #### `DB30` RET

  *Returns* to the continuation at `c0`. The remainder of the current continuation `cc` is discarded.<br />Approximately equivalent to `c0 PUSHCTR` `JMPX`.<br />
  **Category:** Cont Basic (cont\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  RET
  RETTRUE
  ```

  #### `DB31` RETALT

  *Returns* to the continuation at `c1`.<br />Approximately equivalent to `c1 PUSHCTR` `JMPX`.<br />
  **Category:** Cont Basic (cont\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  RETALT
  RETFALSE
  ```

  #### `DB32` BRANCH

  Performs `RETTRUE` if integer `f!=0`, or `RETFALSE` if `f=0`.<br />
  **Category:** Cont Basic (cont\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BRANCH
  RETBOOL
  ```

  #### `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`).<br />
  **Category:** Cont Basic (cont\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  CALLCC
  ```

  #### `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`.<br />
  **Category:** Cont Basic (cont\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  JMPXDATA
  ```

  #### `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`.<br />
  **Category:** Cont Basic (cont\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [p] [r] CALLCCARGS
  ```

  #### `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`.<br />
  **Category:** Cont Basic (cont\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  CALLXVARARGS
  ```

  #### `DB39` RETVARARGS

  Similar to `RETARGS`.<br />
  **Category:** Cont Basic (cont\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  RETVARARGS
  ```

  #### `DB3A` JMPXVARARGS

  Similar to `JMPXARGS`.<br />
  **Category:** Cont Basic (cont\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  JMPXVARARGS
  ```

  #### `DB3B` CALLCCVARARGS

  Similar to `CALLCCARGS`.<br />
  **Category:** Cont Basic (cont\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  CALLCCVARARGS
  ```

  #### `DB3C` CALLREF

  Equivalent to `PUSHREFCONT` `CALLX`.<br />
  **Category:** Cont Basic (cont\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [ref] CALLREF
  ```

  #### `DB3D` JMPREF

  Equivalent to `PUSHREFCONT` `JMPX`.<br />
  **Category:** Cont Basic (cont\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [ref] JMPREF
  ```

  #### `DB3E` JMPREFDATA

  Equivalent to `PUSHREFCONT` `JMPXDATA`.<br />
  **Category:** Cont Basic (cont\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [ref] JMPREFDATA
  ```

  #### `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.<br />
  **Category:** Cont Basic (cont\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  RETDATA
  ```

  #### `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.<br /><br />Flags operate similarly to `RUNVMX` in Fift:<br />- `+1`: sets `c3` to code.<br />- `+2`: pushes an implicit `0` before executing the code.<br />- `+4`: takes persistent data `c4` from the stack and returns its final value.<br />- `+8`: takes the gas limit `g_l` from the stack and returns the consumed gas `g_c`.<br />- `+16`: takes `c7` (smart contract context) from the stack.<br />- `+32`: returns the final value of `c5` (actions).<br />- `+64`: pops the hard gas limit `g_m` enabled by `ACCEPT` from the stack.<br />- `+128`: enables "isolated gas consumption", meaning the child VM maintains a separate set of visited cells and a `chksgn` counter.<br />- `+256`: pops an integer `r` and ensures exactly `r` values are returned from the top of the stack:<br />  - If `RUNVM` call succeeds and `r` is set, it returns `r` elements. If `r` is not set, it returns all available elements.<br />  - 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.<br />  - If `RUNVM` fails with an exception, only one element is returned, `exit_arg`, which should not be confused with `exit_code`.<br />  - In the case of running out of gas, `exit_code` is set to `-14`, and `exit_arg` contains the amount of gas.<br /><br />Gas cost:<br />- 66 gas;<br />- 1 gas for each stack element passed to the child VM (the first 32 elements are free);<br />- 1 gas for each stack element returned from the child VM (the first 32 elements are free).<br />
  **Category:** Cont Basic (cont\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  flags RUNVM
  ```

  #### `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.<br /><br />Flags operate similarly to `RUNVMX` in Fift:<br />- `+1`: sets `c3` to code.<br />- `+2`: pushes an implicit `0` before executing the code.<br />- `+4`: takes persistent data `c4` from the stack and returns its final value.<br />- `+8`: takes the gas limit `g_l` from the stack and returns the consumed gas `g_c`.<br />- `+16`: takes `c7` (smart contract context) from the stack.<br />- `+32`: returns the final value of `c5` (actions).<br />- `+64`: pops the hard gas limit `g_m` enabled by `ACCEPT` from the stack.<br />- `+128`: enables "isolated gas consumption", meaning the child VM maintains a separate set of visited cells and a `chksgn` counter.<br />- `+256`: pops an integer `r` and ensures exactly `r` values are returned from the top of the stack:<br />  - If `RUNVM` call succeeds and `r` is set, it returns `r` elements. If `r` is not set, it returns all available elements.<br />  - 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.<br />  - If `RUNVM` fails with an exception, only one element is returned, `exit_arg`, which should not be confused with `exit_code`.<br />  - In the case of running out of gas, `exit_code` is set to `-14`, and `exit_arg` contains the amount of gas.<br /><br />Gas cost:<br />- 66 gas;<br />- 1 gas for each stack element passed to the child VM (the first 32 elements are free);<br />- 1 gas for each stack element returned from the child VM (the first 32 elements are free).<br />
  **Category:** Cont Basic (cont\_basic)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  RUNVMX
  ```

  #### `DC` IFRET

  Performs a `RET`, but only if integer `f` is non-zero. If `f` is a `NaN`, throws an integer overflow exception.<br />
  **Category:** Cont Conditional (cont\_conditional)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  IFRET
  IFNOT:
  ```

  #### `DD` IFNOTRET

  Performs a `RET`, but only if integer `f` is zero.<br />
  **Category:** Cont Conditional (cont\_conditional)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  IFNOTRET
  IF:
  ```

  #### `DE` IF

  Performs `EXECUTE` for `c` (i.e., *executes* `c`), but only if integer `f` is non-zero. Otherwise simply discards both values.<br />
  **Category:** Cont Conditional (cont\_conditional)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  IF
  ```

  #### `DF` IFNOT

  Executes continuation `c`, but only if integer `f` is zero. Otherwise simply discards both values.<br />
  **Category:** Cont Conditional (cont\_conditional)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  IFNOT
  ```

  #### `E0` IFJMP

  Jumps to `c` (similarly to `JMPX`), but only if `f` is non-zero.<br />
  **Category:** Cont Conditional (cont\_conditional)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  IFJMP
  ```

  #### `E1` IFNOTJMP

  Jumps to `c` (similarly to `JMPX`), but only if `f` is zero.<br />
  **Category:** Cont Conditional (cont\_conditional)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  IFNOTJMP
  ```

  #### `E2` IFELSE

  If integer `f` is non-zero, executes `c`, otherwise executes `c'`. Equivalent to `CONDSELCHK` `EXECUTE`.<br />
  **Category:** Cont Conditional (cont\_conditional)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  IFELSE
  ```

  #### `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`.<br />Gas consumption of this primitive depends on whether `f=0` and whether the reference was loaded before.<br />Similar remarks apply other primitives that accept a continuation as a reference.<br />
  **Category:** Cont Conditional (cont\_conditional)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [ref] IFREF
  ```

  #### `E301` IFNOTREF

  Equivalent to `PUSHREFCONT` `IFNOT`.<br />
  **Category:** Cont Conditional (cont\_conditional)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [ref] IFNOTREF
  ```

  #### `E302` IFJMPREF

  Equivalent to `PUSHREFCONT` `IFJMP`.<br />
  **Category:** Cont Conditional (cont\_conditional)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [ref] IFJMPREF
  ```

  #### `E303` IFNOTJMPREF

  Equivalent to `PUSHREFCONT` `IFNOTJMP`.<br />
  **Category:** Cont Conditional (cont\_conditional)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [ref] IFNOTJMPREF
  ```

  #### `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`.<br />
  **Category:** Cont Conditional (cont\_conditional)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  CONDSEL
  ```

  #### `E305` CONDSELCHK

  Same as `CONDSEL`, but first checks whether `x` and `y` have the same type.<br />
  **Category:** Cont Conditional (cont\_conditional)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  CONDSELCHK
  ```

  #### `E308` IFRETALT

  Performs `RETALT` if integer `f!=0`.<br />
  **Category:** Cont Conditional (cont\_conditional)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  IFRETALT
  ```

  #### `E309` IFNOTRETALT

  Performs `RETALT` if integer `f=0`.<br />
  **Category:** Cont Conditional (cont\_conditional)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  IFNOTRETALT
  ```

  #### `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.<br />
  **Category:** Cont Conditional (cont\_conditional)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [ref] IFREFELSE
  ```

  #### `E30E` IFELSEREF

  Equivalent to `PUSHREFCONT` `IFELSE`.<br />
  **Category:** Cont Conditional (cont\_conditional)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [ref] IFELSEREF
  ```

  #### `E30F` IFREFELSEREF

  Equivalent to `PUSHREFCONT` `PUSHREFCONT` `IFELSE`.<br />
  **Category:** Cont Conditional (cont\_conditional)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [ref] [ref] IFREFELSEREF
  ```

  #### `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.<br />
  **Category:** Cont Conditional (cont\_conditional)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [n] IFBITJMP
  ```

  #### `E3B_n` IFNBITJMP

  Jumps to `c` if bit `0 <= n <= 31` is not set in integer `x`.<br />
  **Category:** Cont Conditional (cont\_conditional)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [n] IFNBITJMP
  ```

  #### `E3D_n` IFBITJMPREF

  Performs a `JMPREF` if bit `0 <= n <= 31` is set in integer `x`.<br />
  **Category:** Cont Conditional (cont\_conditional)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [ref] [n] IFBITJMPREF
  ```

  #### `E3F_n` IFNBITJMPREF

  Performs a `JMPREF` if bit `0 <= n <= 31` is not set in integer `x`.<br />
  **Category:** Cont Conditional (cont\_conditional)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [ref] [n] IFNBITJMPREF
  ```

  #### `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.<br />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.<br />
  **Category:** Cont Loops (cont\_loops)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  REPEAT
  ```

  #### `E5` REPEATEND

  Similar to `REPEAT`, but it is applied to the current continuation `cc`.<br />
  **Category:** Cont Loops (cont\_loops)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  REPEATEND
  REPEAT:
  ```

  #### `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.<br />
  **Category:** Cont Loops (cont\_loops)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  UNTIL
  ```

  #### `E7` UNTILEND

  Similar to `UNTIL`, but executes the current continuation `cc` in a loop. When the loop exit condition is satisfied, performs a `RET`.<br />
  **Category:** Cont Loops (cont\_loops)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  UNTILEND
  UNTIL:
  ```

  #### `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.<br />
  **Category:** Cont Loops (cont\_loops)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  WHILE
  ```

  #### `E9` WHILEEND

  Similar to `WHILE`, but uses the current continuation `cc` as the loop body.<br />
  **Category:** Cont Loops (cont\_loops)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  WHILEEND
  ```

  #### `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`).<br />
  **Category:** Cont Loops (cont\_loops)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  AGAIN
  ```

  #### `EB` AGAINEND

  Similar to `AGAIN`, but performed with respect to the current continuation `cc`.<br />
  **Category:** Cont Loops (cont\_loops)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  AGAINEND
  AGAIN:
  ```

  #### `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.<br />
  **Category:** Cont Loops (cont\_loops)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  REPEATBRK
  ```

  #### `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`.<br />
  **Category:** Cont Loops (cont\_loops)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  REPEATENDBRK
  ```

  #### `E316` UNTILBRK

  Similar to `UNTIL`, but also modifies `c1` in the same way as `REPEATBRK`.<br />
  **Category:** Cont Loops (cont\_loops)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  UNTILBRK
  ```

  #### `E317` UNTILENDBRK

  Equivalent to `SAMEALTSAVE` `UNTILEND`.<br />
  **Category:** Cont Loops (cont\_loops)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  UNTILENDBRK
  UNTILBRK:
  ```

  #### `E318` WHILEBRK

  Similar to `WHILE`, but also modifies `c1` in the same way as `REPEATBRK`.<br />
  **Category:** Cont Loops (cont\_loops)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  WHILEBRK
  ```

  #### `E319` WHILEENDBRK

  Equivalent to `SAMEALTSAVE` `WHILEEND`.<br />
  **Category:** Cont Loops (cont\_loops)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  WHILEENDBRK
  ```

  #### `E31A` AGAINBRK

  Similar to `AGAIN`, but also modifies `c1` in the same way as `REPEATBRK`.<br />
  **Category:** Cont Loops (cont\_loops)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  AGAINBRK
  ```

  #### `E31B` AGAINENDBRK

  Equivalent to `SAMEALTSAVE` `AGAINEND`.<br />
  **Category:** Cont Loops (cont\_loops)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  AGAINENDBRK
  AGAINBRK:
  ```

  #### `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.<br />
  **Category:** Cont Stack (cont\_stack)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [r] [n] SETCONTARGS
  ```

  **Aliases**:

  * `SETNUMARGS`<br />
    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`<br />
    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

  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.<br />
  **Category:** Cont Stack (cont\_stack)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [p] RETURNARGS
  ```

  #### `ED10` RETURNVARARGS

  Similar to `RETURNARGS`, but with Integer `0 <= p <= 255` taken from the stack.<br />
  **Category:** Cont Stack (cont\_stack)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  RETURNVARARGS
  ```

  #### `ED11` SETCONTVARARGS

  Similar to `SETCONTARGS`, but with `0 <= r <= 255` and `-1 <= n <= 255` taken from the stack.<br />
  **Category:** Cont Stack (cont\_stack)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SETCONTVARARGS
  ```

  #### `ED12` SETNUMVARARGS

  `-1 <= n <= 255`<br />If `n=-1`, this operation does nothing (`c'=c`).<br />Otherwise its action is similar to `[n] SETNUMARGS`, but with `n` taken from the stack.<br />
  **Category:** Cont Stack (cont\_stack)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SETNUMVARARGS
  ```

  #### `ED1E` BLESS

  Transforms a *Slice* `s` into a simple ordinary continuation `c`, with `c.code=s` and an empty stack and savelist.<br />
  **Category:** Cont Create (cont\_create)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BLESS
  ```

  #### `ED1F` BLESSVARARGS

  Equivalent to `ROT` `BLESS` `ROTREV` `SETCONTVARARGS`.<br />
  **Category:** Cont Create (cont\_create)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BLESSVARARGS
  ```

  #### `EErn` BLESSARGS

  `0 <= r <= 15`, `-1 <= n <= 14`<br />Equivalent to `BLESS` `[r] [n] SETCONTARGS`.<br />The value of `n` is represented inside the instruction by the 4-bit integer `n mod 16`.<br />
  **Category:** Cont Create (cont\_create)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [r] [n] BLESSARGS
  ```

  **Aliases**:

  * `BLESSNUMARGS`<br />
    Also transforms a *Slice* `s` into a *Continuation* `c`, but sets `c.nargs` to `0 <= n <= 14`.

  #### `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.<br />
  **Category:** Cont Registers (cont\_registers)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  c[i] PUSHCTR
  c[i] PUSH
  ```

  **Aliases**:

  * `PUSHROOT`<br />
    Pushes the ''global data root'' cell reference, thus enabling access to persistent smart-contract data.

  #### `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.<br />
  **Category:** Cont Registers (cont\_registers)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  c[i] POPCTR
  c[i] POP
  ```

  **Aliases**:

  * `POPROOT`<br />
    Sets the ''global data root'' cell reference, thus allowing modification of persistent smart-contract data.

  #### `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`.<br />
  **Category:** Cont Registers (cont\_registers)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  c[i] SETCONT
  c[i] SETCONTCTR
  ```

  #### `ED7i` SETRETCTR

  Equivalent to `c0 PUSHCTR` `c[i] SETCONTCTR` `c0 POPCTR`.<br />
  **Category:** Cont Registers (cont\_registers)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  c[i] SETRETCTR
  ```

  #### `ED8i` SETALTCTR

  Equivalent to `c1 PUSHCTR` `c[i] SETCONTCTR` `c1 POPCTR`.<br />
  **Category:** Cont Registers (cont\_registers)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  c[i] SETALTCTR
  ```

  #### `ED9i` POPSAVE

  Similar to `c[i] POPCTR`, but also saves the old value of `c[i]` into continuation `c0`.<br />Equivalent (up to exceptions) to `c[i] SAVECTR` `c[i] POPCTR`.<br />
  **Category:** Cont Registers (cont\_registers)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  c[i] POPSAVE
  c[i] POPCTRSAVE
  ```

  #### `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`.<br />
  **Category:** Cont Registers (cont\_registers)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  c[i] SAVE
  c[i] SAVECTR
  ```

  #### `EDBi` SAVEALT

  Similar to `c[i] SAVE`, but saves the current value of `c[i]` into the savelist of `c1`, not `c0`.<br />
  **Category:** Cont Registers (cont\_registers)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  c[i] SAVEALT
  c[i] SAVEALTCTR
  ```

  #### `EDCi` SAVEBOTH

  Equivalent to `c[i] SAVE` `c[i] SAVEALT`.<br />
  **Category:** Cont Registers (cont\_registers)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  c[i] SAVEBOTH
  c[i] SAVEBOTHCTR
  ```

  #### `EDE0` PUSHCTRX

  Similar to `c[i] PUSHCTR`, but with `i`, `0 <= i <= 255`, taken from the stack.<br />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`.<br />
  **Category:** Cont Registers (cont\_registers)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PUSHCTRX
  ```

  #### `EDE1` POPCTRX

  Similar to `c[i] POPCTR`, but with `0 <= i <= 255` from the stack.<br />
  **Category:** Cont Registers (cont\_registers)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  POPCTRX
  ```

  #### `EDE2` SETCONTCTRX

  Similar to `c[i] SETCONTCTR`, but with `0 <= i <= 255` from the stack.<br />
  **Category:** Cont Registers (cont\_registers)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SETCONTCTRX
  ```

  #### `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`).<br />
  **Category:** Cont Registers (cont\_registers)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SETCONTCTRMANY
  SETCONTMANY
  ```

  #### `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`).<br />
  **Category:** Cont Registers (cont\_registers)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SETCONTCTRMANYX
  SETCONTMANYX
  ```

  #### `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`.<br />
  **Category:** Cont Registers (cont\_registers)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  COMPOS
  BOOLAND
  ```

  #### `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`.<br />
  **Category:** Cont Registers (cont\_registers)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  COMPOSALT
  BOOLOR
  ```

  #### `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`''.<br />
  **Category:** Cont Registers (cont\_registers)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  COMPOSBOTH
  ```

  #### `EDF3` ATEXIT

  Sets `c0` to `compose0(c, c0)`. In other words, `c` will be executed before exiting current subroutine.<br />
  **Category:** Cont Registers (cont\_registers)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  ATEXIT
  ```

  #### `EDF4` ATEXITALT

  Sets `c1` to `compose1(c, c1)`. In other words, `c` will be executed before exiting current subroutine by its alternative return path.<br />
  **Category:** Cont Registers (cont\_registers)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  ATEXITALT
  ```

  #### `EDF5` SETEXITALT

  Sets `c1` to `compose1(compose0(c, c0), c1)`,<br />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.<br />
  **Category:** Cont Registers (cont\_registers)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SETEXITALT
  ```

  #### `EDF6` THENRET

  Computes `compose0(c, c0)`.<br />
  **Category:** Cont Registers (cont\_registers)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  THENRET
  ```

  #### `EDF7` THENRETALT

  Computes `compose0(c, c1)`<br />
  **Category:** Cont Registers (cont\_registers)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  THENRETALT
  ```

  #### `EDF8` INVERT

  Interchanges `c0` and `c1`.<br />
  **Category:** Cont Registers (cont\_registers)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  INVERT
  ```

  #### `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.<br />
  **Category:** Cont Registers (cont\_registers)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BOOLEVAL
  ```

  #### `EDFA` SAMEALT

  Sets `c1` to `c0`. Equivalent to `c0 PUSHCTR` `c1 POPCTR`.<br />
  **Category:** Cont Registers (cont\_registers)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SAMEALT
  ```

  #### `EDFB` SAMEALTSAVE

  Sets `c1` to `c0`, but first saves the old value of `c1` into the savelist of `c0`.<br />Equivalent to `c1 SAVE` `SAMEALT`.<br />
  **Category:** Cont Registers (cont\_registers)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SAMEALTSAVE
  ```

  #### `F0nn` CALLDICT

  Calls the continuation in `c3`, pushing integer `0 <= nn <= 255` into its stack as an argument.<br />Approximately equivalent to `[nn] PUSHINT` `c3 PUSHCTR` `EXECUTE`.<br />
  **Category:** Cont Dict (cont\_dict)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [nn] CALL
  [nn] CALLDICT
  ```

  #### `F12_n` CALLDICT\_LONG

  For `0 <= n < 2^14`, an encoding of `[n] CALL` for larger values of `n`.<br />
  **Category:** Cont Dict (cont\_dict)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [n] CALL
  [n] CALLDICT
  ```

  #### `F16_n` JMPDICT

  Jumps to the continuation in `c3`, pushing integer `0 <= n < 2^14` as its argument.<br />Approximately equivalent to `n PUSHINT` `c3 PUSHCTR` `JMPX`.<br />
  **Category:** Cont Dict (cont\_dict)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [n] JMP
  ```

  #### `F1A_n` PREPAREDICT

  Equivalent to `n PUSHINT` `c3 PUSHCTR`, for `0 <= n < 2^14`.<br />In this way, `[n] CALL` is approximately equivalent to `[n] PREPARE` `EXECUTE`, and `[n] JMP` is approximately equivalent to `[n] PREPARE` `JMPX`.<br />One might use, for instance, `CALLXARGS` or `CALLCC` instead of `EXECUTE` here.<br />
  **Category:** Cont Dict (cont\_dict)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [n] PREPARE
  [n] PREPAREDICT
  ```

  #### `F22_n` THROW\_SHORT

  Throws exception `0 <= n <= 63` with parameter zero.<br />In other words, it transfers control to the continuation in `c2`, pushing `0` and `n` into its stack, and discarding the old stack altogether.<br />
  **Category:** Exceptions (exceptions)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [n] THROW
  ```

  #### `F26_n` THROWIF\_SHORT

  Throws exception `0 <= n <= 63` with  parameter zero only if integer `f!=0`.<br />
  **Category:** Exceptions (exceptions)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [n] THROWIF
  ```

  #### `F2A_n` THROWIFNOT\_SHORT

  Throws exception `0 <= n <= 63` with parameter zero only if integer `f=0`.<br />
  **Category:** Exceptions (exceptions)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [n] THROWIFNOT
  ```

  #### `F2C4_n` THROW

  For `0 <= n < 2^11`, an encoding of `[n] THROW` for larger values of `n`.<br />
  **Category:** Exceptions (exceptions)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [n] THROW
  ```

  #### `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`.<br />
  **Category:** Exceptions (exceptions)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [n] THROWARG
  ```

  #### `F2D4_n` THROWIF

  For `0 <= n < 2^11`, an encoding of `[n] THROWIF` for larger values of `n`.<br />
  **Category:** Exceptions (exceptions)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [n] THROWIF
  ```

  #### `F2DC_n` THROWARGIF

  Throws exception `0 <= nn < 2^11` with parameter `x` only if integer `f!=0`.<br />
  **Category:** Exceptions (exceptions)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [n] THROWARGIF
  ```

  #### `F2E4_n` THROWIFNOT

  For `0 <= n < 2^11`, an encoding of `[n] THROWIFNOT` for larger values of `n`.<br />
  **Category:** Exceptions (exceptions)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [n] THROWIFNOT
  ```

  #### `F2EC_n` THROWARGIFNOT

  Throws exception `0 <= n < 2^11` with parameter `x` only if integer `f=0`.<br />
  **Category:** Exceptions (exceptions)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [n] THROWARGIFNOT
  ```

  #### `F2F0` THROWANY

  Throws exception `0 <= n < 2^16` with parameter zero.<br />Approximately equivalent to `ZERO` `SWAP` `THROWARGANY`.<br />
  **Category:** Exceptions (exceptions)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  THROWANY
  ```

  #### `F2F1` THROWARGANY

  Throws exception `0 <= n < 2^16` with parameter `x`, transferring control to the continuation in `c2`.<br />Approximately equivalent to `c2 PUSHCTR` `2 JMPXARGS`.<br />
  **Category:** Exceptions (exceptions)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  THROWARGANY
  ```

  #### `F2F2` THROWANYIF

  Throws exception `0 <= n < 2^16` with parameter zero only if `f!=0`.<br />
  **Category:** Exceptions (exceptions)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  THROWANYIF
  ```

  #### `F2F3` THROWARGANYIF

  Throws exception `0 <= n<2^16` with parameter `x` only if `f!=0`.<br />
  **Category:** Exceptions (exceptions)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  THROWARGANYIF
  ```

  #### `F2F4` THROWANYIFNOT

  Throws exception `0 <= n<2^16` with parameter zero only if `f=0`.<br />
  **Category:** Exceptions (exceptions)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  THROWANYIFNOT
  ```

  #### `F2F5` THROWARGANYIFNOT

  Throws exception `0 <= n<2^16` with parameter `x` only if `f=0`.<br />
  **Category:** Exceptions (exceptions)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  THROWARGANYIFNOT
  ```

  #### `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.<br />
  **Category:** Exceptions (exceptions)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  TRY
  ```

  #### `F3pr` TRYARGS

  Similar to `TRY`, but with `[p] [r] CALLXARGS` internally used instead of `EXECUTE`.<br />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.<br />
  **Category:** Exceptions (exceptions)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [p] [r] TRYARGS
  ```

  #### `F400` STDICT

  Stores dictionary `D` into *Builder* `b`, returning the resulting *Builder* `b'`.<br />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.<br />
  **Category:** Dict Serial (dict\_serial)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STDICT
  STOPTREF
  ```

  #### `F401` SKIPDICT

  Equivalent to `LDDICT` `NIP`.<br />
  **Category:** Dict Serial (dict\_serial)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SKIPDICT
  SKIPOPTREF
  ```

  #### `F402` LDDICTS

  Loads (parses) a (*Slice*-represented) dictionary `s'` from *Slice* `s`, and returns the remainder of `s` as `s''`.<br />This is a ''split function'' for all `HashmapE(n,X)` dictionary types.<br />
  **Category:** Dict Serial (dict\_serial)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDDICTS
  ```

  #### `F403` PLDDICTS

  Preloads a (*Slice*-represented) dictionary `s'` from *Slice* `s`.<br />Approximately equivalent to `LDDICTS` `DROP`.<br />
  **Category:** Dict Serial (dict\_serial)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PLDDICTS
  ```

  #### `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.<br />
  **Category:** Dict Serial (dict\_serial)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDDICT
  LDOPTREF
  ```

  #### `F405` PLDDICT

  Preloads a dictionary `D` from *Slice* `s`.<br />Approximately equivalent to `LDDICT` `DROP`.<br />
  **Category:** Dict Serial (dict\_serial)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PLDDICT
  PLDOPTREF
  ```

  #### `F406` LDDICTQ

  A quiet version of `LDDICT`.<br />
  **Category:** Dict Serial (dict\_serial)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDDICTQ
  ```

  #### `F407` PLDDICTQ

  A quiet version of `PLDDICT`.<br />
  **Category:** Dict Serial (dict\_serial)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PLDDICTQ
  ```

  #### `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.<br />On success, returns the value found as a *Slice* `x`.<br />
  **Category:** Dict Get (dict\_get)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTGET
  ```

  #### `F40B` DICTGETREF

  Similar to `DICTGET`, but with a `LDREF` `ENDS` applied to `x` on success.<br />This operation is useful for dictionaries of type `HashmapE(n,^Y)`.<br />
  **Category:** Dict Get (dict\_get)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTGETREF
  ```

  #### `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.<br />
  **Category:** Dict Get (dict\_get)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIGET
  ```

  #### `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.<br />
  **Category:** Dict Get (dict\_get)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIGETREF
  ```

  #### `F40E` DICTUGET

  Similar to `DICTIGET`, but with *unsigned* (big-endian) `n`-bit *Integer* `i` used as a key.<br />
  **Category:** Dict Get (dict\_get)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUGET
  ```

  #### `F40F` DICTUGETREF

  Similar to `DICTIGETREF`, but with an unsigned `n`-bit *Integer* key `i`.<br />
  **Category:** Dict Get (dict\_get)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUGETREF
  ```

  #### `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'`.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTSET
  ```

  #### `F413` DICTSETREF

  Similar to `DICTSET`, but with the value set to a reference to *Cell* `c`.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTSETREF
  ```

  #### `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.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTISET
  ```

  #### `F415` DICTISETREF

  Similar to `DICTSETREF`, but with the key a signed `n`-bit integer as in `DICTISET`.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTISETREF
  ```

  #### `F416` DICTUSET

  Similar to `DICTISET`, but with `i` an *unsigned* `n`-bit integer.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUSET
  ```

  #### `F417` DICTUSETREF

  Similar to `DICTISETREF`, but with `i` unsigned.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUSETREF
  ```

  #### `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.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTSETGET
  ```

  #### `F41B` DICTSETGETREF

  Combines `DICTSETREF` with `DICTGETREF` similarly to `DICTSETGET`.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTSETGETREF
  ```

  #### `F41C` DICTISETGET

  `DICTISETGET`, but with `i` a signed `n`-bit integer.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTISETGET
  ```

  #### `F41D` DICTISETGETREF

  `DICTISETGETREF`, but with `i` a signed `n`-bit integer.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTISETGETREF
  ```

  #### `F41E` DICTUSETGET

  `DICTISETGET`, but with `i` an unsigned `n`-bit integer.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUSETGET
  ```

  #### `F41F` DICTUSETGETREF

  `DICTISETGETREF`, but with `i` an unsigned `n`-bit integer.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUSETGETREF
  ```

  #### `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`.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTREPLACE
  ```

  #### `F423` DICTREPLACEREF

  A *Replace* counterpart of `DICTSETREF`.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTREPLACEREF
  ```

  #### `F424` DICTIREPLACE

  `DICTREPLACE`, but with `i` a signed `n`-bit integer.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIREPLACE
  ```

  #### `F425` DICTIREPLACEREF

  `DICTREPLACEREF`, but with `i` a signed `n`-bit integer.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIREPLACEREF
  ```

  #### `F426` DICTUREPLACE

  `DICTREPLACE`, but with `i` an unsigned `n`-bit integer.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUREPLACE
  ```

  #### `F427` DICTUREPLACEREF

  `DICTREPLACEREF`, but with `i` an unsigned `n`-bit integer.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUREPLACEREF
  ```

  #### `F42A` DICTREPLACEGET

  A *Replace* counterpart of `DICTSETGET`: on success, also returns the old value associated with the key in question.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTREPLACEGET
  ```

  #### `F42B` DICTREPLACEGETREF

  A *Replace* counterpart of `DICTSETGETREF`.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTREPLACEGETREF
  ```

  #### `F42C` DICTIREPLACEGET

  `DICTREPLACEGET`, but with `i` a signed `n`-bit integer.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIREPLACEGET
  ```

  #### `F42D` DICTIREPLACEGETREF

  `DICTREPLACEGETREF`, but with `i` a signed `n`-bit integer.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIREPLACEGETREF
  ```

  #### `F42E` DICTUREPLACEGET

  `DICTREPLACEGET`, but with `i` an unsigned `n`-bit integer.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUREPLACEGET
  ```

  #### `F42F` DICTUREPLACEGETREF

  `DICTREPLACEGETREF`, but with `i` an unsigned `n`-bit integer.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUREPLACEGETREF
  ```

  #### `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`.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTADD
  ```

  #### `F433` DICTADDREF

  An *Add* counterpart of `DICTSETREF`.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTADDREF
  ```

  #### `F434` DICTIADD

  `DICTADD`, but with `i` a signed `n`-bit integer.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIADD
  ```

  #### `F435` DICTIADDREF

  `DICTADDREF`, but with `i` a signed `n`-bit integer.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIADDREF
  ```

  #### `F436` DICTUADD

  `DICTADD`, but with `i` an unsigned `n`-bit integer.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUADD
  ```

  #### `F437` DICTUADDREF

  `DICTADDREF`, but with `i` an unsigned `n`-bit integer.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUADDREF
  ```

  #### `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.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTADDGET
  ```

  #### `F43B` DICTADDGETREF

  An *Add* counterpart of `DICTSETGETREF`.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTADDGETREF
  ```

  #### `F43C` DICTIADDGET

  `DICTADDGET`, but with `i` a signed `n`-bit integer.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIADDGET
  ```

  #### `F43D` DICTIADDGETREF

  `DICTADDGETREF`, but with `i` a signed `n`-bit integer.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIADDGETREF
  ```

  #### `F43E` DICTUADDGET

  `DICTADDGET`, but with `i` an unsigned `n`-bit integer.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUADDGET
  ```

  #### `F43F` DICTUADDGETREF

  `DICTADDGETREF`, but with `i` an unsigned `n`-bit integer.<br />
  **Category:** Dict Set (dict\_set)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUADDGETREF
  ```

  #### `F441` DICTSETB

  <br />

  **Category:** Dict Set Builder (dict\_set\_builder)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTSETB
  ```

  #### `F442` DICTISETB

  <br />

  **Category:** Dict Set Builder (dict\_set\_builder)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTISETB
  ```

  #### `F443` DICTUSETB

  <br />

  **Category:** Dict Set Builder (dict\_set\_builder)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUSETB
  ```

  #### `F445` DICTSETGETB

  <br />

  **Category:** Dict Set Builder (dict\_set\_builder)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTSETGETB
  ```

  #### `F446` DICTISETGETB

  <br />

  **Category:** Dict Set Builder (dict\_set\_builder)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTISETGETB
  ```

  #### `F447` DICTUSETGETB

  <br />

  **Category:** Dict Set Builder (dict\_set\_builder)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUSETGETB
  ```

  #### `F449` DICTREPLACEB

  <br />

  **Category:** Dict Set Builder (dict\_set\_builder)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTREPLACEB
  ```

  #### `F44A` DICTIREPLACEB

  <br />

  **Category:** Dict Set Builder (dict\_set\_builder)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIREPLACEB
  ```

  #### `F44B` DICTUREPLACEB

  <br />

  **Category:** Dict Set Builder (dict\_set\_builder)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUREPLACEB
  ```

  #### `F44D` DICTREPLACEGETB

  <br />

  **Category:** Dict Set Builder (dict\_set\_builder)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTREPLACEGETB
  ```

  #### `F44E` DICTIREPLACEGETB

  <br />

  **Category:** Dict Set Builder (dict\_set\_builder)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIREPLACEGETB
  ```

  #### `F44F` DICTUREPLACEGETB

  <br />

  **Category:** Dict Set Builder (dict\_set\_builder)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUREPLACEGETB
  ```

  #### `F451` DICTADDB

  <br />

  **Category:** Dict Set Builder (dict\_set\_builder)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTADDB
  ```

  #### `F452` DICTIADDB

  <br />

  **Category:** Dict Set Builder (dict\_set\_builder)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIADDB
  ```

  #### `F453` DICTUADDB

  <br />

  **Category:** Dict Set Builder (dict\_set\_builder)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUADDB
  ```

  #### `F455` DICTADDGETB

  <br />

  **Category:** Dict Set Builder (dict\_set\_builder)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTADDGETB
  ```

  #### `F456` DICTIADDGETB

  <br />

  **Category:** Dict Set Builder (dict\_set\_builder)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIADDGETB
  ```

  #### `F457` DICTUADDGETB

  <br />

  **Category:** Dict Set Builder (dict\_set\_builder)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUADDGETB
  ```

  #### `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`.<br />
  **Category:** Dict Delete (dict\_delete)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTDEL
  ```

  #### `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'').<br />
  **Category:** Dict Delete (dict\_delete)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIDEL
  ```

  #### `F45B` DICTUDEL

  Similar to `DICTIDEL`, but with `i` an unsigned `n`-bit integer.<br />
  **Category:** Dict Delete (dict\_delete)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUDEL
  ```

  #### `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`.<br />
  **Category:** Dict Delete (dict\_delete)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTDELGET
  ```

  #### `F463` DICTDELGETREF

  Similar to `DICTDELGET`, but with `LDREF` `ENDS` applied to `x` on success, so that the value returned `c` is a *Cell*.<br />
  **Category:** Dict Delete (dict\_delete)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTDELGETREF
  ```

  #### `F464` DICTIDELGET

  `DICTDELGET`, but with `i` a signed `n`-bit integer.<br />
  **Category:** Dict Delete (dict\_delete)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIDELGET
  ```

  #### `F465` DICTIDELGETREF

  `DICTDELGETREF`, but with `i` a signed `n`-bit integer.<br />
  **Category:** Dict Delete (dict\_delete)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIDELGETREF
  ```

  #### `F466` DICTUDELGET

  `DICTDELGET`, but with `i` an unsigned `n`-bit integer.<br />
  **Category:** Dict Delete (dict\_delete)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUDELGET
  ```

  #### `F467` DICTUDELGETREF

  `DICTDELGETREF`, but with `i` an unsigned `n`-bit integer.<br />
  **Category:** Dict Delete (dict\_delete)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUDELGETREF
  ```

  #### `F469` DICTGETOPTREF

  A variant of `DICTGETREF` that returns *Null* instead of the value `c^?` if the key `k` is absent from dictionary `D`.<br />
  **Category:** Dict Mayberef (dict\_mayberef)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTGETOPTREF
  ```

  #### `F46A` DICTIGETOPTREF

  `DICTGETOPTREF`, but with `i` a signed `n`-bit integer. If the key `i` is out of range, also returns *Null*.<br />
  **Category:** Dict Mayberef (dict\_mayberef)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIGETOPTREF
  ```

  #### `F46B` DICTUGETOPTREF

  `DICTGETOPTREF`, but with `i` an unsigned `n`-bit integer. If the key `i` is out of range, also returns *Null*.<br />
  **Category:** Dict Mayberef (dict\_mayberef)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUGETOPTREF
  ```

  #### `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).<br />
  **Category:** Dict Mayberef (dict\_mayberef)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTSETGETOPTREF
  ```

  #### `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.<br />
  **Category:** Dict Mayberef (dict\_mayberef)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTISETGETOPTREF
  ```

  #### `F46F` DICTUSETGETOPTREF

  Similar to primitive `DICTSETGETOPTREF`, but using unsigned `n`-bit *Integer* `i` as a key.<br />
  **Category:** Dict Mayberef (dict\_mayberef)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUSETGETOPTREF
  ```

  #### `F470` PFXDICTSET

  <br />

  **Category:** Dict Prefix (dict\_prefix)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PFXDICTSET
  ```

  #### `F471` PFXDICTREPLACE

  <br />

  **Category:** Dict Prefix (dict\_prefix)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PFXDICTREPLACE
  ```

  #### `F472` PFXDICTADD

  <br />

  **Category:** Dict Prefix (dict\_prefix)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PFXDICTADD
  ```

  #### `F473` PFXDICTDEL

  <br />

  **Category:** Dict Prefix (dict\_prefix)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PFXDICTDEL
  ```

  #### `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*).<br />
  **Category:** Dict Next (dict\_next)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTGETNEXT
  ```

  #### `F475` DICTGETNEXTEQ

  Similar to `DICTGETNEXT`, but computes the minimal key `k'` that is lexicographically greater than or equal to `k`.<br />
  **Category:** Dict Next (dict\_next)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTGETNEXTEQ
  ```

  #### `F476` DICTGETPREV

  Similar to `DICTGETNEXT`, but computes the maximal key `k'` lexicographically smaller than `k`.<br />
  **Category:** Dict Next (dict\_next)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTGETPREV
  ```

  #### `F477` DICTGETPREVEQ

  Similar to `DICTGETPREV`, but computes the maximal key `k'` lexicographically smaller than or equal to `k`.<br />
  **Category:** Dict Next (dict\_next)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTGETPREVEQ
  ```

  #### `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).<br />
  **Category:** Dict Next (dict\_next)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIGETNEXT
  ```

  #### `F479` DICTIGETNEXTEQ

  Similar to `DICTGETNEXTEQ`, but interprets keys as signed `n`-bit integers.<br />
  **Category:** Dict Next (dict\_next)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIGETNEXTEQ
  ```

  #### `F47A` DICTIGETPREV

  Similar to `DICTGETPREV`, but interprets keys as signed `n`-bit integers.<br />
  **Category:** Dict Next (dict\_next)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIGETPREV
  ```

  #### `F47B` DICTIGETPREVEQ

  Similar to `DICTGETPREVEQ`, but interprets keys as signed `n`-bit integers.<br />
  **Category:** Dict Next (dict\_next)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIGETPREVEQ
  ```

  #### `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).<br />
  **Category:** Dict Next (dict\_next)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUGETNEXT
  ```

  #### `F47D` DICTUGETNEXTEQ

  Similar to `DICTGETNEXTEQ`, but interprets keys as unsigned `n`-bit integers.<br />
  **Category:** Dict Next (dict\_next)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUGETNEXTEQ
  ```

  #### `F47E` DICTUGETPREV

  Similar to `DICTGETPREV`, but interprets keys as unsigned `n`-bit integers.<br />
  **Category:** Dict Next (dict\_next)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUGETPREV
  ```

  #### `F47F` DICTUGETPREVEQ

  Similar to `DICTGETPREVEQ`, but interprets keys a unsigned `n`-bit integers.<br />
  **Category:** Dict Next (dict\_next)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUGETPREVEQ
  ```

  #### `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`.<br />
  **Category:** Dict Min (dict\_min)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTMIN
  ```

  #### `F483` DICTMINREF

  Similar to `DICTMIN`, but returns the only reference in the value as a *Cell* `c`.<br />
  **Category:** Dict Min (dict\_min)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTMINREF
  ```

  #### `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`.<br />
  **Category:** Dict Min (dict\_min)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIMIN
  ```

  #### `F485` DICTIMINREF

  Similar to `DICTIMIN`, but returns the only reference in the value.<br />
  **Category:** Dict Min (dict\_min)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIMINREF
  ```

  #### `F486` DICTUMIN

  Similar to `DICTMIN`, but returns the key as an unsigned `n`-bit *Integer* `i`.<br />
  **Category:** Dict Min (dict\_min)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUMIN
  ```

  #### `F487` DICTUMINREF

  Similar to `DICTUMIN`, but returns the only reference in the value.<br />
  **Category:** Dict Min (dict\_min)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUMINREF
  ```

  #### `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`.<br />
  **Category:** Dict Min (dict\_min)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTMAX
  ```

  #### `F48B` DICTMAXREF

  Similar to `DICTMAX`, but returns the only reference in the value.<br />
  **Category:** Dict Min (dict\_min)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTMAXREF
  ```

  #### `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`.<br />
  **Category:** Dict Min (dict\_min)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIMAX
  ```

  #### `F48D` DICTIMAXREF

  Similar to `DICTIMAX`, but returns the only reference in the value.<br />
  **Category:** Dict Min (dict\_min)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIMAXREF
  ```

  #### `F48E` DICTUMAX

  Similar to `DICTMAX`, but returns the key as an unsigned `n`-bit *Integer* `i`.<br />
  **Category:** Dict Min (dict\_min)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUMAX
  ```

  #### `F48F` DICTUMAXREF

  Similar to `DICTUMAX`, but returns the only reference in the value.<br />
  **Category:** Dict Min (dict\_min)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUMAXREF
  ```

  #### `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'`.<br />
  **Category:** Dict Min (dict\_min)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTREMMIN
  ```

  #### `F493` DICTREMMINREF

  Similar to `DICTREMMIN`, but returns the only reference in the value as a *Cell* `c`.<br />
  **Category:** Dict Min (dict\_min)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTREMMINREF
  ```

  #### `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`.<br />
  **Category:** Dict Min (dict\_min)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIREMMIN
  ```

  #### `F495` DICTIREMMINREF

  Similar to `DICTIREMMIN`, but returns the only reference in the value.<br />
  **Category:** Dict Min (dict\_min)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIREMMINREF
  ```

  #### `F496` DICTUREMMIN

  Similar to `DICTREMMIN`, but returns the key as an unsigned `n`-bit *Integer* `i`.<br />
  **Category:** Dict Min (dict\_min)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUREMMIN
  ```

  #### `F497` DICTUREMMINREF

  Similar to `DICTUREMMIN`, but returns the only reference in the value.<br />
  **Category:** Dict Min (dict\_min)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUREMMINREF
  ```

  #### `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'`.<br />
  **Category:** Dict Min (dict\_min)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTREMMAX
  ```

  #### `F49B` DICTREMMAXREF

  Similar to `DICTREMMAX`, but returns the only reference in the value as a *Cell* `c`.<br />
  **Category:** Dict Min (dict\_min)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTREMMAXREF
  ```

  #### `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`.<br />
  **Category:** Dict Min (dict\_min)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIREMMAX
  ```

  #### `F49D` DICTIREMMAXREF

  Similar to `DICTIREMMAX`, but returns the only reference in the value.<br />
  **Category:** Dict Min (dict\_min)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIREMMAXREF
  ```

  #### `F49E` DICTUREMMAX

  Similar to `DICTREMMAX`, but returns the key as an unsigned `n`-bit *Integer* `i`.<br />
  **Category:** Dict Min (dict\_min)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUREMMAX
  ```

  #### `F49F` DICTUREMMAXREF

  Similar to `DICTUREMMAX`, but returns the only reference in the value.<br />
  **Category:** Dict Min (dict\_min)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUREMMAXREF
  ```

  #### `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.<br />
  **Category:** Dict Special (dict\_special)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIGETJMP
  ```

  #### `F4A1` DICTUGETJMP

  Similar to `DICTIGETJMP`, but performs `DICTUGET` instead of `DICTIGET`.<br />
  **Category:** Dict Special (dict\_special)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUGETJMP
  ```

  #### `F4A2` DICTIGETEXEC

  Similar to `DICTIGETJMP`, but with `EXECUTE` instead of `JMPX`.<br />
  **Category:** Dict Special (dict\_special)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIGETEXEC
  ```

  #### `F4A3` DICTUGETEXEC

  Similar to `DICTUGETJMP`, but with `EXECUTE` instead of `JMPX`.<br />
  **Category:** Dict Special (dict\_special)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUGETEXEC
  ```

  #### `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.<br />
  **Category:** Dict Special (dict\_special)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [ref] [n] DICTPUSHCONST
  ```

  #### `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.<br />
  **Category:** Dict Special (dict\_special)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PFXDICTGETQ
  ```

  #### `F4A9` PFXDICTGET

  Similar to `PFXDICTGET`, but throws a cell deserialization failure exception on failure.<br />
  **Category:** Dict Special (dict\_special)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PFXDICTGET
  ```

  #### `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.<br />
  **Category:** Dict Special (dict\_special)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PFXDICTGETJMP
  ```

  #### `F4AB` PFXDICTGETEXEC

  Similar to `PFXDICTGETJMP`, but `EXEC`utes the continuation found instead of jumping to it. On failure, throws a cell deserialization exception.<br />
  **Category:** Dict Special (dict\_special)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PFXDICTGETEXEC
  ```

  #### `F4AE_n` PFXDICTCONSTGETJMP

  Combines `[n] DICTPUSHCONST` for `0 <= n <= 1023` with `PFXDICTGETJMP`.<br />
  **Category:** Dict Special (dict\_special)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [ref] [n] PFXDICTCONSTGETJMP
  [ref] [n] PFXDICTSWITCH
  ```

  #### `F4BC` DICTIGETJMPZ

  A variant of `DICTIGETJMP` that returns index `i` on failure.<br />
  **Category:** Dict Special (dict\_special)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIGETJMPZ
  ```

  #### `F4BD` DICTUGETJMPZ

  A variant of `DICTUGETJMP` that returns index `i` on failure.<br />
  **Category:** Dict Special (dict\_special)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUGETJMPZ
  ```

  #### `F4BE` DICTIGETEXECZ

  A variant of `DICTIGETEXEC` that returns index `i` on failure.<br />
  **Category:** Dict Special (dict\_special)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTIGETEXECZ
  ```

  #### `F4BF` DICTUGETEXECZ

  A variant of `DICTUGETEXEC` that returns index `i` on failure.<br />
  **Category:** Dict Special (dict\_special)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  DICTUGETEXECZ
  ```

  #### `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'`.<br />
  **Category:** Dict Sub (dict\_sub)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SUBDICTGET
  ```

  #### `F4B2` SUBDICTIGET

  Variant of `SUBDICTGET` with the prefix represented by a signed big-endian `l`-bit *Integer* `x`, where necessarily `l <= 257`.<br />
  **Category:** Dict Sub (dict\_sub)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SUBDICTIGET
  ```

  #### `F4B3` SUBDICTUGET

  Variant of `SUBDICTGET` with the prefix represented by an unsigned big-endian `l`-bit *Integer* `x`, where necessarily `l <= 256`.<br />
  **Category:** Dict Sub (dict\_sub)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SUBDICTUGET
  ```

  #### `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)`.<br />
  **Category:** Dict Sub (dict\_sub)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SUBDICTRPGET
  ```

  #### `F4B6` SUBDICTIRPGET

  Variant of `SUBDICTRPGET` with the prefix represented by a signed big-endian `l`-bit *Integer* `x`, where necessarily `l <= 257`.<br />
  **Category:** Dict Sub (dict\_sub)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SUBDICTIRPGET
  ```

  #### `F4B7` SUBDICTURPGET

  Variant of `SUBDICTRPGET` with the prefix represented by an unsigned big-endian `l`-bit *Integer* `x`, where necessarily `l <= 256`.<br />
  **Category:** Dict Sub (dict\_sub)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SUBDICTURPGET
  ```

  #### `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.<br />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.<br />
  **Category:** App Gas (app\_gas)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  ACCEPT
  ```

  #### `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`.<br />
  **Category:** App Gas (app\_gas)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SETGASLIMIT
  ```

  #### `F807` GASCONSUMED

  Returns gas consumed by VM so far (including this instruction).<br />
  **Category:** App Gas (app\_gas)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  GASCONSUMED
  ```

  #### `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.<br />
  **Category:** App Gas (app\_gas)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  COMMIT
  ```

  #### `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`.<br />
  **Category:** App Rnd (app\_rnd)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  RANDU256
  ```

  #### `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.<br />Equivalent to `RANDU256` `256 MULRSHIFT`.<br />
  **Category:** App Rnd (app\_rnd)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  RAND
  ```

  #### `F814` SETRAND

  Sets the random seed to unsigned 256-bit *Integer* `x`.<br />
  **Category:** App Rnd (app\_rnd)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SETRAND
  ```

  #### `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`.<br />
  **Category:** App Rnd (app\_rnd)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  ADDRAND
  RANDOMIZE
  ```

  #### `F82i` GETPARAM

  Returns the `i`-th parameter from the *Tuple* provided at `c7` for `0 <= i <= 15`. Equivalent to `c7 PUSHCTR` `FIRST` `[i] INDEX`.<br />If one of these internal operations fails, throws an appropriate type checking or range checking exception.<br />
  **Category:** App Config (app\_config)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [i] GETPARAM
  ```

  **Aliases**:

  * `NOW`<br />
    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.<br />Equivalent to `3 GETPARAM`.
  * `BLOCKLT`<br />
    Returns the starting logical time of the current block.<br />Equivalent to `4 GETPARAM`.
  * `LTIME`<br />
    Returns the logical time of the current transaction.<br />Equivalent to `5 GETPARAM`.
  * `RANDSEED`<br />
    Returns the current random seed as an unsigned 256-bit *Integer*.<br />Equivalent to `6 GETPARAM`.
  * `BALANCE`<br />
    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'').<br />Equivalent to `7 GETPARAM`.<br />Note that `RAW` primitives such as `SENDRAWMSG` do not update this field.
  * `MYADDR`<br />
    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`.<br />Equivalent to `8 GETPARAM`.
  * `CONFIGROOT`<br />
    Returns the *Maybe Cell* `D` with the current global configuration dictionary. Equivalent to `9 GETPARAM `.
  * `MYCODE`<br />
    Retrieves code of smart-contract from c7. Equivalent to `10 GETPARAM `.
  * `INCOMINGVALUE`<br />
    Retrieves value of incoming message from c7. Equivalent to `11 GETPARAM `.
  * `STORAGEFEES`<br />
    Retrieves value of storage phase fees from c7. Equivalent to `12 GETPARAM `.
  * `PREVBLOCKSINFOTUPLE`<br />
    Retrives PrevBlocksInfo: `[last_mc_blocks, prev_key_block]` from c7. Equivalent to `13 GETPARAM `.
  * `UNPACKEDCONFIGTUPLE`<br />
    Retrives tuple that contains some config parameters as cell slices. If the parameter is absent from the config, the value is null. Values: <br />\* **0**: `StoragePrices` from `ConfigParam 18`. Not the whole dict, but only the one StoragePrices entry (one which corresponds to the current time).<br />  \* **1**: `ConfigParam 19` (global id).<br />  \* **2**: `ConfigParam 20` (mc gas prices).<br />  \* **3**: `ConfigParam 21` (gas prices).<br />  \* **4**: `ConfigParam 24` (mc fwd fees).<br />  \* **5**: `ConfigParam 25` (fwd fees).<br />  \* **6**: `ConfigParam 43` (size limits).
  * `DUEPAYMENT`<br />
    Retrives current debt for storage fee (nanotons).

  #### `F830` CONFIGDICT

  Returns the global configuration dictionary along with its key length (32).<br />Equivalent to `CONFIGROOT` `32 PUSHINT`.<br />
  **Category:** App Config (app\_config)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  CONFIGDICT
  ```

  #### `F832` CONFIGPARAM

  Returns the value of the global configuration parameter with integer index `i` as a *Cell* `c`, and a flag to indicate success.<br />Equivalent to `CONFIGDICT` `DICTIGETREF`.<br />
  **Category:** App Config (app\_config)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  CONFIGPARAM
  ```

  #### `F833` CONFIGOPTPARAM

  Returns the value of the global configuration parameter with integer index `i` as a *Maybe Cell* `c^?`.<br />Equivalent to `CONFIGDICT` `DICTIGETOPTREF`.<br />
  **Category:** App Config (app\_config)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  CONFIGOPTPARAM
  ```

  #### `F83400` PREVMCBLOCKS

  Retrives `last_mc_blocks` part of PrevBlocksInfo from c7 (parameter 13).<br />
  **Category:** App Config (app\_config)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PREVMCBLOCKS
  ```

  #### `F83401` PREVKEYBLOCK

  Retrives `prev_key_block` part of PrevBlocksInfo from c7 (parameter 13).<br />
  **Category:** App Config (app\_config)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PREVKEYBLOCK
  ```

  #### `F83402` PREVMCBLOCKS\_100

  Retrives `last_mc_blocks_divisible_by_100` part of PrevBlocksInfo from c7 (parameter 13).<br />
  **Category:** App Config (app\_config)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PREVMCBLOCKS_100
  ```

  #### `F835` GLOBALID

  Retrieves `global_id` from 19 network config.<br />
  **Category:** App Config (app\_config)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  GLOBALID
  ```

  #### `F836` GETGASFEE

  Calculates gas fee<br />
  **Category:** App Config (app\_config)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  GETGASFEE
  ```

  #### `F837` GETSTORAGEFEE

  Calculates storage fees (only current StoragePrices entry is used).<br />
  **Category:** App Config (app\_config)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  GETSTORAGEFEE
  ```

  #### `F838` GETFORWARDFEE

  Calculates forward fee.<br />
  **Category:** App Config (app\_config)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  GETFORWARDFEE
  ```

  #### `F839` GETPRECOMPILEDGAS

  Returns gas usage for the current contract if it is precompiled, `null` otherwise.<br />
  **Category:** App Config (app\_config)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  GETPRECOMPILEDGAS
  ```

  #### `F83A` GETORIGINALFWDFEE

  Calculate `(fwd_fee * 2^16) / (2^16 - first_frac)`. Can be used to get the original `fwd_fee` of the message.<br />
  **Category:** App Config (app\_config)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  GETORIGINALFWDFEE
  ```

  #### `F83B` GETGASFEESIMPLE

  Same as `GETGASFEE`, but without flat price (just `(gas_used * price) / 2^16)`.<br />
  **Category:** App Config (app\_config)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  GETGASFEESIMPLE
  ```

  #### `F83C` GETFORWARDFEESIMPLE

  Same as `GETFORWARDFEE`, but without lump price (just (`bits*bit_price + cells*cell_price) / 2^16`).<br />
  **Category:** App Config (app\_config)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  GETFORWARDFEESIMPLE
  ```

  #### `F840` GETGLOBVAR

  Returns the `k`-th global variable for `0 <= k < 255`.<br />Equivalent to `c7 PUSHCTR` `SWAP` `INDEXVARQ`.<br />
  **Category:** App Global (app\_global)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  GETGLOBVAR
  ```

  #### `F85_k` GETGLOB

  Returns the `k`-th global variable for `1 <= k <= 31`.<br />Equivalent to `c7 PUSHCTR` `[k] INDEXQ`.<br />
  **Category:** App Global (app\_global)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [k] GETGLOB
  ```

  #### `F860` SETGLOBVAR

  Assigns `x` to the `k`-th global variable for `0 <= k < 255`.<br />Equivalent to `c7 PUSHCTR` `ROTREV` `SETINDEXVARQ` `c7 POPCTR`.<br />
  **Category:** App Global (app\_global)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SETGLOBVAR
  ```

  #### `F87_k` SETGLOB

  Assigns `x` to the `k`-th global variable for `1 <= k <= 31`.<br />Equivalent to `c7 PUSHCTR` `SWAP` `k SETINDEXQ` `c7 POPCTR`.<br />
  **Category:** App Global (app\_global)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [k] SETGLOB
  ```

  #### `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).<br />
  **Category:** App Global (app\_global)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  GETEXTRABALANCE
  ```

  #### `F881ii` GETPARAMLONG

  Returns the `i`-th parameter from the *Tuple* provided at `c7` for `0 <= i <= 255`. Equivalent to `c7 PUSHCTR` `FIRST` `[i] INDEX`.<br />If one of these internal operations fails, throws an appropriate type checking or range checking exception.<br />
  **Category:** App Config (app\_config)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [i] GETPARAMLONG
  ```

  #### `F89i` INMSGPARAM

  Equivalent to `INMSGPARAMS` `i INDEX`<br />
  **Category:** App Config (app\_config)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [i] INMSGPARAM
  ```

  **Aliases**:

  * `INMSG_BOUNCE`<br />
    Retrives `bounce` flag of incoming message.
  * `INMSG_BOUNCED`<br />
    Retrives `bounced` flag of incoming message.
  * `INMSG_SRC`<br />
    Retrives `src` flag of incoming message.
  * `INMSG_FWDFEE`<br />
    Retrives `fwd_fee` field of incoming message.
  * `INMSG_LT`<br />
    Retrives `lt` field of incoming message.
  * `INMSG_UTIME`<br />
    Retrives `utime` field of incoming message.
  * `INMSG_ORIGVALUE`<br />
    Retrives original value of the message. This is sometimes different from the value in `INCOMINGVALUE` and TVM stack because of storage fees.
  * `INMSG_VALUE`<br />
    Retrives value of the message after deducting storage fees. This is same as in `INCOMINGVALUE` and TVM stack.
  * `INMSG_VALUEEXTRA`<br />
    Same as in `INCOMINGVALUE`.
  * `INMSG_STATEINIT`<br />
    Retrieves `init` field of the incoming message.

  #### `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.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  HASHCU
  ```

  #### `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`.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  HASHSU
  ```

  #### `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`.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SHA256U
  ```

  #### `F90400` HASHEXT\_SHA256

  Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  HASHEXT_SHA256
  ```

  #### `F90401` HASHEXT\_SHA512

  Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  HASHEXT_SHA512
  ```

  #### `F90402` HASHEXT\_BLAKE2B

  Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  HASHEXT_BLAKE2B
  ```

  #### `F90403` HASHEXT\_KECCAK256

  Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  HASHEXT_KECCAK256
  ```

  #### `F90404` HASHEXT\_KECCAK512

  Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  HASHEXT_KECCAK512
  ```

  #### `F90500` HASHEXTR\_SHA256

  Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  HASHEXTR_SHA256
  ```

  #### `F90501` HASHEXTR\_SHA512

  Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  HASHEXTR_SHA512
  ```

  #### `F90502` HASHEXTR\_BLAKE2B

  Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  HASHEXTR_BLAKE2B
  ```

  #### `F90503` HASHEXTR\_KECCAK256

  Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  HASHEXTR_KECCAK256
  ```

  #### `F90504` HASHEXTR\_KECCAK512

  Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  HASHEXTR_KECCAK512
  ```

  #### `F90600` HASHEXTA\_SHA256

  Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  HASHEXTA_SHA256
  ```

  #### `F90601` HASHEXTA\_SHA512

  Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  HASHEXTA_SHA512
  ```

  #### `F90602` HASHEXTA\_BLAKE2B

  Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  HASHEXTA_BLAKE2B
  ```

  #### `F90603` HASHEXTA\_KECCAK256

  Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  HASHEXTA_KECCAK256
  ```

  #### `F90604` HASHEXTA\_KECCAK512

  Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  HASHEXTA_KECCAK512
  ```

  #### `F90700` HASHEXTAR\_SHA256

  Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  HASHEXTAR_SHA256
  ```

  #### `F90701` HASHEXTAR\_SHA512

  Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  HASHEXTAR_SHA512
  ```

  #### `F90702` HASHEXTAR\_BLAKE2B

  Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  HASHEXTAR_BLAKE2B
  ```

  #### `F90703` HASHEXTAR\_KECCAK256

  Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  HASHEXTAR_KECCAK256
  ```

  #### `F90704` HASHEXTAR\_KECCAK512

  Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  HASHEXTAR_KECCAK512
  ```

  #### `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).<br />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.<br />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`.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  CHKSIGNU
  ```

  #### `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.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  CHKSIGNS
  ```

  #### `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`.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  ECRECOVER
  ```

  #### `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`).<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SECP256K1_XONLY_PUBKEY_TWEAK_ADD
  ```

  #### `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`).<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  P256_CHKSIGNU
  ```

  #### `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`).<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  P256_CHKSIGNS
  ```

  #### `F916` HASHBU

  Same as `ENDC HASHCU`, but without gas cost for cell creation.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  HASHBU
  ```

  #### `F920` RIST255\_FROMHASH

  Deterministically generates a valid point `x` from a 512-bit hash (given as two 256-bit integers).<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  RIST255_FROMHASH
  ```

  #### `F921` RIST255\_VALIDATE

  Checks that integer `x` is a valid representation of some curve point. Throws range\_chk on error.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  RIST255_VALIDATE
  ```

  #### `F922` RIST255\_ADD

  Addition of two points on a curve.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  RIST255_ADD
  ```

  #### `F923` RIST255\_SUB

  Subtraction of two points on curve.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  RIST255_SUB
  ```

  #### `F924` RIST255\_MUL

  Multiplies point `x` by a scalar `n`. Any `n` is valid, including negative.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  RIST255_MUL
  ```

  #### `F925` RIST255\_MULBASE

  Multiplies the generator point `g` by a scalar `n`. Any `n` is valid, including negative.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  RIST255_MULBASE
  ```

  #### `F926` RIST255\_PUSHL

  Pushes integer l=2^252+27742317777372353535851937790883648493, which is the order of the group.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  RIST255_PUSHL
  ```

  #### `B7F921` RIST255\_QVALIDATE

  Checks that integer `x` is a valid representation of some curve point. Returns -1 on success and 0 on failure.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  RIST255_QVALIDATE
  ```

  #### `B7F922` RIST255\_QADD

  Addition of two points on a curve. Returns -1 on success and 0 on failure.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  RIST255_QADD
  ```

  #### `B7F923` RIST255\_QSUB

  Subtraction of two points on curve. Returns -1 on success and 0 on failure.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  RIST255_QSUB
  ```

  #### `B7F924` RIST255\_QMUL

  Multiplies point `x` by a scalar `n`. Any `n` is valid, including negative. Returns -1 on success and 0 on failure.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  RIST255_QMUL
  ```

  #### `B7F925` RIST255\_QMULBASE

  Multiplies the generator point `g` by a scalar `n`. Any `n` is valid, including negative.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  RIST255_QMULBASE
  ```

  #### `F93000` BLS\_VERIFY

  Checks BLS signature, return true on success, false otherwise.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BLS_VERIFY
  ```

  #### `F93001` BLS\_AGGREGATE

  Aggregates signatures. `n>0`. Throw exception if `n=0` or if some `sig_i` is not a valid signature.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BLS_AGGREGATE
  ```

  #### `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`.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BLS_FASTAGGREGATEVERIFY
  ```

  #### `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`.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BLS_AGGREGATEVERIFY
  ```

  #### `F93010` BLS\_G1\_ADD

  Addition on G1.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BLS_G1_ADD
  ```

  #### `F93011` BLS\_G1\_SUB

  Subtraction on G1.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BLS_G1_SUB
  ```

  #### `F93012` BLS\_G1\_NEG

  Negation on G1.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BLS_G1_NEG
  ```

  #### `F93013` BLS\_G1\_MUL

  Multiplies G1 point `x` by scalar `s`. Any `s` is valid, including negative.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BLS_G1_MUL
  ```

  #### `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.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BLS_G1_MULTIEXP
  ```

  #### `F93015` BLS\_G1\_ZERO

  Pushes zero point in G1.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BLS_G1_ZERO
  ```

  #### `F93016` BLS\_MAP\_TO\_G1

  Converts FP element `f` to a G1 point.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BLS_MAP_TO_G1
  ```

  #### `F93017` BLS\_G1\_INGROUP

  Checks that slice `x` represents a valid element of G1.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BLS_G1_INGROUP
  ```

  #### `F93018` BLS\_G1\_ISZERO

  Checks that G1 point `x` is equal to zero.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BLS_G1_ISZERO
  ```

  #### `F93020` BLS\_G2\_ADD

  Addition on G2.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BLS_G2_ADD
  ```

  #### `F93021` BLS\_G2\_SUB

  Subtraction on G2.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BLS_G2_SUB
  ```

  #### `F93022` BLS\_G2\_NEG

  Negation on G2.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BLS_G2_NEG
  ```

  #### `F93023` BLS\_G2\_MUL

  Multiplies G2 point `x` by scalar `s`. Any `s` is valid, including negative.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BLS_G2_MUL
  ```

  #### `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.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BLS_G2_MULTIEXP
  ```

  #### `F93025` BLS\_G2\_ZERO

  Pushes zero point in G2.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BLS_G2_ZERO
  ```

  #### `F93026` BLS\_MAP\_TO\_G2

  Converts FP2 element `f` to a G2 point.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BLS_MAP_TO_G2
  ```

  #### `F93027` BLS\_G2\_INGROUP

  Checks that slice `x` represents a valid element of G2.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BLS_G2_INGROUP
  ```

  #### `F93028` BLS\_G2\_ISZERO

  Checks that G2 point `x` is equal to zero.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BLS_G2_ISZERO
  ```

  #### `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`.<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BLS_PAIRING
  ```

  #### `F93031` BLS\_PUSHR

  Pushes the order of G1 and G2 (approx. `2^255`).<br />
  **Category:** App Crypto (app\_crypto)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  BLS_PUSHR
  ```

  #### `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`.<br />
  **Category:** App Misc (app\_misc)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  CDATASIZEQ
  ```

  #### `F941` CDATASIZE

  A non-quiet version of `CDATASIZEQ` that throws a cell overflow exception (8) on failure.<br />
  **Category:** App Misc (app\_misc)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  CDATASIZE
  ```

  #### `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`.<br />
  **Category:** App Misc (app\_misc)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SDATASIZEQ
  ```

  #### `F943` SDATASIZE

  A non-quiet version of `SDATASIZEQ` that throws a cell overflow exception (8) on failure.<br />
  **Category:** App Misc (app\_misc)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SDATASIZE
  ```

  #### `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`.<br />The net effect is approximately equivalent to `4 LDU` `SWAP` `3 LSHIFT#` `LDUX`.<br />
  **Category:** App Currency (app\_currency)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDGRAMS
  LDVARUINT16
  ```

  #### `FA01` LDVARINT16

  Similar to `LDVARUINT16`, but loads a *signed* *Integer* `x`.<br />Approximately equivalent to `4 LDU` `SWAP` `3 LSHIFT#` `LDIX`.<br />
  **Category:** App Currency (app\_currency)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDVARINT16
  ```

  #### `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.<br />
  **Category:** App Currency (app\_currency)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STGRAMS
  STVARUINT16
  ```

  #### `FA03` STVARINT16

  Similar to `STVARUINT16`, but serializes a *signed* *Integer* `x` in the range `-2^119...2^119-1`.<br />
  **Category:** App Currency (app\_currency)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STVARINT16
  ```

  #### `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`.<br />The net effect is approximately equivalent to `4 LDU` `SWAP` `3 LSHIFT#` `LDUX`.<br />
  **Category:** App Currency (app\_currency)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDVARUINT32
  ```

  #### `FA05` LDVARINT32

  Similar to `LDVARUINT32`, but loads a *signed* *Integer* `x`.<br />Approximately equivalent to `5 LDU` `SWAP` `3 LSHIFT#` `LDIX`.<br />
  **Category:** App Currency (app\_currency)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDVARINT32
  ```

  #### `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.<br />
  **Category:** App Currency (app\_currency)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STVARUINT32
  ```

  #### `FA07` STVARINT32

  Similar to `STVARUINT32`, but serializes a *signed* *Integer* `x` in the range `-2^247...2^247-1`.<br />
  **Category:** App Currency (app\_currency)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STVARINT32
  ```

  #### `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.<br />
  **Category:** App Addr (app\_addr)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDMSGADDR
  ```

  #### `FA41` LDMSGADDRQ

  A quiet version of `LDMSGADDR`: on success, pushes an extra `-1`; on failure, pushes the original `s` and a zero.<br />
  **Category:** App Addr (app\_addr)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDMSGADDRQ
  ```

  #### `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.<br />
  **Category:** App Addr (app\_addr)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PARSEMSGADDR
  ```

  #### `FA43` PARSEMSGADDRQ

  A quiet version of `PARSEMSGADDR`: returns a zero on error instead of throwing an exception.<br />
  **Category:** App Addr (app\_addr)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  PARSEMSGADDRQ
  ```

  #### `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.<br />
  **Category:** App Addr (app\_addr)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  REWRITESTDADDR
  ```

  #### `FA45` REWRITESTDADDRQ

  A quiet version of primitive `REWRITESTDADDR`.<br />
  **Category:** App Addr (app\_addr)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  REWRITESTDADDRQ
  ```

  #### `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`.<br />
  **Category:** App Addr (app\_addr)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  REWRITEVARADDR
  ```

  #### `FA47` REWRITEVARADDRQ

  A quiet version of primitive `REWRITEVARADDR`.<br />
  **Category:** App Addr (app\_addr)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  REWRITEVARADDRQ
  ```

  #### `FA48` LDSTDADDR

  Loads `addr_std$10`, if address is not `addr_std`, throws an error 9 (`cannot load a MsgAddressInt`).<br />
  **Category:** App Addr (app\_addr)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDSTDADDR
  ```

  #### `FA49` LDSTDADDRQ

  A quiet version of primitive `LDSTDADDR`.<br />
  **Category:** App Addr (app\_addr)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDSTDADDRQ
  ```

  #### `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`).<br />
  **Category:** App Addr (app\_addr)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDOPTSTDADDR
  ```

  #### `FA51` LDOPTSTDADDRQ

  A quiet version of primitive `LDOPTSTDADDR`.<br />
  **Category:** App Addr (app\_addr)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  LDOPTSTDADDRQ
  ```

  #### `FA52` STSTDADDR

  Stores `addr_std$10`, if address is not `addr_std`, throws an error 9 (`cannot load a MsgAddressInt`).<br />
  **Category:** App Addr (app\_addr)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STSTDADDR
  ```

  #### `FA53` STSTDADDRQ

  A quiet version of primitive `STSTDADDR`.<br />
  **Category:** App Addr (app\_addr)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STSTDADDRQ
  ```

  #### `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`).<br />
  **Category:** App Addr (app\_addr)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STOPTSTDADDR
  ```

  #### `FA55` STOPTSTDADDRQ

  A quiet version of primitive `STOPTSTDADDR`.<br />
  **Category:** App Addr (app\_addr)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  STOPTSTDADDRQ
  ```

  #### `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`.<br />
  **Category:** App Actions (app\_actions)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SENDRAWMSG
  ```

  #### `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`.<br />
  **Category:** App Actions (app\_actions)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  RAWRESERVE
  ```

  #### `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.<br />
  **Category:** App Actions (app\_actions)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  RAWRESERVEX
  ```

  #### `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.<br />
  **Category:** App Actions (app\_actions)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SETCODE
  ```

  #### `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.<br />
  **Category:** App Actions (app\_actions)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SETLIBCODE
  ```

  #### `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.<br />
  **Category:** App Actions (app\_actions)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  CHANGELIB
  ```

  #### `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).<br />
  **Category:** App Actions (app\_actions)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SENDMSG
  ```

  #### `FEij` DEBUG

  <br />

  **Category:** Debug (debug)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  {i*16+j} DEBUG
  ```

  **Aliases**:

  * `DUMPSTK`<br />
    Dumps the stack (at most the top 255 values) and shows the total stack depth. Does nothing on production versions of TVM.
  * `STRDUMP`<br />
    Dumps slice with length divisible by 8 from top of stack as a string. Does nothing on production versions of TVM.
  * `DUMP`<br />
    Dumps slice with length divisible by 8 from top of stack as a string. Does nothing on production versions of TVM.

  #### `FEFnssss` DEBUGSTR

  `0 <= n < 16`. Length of `ssss` is `n+1` bytes.<br />`{string}` is a [string literal](https://github.com/Piterden/TON-docs/blob/master/Fift.%20A%20Brief%20Introduction.md#user-content-29-string-literals).<br />`DEBUGSTR`: `ssss` is the given string.<br />`DEBUGSTRI`: `ssss` is one-byte integer `0 <= x <= 255` followed by the given string.<br />
  **Category:** Debug (debug)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  {string} DEBUGSTR
  {string} {x} DEBUGSTRI
  ```

  #### `FFnn` SETCP

  Selects TVM codepage `0 <= nn < 240`. If the codepage is not supported, throws an invalid opcode exception.<br />
  **Category:** Codepage (codepage)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [nn] SETCP
  ```

  **Aliases**:

  * `SETCP0`<br />
    Selects TVM (test) codepage zero as described in this document.

  #### `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.<br />
  **Category:** Codepage (codepage)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  [z-16] SETCP
  ```

  #### `FFF0` SETCPX

  Selects codepage `c` with `-2^15 <= c < 2^15` passed in the top of the stack.<br />
  **Category:** Codepage (codepage)<br />

  ```fift Fift theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
  SETCPX
  ```
</div>