c64bridge 0.5.0

package/dist/loggingHttpClient.js

@@ -0,0 +1,88 @@
+import { HttpClient } from "../generated/c64/index.js";
+import { formatErrorMessage, formatPayloadForDebug, loggerFor, payloadByteLength } from "./logger.js";
+export function createLoggingHttpClient(config, logger = loggerFor("c64u")) {
+    const http = new HttpClient(config);
+    http.instance.interceptors.request.use((request) => {
+        const method = (request.method ?? "get").toUpperCase();
+        const path = resolvePath(request);
+        const meta = {
+            startedAt: Date.now(),
+            method,
+            path,
+            headers: request.headers ? { ...request.headers } : undefined,
+            params: request.params ? { ...request.params } : undefined,
+            body: request.data,
+        };
+        request.__c64Meta = meta;
+        return request;
+    });
+    http.instance.interceptors.response.use((response) => {
+        handleResponse(response, logger);
+        return response;
+    }, (error) => {
+        handleError(error, logger);
+        return Promise.reject(error);
+    });
+    return http;
+}
+function handleResponse(response, logger) {
+    const meta = extractMeta(response.config);
+    const latency = meta ? Date.now() - meta.startedAt : 0;
+    const method = meta?.method ?? (response.config.method ?? "get").toUpperCase();
+    const path = meta?.path ?? resolvePath(response.config);
+    const bytes = payloadByteLength(response.data);
+    logger.info(`${method} ${path} status=${response.status} bytes=${bytes} latencyMs=${latency}`);
+    if (logger.isDebugEnabled()) {
+        logger.debug(`request ${method} ${path}`, {
+            headers: meta?.headers,
+            query: meta?.params,
+            body: formatPayloadForDebug(meta?.body),
+        });
+        logger.debug(`response ${method} ${path}`, {
+            status: response.status,
+            headers: response.headers ?? {},
+            body: formatPayloadForDebug(response.data),
+        });
+    }
+}
+function handleError(error, logger) {
+    const config = error.config;
+    if (!config) {
+        logger.error(`UNKNOWN UNKNOWN status=ERR bytes=0 latencyMs=0 error=${formatErrorMessage(error)}`);
+        return;
+    }
+    const meta = extractMeta(config);
+    const latency = meta ? Date.now() - meta.startedAt : 0;
+    const method = meta?.method ?? (config.method ?? "get").toUpperCase();
+    const path = meta?.path ?? resolvePath(config);
+    const response = error.response;
+    const status = response?.status ?? "ERR";
+    const bytes = response ? payloadByteLength(response.data) : 0;
+    const message = formatErrorMessage(error);
+    logger.warn(`${method} ${path} status=${status} bytes=${bytes} latencyMs=${latency} error=${message}`);
+    if (logger.isDebugEnabled()) {
+        logger.debug(`request ${method} ${path}`, {
+            headers: meta?.headers,
+            query: meta?.params,
+            body: formatPayloadForDebug(meta?.body),
+        });
+        logger.debug(`error ${method} ${path}`, {
+            status,
+            headers: response?.headers ?? {},
+            body: response ? formatPayloadForDebug(response.data) : null,
+            message,
+        });
+    }
+}
+function extractMeta(config) {
+    const meta = config.__c64Meta;
+    delete config.__c64Meta;
+    return meta;
+}
+function resolvePath(config) {
+    if (config.url)
+        return config.url;
+    if (config.baseURL)
+        return config.baseURL;
+    return "UNKNOWN";
+}

package/dist/mcp-server.js

