rea-agents 0.2.1

package/dist/contracts/toolContracts.js

@@ -0,0 +1,144 @@
+import { z } from "zod";
+import { evidenceBundleSchema } from "../domain/evidenceBundle.js";
+import { processCaptureSchema, processScenarioSchema, } from "../domain/processCapture.js";
+import { enhancedInputSchemas } from "./enhancedInputs.js";
+import { enhancedOutputSchemas, officialOutputSchemas, sessionOutputSchemas, } from "./toolOutputSchemas.js";
+const document = z.string().optional().describe("The document name");
+const address = z.string().describe("A Hopper address");
+const optionalAddress = address.optional();
+const procedure = z.string().describe("The procedure name or address");
+const pattern = z.string().describe("The regex pattern to search for");
+const caseSensitive = z
+    .boolean()
+    .default(false)
+    .describe("Whether to match case");
+const pagination = {
+    offset: z.number().int().min(0).default(0),
+    limit: z.number().int().min(1).max(500).default(100),
+};
+const annotations = (name, kind) => ({
+    readOnlyHint: kind === "enhanced" ||
+        name === "export_evidence_bundle" ||
+        (!name.startsWith("set_") &&
+            name !== "unset_bookmark" &&
+            name !== "goto_address" &&
+            kind !== "session"),
+    destructiveHint: name === "unset_bookmark" ||
+        name === "set_address_name" ||
+        name === "set_addresses_names" ||
+        name === "set_comment" ||
+        name === "set_inline_comment",
+    idempotentHint: true,
+    openWorldHint: false,
+});
+const official = (name, description, inputSchema) => ({
+    name,
+    description,
+    kind: "official-proxy",
+    inputSchema,
+    outputSchema: requireOutputSchema(officialOutputSchemas, name),
+    annotations: annotations(name, "official-proxy"),
+});
+const enhanced = (name, description, inputSchema) => ({
+    name,
+    description,
+    kind: "enhanced",
+    inputSchema,
+    outputSchema: requireOutputSchema(enhancedOutputSchemas, name),
+    annotations: annotations(name, "enhanced"),
+});
+const session = (name, description, inputSchema) => ({
+    name,
+    description,
+    kind: "session",
+    inputSchema,
+    outputSchema: requireOutputSchema(sessionOutputSchemas, name),
+    annotations: annotations(name, "session"),
+});
+const requireOutputSchema = (schemas, name) => {
+    const schema = schemas[name];
+    if (schema === undefined)
+        throw new Error(`Missing output schema for ${name}`);
+    return schema;
+};
+/** Bridge operations exposed without additional application composition. */
+export const OFFICIAL_TOOL_CONTRACTS = [
+    official("address_name", "Resolve the analyzed name at a code or data address, defaulting to Hopper's current cursor. Use before following a symbol into xrefs; null means Hopper has no name at that address.", z.object({ document, address: optionalAddress })),
+    official("comment", "Read the regular analysis comment at an address, defaulting to the current cursor. This is read-only and returns null when no comment exists; use set_comment to persist a finding.", z.object({ document, address: optionalAddress })),
+    official("current_address", "Return Hopper's current cursor address for the selected document. Use only for interactive navigation state; prefer explicit addresses in reproducible investigations.", z.object({ document })),
+    official("current_procedure", "Return the analyzed procedure containing Hopper's current cursor. Use procedure_info or analyze_function next; this depends on GUI cursor state and is not an exhaustive lookup.", z.object({ document })),
+    official("current_document", "Return the document currently selected by REA's Hopper bridge. Use list_documents before switching when several documents are open.", z.object({})),
+    official("goto_address", "Move Hopper's GUI cursor to a hexadecimal address and return the resolved address. This changes navigation state but not analysis data; use explicit-address tools for headless workflows.", z.object({ address, document })),
+    official("inline_comment", "Read the inline instruction comment at an address, defaulting to the current cursor. Returns null when absent; use set_inline_comment to write one.", z.object({ document, address: optionalAddress })),
+    official("list_bookmarks", "List every bookmark in the selected Hopper document as address and name pairs. Use bookmarks as analyst-authored navigation aids; this does not discover code references.", z.object({ document })),
+    official("list_documents", "List all Hopper documents visible to the bridge. Use before set_current_document when a provider session contains multiple documents.", z.object({})),
+    official("list_names", "Page through analyzed names as address/value pairs. Results are bounded by offset and limit; follow next_offset until has_more is false before claiming exhaustive symbol coverage.", z.object({ document, address: optionalAddress, ...pagination })),
+    official("list_procedures", "Page through analyzed procedures as address/value pairs. Wait for Hopper analysis first, then follow next_offset for exhaustive coverage; use returned addresses with analyze_function or procedure_pseudo_code.", z.object({ document, ...pagination })),
+    official("list_segments", "List all segments and sections in the selected document. Hopper's public API does not expose permissions, so writable and executable are null with explicit capability metadata.", z.object({ document })),
+    official("list_strings", "Page through analyzed strings, or filter to one address, as address/value pairs. Follow next_offset for exhaustive results and use xrefs on interesting string addresses.", z.object({ document, address: optionalAddress, ...pagination })),
+    official("next_address", "Return the next analyzed object address after an explicit address or current cursor. This is a navigation primitive, not instruction-flow or CFG analysis.", z.object({ document, address: optionalAddress })),
+    official("prev_address", "Return the previous analyzed instruction start before an explicit address or current cursor. This is a navigation primitive and may fail at document boundaries.", z.object({ document, address: optionalAddress })),
+    official("procedure_address", "Resolve a procedure symbol name or hexadecimal address to its entry address. Use this to canonicalize user-supplied identifiers before xrefs, assembly, or decompilation.", z.object({ procedure, document })),
+    official("procedure_assembly", "Return assembly for one analyzed procedure identified by symbol or hexadecimal address. Use when pseudocode loses calling-convention or instruction-level detail; output is currently returned as one unpaginated string.", z.object({ procedure, document })),
+    official("procedure_callees", "Return Hopper's analyzed direct callees for one procedure identified by symbol or address. Indirect calls may be absent; use analyze_function and xrefs to corroborate the call path.", z.object({ procedure, document })),
+    official("procedure_callers", "Return Hopper's analyzed direct callers for one procedure identified by symbol or address. Results reflect completed static analysis and may omit indirect references.", z.object({ procedure, document })),
+    official("procedure_info", "Return bounded metadata for one procedure identified by symbol or address: entrypoint, signature, locals, size, and block count. Follow with decompilation or assembly for behavior.", z.object({ procedure, document })),
+    official("procedure_references", "Return a bounded set of raw incoming or outgoing reference edges for one procedure. Endpoint procedures are resolved only when Hopper reports containment; reference kinds remain explicitly unavailable.", z.object({
+        procedure,
+        direction: z.enum(["incoming", "outgoing"]).default("outgoing"),
+        offset: z.number().int().min(0).default(0),
+        limit: z.number().int().min(1).max(500).default(100),
+        max_instructions: z.number().int().min(1).max(5000).default(500),
+        document,
+    })),
+    official("procedure_pseudo_code", "Decompile one analyzed procedure by symbol name or hexadecimal address. Returns Hopper pseudocode, not original source, and may return null; request procedure_assembly when instruction precision matters.", z.object({ procedure, document })),
+    official("resolve_containing_procedure", "Resolve an arbitrary address, including an xref source or interior instruction, to its Hopper-analyzed containing procedure. A negative result includes an explicit reason and is not guessed from nearby symbols.", z.object({ address, document })),
+    official("search_procedures", "Regex-search all analyzed procedure names with optional case sensitivity. The current bridge returns an unpaginated address/name map, so constrain patterns and use list_procedures for controlled exhaustive traversal.", z.object({ pattern, case_sensitive: caseSensitive, document })),
+    official("search_strings", "Regex-search all analyzed strings with optional case sensitivity. The current bridge is unpaginated and evaluates Python regex, so use narrow patterns and follow matches with xrefs.", z.object({ pattern, case_sensitive: caseSensitive, document })),
+    official("set_address_name", "Assign an analyst name to one hexadecimal address and report Hopper's boolean result. This mutates analysis metadata; read it back with address_name before relying on it.", z.object({ address, name: z.string(), document })),
+    official("set_addresses_names", "Assign analyst names to an address/name map and return per-address success booleans. This mutates analysis metadata; use for bounded batches and verify failures individually.", z.object({ names: z.record(z.string(), z.string()), document })),
+    official("set_bookmark", "Create or replace a bookmark at a hexadecimal address. This mutates navigation metadata; verify with list_bookmarks and do not treat bookmarks as binary evidence.", z.object({ address, name: z.string().optional(), document })),
+    official("set_comment", "Write a regular analysis comment at a hexadecimal address and return whether readback matched. This mutates the Hopper document; use comments to record evidence IDs or reasoning.", z.object({ address, comment: z.string(), document })),
+    official("set_current_document", "Select an already-open Hopper document by exact document name. This changes subsequent default-document routing; call list_documents first and prefer explicit document inputs where reproducibility matters.", z.object({ document: z.string() })),
+    official("set_inline_comment", "Write an inline instruction comment at a hexadecimal address and return whether readback matched. This mutates analysis metadata; confirm with inline_comment.", z.object({ address, comment: z.string(), document })),
+    official("unset_bookmark", "Remove the bookmark at a hexadecimal address and return whether it is absent. This mutates navigation metadata and does not alter binary bytes.", z.object({ address, document })),
+    official("xrefs", "Return analyzed references to a code or data address, defaulting to the current cursor. Use to connect strings, globals, selectors, and functions; bare addresses are untyped and indirect references may be incomplete.", z.object({ document, address: optionalAddress })),
+];
+/** Bounded workflows composed from one or more bridge operations. */
+export const ENHANCED_TOOL_CONTRACTS = [
+    enhanced("swift_classes", "Discover legacy-mangled Swift class procedures after exhaustively paging analyzed procedures. Returns at most 100 entries and scans at most 5,000 symbols; use analyze_swift_types for other Swift kinds.", enhancedInputSchemas.swift_classes),
+    enhanced("get_objc_classes", "Discover and deduplicate Objective-C class labels after exhaustively paging names, optionally filtering by literal substring. Returns at most 100 classes; inspect matching metadata and references next.", enhancedInputSchemas.get_objc_classes),
+    enhanced("get_objc_protocols", "Discover and deduplicate Objective-C and Swift protocol labels after exhaustively paging names. Returns at most 100 entries; use xrefs or analyze_function to connect a protocol to implementations.", enhancedInputSchemas.get_objc_protocols),
+    enhanced("batch_decompile", "Decompile up to 20 explicit procedure symbols or addresses concurrently. Per-item strings may contain errors or no-output markers, so validate each result; use analyze_function for a richer single-function dossier.", enhancedInputSchemas.batch_decompile),
+    enhanced("get_call_graph", "Traverse Hopper's caller or callee relationships from one symbol or address for at most five levels. Nodes preserve per-procedure errors; indirect calls may be missing and results are not a whole-program CFG.", enhancedInputSchemas.get_call_graph),
+    enhanced("analyze_swift_types", "Categorize exhaustively paged procedure names into Swift classes, structs, enums, protocols, extensions, and other symbols. Scans at most 5,000 names and returns at most 50 entries per category.", enhancedInputSchemas.analyze_swift_types),
+    enhanced("find_xrefs_to_name", "Resolve a name through Hopper and return analyzed references to its address. Use when starting from a selector or symbol; resolution failure is returned explicitly and xrefs remain untyped.", enhancedInputSchemas.find_xrefs_to_name),
+    enhanced("binary_overview", "Use immediately after opening a target to summarize document, exhaustive procedure/string counts, and a bounded segment sample. detail controls segment fields and limit controls only the returned segment sample.", enhancedInputSchemas.binary_overview),
+    enhanced("analyze_function", "Preferred bounded analysis for one procedure symbol or address. Returns identity, pseudocode, optional assembly, comments, calls, incoming references, and blocks; unsupported outgoing references and CFG edges carry explicit unavailable metadata.", enhancedInputSchemas.analyze_function),
+    enhanced("trace_feature", "Trace a bounded literal feature query through matching strings and procedures, xrefs, and truthful containing-procedure resolution. Returns the operation budget, truncation, and residual unknowns; it does not infer reference kinds.", enhancedInputSchemas.trace_feature),
+];
+/** Target lifecycle tools available only on the long-lived MCP adapter. */
+export const SESSION_TOOL_CONTRACTS = [
+    session("open_binary", "Open a local executable, application bundle, or Hopper database, replacing the active target only after validation. This launches Hopper and may show UI; call binary_overview after success.", z.object({ path: z.string().min(1) })),
+    session("close_binary", "Close the active Hopper-backed target and release its provider process. The operation is idempotent; call binary_session to verify the session is closed.", z.object({})),
+    session("binary_session", "Report whether a target is open and, when open, its canonical path, format, and kind. Use before analysis calls or target switches; this performs no analysis.", z.object({})),
+    session("export_evidence_bundle", "Return the session's deterministic Evidence v2 bundle without clearing it. Records are sorted by evidence ID, and array order carries no investigative meaning.", z.object({})),
+    session("import_evidence_bundle", "Validate and atomically merge a local Evidence v2 bundle supplied as data. Semantic IDs are recomputed; tampering, unsupported versions, conflicts, and ledger overflow reject the entire import.", z.object({ bundle: evidenceBundleSchema })),
+    session("capture_process_scenario", "Run one bounded process under a PTY using operator-approved executable and working roots. Requires approved: true on every call. Captures normalized terminal frames, sampled descendants, filesystem snapshots, and loopback HTTP/WebSocket replay. This launches a process and is disabled unless operator policy enables it; it is not a security sandbox.", processScenarioSchema),
+    session("compare_process_captures", "Compare two bounded process captures across terminal, exit, sampled process, filesystem, HTTP, and WebSocket evidence. Missing or truncated observations are never treated as equivalent.", z.object({
+        left_evidence_id: z.string().regex(/^ev_[a-f0-9]{64}$/u),
+        left: processCaptureSchema,
+        right_evidence_id: z.string().regex(/^ev_[a-f0-9]{64}$/u),
+        right: processCaptureSchema,
+    })),
+];
+/**
+ * Complete ordered public inventory used by registration and verification.
+ * Keep this collection at 50 tools unless a deliberate contract change updates
+ * snapshots, package verification, and real-Hopper verification together.
+ */
+export const TOOL_CONTRACTS = [
+    ...OFFICIAL_TOOL_CONTRACTS,
+    ...ENHANCED_TOOL_CONTRACTS,
+    ...SESSION_TOOL_CONTRACTS,
+];

