diff --git a/content/learning-paths/mobile-graphics-and-gaming/swin2sr-vgf/1-prepare-environment.md b/content/learning-paths/mobile-graphics-and-gaming/swin2sr-vgf/1-prepare-environment.md new file mode 100644 index 0000000000..67e757b0dc --- /dev/null +++ b/content/learning-paths/mobile-graphics-and-gaming/swin2sr-vgf/1-prepare-environment.md @@ -0,0 +1,82 @@ +--- +title: Prepare your environment and image +description: Install the Swin2SR example and Arm ML SDK, then prepare a 64 × 64 input image and its high-resolution reference. +weight: 2 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +## What you'll build + +You will upscale a low-resolution image using Swin2SR, a pretrained image super-resolution model. It predicts finer detail as it doubles the image's width and height. + +You export the model with ExecuTorch, then run it through the Arm Vulkan Graph Format (VGF) backend. The result is a PNG image you can open and compare with a high-resolution reference. + +![Equal-size views compare a 64 by 64 low-resolution input with its 128 by 128 Swin2SR output. The input is enlarged for display only; labels show actual pixel dimensions. ExecuTorch and Arm VGF run the model on the host.#center](swin2sr-image-flow.svg "Images shown at the same display size to compare detail; labels show actual resolution") + +This workflow runs on your Linux host using the Arm ML SDK's Vulkan emulation layer. It introduces the model execution flow used by Arm neural graphics; it doesn't deploy an application to a phone or measure Mali GPU performance. + +## Install the example + +Use a 64-bit Linux system (AArch64 or x86_64) with a working Vulkan 1.3 GPU driver. The packaged ML SDK checks for the `shaderFloat64` feature, even though you export a floating-point 32-bit model. The setup script stops if your GPU doesn't support it. Apple Silicon with MoltenVK needs a separate source-built SDK, which isn't covered here. + +Have Python 3.12 with development headers and virtual environment support, Git, `curl`, `xz-utils`, a C++17 compiler, and [CMake 3.24–3.x](/install-guides/cmake/) available before continuing. On Ubuntu 24.04, the Python packages are `python3.12`, `python3.12-dev`, and `python3.12-venv`. + +From a directory without an existing `executorch` folder, clone upstream ExecuTorch and select the revision containing this example. Keep the checkout folder named `executorch`; the build requires this exact name: + +```bash +git clone https://github.com/pytorch/executorch.git +cd executorch +git checkout 32a86b69388b5a5208e367a96b0f5b7cb39df8e2 +``` + +Create a Python environment and install ExecuTorch and the example's dependencies: + +```bash +python3.12 -m venv .venv +source .venv/bin/activate +python -m pip install --upgrade pip +./install_executorch.sh --minimal +python -m pip install -r examples/arm/super_resolution_example_vgf/requirements.txt +``` + +Confirm that the installation succeeded before continuing: + +```bash +python -c "import executorch.exir; from executorch.extension.pybindings import portable_lib; print('ExecuTorch is ready')" +``` + +Install the Arm ML SDK dependencies and activate their paths: + +```bash +./examples/arm/setup.sh \ + --disable-ethos-u-deps \ + --disable-cortex-m-deps \ + --enable-mlsdk-deps +source examples/arm/arm-scratch/setup_path.sh +``` + +The setup script installs the Vulkan SDK and the tools that compile and execute VGF graphs. Keep this terminal open and run the remaining commands from the `executorch` directory. + +## Prepare the input image + +Create the example images from a screenshot included in ExecuTorch: + +```bash +python examples/arm/super_resolution_example_vgf/model_export/prepare_demo_assets.py \ + --output-dir swin2sr-work +``` + +The script creates a 128 × 128 crop and downsizes a copy to 64 × 64. You use these two files: + +| File in `swin2sr-work/runtime/` | What it is | +| --- | --- | +| `demo_lr_64.png` | Small image you give to the model | +| `demo_hr_128.png` | High-resolution reference: the original crop before downsampling | + +The helper also prepares calibration and evaluation folders. You don't need them for this floating-point walkthrough. + +## What you've accomplished and what's next + +You have the example, its tools, and a small input image with a high-resolution reference. Next, export Swin2SR as an ExecuTorch program. diff --git a/content/learning-paths/mobile-graphics-and-gaming/swin2sr-vgf/2-export-model.md b/content/learning-paths/mobile-graphics-and-gaming/swin2sr-vgf/2-export-model.md new file mode 100644 index 0000000000..6ea07ed64a --- /dev/null +++ b/content/learning-paths/mobile-graphics-and-gaming/swin2sr-vgf/2-export-model.md @@ -0,0 +1,45 @@ +--- +title: Export Swin2SR for Arm VGF +description: Convert the pretrained Swin2SR ×2 model into a floating-point ExecuTorch program with Arm VGF. +weight: 3 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +## Export the pretrained model + +You don't need to train Swin2SR. The exporter downloads the pretrained ×2 checkpoint and converts it into an ExecuTorch `.pte` program. The pinned checkpoint revision keeps the model weights consistent between runs. + +Run the exporter from your ExecuTorch directory: + +```bash +python examples/arm/super_resolution_example_vgf/model_export/export_super_resolution.py \ + --model-name swin2sr \ + --checkpoint caidas/swin2SR-classical-sr-x2-64 \ + --checkpoint-revision cee1c923c6a37361c6e5650b65dcf4be821e5d52 \ + --input-height 64 \ + --input-width 64 \ + --quantization-mode none \ + --output-path swin2sr-work/swin2sr.pte +``` + +The first run downloads the model weights. `--quantization-mode none` keeps floating-point calculations, so you don't need calibration images. + +The `64` dimensions fix the input size for this export. The model produces a 128 × 128 image because the checkpoint upscales by two. + +## Keep the program and metadata together + +After export finishes, check the two files the runner needs: + +```bash +ls -lh swin2sr-work/swin2sr.pte swin2sr-work/swin2sr.json +``` + +`swin2sr.pte` contains the executable model, including its VGF graphs. `swin2sr.json` tells the image helper how to read the input and reconstruct the output. Keep both files in the same directory with the same base name. + +The exporter also saves `swin2sr_delegation.txt`. It records which operations run through VGF and which remain in ExecuTorch. You don't need to change this report to run the example. + +## What you've accomplished and what's next + +You have a floating-point Swin2SR program configured for one 64 × 64 RGB image. Next, build the host runner and use it to upscale your image. diff --git a/content/learning-paths/mobile-graphics-and-gaming/swin2sr-vgf/3-run-model.md b/content/learning-paths/mobile-graphics-and-gaming/swin2sr-vgf/3-run-model.md new file mode 100644 index 0000000000..407edeab5c --- /dev/null +++ b/content/learning-paths/mobile-graphics-and-gaming/swin2sr-vgf/3-run-model.md @@ -0,0 +1,48 @@ +--- +title: Run Swin2SR on your image +description: Build the VGF host runner and use the exported Swin2SR program to save a 128 × 128 image. +weight: 4 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +## Build the host runner + +ExecuTorch's `executor_runner` loads your `.pte` program and executes it. Continue from the same terminal in your `executorch` directory. + +If you opened a new terminal, restore the environment first: + +```bash +source .venv/bin/activate +source examples/arm/arm-scratch/setup_path.sh +``` + +Use the repository's build script to enable VGF and the runtime libraries it needs: + +```bash +bash backends/arm/scripts/build_executor_runner_vkml.sh \ + --output=swin2sr-work/build +``` + +This builds a Release executable at `swin2sr-work/build/executor_runner`. You only need to build it once for this walkthrough. + +## Upscale the image + +Run the image helper with your exported program, the host runner, and the 64 × 64 input: + +```bash +python examples/arm/super_resolution_example_vgf/runtime/run_super_resolution.py \ + --model-path swin2sr-work/swin2sr.pte \ + --runner swin2sr-work/build/executor_runner \ + --input-image swin2sr-work/runtime/demo_lr_64.png \ + --output-image swin2sr-work/runtime/demo_sr_128.png +``` + +The helper converts the image into a tensor, runs the model, and saves the output tensor as a PNG. A successful run ends with `Saved super-resolved image to` followed by the full path to `demo_sr_128.png`. + +Your input must be exactly 64 × 64 pixels. If you see an `expected (1, 3, 64, 64)` error, check that you used `demo_lr_64.png`, not the larger reference image. + +## What you've accomplished and what's next + +You have executed the exported program and saved its 128 × 128 output. Next, open the result and compare it with the input and high-resolution reference. diff --git a/content/learning-paths/mobile-graphics-and-gaming/swin2sr-vgf/4-inspect-result.md b/content/learning-paths/mobile-graphics-and-gaming/swin2sr-vgf/4-inspect-result.md new file mode 100644 index 0000000000..fc14eacea2 --- /dev/null +++ b/content/learning-paths/mobile-graphics-and-gaming/swin2sr-vgf/4-inspect-result.md @@ -0,0 +1,64 @@ +--- +title: Inspect the upscaled image +description: Verify the Swin2SR output size and compare the generated image with the low-resolution input and high-resolution reference. +weight: 5 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +## Check the image dimensions + +Confirm that the input is 64 × 64 and that the model created a 128 × 128 RGB image: + +```bash +python - <<'PY' +from PIL import Image + +for name in ("demo_lr_64.png", "demo_sr_128.png", "demo_hr_128.png"): + with Image.open(f"swin2sr-work/runtime/{name}") as image: + print(f"{name}: {image.width} x {image.height}, {image.mode}") +PY +``` + +The expected output is: + +```output +demo_lr_64.png: 64 x 64, RGB +demo_sr_128.png: 128 x 128, RGB +demo_hr_128.png: 128 x 128, RGB +``` + +Twice the width and twice the height give you four times as many pixels. + +## Compare the images + +Open `swin2sr-work/runtime/` in your image viewer. Compare the low-resolution input, the Swin2SR output, and the high-resolution reference. Enlarge the input to the same display size so you can compare the same text and edges. + +The high-resolution reference is the original 128 × 128 crop, before downsampling creates the 64 × 64 input. You keep it for comparison; the model receives only the low-resolution input. + +![Low-resolution input enlarged for display, an actual Swin2SR output from an earlier run, and the high-resolution reference at the same display size. Compare letter edges to see reconstructed detail and remaining differences.#center](swin2sr-result-comparison.png "Low-resolution input, Swin2SR output, and high-resolution reference at the same display size") + +The example output shown here comes from an earlier run with the same checkpoint and demo image. It illustrates the comparison; it isn't a new measurement on your host. + +Look at the edges of the letters. The output estimates detail that was lost when the original was reduced to 64 × 64. It won't reproduce every detail of the original, and a larger image doesn't automatically mean a more accurate one. + +Your end-to-end flow succeeds when the runner finishes, the generated image has the expected dimensions, and it shows the same scene without obvious corruption. This visual check doesn't establish a quality benchmark or a performance result. + +## Try another image + +Use another 64 × 64 RGB image with the same program. Replace `my-image.png` with its path and choose a new output name: + +```bash +python examples/arm/super_resolution_example_vgf/runtime/run_super_resolution.py \ + --model-path swin2sr-work/swin2sr.pte \ + --runner swin2sr-work/build/executor_runner \ + --input-image my-image.png \ + --output-image swin2sr-work/runtime/my-image-sr.png +``` + +For a different input size, export a matching program first. The helper doesn't resize or tile images automatically. + +## What you've accomplished + +You have prepared an image, exported a pretrained Swin2SR model, run it through Arm VGF with ExecuTorch, and inspected the upscaled output. You can now repeat the same flow with your own 64 × 64 images. diff --git a/content/learning-paths/mobile-graphics-and-gaming/swin2sr-vgf/_index.md b/content/learning-paths/mobile-graphics-and-gaming/swin2sr-vgf/_index.md new file mode 100644 index 0000000000..4ecddb8ee6 --- /dev/null +++ b/content/learning-paths/mobile-graphics-and-gaming/swin2sr-vgf/_index.md @@ -0,0 +1,74 @@ +--- +title: Upscale an image with Swin2SR and Arm VGF + +draft: true +cascade: + draft: true + +description: Export Swin2SR with ExecuTorch and run it through Arm VGF on your Linux host to upscale a low-resolution image and reconstruct finer detail. + +minutes_to_complete: 60 +lastmod: 2026-09-14 + +who_is_this_for: This is an introductory topic for machine learning and graphics developers who want to run image super-resolution with ExecuTorch and Arm VGF. + +learning_objectives: + - Prepare ExecuTorch, the Arm ML SDK for Vulkan, and a sample image + - Export a pretrained Swin2SR model as a VGF-backed ExecuTorch program + - Build the host runner and upscale a 64 × 64 image to 128 × 128 + - Check the output dimensions and compare the result with the high-resolution reference + +prerequisites: + - A 64-bit Linux host (AArch64 or x86_64) with a Vulkan 1.3 GPU and driver that support shaderFloat64, as required by the packaged ML SDK emulation layer + - Python 3.12 with development headers and venv support, Git, curl, xz-utils, CMake 3.24–3.x, and a C++17 compiler + - An internet connection to download ExecuTorch, model weights, and the Arm ML SDK dependencies + - Basic familiarity with Python and command-line tools + +author: Usamah Zaheer + +generate_summary_faq: true +rerun_summary: false +rerun_faqs: false + +### Tags +skilllevels: Introductory +subjects: ML +armips: + - Mali +tools_software_languages: + - ExecuTorch + - PyTorch + - Python + - Vulkan + - VGF +operatingsystems: + - Linux + +further_reading: + - resource: + title: Swin2SR VGF example source + link: https://github.com/pytorch/executorch/tree/32a86b69388b5a5208e367a96b0f5b7cb39df8e2/examples/arm/super_resolution_example_vgf + type: code + - resource: + title: Swin2SR pretrained model + link: https://huggingface.co/caidas/swin2SR-classical-sr-x2-64 + type: website + - resource: + title: Arm ML SDK for Vulkan + link: https://github.com/arm/ai-ml-sdk-for-vulkan + type: documentation + - resource: + title: Prepare models for neural graphics with Arm neural technology + link: /learning-paths/mobile-graphics-and-gaming/preparing-models-for-nt/ + type: learningpath + - resource: + title: Quantize neural upscaling models with ExecuTorch + link: /learning-paths/mobile-graphics-and-gaming/quantize-neural-upscaling-models/ + type: learningpath + +### FIXED, DO NOT MODIFY +# ================================================================================ +weight: 1 +layout: "learningpathall" +learning_path_main_page: "yes" +--- diff --git a/content/learning-paths/mobile-graphics-and-gaming/swin2sr-vgf/_next-steps.md b/content/learning-paths/mobile-graphics-and-gaming/swin2sr-vgf/_next-steps.md new file mode 100644 index 0000000000..e20dfa6d43 --- /dev/null +++ b/content/learning-paths/mobile-graphics-and-gaming/swin2sr-vgf/_next-steps.md @@ -0,0 +1,8 @@ +--- +# ================================================================================ +# FIXED, DO NOT MODIFY THIS FILE +# ================================================================================ +weight: 21 +title: "Next Steps" +layout: "learningpathall" +--- diff --git a/content/learning-paths/mobile-graphics-and-gaming/swin2sr-vgf/swin2sr-image-flow.excalidraw b/content/learning-paths/mobile-graphics-and-gaming/swin2sr-vgf/swin2sr-image-flow.excalidraw new file mode 100644 index 0000000000..74c11c25c8 --- /dev/null +++ b/content/learning-paths/mobile-graphics-and-gaming/swin2sr-vgf/swin2sr-image-flow.excalidraw @@ -0,0 +1,587 @@ +{ + "type": "excalidraw", + "version": 2, + "source": "null", + "elements": [ + { + "id": "title", + "type": "text", + "x": 40, + "y": 18, + "width": 520.2421875, + "height": 41.4, + "angle": 0, + "strokeColor": "#17324d", + "backgroundColor": "transparent", + "fillStyle": "solid", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 0, + "opacity": 100, + "groupIds": [], + "frameId": null, + "roundness": null, + "seed": 7321, + "version": 1, + "versionNonce": 9121, + "isDeleted": false, + "boundElements": null, + "updated": 1789395495529, + "link": null, + "locked": false, + "text": "Upscale an image with Swin2SR", + "fontSize": 36, + "fontFamily": 2, + "textAlign": "left", + "verticalAlign": "top", + "baseline": 33, + "containerId": null, + "originalText": "Upscale an image with Swin2SR", + "lineHeight": 1.15 + }, + { + "id": "subtitle", + "type": "text", + "x": 40, + "y": 66, + "width": 546.1181640625, + "height": 28.749999999999996, + "angle": 0, + "strokeColor": "#495866", + "backgroundColor": "transparent", + "fillStyle": "solid", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 0, + "opacity": 100, + "groupIds": [], + "frameId": null, + "roundness": null, + "seed": 7322, + "version": 1, + "versionNonce": 9122, + "isDeleted": false, + "boundElements": null, + "updated": 1789395495529, + "link": null, + "locked": false, + "text": "Same display size; input enlarged for comparison", + "fontSize": 25, + "fontFamily": 2, + "textAlign": "left", + "verticalAlign": "top", + "baseline": 22, + "containerId": null, + "originalText": "Same display size; input enlarged for comparison", + "lineHeight": 1.15 + }, + { + "id": "input-card", + "type": "rectangle", + "x": 40, + "y": 115, + "width": 282, + "height": 342, + "angle": 0, + "strokeColor": "#c7d6df", + "backgroundColor": "#f5f8fa", + "fillStyle": "solid", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 0, + "opacity": 100, + "groupIds": [], + "frameId": null, + "roundness": { + "type": 3 + }, + "seed": 7323, + "version": 1, + "versionNonce": 9123, + "isDeleted": false, + "boundElements": null, + "updated": 1789395495529, + "link": null, + "locked": false + }, + { + "id": "output-card", + "type": "rectangle", + "x": 800, + "y": 115, + "width": 282, + "height": 342, + "angle": 0, + "strokeColor": "#b9d8c8", + "backgroundColor": "#f1f8f4", + "fillStyle": "solid", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 0, + "opacity": 100, + "groupIds": [], + "frameId": null, + "roundness": { + "type": 3 + }, + "seed": 7324, + "version": 1, + "versionNonce": 9124, + "isDeleted": false, + "boundElements": null, + "updated": 1789395495529, + "link": null, + "locked": false + }, + { + "id": "input-label", + "type": "text", + "x": 77, + "y": 139, + "width": 205.84326171875, + "height": 26.45, + "angle": 0, + "strokeColor": "#17324d", + "backgroundColor": "transparent", + "fillStyle": "solid", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 0, + "opacity": 100, + "groupIds": [], + "frameId": null, + "roundness": null, + "seed": 7325, + "version": 1, + "versionNonce": 9125, + "isDeleted": false, + "boundElements": null, + "updated": 1789395495529, + "link": null, + "locked": false, + "text": "Low-resolution input", + "fontSize": 23, + "fontFamily": 2, + "textAlign": "left", + "verticalAlign": "top", + "baseline": 21, + "containerId": null, + "originalText": "Low-resolution input", + "lineHeight": 1.15 + }, + { + "id": "output-label", + "type": "text", + "x": 829, + "y": 139, + "width": 226.30517578125, + "height": 26.45, + "angle": 0, + "strokeColor": "#246e4b", + "backgroundColor": "transparent", + "fillStyle": "solid", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 0, + "opacity": 100, + "groupIds": [], + "frameId": null, + "roundness": null, + "seed": 7326, + "version": 1, + "versionNonce": 9126, + "isDeleted": false, + "boundElements": null, + "updated": 1789395495529, + "link": null, + "locked": false, + "text": "Super-resolved output", + "fontSize": 23, + "fontFamily": 2, + "textAlign": "left", + "verticalAlign": "top", + "baseline": 21, + "containerId": null, + "originalText": "Super-resolved output", + "lineHeight": 1.15 + }, + { + "id": "input-dimensions", + "type": "text", + "x": 108, + "y": 405, + "width": 145.22705078125, + "height": 28.749999999999996, + "angle": 0, + "strokeColor": "#17324d", + "backgroundColor": "transparent", + "fillStyle": "solid", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 0, + "opacity": 100, + "groupIds": [], + "frameId": null, + "roundness": null, + "seed": 7327, + "version": 1, + "versionNonce": 9127, + "isDeleted": false, + "boundElements": null, + "updated": 1789395495529, + "link": null, + "locked": false, + "text": "64 × 64 RGB", + "fontSize": 25, + "fontFamily": 2, + "textAlign": "left", + "verticalAlign": "top", + "baseline": 22, + "containerId": null, + "originalText": "64 × 64 RGB", + "lineHeight": 1.15 + }, + { + "id": "output-dimensions", + "type": "text", + "x": 852, + "y": 405, + "width": 173.03466796875, + "height": 28.749999999999996, + "angle": 0, + "strokeColor": "#246e4b", + "backgroundColor": "transparent", + "fillStyle": "solid", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 0, + "opacity": 100, + "groupIds": [], + "frameId": null, + "roundness": null, + "seed": 7328, + "version": 1, + "versionNonce": 9128, + "isDeleted": false, + "boundElements": null, + "updated": 1789395495530, + "link": null, + "locked": false, + "text": "128 × 128 RGB", + "fontSize": 25, + "fontFamily": 2, + "textAlign": "left", + "verticalAlign": "top", + "baseline": 22, + "containerId": null, + "originalText": "128 × 128 RGB", + "lineHeight": 1.15 + }, + { + "id": "model", + "type": "rectangle", + "x": 411, + "y": 196, + "width": 302, + "height": 178, + "angle": 0, + "strokeColor": "#007d99", + "backgroundColor": "#e8f5f8", + "fillStyle": "solid", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 0, + "opacity": 100, + "groupIds": [], + "frameId": null, + "roundness": { + "type": 3 + }, + "seed": 7329, + "version": 1, + "versionNonce": 9129, + "isDeleted": false, + "boundElements": null, + "updated": 1789395495530, + "link": null, + "locked": false + }, + { + "id": "model-name", + "type": "text", + "x": 462, + "y": 222, + "width": 182.51513671875, + "height": 37.949999999999996, + "angle": 0, + "strokeColor": "#007d99", + "backgroundColor": "transparent", + "fillStyle": "solid", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 0, + "opacity": 100, + "groupIds": [], + "frameId": null, + "roundness": null, + "seed": 7330, + "version": 1, + "versionNonce": 9130, + "isDeleted": false, + "boundElements": null, + "updated": 1789395495530, + "link": null, + "locked": false, + "text": "Swin2SR ×2", + "fontSize": 33, + "fontFamily": 2, + "textAlign": "left", + "verticalAlign": "top", + "baseline": 29, + "containerId": null, + "originalText": "Swin2SR ×2", + "lineHeight": 1.15 + }, + { + "id": "model-runtime", + "type": "text", + "x": 445, + "y": 272, + "width": 242.20751953125, + "height": 26.45, + "angle": 0, + "strokeColor": "#17324d", + "backgroundColor": "transparent", + "fillStyle": "solid", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 0, + "opacity": 100, + "groupIds": [], + "frameId": null, + "roundness": null, + "seed": 7331, + "version": 1, + "versionNonce": 9131, + "isDeleted": false, + "boundElements": null, + "updated": 1789395495530, + "link": null, + "locked": false, + "text": "ExecuTorch + Arm VGF", + "fontSize": 23, + "fontFamily": 2, + "textAlign": "left", + "verticalAlign": "top", + "baseline": 21, + "containerId": null, + "originalText": "ExecuTorch + Arm VGF", + "lineHeight": 1.15 + }, + { + "id": "model-location", + "type": "text", + "x": 469, + "y": 312, + "width": 173.892578125, + "height": 26.45, + "angle": 0, + "strokeColor": "#495866", + "backgroundColor": "transparent", + "fillStyle": "solid", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 0, + "opacity": 100, + "groupIds": [], + "frameId": null, + "roundness": null, + "seed": 7332, + "version": 1, + "versionNonce": 9132, + "isDeleted": false, + "boundElements": null, + "updated": 1789395495530, + "link": null, + "locked": false, + "text": "Runs on the host", + "fontSize": 23, + "fontFamily": 2, + "textAlign": "left", + "verticalAlign": "top", + "baseline": 21, + "containerId": null, + "originalText": "Runs on the host", + "lineHeight": 1.15 + }, + { + "id": "input-arrow", + "type": "arrow", + "x": 338, + "y": 285, + "width": 57, + "height": 0, + "angle": 0, + "strokeColor": "#007d99", + "backgroundColor": "transparent", + "fillStyle": "solid", + "strokeWidth": 3, + "strokeStyle": "solid", + "roughness": 0, + "opacity": 100, + "groupIds": [], + "frameId": null, + "roundness": null, + "seed": 7333, + "version": 1, + "versionNonce": 9133, + "isDeleted": false, + "boundElements": null, + "updated": 1789395495530, + "link": null, + "locked": false, + "points": [ + [ + 0.5, + 0 + ], + [ + 56.5, + 0 + ] + ], + "lastCommittedPoint": null, + "startBinding": null, + "endBinding": null, + "startArrowhead": null, + "endArrowhead": "triangle" + }, + { + "id": "output-arrow", + "type": "arrow", + "x": 729, + "y": 285, + "width": 55, + "height": 0, + "angle": 0, + "strokeColor": "#007d99", + "backgroundColor": "transparent", + "fillStyle": "solid", + "strokeWidth": 3, + "strokeStyle": "solid", + "roughness": 0, + "opacity": 100, + "groupIds": [], + "frameId": null, + "roundness": null, + "seed": 7334, + "version": 1, + "versionNonce": 9134, + "isDeleted": false, + "boundElements": null, + "updated": 1789395495530, + "link": null, + "locked": false, + "points": [ + [ + 0.5, + 0 + ], + [ + 54.5, + 0 + ] + ], + "lastCommittedPoint": null, + "startBinding": null, + "endBinding": null, + "startArrowhead": null, + "endArrowhead": "triangle" + }, + { + "id": "input-image", + "type": "image", + "x": 85, + "y": 189, + "width": 192, + "height": 192, + "angle": 0, + "strokeColor": "transparent", + "backgroundColor": "transparent", + "fillStyle": "solid", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 0, + "opacity": 100, + "groupIds": [], + "frameId": null, + "roundness": null, + "seed": 7335, + "version": 1, + "versionNonce": 9135, + "isDeleted": false, + "boundElements": null, + "updated": 1789395495530, + "link": null, + "locked": false, + "status": "saved", + "fileId": "swin2sr-input", + "scale": [ + 1, + 1 + ] + }, + { + "id": "output-image", + "type": "image", + "x": 845, + "y": 189, + "width": 192, + "height": 192, + "angle": 0, + "strokeColor": "transparent", + "backgroundColor": "transparent", + "fillStyle": "solid", + "strokeWidth": 2, + "strokeStyle": "solid", + "roughness": 0, + "opacity": 100, + "groupIds": [], + "frameId": null, + "roundness": null, + "seed": 7336, + "version": 1, + "versionNonce": 9136, + "isDeleted": false, + "boundElements": null, + "updated": 1789395495530, + "link": null, + "locked": false, + "status": "saved", + "fileId": "swin2sr-output", + "scale": [ + 1, + 1 + ] + } + ], + "appState": { + "viewBackgroundColor": "#ffffff" + }, + "files": { + "swin2sr-input": { + "id": "swin2sr-input", + "mimeType": "image/png", + "dataURL": "data:image/png;base64,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", + "created": 1789344000000, + "lastRetrieved": 1789344000000 + }, + "swin2sr-output": { + "id": "swin2sr-output", + "mimeType": "image/png", + "dataURL": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAIAAABMXPacAABBk0lEQVR4nO19B3gc1bXwtO1Vq96rLVlWdZUlN1muNMPLo4XygCQQTGhJSCGP5P8CJHkPMCRAIICTgAEXYhuMwb3Lsi1btmRZvXetyq52V9oy9f/uvTOzuyq2SOCZJFx/tuTZnTt37jn39II7HR7s6z0EQcAwDMfxK1xH/6IrX+chCAKO4wKG4Rg2OjZ68ngZ/i8CAAwXsK/77oMhCBh6EUHgBN7ndf8TAOBfbwjSXxwjiGu9mH/HIZ5ZQIuEbwBwbQaipziGfQOAazkADbqmC/hmfAOAazq+IUHXfnxDgq7RkJSWbwBw7YYAdMdvAHANBg+UeB7q8QI14VNZoQ9U/RGc+GkaCSaOibaa6dwrQMvJ9O08V57zH/l04ncCfke3CMEzoNUGziaunxcEq9XqGBkxGAzRMdHjTsDXzpwifO3ta19Q/8Uwnt+8efP3H3zwjT++4Xa7J56AcXDDxuG+IPAAzAQC9AQTGHrKhF2buI9BuIajL8kfBU3A8zy6IprdAqYY96Ar4y8B7S48z4/75hR4HbBoZG+VHhj8HbgHgU+fsCrp++JUvCCcKz9feanKFGLhOW7cCZAP1JWHtO04/BN0/1R7IFzheOHgLvG+wJ0JeIfg/8trBd++0sz/yAh4vPyS0ib7PxEpz4RVTTXE+xVKBUkQGI5NegIm3ITjfmwgCLgf4AIybUu/o9kDjwSg4PL2TbUcAdF6/+8T6SkuPiJ4WyD2oceL1yXfgLgK+T/inDz4iViKMCndByxn4nX4u/wbvDwOy/2bIzIsSBvgbOIyIKDQ6oABjsA5jmdZDsfxaQEA3IPjPJwGoCqBC7zA8zxJkjiO8ZCpy4dPwDCRPolvKe7slLDFpI0Ud3o8q0cODHlrZM4svg+CDNxbBBO4QzLY4RWEMuJs4qmVd1nCEj7gMKNHoDslwocDBipO4UcB+YKMo/AnXGQAoYKzQOwlxKeBIQhXPAESnCHuwEMgYIKCpAQBczodDMtotVqVSgPPB2AMAs/jBM6xnMfHMCyDE7hGo1EplWAOEUhBPiwcxxiacXvcPp+PJCmNRqNWqXACOYz8UAMiG8/xPI+IOIbjDM14vR4cxzUaLUWR8Kvi7mOY4PMxPp+P53mlSqlSqQgAYYkKw0dzPMeyLNp6AscFHOc4zuPxCBimUasVFAWPowgkjuMZhqFpBry7QgFWKKIKYkt+fxyYmWM9btrr8wo8r1CKgyAIuEWQOaIzAP4nwntKAMjklSCIioqK8jNnUtNmFBYVjnHcmdOnKy6cH3OPmU0haWkzCwoKIiMj0K719fWdPXu2sbHRMTJCKRTp6elFRUUJiQkSiRf3iMCJMbe7sbGxurq6taXZPmJXqzXR0dFpaWlZWVlxcXEURQk8PLYEmPPQoUM0zRQXL4uMjOzq7jl+7HhDQ51SqcrOzilcVBAbF0uCXcMdDkddXd3Fixd7urt5QYiPj1+4cGF6erparSZJUmZx3d3dR44cIXB82fLloRZLa2vr6TOn29s7SJLMyJhVsHBhUnISQQg8xzudo83NTdWXLrW2tdE0HRcXV1hYmJWVpVQqcZwIpM8cxw0NDdfUXL50qaq/vw/DBJPJnJiQmJubmzZjhkqtAqcKoAk8KAJGEBD2wng9IFDeF7GVJMl9+w/+4ZWXSkpWpaWl7T+wb9Of/zwwMMBxDIYTJqPp5vW3PPnkkxZLSEVFxbub3ztx/PiIY4TjOAzD9Xrd3DlzH3vs8YJFBTwn0haSJIeHbTt27vzk413Nzc1ut1siI5jZbC4qKrrvvv/Ky8tTqVTo0FZWVv7ud7/FMFyjUcfGRP/prbdPlZW5x1wChoWYLQvmL7jn3nuWLFnsHvN8uOXDLVu39PX20jTN87xWq01Lm3HffffdcMMNeoMBEEZBICmqoaHh+eefwwSMpBSZmRkbN248duw4zfgIgtCoNdk5uY899ljhokVDQ4Pbtm3fs+ezjo42jxecD5VKuXt32v33P3DTTev1er3MgmiaLj9bvv2j7afLyvoG+lmGxgmcIAi1SjM7M/Pee/9r1aqVRqMRgUqSowCBE7DxAPCTY8RX4c7gPp+X4diW1ubXXnv9xMljRqMpPzd/zO2uqbnc19+7+f3NPMfPTE/btm17e3t7SnLy3DnzPF5vS0tzd0/3wUOHSFKRmpYWHhrGCxxJEk6nc9Omt997b7PNNhweEZmVlWWxWGia7mhvb25p2f3p7v6+/p/+/CcLFixAlJOmmbGxMZblPt+71zY8PDg4uKpkpU6nq6uru1xz+cDB/V3d3Rs2PNzR0fH++++HhISsXbOOUiiaGhvrG+urLlVufGljeFjY8hXFOKlAR4BlWZ+PZlnmbzs+Uu9R1dc3Ll26xGQ2NzY21dfVnio96XGPbXj4kUvVlz54/4Oo6Jjr1l3PCXxDfX1rW3NN7eWXN240my3r1q1DIgjHC8eOH3/hf/+n+vIlnVaXm5ObkBBP4Hj/gLWhvuHM2bMdHR12u+2ee+/RajS4yAHAixGAOE4CgEDGIl4ClEyhtA4MHDl65O6777755vWhllCa9lVXX/7T22+Vnizdtn0rQRAxsXG/+MV/L1my2GgwMAxTV1v32h/fOHHyeFlZWUXFhbVrVoMNxfHSU6V//ctf7CMj69Zdd9/996elpqpVKpbjHCMjez7b89rrr5efO3vyxIn8/HySVFACptPqtBrdmHus/Oy5osLCp5/+RVpqKkmSgwMDmz/44MMPP2xubnzxxRcJgli//ubbbr01IiKCIAi73fbW2+9s2761s6tj7969CwsKDAYFYGYCplKr9XqDx+OuraktKlq88eWNWbNnUxTV09OzBYwPa2pqn33uWZ7nb7v99jvuuD06OhrH8c7Ozr+++9edO//W29d74ODBJUuXGPQ6giCt1v633nqrqvJCckrq97774MrVq0JCzALHOkdd9fWNL7208dz5s5vf37yseFlmxiweiRgBQtSUPEAU++CJIQFFBKz4rrvueuyxR5UqJc8DGK6MjtTqte1t7T09nRqN9gc/eOTOO+7ggbsfADIyKsLH0rV1lwcHBi5eqFi1agWBEyzDmU0hJStXhYSEPPDAdxKTEnkOSGM8z4eGWe5/4P7LNbUfbd9W31Dv9Xn1WgU4pApKEHiP15OVlfXfz/wiNS0FKFMCFhZueezxxzo62g8dOtDR2XHLzbc88eQTFksIwpqIyPDHHnv00qVL58+fvVxT43A6DEYjlBUwAd5O03RGxqxfPP3zGTNncuCKYLFYIiMj29s7Dh8+2NPbff31Nz755OMhFgtSbkJDQ0PDQptbms+cLmtqarTb7UaDHkgzHJufm5s+Y8bq1asXFRYqlWDNOC4YTIaY2Njevr5L1VUdHR3NTU2zZ83CoRQpC6dAYpwKAAEiN9h8mvGFhlpKSlao1WpAzUVBG5+ZPjM5JYllmbi4mIKCBQSB8xyAFS/wBImnpaVGR0fxPNvV3cFBwQPDsHnz5v72t7/96U9+Ghsby3OsbPPhOV5v0M/JzyUp0mq10j4f0FuBdMizQBLxLli4ICUlGcoFQHwRMCwqMmL+/Lk8zxG4sKiwIDTUAvgbThAkKQgYYsIYho/Y7WOjY0jGxQWMYVma9rEsk5eXl5yawoHXwTGc4AUsKioqJycXkmls3rx5llALotq8gPGcEB8fNyc/l8DxoeFhl8tFkiTPC+ERET/80Q9/9f9+tWz5MqVSAf2MAFkB/8Lx9PQZBoPB5/P19/dDKU4Us0UR9cpiKPoiYjQcz4eHR4SHh3Mch9gDErWVCoVGqxYwISIiIiTEzALeK0nkGE4pKKVKKeCCj/ZxYCuRIExSWiC88kC2BPoIyzIczwPUBKIH4BOjo6MMwyA0gTIoRxBEXFwMTmBAfSeBYAdkTwLT6fW8wGtVQIhCWoIog4NnEZZQCw6lTLDLEm2FM3IYjsfFxREEAX8VTz2OEwaDHidwkqSiIqMAwiKOiRgmSekNBhxwEYZlGbgLuEKhIIHMBmRbuFEsh16MB7MxPp9SoeAFfnR0DH0fAhcoZTCWaXIABKpNgBIBjMMwg96gVKkQaZI4hECSSKDCTSaTQqmU1HbpL1Q4CJxAiClNCB4+NDTU0NDQ3t5hs9mcLgdDI8kBLy8/DwwmcM/Q2UfqMUmSBoOBAMQQ6hxQ28FxQqFQYBimUCh1Om0A/QQDrIwgoMrIA44nqenwfPAEjltCLARO8hiL3hhBD6gOGK5UKo0GE7wdUg0ECEEgCRIxUkTIZYnFPebu6elu72gfGLS6XK4x9xjLAKRpb29zu91AjYUWrXGojU+Qgsajf4A2i5MUOPnyG0KNGKIZ1I8IkhItFqIeBcAENgkoHJLtDk7H8fzZM2e2bttaUXF+eMjGMDTPsYj7q1QqnudInIRzioYlRLgIglQokPQN1Bi/ZQTpU4gqoSf6rR9+C4pkKoHnRlRSMUoB5CL0LpLuDvQe+EyCpEjRNIIDEV78GBpN/BYHOLq6unf87aODhw52dLa7x9wMONAczwkqlVKr1cAzTYq6mLh74mYI2CSmiCDbHvgOUEQB0vE8fG9J7xfRQMJSSJrG2fJwBCMMB8onIH7wyWWnSp999rmqS5UqlSo1JTU+Lt5oNKg1aoPBGB4ece78uc8/24MAK6rwkJpBgweOCwS8BLVbyMLQUjiOBfQd6jYS2qBjIJqWZLMADmigqNXzPCcbm/xoKW4Cjz71m1ngZXFVgLzAKQm8t6f3D3/4/c5dO5wuZ0REZH7+nKjoKLVKrVQpY2Ojbbbh9za/z9BMwHFBeIBD09QkYqj/N1nnhhwFLAXc47dCiXAEFwFhFRV++fAEoh68FdiOurq6//D7V8+fPxcdHfPwhg2rV68ODwtTKBUUSVEUOEOUQvHpp59Cki0GsUI04MEixIcHghkc7YBdRkjjtx6KFjhoCkHLQkdUnBWZiESS6r+MrNZg5nEvIxrbxdmAHYzjP/10z44df+N4/rZb77jzjjszZmXodDqCJHFAzRSnz5Rt2bLNjXnkjZNsRKJdYmoSJNsfRaMQGkGWMohF4CIiA36DvgwgaMaRzSaUgqqurrlw4QJJUjfdeNODDz6oUqogNom3sRw/ODiArFTyaRdJmd86IvNMcQ3oZGI4IVqbxNX6MTqAKEn/g58h4imbmoOtsDiU2UVuKVv3AFDg3iFJxOvxni477Rx1LFqw+JlfPJOQGMeyIotCIr/D4WBZDvE/eQOBCCdAc+mEExBouJQtmkCsg6QG0IWA78jgAQsiSWDdljdF+gTCGeImQQDR0G6z0zRNkWRsbKxareJYETzIYdLb03O+/DyO4eA0EGBDJYqLk0D0CRSa0d4i7IUES1LcpSWhrQQ0EBiCJP4kQDKCtlh6Hf8L+63JADxk4IsG0H3/FrEc6/a4MUwIsVjMZjOkw8g0D17b6/VdqLhA0z74QMlfIzI2ICMIQCocP9ABD1wWDB+STKxAnICcEH0IYQMkE/E0+y21SNiCLjMch5oZEAcjo6KUKhXDMjW1NYMDgyhGFW4X39fb++5f/1JdfRno3RSJiAU8ZDL7DIS7H49FC5e84IBNFKXVACkAxzHgCQFEHhAQWZyTtwfSKyAjAfkuwK4uY4nsnxEEQalUhIWFETjZ0tJ0ueYykHYhSRQEwef1lpWVHtx/AJ1BeIwIwAfhcxFVvJoU5H9RASgdUL8K4EmipgxlREJ6cBCSQNmLoCjwFMg/sJycrDn5+YcOHzx+/Nhrr/9x2dKl4eFhAib0dPd8/PHHpadOGUwGH+1lWBaKoWgSSL8IgmW5ACLn50AkVAsCYCAiB9DiBIEiCfDKUEFBpEwkIwQgMoFeR0Q6kKUamoz9T5Os00ADIIDoLR4OpUK5YOHCvXv3dnZ2vPL7V759x53Qkkq6XM4LF87v2LnT4XAplWqa9gV6daCIBVFfuKpDBiCvwDKsqN1CSUheMY5hLMvRNDCLsvD0ya4ipKmxLNCxIIZyggBU5LDwsCd/+KRr1FVdXf3+5vcO7N8XYgGu0YGBAZVatWHDBq/X98L//o/LNcowLBQswUDuC5ZlAzcZiVgsy8IPMeTrld8RUWqGAW4Jn88nOwAwAfP5fAzDQP4sszmwdiQXIamP41hJE5ReFVJwjgWwBC4toG2BSytWFLe1tmx+f/Oxo0fqa+uiY2JIkhgcHHQ6HavXrM3OynrpxZfG3GOIIsocnqEZZFC5CgCQCJOQEJ+bk5edna1WqSUehiQ5TEEqMmdl9nX3zpyRDoz4ktcOHUOj0TR3zhyOpWfNyiRJCmwUxxcULHz++d+8//7mixcvjNhHHI4RjVablZV1xx23rygurrhQCSwESUk6vR55vC2W0PzcfJdrNCYmWmKoojAkCFhyUlJ+3lydTmcyQSsQ1BKQo1wQhMSEhPy8ueERESaTGRAQuLDIyMiFCxY6XU4wYZDDESB+XFx8Xm4+paCATU3OKBI9blhqakpOTl5UVJQW6H1AE4yNidnwyAaNRnPgwAHHyEhrazOO4wkJiffee++tt97qcDiOHDk6MGCNjooGPkgMJwk8c9as/v6e9PR0pUoxrQwZm802ODhoNpnDwsOQZ0NaMRjDw0ODg0MhIZbwiIhxGoogCENDgwMDA+ER4ZHhEQBHRVaIjYzYu7q6BwcHOY4LDw+Pj4+3ALMXyJwasA4YTaawsDDAcATB4/VYrQMcy8XExmo0miAAYJjbPTZgtWI4HhUdrVapJT+w+HSHwzE4NKRWqaKjo5A2hOGYz+sbGLB6vb7Y2FitVicLTIiHOZ2uoaEhkiQjIyM1arUcDoAg4HQ6h4aGCZKIioyUFyMIvMs1arVabTaby+WiSDIhMTE2NlapVPh89MDggMALJrPZbDKhhQ0NDbndYwqFMiIifBoAQJIE5OwcNIKKio1EaoB5ABJjXuADgiRElEE2ACkeZLyoh8niZUDAiKRRS55+dCXAQCuJ4eJui5wTnOigIA3ZX4g0GNn5DBV4dIvMtSS6Cu1LQKyQdItgH73ojg4AmV/cgDZdSaRGAgRENnH7JKoQHCMjTDdHDD0+QLEXnUGBRlPojkcCL1LOgmwf0oplfSdIYhoXqIPYiWz5kPza4ycMUBjHRx75J/Q76APk5uClTzUCwx0CL04zGFBWHQM3TD6+aAOmJQVN8n7SuwWJf1edBN0j3hq0VnmKSSEXYCSYeN0/ByJukz01KDBjfCTPlKGPclxJsBVtGrsfQCb8ZibAYSTpUV7P9MTQCXGTU0V5Smd2OrNO+iD/U8RzMBlkJ5X6A8TFSce0dm3iLSLxvWKs35TxpgE/EPUJWJ/4y3RPwBca08SRyYdshBJNZn/Pzn2J4adf9dOnBQDEMaZa6MRP/5G8dWFSMhI8rh77N9kUaD1Xfpep7pr+GqaKsp7q+/+S+QHC3/nZtRhfgAdM/9MvK6Yc/3tI2ZSPHh/z/NWML7rmf8kT8M80vgHANR7fAOAaj28AcI3HNwC4xuNfDADC10/O/PIAgMyXSMeSAgm+DmWqBBTgIAVWBYLh2i/u79EDJtXlRBma570+MAReUGs1KjFd5Opj+hnFE8cVrC7IMsyyIGGGoii1Wo2u8wLPMjBSCCdhMkWQ0/iaj8Dd+AK2oDH32OXqyzW1tT3d3T6vN3/OnHXrrtNqtV/5u+FyiMO4D4DpzjZs//TT3U1NjZmZs9evX2/Q63hBGLE7Pv/8M2t/f05e/oriYoVC8X8MgOkbYyYBQJDVE1nhQcQOe/jQ4ddefa21vc3jHmMYprCwqLCwSKsFnrmr2qy+KO4LATgCAhqkSoMBn4IvkDhx8WLlSy++6KW9yUmpmZmz583NEzjB6XS9997m1pam9TffsmzpEhi0LN525ZWIeZ9fMbQC13A1nzD4B6R0NTW3vP766xUXK/Q6Q25OXkJC/KKixUajcTq7/6UM3P+r30FIEDhN+2iGxjHM6/EA2igGmAiQVHqdTmdQQNb0HvSPb//0Dxw1TdfEufMVl2sukwRx9913bXj44dDwMKVCKUW/TrT8BTiihCs5mPDgkDd/BnhA8Nt4Vxe8jj7meD4vL/e2227v7OzIzc1LT5/B8wJFUSjMnQcxWCBkZertGO/jm/Tdp41hQX63cRsSmMMa6PMIAoCc3jzuXl4QhoaHPW53bEzsnd/+dnxCAoi784eJBiT6Bu3sJDULJl2y4HfyTbDroXwHKdgi6Bsw5jsmJvrpp3/u9Xo0Gq1KrYbB68h7DEQiEAQnOaUnEp9xkUQg1hN5cYNcT8g1dnUYBEbxTvxo0oM1PlEbpRaNexhaE4hwF/i4uLiY6Gi4+4AugUggFKeOXk+OIZVPQRBaiWRdRgJeTqbwr17it9JhQFFvgUFX8vFC7kJBEDQatVqlAnOJVSWglIziPuGyZLokh7YHpMsHOv0FEF4JIjHETZ8mJQEwDj7bE8tMiLJywOai516JBwgwJMRus7Ms09PTIwi82+Pu6u5kWJqmGaPRYDSY5KAEmqFHXS6bHcRl8LygVquNBqMl1KLR+PMm0MNZjh2x21mWN5vNKpWKpn1DQ0N2u53AcaPJFBoaCqRJKU7C4/Ha7Tan04lhmNFoCAmxaLUasLvSi3Ac53K5WJZVKBR6g4EUawTAfZcyZjBB8PnoEYeD50Duqk6rJWGwXjDy8T6fj6ZB9qSA4RazWSyqekU/J7xPcNgdHo/HYglBgSrS5oF/3R6Pw+FUKBRGk1FJwTRNaTZe4F3O0XE8YPz058+f3/LhFpfLWVdfhxN4c3PTb37zu9BQi9fjLS5ecfvtt4H8G44fHBo4ebL0zJkzbe3tbvcYhuEqlTIkJHTu3DmrV61OTk4iKZDdIWAgLrO5pf33v3+FZblHH33UZDTt2bPnxMmTw8PDGIbFxcYtXlxUsrIkLjaW4/mamsv79u6tvFRlt9tYhg0LC58/b97atWtmpmeolEDkJwh8eNixcePG3t7ezMzM7z34YIgYeyOA3D9RJwM74XA4X3/9j4319fPmz/vOd75jMpmlKFm0WzyOYZUXL276yyaX0/m9Bx8sWVECE/8BCZuSqcI8crtt+E9vv9Xa3FKysuTWW29VANYosjJe4D/ds/vggYNKpeq2W29bUbICMCaURoJjY6Oud//y7hQnAIIdx7Cuzq6TJ08AGYP2kgTBMHRVVRWBE7SPjoqKYTlOoVD09PW++cYbu3btsg3bdHq92WzCcdzj8djt5w7s31dWWvr4E4/Pn78AnRSSJHp6uj/f+xlJELNnz+rq7tn72ecETmp1OpvNXldTe/r0qapLFzc8/HBXd9crr7xSV1enhcTd4XDU1F4+fbq0sqrymV/+MiM9AwVFMwx99Nix9vbWfqv1nnvvxUNABJxfI4YqO8fzer3Oau0/cvRwR0f7mnXrTAhOYtCDSOKOHj/6ySe74mLi4uPjCZJkefaqwjVI9FVQnZ2dJ04cHxoaXLJ0aWJCIoiRhhTGPTZ25MjhY8eOsixnsVgWL11MkRRM0xNInOjt7du3f+/kOWLiocOx5cXLDQYjjgk7du74ZPeu+LjEp576CcyrZlJTUxUKhc/n275t25atH9I+es3atdddd11oKIj1dLpclRcrt3+0/cChg3qDITMz02g0wZRHMDFFkhzH79ixS6FQ3HD9jQsLCsLDw1tbWt/b/F5t7eWPd31i7e8bsg0xDPud73w3NyfXYDT09vZu3bb1XHl5aemp48ePz0hJA7gG8QlUIoBByyAKWNpRFAQn50HodLp1a9cdOnSw32qtq6nNzMiQIx5Q7JnT5Tx/7rzAC4VFi9NSZ6Dk2asKlLwgmEymgoKC/fv2tbS29vb0JCclgRQBGI/V19fb0tzkpb0Cj9XV1Y2MOCJAliP4FMOwlpYWq9U6xQmQOGB8XHxCfALPcxerLnIcl5CQuHbd2pCQEIpUgOhlHHOM2FtaWsJCw0tWljz8/YcTEhPQqeY4bvWa1ZRS8drrr50uO93W1p6bm4u0KpQJw7I0Q9NPPP7EqlWrdDDtv6iocEb6zKee+nFrc+PxEydycvOfe/Y38+bOIymgx3IcGxMT+/Of/aylpfnE8RPfuvlbkRFRcp0cmAIlxkJJRFtioYCtggD6JUsWZ2dlnzx5Yt++vatWrzIDJUakJCRFtrW2NTY0aLW6kpISlUpJ++jJYvcnGSRJpKenK5RKu83W3NJcVFQkH4/Gxsb+/n6z2czQTEtzc2NDQ3RUFIwQBVVKamouO5zOyZ8hy+QgQRTiAsw4BFYXhDiclN+r0WgeeuihN95488c//HFcXLxoB4MIaDKZVpaUhJpDHE5HT0+3lOsCslNBLifH5eXnLV++XK/XyVlXi4uK1q27DlRawbGVK1cuXFBAUgoU3ESRivz8OXl5czAMa2trHxoeRqnCMJMIvBJIEJeylCR+JspdsKYOFh4WVlxcjOF4eXl5b08v4sOIIIPMtbJTg0ODaakz5s2fJ2fIBiaaTTFAOGJ8XFxkRKTH6z5/rsLn80lpcXxtTe3o2Ngdt92+Zs0am3341KlTHA+wFsMxt9ddc7mWZeipgBwgRcHdwTCQZwLi1HkeJA2K1kdMo9Hm5ubOmzc3NDRURCdUS4jlWJoxm0wGg5FhaJvNToCsKZi0BHNXVSp1bm6uTqfjWA6GvYP8WgzDUlKSCZLQ6XS5OdlA9mWRrAumVatUltAwgiC8Ho/H65VzlYEgItbDEWOggnZIggdO4EVFRZaQ0MGhwYaGevmok6Cugf3Y0WM8z89fMD82Ng5FqU5HI4ZaEh8VFTVn7hxeEC5dugQwAwLfPeaur29QqVWrVq1aXrxCoVRWVVaBbGGIE8PDts7OLij4Ttx7KYJQSg8R46PAERdL3wQqQyCOlWXZMffY0PBQW1t7TU1N+blzpWWnTpw8efTo0TH3GOTJbjnxBtFlrUYTFRVFgMQmiePDHaQoBUESWq0uJMSM8jL8q5Kkdxjmjmi0qEZIdZekNFUp+BelFaIZWJabOXPm3HnzaJ/v1KlSH+1DaTckSVZUVFRWVRr0hsLCIopChW1ExVBMA50KT+HsKpWyeHmxRq3p6em29ltRQlJfX19Lc3NcbHxiUvLMGelRkZFdXV2DA4Mg0ZjAu7u6bXYbBZjyFKANNIqI7y4XkZQ4GxQsea/X19TYVH7uXEtLU19vn33EDjOV3SzD+rze0bFRkiSRiifiDNRcCJIQ48X9apuEqiiNS4qgCogchSqSHOknBbnKOY4B8bhi7picJQmSv3neYDCsXbPm2NHD5eXnenv7kxMTeY6nGWb/gQN2u212ZlZ+fp6Yghps9p76CIjeh7zc3OjomN7enrbWtry8HJzA6+oa+qzWG66/LiIiQqPWzExPLz9zrrm5OSUlSeD5psam0VFXZGTUJCdAzhCWTTkI1+DBlDIXpTp7Ph997PjxX/7ql7/57fObN28+d67carX6fD4FRYWEhJhFoVBCQ3/stsCxIGFmYs0/qC4gYjUe9/zWUGSiENO6QPawVBsO5RAj3gCLJgQmu8HXWrxkSUJiYkdHW+XFizzGY4TQ328tO1XGC/zcefPi4+OhTiDSLeyq5wC+FsfzMbEx8+fPp2lfVVUlYEo8f6HiPMdxCxYWUJRCrzdk5+R6vJ7Ki5U4jvsAB67x0Z6c3Lyr+gNELV20kIjrQZIG+M+lqksvvvji5epLMTGxJStXLlu6NC4+XqlUURSp1WguXrz49NNPDw0NiUIVvBGZ74LNbIKf3aAUBPELkn0qyHYnleUTLT5ifYjA7ZYSVSU7h0SWBF5ITIifkz/no5bm/fv3rVxVYjLoK6sutne0m4zmVatWopSKL2Q7Ryq3WqMuKSn5ZPcn1dXVbo/b7fZcqKgwGoyZszJ5HpikcnJy9DrdxcoLbo9nbGyspbmJJKi5c+ZdvVhHoJ9VhgFI9oRJmoePHL50qSoxIenXv/51cfFyrVYrVRMAZhmn06nX6222YX9KgJj1JRpqhEALItxGsFyQ5SzjoAgf6X9+chRgVkEzB+21H31QlDUkn6gaQmFh4cef7DpZerLmcs2iRQWnSsvc7rHiZcsXFiykGTbo0f70YFgtdZKIT2l9ApaXlweq3XS02YbtnZ0dzS3NKSnJsXFxPCxSkj5zZmx8THNz48CAdXRstKun0xISMnfunOn6hEHyBap3gVIM4bMZhmlra2MYOjtr9uLFRRq1GubLgaJ4ApSDoPYxgoqbiOQb7g9KvhMC31OGgFidQDTzBZFjmPZNABMzquIgVkUR8xSkhDsxs1oywyFmEBhxvaiwMCY6tq+v9/ixE4NDQ5WVF1VK1cpVq8JCw4AxVbSdiesKzvmZCksBwkVHRycmJg3b7A2NDRUVFU6XKz0jw2wGiWaYgEVGRqakJA8ODTQ01tfWXB4ZsScnJ6empV0NAGiTUMasv/SCv3wkSYHddblGnU6nKL0h5ocJXV1duz/Z7XK5gDkFYuC40GVBqtPpF1zEzCE4j1RcQWI3sNSgWKQBgQdcQbBE9hz5IMkwhcmRYpIQeijHcakpyYsXL2FZ9vSZU+fOn2tvb4uNiV26ZKmU8i8qwDxI+oV0DCJfYLrORAjwvKDTajNnZdK0b9eOnSdPntRoNQsXFqiUSsTQtBrN7NmzeUHYtXPX7t27OV7Izs3T67TTPgGgABMhlSpAplpMoVSmz0xXqTTVly/v2fNZZ1e3w+FwOZ3Dw7ZLly796c0/lZ87K2ajizCDxno4Byw8IwTslZ+5w+5OhPj243EB5E9LtTtkQQ0xc1l4gOgPMsilipWybgk/ValUa1av0ekMtXWXX331D8PDw4uXLElPTxcLVEDEqqysfPmV32/atMlqtYKc/cCMqikGpaDy8/O1Gu3p02UN9fVxsXFz586TqpyCt8zJyTUZTaWlpZWVVTqdNj8/7wpiaODeI0UfpGTyAqx7I2EZgeMlJSUHDx64cPHi66+/VlFRMWfuHI1a3dnRce7cObfHXVRUVF5ePuJwiJUkIEGG+WOEUqEQeE50AQUYygVeoAhSpVSBrGDJ8yVLYsCATlGgjA+ghKLPR+B5SqEAwi40TyKfDKpQAOI2gngY+JdhuaKiwnnz5p4tL6uqvEhRVElJiU6n8XihRxMqddu2bX/vvXeTk5KXL18eE4PO3FUgIAhCVtZsS2iYc8TOsPT81AUxsbFymSCe49PS0uLi45sbG0mKioiISs+YNb0+YhCCZlNIqDksIiyCICi/mo/hmbMyf/SjHxcsXET7fPv3733l5Y0vvPDC1m3bOJ7fsOGRp576SS44aHoFdIujw6hWqy2WMJMpRKFQySWZ5KFUKS2WMIslTNr8oNc26PWW0LAQc4jo6AKUjdDrTWaTJTwsXHLq4BRJWSwhZnOIyWT0ewWk9+F5Liw8bM2aNThGMAyTmjpjztw5DKh3BZZCkITT5aqpucxzTGJSUkREBLK7XHmP0MvFxcbNmpUJD5kmNzc/MGREEITw8Ii8vHxIz8js7Dzg2uL5icU6JgEshmErSlaYTabo2Fi9Xi9OCrGFpMiiosVhYeFVVVXNzc02m81oNM6ePTs7Jyc5OYlnufvve2DtunX5efmo+AvLsikpKT/+0U85lp2dlQVOt79gAxCoc7Kzn3rqp1qtJikpKZjtgTNw3XXrZqbPIHA8Pj4WFkXijAbD9773kNfjNZnNarUGPkUwmYwbHn54cHAwPj7eXylS1BuQsxSbMWOmQqFifL6SkpKoqEiaZqSqIIRteLi3r1ehVCwsWGg0GiBvmApT/eya5wWtXvfYoz+44fp1JEnOmTsfVQeURWoFpbzn7nuzZ2cTBJkxK1Or1QJNaDppquMaKYyLskK/wBK/NMsCD4FKpZR5qVSaRCz5JVJr4MQE+i4kF0EOR5lfwjo0yGfpN22KpU9EGxyowIfhwJaA6ncCHgNJE7RciQmzYtWfACoOi2wot2zZ+sMfPqnT6f74xzdWrVrp8/mg+IuplKrTZ87ceeftBEG8+eZbK1Ysh5w8qK7K5HsEfyoUFBTSBBYaMoMABRYPRDggKUImP53ALCRuiGXBJs1cRBZgkiQoSi2WQ4C6FvQlSXgn77EsFvptSrifCPmz1kWAyW5x+XNkBkdCLTJSifWFZOc3/I0LOFgItIhp8aCWHNHa1vbxrl0YoNrZGRnpgBSgkjYQilar1ev1xscnJCYmQPiJOsTUgqg/G5gDxxLYxgNBLt4KjGYch4OawjLiXg0A/p2RpMOJrsuAXOkAZBblzqCE1gCYAfoloJcKei0/0bzK64pkXYpQ9QtUonQram1yJXCwnsGhYfuIzTniePOtt06fLjMajTfccENERARklbKlT6ipqaFpeubM9MioSLFcxBUNo/6IgkCNfUqxKQh3r14tRfr6laziEoWdJPZi8gyygGJkWHBPClnDuMKz5OVP+gjJ14tmQ28M/pAEeejQ4V0f77INDTW1NJMEubx4xZq1a5UKJRB50VsQuI+mL1y8wLFcdnaOTqeDtX2mZZrwmz2Qayh4VfI7jrv+peUJTxahNY2oDuHLev6kS/KvA6kE/VZrc1OzQkHNypi1dMmyO+68IzYmBmyxv/QFwTI+HCPiE5IWzF8A6LVccHS6TxV/TjOq5UvoJ/z3RT5/0Vxi4Yr5t1edB52q2tq6zs5Ovd4QGxsTHx+nVqtRISeZRiNVubaujmO52bMzQR3iL5grPlU28lTrvGYA+LKegk8bkNCiILoZJDkKFgQVtRpJ0II6LYi3YNkvjP5BDowggvwVAuCfcQhTVKH4vx//YilK0x1fk93/9wUA9vXY/X9jAHxtxjcAuMbjGwBc4/ENAK7x+AYA13hM2cbqyp2EA74/zosg96kHduYrfvOfb3wVOj/x1VhnvkoTz7/WuKpHjP+CmytgmN8L8XUf+BfDln8803/i+LfmAXhQ2A+8Mr49zFc+/g4AjF/xPy9FEqAJVIo4Fq9dfbViJBL+pQDsiwEABaJ9WTiCf7GvT70143pOXDGrcZJZUSSw1J7oqnZVuXXHFxp+X1nwmL5DRoqrDXDPTiY24dNP/xem8VDR5yh1pA6KBxXnlgJ9Zb+gnAc8rv/7ZPPLPeElp7LcdDtoAUFvF+hkFb2jV8vklnOjoTPw76mWIuYxwxAPhmE5jodeeEp0c8NwNsCw5bR2FE4qBm5K7YgCN08yCOPj8+nFMABBAB0bQLYQ6CaqoBQKArq8g2uJiDkYctgWbK2A0V6f2OOOBK1QQJu+8RsEKQ+MzmNZhqZpmFqrIkF7aBA4FBwMH3gXyOVmGbAwHAf93lBAGOh5NUnoCgxOgMEMoDEdbCIBGkaDXHDR8zpNAIBFMAzd0tJy9uzZ1tY2hmHCw8Nmz549Jz8/PDKip7d33/59As8vX16clpYKcpcdzr379vq8nry8fJSe599c+Jt1wFp64oRtZKRkxYqZM2fCyg7igzie7WjvqKysbGxsRPnDYWGh6RkZOTk5CfHxFAVjvOCGkjhRW1f7+eefx8fHr1y50qDX19U3nCwt7ersxDAsMjIiY9asvNzcCNDYQAoQljDJ4/U0NzdXX6pubGqy2+wURUVFRWbMysjPy4+JicGD43rRjSzL9vdbL1WDP/39/QqlIioyKj4+Pjc3NxU0ePU7z2T/2tjYaF1dXU1NbUdHp9PlUqmUsTHRc/LnZGXP1ukN0+gliWbDscH+gZ27du3Y8VF9fT3oWYLhKqVCb9AXLCp88sknOto7nv31swJoSBqanjGTFAS73b7xpZe6u7s2bPhBbn4eOkGSGRiUOaiqrHru+edGRkb0Ov3s2bN9vA+1jne5XLt37/7oo48aGupHXaOgzyncbrVaNWvW7AceeGDt2jVq0FcBHCCSIsvKTr/y8sbIqBhKofR5Pe+883ZzczNMeOcUCspsDikoWPToYz/IzQFIgOKlCQLv7+/fsmXLZ5991tnRMTY2BqIiQAdQQqfT5+bmff/731+yZDHs1yPnXGKjo6OHDx/+6KPtVVVVDocDJNJA55paBRb2vQcfXLNmFciTDQjD6ent+cumP+/57LOBAStogANbHJAEGRcbt3r16ptvuSUzM5O6QgAWuojj+Oio69VXX33/g/fdbndkZOSMGTMiIiMxTLD295eXn/3N889nZ+WAFDvYrQ3RZI5nXS6n3EGO4zkCZBTIa5N7tdNiKxaIlSzLb9u+/ZWXX7bb7dHR0fPnzQe9OnlucGiotqbm9JlTdrvNYDCsKCkGs8Elut1uhgHP2rVzZ19vD8dxMNBTb7fbqqsvDwwOHDiwX6vVPPPMMxERESjXxWa3v/Hmmx9t2zY6NhYTE7N4yWKdTu/1ejo7u5qbm04cPzY8PPzCiy/k5eUJsKUMhuE0Te/csfPV118dtFo1Wl1mZmZiQqJKre7t621ubKq+fOm5Z389MGi99+67lUoliBjDcWu/9ZWXf7979ycMQ8fGxM6YOUOr1TkcI12dXV1dXR988EFza8ujP3h0QsmEQH4C6QVJkKWnTn/0t+0er3vhgoKHNzw8f8E8g8HAcbzdZi8vL3/nnbc//mQXgWOAJ4A2MmDJIAQMNP7ClSqlFF8uJq6jXYBdggUUSiYBgOzt7dq6ZcvAgHVW5uxfPP30woKFFKXAMWHM7S49eeq555+tq6/98MMP586dYwkJgQ0zYCwdIKl8c3NTcXHxvffem5CQQFIKlqErK6t+97vflZ89fejQgYKCRXfd9W0BtFwiT544sWvXzrGx0YUFhT/60Q9BOiZBcjw/ODS4beu2N99443J11Y4dOzIzZylICuIsUV1d/d577/b19WXMzHjgOw8ULV4SHhZKEITD6Tx27Nhbf3qrtbX59ddfS01JWbmyhGcA99q+fdsnn3xC4NiNN66///77Z8yYQVIUyzIDVuuePZ9t2vROWdkpgpwsOjqghg48emPunTt22Oy2+LiEJ598YuWqVVJjQFyv08XGxpIk9ZOf/IhhfCpSzXIgwwSxesiQOZbl/JmicHrEe2FHIg7uu9zODiBaQmJCWFjY/fc/sGr1asAPgVtc0Ki1t9xyc3V19UsbX6ioqLBaraFhFtgEFRFb3uN2h6RZ7rrrrtmzQUqQIACOWly8nGHYhx767rDNVnHhwh13gGhDRKfT0mbExcQ++NCDOTk5PAc67WI4lhifcM8995aePHnq1MmzZ886HM7w0FBYscS7Z89nTU2NoZbQp5566vobrper9eh1uttvu43j+N8892xfX+/RI0eWFy8nCKK2tnr7Rx95PGOrVq3+2c9+lpAQL/bTxbUmo/nhhxNsdtumP/+59OTxK/MAgC+dnR0V589jAra4aHHBooUwAQZWCIBxLwSOLy9eNmfO3EOHD6gwlZzUJyc4owjIcTIIyg8VZAFTigeJjYv73e/+R6tWG4xG2JMGFguCkygpZUb6TJKiHGA4QbEcDDQlQqDjBaG4eMXMmekA3ugJoIcVO3funIxZs0pPnfR6PKipLcdxq1atLlxUqNcbtFoNyzJQA4B5fRwfER42O3P2qVOltmGbyzUK0BzH+/utJ44fd3u8629ZXgIKboAwVPQiLAfS8G+++aburq7S0pNZ2Tkcx5E4vn//gebmZpPJ+K1v/WdCQjzLMCIDBIV+BI1GtXrVyh07dzhH7EGS0wS9DohQbW2tg0NWrVazsGChVgd7DiHFUdRchJAQ8/LlAOwoewnxABA6y4FMAn85oADxVKwyhIuZvfJQq1RRkZEms1mMbAQ1hXiWY0DzLoxnWHC8WI5xu91S4Bvg5yBfXK3Jys5SoobGksIoCLxWp42OjiVwnGEY1KAYw3CNWhMREaHTaiFIQHdVVuBplqFZmuFYlVpNURTDsj4vyHknSLKnq7u9vY1SKBYXLdboQEhzoNYnCIJOq3vkkQ3vvPPOTTfdRBKk2+MtO33ax/iioqOzc7Lk5msohwQ0HeeFtLQZaSlpoLf1FQ8A+GdgYICm6bCwsISEREgrQdKPyCAgJcFxPDMTBlvDHZfSeWUIiiG9wVGOcEEEUCv86VtAkQAfuVyuxoamlraWvr5eu31kbGyUIAiD0Xjh/HkQVowByV3M0hRDegSlSmk06iUdwt/xhyJJHSgrCBBfXgOKwbXZbE2NzZ1dnVar1W63ezxu2IgQu3ihQqlQQPiJ3cH7rX0er0er1SUkxgdtjbQNmIDp9XqDwcDzoGPs2NhYT283z/MWS6jRaJKVu8DYS5PJlJSUVF19abw/QNInZZ0WZxgWKikalVIZHOrlv0ulUoCkIg7IDIj+iNYSqcNwMG+H8emoj5MQIHfBZTY0NLz713cPHwXNz2jaC9s9g2BjpVoFOorCYl2w05RIw6TkeKAYigcTMhoRS2HwOkrpEcNvcYxmmPPnz72/efPpM2eGh4cZmkY1wKBYiWvUapjdBMKRUYquzT5MELjZbNLrwaEJfBeUqYaQW2qsK/h8XvfYKA7zwkC384CsXpHkYhhFkTqdDgSBBW9/AIAl64pGqyNw0uv1jIyMjGtni7CPF/ievh6vz0uRYoNqSc0DcicoHDHOvCJpxwJ8E9T2Fb1/fX3Dr371q+PHj2I4npSQmJKWDDq8Y7jBaEhOSblQcWHHjh0YjlEUylaT+oqJcZ0SZgY3y5HTY+S6ZPv3H9i48cWGhjqCIBPi4+MTE0JDQzWgBbNKqVJdrq4uLy+XqpyhjAQAcFi2BHSNH08m0JmTfsDm4iCTE26N2MPaXwFISlYDydzgVHJTFWzyv01sTKxSrXaMjNTX15esLAFoIqMAlARoH32uvJz20Uq9MmACsPsCD4R9sZlZAN3EMdzr83IcC5utI3IEOj5++OGHR44cVqvV99xzz113fzs+Pk4BogRJkiQ1Wt3WrVs//uQTMQfTL0/BFtf+VOLgN5WS7mAFESBQDgwNbd2ypba2Liws7KGHHrzhxusjIiKARQFumVKpfPHFF8vKymD2DWq1K0RGRuEY0B6GBm1A5sVlLBTjHJExhsAJHna91Ov0ZlNIR2e7Y8Th9XhMQKCQquNJaToMy9hsNpAUPdnm+9+A4/iMjPSkpCSPz3vs+LHOzm6xwAOCETzgjU1NZWWnAQUAhhkRKiq1SqlUcjw36nKhCn8BudPgWPT39ft8tJypQZFUe3v7wYP7Gca3fHnxU089lZ2Vo9PpVSo1yiTkOdbpGOFg5l4AWgU4O0VTRlC+jRgqC+kUYMIE3t3d3dBQT2D4nXd8e8Mjj6SmpGo0WopEhAJUB25qagSkE9bCQTPGx8cZjUaP21NbWy932Q4cSFKqqr40OjrK86AsXUpKCkmQ1gFrb18fCEiVziKSRgiCGLBa29vbxldLmWjd5jguKjrqtltvVSqU5eXlb7z5RndXN9C54Po4nmtrb/3wgw/6+vpJkkLiGUzqFIx6o8lgEgS+u7sbCC1S7Uj0eKTBsaA7qqAAdXvgmgaH7CN2iqRMZpNKBVrAyjX3CBx3u8dAvR2WJWHnRHF/5WIEUAMfj0ZStC1aEsrPdLlcNO1TKhWpaakkgTM0KPqKAEiSZFVl5aWqKo1WqwC5mADFWIaJT0jIz88ncGzfvs9bWloDzIdgUpKk+vr6n3vuuQ0bNuzbf4DnBYVSuXJliUFvHBoePnbsGO2j5cJDiE0IAl9WVtbd3QXOzUR4BryDSGNvvmX9ggUFHMf+7W/bf/bzn324ZeuJE6UHDx7atOmdp5/++aGDBzIzMxUKJZLPBAHnOUGv18fFxRM4WVNXe/LESfeYG1TngGNszH3s2PHq6mp0bFEiMS/woaGhlpBQAROqKqsaGhpI1CYYtq11jY7+9a/vnThxgiQp2OlXQnmQZiOJNuhd5GRSyfIE5VS5ByRvNJrUKi3DsmfOnAFZ/GJ/cgHHyd7evs3vvc/QDElQGEZQMB9UEDCT0XTjjTeaTKbauto3/vRmX2+vaDyBo7e377XX/rh37+e9PV39/f0UpRB4oWRlydw5c1mO271797FjxxiGAe8J+37zPF9x/sK2bR95vD6NWntlRUw8ubExsT/4wSMbN/qam5uPHz92oaIiMiKS5Vj7iI3A8Tvv/HZ2ds7jTzzOMh7UV1wQMEqhWLN2zekzZQMD1pdfedlq7Z+ZPhPHcIfTWVtTW1lZGRYeNghamnqhlAVoXVpqyto1a3t7ezs62l555ZW77vp2XFys1+vt7Ow6cuRwxcWLRoPZbhsB5aKQgU4CNqxIhjJ8/X3OZcO4WLUDlj4VeCE5KTE9I6Oru+vQoYOWEPOyZctCQkAf3OFh26d7PnWMOMLCIqzWQYPYuhpm7+N4cXHJokX7jx498tme3c4Rx8qVK6OiQHtWgONHjx05coSiqMLCwuuuuw5atISY6Ojvfve73T3dXV1dG195ua6uLjsnW2/QMzTT1Ni06+OP6+vrtVrtHbfdfvV+wig7rHj5cpPZfPjQoZqamuHhYZ7jjSZjbl7e8mXF11+/rra2FrWuJylgk0V5/tdff13N5eqt27ZdulTV1dUZHh5OEqTD6WQYZs2aNckpyXV1dYBJjLkQDVFr1Pfdf9/A4ODnez87fORQVVWl2WTy+rxDQ0NRkdGPP/F4Q139q6+9ihwS0PcAUB/QPQzkbSOJVrYHI6QXBIBAqOYAaIONYeYQ8/3339fa0tLW0fbOpk07d+3S6/Q4TtjtttDQ0J///Gdbtm51ezxeUEMUGH2RwBsZGfHEE08yDHv+/Ll9+/aeKj1pMJoIkvS43aAgEkEWFi5+6qmnUtPSOGB6AT6SkpUlDsfIpj9vamxoaGlq0usNKo2aY1mn0+n2eKIio/7jP7710PcfvLo5GvEFiqLmz5+XlZlps9vtIyO0z6fT6SIjo8xms1anHhoaZhkG5bDLqXmhoZaHN2wIj4goO3Wqrb29v9+qVCqTk5NXr161du263t7e1tbWEbs9JiYGpTmyLBsfH/+jHz4ZExN94sSJvr7ewaEhiqIyMzMfeOA7N95448kTJ06WllIKCnVBR8tLSkrMyck16PUmo0mUSwOEdAwTMjIycrLzsrJmK1VKUMqN5ZYuW7rx5Y3btm0vLz87bBse9g6HmM35+fnrb7556dJlTpdreGg41BJqMplwyH5Q39m8vNwX/vd/Dxw6dOzosaamBqfTwQuCQafPnDVrcVHRf3zrP5OTk1EdL1SQR6lS/eett6ampX7y8e4LFy4MDg2O2O0ESUZERMybN+/6669fsGAhUAWunKAhcg4gTbIURSkpChVykHK1gXSnUCr++Nobv/zlM3qD4dVXX12/fj1ooS7KXCDnbWhoqKuzc2TEYTIZU1NTw8PCCZJkGGZkxM4wTEhICDQhiDmmBEH4aF93d3dfXz8k2cbo6Oiw8AhMEBjGZ7PZcRwPtVgohQIJJDTtHXWNYhhovA2lQtmJKBai93g8o6OjOp1ep0NlbcHKQOE5r7e3p7evv08QhOjo6JiYaK1WD91WDCo8YjaboUPNXyYHdk4WHCOO7u7ugYEBAcNCzKao6Kjw8HAFpQj21on+HJwA5doGBwYHBwZGR8eADycqKiY6WqPVArV7GonaoB5cWVnZvr37klNS1q+/KTIqEvOfd/CODofjscee2Lv3s+jo2LffebuosJChaVQvQ3xdWDgSTYf4MFooAXO4RSOBfOCkbvHi0YNQRmU0kBEbmAgQTYGCI1QSwDaxHJCpJsavofISsLAdI+c8IwoVmEQuJnTDv3IuuNzZWPKdShq1fC/0d8KqgYGnLsh3LX3XbxSA7j/xjquTIAVFtba2vv/B+zguVFZV3vdf982cMUOpUnE85x5zW63Wzz//vOz0KaVSuWzZslkZGWLdWPAEqYU2sN3COimBJwsJ5vgEjzD8w8KSIAga/ncTgDM20GCOKquzsMzDJOlXcApE3GTcF/kDyvkGplN/OXnZAIMsuAGrle0yUiUjSBhEw7uoBgZKX4F3QrUXmQGlUy4KaAhRrkqCKJLo7Or65S9/uX//PgEDpVxzYYE6r9fT09Pb2dnZ3d3N8eyigkXPPPNMTnY2KjMjbwiy+fizWL+adi7CZNEPfo0SlmG6QozmVZs2TLwXib6yLV2aZpKloY/gPiA9ICiEYjpJegJJEq2tbW+//c7evZ/3WwFpVlAKHnpbKIoKD49YUbzi/gfuz8rOlsv3+w1wgaUKJuD7lzJkD/ikAJAayk/dyHZcMYXJxiTAk5x848rVTVwdQr2pioBPCwDIb+VyucrLy0+fPt3a2jIy4sAwzGQyJiYmLViwoKCgICwsDBVWC3QmT4VxwavDphPpNe1vTpmtP9W9k2H31Vcuzy09dKqPg0ouTJJmO81qKchaAKQan290dMzj8QBPoUar1+tAjAKKvZksavH/HABTjSnzrScegC8RAOOPzT8AADEoUS6IJ9a/ksPPpjWm+iKO/buOL1QrAtmBpxE++cUGjv0bj2kB4KuM2Maxf+/xb50fgH0Nxv8HwixFcGklXzkAAAAASUVORK5CYII=", + "created": 1789344000000, + "lastRetrieved": 1789344000000 + } + } +} diff --git a/content/learning-paths/mobile-graphics-and-gaming/swin2sr-vgf/swin2sr-image-flow.svg b/content/learning-paths/mobile-graphics-and-gaming/swin2sr-vgf/swin2sr-image-flow.svg new file mode 100644 index 0000000000..5b36cacddc --- /dev/null +++ b/content/learning-paths/mobile-graphics-and-gaming/swin2sr-vgf/swin2sr-image-flow.svg @@ -0,0 +1,22 @@ + +Swin2SR upscales a low-resolution 64 by 64 RGB image to a super-resolved 128 by 128 outputRead left to right. Swin2SR uses learned super-resolution to reconstruct higher-resolution detail from a low-resolution 64 by 64 RGB image. ExecuTorch and Arm VGF run the model on the host to produce a 128 by 128 RGB image. Both images are displayed at the same size to compare detail; the input is enlarged for display only. The labels show their actual pixel dimensions. The two arrows show this single sequence using actual example images. + + + + + + + Upscale an image with Swin2SRSame display size; input enlarged for comparisonLow-resolution inputSuper-resolved output64 × 64 RGB128 × 128 RGBSwin2SR ×2ExecuTorch + Arm VGFRuns on the host diff --git a/content/learning-paths/mobile-graphics-and-gaming/swin2sr-vgf/swin2sr-result-comparison.png b/content/learning-paths/mobile-graphics-and-gaming/swin2sr-vgf/swin2sr-result-comparison.png new file mode 100644 index 0000000000..6062e32e06 Binary files /dev/null and b/content/learning-paths/mobile-graphics-and-gaming/swin2sr-vgf/swin2sr-result-comparison.png differ