@@ -0,0 +1,426 @@
+#!/usr/bin/env node
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { loadConfig } from "./config.js";
+import { C64Client } from "./c64Client.js";
+import { listKnowledgeResources, readKnowledgeResource, } from "./rag/knowledgeIndex.js";
+import { initRag } from "./rag/init.js";
+import { toolRegistry } from "./tools/registry.js";
+import { unknownErrorResult } from "./tools/errors.js";
+import { createPromptRegistry } from "./prompts/registry.js";
+import { describePlatformCapabilities, getPlatformStatus, setPlatform } from "./platform.js";
+import axios from "axios";
+import { loggerFor, payloadByteLength, formatPayloadForDebug, formatErrorMessage } from "./logger.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PROJECT_ROOT = join(__dirname, "..");
+function parseCliOptions(argv) {
+    const httpIndex = argv.indexOf("--http");
+    if (httpIndex === -1) {
+        return { mode: "stdio" };
+    }
+    const portCandidate = argv[httpIndex + 1];
+    return { mode: "http", port: parsePort(portCandidate) };
+}
+function parsePort(raw) {
+    if (!raw || raw.startsWith("--")) {
+        return undefined;
+    }
+    const parsed = Number(raw);
+    if (Number.isInteger(parsed) && parsed > 0 && parsed <= 65535) {
+        return parsed;
+    }
+    return undefined;
+}
+async function main() {
+    console.error("Starting c64bridge MCP server...");
+    const config = loadConfig();
+    const baseUrl = config.baseUrl ?? `http://${config.c64_host}`;
+    // Initialize C64 client (reuse existing)
+    const client = new C64Client(baseUrl);
+    const rag = await initRag();
+    const toolLogger = loggerFor("tool");
+    const resourceLogger = loggerFor("resource");
+    const promptLogger = loggerFor("prompt");
+    const promptRegistry = createPromptRegistry();
+    // Create MCP server
+    const server = new Server({
+        name: "c64bridge",
+        version: "0.4.0",
+    }, {
+        capabilities: {
+            resources: {},
+            tools: {},
+            prompts: {},
+        },
+    });
+    // RESOURCES: Expose C64 knowledge base
+    server.setRequestHandler(ListResourcesRequestSchema, async () => {
+        const startedAt = Date.now();
+        try {
+            const knowledgeResources = listKnowledgeResources().map((resource) => ({
+                uri: resource.uri,
+                name: resource.name,
+                description: resource.description,
+                mimeType: resource.mimeType,
+                metadata: resource.metadata,
+            }));
+            const platformResource = createPlatformResourceDescriptor();
+            const response = {
+                resources: [...knowledgeResources, platformResource],
+            };
+            const latency = Date.now() - startedAt;
+            const bytes = payloadByteLength(response);
+            resourceLogger.info(`list resources count=${response.resources.length} bytes=${bytes} latencyMs=${latency}`);
+            if (resourceLogger.isDebugEnabled()) {
+                resourceLogger.debug("list resources request", { request: {} });
+                resourceLogger.debug("list resources response", { response: formatPayloadForDebug(response) });
+            }
+            return response;
+        }
+        catch (error) {
+            const latency = Date.now() - startedAt;
+            resourceLogger.error(`list resources failed bytes=0 latencyMs=${latency} error=${formatErrorMessage(error)}`);
+            if (resourceLogger.isDebugEnabled()) {
+                resourceLogger.debug("list resources request", { request: {} });
+                resourceLogger.debug("list resources error", { error: formatErrorMessage(error) });
+            }
+            throw error;
+        }
+    });
+    server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+        const startedAt = Date.now();
+        try {
+            let response;
+            if (request.params.uri === PLATFORM_RESOURCE_URI) {
+                response = {
+                    contents: [
+                        {
+                            uri: PLATFORM_RESOURCE_URI,
+                            mimeType: "text/markdown",
+                            text: renderPlatformStatusMarkdown(),
+                        },
+                    ],
+                };
+            }
+            else {
+                const result = readKnowledgeResource(request.params.uri, PROJECT_ROOT);
+                if (!result) {
+                    throw new Error(`Unknown resource: ${request.params.uri}`);
+                }
+                response = {
+                    contents: [result],
+                };
+            }
+            const latency = Date.now() - startedAt;
+            const bytes = payloadByteLength(response);
+            resourceLogger.info(`read resource uri=${request.params.uri} bytes=${bytes} latencyMs=${latency}`);
+            if (resourceLogger.isDebugEnabled()) {
+                resourceLogger.debug("read resource request", { request: formatPayloadForDebug(request.params) });
+                resourceLogger.debug("read resource response", { response: formatPayloadForDebug(response) });
+            }
+            return response;
+        }
+        catch (error) {
+            const latency = Date.now() - startedAt;
+            resourceLogger.error(`read resource uri=${request.params.uri} bytes=0 latencyMs=${latency} error=${formatErrorMessage(error)}`);
+            if (resourceLogger.isDebugEnabled()) {
+                resourceLogger.debug("read resource request", { request: formatPayloadForDebug(request.params) });
+                resourceLogger.debug("read resource error", { error: formatErrorMessage(error) });
+            }
+            throw error;
+        }
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        const startedAt = Date.now();
+        try {
+            const response = {
+                tools: toolRegistry.list(),
+            };
+            const latency = Date.now() - startedAt;
+            const bytes = payloadByteLength(response);
+            toolLogger.info(`list tools count=${response.tools.length} bytes=${bytes} latencyMs=${latency}`);
+            if (toolLogger.isDebugEnabled()) {
+                toolLogger.debug("list tools request", { request: {} });
+                toolLogger.debug("list tools response", { response: formatPayloadForDebug(response) });
+            }
+            return response;
+        }
+        catch (error) {
+            const latency = Date.now() - startedAt;
+            toolLogger.error(`list tools failed bytes=0 latencyMs=${latency} error=${formatErrorMessage(error)}`);
+            if (toolLogger.isDebugEnabled()) {
+                toolLogger.debug("list tools request", { request: {} });
+                toolLogger.debug("list tools error", { error: formatErrorMessage(error) });
+            }
+            throw error;
+        }
+    });
+    server.setRequestHandler(ListPromptsRequestSchema, async () => {
+        const startedAt = Date.now();
+        try {
+            const entries = promptRegistry.list();
+            const response = {
+                prompts: entries.map((entry) => ({
+                    name: entry.descriptor.name,
+                    title: entry.descriptor.title,
+                    description: entry.descriptor.description,
+                    arguments: entry.arguments?.map((argument) => ({
+                        name: argument.name,
+                        description: argument.description,
+                        required: argument.required,
+                        options: argument.options,
+                    })),
+                    _meta: {
+                        requiredResources: entry.descriptor.requiredResources,
+                        optionalResources: entry.descriptor.optionalResources ?? [],
+                        tools: entry.descriptor.tools,
+                        tags: entry.descriptor.tags ?? [],
+                    },
+                })),
+            };
+            const latency = Date.now() - startedAt;
+            const bytes = payloadByteLength(response);
+            promptLogger.info(`list prompts count=${response.prompts.length} bytes=${bytes} latencyMs=${latency}`);
+            if (promptLogger.isDebugEnabled()) {
+                promptLogger.debug("list prompts request", { request: {} });
+                promptLogger.debug("list prompts response", { response: formatPayloadForDebug(response) });
+            }
+            return response;
+        }
+        catch (error) {
+            const latency = Date.now() - startedAt;
+            promptLogger.error(`list prompts failed bytes=0 latencyMs=${latency} error=${formatErrorMessage(error)}`);
+            if (promptLogger.isDebugEnabled()) {
+                promptLogger.debug("list prompts request", { request: {} });
+                promptLogger.debug("list prompts error", { error: formatErrorMessage(error) });
+            }
+            throw error;
+        }
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name } = request.params;
+        const args = request.params.arguments ?? {};
+        const startedAt = Date.now();
+        if (toolLogger.isDebugEnabled()) {
+            toolLogger.debug("tool request", {
+                name,
+                arguments: formatPayloadForDebug(args),
+            });
+        }
+        try {
+            const result = await toolRegistry.invoke(name, args, {
+                client,
+                rag,
+                logger: toolLogger,
+                platform: getPlatformStatus(),
+                setPlatform,
+            });
+            const response = toCallToolResult(result);
+            const latency = Date.now() - startedAt;
+            const bytes = payloadByteLength(response);
+            const status = result.isError ? "error" : "ok";
+            toolLogger.info(`call tool name=${name} status=${status} bytes=${bytes} latencyMs=${latency}`);
+            if (toolLogger.isDebugEnabled()) {
+                toolLogger.debug("tool response", {
+                    name,
+                    response: formatPayloadForDebug(response),
+                });
+            }
+            return response;
+        }
+        catch (error) {
+            const latency = Date.now() - startedAt;
+            const fallback = unknownErrorResult(error);
+            const response = toCallToolResult(fallback);
+            const bytes = payloadByteLength(response);
+            toolLogger.error(`call tool name=${name} status=failed bytes=${bytes} latencyMs=${latency} error=${formatErrorMessage(error)}`);
+            if (toolLogger.isDebugEnabled()) {
+                toolLogger.debug("tool response", {
+                    name,
+                    response: formatPayloadForDebug(response),
+                    error: formatErrorMessage(error),
+                });
+            }
+            return response;
+        }
+    });
+    server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+        const { name } = request.params;
+        const args = request.params.arguments ?? {};
+        const startedAt = Date.now();
+        if (promptLogger.isDebugEnabled()) {
+            promptLogger.debug("prompt request", {
+                name,
+                arguments: formatPayloadForDebug(args),
+            });
+        }
+        try {
+            const resolved = promptRegistry.resolve(name, args);
+            const response = {
+                description: resolved.description,
+                messages: resolved.messages.map(toPromptMessage),
+                _meta: {
+                    arguments: resolved.arguments,
+                    resources: resolved.resources.map((resource) => ({
+                        uri: resource.uri,
+                        name: resource.name,
+                        description: resource.description,
+                        mimeType: resource.mimeType,
+                        metadata: resource.metadata,
+                    })),
+                    tools: resolved.tools,
+                },
+            };
+            const latency = Date.now() - startedAt;
+            const bytes = payloadByteLength(response);
+            promptLogger.info(`get prompt name=${name} bytes=${bytes} latencyMs=${latency}`);
+            if (promptLogger.isDebugEnabled()) {
+                promptLogger.debug("prompt response", {
+                    name,
+                    response: formatPayloadForDebug(response),
+                });
+            }
+            return response;
+        }
+        catch (error) {
+            const latency = Date.now() - startedAt;
+            promptLogger.error(`get prompt name=${name} bytes=0 latencyMs=${latency} error=${formatErrorMessage(error)}`);
+            if (promptLogger.isDebugEnabled()) {
+                promptLogger.debug("prompt request", {
+                    name,
+                    arguments: formatPayloadForDebug(args),
+                });
+                promptLogger.debug("prompt error", { name, error: formatErrorMessage(error) });
+            }
+            throw error;
+        }
+    });
+    // Connect via stdio
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    await logConnectivity(client, baseUrl);
+    console.error("c64bridge MCP server running on stdio");
+}
+const PLATFORM_RESOURCE_URI = "c64://platform/status";
+function createPlatformResourceDescriptor() {
+    return {
+        uri: PLATFORM_RESOURCE_URI,
+        name: "Active Platform Status",
+        description: "Reports the active MCP platform and tool compatibility snapshot.",
+        mimeType: "text/markdown",
+        metadata: {
+            domain: "platform",
+            priority: "critical",
+            summary: "Current platform (c64u or vice), feature flags, and tool support overview.",
+            prompts: [],
+            tools: [],
+            tags: ["platform", "compatibility"],
+            relatedResources: [],
+        },
+    };
+}
+function renderPlatformStatusMarkdown() {
+    const status = getPlatformStatus();
+    const capabilities = describePlatformCapabilities(toolRegistry.list());
+    const lines = [
+        "# MCP Platform Status",
+        "",
+        `Current platform: \`${status.id}\``,
+        "",
+        status.features.length > 0
+            ? ["## Active Features", "", ...status.features.map((feature) => `- ${feature}`)].join("\n")
+            : "",
+        status.limitedFeatures.length > 0
+            ? ["## Limited or Unavailable Features", "", ...status.limitedFeatures.map((feature) => `- ${feature}`)].join("\n")
+            : "",
+        "## Tool Compatibility",
+        "",
+    ].filter(Boolean);
+    for (const [platformId, info] of Object.entries(capabilities.platforms)) {
+        lines.push(`### ${platformId.toUpperCase()}`);
+        lines.push("");
+        lines.push(info.tools.length > 0
+            ? `- Supported tools (${info.tools.length}): ${info.tools.map((tool) => `\`${tool}\``).join(", ")}`
+            : "- Supported tools: _none_");
+        lines.push(info.unsupported_tools.length > 0
+            ? `- Unsupported tools (${info.unsupported_tools.length}): ${info.unsupported_tools
+                .map((tool) => `\`${tool}\``)
+                .join(", ")}`
+            : "- Unsupported tools: _none_");
+        lines.push("");
+    }
+    lines.push("> Switching platforms currently requires restarting the MCP server with an updated configuration.");
+    return lines.join("\n");
+}
+async function logConnectivity(client, baseUrl) {
+    const c64Logger = loggerFor("c64u");
+    const startedAt = Date.now();
+    let response = null;
+    try {
+        const probeResponse = await axios.get(baseUrl, { timeout: 2000 });
+        response = probeResponse;
+        const latency = Date.now() - startedAt;
+        const bytes = payloadByteLength(probeResponse.data);
+        c64Logger.info(`GET ${baseUrl} status=${probeResponse.status} bytes=${bytes} latencyMs=${latency}`);
+    }
+    catch (error) {
+        const latency = Date.now() - startedAt;
+        if (axios.isAxiosError(error)) {
+            const status = error.response?.status ?? "ERR";
+            const bytes = error.response ? payloadByteLength(error.response.data) : 0;
+            c64Logger.warn(`GET ${baseUrl} status=${status} bytes=${bytes} latencyMs=${latency} error=${formatErrorMessage(error)}`);
+        }
+        else {
+            c64Logger.error(`GET ${baseUrl} status=ERR bytes=0 latencyMs=${latency} error=${formatErrorMessage(error)}`);
+        }
+        console.log(`Skipping direct REST connectivity probe (no hardware REST base reachable at ${baseUrl})`);
+        return;
+    }
+    if (!response) {
+        console.log(`Skipping direct REST connectivity probe (no hardware REST base reachable at ${baseUrl})`);
+        return;
+    }
+    console.log(`Connectivity check succeeded for c64 device at ${baseUrl}`);
+    try {
+        const memoryAddress = "$0000";
+        const memoryResult = await client.readMemory(memoryAddress, "1");
+        if (memoryResult.success && memoryResult.data) {
+            console.log(`Zero-page probe @ ${memoryAddress}: ${memoryResult.data}`);
+        }
+        else if (memoryResult.details) {
+            console.warn(`Zero-page probe failed: ${JSON.stringify(memoryResult.details)}`);
+        }
+    }
+    catch (memoryError) {
+        const message = memoryError instanceof Error ? memoryError.message : String(memoryError);
+        console.warn(`Zero-page probe skipped or failed (may be unsupported on current backend): ${message}`);
+    }
+}
+function toCallToolResult(result) {
+    const base = { content: result.content };
+    if (result.structuredContent !== undefined) {
+        base.structuredContent = result.structuredContent;
+    }
+    if (result.metadata !== undefined) {
+        base.metadata = result.metadata;
+    }
+    return base;
+}
+function toPromptMessage(segment) {
+    const role = segment.role === "user" ? "user" : "assistant";
+    return {
+        role,
+        content: {
+            type: "text",
+            text: segment.content,
+        },
+    };
+}
+main().catch((error) => {
+    console.error("Fatal error in MCP server:", error);
+    process.exit(1);
+});

package/dist/petscii.js

@@ -0,0 +1,135 @@
+/*
+C64 Bridge - An MCP Server for the Commodore 64 Ultimate
+Copyright (C) 2025 Christian Gleissner
+
+Licensed under the GNU General Public License v2.0 or later.
+See <https://www.gnu.org/licenses/> for details.
+*/
+const PETSCII_TO_ASCII = {
+    0x00: " ",
+    0x07: "\u0007",
+    0x0d: "\n",
+    0x11: "\n",
+    0x8d: "\n",
+    0xa0: " ",
+};
+function petsciiByteToChar(byte) {
+    if (PETSCII_TO_ASCII[byte]) {
+        return PETSCII_TO_ASCII[byte];
+    }
+    if (byte >= 0x20 && byte <= 0x7e) {
+        return String.fromCharCode(byte);
+    }
+    if (byte >= 0xc1 && byte <= 0xda) {
+        return String.fromCharCode(byte - 0x80);
+    }
+    if (byte >= 0x41 && byte <= 0x5a) {
+        return String.fromCharCode(byte);
+    }
+    return " ";
+}
+export function petsciiToAscii(bytes) {
+    return Array.from(bytes)
+        .map(petsciiByteToChar)
+        .join("");
+}
+/**
+ * Minimal ASCII→PETSCII mapping used by the encoder.
+ * For now we pass through printable ASCII and a handful of control codes.
+ */
+export function asciiToPetscii(char) {
+    if (char.length !== 1) {
+        throw new Error("Expected a single character");
+    }
+    const code = char.charCodeAt(0);
+    if (code < 0 || code > 255) {
+        throw new Error(`Character out of PETSCII range: ${char}`);
+    }
+    return code;
+}
+/** Named PETSCII and control codes that are commonly used on the C64. */
+const NAMED_CHARS = Object.freeze({
+    // Control characters (BASIC CHR$ values)
+    "clear": 147, // CLR/HOME (clears screen)
+    "clr": 147,
+    "home": 19,
+    "bell": 7,
+    "beep": 7,
+    "newline": 13,
+    "return": 13,
+    "cr": 13,
+    "lf": 10,
+    "reverse_on": 18,
+    "rvon": 18,
+    "reverse_off": 146,
+    "rvoff": 146,
+    "cursor_up": 145,
+    "cursor_down": 17,
+    "cursor_right": 29,
+    "cursor_left": 157,
+    // Graphic glyphs (commonly referenced by name)
+    // Note: Exact byte shown on screen depends on mode; these are PETSCII/CHR$ values
+    "heart": 81, // widely used PETSCII code for heart glyph
+    "up_arrow": 94,
+    "uparrow": 94,
+    "left_arrow": 95,
+    "leftarrow": 95,
+    "pi": 222,
+});
+export function listNamedPetscii() {
+    return Object.entries(NAMED_CHARS)
+        .sort((a, b) => a[0].localeCompare(b[0]))
+        .map(([name, code]) => ({ name, code, hex: `$${code.toString(16).toUpperCase().padStart(2, "0")}` }));
+}
+export function lookupNamedPetscii(name) {
+    const key = name.trim().toLowerCase().replace(/\s+/g, "_");
+    return NAMED_CHARS[key];
+}
+/**
+ * Try to parse a named character token starting at the given index.
+ * Supported forms: {name}, :name:, <name>
+ * Returns the PETSCII code and index of the first character AFTER the token
+ * when matched, otherwise null.
+ */
+export function parseNamedCharToken(source, startIndex) {
+    const open = source[startIndex];
+    if (open !== "{" && open !== ":" && open !== "<") {
+        return null;
+    }
+    const close = open === "{" ? "}" : open === ":" ? ":" : ">";
+    let idx = startIndex + 1;
+    let name = "";
+    while (idx < source.length && source[idx] !== close) {
+        name += source[idx]
+            .replace(/[^A-Za-z0-9_\s-]/g, "") // restrict to sane name characters
+            .trim();
+        idx += 1;
+    }
+    if (idx >= source.length || source[idx] !== close) {
+        return null;
+    }
+    const value = lookupNamedPetscii(name.replace(/[-\s]+/g, "_"));
+    if (value === undefined) {
+        return null;
+    }
+    return { value, endIndex: idx + 1 };
+}
+/**
+ * Encode a text containing optional named tokens into PETSCII bytes.
+ * Named tokens may appear as {heart}, :heart:, or <heart>.
+ */
+export function encodeStringWithNames(input) {
+    const bytes = [];
+    let i = 0;
+    while (i < input.length) {
+        const maybe = parseNamedCharToken(input, i);
+        if (maybe) {
+            bytes.push(maybe.value & 0xff);
+            i = maybe.endIndex;
+            continue;
+        }
+        bytes.push(asciiToPetscii(input[i]));
+        i += 1;
+    }
+    return Uint8Array.from(bytes);
+}