package/dist/contracts/toolOutputSchemas.js

@@ -0,0 +1,267 @@
+import { z } from "zod";
+import { evidenceSchema } from "../domain/evidence.js";
+import { processCaptureSchema } from "../domain/processCapture.js";
+import { evidenceBundleSchema } from "../domain/evidenceBundle.js";
+const resultOf = (schema) => evidenceSchema.omit({ result: true }).extend({ result: schema });
+const lifecycleResultOf = (schema) => z.object({ result: schema });
+const comparisonStatus = z.enum([
+    "unchanged",
+    "added",
+    "removed",
+    "changed",
+    "truncated",
+    "unknown",
+]);
+const nullableText = z.string().nullable();
+const addressList = z.array(z.string());
+const addressedEntry = z.object({ address: z.string(), name: z.string() });
+const procedureIdentity = z.object({ address: z.string(), name: z.string() });
+const containingProcedureResolution = z.discriminatedUnion("found", [
+    z.object({
+        query_address: z.string(),
+        found: z.literal(true),
+        procedure: procedureIdentity,
+    }),
+    z.object({
+        query_address: z.string(),
+        found: z.literal(false),
+        procedure: z.null(),
+        reason: z.enum(["outside_segments", "not_in_procedure"]),
+    }),
+]);
+const unavailable = z.object({
+    available: z.literal(false),
+    reason: z.string(),
+});
+const bounded = (item) => z.object({
+    items: z.array(item),
+    total: z.number().int().min(0).nullable(),
+    returned: z.number().int().min(0),
+    truncated: z.boolean(),
+    next_offset: z.number().int().min(0).nullable(),
+});
+const pageOutput = z.object({
+    items: z.array(z.object({ address: z.string(), value: z.string() })),
+    offset: z.number().int().min(0),
+    limit: z.number().int().min(1),
+    total: z.number().int().min(0),
+    next_offset: z.number().int().min(0).nullable(),
+    has_more: z.boolean(),
+});
+const segmentOutput = resultOf(z.array(z.object({
+    name: z.string(),
+    start: z.string(),
+    end: z.string(),
+    writable: z.boolean().nullable(),
+    executable: z.boolean().nullable(),
+    permissions: unavailable,
+    sections: z.array(z.object({ name: z.string(), start: z.string(), end: z.string() })),
+})));
+const procedureInfoOutput = resultOf(z.object({
+    name: z.string(),
+    entrypoint: z.string(),
+    basicblock_count: z.number().int().min(0),
+    length: z.number().min(0),
+    signature: nullableText,
+    locals: z.array(z.json()),
+}));
+const symbolDiscoveryOutput = (property) => resultOf(z.object({
+    count: z.number().int().min(0),
+    [property]: z.array(addressedEntry),
+}));
+const graphNode = z.union([
+    z.object({ address: z.string(), calls: z.array(z.string()) }),
+    z.object({ address: z.string(), error: z.string() }),
+]);
+const referenceEdge = z.object({
+    source_address: z.string(),
+    target_address: z.string(),
+    source_procedure: procedureIdentity.nullable(),
+    target_procedure: procedureIdentity.nullable(),
+    kind: unavailable,
+});
+const referencedValue = z.object({
+    address: z.string(),
+    value: z.string(),
+    source_address: z.string(),
+});
+const functionDossierOutput = resultOf(z.object({
+    procedure: z.object({
+        address: z.string(),
+        name: z.string(),
+        signature: nullableText,
+        locals: z.array(z.json()),
+    }),
+    pseudocode: z.object({
+        text: z.string(),
+        total_chars: z.number().int().min(0),
+        returned_chars: z.number().int().min(0),
+        truncated: z.boolean(),
+        next_offset: z.number().int().min(0).nullable(),
+    }),
+    assembly: bounded(z.string()),
+    comments: bounded(z.object({
+        address: z.string(),
+        kind: z.enum(["comment", "inline"]),
+        text: z.string(),
+    })),
+    callers: bounded(procedureIdentity),
+    callees: bounded(procedureIdentity),
+    incoming_references: bounded(referenceEdge),
+    outgoing_references: bounded(referenceEdge),
+    referenced_strings: bounded(referencedValue),
+    referenced_names: bounded(referencedValue),
+    basic_blocks: bounded(z.object({
+        start: z.string(),
+        end: z.string(),
+        successors: z.array(z.string()),
+    })),
+    instruction_scan: z.object({
+        scanned: z.number().int().min(0),
+        truncated: z.boolean(),
+    }),
+}));
+/** Exact structured-content schemas for the direct Hopper operations. */
+export const officialOutputSchemas = {
+    address_name: resultOf(nullableText),
+    comment: resultOf(nullableText),
+    current_address: resultOf(z.string()),
+    current_procedure: resultOf(z.string()),
+    current_document: resultOf(z.string()),
+    goto_address: resultOf(z.string()),
+    inline_comment: resultOf(nullableText),
+    list_bookmarks: resultOf(z.array(addressedEntry)),
+    list_documents: resultOf(z.array(z.string())),
+    list_names: resultOf(pageOutput),
+    list_procedures: resultOf(pageOutput),
+    list_segments: segmentOutput,
+    list_strings: resultOf(pageOutput),
+    next_address: resultOf(z.string()),
+    prev_address: resultOf(z.string()),
+    procedure_address: resultOf(z.string()),
+    procedure_assembly: resultOf(z.string()),
+    procedure_callees: resultOf(addressList),
+    procedure_callers: resultOf(addressList),
+    procedure_info: procedureInfoOutput,
+    procedure_references: resultOf(z.object({
+        procedure: procedureIdentity,
+        direction: z.enum(["incoming", "outgoing"]),
+        references: bounded(z.object({
+            source_address: z.string(),
+            target_address: z.string(),
+            source_procedure: procedureIdentity.nullable(),
+            target_procedure: procedureIdentity.nullable(),
+            kind: unavailable,
+        })),
+        instructions_scanned: z.number().int().min(0),
+        instruction_scan_truncated: z.boolean(),
+    })),
+    procedure_pseudo_code: resultOf(nullableText),
+    resolve_containing_procedure: resultOf(containingProcedureResolution),
+    search_procedures: resultOf(z.record(z.string(), z.string())),
+    search_strings: resultOf(z.record(z.string(), z.string())),
+    set_address_name: resultOf(z.boolean()),
+    set_addresses_names: resultOf(z.record(z.string(), z.boolean())),
+    set_bookmark: resultOf(z.boolean()),
+    set_comment: resultOf(z.boolean()),
+    set_current_document: resultOf(z.string()),
+    set_inline_comment: resultOf(z.boolean()),
+    unset_bookmark: resultOf(z.boolean()),
+    xrefs: resultOf(addressList),
+};
+/** Exact structured-content schemas for composed analysis workflows. */
+export const enhancedOutputSchemas = {
+    swift_classes: symbolDiscoveryOutput("classes"),
+    get_objc_classes: symbolDiscoveryOutput("classes"),
+    get_objc_protocols: symbolDiscoveryOutput("protocols"),
+    batch_decompile: resultOf(z.union([
+        z.object({ error: z.literal("No addresses provided") }),
+        z.record(z.string(), z.string()),
+    ])),
+    get_call_graph: resultOf(z.record(z.string(), z.array(graphNode))),
+    analyze_swift_types: resultOf(z.object({
+        total: z.number().int().min(0),
+        categories: z.record(z.string(), z.object({
+            count: z.number().int().min(0),
+            items: z.array(addressedEntry),
+        })),
+    })),
+    find_xrefs_to_name: resultOf(z.union([
+        z.object({ xrefs: addressList }),
+        z.object({ error: z.string() }),
+    ])),
+    binary_overview: resultOf(z.object({
+        document: z.string(),
+        detail: z.enum(["concise", "detailed"]),
+        segments: z.array(z.object({
+            name: z.string(),
+            start: z.string(),
+            end: z.string(),
+            length: z.number().min(0).optional(),
+        })),
+        segment_count: z.number().int().min(0),
+        procedure_count: z.number().int().min(0),
+        string_count: z.number().int().min(0),
+    })),
+    analyze_function: functionDossierOutput,
+    trace_feature: resultOf(z.object({
+        query: z.string(),
+        search_mode: z.literal("literal"),
+        operations_used: z.number().int().min(0),
+        operation_budget: z.number().int().min(1),
+        matches: z.array(z.object({
+            type: z.enum(["string", "procedure"]),
+            address: z.string(),
+            value: z.string(),
+        })),
+        references: z.array(z.object({
+            target_address: z.string(),
+            source_address: z.string(),
+            containing_procedure: containingProcedureResolution,
+        })),
+        truncated: z.boolean(),
+        residual_unknowns: z.array(z.string()),
+    })),
+};
+/** Exact structured-content schemas for target lifecycle operations. */
+export const sessionOutputSchemas = {
+    open_binary: lifecycleResultOf(z.object({
+        path: z.string(),
+        format: z.enum(["hopper", "mach-o", "elf", "pe"]),
+        kind: z.enum(["executable", "database"]),
+        loaderArgs: z.array(z.string()),
+        sha256: z.string().regex(/^[a-f0-9]{64}$/u),
+        architecture: z.enum(["x86", "x86_64", "arm", "arm64"]).nullable(),
+    })),
+    close_binary: lifecycleResultOf(z.null()),
+    binary_session: lifecycleResultOf(z.union([
+        z.object({ open: z.literal(false) }),
+        z.object({
+            open: z.literal(true),
+            path: z.string(),
+            format: z.enum(["hopper", "mach-o", "elf", "pe"]),
+            kind: z.enum(["executable", "database"]),
+            sha256: z.string().regex(/^[a-f0-9]{64}$/u),
+            architecture: z.enum(["x86", "x86_64", "arm", "arm64"]).nullable(),
+        }),
+    ])),
+    export_evidence_bundle: lifecycleResultOf(evidenceBundleSchema),
+    import_evidence_bundle: lifecycleResultOf(z.object({
+        imported: z.number().int().min(0),
+        total: z.number().int().min(0),
+    })),
+    capture_process_scenario: lifecycleResultOf(evidenceSchema
+        .omit({ result: true })
+        .extend({ result: processCaptureSchema })),
+    compare_process_captures: lifecycleResultOf(evidenceSchema.omit({ result: true }).extend({
+        result: z.object({
+            status: comparisonStatus,
+            terminal: comparisonStatus,
+            exit: comparisonStatus,
+            filesystem: comparisonStatus,
+            protocol: comparisonStatus,
+            process: comparisonStatus,
+            limitations: z.array(z.string()),
+        }),
+    })),
+};