diff --git a/.github/skills/summary-faq-workflow/SKILL.md b/.github/skills/summary-faq-workflow/SKILL.md index 5c116d8590..59b4e6a080 100644 --- a/.github/skills/summary-faq-workflow/SKILL.md +++ b/.github/skills/summary-faq-workflow/SKILL.md @@ -6,7 +6,7 @@ description: Generate, style-review, and patch AI-assisted Learning Path summari # Summary and FAQ workflow Use this skill when a user asks to generate, review, or style-fix the -`generated_summary_faq` block in Learning Path `_index.md` files. +`generated_summary_faq` block in Learning Path `_index.md` files. The summary renders on the introductory page with `who_is_this_for`, `learning_objectives`, and `prerequisites`. The FAQs render on the next steps page with `further_reading`. If subagents are available, use three roles: diff --git a/.gitignore b/.gitignore index 0d5a16ecc8..4dcc6d487e 100644 --- a/.gitignore +++ b/.gitignore @@ -22,6 +22,7 @@ startup.sh nohup.out venv/ +.venv/ z_local_saved/ /.idea/ /tools/.python-version diff --git a/.htmltest.yml b/.htmltest.yml index c6f52ef394..530c41b91f 100644 --- a/.htmltest.yml +++ b/.htmltest.yml @@ -10,4 +10,9 @@ IgnoreURLs: - "localhost" - "127.0.0.1" - "192.168.64.39" - - "/livereload.js" \ No newline at end of file + - "/livereload.js" + # Single-page app that uses client-side hash routes (#/sme/...), not element IDs + - "^/apps/sme-visualisations/#/" + # Homepage cards link to sections that aren't built from this repo + - "^/courses/$" + - "^/insights/$" \ No newline at end of file diff --git a/.wordlist.txt b/.wordlist.txt index 8a9369e1dc..430b75b3be 100644 --- a/.wordlist.txt +++ b/.wordlist.txt @@ -7730,3 +7730,56 @@ validator's validators yolox zprofile +ABAC +DDP +Distrobox +EfficientNet +Googlebook +Nota +SDL +Sidebottom +Termux +TinyCNN +TinyStories +VSI +aacb +abbb +abec +acaf +adebf +adeec +afbf +augreg +baed +bbdb +bbeb +befae +clayer +cnn +dbfe +ddfd +deacd +dfdb +distrobox +ecaef +edad +effaec +efficientnet +exponentiates +fcfd +ffde +ffec +fullscreen +googlenet +iframe +letterboxing +migrators +nota +nvm +peYlm +shufflenet +termux +topk +userfaultfd +visualisations +wideresnet diff --git a/assets/contributors.csv b/assets/contributors.csv index 8495f0c8d8..da5fe8f32d 100644 --- a/assets/contributors.csv +++ b/assets/contributors.csv @@ -186,6 +186,8 @@ Karthik Gopalakrishnan,Tinkerblox,,,, David Torres,ThirdAI,,,, Sammy Sahnine,,,,, Matthew Sloyan,Arm,matthewsloyanARM,,, -Austin Hill,,,,, -Andreas Mullen,Arm,,,, -Liam Randall,,,,, +Austin Hill,Arm,hilaus-arm,austinchill,, +Andreas Mullen,Arm,,,, +Michalis Spyrou,Arm,,,, +Michael Koslov,Arm,,,, +Liam Randall,Cosmonic,,hectaman,,https://cosmonic.com/ diff --git a/assets/css/content-pages.css b/assets/css/content-pages.css index 5c78aabdab..06cb670495 100644 --- a/assets/css/content-pages.css +++ b/assets/css/content-pages.css @@ -301,7 +301,6 @@ html[theme='dark'] .incorrect-explain {color: #e86868} /* 27% lighter than arm's line-height: 1.1; margin: 0; } - .generated-summary-faq__assist { align-items: center; display: inline-flex; @@ -379,6 +378,31 @@ html[theme='dark'] ads-expansion-panel.generated-summary-faq__panel { font-size: 16px; } +/* Keep ADS rendering while native links provide page navigation. */ +.learning-path-nav-control { + display: inline-block; + position: relative; +} + +.learning-path-nav-hitarea { + position: absolute; + inset: 0; + border-radius: 4px; + cursor: pointer; +} + +.learning-path-nav-hitarea:focus-visible { + outline: 2px solid var(--ads-ui-violet-40); + outline-offset: 3px; +} + +.learning-path-nav-control:hover ads-button, +.learning-path-nav-control:focus-within ads-button { + --ads-button-background-color-primary: var(--arm-green); + --ads-button-border-color-primary: var(--arm-green); + --ads-button-color-primary: var(--lp-hover-text); + --ads-button-border-color-secondary: var(--arm-green); + --ads-button-color-secondary: var(--lp-hover-text); /* Next Steps: resources and feedback side by side. */ .next-steps-layout { display: grid; @@ -404,3 +428,28 @@ html[theme='dark'] ads-expansion-panel.generated-summary-faq__panel { .next-steps-resources { grid-column: 1 / span 8; } .next-steps-feedback { grid-column: 9 / span 4; } } + +.next-steps-layout { + display: grid; + grid-template-columns: minmax(0, 1fr); + gap: 2rem 1.5rem; + align-items: start; +} + +@media (min-width: 900px) { + .next-steps-layout { + grid-template-columns: minmax(0, 2fr) minmax(0, 1fr); + } + + .next-steps-resources { grid-column: 1; } + .next-steps-feedback { grid-column: 2; } +} + +@media (min-width: 1280px) { + .next-steps-layout { + grid-template-columns: repeat(12, minmax(0, 1fr)); + } + + .next-steps-resources { grid-column: 1 / span 8; } + .next-steps-feedback { grid-column: 9 / span 4; } +} diff --git a/assets/css/cross-page.css b/assets/css/cross-page.css index daf653424a..f7a53ae6fe 100644 --- a/assets/css/cross-page.css +++ b/assets/css/cross-page.css @@ -410,3 +410,51 @@ arm-footer-navigation:not(:defined) { #arm-footer { contain: layout; } + +/* Native links inside Learning Path and Install Guide listing cards. */ +ads-card.path-card ads-card-content, +ads-card.tool-card ads-card-content { + display: flex; + flex-direction: column; +} + +a.listing-card-link, +a.listing-card-link:hover, +a.listing-card-link:focus { + display: flex; + flex-direction: column; + flex: 1; + width: 100%; + color: inherit; + text-decoration: none; +} + +/* Stretch each native link across the card, including its padding. */ +ads-card.path-card, +ads-card.tool-card { + position: relative; +} + +ads-card.path-card ads-card-content, +ads-card.tool-card ads-card-content, +a.listing-card-link { + position: static; +} + +a.listing-card-link::after { + content: ""; + position: absolute; + inset: 0; + z-index: 2; + border-radius: var(--ads-card-border-radius); + cursor: pointer; +} + +a.listing-card-link:focus-visible { + outline: none; +} + +a.listing-card-link:focus-visible::after { + outline: 2px solid var(--ads-ui-violet-40); + outline-offset: 2px; +} diff --git a/assets/css/home.css b/assets/css/home.css index cc912b7e3a..8987e790a6 100644 --- a/assets/css/home.css +++ b/assets/css/home.css @@ -56,7 +56,19 @@ ads-breadcrumbs:not(:defined) { padding-top: 24px; } -.homepage-section > h2 { +.homepage .sr-only { + position: absolute; + width: 1px; + height: 1px; + padding: 0; + margin: -1px; + overflow: hidden; + clip: rect(0, 0, 0, 0); + white-space: nowrap; + border: 0; +} + +.homepage-section > h2:not(.sr-only) { color: var(--ads-ui-ink-05); font-size: clamp(26px, 2.5vw, 32px); font-weight: 400; @@ -85,9 +97,36 @@ ads-breadcrumbs:not(:defined) { .homepage-topic-card { --ads-card-background-color: #2A2742; --ads-card-border-radius: 8px; - --ads-card-padding: 16px; + --ads-card-padding: 0; --ads-card-min-height: 116px; + --ads-card-transform-hover: none; border: 1px solid transparent; + transition: border-color 0.3s ease-in-out, transform 0.3s ease-in-out; +} + +.homepage-topic-card:hover, +.homepage-topic-card:focus-within { + --ads-card-border-color-hover: #848192; + --ads-card-box-shadow-hover: #000 @50%, X:0 Y: 3 B:12; + border-color: #848192; +} + +.homepage-topic-card:hover { + transform: scale(1.01); +} + +.homepage-card-link, +.homepage-card-link:hover, +.homepage-card-link:focus { + color: inherit; + text-decoration: none; + outline: none; +} + +.homepage-topic-card:focus-within, +.homepage-resource-card:focus-within { + outline: 2px solid var(--ads-cta-link-border-focus-color); + outline-offset: -2px; } .homepage-topic-content { @@ -95,6 +134,9 @@ ads-breadcrumbs:not(:defined) { align-items: center; gap: 16px; height: 100%; + width: 100%; + padding: 16px; + box-sizing: border-box; } .homepage-topic-content > div { @@ -132,10 +174,7 @@ ads-breadcrumbs:not(:defined) { .homepage-resource-card { --ads-card-background-color: #2A2742; /* #6B677C */ --ads-card-border-radius: 10px; - - --ads-card-padding: 8px; - - + --ads-card-padding: 0; border: 1px solid transparent; transition: border-color 0.3s ease-in-out; } @@ -147,12 +186,12 @@ ads-breadcrumbs:not(:defined) { border-color: #848192; } - - -.homepage-resource-card ads-card-content { - padding-left: 8px; - padding-top: 4px; - padding-bottom: 4px; +.homepage-resource-card .homepage-card-link { + display: block; + height: 100%; + width: 100%; + padding: 12px 8px 12px 16px; + box-sizing: border-box; } .homepage-resource-card h3 { @@ -169,13 +208,29 @@ ads-breadcrumbs:not(:defined) { gap: 24px; } +.homepage-contribution-actions .c-cta-button[data-theme='dark'], .homepage-contribution-actions ads-cta-button { + --ads-cta-button-background-color-primary: #7233f7; + --ads-cta-button-background-color-primary-focus: #8047f8; + --ads-cta-button-background-color-primary-hover: var(--arm-green); + --ads-cta-button-border-color-primary: none; + --ads-cta-button-border-color-primary-focus: none; + --ads-cta-button-border-color-primary-hover: var(--arm-green); + --ads-cta-button-color-primary: #fff; + --ads-cta-button-color-primary-focus: #fff; + --ads-cta-button-color-primary-hover: var(--lp-hover-text); --ads-cta-button-background-color-secondary: transparent; --ads-cta-button-background-color-secondary-hover: var(--homepage-resource-active-background); --ads-cta-button-background-color-secondary-focus: var(--homepage-resource-active-background); --ads-cta-button-border-color-secondary: var(--ads-ui-violet-60); --ads-cta-button-border-color-secondary-hover: var(--ads-ui-violet-40); --ads-cta-button-border-color-secondary-focus: var(--ads-ui-violet-40); + --ads-cta-button-color-secondary: #c7adfc; + --ads-cta-button-color-secondary-focus: #c7adfc; + --ads-cta-button-color-secondary-hover: var(--lp-hover-text); + --ads-cta-button-focus-outer-border-color: #d1bafc; + box-sizing: border-box; + justify-content: center; min-width: 280px; } @@ -209,6 +264,7 @@ table.contributor-table tbody { display: none; } + .homepage-contribution-actions .c-cta-button, .homepage-contribution-actions ads-cta-button { min-width: 0; width: 100%; diff --git a/content/install-guides/distrobox.md b/content/install-guides/distrobox.md new file mode 100644 index 0000000000..2e00a77bb3 --- /dev/null +++ b/content/install-guides/distrobox.md @@ -0,0 +1,259 @@ +--- +title: Distrobox +description: Install Distrobox on Arm Linux or Linux on a ChromeOS or Googlebook OS device, and run an Ubuntu 26.04 container that integrates with your home directory. + + +additional_search_terms: +- distrobox +- container +- Podman +- Ubuntu +- Chromebook +- Googlebook +- Crostini +- Linux + +minutes_to_complete: 15 + +author: Jason Andrews + +official_docs: https://distrobox.it/ + +test_images: +- ubuntu:latest +test_maintenance: false + +weight: 1 # Defines page ordering. Must be 1 for first (or only) page. +tool_install: true # Set to true to be listed in main selection page, else false +multi_install: false # Set to true if first page of multi-page article, else false +multitool_install_part: false # Set to true if a sub-page of a multi-page article, else false +layout: installtoolsall # DO NOT MODIFY. Always true for tool install articles +--- + +You can use [Distrobox](https://distrobox.it/) to run any Linux distribution inside a container while sharing your home directory with the host. Distrobox uses Podman or Docker underneath, so that you can create a container and enter it similar to a normal shell. You can install packages with the package manager for the distribution, and remove the container when you're done. Your files stay on the host, which makes the containers safe to experiment with and quick to throw away. + +Distrobox is useful on Arm systems when you want a different distribution than your host, or a clean build environment for testing. + +You'll learn how to install Distrobox and run an Ubuntu container on a system running Arm Linux. + +You can use any of the following hosts: + +- A physical Arm device +- An Arm-based virtual machine +- The Linux development environment on a ChromeOS or Googlebook OS device + +## Before you begin + +Make sure that you're using a system running Arm Linux. + +Confirm the architecture: + +```bash +uname -m +``` + +The expected output for 64-bit Arm systems is `aarch64`. + +Distrobox needs a container engine. Podman is used in these steps because it runs containers without root privileges. This suits both Arm Linux and the ChromeOS and Googlebook OS Linux environment. + +{{% notice Note %}} +On a ChromeOS or Googlebook OS device, set up the Linux development environment first. On ChromeOS, open **Settings**. Navigate to **About ChromeOS** and select **Developers**. Then, turn on **Linux development environment**. + +On Googlebook OS, open the **Terminal** app from the app drawer. Follow the prompts to initialize the Linux environment. This creates a managed Debian environment where you install and run Distrobox. The environment already provides the user namespace and `subuid` and `subgid` configuration that rootless Podman needs. +{{% /notice %}} + +## Install Distrobox on Arm Linux + +The following steps are for a Debian-based distribution. This can be Ubuntu, or the Debian environment on a ChromeOS or Googlebook OS device. + +Install Podman, Distrobox, and the `uidmap` package for rootless containers: + +```bash +sudo apt update +sudo apt install -y podman distrobox uidmap curl +``` + +Confirm that the tools are installed: + +```bash +distrobox version +podman --version +``` + +The output is similar to: + +```output +distrobox: 1.8.1.2 +podman version 5.4.2 +``` + +Check that Podman can run containers without root privileges: + +```bash +podman info --format '{{.Host.Security.Rootless}}' +``` + +The expected output is: + +```output +true +``` + +A `true` result confirms that rootless mode is working. You can create and enter containers as your normal user. + +## Verify Distrobox installation + +You'll now verify Distrobox installation by creating a container and running commands in it. The container will run `arm64` software. + +### Create an Ubuntu 26.04 container + +Create a container named `ubuntu26` from the official Ubuntu 26.04 image. Podman automatically pulls the `arm64` variant of the image for your Arm CPU: + +```bash +distrobox create --name ubuntu26 --image docker.io/library/ubuntu:26.04 --yes +``` + +The output is similar to: + +```output +Trying to pull docker.io/library/ubuntu:26.04... +Creating 'ubuntu26' using image docker.io/library/ubuntu:26.04 [ OK ] +Distrobox 'ubuntu26' successfully created. +To enter, run: + +distrobox enter ubuntu26 +``` + +### Enter the container + +The first time you enter a container, Distrobox sets up your user, sudo access, and the shared home directory. This takes a moment. Later entries are faster. + +Enter the container: + +```bash +distrobox enter ubuntu26 +``` + +When setup finishes, your shell prompt changes to show that you're inside the container. + +Confirm the distribution and architecture: + +```bash +grep PRETTY_NAME /etc/os-release +uname -m +``` + +The output is similar to: + +```output +PRETTY_NAME="Ubuntu 26.04.1 LTS" +aarch64 +``` + +You're now in an Ubuntu 26.04 environment on Arm. Your home directory is shared with the host, so files that you create are visible in both places. Confirm this by listing your home directory: + +```bash +ls $HOME +``` + +You'll see the same files and directories as on your host. + +Install packages with `apt` as you would on any Ubuntu system: + +```bash +sudo apt update +sudo apt install -y htop +``` + +{{% notice Note %}} +Any software that you install inside the container needs to have an `arm64` build. Most packages in the Ubuntu repositories provide one, so `apt` installs work as expected on your Arm device. +{{% /notice %}} + +### Exit the container + +To leave the container and return to your host shell, press **Ctrl+D**. + +The container keeps running in the background after you exit. You can enter it again without waiting for setup. + +### Run a command in the container from the host + +To run a single command inside the container from your host, pass it after `--`: + +```bash +distrobox enter ubuntu26 -- uname -m +``` + +The output is similar to: + +```output +aarch64 +``` + +### View container status + +See a list of containers that you've created, and their status: + +```bash +distrobox list +``` + +The output is similar to: + +```output +ID | NAME | STATUS | IMAGE +56452187200e | ubuntu26 | Up 23 minutes | docker.io/library/ubuntu:26.04 +``` + +## Stop the container + +Stop the running container without deleting it: + +```bash +distrobox stop ubuntu26 +``` + +The container files and installed packages stay in place. Enter the container again at any time to resume work. + +## Delete the container + +When you no longer need a container, make sure that it's stopped first, then delete it. + +Delete the test container: + +```bash +distrobox rm ubuntu26 +``` + +Deleting a container removes its installed packages. Your home directory stays on the host because it's shared rather than stored inside the container. + +## Find other distributions for Distrobox + +Distrobox doesn't have its own catalog of distributions. It creates containers from standard container images that are hosted on registries such as Docker Hub and quay.io. Any distribution with a suitable image works with Distrobox. + +List the images tested for the Distrobox project: + +```bash +distrobox create --compatibility +``` + +The output is a list of image names, and includes entries similar to: + +```output +docker.io/library/debian:stable-backports +docker.io/library/debian:unstable +quay.io/fedora/fedora:44 +quay.io/toolbx-images/almalinux-toolbox:9 +quay.io/toolbx-images/alpine-toolbox:edge +``` + +The list changes as new releases are tested. The [Distrobox compatibility page](https://distrobox.it/compatibility/#containers-distros) shows the same information in a table, grouped by distribution. + +{{% notice Note %}} +The compatibility list doesn't indicate which images support Arm. Before you use an image, check that its registry page lists an `arm64` variant. Most official images from Ubuntu, Debian, Fedora, and Alpine provide one. +{{% /notice %}} + +## Next steps + +You're now ready to use Distrobox to run Ubuntu 26.04 and other distributions on your Arm device. + +To create a container from any image on the compatibility list or a registry, pass its name to the `--image` option. diff --git a/content/install-guides/dotnet.md b/content/install-guides/dotnet.md index bd2f0e57d9..9925f67f22 100644 --- a/content/install-guides/dotnet.md +++ b/content/install-guides/dotnet.md @@ -20,7 +20,7 @@ weight: 1 The [.NET SDK](https://dotnet.microsoft.com/en-us/) is a free, open-source, cross-platform development environment that provides tools and libraries for building applications. You can use it to create web apps, mobile apps, desktop apps, cloud services, and more. -.NET 10 is the latest Long Term Support (LTS) release. .NET 9 (Standard Term Support) and .NET 8 (LTS) are also available. This guide defaults to .NET 10, with instructions for selecting an alternative version. +.NET 10 is the Long Term Support (LTS) release, and .NET 11 is the Standard Term Support (STS) release. This guide uses .NET 10. For current support dates, see the [.NET support policy](https://dotnet.microsoft.com/en-us/platform/support/policy/dotnet-core). The .NET SDK is available for Linux distributions on Arm-based systems. @@ -62,7 +62,7 @@ Use `dnf` to install the .NET 10 SDK on Fedora: sudo dnf install dotnet-sdk-10.0 ``` -To install a different version, replace `10.0` with the version you need. For example, use `dotnet-sdk-9.0` for .NET 9 or `dotnet-sdk-8.0` for .NET 8. +To install a different version, replace `10.0` with the version you need. For example, use `dotnet-sdk-11.0` for .NET 11. If the .NET SDK is not found in your package manager, you can install it using a script. @@ -86,10 +86,10 @@ To install the latest LTS version (.NET 10), run: bash ./dotnet-install.sh ``` -To install the latest available version (including STS releases), run: +To install the latest STS release, run: ```bash -bash ./dotnet-install.sh --version latest +bash ./dotnet-install.sh --channel STS ``` To install a specific version channel, use the `--channel` flag. For example, to install .NET 10: @@ -98,7 +98,7 @@ To install a specific version channel, use the `--channel` flag. For example, to bash ./dotnet-install.sh --channel 10.0 ``` -You can also use `--channel 9.0` for .NET 9 or `--channel 8.0` for .NET 8. +You can also use `--channel 11.0` for .NET 11. 3. Add the .dotnet folder to the PATH environment variable: diff --git a/content/install-guides/e2b.md b/content/install-guides/e2b.md new file mode 100644 index 0000000000..f8adb7d90a --- /dev/null +++ b/content/install-guides/e2b.md @@ -0,0 +1,319 @@ +--- +title: E2B + +description: Install a self-hosted E2B sandbox environment on Arm Linux with Docker Compose, KVM, and Firecracker microVMs. + +minutes_to_complete: 25 +official_docs: https://docs.e2b.dev/ + +author: Pareena Verma + +test_images: +test_maintenance: false + +weight: 1 +tool_install: true +multi_install: false +multitool_install_part: false +layout: installtoolsall +--- + +E2B provides isolated Linux sandboxes for AI agents and generated code. A self-hosted E2B installation runs each sandbox in a Firecracker microVM and exposes the E2B API and SDK interfaces. + +You'll install [E2B Embed](https://github.com/e2b-dev/runtime/tree/main/embed/compose), the official single-host deployment, on an Arm Linux system. E2B Embed uses Docker Compose to run the control plane, Firecracker orchestrator, dashboard, and supporting services on one host. + +These instructions are for Ubuntu 24.04 LTS on `aarch64`. E2B requires kernel-based virtual machine (KVM) and Linux kernel 6.10 or later on Arm. + +## Before you begin + +Use a dedicated Arm Linux host with KVM, such as an Arm AGI CPU platform or an Arm-based bare-metal cloud instance. The installation loads kernel modules and reserves huge pages. It creates host directories and network namespaces, and changes host networking and system settings. + +You need the following prerequisites: + +- Ubuntu 24.04 LTS on `aarch64` +- Linux kernel 6.10 or later +- KVM and the TUN/TAP device +- A 4 KiB page-size kernel and cgroup v2 +- Sudo access +- Docker Engine 27 or later, and Docker Compose 2.24 or later +- 12 GiB of RAM and 20 GiB of free disk space, as recommended by E2B +- Internet access to Docker Hub, Google Artifact Registry, Google Cloud Storage and GitHub + +The default configuration reserves 4 GiB of RAM as huge pages for sandboxes. + +### Check the Arm Linux host + +Print the architecture, kernel version, page size, and cgroup filesystem type: + +```bash +uname -m +uname -r +getconf PAGESIZE +stat -fc %T /sys/fs/cgroup +``` + +Confirm that the output shows the following values: + +- `aarch64` for the architecture +- Kernel version 6.10 or later +- `4096` for the page size +- `cgroup2fs` for the cgroup filesystem + +{{% notice Note %}} +- The E2B Embed version used in this guide doesn't support 64 KiB-page kernels on Arm. E2B requires a 4 KiB-page kernel, and Firecracker currently supports only 4 KiB host and guest kernels on `aarch64`. Support for 64 KiB pages is currently tracked as a [Firecracker feature request](https://github.com/firecracker-microvm/firecracker/issues/6381). +- If `getconf PAGESIZE` returns `65536`, switch to a 4 KiB-page kernel before continuing. For more information, see [E2B Embed host requirements](https://github.com/e2b-dev/runtime/tree/main/embed/compose#requirements). +{{% /notice %}} + +If Ubuntu 24.04 is still using its original 6.8 kernel, install the current hardware enablement kernel: + +```bash +sudo apt update +sudo apt install -y linux-generic-hwe-24.04 +sudo reboot +``` + +After the system restarts, run `uname -r` again and confirm that the active kernel is version 6.10 or later. + +### Check KVM and TUN/TAP + +Confirm that the KVM and TUN/TAP devices exist: + +```bash +ls -l /dev/kvm /dev/net/tun +``` + +Check that the current user can access KVM: + +```bash +if [ -c /dev/kvm ] && [ -r /dev/kvm ] && [ -w /dev/kvm ]; then + echo "KVM device is accessible" +else + echo "STOP: resolve KVM availability or permissions before continuing" +fi +``` + +The expected output is: + +```output +KVM device is accessible +``` + +If `/dev/kvm` belongs to the `kvm` group but your user doesn't have access, add the user to the group: + +```bash +sudo usermod -aG kvm "$USER" +``` + +Activate the new group membership: + +```bash +newgrp kvm +``` + +The command starts a new shell with `kvm` as the active group. + +### Install the host packages + +Install the packages required by E2B and its verification steps: + +```bash +sudo apt update +sudo apt install -y ca-certificates curl e2fsprogs iproute2 iptables python3-venv rsync +``` + +### Confirm Docker installation + +If Docker isn't already installed, follow the [Docker Engine install guide](/install-guides/docker/docker-engine/). + +Add your user to the `docker` group so that the E2B commands don't require `sudo`: + +```bash +sudo usermod -aG docker "$USER" +``` + +Activate the new group membership: + +```bash +newgrp docker +``` +Print the installed versions: + +```bash +docker version --format 'Docker Engine {{.Server.Version}}' +docker compose version +``` + +The output is similar to: + +```output +Docker Engine 29.8.0 +Docker Compose version v5.5.1 +``` + +Confirm that Docker Engine is version 27 or later and Docker Compose is version 2.24 or later. + +## Install E2B Embed + +Create a directory for the Compose deployment: + +```bash +mkdir -p ~/e2b +cd ~/e2b +``` + +{{% notice Note %}} +These commands pin E2B runtime commit `780b991b5e4d814f5a7ef625a21033d75416e0f1` because `main` changes over time and release tag `2026.30` doesn't contain the Embed Compose files. This revision provides matching `compose.yaml` and `.env` files, pins E2B API v0.30.0, and was validated on an Arm AGI CPU. If you select another commit from the [E2B runtime repository](https://github.com/e2b-dev/runtime), download both files from that commit. +{{% /notice %}} + +Download the Compose file and its matching environment file: + +```bash +e2b_runtime_commit=780b991b5e4d814f5a7ef625a21033d75416e0f1 +curl -fsSLo compose.yaml "https://raw.githubusercontent.com/e2b-dev/runtime/${e2b_runtime_commit}/embed/compose/compose.yaml" +curl -fsSLo .env "https://raw.githubusercontent.com/e2b-dev/runtime/${e2b_runtime_commit}/embed/compose/.env" +``` + +Validate the Compose configuration: + +```bash +docker compose config --quiet +``` + +The command exits without output when the configuration is valid. + +Start E2B and wait for the base sandbox template to become ready: + +```bash +docker compose up -d --wait +``` + +The first run performs host checks, configures the host, and downloads the Firecracker artifacts and container images. It also initializes the databases and builds the `base` template. The download and build can take several minutes. + +{{% notice Warning %}} +The E2B Compose file publishes multiple service ports on every host interface. Keep the host behind a firewall. Expose ports 3000, 3001, and 3002 only to trusted clients, if needed. In particular, don't expose the unauthenticated orchestrator API on port 5008. +{{% /notice %}} + +## Verify the installation + +Check the service state: + +```bash +docker compose ps +``` + +In the output, confirm that the `ready` service has a status beginning with `Up`. E2B uses this service to indicate that the stack and the `base` template are usable. The other long-running services should also show `Up` and, when a health check is configured, `(healthy)`. + +Include the one-time setup services in the output: + +```bash +docker compose ps -a +``` +The following setup services should show `Exited (0)`: + +- `preflight` +- `host-setup` +- `fetch-artifacts` +- Database migrators +- `seed` +- `base-template` + +A nonzero exit code or a long-running service that isn't `Up` indicates a failed installation. + +Run the packaged smoke test: + +```bash +docker compose --profile test run --rm smoke +``` + +The test creates a sandbox through the E2B SDK and runs a command in the Firecracker microVM. It reaches a test service through the client proxy and deletes the sandbox. Docker prints container status updates before the test result. + +The final line of the output is similar to: + +```output +smoke: ok sandbox=i7hkvuw9l8pybg2bfreo8 port 8080 reached through http://127.0.0.1:3002 +``` + +The sandbox ID differs on each run. Confirm that the final line begins with `smoke: ok` and reports that port 8080 was reached through `http://127.0.0.1:3002`. + +### Run Python in an E2B sandbox + +Load the local E2B API endpoints and generated team API key into the current shell: + +```bash +eval "$(docker compose exec ready cat /run/e2b/sdk.env)" +``` + +The API key is a secret. Don't print or store the command output in logs. + +Create a Python virtual environment and install the SDK version tested by the pinned E2B deployment: + +```bash +python3 -m venv .venv +.venv/bin/pip install e2b==2.46.0 +``` + +Run a Python program that creates a sandbox, prints its architecture, performs a calculation, and deletes the sandbox: + +```bash +.venv/bin/python - <<'PY' +from e2b import Sandbox + +sandbox = Sandbox.create("base") +try: + result = sandbox.commands.run( + "uname -m && python3 -c 'print(6 * 7)'" + ) + print(result.stdout, end="") +finally: + sandbox.kill() +PY +``` + +The expected output is: + +```output +aarch64 +42 +``` + +This confirms that the E2B API created an Arm64 Firecracker sandbox and ran commands inside it. + +## Troubleshoot E2B installation + +If `docker compose up` fails, identify the failing service: + +```bash +docker compose ps -a +``` + +Read the logs for the setup services: + +```bash +docker compose logs preflight host-setup fetch-artifacts base-template +``` + +Look for a line beginning with `FIX:`, correct the reported problem, and run `docker compose up -d --wait` again. The setup steps are idempotent and skip work that already succeeded. + +If sandbox creation fails on Arm with `Failed to UFFD object`, the running kernel lacks the userfaultfd write-protect support that E2B needs. Install the Ubuntu 24.04 hardware enablement kernel, reboot, and confirm that `uname -r` reports kernel 6.10 or later. + +If the stack reports insufficient huge pages, check the current allocation: + +```bash +grep -E 'HugePages_Total|HugePages_Free|Hugepagesize' /proc/meminfo +``` + +The default `HUGEPAGES=2048` reserves 2048 pages of 2 MiB each, or 4 GiB. On a host with less memory, lower `HUGEPAGES` in `.env` and run `docker compose up -d --wait` again. A 512 MiB `base` sandbox needs 256 of the 2 MiB huge pages. + +If the smoke test fails, inspect the main runtime logs: + +```bash +docker compose logs api orchestrator client-proxy +``` + +After a host reboot, return to `~/e2b`. Run `docker compose up -d --wait` to restore the host networking state that's required by E2B. + +## Next steps + +You can now use the E2B SDKs to run AI agent code in self-hosted Firecracker microVMs on Arm Linux. + +For configuration, upgrades, security considerations, and sandbox limits, see the [E2B Embed Docker Compose documentation](https://github.com/e2b-dev/runtime/tree/main/embed/compose). diff --git a/content/install-guides/vscode-tunnels.md b/content/install-guides/vscode-tunnels.md index bf23153813..8b203890ef 100644 --- a/content/install-guides/vscode-tunnels.md +++ b/content/install-guides/vscode-tunnels.md @@ -1,16 +1,11 @@ --- -### Title the install tools article with the name of the tool to be installed -### Include vendor name where appropriate title: VS Code Tunnels description: Install the VS Code CLI on Arm systems and configure Remote Tunnels for browser-based access to non-desktop Arm development environments. -### Optional additional search terms (one per line) to assist in finding the article additional_search_terms: - ide - vscode - -### Estimated completion time in minutes (please use integer multiple of 5) minutes_to_complete: 10 author: Jason Andrews @@ -26,64 +21,66 @@ multitool_install_part: false # Set to true if a sub-page of a multi-page arti layout: installtoolsall # DO NOT MODIFY. Always true for tool install articles --- -The Arm architecture is well supported by the popular [Visual Studio Code](https://code.visualstudio.com/) development tool. The [Download page](https://code.visualstudio.com/download) has binaries for all popular Arm architectures and operating systems. Desktop installation is straightforward and there are plenty of tutorials. +Visual Studio Code fully supports the Arm architecture. The [Download page](https://code.visualstudio.com/download) has binaries for all popular Arm architectures and operating systems. Desktop installation is straightforward and there are plenty of tutorials. VS Code Remote Tunnels is a useful feature for non-desktop Arm development. Tunnel use cases include: - Remote Linux servers, including Arm cloud instances, with no Linux desktop installed - Developer virtual machines such as Multipass -- Arm single board computers running Linux +- Arm single-board computers running Linux -To create a tunnel a command-line instance of VS Code is run on the remote machine (server) which registers a tunnel. A browser or a VS Code desktop instance (client) is used to connect to the tunnel and access the remote machine. The tunnel removes the need for open ports or SSH port forwarding. VS Code tunnels also work well for connecting to Arm boards on your local network when you are away because no changes to the - network are needed. +A command-line instance of VS Code is run on the remote machine (server) which registers a tunnel. A browser or a VS Code desktop instance (client) is used to connect to the tunnel and access the remote machine. The tunnel removes the need for open ports or SSH port forwarding. VS Code tunnels also work well for connecting to Arm boards on your local network when you are away because no changes to the network are needed. -{{% notice Note %}} -Creating VS Code tunnels requires a [GitHub](https://github.com/) account. -{{% /notice %}} +Creating VS Code tunnels requires a [GitHub](https://github.com/) or [Microsoft](https://account.microsoft.com/) account. This guide uses GitHub. Create an account if you don't already have one. -## What are the prerequisites before installing VS Code Tunnels? +## Before you begin -Follow the instructions below to install either the CLI version or the desktop version of VS Code on an Arm Linux machine. This is the remote machine you want to use for development. +Install either the CLI version or the desktop version of VS Code on an Arm Linux machine. This is the remote machine you want to use for development. -The use cases for VS Code tunnels assume SSH or command line access to the remote Linux machine is available, but no Linux desktop or browser access is required. This means VS Code must be installed from the command line. +The use cases for VS Code tunnels assume SSH or command-line access to the remote Linux machine is available, but no Linux desktop or browser access is required. This means VS Code must be installed from the command line. Confirm you are using an Arm machine by running: ```bash uname -m ``` -Depending on the version of the Arm architecture, the results are shown below. Both Armv8-A and Armv7-A are supported. -The output should be one of the values shown below. +Depending on the version of the Arm architecture, the output is one of the following. Both Armv8-A and Armv7-A are supported. + +For the Armv8-A architecture, the output is: -For the Armv8-A architecture the output should be: ```output aarch64 ``` -For the Armv7-A architecture the output should be: + +For the Armv7-A architecture, the output is: + ```output armv7l ``` -## Which version of VS Code should I download? +## Download VS Code Download either the CLI version or the desktop version of VS Code. The desktop version is the best choice if the machine has a Linux desktop and you want to use both a remote tunnel and do desktop development. The CLI version is best for tunneling only. -### How do I download the CLI version of VS Code for tunneling? +### Download the CLI version + +Select the download for your Arm architecture. Armv8-A is 64-bit and Armv7-A is 32-bit. -Download a command line (CLI) release of VS Code from the Downloads page. +### Download for Armv8-A -### How do I download VS Code for Armv8-A? ```console wget -O vscode.tgz 'https://code.visualstudio.com/sha/download?build=stable&os=cli-alpine-arm64' ``` -### How do I download VS Code for Armv7-A? + +### Download for Armv7-A + ```console wget -O vscode.tgz 'https://code.visualstudio.com/sha/download?build=stable&os=cli-linux-armhf' ``` -### How do I download the desktop version of VS Code for tunneling and desktop development? +### Download the desktop version VS Code desktop also works for the remote machine. @@ -97,31 +94,64 @@ wget -O vscode.deb 'https://code.visualstudio.com/sha/download?build=stable&os=l The `snap` install is for a non-Arm architecture and does not work. {{% /notice %}} -## How do I install the downloaded version of VS Code? +## Install VS Code For CLI, extract the file. The result is a single executable named `code`. It is placed in the current directory. + ```console tar xvf vscode.tgz ``` + +Then copy the binary to `/usr/local/bin/` so it is available on `PATH`: + +```console +sudo cp code /usr/local/bin/ +``` + For the desktop, install the Debian package. + ```console sudo apt install ./vscode.deb ``` -## How do I start a VS Code Tunnel? -On the remote machine start a VS Code tunnel. The `./` is used to indicate the CLI version which was extracted in the current directory. +## Verify the installation + +Confirm the installed binary works: ```console -./code tunnel --name my-tunnel-1 --accept-server-license-terms +code --version ``` -For the desktop, ensure the `code` executable is on `PATH`. The `./` should be omitted: +For the CLI version, the output looks like: + +```output +code 1.146.0 (commit 69047191fc427f2f92828279aae1d90d8eeda7ab) +``` + +For the desktop version, the output looks like: +```output +1.146.0 +69047191fc427f2f92828279aae1d90d8eeda7ab +arm64 +``` + +The exact version numbers will differ, but a successful response confirms the binary is working. The `arm64` line in the desktop output also confirms the correct architecture was installed. + +## Start a VS Code tunnel + +On the remote machine, start a VS Code tunnel. + ```console code tunnel --name my-tunnel-1 --accept-server-license-terms ``` -If `--name` is not used, an arbitrary name will be assigned to the tunnel. -The VS Code tunnel server will print a URL to authenticate and link it to your GitHub account. +If `--name` is not used, an arbitrary name is assigned to the tunnel. + +{{% notice Note %}} +This command runs the tunnel in the foreground, attached to your terminal session. The tunnel stays online only while the command is running. If you close the terminal, disconnect your SSH session, or press `Ctrl+C`, the tunnel stops and disappears from your tunnel list. To keep a tunnel running permanently, install it as a service instead. See [Run a tunnel as a service](#service). +{{% /notice %}} + +The VS Code tunnel server prints a URL to authenticate and link the machine to your GitHub account. ```output * * Visual Studio Code Server @@ -132,17 +162,94 @@ The VS Code tunnel server will print a URL to authenticate and link it to your G * To grant access to the server, please log into https://github.com/login/device and use code XXXX-YYYY ``` -Visit [device link](https://github.com/login/device) and then enter the code shown. +Open [https://github.com/login/device](https://github.com/login/device) in a browser and enter the code shown. + +After the code is entered, the tunnel comes online and prints the connection URL: +```output +[2026-01-01 00:00:00] info Creating tunnel with the name: my-tunnel-1 + + Visual Studio Code Tunnel v1.146.0 -After the code is entered, the remote device is connected to your GitHub account. + ➜ Tunnel: my-tunnel-1 + ➜ Open: https://vscode.dev/tunnel/my-tunnel-1 +``` ![Device Connect #center](/install-guides/_images/vsc-device-connect.png) -## How do I connect to the remote machine using VS Code Tunnels? +## Run a tunnel as a service {#service} + +The foreground `code tunnel` command stops when the terminal closes. For a tunnel that stays online across logouts and reboots, install it as a background service. On Linux, this registers a `systemd` user service that starts the tunnel automatically. + +```console +code tunnel service install --name my-tunnel-1 --accept-server-license-terms +``` + +The first time you install the service, you are prompted to authenticate with GitHub using the same device-code flow as the foreground tunnel command. After you enter the code, the service registers and starts: +```output +[2026-01-01 00:00:00] info Successfully registered service... +[2026-01-01 00:00:00] info Successfully enabled unit files... +[2026-01-01 00:00:00] info Tunnel service successfully started +[2026-01-01 00:00:00] info Tip: run `sudo loginctl enable-linger $USER` to ensure the service stays running after you disconnect. +Service successfully installed! You can use `code tunnel service log` to monitor it, and `code tunnel service uninstall` to remove it. +``` + +Run the `loginctl` command shown in the tip to keep the service alive across SSH logouts and reboots: +```console +sudo loginctl enable-linger $USER +``` + +Manage the service with these commands: + +| Command | Action | +|---------|--------| +| `code tunnel service log` | Follow the live service log (press `Ctrl+C` to exit) | +| `code tunnel service uninstall` | Stop and remove the service | + +Running `code tunnel service uninstall` prints: +```output +[2026-01-01 00:00:00] info Successfully stopped service... +[2026-01-01 00:00:00] info Tunnel service uninstalled +``` + +## Find and manage tunnels -The remote machine is now ready to accept client connections. These can be from a [browser](#browser) or [VS Code desktop](#vsdesktop). +If you started a tunnel but cannot find it, the most common reason is that it was run in the foreground and stopped when the terminal closed. Use the commands below to check the current state on the remote machine. -### How do I connect using a browser? {#browser} +Check whether a tunnel is running and whether a service is installed: +```console +code tunnel status +``` +The output reports the tunnel name, whether it is `Connected`, and whether a service is installed: +```output +{"tunnel":{"name":"my-tunnel-1","tunnel":"Connected", ... },"service_installed":true} +``` +If the output shows `"tunnel":null` and `"service_installed":false`, no tunnel is currently running. Start one again, or install it as a service so it persists. + +Check which GitHub account the tunnel is registered to: +```console +code tunnel user show +``` +```output +logged in with provider GitHub Account +``` + +Other useful management commands: + +| Command | Action | +|---------|--------| +| `code tunnel kill` | Stop any tunnel currently running on this machine | +| `code tunnel restart` | Restart the running tunnel | +| `code tunnel rename ` | Change the machine's tunnel name | +| `code tunnel prune` | Delete registered tunnels that are not currently running | +| `code tunnel unregister` | Remove this machine's association with the tunnel service | + +You can also see every tunnel registered to your account, and whether each one is online, by opening [https://vscode.dev](https://vscode.dev) and selecting **Connect to Tunnel**, or from the **Remote Explorer** in VS Code Desktop. + +## Connect to the remote machine + +The remote machine is now ready to accept client connections. These can be from a browser or VS Code desktop. + +### Connect using a browser The quickest way to connect to the remote machine is using a browser. Even a tablet or phone can be used. @@ -150,7 +257,7 @@ Connect using a browser by visiting the link which is printed by the server. The link will contain the tunnel name specified with `--name` or a created name if no name was provided. -In the example above, the tunnel link is: +If you used `--name my-tunnel-1`, the tunnel link is: ```url https://vscode.dev/tunnel/my-tunnel-1 ``` @@ -158,32 +265,28 @@ If you do not remember or cannot see the tunnel name, open: ```url https://vscode.dev ``` -When VS Code opens, click on the lower left corner and select `Connect to Tunnel`. +When VS Code opens, click on the lower-left corner and select **Connect to Tunnel**. ![Remote #center](/install-guides/_images/vsc-remote.png) -A list of tunnels attached to your account will be opened. If you are not signed in to GitHub it will require authentication before showing the list of tunnels. The tunnel list also shows if the tunnel is online and ready for a connection. +A list of tunnels attached to your account opens. If you are not signed in to GitHub, it will require authentication before showing the list of tunnels. The tunnel list also shows if the tunnel is online and ready for a connection. -Select the tunnel to open and VS Code will connect to the remote machine and you are ready to use VS Code on the remote machine. +Select the tunnel to open. VS Code connects to the remote machine and you're ready to develop software. -### How do I connect using VS Code Desktop? {#vsdesktop} +### Connect using VS Code Desktop Connecting to a tunnel from VS Code Desktop requires the [Remote - Tunnels Extension](https://marketplace.visualstudio.com/items?itemName=ms-vscode.remote-server). -Search for `remote tunnels` in the Extensions Marketplace and install the extension. +Search for `remote tunnels` in the **Extensions** view and install the extension. -Just as with the browser connection, click on the lower left corner and select `Connect to Tunnel`. +Just as with the browser connection, click on the lower-left corner and select **Connect to Tunnel**. ![Remote #center](/install-guides/_images/vsc-remote.png) -A list of tunnels attached to your account will be opened. If you are not signed in to GitHub it will require authentication before showing the list of tunnels. The tunnel list also shows if the tunnel is online and ready for a connection. - -Select the tunnel to open and VS Code will connect to the remote machine and you are ready to use VS Code on the remote machine. - -## How do I close a tunnel connection? +## Close the tunnel connection -On both browser and desktop, click the lower left (which now shows the name of the connected tunnel) and select `Close Remote Connection` to disconnect from the tunnel server. +On both browser and desktop, click the lower-left corner (which now shows the name of the connected tunnel) and select **Close Remote Connection** to disconnect from the tunnel server. -## What are the key takeaways? +## Summary VS Code tunnels and your GitHub account make it easy to connect to Arm machines running Linux for terminal access or to do development on a remote machine with VS Code. This is done without any open ports or SSH port forwarding. diff --git a/content/learning-paths/automotive/_index.md b/content/learning-paths/automotive/_index.md index 2d15e7afef..4c38f28206 100644 --- a/content/learning-paths/automotive/_index.md +++ b/content/learning-paths/automotive/_index.md @@ -20,14 +20,14 @@ subjects_filter: - Performance and Architecture: 10 operatingsystems_filter: - Baremetal: 1 -- Linux: 15 +- Linux: 18 - macOS: 1 - other: 1 - RTOS: 2 tools_software_languages_filter: - Arm Compiler for Embedded: 1 - Arm Development Studio: 1 -- Arm Zena CSS: 2 +- Arm Zena CSS: 5 - BitBake: 2 - C: 2 - Clang: 3 @@ -40,7 +40,9 @@ tools_software_languages_filter: - Gazebo: 1 - GCC: 4 - Git: 1 +- GStreamer: 1 - Linux traffic control: 1 +- llama.cpp: 2 - Multipass: 1 - Navigation2: 1 - Perf: 1 @@ -50,7 +52,9 @@ tools_software_languages_filter: - ROS 2: 7 - Rust: 1 - RViz: 1 +- Siemens Innexis ANA: 3 - SME2: 1 +- SSH: 1 - Tinkerblox: 1 - topdown-tool: 1 - Yocto: 3 @@ -74,5 +78,4 @@ tools_software_languages_filter: # auto-generated padding to avoid Hugo YAML alias limit # auto-generated padding to avoid Hugo YAML alias limit # auto-generated padding to avoid Hugo YAML alias limit -# auto-generated padding to avoid Hugo YAML alias limit --- diff --git a/content/learning-paths/automotive/freertos-zena-css/_index.md b/content/learning-paths/automotive/freertos-zena-css/_index.md index 930757c173..e1d7297bb2 100644 --- a/content/learning-paths/automotive/freertos-zena-css/_index.md +++ b/content/learning-paths/automotive/freertos-zena-css/_index.md @@ -40,17 +40,17 @@ generated_summary_faq: it on the standalone Cortex-R82AE FVP. You'll then configure Zena CSS and load the binary directly into Safety Island Cluster 1. Next, you'll substitute the firmware to validate secure boot. Finally, you'll apply and inspect a Yocto patch that makes FreeRTOS selectable. - # faqs: - # - question: What should I check if the FreeRTOS application fails early on the standalone Cortex-R82AE FVP? - # answer: Check each bring-up stage before moving to the next. You can use Arm Development Studio for source-level debugging or Tarmac Trace to locate where startup stops. - # - question: What must I change before loading FreeRTOS directly into Zena CSS Cluster 1? - # answer: You need to use the Zena CSS memory map, Safety Island UART address, and Cluster 1 interrupt configuration. For direct loading, configure GIC view 0 and start the FVP reference counter so the scheduler tick can run. - # - question: How do I test FreeRTOS through the normal Zena CSS secure boot flow? - # answer: Build the `zena_css_fvp` binary, substitute it for the Cluster 1 payload in `do_sign_images()`, rebuild the signed firmware image, and boot the Zena CSS FVP. At the SI CL1 console, enter `ping` and check for responses from cores 0 through 3. - # - question: How do I select FreeRTOS instead of Zephyr in the Yocto build? - # answer: Apply the supplied `freertos-yocto-integration.patch` to a clean Zena CSS checkout. In `kas menu`, select **RD-Aspen Cfg2** and **FreeRTOS** under **Safety Island RTOS**, then run `kas build`. - # - question: How can I verify that Yocto built and booted the FreeRTOS image? - # answer: Check that `pn-buildlist` contains `freertos-demos-cl1` instead of `zephyr-demos-cl1`, then inspect the deployed FreeRTOS binary and RSE flash image. Boot the FVP and enter `ping` at the SI CL1 console; responses from all four cores confirm runtime operation. + faqs: + - question: What should I check if the FreeRTOS application fails early on the standalone Cortex-R82AE FVP? + answer: Check each bring-up stage before moving to the next. You can use Arm Development Studio for source-level debugging or Tarmac Trace to locate where startup stops. + - question: What do I need to change before loading FreeRTOS directly into Zena CSS Cluster 1? + answer: You need to use the Zena CSS memory map, Safety Island UART address, and Cluster 1 interrupt configuration. For direct loading, configure GIC view 0 and start the FVP reference counter so that the scheduler tick can run. + - question: How do I test FreeRTOS through the normal Zena CSS secure boot flow? + answer: Build the `zena_css_fvp` binary, substitute it for the Cluster 1 payload in `do_sign_images()`, rebuild the signed firmware image, and boot the Zena CSS FVP. At the Safety Island Cluster 1 console, enter `ping` and check for responses from cores 0 through 3. + - question: How do I select FreeRTOS instead of Zephyr in the Yocto build? + answer: Apply the supplied `freertos-yocto-integration.patch` to a clean Zena CSS checkout. Run `kas menu arm-zena-css/Kconfig`, select **RD-Aspen Cfg2**, then choose **Baremetal** or **Virtualization** and **FreeRTOS** under **Safety Island RTOS**. Run `kas build`. + - question: How can I verify that Yocto built and booted the FreeRTOS image? + answer: Check that `pn-buildlist` contains `freertos-demos-cl1` instead of `zephyr-demos-cl1`. Old deploy artifacts can remain, so the presence of the file alone doesn't prove which recipe was selected. Inspect the deployed FreeRTOS binary and RSE flash image, then boot the FVP and enter `ping` at the Safety Island Cluster 1 console. Responses from all four cores confirm runtime operation. # END generated_summary_faq author: diff --git a/content/learning-paths/automotive/innexis_ana_zena/1_understand_zena_css.md b/content/learning-paths/automotive/innexis_ana_zena/1_understand_zena_css.md index 77e7b18122..c5d3be02a8 100755 --- a/content/learning-paths/automotive/innexis_ana_zena/1_understand_zena_css.md +++ b/content/learning-paths/automotive/innexis_ana_zena/1_understand_zena_css.md @@ -1,12 +1,16 @@ --- -title: Understand the Zena CSS virtual platform +title: Introduction to the Zena CSS virtual platform in Siemens Innexis ANA weight: 2 ### FIXED, DO NOT MODIFY layout: learningpathall --- -## Understand the Zena CSS virtual platform +## Introduction to the Siemens Innexis Architecture Native Acceleration + +[Siemens Innexis Architecture Native Acceleration (ANA)](https://resources.sw.siemens.com/en-US/fact-sheet-innexis-ana/) is a virtual system-on-chip (vSoC) platform that enables engineering teams to develop, debug, and test embedded software before physical chips or boards are available. It provides configurable virtual hardware—including processors, memory, and peripherals—and runs software natively on Arm-based servers, delivering substantially faster execution than traditional instruction-set simulation. Its [cloud service](https://aws.amazon.com/marketplace/pp/prodview-o5nb3mu4upsc4) offers browser-based access, scalable computing resources, and APIs for automated testing, allowing distributed teams to collaborate on operating systems, drivers, middleware, and applications. The core benefit is earlier software readiness: teams can identify integration issues sooner, reduce dependence on physical prototypes, and shorten development cycles for software-defined vehicles and other complex embedded products. + +## Introduction to the Zena CSS virtual platform in Innexis ANA In [Innexis ANA](https://www.siemens.com/en-gb/products/ic/hav/innexis/architecture-native-acceleration/), a *chamber* provides the environment in which you create and run a virtual platform. The **Arm-Zena-CSS** vSoC describes the virtual hardware. The [**Arm-Zena-CSS EWAOL Software Stack**](https://arm-zena-css.docs.arm.com/en/v2.2/overview.html) supplies the software images used to boot it. @@ -29,6 +33,6 @@ The firmware consoles help you see how the virtual system reaches Linux. They do For this Learning Path, your first working result is the **EWAOL Linux login prompt on the primary-compute console**. You will then inspect the guest from its shell. You do not need to change firmware or rebuild the software stack. -## Check your understanding +## What you have learned Before continuing, locate **Arm-Zena-CSS** and its **EWAOL Software Stack** in your chamber. If either is absent, ask the chamber administrator which Zena assets are available. diff --git a/content/learning-paths/automotive/innexis_ana_zena/4_connect_to_guest.md b/content/learning-paths/automotive/innexis_ana_zena/4_connect_to_guest.md index 358fb66bd3..82335447f6 100755 --- a/content/learning-paths/automotive/innexis_ana_zena/4_connect_to_guest.md +++ b/content/learning-paths/automotive/innexis_ana_zena/4_connect_to_guest.md @@ -16,7 +16,11 @@ In **Lab Manager > Networking > Port Mapping** (or **Device Access Ports**), sel ![ANA Port Mapping panel with the Authorize button and generated SSH tunnel command#center](ana_port_mapping.png "Authorize an ANA SSH tunnel") -Find the TCP entry whose **target port** is `22`. Record its target IP and external port in your private run notes. Read the network prefix from the guest interface. Do not treat every listed external port as an SSH port. + 1. Find the TCP entry whose **target port** is `22`. + 2. Record its target IP and external port in your private run notes. + 3. Read the network prefix from the guest interface. + + NOTE: Do not treat every listed external port as an SSH port. ![ANA Port Mapping table showing the external TCP port mapped to guest port 22#center](ana_port_mapping2.png "Find the SSH port mapping") @@ -61,7 +65,15 @@ systemctl is-active sshd.socket ## Authorize the tunnel and connect -In ANA, select or register your local SSH public key and choose **Authorize** for this VP. Copy the complete tunnel command that ANA generates and run it on your **local computer**. Keep that terminal open. Do not include the generated endpoint or key material in a published example. +In ANA dashboard: + + 1. Select or register your local SSH public key and choose **Authorize** for this VP. + 2. Copy the complete tunnel command that ANA generates and run it on your **local computer**. + 3. In the command copied, add "-i $HOME/.ssh/PRIV_SSH_KEY_FILENAME" where + PRIV_SSH_KEY_FILENAME is the name of the private key file whose public key you authorized above. + 4. Issue the command in a local terminal. The command should continue running. + +Keep that terminal open. Do not include the generated endpoint or key material in a published example. In a second **local terminal**, enter the external port from the mapping whose target port is `22`: diff --git a/content/learning-paths/automotive/innexis_ana_zena/5_share_and_verify.md b/content/learning-paths/automotive/innexis_ana_zena/5_share_and_verify.md index b6f9c318bb..ad495de354 100755 --- a/content/learning-paths/automotive/innexis_ana_zena/5_share_and_verify.md +++ b/content/learning-paths/automotive/innexis_ana_zena/5_share_and_verify.md @@ -74,6 +74,6 @@ Before stopping, save the boot marker, guest environment output, SSH check, file For a persistence check, start the **same project** again. In the tested run, the shared folder and files remained in the ANA workspace, but Linux needed the 9p mount command again after the VP restarted. Remount the share and read **lp1-check.txt** to confirm it is still available. Stop the virtual platform again when you finish this check. -## What you have accomplished +## What you have learned You have completed this Learning Path when you have a recorded Linux boot, guest environment details, a successful SSH connection, a verified file round trip, and a stopped virtual platform. These results establish a boot and guest-access baseline on this virtual platform. They do not measure physical-silicon performance or validate its security properties. \ No newline at end of file diff --git a/content/learning-paths/automotive/innexis_zena_camera_vlm/2_configure_virtual_camera.md b/content/learning-paths/automotive/innexis_zena_camera_vlm/2_configure_virtual_camera.md index 7934ba9a1e..1d5caad0f5 100644 --- a/content/learning-paths/automotive/innexis_zena_camera_vlm/2_configure_virtual_camera.md +++ b/content/learning-paths/automotive/innexis_zena_camera_vlm/2_configure_virtual_camera.md @@ -80,7 +80,7 @@ In the ANA Web IDE, open **Explorer** and drag `automotive-parked-cars-640x480.m In **Lab Manager → Device Connections → Audio/Video Inputs**, find `vsock-camera-0` under **Camera Inputs**. Confirm that **None** is currently selected. The following screenshot was captured while the virtual platform was running, so the controls are greyed out: -![ANA Lab Manager Audio/Video Inputs page showing vsock-camera-0 with None selected#center](ana_camera_inputs_none.png "Find vsock-camera-0 and select None") +![ANA Lab Manager Audio/Video Inputs page showing vsock-camera-0 with None selected#center](ana_camera_inputs_none.webp "Find vsock-camera-0 and select None") If **None** isn't selected, stop the virtual platform. Select **None**, then select **Save** and restart the virtual platform. diff --git a/content/learning-paths/automotive/innexis_zena_camera_vlm/_index.md b/content/learning-paths/automotive/innexis_zena_camera_vlm/_index.md index 724f366f18..eac75d4683 100644 --- a/content/learning-paths/automotive/innexis_zena_camera_vlm/_index.md +++ b/content/learning-paths/automotive/innexis_zena_camera_vlm/_index.md @@ -46,30 +46,31 @@ generated_summary_faq: inspect a JPEG from `/dev/video0`, and download a matching model and projector for `llama-cli`. Finally, you'll save the image-inference log and exit status. Optionally, you can capture frames from moving traffic and compare two model responses. - # faqs: - # - question: Do I need to run this in the same guest where I built llama.cpp? - # answer: >- - # Yes. You use the same Zena CSS Linux guest as the prerequisite Learning Path so your - # `llama-cli` binary is available. - # - question: How do I check that the virtual camera is configured and reachable from the guest? - # answer: >- - # Check that `virtualcam-bridge@1.service` is active, the file-input command returns `OK`, - # and the `INPUT` readback shows your selected file. Then capture a JPEG from `/dev/video0` - # and inspect it to confirm that the intended image arrived. - # - question: Which GStreamer elements should be present before I try to capture a frame? - # answer: >- - # You need `v4l2src`, `videoconvert`, `jpegenc`, `filesink`, and `waylandsink`. Check each - # element with `gst-inspect-1.0` before you capture a frame. - # - question: How do I verify the model and `mmproj` files are set correctly for `llama.cpp` image - # inference? - # answer: >- - # You download the pinned model and matching multimodal projector (`mmproj`) from the - # specified revision. Check that both files pass their SHA-256 checks before inference. - # - question: What outputs should I expect after running the final command block? - # answer: >- - # You should find `vision-run.exit` and `vision-run.log` in - # `/root/zena-camera-vlm/results/`. Check for exit status `0`, confirm that the log names - # the captured JPEG after `Loaded media from`, and compare the response with your saved image. + faqs: + - question: Do I need to run this in the same guest where I built llama.cpp? + answer: >- + Yes. You use the same Zena CSS Linux guest as the prerequisite Learning Path so your + `llama-cli` binary is available. + - question: How do I check that the virtual camera is configured and reachable from the guest? + answer: >- + Check that `virtualcam-bridge@1.service` is active, the file-input command returns `OK`, + and the `INPUT` readback shows your selected file. Then capture a JPEG from `/dev/video0` + and inspect it to confirm that the intended image arrived. + - question: Which GStreamer elements should be present before I try to capture a frame? + answer: >- + Check `v4l2src`, `videoconvert`, `jpegenc`, `filesink`, and `waylandsink` with + `gst-inspect-1.0`. The JPEG capture pipeline uses the first four elements; + `waylandsink` is checked but isn't part of that pipeline. + - question: How do I verify the model and `mmproj` files are set correctly for `llama.cpp` image + inference? + answer: >- + You download the pinned model and matching multimodal projector (`mmproj`) from the + specified revision. Check that both files pass their SHA-256 checks before inference. + - question: What outputs should I expect after running the final command block? + answer: >- + You should find `vision-run.exit` and `vision-run.log` in + `/root/zena-camera-vlm/results/`. Check for exit status `0`, confirm that the log names + the captured JPEG after `Loaded media from`, and compare the response with your saved image. # END generated_summary_faq author: Odin Shen diff --git a/content/learning-paths/automotive/innexis_zena_camera_vlm/ana_camera_inputs_none.png b/content/learning-paths/automotive/innexis_zena_camera_vlm/ana_camera_inputs_none.png deleted file mode 100644 index e57ea41e0a..0000000000 Binary files a/content/learning-paths/automotive/innexis_zena_camera_vlm/ana_camera_inputs_none.png and /dev/null differ diff --git a/content/learning-paths/automotive/innexis_zena_camera_vlm/ana_camera_inputs_none.webp b/content/learning-paths/automotive/innexis_zena_camera_vlm/ana_camera_inputs_none.webp new file mode 100644 index 0000000000..6759abffde Binary files /dev/null and b/content/learning-paths/automotive/innexis_zena_camera_vlm/ana_camera_inputs_none.webp differ diff --git a/content/learning-paths/cross-platform/compute-flow-getting-started/_index.md b/content/learning-paths/cross-platform/compute-flow-getting-started/_index.md index 5bd84dadf9..d75281ca26 100644 --- a/content/learning-paths/cross-platform/compute-flow-getting-started/_index.md +++ b/content/learning-paths/cross-platform/compute-flow-getting-started/_index.md @@ -38,30 +38,30 @@ generated_summary_faq: You'll set up Compute Flow and use it to build an audio-to-audio pipeline on an Arm-based device. First, you'll learn about Compute Flow and bricks. Then, you'll create an application that connects speech-to-text, translation, and text-to-speech bricks. You'll start with the Parakeet model for speech-to-text. Then, you'll switch to Moonshine by installing its implementation and model, rebuilding, and selecting its manifest. Finally, you'll compare speech-to-text performance between the two models. - # faqs: - # - question: How do I know my Mac is using the Arm architecture? - # answer: >- - # Run `uname -m` in your terminal and confirm that the output is `arm64`. - # - question: What should I do if Compute Flow reports missing dependencies? - # answer: >- - # Run `compute-flow check`, follow the suggested action for each missing dependency, and rerun - # `compute-flow check` to confirm the result. The check does not install dependencies or test - # whether a compiler can compile and link a program. - # - question: Which option should I use to switch from Parakeet to Moonshine for speech recognition? - # answer: >- - # Install the Moonshine speech-to-text implementation and model, rebuild with - # `compute-flow build native`, then pass `moonshine_manifest_base_en.json` to your application - # or CLI. You can keep your Python script unchanged because both variants implement `stt.v1`. - # - question: What result should I expect when the pipeline runs successfully? - # answer: >- - # You should see the transcription and translation in your terminal. The application saves - # synthesized audio to `translated_french.wav` by default, or to the path you provide with - # `--output`. - # - question: How do I compare the two speech-to-text variants correctly? - # answer: >- - # Run the built speech-to-text CLI for both models on the same 9.963-second mono 16 kHz sample, - # changing only the manifest, and compare their total `run()` times. These sample timings do not - # assess transcription accuracy. + faqs: + - question: How do I know that my Mac is using the Arm architecture? + answer: >- + Run `uname -m` in your terminal and confirm that the output is `arm64`. + - question: What should I do if Compute Flow reports missing dependencies? + answer: >- + Run `compute-flow check`, follow the suggested action for each missing dependency, and rerun + `compute-flow check` to confirm each dependency is available. The check doesn't install dependencies or test + whether a compiler can compile and link a program. + - question: Which option should I use to switch from Parakeet to Moonshine for speech recognition? + answer: >- + Install the Moonshine speech-to-text implementation and model, rebuild with + `compute-flow build native`, then pass `moonshine_manifest_base_en.json` to your application + or CLI. You can keep your Python script unchanged because both variants implement `stt.v1`. + - question: What result should I expect when the pipeline runs successfully? + answer: >- + You should see the transcription and translation in your terminal. The application saves + synthesized audio to `translated_french.wav` by default, or to the output file that you specify with + `--output`. + - question: How do I compare the two speech-to-text variants correctly? + answer: >- + Run the built speech-to-text CLI for both models on the same 9.963-second mono 16 kHz sample, + changing only the manifest. Compare their total `run()` times. These sample timings don't + assess transcription accuracy. # END generated_summary_faq author: Kieran Hejmadi diff --git a/content/learning-paths/cross-platform/explore-sme-visualisations/1-za-layout.md b/content/learning-paths/cross-platform/explore-sme-visualisations/1-za-layout.md index 0e7607167c..730badecc2 100644 --- a/content/learning-paths/cross-platform/explore-sme-visualisations/1-za-layout.md +++ b/content/learning-paths/cross-platform/explore-sme-visualisations/1-za-layout.md @@ -39,7 +39,7 @@ The ZA Tile Layout interactive view shows the same ZA storage as a full array an ## Explore ZA storage and logical tiles -If the embedded visualization doesn't load, [open the ZA layout visualization in a separate browser tab](/apps/sme-visualisations/#/sme/layout). Switch between the Learning Path and the visualization tab. +To keep this Learning Path open while exploring, open the ZA layout visualization in a separate browser tab. Move the tab to a separate window to view the visualization and Learning Path side by side. Use the visualization to explore how the data type and scalable vector length affect the organization of ZA storage. @@ -72,6 +72,7 @@ Use the visualization to explore how the data type and scalable vector length af The visualization still shows four logical tiles, but each tile now contains more elements. +  {{< fullscreen-iframe src="/apps/sme-visualisations/#/sme/layout" diff --git a/content/learning-paths/cross-platform/explore-sme-visualisations/10-interleaved-gemm.md b/content/learning-paths/cross-platform/explore-sme-visualisations/10-interleaved-gemm.md index 0fab0e9d8d..033ae66735 100644 --- a/content/learning-paths/cross-platform/explore-sme-visualisations/10-interleaved-gemm.md +++ b/content/learning-paths/cross-platform/explore-sme-visualisations/10-interleaved-gemm.md @@ -9,23 +9,27 @@ layout: learningpathall ## Compare input layouts in GEMM -This final General Matrix Multiplication (GEMM) visualization begins with matrix A in transposed-and-interleaved layout. It loads input values into Z registers, accumulates outer products in ZA, and writes the output matrix. Compared to the Gather Load version, all loads from **A Input Data** are from contiguous addresses. +This final General Matrix Multiplication (GEMM) visualization begins with matrix A in transposed-and-interleaved layout. It loads input values into Z registers, accumulates outer products in ZA, and writes the output matrix. In contrast to the Gather Load version, all loads from **A Input Data** are from contiguous addresses. ## Trace the interleaved loads -If the embedded visualization doesn't load, [open the interleaved GEMM visualization in a separate browser tab](/apps/sme-visualisations/#/sme/gemm32-2x2-interleave). Switch between the Learning Path and the visualization tab. +To keep this Learning Path open while exploring, open the interleaved GEMM visualization in a separate browser tab. Move the tab to a separate window to view the visualization and Learning Path side by side. -Follow the same stages as the Gather Load GEMM and compare how matrix A reaches Z2 and Z3: +Follow the same stages as the Gather Load GEMM and compare how matrix A data reaches Z2 and Z3: -| Stage | Visualization steps | Operation | +| Stage | Number of steps | Operation | |---|---|---| -| Load the first inputs | 1–4 | Load the first row of **B Input Data** into Z0–Z1 and the first two rows of **A Input Data** into Z2–Z3. The **A Input Data** is loaded from contiguous memory addresses. | -| Calculate the first outer products | 5–8 | Calculate matrix outer product and accumulate the first partial results in ZA0–ZA3. | -| Process the second inputs | 9–16 | Load the second row of B and the third and fourth rows of A, then accumulate outer products in ZA0–ZA3. | -| Process the third inputs | 17–24 | Repeat for the third row of B and the fifth and sixth rows of A. | -| Process the fourth inputs | 25–32 | Repeat for the fourth row of B and the final two rows of A. | -| Store the first results | 33–40 | Write ZA0 and ZA1 to **Output Matrix Data**. | -| Store the remaining results | 41–48 | Write ZA2 and ZA3 to **Output Matrix Data**. | +| Load the first inputs | 4 | Load the first row of **B Input Data** into Z0–Z1 and the first two rows of **A Input Data** into Z2–Z3.| +| Calculate the first outer products | 4 | Calculate matrix outer product and accumulate the first partial results in ZA0–ZA3. | +| Process the second inputs | 8 | Load the second row of B and the third and fourth rows of A, then accumulate outer products in ZA0–ZA3. | +| Process the third inputs | 8 | Repeat for the third row of B and the fifth and sixth rows of A. | +| Process the fourth inputs | 8 | Repeat for the fourth row of B and the final two rows of A. | +| Store the first results | 8 | Write ZA0 and ZA1 to **Output Matrix Data**. | +| Store the remaining results | 8 | Write ZA2 and ZA3 to **Output Matrix Data**. | + +**A Input Data** is loaded from contiguous memory addresses. + +  {{< fullscreen-iframe src="/apps/sme-visualisations/#/sme/gemm32-2x2-interleave" diff --git a/content/learning-paths/cross-platform/explore-sme-visualisations/2-transpose.md b/content/learning-paths/cross-platform/explore-sme-visualisations/2-transpose.md index 0b9f168955..ae8b40a161 100644 --- a/content/learning-paths/cross-platform/explore-sme-visualisations/2-transpose.md +++ b/content/learning-paths/cross-platform/explore-sme-visualisations/2-transpose.md @@ -11,7 +11,7 @@ layout: learningpathall A transpose exchanges rows and columns. ZA tiles make this easy because you can move vectors of values into rows. You can then extract those values back as columns, or vice versa. -The following visualization shows a transpose in-place, where no external memory is used. The transposed result overwrites the original data. If the embedded visualization doesn't load, [open the 32-bit transpose visualization in a separate browser tab](/apps/sme-visualisations/#/sme/transpose32). Switch between the Learning Path and the visualization tab. +The following visualization shows a transpose in-place, where no external memory is used. The transposed result overwrites the original data. To keep this Learning Path open while exploring, open the 32-bit transpose visualization in a separate browser tab. Move the tab to a separate window to view the visualization and Learning Path side by side. The description of each step appears immediately under the **32-bit Transpose** title. It includes the tile addressing. The highlights show the memory and ZA locations involved. @@ -21,13 +21,17 @@ With Scalable Vector Length equal to 256 bits and accessing 32-bit data elements The transpose is achieved by loading data into rows and storing it back from columns. Select the play button or advance manually to follow the algorithm: -1. The first 16 steps load data sequentially from memory into rows of the ZA0 and ZA1 tiles. -2. The next 16 steps load data sequentially from memory into rows of the ZA2 and ZA3 tiles. -3. The next 16 steps store data sequentially into memory from columns of the ZA0 and ZA2 tiles. -4. The final 16 steps store data sequentially into memory from columns of the ZA1 and ZA3 tiles. +| Stage | Number of steps | Operation | +| --- | --- | --- | +| Load first two tiles | 16 | Load data sequentially from memory into rows of the ZA0 and ZA1 tiles. | +| Load next two tiles | 16 | Load data sequentially from memory into rows of the ZA2 and ZA3 tiles. | +| Store two tiles | 16 | Store data sequentially into memory from columns of the ZA0 and ZA2 tiles. | +| Store remaining tiles | 16 | Store data sequentially into memory from columns of the ZA1 and ZA3 tiles. | The original matrix had data increasing sequentially along each row. The resulting transposed matrix instead has data increasing sequentially down each column. To see the original data, use browser reload to reset the visualization. +  + {{< fullscreen-iframe src="/apps/sme-visualisations/#/sme/transpose32" title="Interactive 32-bit matrix transpose" diff --git a/content/learning-paths/cross-platform/explore-sme-visualisations/3-transpose-edge.md b/content/learning-paths/cross-platform/explore-sme-visualisations/3-transpose-edge.md index 47eeee107c..ff7476e17c 100644 --- a/content/learning-paths/cross-platform/explore-sme-visualisations/3-transpose-edge.md +++ b/content/learning-paths/cross-platform/explore-sme-visualisations/3-transpose-edge.md @@ -11,22 +11,22 @@ layout: learningpathall Real matrices don't always divide evenly into vector-sized blocks. The following visualization adds a two-element edge beyond the complete 32-bit blocks. It separates **Input Matrix Data** from **Output Matrix Data**. That way, you can follow the remaining values without losing sight of the original input. -If the embedded visualization doesn't work, [open the incomplete-edge transpose visualization in a separate browser tab](/apps/sme-visualisations/#/sme/transpose32-overflow2). Switch between the Learning Path and the visualization tab. +To keep this Learning Path open while exploring, open the incomplete-edge transpose visualization in a separate browser tab. Move the tab to a separate window to view the visualization and Learning Path side by side. ## Follow the edge values -Select the play button or advance manually to follow the algorithm. Focus on how the last two columns of **Input Matrix Data** are loaded into ZA0 - ZA2 as partial rows in step 5: - -1. The first 10 steps load rows from the first four columns of the input matrix into rows of ZA0-ZA2. -2. The next 12 steps store data sequentially into the output matrix from columns of ZA0-ZA2. -3. The next 10 steps load rows from the next four columns of the input matrix into rows of ZA0-ZA2. -4. The next 12 steps store data sequentially into the output matrix from columns of ZA0-ZA2. -5. The next 10 steps load rows from the last two columns of the input matrix into rows of ZA0-ZA2. - - Only two data values per row are loaded into ZA tiles. This is achieved by using a predicate mask that marks only two columns as active. -6. The last six steps store data sequentially into the output matrix from columns of ZA0-ZA2. - - Only two columns are active, which is why only six steps are needed instead of 12. +Select the play button or advance manually to follow the algorithm. The table shows how each group of **Input Matrix Data** columns moves through ZA0–ZA2: + +| Stage | Number of steps | Operation | +| --- | --- | --- | +| Load the first block | 10 | Load rows from the first four columns of **Input Matrix Data** into rows of ZA0–ZA2. | +| Store the first block | 12 | Store data sequentially in **Output Matrix Data** from columns of ZA0–ZA2. | +| Load the second block | 10 | Load rows from the next four columns of **Input Matrix Data** into rows of ZA0–ZA2. | +| Store the second block | 12 | Store data sequentially in **Output Matrix Data** from columns of ZA0–ZA2. | +| Load the edge block | 10 | Load partial rows from the last two columns of **Input Matrix Data** into rows of ZA0–ZA2. Only two data values per row are loaded into ZA tiles. This is achieved by using a predicate mask that marks only two columns as active. | +| Store the edge block | 6 | Store data sequentially in **Output Matrix Data** from columns of ZA0–ZA2. Only two columns are active during the final store, so it takes six steps instead of 12. | + +  {{< fullscreen-iframe src="/apps/sme-visualisations/#/sme/transpose32-overflow2" diff --git a/content/learning-paths/cross-platform/explore-sme-visualisations/5-pack-a.md b/content/learning-paths/cross-platform/explore-sme-visualisations/5-pack-a.md index 9a43f868da..9a7646e80c 100644 --- a/content/learning-paths/cross-platform/explore-sme-visualisations/5-pack-a.md +++ b/content/learning-paths/cross-platform/explore-sme-visualisations/5-pack-a.md @@ -11,15 +11,21 @@ layout: learningpathall Packing changes the order of values in memory so that a matrix multiplication kernel can load those values more efficiently. The following visualization loads **Input Matrix A** values into rows of ZA, and writes columns of ZA into **Output Packed Data**. Packing changes the layout of data, but it doesn't calculate the matrix product. -If the embedded visualization doesn't load, [open the Pack A visualization in a separate browser tab](/apps/sme-visualisations/#/sme/pack32-a). Switch between the Learning Path and the visualization tab. +To keep this Learning Path open while exploring, open the Pack A visualization in a separate browser tab. Move the tab to a separate window to view the visualization and Learning Path side by side. ## Follow the transpose and pack algorithm Select the play button or advance manually to follow the algorithm: -1. The first 10 steps load rows from **Input Matrix A** into rows of ZA0 - ZA2. Predicates are used to determine which rows are active because different implementations can have different scalable vector lengths. -2. The next 12 steps write columns of ZA data into rows of **Output Packed Data**. -3. The last four steps write zero-padded values. This is because the rows of **Input Matrix A** aren't an exact multiple of the ZA tile height. Predicates control which rows of ZA2 are active. As a result, they control which elements of **Output Packed Data** are zero-padded. +| Stage | Number of steps | Operation | +| --- | --- | --- | +| Load matrix A | 10 | Load **Input Matrix A** into rows of ZA0–ZA2. | +| Store packed data | 8 | Write full columns of ZA data into rows of **Output Packed Data**. | +| Pad the final rows | 4 | Write zero-padded columns of ZA data into rows of **Output Packed Data**. The zero-padding happens because the rows of **Input Matrix A** aren't an exact multiple of the ZA tile height. | + +During matrix A load, predicates determine which rows are active, which in turn determines the elements of **Output Packed Data** that are zero-padded. + +  {{< fullscreen-iframe src="/apps/sme-visualisations/#/sme/pack32-a" diff --git a/content/learning-paths/cross-platform/explore-sme-visualisations/6-pad-b.md b/content/learning-paths/cross-platform/explore-sme-visualisations/6-pad-b.md index d24d35fc40..78a1f51173 100644 --- a/content/learning-paths/cross-platform/explore-sme-visualisations/6-pad-b.md +++ b/content/learning-paths/cross-platform/explore-sme-visualisations/6-pad-b.md @@ -13,18 +13,22 @@ Although unaligned vector loads from memory are supported, they have drawbacks. Consider a matrix with a column count that isn't an exact multiple of the ZA tile column count for a given data element size. For such a matrix, padding the data might be a better solution. Padding results in cleaner loop code and fully sequential memory access. -The same code running on different devices can produce different output data structures, and that isn't a problem. Each device generates a data structure for its own ZA tile width. Each device later uses that data structure with its ZA tiles to compose input vectors for the Outer Product operation. Although the data structure can vary between devices, the Outer Product results are the same across all devices. - ## Inspect the padded result -The following visualization depicts the padded matrix B. If the embedded visualization doesn't load, [open the Pad B visualization in a separate browser tab](/apps/sme-visualisations/#/sme/pad32-b). Switch between the Learning Path and the visualization tab. +The following visualization depicts the padded matrix B. To keep this Learning Path open while exploring, open the Pad B visualization in a separate browser tab. Move the tab to a separate window to view the visualization and Learning Path side by side. + +Follow the padding algorithm: -Compare a complete group with one at the edge: +| Stage | Number of steps | Operation | +| --- | --- | --- | +| Load the first row | 3 | Load the first row of **Input Matrix B** into ZA0. | +| Load the second row | 3 | Load the second row of **Input Matrix B** into ZA0–ZA1, with zero padding on the final load. | +| Load the remaining rows | 6 | Load the third and fourth rows into ZA1–ZA2. | +| Store the padded data | 12 | Write the rows of ZA0–ZA2 into **Output Padded Data**. | -1. The first three steps load the first row of **Input Matrix B** into rows of ZA0. The third step loads only the last two columns of the matrix, and leaves the other columns zero-padded. This is achieved by using a predicate register to control which columns are active. -2. The next three steps load the second row of **Input Matrix B** into rows of ZA0 - ZA1. The final load is zero-padded. -3. The following six steps finish loading the third and fourth rows into ZA1 - ZA2. -4. The next 12 steps write the rows of ZA0 to ZA2 into rows of **Output Padded Data**. The rows are written with all columns active, so the zero padding is copied verbatim to the output buffer. +A predicate register controls which columns are active and limits the third block of each row to load just two columns. This leaves the other columns zero-padded. The padded data store happens with all columns active, so zero padding is copied verbatim to the output buffer. + +  {{< fullscreen-iframe src="/apps/sme-visualisations/#/sme/pad32-b" @@ -37,6 +41,8 @@ Compare a complete group with one at the edge: {{% notice Important %}} Scalable vector length can vary between devices. This visualization zero-pads the data for the tile size of the device. Running the same code on a different device with a different scalable vector length can result in a different output data structure. Specifically, for larger scalable vector lengths, there's likely to be more padding. However, it depends on the number of columns. + +The fact that different devices can produce different output data structures isn't a problem. Each device generates a data structure for its own ZA tile width. Each device later uses that data structure with its ZA tiles, to compose input vectors for the Outer Product operation. Although the data structure can vary between devices, the Outer Product results are the same across all devices. {{% /notice %}} ## What you've learned and what's next diff --git a/content/learning-paths/cross-platform/explore-sme-visualisations/7-packed-gemm.md b/content/learning-paths/cross-platform/explore-sme-visualisations/7-packed-gemm.md index 91c9440ad9..d8401eaf51 100644 --- a/content/learning-paths/cross-platform/explore-sme-visualisations/7-packed-gemm.md +++ b/content/learning-paths/cross-platform/explore-sme-visualisations/7-packed-gemm.md @@ -27,41 +27,47 @@ For large matrices, the most efficient arrangement is to process four tiles at a This visualization processes three tiles at a time arranged in a 1 x 3 horizontal block. This arrangement requires four vector loads per three tiles of partial results. For a large matrix, it would be slightly less efficient than 2 x 2. However, this visualization uses a small matrix of size 10 x 10. -Consider scalable vector length equal to 128 bits and 32-bit data elements. Using a 2 x 2 tile arrangement for a 10 x 10 matrix would require four passes. Using a 1 x 3 tile arrangement requires only three passes. For small matrices whose dimensions are known at compile time, the 2 x 2 configuration is sometimes outperformed by other tiling arrangements. +Consider Scalable Vector Length of 128 bits with 32-bit data element size. Using a 2 x 2 tile arrangement for a 10 x 10 matrix would require four passes. Using a 1 x 3 tile arrangement requires only three passes. For small matrices whose dimensions are known at compile time, the 2 x 2 configuration is sometimes outperformed by other tiling arrangements. -For larger scalable vector lengths, the calculus can change. For scalable vector length equal to 256 bits, the 2 x 2 configuration would require only one pass. Alternatively, the 1 x 3 configuration would require two passes. +For larger scalable vector lengths, the calculus can change. For Scalable Vector Length of 256 bits, the 2 x 2 configuration would require only one pass. However, the 1 x 3 configuration would require two passes. -In this visualization, the code is functionally correct on all devices regardless of scalable vector length. However, it's optimized for devices with scalable vector length equal to 128 bits. +In this visualization, the code is functionally correct on all devices regardless of Scalable Vector Length. However, it's optimized for devices with scalable vector length equal to 128 bits. ## Trace packed GEMM loads and ZA accumulation -If the embedded view doesn't load, [open the GEMM visualization in a separate browser tab](/apps/sme-visualisations/#/sme/gemm32-packed). Switch between the Learning Path and the visualization tab. +To keep this Learning Path open while exploring, open the GEMM visualization in a separate browser tab. Move the tab to a separate window to view the visualization and Learning Path side by side. -Follow the data from input through accumulation and storage. The following table summarizes how the visualization processes the input matrices in blocks: +Follow the data from input through accumulation and storage. The following table summarizes how the visualization processes the first three tile-sized blocks, corresponding to the first four rows of input matrix data: -| Stage | Visualization steps | Operation | +| Stage | Number of steps | Operation | |---|---|---| -| Load the first row | 1–4 | Load the first row of **A Packed Data** into Z0 and the first row of **B Padded Data** into Z1–Z3. | -| Calculate the outer products | 5–7 | Calculate the matrix outer products in ZA0–ZA2. | -| Process the second row | 8–14 | Load the second row of **A Packed Data** into Z0 and the second row of **B Padded Data** into Z1 - Z3. Accumulate the outer products in ZA0–ZA2. | -| Process the remaining rows | 15-28| Repeat the load and accumulation operations for rows three and four. | -| Store the results | 29-40 | Store rows of ZA0–ZA2 in **Output Matrix Data**. | -| Clear the tiles | 41-43 | Zero the ZA0–ZA2 tiles to prepare for the next block of four rows. | +| Load the first row | 4 | Load the first row of **A Packed Data** into Z0 and the first row of **B Padded Data** into Z1–Z3. | +| Calculate the outer products | 3 | Calculate the matrix outer products in ZA0–ZA2. | +| Process the second row | 7 | Load the second row of **A Packed Data** into Z0 and the second row of **B Padded Data** into Z1 - Z3. Accumulate the outer products in ZA0–ZA2. | +| Process the remaining rows | 14 | Repeat the load and accumulation operations for rows three and four. | +| Store the results | 12 | Store rows of ZA0–ZA2 in **Output Matrix Data**. | +| Clear the tiles | 3 | Zero the ZA0–ZA2 tiles to prepare for the next block of four rows. | ### Processing subsequent blocks After clearing ZA0–ZA2, the algorithm moves down by one tile-sized block in **A Packed Data**. It returns to the leftmost column of **B Padded Data**. -Processing the next block requires 43 steps: +Processing the next three tile-sized blocks that correspond to the next four rows shown purple in the top diagram, requires another 43 steps: -- 28 steps to load four rows and calculate their outer products -- 12 steps to store the results in **Output Matrix Data** -- Three steps to clear the ZA tiles +| Stage | Number of steps | Operation | +|---|---|---| +| Calculate outer products | 28 | Load data and calculate outer products for four rows | +| Store to memory | 12 | Store the results to **Output Matrix Data** | +| Clear the ZA tiles | 3 | Clear the ZA tiles ready for the next blocks | + +Processing the final three tile-sized blocks that correspond to the last two rows shown orange in the top diagram, requires 34 steps: -The final block requires 34 steps: +| Stage | Number of steps | Operation | +|---|---|---| +| Calculate outer products | 28 | Load data and calculate outer products for four rows | +| Store to memory | 6 | Store the results to **Output Matrix Data**. Only six steps because just two rows remain. | -- 28 steps to load four rows and calculate their outer products -- Six steps to store the results in **Output Matrix Data** because only two output rows remain +  {{< fullscreen-iframe src="/apps/sme-visualisations/#/sme/gemm32-packed" @@ -86,7 +92,7 @@ This is 13 instructions, which is an efficiency of 0.08 output elements per inst Consider a larger matrix of 12 x 12. The Scalable Matrix Extension (SME) implementation would take the same 120 cycles to process 144 output elements. This is 1.44 output elements per instruction. The scalar implementation would produce the same 0.08 output elements per instruction. -For larger scalable vector lengths, the efficiency is much higher. Every time the scalable vector length doubles, the efficiency quadruples for large matrices. For small matrices, edge effects can limit these gains. For example, for scalable vector length equal to 512 bits, each ZA tile is 16 x 16 elements of 32-bit data. This is 256 elements in total. The 10 x 10 matrix is only 100 elements. It therefore uses just under 40% of the available throughput of one tile. +For larger Scalable Vector Length, the efficiency is much higher. Every time the Scalable Vector Length doubles, the efficiency quadruples for large matrices. For small matrices, edge effects can limit these gains. For example, for Scalable Vector Length of 512 bits, each ZA tile is 16 x 16 elements of 32-bit data. This is 256 elements in total. The 10 x 10 matrix is only 100 elements. It therefore uses just under 40% of the available throughput of one tile. ## What you've learned and what's next diff --git a/content/learning-paths/cross-platform/explore-sme-visualisations/8-gather-load.md b/content/learning-paths/cross-platform/explore-sme-visualisations/8-gather-load.md index 489c6f0636..ae7de3ea35 100644 --- a/content/learning-paths/cross-platform/explore-sme-visualisations/8-gather-load.md +++ b/content/learning-paths/cross-platform/explore-sme-visualisations/8-gather-load.md @@ -13,7 +13,7 @@ The previous General Matrix Multiplication (GEMM) began with an input matrix A t These instructions are available in Streaming SVE mode only if `FEAT_SME_FA64` is implemented and enabled. Scalable Matrix Extension (SME) functionality requires Streaming SVE mode to be enabled. If `FEAT_SME_FA64` isn't enabled, Gather Load and Scatter Store are illegal instructions while in Streaming SVE mode. -The following visualization uses Gather Loads to access columns of matrix A data. The elements are separated by the length of a full row of matrix A. +The following visualization uses Gather Loads to access columns of matrix A data. The elements of each column are separated in memory by the length of a full row of matrix A. {{% notice Note %}} Gather Loads and Scatter Stores stress the memory system more than contiguous loads. They might potentially require multiple cache line loads before the operation can complete. Both these effects can impact performance. @@ -21,21 +21,24 @@ Gather Loads and Scatter Stores stress the memory system more than contiguous lo ## Compare the input path -If the embedded visualization doesn't load, [open the gather-load GEMM visualization in a separate browser tab](/apps/sme-visualisations/#/sme/gemm32-2x2). Switch between the Learning Path and the visualization tab. +To keep this Learning Path open while exploring, open the gather-load GEMM visualization in a separate browser tab. Move the tab to a separate window to view the visualization and Learning Path side by side. Focus on how matrix A data is loaded into Z2 and Z3: -| Stage | Visualization steps | Operation | +| Stage | Number of steps | Operation | |---|---|---| -| Load the first inputs | 1–4 | Read the first row of **B Input Data** into Z0–Z1 and the first column of **A Input Data** into Z2–Z3. | -| Calculate the first outer products | 5–8 | Use Z0–Z3 to calculate the first matrix outer products. | -| Process the second inputs | 9–16 | Read the second row of B and second column of A. Calculate the matrix outer products with accumulation of the result. | -| Process the third inputs | 17–24 | Repeat for the third row of B and third column of A. | -| Process the fourth inputs | 25–32 | Repeat for the fourth row of B and fourth column of A. | -| Store the first results | 33–40 | Write ZA0 and ZA1 to **Output Matrix Data**. | -| Store the remaining results | 41–48 | Write ZA2 and ZA3 to **Output Matrix Data**. | +| Load the first inputs | 4 | Read the first row of **B Input Data** into Z0–Z1 and the first column of **A Input Data** into Z2–Z3. | +| Calculate the first outer products | 4 | Use Z0–Z3 to calculate the first matrix outer products. | +| Process the second inputs | 8 | Read the second row of B and second column of A. Calculate the matrix outer products with accumulation of the result. | +| Process the third inputs | 8 | Repeat for the third row of B and third column of A. | +| Process the fourth inputs | 8 | Repeat for the fourth row of B and fourth column of A. | +| Store the first results | 8 | Write ZA0 and ZA1 to **Output Matrix Data**. | +| Store the remaining results | 8 | Write ZA2 and ZA3 to **Output Matrix Data**. | The **B Input Data** loads use contiguous addresses. The four 32-bit words loaded from **A Input Data** come from separate rows, so their addresses are 16 bytes apart. + +  + {{< fullscreen-iframe src="/apps/sme-visualisations/#/sme/gemm32-2x2" title="Interactive GEMM with gather-load" diff --git a/content/learning-paths/cross-platform/explore-sme-visualisations/9-transpose-interleave.md b/content/learning-paths/cross-platform/explore-sme-visualisations/9-transpose-interleave.md index 1b63ceefed..e1c15805df 100644 --- a/content/learning-paths/cross-platform/explore-sme-visualisations/9-transpose-interleave.md +++ b/content/learning-paths/cross-platform/explore-sme-visualisations/9-transpose-interleave.md @@ -13,28 +13,30 @@ To eliminate the need for Gather Loads, transform the **Input Matrix**. Process ![Colored regions of the input matrix are rearranged into an output memory buffer. Values from the red and orange regions sit together, followed by values from the green and blue regions.#center](images/transpose_interleave.png "Transposing and interleaving the input matrix") -The visualization shows the output **Interleaved Matrix** as a 16 x 16 matrix. If you represent the output memory buffer as a 16 x 16 matrix, it looks similar to: +The visualization shows the output **Interleaved Matrix** as a 16 x 16 matrix. If you represent the output memory buffer as a 16 x 16 matrix, its layout is as follows: ![The same interleaved output memory buffer viewed as a 16-column grid. Red and orange blocks alternate across the first eight rows, and green and blue blocks alternate across the next eight rows.#center](images/transpose_interleave_wide.png "Transposed interleaved output buffer shown as 16-column array") ## Follow the transpose and interleave -If the embedded visualization doesn't load, [open the A interleave visualization in a separate browser tab](/apps/sme-visualisations/#/sme/pack32-2x2-a). Switch between the Learning Path and the visualization tab. +To keep this Learning Path open while exploring, open the A interleave visualization in a separate browser tab. Move the tab to a separate window to view the visualization and Learning Path side by side. -Use the step ranges to follow how the **Input Matrix** becomes an **Interleaved Matrix**: +Follow through each visualization stage to see how the **Input Matrix** becomes the **Interleaved Matrix**: -| Stage | Visualization steps | Operation | +| Stage | Number of steps | Operation | |---|---|---| -| Load the first region | 1–8 | Load partial rows of **Input Matrix** into rows of ZA0 and ZA1. | -| Load the next rows | 9–16 | Load partial rows into rows of ZA2 and ZA3. | -| Store the first output rows | 17–24 | Store columns of ZA0 and ZA2 into rows of the **Interleaved Matrix** output buffer. | -| Store the next output rows | 25–32 | Store columns of ZA1 and ZA3 into the next two rows of the **Interleaved Matrix** output buffer. | -| Process the top-right region | 33–64 | Repeat the load-and-store pattern for the rest of the first horizontal strip. | -| Process the bottom-left region | 65–96 | Move to the next horizontal strip and write four more output rows. | -| Process the bottom-right region | 97–128 | Finish the strip and write the final four output rows. | +| Load the first region | 8 | Load partial rows of **Input Matrix** into rows of ZA0 and ZA1. | +| Load the next rows | 8 | Load partial rows of **Input Matrix** into rows of ZA2 and ZA3. | +| Store the first output rows | 8 | Store columns of ZA0 and ZA2 into rows of the **Interleaved Matrix** output buffer. | +| Store the next output rows | 8 | Store columns of ZA1 and ZA3 into the next two rows of the **Interleaved Matrix** output buffer. | +| Process the top-right region | 32 | Repeat the load-and-store pattern for the rest of the first horizontal strip. | +| Process the bottom-left region | 32 | Load partial rows of the next horizontal strip and write four more output rows. | +| Process the bottom-right region | 32 | Finish the strip and write the final four output rows. | The **Input Matrix** has 16 rows and 16 columns. The first 32 steps process the top-left quadrant of the input. The remaining stages cover the other three quadrants. +  + {{< fullscreen-iframe src="/apps/sme-visualisations/#/sme/pack32-2x2-a" title="Interactive transpose and interleave of matrix" diff --git a/content/learning-paths/cross-platform/explore-sme-visualisations/_index.md b/content/learning-paths/cross-platform/explore-sme-visualisations/_index.md index 95d0982e76..1a8f319fcb 100644 --- a/content/learning-paths/cross-platform/explore-sme-visualisations/_index.md +++ b/content/learning-paths/cross-platform/explore-sme-visualisations/_index.md @@ -1,10 +1,6 @@ --- title: Explore SME matrix operations with interactive visualizations -draft: true -cascade: - draft: true - description: Trace Arm SME data movement through interactive ZA layout, operand preparation, and matrix multiplication visualizations. minutes_to_complete: 40 @@ -40,30 +36,31 @@ generated_summary_faq: incomplete-edge transposes. Next, you'll see how outer products accumulate results, then pack matrix A and pad matrix B for a GEMM. Finally, you'll compare gather loads with a transposed-and-interleaved layout and confirm that both produce the same output. - # faqs: - # - question: How do data type and vector length change the ZA tile layout? - # answer: >- - # Use **Data Type** and **Scalable Vector Length** to change the layout view. You'll see - # how the same ZA storage maps to different numbers and sizes of logical tiles. - # - question: How do I check a transpose with an incomplete edge? - # answer: >- - # Compare **Input Matrix Data** with **Output Matrix Data**. You can follow the highlighted - # edge values to confirm that each reaches its transposed position without being lost or duplicated. - # - question: How does a vector outer product contribute to matrix C? - # answer: >- - # Follow one column of matrix A and the corresponding row of matrix B. You'll see their - # outer product add a partial result to multiple elements of matrix C at the same time. - # Repeat for each column and row pair to see the complete result accumulate in ZA. - # - question: What should I check after packing A and padding B? - # answer: >- - # In **Output Packed Data**, you should see matrix A's values in the new order, with zeros - # where its final tile has no input rows. In **Output Padded Data**, check that matrix B's - # original values remain in order and zeros fill the inactive columns. - # - question: What changes between the gather-load and interleaved GEMM views? - # answer: >- - # Compare how each view loads matrix A. With gather loads, you read values from non-contiguous - # addresses. With the transposed-and-interleaved layout, you load from contiguous addresses. You can - # compare **Output Matrix Data** in both views to confirm that the results are identical. + faqs: + - question: How do data type and vector length change the ZA tile layout? + answer: >- + **Scalable Vector Length** determines the height and width of the ZA storage. + **Data element size** determines how many elements will fit into a row of ZA storage of a given Scalable Vector Length. + That number of elements per row determines the height of the logical ZA tiles. + The height of the ZA storage divided by the height of a logical ZA tile, determines the number of ZA tiles. + - question: How does SME deal with matrices that are not an exact multiple of the ZA tile size? + answer: >- + SME uses predicates to specify which rows or columns are active. SME operations only affect active rows. If a matrix is not an exact multiple of the ZA tile size, then the last few rows or columns will be set as inactive. + - question: How does a vector outer product contribute to matrix C? + answer: >- + Review the section on [vectorizing matrix multiplication](/learning-paths/cross-platform/explore-sme-visualisations/4-gemm-vector/#vectorize-matrix-multiplication) + Follow one column of matrix A and the corresponding row of matrix B. You'll see their + outer product add a partial result to multiple elements of matrix C at the same time. + Repeat for each column and row pair to see the complete result accumulate in ZA. + - question: What should I check after packing A and padding B? + answer: >- + In **Output Packed Data**, you should see the values of matrix A in the new order, with zeros + where its final tile has no input rows. In **Output Padded Data**, check that the original values of matrix B remain in order and zeros fill the inactive columns. + - question: What is the difference between the gather-load and interleaved GEMM views? + answer: >- + Compare how each view loads matrix A. With gather loads, you read values from non-contiguous + addresses. With the transposed-and-interleaved layout, you load from contiguous addresses. You can + compare **Output Matrix Data** in both views to confirm that the results are identical. # END generated_summary_faq author: diff --git a/content/learning-paths/cross-platform/llm-decode-roofline/_index.md b/content/learning-paths/cross-platform/llm-decode-roofline/_index.md index 058804bfb9..e344bf1daf 100644 --- a/content/learning-paths/cross-platform/llm-decode-roofline/_index.md +++ b/content/learning-paths/cross-platform/llm-decode-roofline/_index.md @@ -41,32 +41,33 @@ generated_summary_faq: read bandwidth and inspect how many bytes each model reads per token. Finally, you'll compare decode and prefill across thread counts. You'll diagnose memory limits, and choose a model size and thread settings. -# faqs: -# - question: How do I confirm my system is 64-bit Arm and see which CPU features are present? -# answer: >- -# Run `uname -m` and `grep -m1 Features /proc/cpuinfo`. Look for `aarch64` and flags such as -# `asimd` (Neon) and `asimddp` (DotProd). llama.cpp detects DotProd at build time and uses it -# for quantized kernels on the Cortex-A76. -# - question: What should I check before measuring memory bandwidth? -# answer: >- -# Close other applications and ensure your system is idle. Use `uptime` and `free -m` to -# confirm low load and that available memory exceeds the largest model file (1,066 MB). -# Background load lowers measured bandwidth and distorts results that depend on it. -# - question: How do I see how many bytes per token a model reads during decode? -# answer: >- -# Run `llama-roofline inspect` on the GGUF file. Check the `per token` line in its report to -# see how many megabytes decode reads from the file for each token. -# - question: How do I know whether decode is memory-bound after inspection and measurement? -# answer: >- -# Compare the bytes per token reported by `llama-roofline inspect` with the measured -# bandwidth ceiling. If decode approaches that ceiling, memory bandwidth limits performance, -# so adding threads might not help. -# - question: What result should I expect from the `llama-bench` thread sweep, and how do I pick -# a thread count? -# answer: >- -# Read the `llama-bench` table, which reports threads and tokens per second (`t/s`). Choose -# the thread count with the highest `t/s` for your test. Decode can saturate quickly when -# memory-bound, while prefill can benefit from more threads. + faqs: + - question: How do I confirm my system is 64-bit Arm and see which CPU features are present? + answer: >- + Run `uname -m` and `grep -m1 Features /proc/cpuinfo`. Look for `aarch64` and flags such as + `asimd` (Neon) and `asimddp` (DotProd). On the Raspberry Pi 5's Cortex-A76, + llama.cpp detects DotProd at build time and uses it for quantized kernels. + - question: What should I check before measuring memory bandwidth? + answer: >- + Close other applications and ensure your system is idle. Use `uptime` and `free -m` to + confirm low load and that available memory exceeds the largest model file (1,066 MB). + Background load lowers measured bandwidth and distorts results that depend on it. + - question: How do I see how many bytes per token a model reads during decode? + answer: >- + Run `llama-roofline inspect` on the GGUF file. Check the `per token` line in its report to + see the estimated model data read per generated token, in megabytes. + - question: How do I know whether decode is memory-bound after inspection and measurement? + answer: >- + Multiply the bytes per token reported by `llama-roofline inspect` by your measured + decode tokens per second. Compare that achieved bandwidth with the measured ceiling, + or use the percentage of the ceiling listed in the report. If it approaches the ceiling, memory + bandwidth limits decode performance, so adding threads might not help. + - question: What result should I expect from the llama-bench thread sweep, and how do I pick + a thread count? + answer: >- + Read the `llama-bench` table, which reports threads and tokens per second (`t/s`). + Choose the best thread count separately for `tg128` decode and `pp512` prefill. + Decode can saturate quickly when memory-bound, while prefill can benefit from more threads. # END generated_summary_faq author: Manu Nicholas Jacob diff --git a/content/learning-paths/cross-platform/review-c-code-with-metis/1-understand-metis.md b/content/learning-paths/cross-platform/review-c-code-with-metis/1-understand-metis.md new file mode 100644 index 0000000000..7bb726bc25 --- /dev/null +++ b/content/learning-paths/cross-platform/review-c-code-with-metis/1-understand-metis.md @@ -0,0 +1,66 @@ +--- +title: Understand the Metis review workflow +description: Learn how Metis gathers evidence, runs security reviews, and presents findings for human triage. +weight: 2 +layout: "learningpathall" +--- + +## What is Metis? + +Arm Metis is an open-source, agentic security code-review framework. It combines language-aware source tooling with a large language model (LLM) to investigate security-relevant behavior and return structured review candidates. Metis supports multiple programming and hardware description languages through language plugins. This Learning Path uses C examples, but the same concepts can be applied to the other supported languages. + +You first run Metis on a small C program with known vulnerabilities. This gives you a quick look at the command flow, JSON output, SARIF output, and reported findings. You then prepare a libpng source tree from the [Magma](https://hexhive.epfl.ch/magma/) benchmark and triage a captured Metis finding against the source diff. + +The exercises show how to use Metis during a security review. They do not benchmark Metis accuracy. Model choice, provider behavior, Metis version, and source changes can all affect a run. Use published benchmark results for comparative performance data. + +{{% notice Note %}} +Model-backed review can consume substantial API tokens. The initial exercise is less expensive than the optional live libpng run. A pre-captured libpng report candidate is included so you can complete the triage exercise without running the larger review. +{{% /notice %}} + +## How Metis reviews code + +A Metis review starts with source files and project context. Metis collects language-aware evidence, asks your configured model to investigate possible vulnerabilities, and returns structured findings for a human reviewer. + +Metis offers two review approaches: + +- **Simple LLM review (default):** the model examines source code or a patch using language-specific security prompts and project guidance. It returns structured findings without requiring a code graph. This is also the review path for languages without C/C++ reachability support. +- **Optional reachability review:** for C/C++, Tree-sitter builds a CodeGraph of functions, calls, and source facts. When enabled, `reachability` reviews selected functions with this evidence and surrounding caller/callee context. Graph evidence does not by itself prove attacker control, build reachability, or exploitability. + +In Metis 2.0.0, the packaged Review stage runs `simple_llm_review`, `finding_dedup`, and `result`. `review_code` and `review_file` use simple LLM review by default. Metis builds a CodeGraph for triage, but runs reachability review only when you enable it. + +## Follow a review workflow with Metis + +A security review with Metis typically follows these steps: + +1. Choose a codebase, directory, file, or patch to review. +2. Add project-specific security context in `.metis.md` when needed. +3. Run a review and save the findings as JSON or SARIF. +4. Optionally use automated triage to check the findings against more source code. +5. Verify the findings against the source code, build configuration, and tests. + +## Assess findings with automated triage + +Automated triage checks a reported finding against more source code and marks it `valid`, `invalid`, or `inconclusive`. Metis checks the source lines cited for a `valid` or `invalid` verdict, but the verdict does not prove that the finding is correct or that an exploit works. + +## How this Learning Path uses Metis + +You will use two review commands on C code: + +- In the first exercise, you use `review_code` to review the small C codebase. +- In the second exercise, you use `review_file` to focus on `pngrutil.c` with context from the rest of the libpng codebase. + +The exercises start Metis with `--interactive` and run these commands at its prompt. Each command initializes the target automatically, so you do not need to run `init` first. You will inspect the findings yourself without enabling automated triage. + +## Interpret Metis findings + +A Metis finding normally includes the issue, source location, reasoning, suggested mitigation, Common Weakness Enumeration (CWE) identifier, severity, and confidence. + +{{% notice Note %}} +CWE identifiers, such as `CWE-190` for integer overflow, provide standard names for common classes of software weakness. +{{% /notice %}} + +You still decide whether a candidate is reachable, exploitable, already mitigated, or worth fixing. + +## What you've learned and what's next + +You have seen how Metis reports possible issues and why each finding needs a source check. Next, you will install the tested release and add your provider API key. diff --git a/content/learning-paths/cross-platform/review-c-code-with-metis/2-install-metis.md b/content/learning-paths/cross-platform/review-c-code-with-metis/2-install-metis.md new file mode 100644 index 0000000000..93055edc11 --- /dev/null +++ b/content/learning-paths/cross-platform/review-c-code-with-metis/2-install-metis.md @@ -0,0 +1,145 @@ +--- +title: Install and configure Metis +description: Install a tested Metis release and configure a model provider with an API key. +weight: 3 +layout: "learningpathall" +--- + +## Install system tools + +The commands in this Learning Path use a Unix-like shell. Use Terminal on macOS, a Linux terminal, or an existing Ubuntu/Debian terminal running under WSL2 on Windows. Native Windows PowerShell and Command Prompt are not covered. + +Select your platform and install the compiler, Git, and command-line utilities used to fetch code, apply patches, and inspect reports: + +{{< tabpane code=true >}} + {{< tab header="macOS" language="bash">}} +xcode-select --install + {{< /tab >}} + {{< tab header="Ubuntu Linux or WSL2" language="bash">}} +sudo apt-get update +sudo apt-get install -y build-essential ca-certificates curl git grep patch sed + {{< /tab >}} +{{< /tabpane >}} + +If the Xcode Command Line Tools are already installed, macOS reports that no installation is needed. On WSL2, use the Linux filesystem for this exercise and avoid creating the workspace under `/mnt/c`. + +## Install uv and Python + +Metis requires Python 3.12 or later. This Learning Path uses `uv` to install Python 3.12 and create an isolated Metis environment: + +```bash +curl -LsSf https://astral.sh/uv/install.sh | sh +``` + +Load the shell environment created by the installer and confirm that `uv` is available: + +```bash +source "$HOME/.local/bin/env" +uv --version +``` + +Install Python 3.12 using `uv`: + +```bash +uv python install 3.12 +uv python find 3.12 +``` + +The second command prints the path to the managed Python 3.12 executable. + +Check that all command-line tools used by the exercises are available: + +```bash +for tool in curl git grep patch sed uv; do + command -v "$tool" >/dev/null || echo "Missing: $tool" +done +``` + +The command prints nothing when all required tools are available. Install any tools that are missing. + +## Create the exercise workspace + +Create one workspace in your home directory for Metis, the review targets, and generated reports. On WSL2, `$HOME` is inside the Linux filesystem: + +```bash +mkdir -p "$HOME/metis-security-review/results" +cd "$HOME/metis-security-review" +``` + +## Clone and install Metis + +Clone the Metis repository at the tested [2.0.0 release](https://github.com/arm/metis/releases/tag/metis-v2.0.0): + +```bash +git clone --branch metis-v2.0.0 --depth 1 \ + https://github.com/arm/metis.git \ + "$HOME/metis-security-review/metis" + +cd "$HOME/metis-security-review/metis" + +uv sync --no-dev --python 3.12 +source "$HOME/metis-security-review/metis/.venv/bin/activate" + +command -v metis +metis --version +git rev-parse HEAD + +cd "$HOME/metis-security-review" +``` + +`uv sync --no-dev --python 3.12` installs only the runtime dependencies needed to run the Metis CLI, using Python 3.12. It creates `metis/.venv` and installs Metis there. Activating the environment makes the `metis` command and the matching Python interpreter available in the current terminal. + +The expected output from `metis --version` for this tag is: + +```output +Metis 2.0.0 +``` + +The `metis-v2.0.0` tag points to commit [`742b20d685b0aeb3216b36ddfc44bc5e05ace82c`](https://github.com/arm/metis/commit/742b20d685b0aeb3216b36ddfc44bc5e05ace82c). The output of `git rev-parse HEAD` should match this commit. Record the version and commit when comparing runs. + +If you open a new terminal, return to the exercise workspace and reactivate the Metis environment before continuing: + +```bash +cd "$HOME/metis-security-review" +source "$HOME/metis-security-review/metis/.venv/bin/activate" +command -v metis +``` + +The path printed by `command -v` should end with `metis-security-review/metis/.venv/bin/metis`. If it points elsewhere, open a new terminal or run `deactivate`, then run the activation command again. + +## Configure the model provider + +Metis supports several hosted and local model providers. These examples use an OpenAI-compatible endpoint that serves the model ID `gpt-6.1-sol`. Export your API key in the same terminal that will run Metis: + +```bash +export OPENAI_API_KEY="your-api-key" +``` + +Do not add secrets to `.metis.md`, `metis-review.yaml`, shell history, source control, or report files. + +Create a provider configuration outside the review targets. Replace `https://your-provider.example/v1` below with the trusted base URL of the provider that serves `gpt-6.1-sol`, including any required API prefix. The example address is a placeholder, not a service endpoint: + +```bash +cat > "$HOME/metis-security-review/metis-review.yaml" <<'EOF' +llm_provider: + name: openai + model: gpt-6.1-sol + base_url: https://your-provider.example/v1 +EOF +``` + +The review commands load this file with `--config` and read the API key from `OPENAI_API_KEY`. Your endpoint must support the OpenAI Responses API and the model named in the file. If you choose a different model from the captured `gpt-6.1-sol` runs, your findings might differ. For other providers, see the [Metis 2.0.0 provider setup instructions](https://github.com/arm/metis/blob/metis-v2.0.0/README.md#2-set-up-llm-provider). + +## Confirm that the command starts + +Display the command help before starting a model-backed review. Metis 2.0.0 runs its full workflow by default, including automated triage. The exercises use `--interactive` to run review-only commands; Metis initializes each target automatically. + +```bash +metis --help +``` + +The help output should include `--codebase-path`, `--config`, `--interactive`, and `--output-file`. Repeat `--output-file` to request more than one format. + +## What you've accomplished and what's next + +You installed the tested Metis 2.0.0 release and set it up with your model provider. Next, you will review a small C program and compare the report with defects that are intentionally present in its source. diff --git a/content/learning-paths/cross-platform/review-c-code-with-metis/3-review-vulnerable-c.md b/content/learning-paths/cross-platform/review-c-code-with-metis/3-review-vulnerable-c.md new file mode 100644 index 0000000000..f7745302eb --- /dev/null +++ b/content/learning-paths/cross-platform/review-c-code-with-metis/3-review-vulnerable-c.md @@ -0,0 +1,163 @@ +--- +title: Compare a Metis report with vulnerable C code +description: Run a Metis review, inspect JSON and SARIF output, and compare the report with known defects in a small C program. +weight: 4 +layout: "learningpathall" +--- + +## Prepare the example program + +The [Damn Vulnerable C Program](https://github.com/hardik05/Damn_Vulnerable_C_Program) contains vulnerabilities intentionally placed and labeled in one C file. Use it first to learn the Metis review process: prepare a small target, run `review_code`, save JSON and SARIF, summarize findings, and compare source locations. + +In your terminal, clone the repository at the tested commit and copy `dvcp.c` into a separate review directory. The copy keeps the review target small and avoids sending the rest of the repository to Metis: + +```bash +git clone https://github.com/hardik05/Damn_Vulnerable_C_Program.git +git -C Damn_Vulnerable_C_Program checkout 8dcbd202887f587783952a320a2301de701be529 +mkdir -p dvcp-review +cp Damn_Vulnerable_C_Program/dvcp.c dvcp-review/ +``` + +Add a short threat-model note for the review. Metis reads `.metis.md` as project context: + +```bash +cat > dvcp-review/.metis.md <<'EOF' +# Project security context + +This command-line C program parses an image file supplied by an untrusted user. +Treat file contents, dimensions, offsets, and derived allocation sizes as +attacker-controlled. Review memory safety, integer arithmetic, resource +exhaustion, input validation, and cleanup on error paths. +EOF +``` + +The note tells Metis how to treat inputs and security boundaries. The source file still contains teaching comments, which is acceptable here because this step teaches the review workflow. You will use libpng for a more realistic triage example. + +## Run the review + +Change into the review directory and start the Metis interactive prompt with the provider configuration you created. Save JSON for detailed inspection and SARIF for code-scanning tools: + +```bash +cd "$HOME/metis-security-review/dvcp-review" +metis \ + --interactive \ + --codebase-path . \ + --config "$HOME/metis-security-review/metis-review.yaml" \ + --output-file ../results/dvcp.json \ + --output-file ../results/dvcp.sarif +``` + +At the Metis prompt, run the review, then exit after it completes. Metis initializes the project automatically, then runs the default simple LLM review and deduplicates the findings: + +```console +review_code +exit +``` + +Metis prints review progress and detailed findings under `File:`, with an `Identified issue` heading. Finding fields include `Snippet`, `Line number`, `CWE`, `Severity`, `Why`, `Mitigation`, and `Confidence`. After the findings, the export and token-usage output is similar to: + +```output +Results saved to ../results/dvcp.json +SARIF report saved to ../results/dvcp.sarif +Token usage (review_code) +Current (input: 8,420 · output: 3,349 · total: 11,769) +``` + +Back in your shell, return to the exercise workspace: + +```bash +cd "$HOME/metis-security-review" +``` + +The run sends source-derived evidence to your configured model provider. Runtime, token use, and findings depend on the model, provider, and Metis version. + +It can take a couple of minutes to complete. + +## Summarize the JSON report + +The JSON report stores findings in `reviews[].reviews`. Source locations can appear in an `anchor`, in `primary_file` and `line_number`, or in the enclosing review group's `file` field. Use the Python interpreter from the active Metis environment to count the findings and print their issue types and source locations: + +```bash +python - <<'PY' +import json +from pathlib import Path + +data = json.loads(Path("results/dvcp.json").read_text()) +review_groups = data["reviews"] +count = sum(len(group["reviews"]) for group in review_groups) +print(f"Finding count: {count}") +for review_group in review_groups: + for finding in review_group["reviews"]: + anchor = finding.get("anchor") or {} + file_path = ( + anchor.get("file_path") + or finding.get("primary_file") + or finding.get("file") + or review_group.get("file") + ) + line = anchor.get("start_line") or finding.get("line_number") + print( + f"- {finding['cwe']} {finding['issue']} " + f"({file_path}:{line})" + ) +PY +``` + +This example was captured on November 2, 2026 using the `metis-v2.0.0` tag ([`742b20d`](https://github.com/arm/metis/commit/742b20d685b0aeb3216b36ddfc44bc5e05ace82c)), with `gpt-6.1-sol` through an OpenAI-compatible endpoint and DVCP commit [`8dcbd20`](https://github.com/hardik05/Damn_Vulnerable_C_Program/commit/8dcbd202887f587783952a320a2301de701be529). The provider reported the model ID as `gpt-6.1-sol`. The run used the packaged simple LLM review and deduplication nodes; reachability review and automated triage were not enabled. + +The output is similar to: + +```output +Finding count: 10 +- CWE-125 Unterminated image fields cause out-of-bounds string reads (dvcp.c:48) +- CWE-122 Unchecked dimension-derived allocations permit heap overflows and NULL dereferences (dvcp.c:54) +- CWE-415 An even dimension sum causes a double free (dvcp.c:59) +- CWE-416 An odd dimension sum divisible by three causes a use-after-free write (dvcp.c:64) +- CWE-369 Unvalidated image dimensions cause invalid integer division (dvcp.c:82) +- CWE-787 File-controlled quotient indexes outside a stack buffer (dvcp.c:90) +- CWE-787 The heap buffer is accessed one byte past its allocation (dvcp.c:91) +- CWE-674 Recursive operation has no termination condition (dvcp.c:22) +- CWE-400 Allocation loop intentionally retains memory until exhaustion (dvcp.c:109) +- CWE-401 Large-quotient branch discards an allocated buffer without freeing it (dvcp.c:97) +``` + +Your exact count and wording can differ. A valid report can contain zero findings. An empty report means that this run did not report any findings; it does not mean the program is safe. If you expected findings, check your provider connection and any Metis log output before judging the result. + +## Compare the report with known defects + +Display four source regions that the program identifies as deliberately vulnerable: + +```bash +sed -n '14,28p' dvcp-review/dvcp.c +sed -n '42,69p' dvcp-review/dvcp.c +sed -n '72,87p' dvcp-review/dvcp.c +sed -n '89,115p' dvcp-review/dvcp.c +``` + +Check whether your report covers these concrete cases: + +- Signed image dimensions are combined and passed to `malloc()` without overflow or range checks. +- `buff1` is freed, then freed again when `size1` is even or written after free when it is divisible by three. +- `img.height` is used as a divisor without a zero check. +- `size3` is used as an index into fixed-size and heap buffers without bounds checks. +- Attacker-controlled dimensions can select recursive stack exhaustion or repeated heap allocation. + +The captured Metis 2.0.0 JSON and SARIF reports contain ten findings. Source anchors can span multiple lines, and one finding can discuss additional sites in its reasoning. The table maps those reported regions and explanations to the known source defects: + +| Source issue | Tested-run outcome | +| --- | --- | +| Non-NUL-terminated image fields passed to `%s` | `CWE-125` at `dvcp.c:48` | +| Dimension-derived allocations followed by fixed-size copies | `CWE-122` anchored at `dvcp.c:54–58`; its reasoning also covers `dvcp.c:74–79` and `dvcp.c:82–87` | +| `buff1` double free and use-after-free | `CWE-415` at `dvcp.c:59–63`; `CWE-416` at `dvcp.c:64–69` | +| Integer division using unvalidated image dimensions | `CWE-369` at `dvcp.c:82` | +| Indexed stack and heap accesses | Separate `CWE-787` findings at `dvcp.c:90–94` and `dvcp.c:91–95` | +| `buff4` allocation lost without being freed | `CWE-401` at `dvcp.c:97–100` | +| Unbounded recursion and repeated heap allocation | `CWE-674` at `dvcp.c:22–27`; `CWE-400` at `dvcp.c:109–115` | + +For each reported finding, verify the source location, attacker control, and operation. Also record known source defects that the run omitted. The goal is to practice reviewing Metis output, not to turn the finding count into a coverage score. + +The same review is also available in `results/dvcp.sarif`. SARIF allows code-hosting services and security tools to associate findings with source locations. Keep JSON when you want the complete Metis reasoning and SARIF when you want to integrate results into an existing code-scanning workflow. + +## What you've accomplished and what's next + +You ran a complete Metis review, exported two report formats, and compared the reported findings with known defects. Next, you will prepare a realistic libpng target without leaving benchmark canaries or fixes in its source. diff --git a/content/learning-paths/cross-platform/review-c-code-with-metis/4-prepare-libpng.md b/content/learning-paths/cross-platform/review-c-code-with-metis/4-prepare-libpng.md new file mode 100644 index 0000000000..ee86e8b562 --- /dev/null +++ b/content/learning-paths/cross-platform/review-c-code-with-metis/4-prepare-libpng.md @@ -0,0 +1,170 @@ +--- +title: Prepare a realistic Magma libpng target +description: Build a reviewable libpng source tree from Magma while removing benchmark canaries and fix branches. +weight: 5 +layout: "learningpathall" +--- + +## Why prepare a Magma libpng target? + +The previous section used a small labeled program to teach the Metis review process. This section prepares a larger C codebase so you can see how a Metis finding is triaged against source that looks closer to real project code. + +[Magma](https://hexhive.epfl.ch/magma/) gives you a repeatable way to prepare that target. Magma is a benchmark for evaluating fuzzers against real programs with documented vulnerabilities. A fuzzer is a testing tool that repeatedly runs a program with generated or mutated inputs to trigger crashes, hangs, memory errors, or other unexpected behavior. + +You use Magma here only to create a prepared libpng source tree for review. You are not using Magma to benchmark Metis. You also do not give Metis the benchmark metadata, bug names, fuzzing harnesses, canaries, or fix branches, because those details would give a review model clues that a normal codebase would not contain. + +The preparation script creates the review target in four steps: + +1. Checks out the libpng revision selected by Magma. +2. Applies Magma patches that introduce known vulnerable code. +3. Removes benchmark controls so the source looks closer to a normal libpng tree. +4. Writes neutral Metis context for the review. + +The result is a deliberately vulnerable example target. Do not use it outside this exercise. + +## Download the preparation script + +Download [the Magma libpng preparation script](https://github.com/ArmDeveloperEcosystem/arm-learning-paths/blob/main/content/learning-paths/cross-platform/review-c-code-with-metis/prepare_magma_libpng.py) into the exercise workspace: + +```bash +curl -L \ + https://raw.githubusercontent.com/ArmDeveloperEcosystem/arm-learning-paths/main/content/learning-paths/cross-platform/review-c-code-with-metis/prepare_magma_libpng.py \ + -o prepare_magma_libpng.py +``` + +Clone Magma, then check out the commit tested for this Learning Path: + +```bash +git clone https://github.com/HexHive/magma.git +git -C magma checkout 75d1ae7b180443a778b8830c79176ca5f93642ac +``` + +Run the script to create `libpng-review`: + +```bash +python prepare_magma_libpng.py \ + --magma-dir magma \ + --output-dir libpng-review +``` + +The output is similar to: + +```output +Prepared libpng commit a37d4836519517bdce6cb9d956092321eca3e73b +Applied 7 Magma vulnerability-introducing patches +Output: /Users/you/metis-security-review/libpng-review +``` + +## Inspect the prepared source + +Confirm that the prepared tree has local changes: + +```bash +git -C libpng-review status --short +git -C libpng-review diff --stat +``` + +The diff summary shows that the script applied patches that introduce known vulnerable code to libpng. During triage, you will inspect a `png.c` guard and the related `pngrutil.c` allocation. Do not send patch names, benchmark descriptions, or known vulnerability lists to Metis. + +## Choose a libpng report option + +You need a Metis report before you can triage a finding. Choose one of these options: + +- Run a live Metis review if you have enough API quota and want to compare your model configuration. +- Use the pre-captured report if you are interested to try Metis, but want to minimize your API usage. + +{{< tabpane-normal >}} + {{< tab header="Run live review" >}} +This option asks Metis to review only `pngrutil.c`, because the triage exercise focuses on a finding in that file. + +The captured Metis 2.0.0 review with `gpt-6.1-sol` used 353,579 model tokens (351,293 input and 2,286 output). Usage varies with the run and model configuration. A live run can take several minutes and consume substantial API quota. Use the captured report option to avoid those model calls or if your run does not produce a finding you can triage. + +```bash +cd "$HOME/metis-security-review/libpng-review" +metis \ + --interactive \ + --codebase-path . \ + --config "$HOME/metis-security-review/metis-review.yaml" \ + --output-file ../results/libpng-live.json +``` + +At the Metis prompt, review the file, then exit. The results are review-only so you can validate a finding manually in the next section: + +```console +review_file pngrutil.c +exit +``` + +Back in your shell, return to the exercise workspace: + +```bash +cd "$HOME/metis-security-review" +``` + +Metis writes `results/libpng-live.json` and a companion `results/libpng-live.sarif`. Use the JSON report in the next section. + {{< /tab >}} + {{< tab header="Use captured report" >}} +This option creates `results/libpng-review-candidate.json` from the Metis 2.0.0 review captured with `gpt-6.1-sol` on November 2, 2026. The full run returned three findings; this example selects the row-buffer size finding for the guided triage. The finding is unchanged from the live report; only the review group's `file_path` is made relative for portability, and `_provenance` records the capture details. + +```bash +cat > results/libpng-review-candidate.json <<'EOF' +{ + "_provenance": { + "artifact_type": "Single finding extracted from a Metis review", + "release_under_test": "metis-v2.0.0", + "metis_commit": "742b20d685b0aeb3216b36ddfc44bc5e05ace82c", + "capture_date": "2026-11-02", + "configured_model": "gpt-6.1-sol", + "reported_model": "gpt-6.1-sol", + "magma_commit": "75d1ae7b180443a778b8830c79176ca5f93642ac", + "libpng_commit": "a37d4836519517bdce6cb9d956092321eca3e73b", + "prepared_source_sha256": "f628738930426bea4dccd718e5d90daaf012d5cef365880fa0f6adc4f936a78d", + "command": "review_file pngrutil.c", + "automatic_triage": false, + "capture_note": "One of three findings from the captured run; only the review group file_path is made relative for portability." + }, + "reviews": [ + { + "reviews": [ + { + "id": "6867943ebb524f57a0132a08a96d3115", + "issue": "Unchecked row-size arithmetic can cause a heap buffer overflow on 32-bit builds", + "code_snippet": "row_bytes = PNG_ROWBYTES(max_pixel_depth, row_bytes) +\n 1 + ((max_pixel_depth + 7) >> 3U);", + "start_line": 4591, + "end_line": 4592, + "reasoning": "PNG_ROWBYTES multiplies using size_t without checking overflow. On a build with 32-bit size_t, an 8-bit RGBA image of width 536870912, with png_set_expand_16 enabled, produces max_pixel_depth 64. The multiplication by eight wraps to zero, leaving row_bytes equal to nine. The subsequent row allocations are consequently only 57 bytes each, but line 4648 clears png_ptr->rowbytes + 1 bytes, where the original RGBA rowbytes is 2147483648, causing a massive heap overwrite before image decompression. This requires the application to raise the default width limit sufficiently, or a build configured with a larger width limit. The inspected png_check_IHDR architecture-size check in png.c has an empty body, so it does not reject this image; the later rowbytes check also accepts the original row size. The default width limit prevents this example, and 64-bit size_t does not exhibit this particular overflow.", + "mitigation": "Check the aligned width against the maximum representable allocation size divided by the maximum pixel byte size before multiplication, reserving all padding and alignment overhead. Restore effective architecture-size rejection in png_check_IHDR and retain checked arithmetic at this allocation site.", + "confidence": 0.96, + "cwe": "CWE-190", + "severity": "High", + "anchor": { + "file_path": "pngrutil.c", + "start_line": 4591, + "end_line": 4592, + "start_col": 0, + "end_col": 41, + "start_byte": 144001, + "end_byte": 144100, + "symbol": "pngrutil.c::png_read_start_row", + "kind": "range", + "content_hash": "21587413f66cc92e", + "confidence": "exact" + }, + "line_number": 4591 + } + ], + "file": "pngrutil.c", + "file_path": "pngrutil.c" + } + ] +} +EOF +``` + +This is a captured finding from the same release used in the exercises, not guaranteed output for every run. Its reasoning depends on the reviewed application using a sufficiently narrow `size_t` and image-width limits that permit very large inputs. The next section checks those conditions against the source; this capture is not a native exploit reproduction. + {{< /tab >}} +{{< /tabpane-normal >}} + +## What you've accomplished and what's next + +You prepared production-like vulnerable libpng source without benchmark hints and selected a report for triage. Next, you will check a reported finding against the benchmark diff and decide how to handle additional live findings. diff --git a/content/learning-paths/cross-platform/review-c-code-with-metis/5-triage-findings.md b/content/learning-paths/cross-platform/review-c-code-with-metis/5-triage-findings.md new file mode 100644 index 0000000000..acbfe09517 --- /dev/null +++ b/content/learning-paths/cross-platform/review-c-code-with-metis/5-triage-findings.md @@ -0,0 +1,163 @@ +--- +title: Triage a libpng finding +description: Check a Metis report finding against source code, attacker control, and the Magma ground-truth diff. +weight: 6 +layout: "learningpathall" +--- + +## List the reported findings + +Both report options provide Metis 2.0.0 review findings without automated triage verdicts. You will check one finding against the source code, build conditions, and Magma diff before deciding its status. + +For optional automated triage of Metis JSON or SARIF reports, see the [Metis 2.0.0 triage flow](https://github.com/arm/metis/blob/metis-v2.0.0/docs/triage-flow.md). + +Select the report you want to summarize: + +{{< tabpane-normal >}} + {{< tab header="Live report" >}} +Use this option if you ran the live review and want to inspect its results first: + +```bash +REPORT=results/libpng-live.json +``` + {{< /tab >}} + {{< tab header="Captured report" >}} +Use this option for the guided row-buffer triage, or if your live review returned no findings: + +```bash +REPORT=results/libpng-review-candidate.json +``` + {{< /tab >}} +{{< /tabpane-normal >}} + +The JSON reports store findings inside `reviews` groups. The summary below uses the finding's source `anchor` when present, then falls back to its primary file or review-group file and `line_number`. Print a compact summary: + +```bash +python - "$REPORT" <<'PY' +import json +import sys +from pathlib import Path + +data = json.loads(Path(sys.argv[1]).read_text()) +for review_group in data["reviews"]: + for finding in review_group["reviews"]: + anchor = finding.get("anchor") or {} + file_path = ( + anchor.get("file_path") + or finding.get("primary_file") + or finding.get("file") + or review_group.get("file") + ) + line = anchor.get("start_line") or finding.get("line_number") + print( + f"{finding['severity']:>6} {finding['cwe']}: " + f"{finding['issue']} " + f"({file_path}:{line})" + ) +PY +``` + +If you selected the captured report, the expected output is: + +```output + High CWE-190: Unchecked row-size arithmetic can cause a heap buffer overflow on 32-bit builds (pngrutil.c:4591) +``` + +If your live report includes the row-buffer finding, use it below. Otherwise, set `REPORT=results/libpng-review-candidate.json` to follow the captured example. The severity and confidence are model assessments, not runtime confirmation. + +## Triage the row-buffer finding + +This finding depends on the target application's ABI, image limits, and selected transforms. Running Metis on an Arm64 machine does not establish whether a reviewed application uses 32-bit or 64-bit `size_t`. + +First, inspect the reported allocation and clearing operations, the row-size macro, and the original row-size calculation: + +```bash +sed -n '4584,4648p' libpng-review/pngrutil.c +sed -n '738,741p' libpng-review/pngpriv.h +sed -n '888,904p' libpng-review/pngrutil.c +``` + +Check the expansion API named in the finding and the order of row initialization: + +```bash +sed -n '941,950p' libpng-review/pngrtran.c +sed -n '4484,4500p' libpng-review/pngrutil.c +sed -n '267,279p' libpng-review/pngread.c +``` + +Trace these relationships in the source: + +1. PNG width and pixel depth influence the row size. An RGBA8 input has 32 bits per pixel; enabling `png_set_expand_16()` makes the maximum transformed depth 64 bits. `PNG_ROWBYTES` multiplies in `size_t`. +2. `png_read_start_row` rounds the width up to an eight-pixel boundary, calculates `row_bytes`, then adds padding before allocation. +3. The later `memset` uses the original `png_ptr->rowbytes + 1`, not the allocation's `row_bytes`. `png_read_update_info()` initializes the row buffers before updating the transformed image information. Check whether the allocation is large enough for that write. +4. On a 32-bit `size_t` build, a sufficiently large width can wrap the aligned row calculation. The same arithmetic does not wrap at that width with a 64-bit `size_t`. + +Next, inspect the earlier architecture-width guard and the prepared-source diff: + +```bash +sed -n '2561,2595p' libpng-review/png.c +git -C libpng-review diff -U8 -- png.c +``` + +The architecture-width test is still present, but its body no longer warns or sets `error = 1`. The diff shows that Magma preparation removed those statements. This connects the finding to the injected vulnerability: the missing defense is in `png.c`, even though the reported allocation is in `pngrutil.c`. + +Now check the default limits and how an application can change them: + +```bash +grep -n 'PNG_USER_WIDTH_MAX' libpng-review/scripts/pnglibconf.h.prebuilt +sed -n '654,668p' libpng-review/libpng-manual.txt +``` + +The default width limit is `1000000`. It rejects the very large input used below during IHDR validation, before row initialization. An application can raise the limit with `png_set_user_limits()` before `png_read_info()`; build-time settings can also change it. Check the deployed ABI, active limits, pixel format, and transforms rather than assuming every PNG reader is affected. + +Also inspect `PNG_MAX_MALLOC_64K`: if enabled, its later `png_ptr->rowbytes` check rejects this example before `memset`. The arithmetic alone does not account for every build-time defense. + +To isolate the arithmetic in the captured finding, model a 32-bit `size_t` with an RGBA8 input and `png_set_expand_16()` enabled. The original row size uses 32 bits per pixel, while the allocation calculation uses a maximum transformed depth of 64 bits: + +```bash +python - <<'PY' +width = 1 << 29 +input_pixel_depth = 32 +max_pixel_depth = 64 +mask = (1 << 32) - 1 +aligned_width = (width + 7) & ~7 +row_bytes = ( + ((aligned_width * (max_pixel_depth >> 3)) & mask) + + 1 + ((max_pixel_depth + 7) >> 3) +) +allocation = row_bytes + 48 +original_rowbytes = (width * (input_pixel_depth >> 3)) & mask +print(f"Width: {width}; aligned width: {aligned_width}") +print(f"Allocation bytes: {allocation}; clear bytes: {original_rowbytes + 1}") +PY +``` + +The expected output is: + +```output +Width: 536870912; aligned width: 536870912 +Allocation bytes: 57; clear bytes: 2147483649 +``` + +This calculation models unsigned wraparound; it does not run libpng or prove that a decoder reaches the write. The source supports an **architecture- and configuration-dependent finding**, but this exercise does not include a native 32-bit reproducer. Record it as **unconfirmed at runtime** until you reproduce the path with the intended build and application settings. Neither the model's heap-overflow claim nor its potential code-execution impact is established by the calculation alone. + +## Check and record other findings + +Your live run might return no findings, the row-buffer finding, or different findings. An empty report does not prove the target is safe. A finding outside the injected changes is not automatically false, but it is not evidence by itself that Metis discovered a new vulnerability. + +For each additional finding, check: + +- Whether untrusted input reaches the reported operation, including through callers or helper functions. +- Whether the build includes that code and the arithmetic and platform assumptions hold. +- Whether an existing guard, API contract, or file-format rule invalidates the finding. +- Whether a focused test or sanitizer reproduces the behavior and the proposed fix preserves intended behavior. + +Search upstream issues and security advisories before reporting a new vulnerability. Treat the finding as **unconfirmed** until you have enough evidence to decide otherwise. + +Record a status of **confirmed**, **rejected**, **duplicate**, **accepted risk**, or **unconfirmed**. Include the input path, build assumptions, reproduction evidence or remaining checks, proposed fix owner, and test coverage. + +Do not publish unverified findings against active open-source projects. Follow the project's security policy and coordinated-disclosure process if further investigation confirms an issue. + +## What you've accomplished and what's next + +You installed Metis, compared a review with known C defects, prepared a realistic benchmark target, and checked a Metis finding against source evidence. You can apply the same workflow to a bounded directory, file, or patch in your own C project, or for other languages. diff --git a/content/learning-paths/cross-platform/review-c-code-with-metis/_index.md b/content/learning-paths/cross-platform/review-c-code-with-metis/_index.md new file mode 100644 index 0000000000..60bf42d175 --- /dev/null +++ b/content/learning-paths/cross-platform/review-c-code-with-metis/_index.md @@ -0,0 +1,84 @@ +--- +title: Review C code for security vulnerabilities with Arm's Metis (AI-powered Security Code Review) + +draft: true +cascade: + draft: true + +description: Install Arm Metis, review vulnerable C code, and triage findings from a prepared libpng target. + +minutes_to_complete: 45 + +who_is_this_for: This Learning Path is for developers who want to add AI-assisted security review to an existing code-review workflow. The examples in this learning path use C, but Metis is applicable to other languages as well. + +learning_objectives: + - Explain how Metis uses language-aware source analysis and model reasoning + - Install Metis and connect it to a supported model provider + - Review vulnerable C code and inspect JSON and SARIF output + - Triage Metis findings against source code and a Magma-derived libpng diff + +prerequisites: + - A macOS computer, Linux computer, or Windows computer with WSL2 + - An API key and sufficient quota for a [Metis-supported model provider](https://github.com/arm/metis#2-set-up-llm-provider) + - Basic familiarity with C, Git, command-line tools, and security code-review procedures + +author: + - Matt Cossins + - Michalis Spyrou + - Michael Koslov + +generate_summary_faq: false +rerun_summary: false +rerun_faqs: false + +### Tags +skilllevels: Introductory +subjects: Security +armips: + - Neoverse + - Cortex-A +operatingsystems: + - Linux + - macOS + - Windows +tools_software_languages: + - Arm Metis + - C + - Python + - Git + - JSON + - SARIF + +shared_path: true +shared_between: + - laptops-and-desktops + - servers-and-cloud-computing + +further_reading: + - resource: + title: Arm Metis GitHub repository + link: https://github.com/arm/metis + type: website + - resource: + title: Empowering engineers with AI-enabled security code review + link: https://developer.arm.com/community/arm-community-blogs/b/ai-blog/posts/empowering-engineers-with-ai-enabled-security-code-review + type: blog + - resource: + title: Arm Metis brings agentic AI to software security + link: https://newsroom.arm.com/blog/arm-metis-agentic-ai-security + type: blog + - resource: + title: Magma ground-truth fuzzing benchmark + link: https://hexhive.epfl.ch/magma/ + type: website + - resource: + title: Damn Vulnerable C Program repository + link: https://github.com/hardik05/Damn_Vulnerable_C_Program + type: website + +### FIXED, DO NOT MODIFY +# ================================================================================ +weight: 1 +layout: "learningpathall" +learning_path_main_page: "yes" +--- diff --git a/content/learning-paths/cross-platform/review-c-code-with-metis/_next-steps.md b/content/learning-paths/cross-platform/review-c-code-with-metis/_next-steps.md new file mode 100644 index 0000000000..9196d79577 --- /dev/null +++ b/content/learning-paths/cross-platform/review-c-code-with-metis/_next-steps.md @@ -0,0 +1,9 @@ +--- +# ================================================================================ +# FIXED, DO NOT MODIFY THIS FILE +# ================================================================================ +weight: 21 +title: "Next Steps" +layout: "learningpathall" +--- + diff --git a/content/learning-paths/cross-platform/review-c-code-with-metis/prepare_magma_libpng.py b/content/learning-paths/cross-platform/review-c-code-with-metis/prepare_magma_libpng.py new file mode 100644 index 0000000000..22b1b9e152 --- /dev/null +++ b/content/learning-paths/cross-platform/review-c-code-with-metis/prepare_magma_libpng.py @@ -0,0 +1,195 @@ +#!/usr/bin/env python3 + +import argparse +import re +import shutil +import subprocess +from pathlib import Path + + +LIBPNG_REPOSITORY = "https://github.com/pnggroup/libpng.git" +LIBPNG_COMMIT = "a37d4836519517bdce6cb9d956092321eca3e73b" +TARGET_MACROS = { + "ENABLE_MAGMA_FIXES": False, + "MAGMA_ENABLE_CANARIES": False, + "MAGMA_ENABLE_FIXES": False, +} + +IFDEF = re.compile(r"^\s*#\s*(ifdef|ifndef)\s+(\w+)\s*$") +IF = re.compile(r"^\s*#\s*if\s+defined\s*\(\s*(\w+)\s*\)\s*$") +ELSE = re.compile(r"^\s*#\s*else\b") +ELIF = re.compile(r"^\s*#\s*elif\b") +ENDIF = re.compile(r"^\s*#\s*endif\b") +ANY_IF = re.compile(r"^\s*#\s*(if|ifdef|ifndef)\b") + + +def run(*command: str, cwd: Path | None = None, input_text: str | None = None) -> None: + subprocess.run( + command, + cwd=cwd, + input=input_text, + text=True, + check=True, + ) + + +def sanitize_file(path: Path) -> None: + lines = path.read_text(errors="surrogateescape").splitlines(keepends=True) + output: list[str] = [] + stack: list[dict[str, object]] = [] + emitting = True + + for line_number, line in enumerate(lines, start=1): + match = IFDEF.match(line) + if match and match.group(2) in TARGET_MACROS: + directive, macro = match.groups() + condition = TARGET_MACROS[macro] + if directive == "ifndef": + condition = not condition + stack.append( + { + "targeted": True, + "parent_emitting": emitting, + "condition": condition, + "else_seen": False, + } + ) + emitting = emitting and condition + continue + + match = IF.match(line) + if match and match.group(1) in TARGET_MACROS: + condition = TARGET_MACROS[match.group(1)] + stack.append( + { + "targeted": True, + "parent_emitting": emitting, + "condition": condition, + "else_seen": False, + } + ) + emitting = emitting and condition + continue + + if ANY_IF.match(line): + stack.append({"targeted": False}) + if emitting: + output.append(line) + continue + + if ELSE.match(line): + if not stack: + raise RuntimeError(f"unmatched #else in {path}:{line_number}") + frame = stack[-1] + if frame["targeted"]: + if frame["else_seen"]: + raise RuntimeError(f"duplicate #else in {path}:{line_number}") + frame["else_seen"] = True + emitting = bool(frame["parent_emitting"]) and not bool( + frame["condition"] + ) + elif emitting: + output.append(line) + continue + + if ELIF.match(line): + if stack and stack[-1]["targeted"]: + raise RuntimeError( + f"targeted #elif is unsupported in {path}:{line_number}" + ) + if emitting: + output.append(line) + continue + + if ENDIF.match(line): + if not stack: + raise RuntimeError(f"unmatched #endif in {path}:{line_number}") + frame = stack.pop() + if frame["targeted"]: + emitting = bool(frame["parent_emitting"]) + elif emitting: + output.append(line) + continue + + if emitting: + output.append(line) + + if stack: + raise RuntimeError(f"unterminated conditional in {path}") + + path.write_text("".join(output), errors="surrogateescape") + + +def parse_arguments() -> argparse.Namespace: + parser = argparse.ArgumentParser( + description="Prepare the sanitized Magma libpng target for Metis review." + ) + parser.add_argument( + "--magma-dir", + type=Path, + required=True, + help="Path to a cloned HexHive/magma repository.", + ) + parser.add_argument( + "--output-dir", + type=Path, + required=True, + help="Destination for the prepared libpng source tree.", + ) + return parser.parse_args() + + +def main() -> None: + arguments = parse_arguments() + magma_dir = arguments.magma_dir.resolve() + output_dir = arguments.output_dir.resolve() + patch_dir = magma_dir / "targets" / "libpng" / "patches" / "bugs" + + if not patch_dir.is_dir(): + raise SystemExit(f"Magma libpng patches not found: {patch_dir}") + if output_dir.exists(): + raise SystemExit(f"Output directory already exists: {output_dir}") + + run("git", "clone", LIBPNG_REPOSITORY, str(output_dir)) + run("git", "checkout", LIBPNG_COMMIT, cwd=output_dir) + + patch_files = sorted(patch_dir.glob("*.patch")) + for patch_file in patch_files: + patch_text = patch_file.read_text().replace( + "%MAGMA_BUG%", patch_file.stem + ) + run("patch", "-p1", cwd=output_dir, input_text=patch_text) + + for path in output_dir.rglob("*"): + if path.is_file() and path.suffix.lower() in { + ".c", + ".cc", + ".cpp", + ".cxx", + ".h", + ".hpp", + }: + sanitize_file(path) + + for pattern in ("*.orig", "*.rej"): + for path in output_dir.rglob(pattern): + path.unlink() + + (output_dir / ".metis.md").write_text( + "# Project security context\n\n" + "This library parses PNG files supplied by untrusted users. Treat image " + "dimensions, chunk lengths, offsets, and compressed data as " + "attacker-controlled. Review memory safety, integer arithmetic, parser " + "state, resource exhaustion, and cleanup on error paths.\n" + ) + (output_dir / ".metisignore").write_text( + ".git/\ncontrib/\ndocs/\nexamples/\nscripts/\ntests/\n" + ) + + print(f"Prepared libpng commit {LIBPNG_COMMIT}") + print(f"Applied {len(patch_files)} Magma vulnerability-introducing patches") + print(f"Output: {output_dir}") + + +if __name__ == "__main__": + main() diff --git a/content/learning-paths/cross-platform/rpi5-energy-per-token/_index.md b/content/learning-paths/cross-platform/rpi5-energy-per-token/_index.md index 11312a17a8..bc712ded5d 100644 --- a/content/learning-paths/cross-platform/rpi5-energy-per-token/_index.md +++ b/content/learning-paths/cross-platform/rpi5-energy-per-token/_index.md @@ -38,33 +38,33 @@ generated_summary_faq: samples and align them with token-generation windows to calculate joules per token, with or without idle power. Finally, you'll compare clock caps and thread counts across repeated runs, accounting for variation and sampler overhead. -# faqs: -# - question: How do I check whether the Raspberry Pi 5 exposes power data through `hwmon`? -# answer: >- -# You can list the sensors under `/sys/class/hwmon/` and check for power or current files. -# On the Raspberry Pi 5, you use `vcgencmd pmic_read_adc` to read current and voltage from the -# onboard PMIC rails instead. -# - question: What does the PMIC sampling script write? -# answer: >- -# You choose the output CSV path when you run `pmic_sampler.py`, for example `idle.csv` in -# your working directory. In your CSV, each row contains `time_s`, `total_W`, and a watts column for -# each rail with both current and voltage readings. -# - question: How do I align power samples with token generation? -# answer: >- -# When you run `energy_per_token.py`, it starts the sampler before `llama-bench`. You can -# trace each generation window from the script's timestamp for a `--progress` start marker -# and the corresponding `samples_ns` duration; the script selects samples inside that window. -# - question: How do I calculate joules per token with and without idle power? -# answer: >- -# You multiply the mean power during a generation window by its duration, then divide by -# the generated token count for `J/token`. For `net_J/token`, you subtract the measured idle -# baseline from the mean window power before multiplying and dividing. -# - question: How should I compare clock caps and thread counts? -# answer: >- -# You set `scaling_max_freq` and check `scaling_cur_freq` during token generation to -# confirm the cap. You then repeat the sweep at least five times, alternating the setting order. -# You compare `J/token` and `net_J/token` separately, and avoid ranking settings whose -# differences fall within run-to-run variation. + faqs: + - question: How do I check whether the Raspberry Pi 5 exposes power data through hwmon? + answer: >- + You can list the sensors under `/sys/class/hwmon/` and check for power or current files. + On the Raspberry Pi 5, you use `vcgencmd pmic_read_adc` to read current and voltage from the + onboard PMIC rails instead. + - question: What does the PMIC sampling script write? + answer: >- + You choose the output CSV path when you run `pmic_sampler.py`, for example `idle.csv` in + your working directory. In your CSV, each row contains `time_s`, `total_W`, and a watts column for + each rail with both current and voltage readings. + - question: How do I align power samples with token generation? + answer: >- + When you run `energy_per_token.py`, it starts the sampler before `llama-bench`. You can + trace each generation window from the script timestamp for a `--progress` start marker, + and the corresponding `samples_ns` duration. The script selects samples inside that window. + - question: How do I calculate joules per token with and without idle power? + answer: >- + Multiply the mean power during a generation window by its duration, then divide by + the generated token count for `J/token`. For `net_J/token`, subtract the measured idle + baseline from the mean window power before multiplying and dividing. + - question: How should I compare clock caps and thread counts? + answer: >- + Set `scaling_max_freq` and check `scaling_cur_freq` during token generation to + confirm the cap. Then, repeat the sweep at least five times, alternating the setting order. + Compare `J/token` and `net_J/token` separately, and avoid ranking settings whose + differences fall within run-to-run variation. # END generated_summary_faq author: Manu Nicholas Jacob diff --git a/content/learning-paths/embedded-and-microcontrollers/_index.md b/content/learning-paths/embedded-and-microcontrollers/_index.md index 27be993883..884fee12b5 100644 --- a/content/learning-paths/embedded-and-microcontrollers/_index.md +++ b/content/learning-paths/embedded-and-microcontrollers/_index.md @@ -15,16 +15,16 @@ pinned_learning_paths: operatingsystems_filter: - Android: 1 - Baremetal: 33 -- Linux: 68 -- macOS: 27 -- RTOS: 14 -- Windows: 14 +- Linux: 73 +- macOS: 28 +- RTOS: 16 +- Windows: 15 subjects_filter: - Agentic AI: 2 -- AI/ML: 33 +- AI/ML: 34 - CI-CD: 7 - Containers and Virtualization: 11 -- Embedded Linux: 6 +- Embedded Linux: 9 - Libraries: 5 - Performance and Architecture: 26 - RTOS Fundamentals: 8 @@ -50,20 +50,23 @@ tools_software_languages_filter: - Arm Streamline: 1 - Arm Virtual Hardware: 15 - Assembly: 1 -- AWS IoT Greengrass: 3 +- AWS IoT Greengrass: 6 - Azure: 1 - balenaCloud: 1 - BalenaOS: 1 - Baremetal: 1 - Bash: 1 - BitBake: 1 -- C: 13 +- C: 15 +- C++: 1 - C2PA Tool: 1 - ChatGPT: 1 - Clang: 1 -- CMake: 4 -- CMSIS: 5 +- CMake: 5 +- CMSIS: 6 +- CMSIS Pack: 1 - CMSIS-DSP: 1 +- CMSIS-NN: 1 - CMSIS-Toolbox: 5 - CNN: 1 - Computer Vision: 1 @@ -79,11 +82,11 @@ tools_software_languages_filter: - Edge Impulse: 2 - ETDump: 1 - ETRecord: 1 -- ExecuTorch: 15 +- ExecuTorch: 16 - ExifTool: 1 - FastAPI: 2 - Fusion 360: 1 -- FVP: 11 +- FVP: 12 - Gazebo: 1 - GCC: 19 - Generative AI: 4 @@ -99,6 +102,7 @@ tools_software_languages_filter: - Keil MDK: 7 - Keil RTX RTOS: 2 - Keil Studio: 1 +- KleidiCV: 1 - Kubernetes: 1 - LeRobot: 1 - libjpeg-turbo: 1 @@ -122,16 +126,17 @@ tools_software_languages_filter: - Neon: 1 - NumPy: 1 - Ollama: 2 -- ONNX: 1 +- ONNX: 2 - ONNX Runtime: 1 +- OpenCV: 1 - OpenSSH: 1 - OpenSSL: 1 - Paddle: 1 - Performance analysis: 1 - picocom: 1 - Porcupine: 1 -- Python: 30 -- PyTorch: 11 +- Python: 33 +- PyTorch: 12 - QEMU: 3 - Raspberry Pi: 14 - Reachy Mini: 1 @@ -158,7 +163,7 @@ tools_software_languages_filter: - TrustZone: 2 - TVMC: 1 - U-Boot: 1 -- vcpkg: 1 +- vcpkg: 2 - Vela: 2 - VGF: 1 - Visual Studio Code: 3 @@ -166,9 +171,9 @@ tools_software_languages_filter: - XNNPACK: 1 - YAML: 1 - Yocto: 1 -- Yocto Project: 1 +- Yocto Project: 4 - YOLO26: 1 - Zenoh: 3 -- Zephyr: 7 +- Zephyr: 9 weight: 5 --- diff --git a/content/learning-paths/embedded-and-microcontrollers/alif-conformer-asr/_index.md b/content/learning-paths/embedded-and-microcontrollers/alif-conformer-asr/_index.md index e72517f12d..72244263d5 100644 --- a/content/learning-paths/embedded-and-microcontrollers/alif-conformer-asr/_index.md +++ b/content/learning-paths/embedded-and-microcontrollers/alif-conformer-asr/_index.md @@ -10,7 +10,7 @@ who_is_this_for: This Learning Path is for embedded ML developers who want to ca learning_objectives: - Prepare a quantized Conformer model with Arm and Alif MLEK for ExecuTorch deployment. - - Build and run ASR on the Corstone-320 Fixed Virtual Platform (FVP) using recorded audio. + - Build and run automatic speech recognition (ASR) on the Corstone-320 Fixed Virtual Platform (FVP) using recorded audio. - Build and flash the E8 application and its external-flash model. - Validate live transcription, Ethos-U85 execution, and standalone restart on the E8. @@ -41,30 +41,30 @@ generated_summary_faq: firmware, program the model in external flash, and capture speech through the onboard microphones. Finally, you'll check the displayed transcription, Ethos-U85 activity, and standalone restart. -# faqs: -# - question: How do I know the FVP ASR application ran correctly before moving to the E8 board? -# answer: >- -# Check that the FVP console identifies the audio sample and prints a `Decoded output:` line -# with recognized text. You can then move on to the E8 build. -# - question: Which application do I build for the E8 and which core does it target? -# answer: >- -# Select the Alif MLEK `alif_asr` application with `-DUSE_CASE_BUILD=alif_asr`, then build -# the `mlek_alif_asr` target. You deploy it to the E8's high-performance Cortex-M55 subsystem. -# - question: Which build option selects the Ethos-U85 NPU for the E8 firmware? -# answer: >- -# Set `-DETHOS_U_NPU_ID=U85` when you configure the E8 firmware. You can check for nonzero -# `NPU ACTIVE` and `NPU TOTAL` counters in the UART log after inference. -# - question: What should I set up on the E8 before opening the serial console, and what settings do I use? -# answer: >- -# Keep the **PRG USB** cable connected and set **SW4** to **UART4**. Open the board's serial -# port at 115200 baud, eight data bits, no parity, and one stop bit. If the port was already -# open when you changed **SW4**, close and reopen it. -# - question: How do I know the E8 is ready to capture speech, and how do I record a phrase? -# answer: >- -# Press **RESET (SW1)** and wait for `Model initialisation complete` in the UART log and -# **Conformer ASR (ExecuTorch)** on the display. Hold down the joystick center while you -# speak, then release it. Check the display for a transcription and the console for a -# `Decoded output:` line. + faqs: + - question: How do I know the FVP ASR application ran correctly before moving to the E8 board? + answer: >- + Check that the FVP console identifies the audio sample and prints a `Decoded output:` line + with recognized text. You can then move on to the E8 build. + - question: Which application do I build for the E8 and which core does it target? + answer: >- + Select the Alif MLEK `alif_asr` application with `-DUSE_CASE_BUILD=alif_asr`, then build + the `mlek_alif_asr` target. You deploy it to the E8's high-performance Cortex-M55 subsystem. + - question: Which build option selects the Ethos-U85 NPU for the E8 firmware? + answer: >- + Set `-DETHOS_U_NPU_ID=U85` when you configure the E8 firmware. You can check for nonzero + `NPU ACTIVE` and `NPU TOTAL` counters in the UART log after inference. + - question: What should I set up on the E8 before opening the serial console, and what settings do I use? + answer: >- + Keep the **PRG USB** cable connected and set **SW4** to **UART4**. Open the board's serial + port at 115200 baud, eight data bits, no parity, and one stop bit. If the port was already + open when you changed **SW4**, close and reopen it. + - question: How do I know the E8 is ready to capture speech, and how do I record a phrase? + answer: >- + Press **RESET (SW1)** and wait for `Model initialisation complete` in the UART log and + **Conformer ASR (ExecuTorch)** on the display. Hold down the joystick center while you + speak, then release it. Check the display for a transcription and the console for a + `Decoded output:` line. # END generated_summary_faq author: diff --git a/content/learning-paths/embedded-and-microcontrollers/c2pa-on-arm/_index.md b/content/learning-paths/embedded-and-microcontrollers/c2pa-on-arm/_index.md index aa60fb149e..84b8009503 100644 --- a/content/learning-paths/embedded-and-microcontrollers/c2pa-on-arm/_index.md +++ b/content/learning-paths/embedded-and-microcontrollers/c2pa-on-arm/_index.md @@ -40,32 +40,32 @@ generated_summary_faq: credential. Then, you'll inspect the manifest and distinguish signature, content-binding, and signer-trust results. You'll compare the provenance of the image in the Content Authenticity Initiative (CAI) web validator. Finally, you'll modify a copy and identify the resulting content-binding failure. -# faqs: -# - question: Which files do I need before signing the image? -# answer: >- -# Keep the unsigned `image.jpg` and your `manifest.json` definition in the same `c2pa-demo` -# directory. Run the signing command from that directory so you can use their filenames -# without full paths. -# - question: How do I read the C2PA Tool result for the signed image? -# answer: >- -# Check `claimSignature.validated` for the signature and `assertion.dataHash.match` for the -# image binding. You'll also see `signingCredential.untrusted` because the example uses a -# development certificate. Read these codes alongside the `Valid` validation state. -# - question: Does signing overwrite my original image? -# answer: >- -# No. You write the signed copy to `image-signed.jpg`, leaving the unsigned `image.jpg` -# unchanged. -# - question: What should I compare in the CAI web validator? -# answer: >- -# Open `image-signed.jpg` and compare its displayed origin, creation action, and issuer -# with your C2PA Tool report. You'll see an **Unrecognized** issuer warning for the -# development credential. The web panel doesn't show separate signature or binding -# status codes. -# - question: How do I identify a content-binding failure after changing the image? -# answer: >- -# Check `image-modified.jpg` in the web validator for an **Invalid** status. In the -# C2PA Tool report, `assertion.dataHash.mismatch` identifies the failed image binding, -# while `claimSignature.validated` shows that the unchanged claim signature still verifies. + faqs: + - question: Which files do I need before signing the image? + answer: >- + Keep the unsigned `image.jpg` and your `manifest.json` definition in the same `c2pa-demo` + directory. Run the signing command from that directory so you can use their filenames + without full paths. + - question: How do I read the C2PA Tool result for the signed image? + answer: >- + Check `claimSignature.validated` for the signature and `assertion.dataHash.match` for the + image binding. You'll also see `signingCredential.untrusted` because the example uses a + development certificate. Read these codes alongside the `Valid` validation state. + - question: Does signing overwrite my original image? + answer: >- + No. You write the signed copy to `image-signed.jpg`, leaving the unsigned `image.jpg` + unchanged. + - question: What should I compare in the CAI web validator? + answer: >- + Open `image-signed.jpg` and compare its displayed origin, creation action, and issuer + with your C2PA Tool report. You'll see an **Unrecognized** issuer warning for the + development credential. The web panel doesn't show separate signature or binding + status codes. + - question: How do I identify a content-binding failure after changing the image? + answer: >- + Check `image-modified.jpg` in the web validator for an **Invalid** status. In the + C2PA Tool report, `assertion.dataHash.mismatch` identifies the failed image binding, + while `claimSignature.validated` shows that the unchanged claim signature still verifies. # END generated_summary_faq author: diff --git a/content/learning-paths/embedded-and-microcontrollers/generate-faces-alif-e8/_index.md b/content/learning-paths/embedded-and-microcontrollers/generate-faces-alif-e8/_index.md index 0189a7f255..a908cc680a 100644 --- a/content/learning-paths/embedded-and-microcontrollers/generate-faces-alif-e8/_index.md +++ b/content/learning-paths/embedded-and-microcontrollers/generate-faces-alif-e8/_index.md @@ -40,31 +40,30 @@ generated_summary_faq: transformer and decoder to the Arm Ethos-U85 NPU. Next, you'll provision the Cortex-M55 boot and debug flow, build the application, and generate human faces. Finally, you'll verify NPU execution through the DevKit LCD, UART output, and performance counters. -# faqs: -# - question: What should I check on the DevKit before connecting it to my computer? -# answer: >- -# Before you connect the DevKit, unplug all USB cables before changing any jumpers. Verify -# that the jumpers match the factory defaults documented in the DK-E8 User Guide. This helps -# you avoid power or boot issues during setup. -# - question: Which USB port do I use for programming, and how do I confirm the board is powered? -# answer: >- -# Connect a USB-C cable to the PRG USB port on the bottom edge of the DevKit. You can confirm -# that the board has power when a green LED illuminates near the E1 device. -# - question: Which repository branch do I need for this example? -# answer: >- -# Clone the CMSIS-ExecuTorch repository using the `hackathon-pico-faces` branch. Use the -# `--branch hackathon-pico-faces --single-branch` options, then open the workspace in VS Code. -# - question: Which serial settings and switch position should I use to view application output? -# answer: >- -# Set **SW4** to **UART4** and open **Serial Monitor** on the **PRG USB** port at `115200` baud, -# eight data bits, no parity, and one stop bit. If the port was open before changing **SW4**, -# close and reopen it. -# - question: What result should I expect when I start a debug session and run the firmware? -# answer: >- -# From the **CMSIS** view, select **Build**, then **Debug**. Keil Studio starts the J-Link GDB -# server over SWD and loads the application into MRAM, stopping at `main`. Press **F5** to -# continue. The DevKit displays a 128 x 128 RGB face, and UART output confirms Arm Ethos-U85 -# execution. + faqs: + - question: What should I check on the DevKit before connecting it to my computer? + answer: >- + Before you connect the DevKit, unplug all USB cables before changing any jumpers. Keep + **JP5** on pins **1–2** and **JP7** on pins **3–4**, and set **SW4** to **SEUART**. + - question: Which USB port do I use for programming, and how do I confirm the board is powered? + answer: >- + Connect a USB-C cable to the PRG USB port on the bottom edge of the DevKit. You can confirm + that the board has power when its power LED lights. + - question: Which repository branch do I need for this example? + answer: >- + Clone the CMSIS-ExecuTorch repository using the `hackathon-pico-faces` branch. Use the + `--branch hackathon-pico-faces --single-branch` options, then open the workspace in VS Code. + - question: Which serial settings and switch position should I use to view application output? + answer: >- + Set **SW4** to **UART4** and open **Serial Monitor** on the **PRG USB** port at `115200` baud, + eight data bits, no parity, and one stop bit. If the port was open before changing **SW4**, + close and reopen it. + - question: What result should I expect when I start a debug session and run the firmware? + answer: >- + From the **CMSIS** view, select **Build**, then **Debug**. Keil Studio starts the J-Link GDB + server over SWD and loads the application into MRAM, stopping at `main`. Press **F5** to + continue. Check the displayed face and `Test_result: PASS` for functional operation. + Check for nonzero NPU counters in the UART output to verify Arm Ethos-U85 activity. # END generated_summary_faq author: Ash Naik diff --git a/content/learning-paths/embedded-and-microcontrollers/opencv-onnx-kleidicv-static-detection/_index.md b/content/learning-paths/embedded-and-microcontrollers/opencv-onnx-kleidicv-static-detection/_index.md index 3e53340fdb..3b2f3faa69 100644 --- a/content/learning-paths/embedded-and-microcontrollers/opencv-onnx-kleidicv-static-detection/_index.md +++ b/content/learning-paths/embedded-and-microcontrollers/opencv-onnx-kleidicv-static-detection/_index.md @@ -40,30 +40,30 @@ generated_summary_faq: matching OpenCV installations and prepare the model, labels, and image. You'll compile and run the C++ application against both builds. Finally, you'll check its detections, and benchmark image operations, full preprocessing, and in-memory pipeline latency under consistent conditions. - # faqs: - # - question: How do I know I’m running a 64-bit Arm userspace before building? - # answer: >- - # Run `uname -m`. The expected output is `aarch64`. - # - question: Where should I place the YOLOX model and the test image? - # answer: >- - # Store them in the `static-detection` directory created earlier under your working folder. - # Use the downloaded filenames shown in the guide so the example application can find them. - # - question: What system information should I record with my benchmark results? - # answer: >- - # Record `/etc/os-release`, the kernel from `uname -r`, and `lscpu` output for topology and CPU - # features. KleidiCV selects implementations based on available CPU features, so you need this - # context to compare runs. - # - question: How should I prepare the board for consistent timing measurements? - # answer: >- - # Close unnecessary applications and allow the board to cool before each run. Keep the board and - # operating system, OpenCV source and compiler, release build configuration, model and image, - # warm-up and measured iteration counts, OpenCV thread count, CPU affinity, and CPU frequency - # governor consistent. - # - question: How do I compare baseline and KleidiCV performance results? - # answer: >- - # Keep the inputs and common build settings the same, with KleidiCV enabled only in the second - # OpenCV build. Compare image-operation, full preprocessing, and end-to-end timings to separate - # local preprocessing gains from overall pipeline changes. + faqs: + - question: How do I know I’m running a 64-bit Arm userspace before building? + answer: >- + Run `uname -m`. The expected output is `aarch64`. + - question: Where should I place the YOLOX model and the test image? + answer: >- + Store them in the `static-detection` directory created earlier under your working folder. + Use the downloaded filenames shown in the guide so the example application can find them. + - question: What system information should I record with my benchmark results? + answer: >- + Record `/etc/os-release`, the kernel from `uname -r`, and `lscpu` output for topology and CPU + features. KleidiCV selects implementations based on available CPU features, so you need this + context to compare runs. + - question: How should I prepare the board for consistent timing measurements? + answer: >- + Close unnecessary applications and allow the board to cool before each run. Keep the board and + operating system, OpenCV source and compiler, release build configuration, model and image, + warm-up and measured iteration counts, OpenCV thread count, CPU affinity, and CPU frequency + governor consistent. + - question: How do I compare baseline and KleidiCV performance results? + answer: >- + Keep the inputs and common build settings the same, with KleidiCV enabled only in the second + OpenCV build. Compare image-operation, full preprocessing, and end-to-end timings to separate + local preprocessing gains from overall pipeline changes. # END generated_summary_faq author: Jett Zhou diff --git a/content/learning-paths/embedded-and-microcontrollers/optimize-executorch-fallback-cortex-m/1-prepare.md b/content/learning-paths/embedded-and-microcontrollers/optimize-executorch-fallback-cortex-m/1-prepare.md index e66ff0091a..afb6d4689d 100644 --- a/content/learning-paths/embedded-and-microcontrollers/optimize-executorch-fallback-cortex-m/1-prepare.md +++ b/content/learning-paths/embedded-and-microcontrollers/optimize-executorch-fallback-cortex-m/1-prepare.md @@ -9,46 +9,44 @@ layout: learningpathall ## ExecuTorch for Cortex-M and Ethos-U -ExecuTorch is PyTorch’s runtime for deploying machine learning models on edge devices, including embedded systems. It converts trained models into programs that can run within the limited memory and compute resources of a microcontroller. +ExecuTorch is the PyTorch runtime for deploying machine learning models on edge devices, including embedded systems. It converts trained models into programs that can run within the limited memory and compute resources of a microcontroller. Many microcontrollers use Arm Cortex-M CPUs. Some also integrate an Arm Ethos-U NPU to accelerate neural-network operations. -For combined Cortex-M and Ethos-U systems, ExecuTorch lets one model use both processors: supported operations are dispatched to the Ethos-U NPU, while remaining operations run on the Cortex-M CPU. - -You will export a model, select CMSIS-NN kernels for its Cortex-M operations, and run a mixed CPU and NPU application on a Corstone-300 FVP. The checks show which implementations the model uses and confirm that inference completes. Measure latency and power on your target hardware to quantify the benefit for your application. +For combined Cortex-M and Ethos-U systems, ExecuTorch lets one model use both processors. Supported operations are dispatched to the Ethos-U NPU, while remaining operations run on the Cortex-M CPU. ## Choose where each operation runs The example model uses three execution paths: -| Execution path | What runs there | Why | +| Execution path | What operation runs there | Why the operation runs there | | --- | --- | --- | | [Ethos-U55 NPU](https://www.arm.com/products/silicon-ip-cpu/ethos/ethos-u55) | The stride-1 convolution | The NPU supports this convolution configuration. | -| [CMSIS-NN kernels on Cortex-M](https://arm-software.github.io/CMSIS-NN/latest/index.html) | The stride-4 convolution | Ethos-U55 does not support this configuration, so the CPU runs it with an optimized CMSIS-NN kernel. | +| [CMSIS-NN kernels on Cortex-M](https://arm-software.github.io/CMSIS-NN/latest/index.html) | The stride-4 convolution | Ethos-U55 doesn't support this configuration, so the CPU runs it with an optimized CMSIS-NN kernel. | | ExecuTorch portable kernels on Cortex-M | The `topk` operation | This operation uses a general CPU implementation. | -The diagram shows the NPU path alongside the two paths that execute on the Cortex-M CPU: +The following diagram shows the NPU path alongside the two paths that run on the Cortex-M CPU: ![Diagram of the simulated Corstone-300 target showing the Cortex-M CPU dispatching the stride-1 convolution to Ethos-U55, running the stride-4 convolution with CMSIS-NN, and running topk with a portable ExecuTorch kernel#center](images/cortex-m-execution-picture.svg "ExecuTorch execution paths") -Fallback here is planned during export. It isn't recovery from an NPU failure +Fallback is expected here during export. It isn't recovery from an NPU failure at runtime. The exporter determines which regions the target Ethos-U delegate -supports, then assigns known remaining patterns to the Cortex-M backend. +supports. It then assigns known remaining patterns to the Cortex-M backend. -{{% notice Why this example uses Ethos-U55 %}} -Ethos-U55 is used because its unsupported stride-4 convolution creates a +{{% notice Note %}} +Ethos-U55 is used for this Learning Path because its unsupported stride-4 convolution creates a predictable fallback region. Ethos-U85 supports more operator configurations, so it will typically have less CPU fallback than Ethos-U55. The same workflow still applies when a model contains operations that remain outside the U85 delegate. {{% /notice %}} -In this Learning Path, you will clone a [CMSIS-Executorch example](https://github.com/Arm-Examples/cmsis-executorch) that already contains the needed board support, -runner, memory configuration, and Fixed Virtual Platform (FVP) settings. You -will then inspect and modify it to observe Cortex-M fallback using optimized CMSIS-NN microkernels. +You'll export a model and select CMSIS-NN kernels for its Cortex-M operations. You'll then run a mixed CPU and NPU application on a Corstone-300 Fixed Virtual Platform (FVP). The checks show which implementations the model uses and confirm that inference completes. Measure latency and power on your target hardware to quantify the benefit for your application. + +The [CMSIS-Executorch example](https://github.com/Arm-Examples/cmsis-executorch) that you'll clone already contains the necessary board support, runner, memory configuration, and FVP settings. ## Check the host tools -VS Code is required for the Keil Studio workflow. Before cloning the project, check that Git and Python 3.10–3.13 are available in your host terminal: +You need Visual Studio Code (VS Code) for the Keil Studio workflow. Before cloning the project, check that Git and Python 3.10–3.13 are available in your host terminal: {{< tabpane code=true >}} {{< tab header="Linux and macOS" language="bash">}} @@ -61,10 +59,16 @@ python --version {{< /tab >}} {{< /tabpane >}} -If either command is unavailable, install [Git](https://git-scm.com/downloads) or a supported [Python version](https://www.python.org/downloads/) before continuing. Python 3.14 is excluded because the pinned TOSA export dependency has no wheel for it. On Linux, your Python installation must also include `venv` support; install your distribution's matching `python3-venv` package if needed. +If either command is unavailable, install [Git](https://git-scm.com/downloads) or a supported [Python version](https://www.python.org/downloads/) before continuing. + +{{% notice Note %}} +Python 3.14 is excluded because the pinned Tensor Operator Set Architecture (TOSA) export dependency has no wheel for it. +{{% /notice %}} + +On Linux, ensure that your Python installation includes `venv` support. Install the `python3-venv` package for your distribution if needed. {{% notice Note %}} -The macOS exporter requires Apple silicon and macOS 15 or later. The pinned ExecuTorch and TOSA packages do not provide Intel macOS wheels. Docker supplies the FVP on macOS; the Python exporter runs on the host. +The macOS exporter requires Apple silicon and macOS 15 or later. The pinned ExecuTorch and TOSA packages don't provide Intel macOS wheels. Docker supplies the FVP on macOS, and the Python exporter runs on the host. {{% /notice %}} On Windows, enable [long-path support](https://learn.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation) before installing the export dependencies. @@ -79,11 +83,11 @@ cd CMSIS-Executorch git checkout 4002b63dcc3e27eb7444946a0dbf69b9a74d6fc9 ``` -The `CMSIS-Executorch` directory is the **project root**. Open this folder in VS Code and use it as the working directory for every command below. +The `CMSIS-Executorch` directory is the project root. Open this folder in VS Code and use it as the working directory for every command. ## Install the VS Code extensions -In VS Code's **Extensions** view, install the [Keil Studio Pack](https://marketplace.visualstudio.com/items?itemName=Arm.keil-studio-pack) and the [Python extension](https://marketplace.visualstudio.com/items?itemName=ms-python.python). Keil Studio Pack includes Arm Tools Environment Manager and the CMSIS Solution extension used by this project. +In the VS Code **Extensions** view, install the [Keil Studio Pack](https://marketplace.visualstudio.com/items?itemName=Arm.keil-studio-pack) and the [Python extension](https://marketplace.visualstudio.com/items?itemName=ms-python.python). Keil Studio Pack includes Arm Tools Environment Manager and the CMSIS Solution extension that you'll use. ![VS Code extension details for Arm Keil Studio Pack. The Disable and Uninstall buttons confirm that the extension pack is installed.#center](images/keil-studio-pack.png "Keil Studio Pack installed in VS Code") @@ -93,9 +97,11 @@ When you open the project folder, Arm Tools Environment Manager automatically ac ![VS Code Arm Tools status bar showing seven activated tools. The tooltip lists CMSIS-Toolbox 2.15.0 and Arm Compiler 6.24.0 among the tools added to the integrated terminal's PATH.#center](images/arm-tools-activated.png "Confirm that the project's Arm tools are active") -If activation does not start, right-click `vcpkg-configuration.json` in the **Explorer** view and select **Activate Environment**. You can also select **Activate Environment** from the **Arm Tools** status-bar menu when the configuration is detected. +If activation doesn't start, right-click `vcpkg-configuration.json` in the **Explorer** view and select **Activate Environment**. You can also select **Activate Environment** from the **Arm Tools** status-bar menu when the configuration is detected. -Arm Compiler for Embedded requires an activated license. Select the license indicator next to **Arm Tools**, then choose **Activate Arm Keil MDK Community Edition** for evaluation or non-commercial use, or **Activate or manage Arm licenses** to use your existing license. Confirm that the indicator shows an active license before building. See [Keil Studio license activation](https://mdk-packs.github.io/vscode-cmsis-solution-docs/installation.html#activating-keil-studio) for the available options. +Arm Compiler for Embedded requires an activated license. Select the license indicator next to **Arm Tools**, then select **Activate Arm Keil MDK Community Edition** for evaluation or non-commercial use. Alternatively, you can select **Activate or manage Arm licenses** to use your existing license. + +Confirm that the indicator shows an active license before building. For available options, see [Keil Studio license activation](https://mdk-packs.github.io/vscode-cmsis-solution-docs/installation.html#activating-keil-studio). In the **CMSIS** view, select **... > Open Solution in Workspace** and choose `cmsis-executorch-u55.csolution.yml`. Confirm that the active target is `SSE-300-U55`. @@ -107,11 +113,11 @@ Select **Terminal > Run Task > Create Python environment (pip)**. ![VS Code task picker with Create Python environment (pip) selected. Run this task to create .venv and install the model-export dependencies.#center](images/create-python-environment.png "Run the pip environment setup task") -The task runs `setup_venv.sh` on Linux and macOS, or `setup_venv.bat` on Windows. Both invoke `setup_venv.py`, which: +The task runs `setup_venv.sh` on Linux and macOS, or `setup_venv.bat` on Windows. Both invoke `setup_venv.py`. The task completes the following setup steps: - Creates `.venv` using the host Python interpreter. - Installs `requirements.txt`, including ExecuTorch 1.5.1, PyTorch 2.14.0, TorchAO 0.18.0, and Vela 5.1.0. -- Installs `requirements-arm-tosa.txt` with `--no-deps` to preserve the exporter's required serialization versions. +- Installs `requirements-arm-tosa.txt` with `--no-deps` to preserve the required serialization versions of the exporter. - Checks that the ExecuTorch Arm quantizer imports successfully. Wait for the task to exit successfully and print a message similar to: @@ -122,7 +128,7 @@ venv ready: .../CMSIS-Executorch/.venv This task installs the Python dependencies for you. Use the setup script when repairing the environment so that both requirements files are installed with the correct options. -If the task selects a different Python version from the supported one you installed, run the setup explicitly from the project root. For example, with Python 3.12 installed: +If the task selects a different Python version from the supported one that you installed, run the setup from the project root. For example, with Python 3.12 installed: {{< tabpane code=true >}} {{< tab header="Linux and macOS" language="bash">}} @@ -135,7 +141,9 @@ py -3.12 setup_venv.py ## Open and verify the working terminal -After Arm tool activation and Python setup finish, select **Terminal > New Terminal**. Use a Bash-compatible shell on Linux and macOS, or PowerShell on Windows. This new integrated terminal receives the activated Arm tool environment. +After Arm tool activation and Python setup, select **Terminal > New Terminal**. + +Use a Bash-compatible shell on Linux and macOS, or PowerShell on Windows. This new integrated terminal receives the activated Arm tool environment. Activate `.venv` in this terminal: @@ -161,7 +169,7 @@ Project: .../CMSIS-Executorch Python: .../CMSIS-Executorch/.venv/bin/python ``` -On Windows, the interpreter path ends in `.venv\Scripts\python.exe`. Both paths must belong to the same project. Keep using this terminal for subsequent commands. Repeat environment activation and this check whenever you open a new terminal. +On Windows, the interpreter path ends in `.venv\Scripts\python.exe`. Both paths need to belong to the same project. Keep using this terminal for subsequent commands. Repeat environment activation and this check if you need to open a new terminal. ## Verify the environment @@ -174,7 +182,9 @@ armclang --version python -c "from importlib.metadata import version; print('ExecuTorch', version('executorch')); print('PyTorch', version('torch'))" ``` -Confirm that Python is between 3.10 and 3.13, `cbuild` reports 2.15.0 or later, Arm Compiler for Embedded reports 6.24, and the final two lines are: +Confirm that Python is between 3.10 and 3.13, `cbuild` reports 2.15.0 or later, and Arm Compiler for Embedded reports 6.24. + +The expected final two lines of the output are: ```output ExecuTorch 1.5.1 @@ -182,22 +192,24 @@ PyTorch 2.14.0 ``` {{% notice Note %}} -If a tool is unavailable or its version differs, reactivate the project's Arm tools and open a new integrated terminal. Activate `.venv` again before repeating these checks. The ExecuTorch Python package and CMSIS Pack versions must match because the embedded runtime loads the program produced by the exporter. +If a tool is unavailable or its version differs, reactivate the Arm tools and open a new integrated terminal. Activate `.venv` again before repeating these checks. The ExecuTorch Python package and CMSIS Pack versions need to match because the embedded runtime loads the program produced by the exporter. {{% /notice %}} ### Set up Docker on macOS -On macOS, install and start [Docker Desktop](https://docs.docker.com/desktop/setup/install/mac-install/). The FVP runs inside a Linux container because there is no native macOS FVP. Check that Docker is running: +On macOS, install and start [Docker Desktop](/install-guides/docker/docker-desktop/). The FVP runs inside a Linux container because it isn't available as a macOS application. + +Check that Docker is running: ```bash docker info ``` -The project's `.vscode/fvp.sh` wrapper mounts the project directory into the container, including when it is outside your home directory. Its first run builds the FVP container image. +The project `.vscode/fvp.sh` wrapper mounts the project directory into the container, including when it's outside your home directory. Its first run builds the FVP container image. ## Download the Learning Path assets -Download this Learning Path's example folder from the code examples repository. +Download the example folder for the Learning Path from the code examples repository. The archive is pinned to a commit and includes the fallback model, integration patch, inspection helpers, and their license. Run the commands from the project root. They create `lp-assets` for the downloaded originals, then copy the four working files into the project root: @@ -218,7 +230,7 @@ Copy-Item lp-assets\*.py, lp-assets\*.patch . ### Keep track of the project files -The working files now have these roles. The `artifacts/` and `out/` directories are created in later chapters; `ai_layer/` already exists in the cloned example and will be regenerated for your model. +The working files now have the following roles: ```text CMSIS-Executorch/ @@ -235,16 +247,19 @@ CMSIS-Executorch/ ├── ai_layer/ Generated model and firmware component list └── out/ Compiled firmware and compilation database ``` +You'll create the `artifacts/` and `out/` directories later. `ai_layer/` already exists in the cloned example and will be regenerated for your model. -The inspection script writes its `.pte` and graph-summary `.json` files into `artifacts/`. The firmware embeds `ai_layer/model.pte`, which `create_ai_layer.py` generates in chapter 3. Keep all commands rooted in `CMSIS-Executorch` so these paths continue to refer to the same files. +The inspection script writes its `.pte` and graph-summary `.json` files into `artifacts/`. The firmware embeds `ai_layer/model.pte`, which `create_ai_layer.py` generates. Keep all commands rooted in `CMSIS-Executorch` so that these paths continue to refer to the same files. -## Use a simple convolution example +## Use a convolution example The CMSIS-Executorch repository starts with a TinyCNN model that can be delegated completely to -Ethos-U. You will change this model to one that will demonstrate fallback by retaining its input and output -interface, but adjusting the operations happening inside it. +Ethos-U. + +You'll change this model to one that will demonstrate fallback. You'll retain the model input and output +interface, but adjust the operations happening inside it. -Replace the original model with the one you have downloaded: +Replace the original model with the one that you downloaded: {{< tabpane code=true >}} {{< tab header="Linux and macOS" language="bash">}} @@ -256,10 +271,10 @@ Copy-Item .\mixed_backend_cnn.py .\model\model.py {{< /tabpane >}} The model still accepts one `16 x 16` RGB image in NHWC order and returns ten -values. Keeping that interface means the supplied bare-metal runner needs no +values. Keeping that interface means that the supplied bare-metal runner needs no changes. -The important part of `model/model.py` now looks like this: +The important part of `model/model.py` is now as follows: ```python self.conv1 = nn.Conv2d( @@ -275,13 +290,14 @@ values = torch.flatten(values, start_dim=2) values, _ = torch.topk(values, k=1, dim=-1) ``` -The *stride* controls how far a convolution filter moves between positions. A -stride of one visits adjacent positions. A stride of four moves four positions +The `stride` controls how far a convolution filter moves between positions. `stride=1` visits adjacent positions. `stride=4` moves four positions at a time and produces a smaller output. For this Ethos-U55 target and tensor shape, -the first convolution can be delegated to the NPU, while the stride-4 convolution +the first convolution can be delegated to the NPU. The stride-4 convolution remains outside the delegate. `topk` selects the largest spatial response for each of the ten output channels. ## What you've accomplished and what's next -You now have a pinned Corstone-300 Ethos-U55 project, its matching Python packages, its versioned Arm tools, and a model that will only partially run on an Ethos-U55. Next, you will understand how to optimize supported operators with CMSIS-NN on Cortex-M CPUs in a CPU-only example. +You now have a pinned Corstone-300 Ethos-U55 project, and its matching Python packages and versioned Arm tools. You've also downloaded a model that will run only partially on an Ethos-U55. + +Next, you'll understand how to optimize supported operators with CMSIS-NN on Cortex-M CPUs in a CPU-only example. diff --git a/content/learning-paths/embedded-and-microcontrollers/optimize-executorch-fallback-cortex-m/2-run-cortex-m.md b/content/learning-paths/embedded-and-microcontrollers/optimize-executorch-fallback-cortex-m/2-run-cortex-m.md index 310edb3fa1..813023ccca 100644 --- a/content/learning-paths/embedded-and-microcontrollers/optimize-executorch-fallback-cortex-m/2-run-cortex-m.md +++ b/content/learning-paths/embedded-and-microcontrollers/optimize-executorch-fallback-cortex-m/2-run-cortex-m.md @@ -1,25 +1,26 @@ --- title: Lower a model to the Cortex-M backend weight: 3 -description: Export a Cortex-M model and identify CMSIS-NN accelerated convolutions +description: Export a Cortex-M model and identify CMSIS-NN accelerated convolutions. ### FIXED, DO NOT MODIFY layout: learningpathall --- -## First use only Cortex-M +## Start with only Cortex-M -Before we demonstrate fallback from an Ethos-U, we will briefly look at running a model exclusively on Cortex-M. Not every microcontroller has an onboard NPU, so some use-cases will involve running TinyML directly on the CPU. In this case, any optimizations can be the vital difference between functional performance, and an impractical application. +Before you see fallback from an Ethos-U, you'll see what running a model exclusively on Cortex-M looks like. -## See how the export script lowers the graph +Not every microcontroller has an onboard NPU, so some use-cases will involve running TinyML directly on the CPU. In such a case, any optimizations can be the vital difference between functional performance and an impractical application. + +### See how the export script lowers the graph {{% notice Note %}} -The ExecuTorch Cortex-M backend is in **beta** in the 1.5 release used here. +The ExecuTorch Cortex-M backend is in beta in the 1.5 release that's used for these steps. Validation covers MLPerf Tiny models and MobileNetV2. It combines optimized CMSIS-NN implementations with portable FP32 operators -for operations outside its accelerated coverage. See the -[Cortex-M backend documentation](https://docs.pytorch.org/executorch/stable/backends/arm-cortex-m/arm-cortex-m-overview.html) -for supported operators and limitations. +for operations outside its accelerated coverage. For supported operators and limitations, see the +[Cortex-M backend documentation](https://docs.pytorch.org/executorch/stable/backends/arm-cortex-m/arm-cortex-m-overview.html). {{% /notice %}} The exporter first prepares and converts the model with `CortexMQuantizer`: @@ -56,20 +57,20 @@ This step rewrites supported patterns as `cortex_m.*` operators. Unsupported operations, including `aten.topk`, remain in the portable graph. The Cortex-M backend is broader than CMSIS-NN. In this model, the quantized -convolutions use CMSIS-NN, while quantize and dequantize use Cortex-M operators +convolutions use CMSIS-NN. Quantize and dequantize use Cortex-M operators with Arm Helium vector implementations. A `cortex_m.*` target therefore means that the Cortex-M backend owns the operator, not necessarily that CMSIS-NN implements it. {{% notice Important %}} -The Cortex-M backend is not a delegate. Delegation replaces a graph region with +The Cortex-M backend isn't a delegate. Delegation replaces a graph region with a call to a separately compiled backend. Cortex-M lowering instead rewrites supported patterns as registered `cortex_m.*` operators that the ExecuTorch -runtime dispatches normally. You will not see an `executorch_call_delegate` -node until the Ethos-U partitioner is added on the next page. +runtime dispatches normally. You won't see an `executorch_call_delegate` +node until you add the Ethos-U partitioner. {{% /notice %}} -## Export the model for Cortex-M +### Export the model for Cortex-M Use the provided script to lower the model to Cortex-M only, by specifying `--mode cortex-m`: @@ -88,7 +89,7 @@ python .\export_cortex_m_fallback.py ` {{< /tab >}} {{< /tabpane >}} -The relevant output is: +The expected output is: ```output Relevant targets before Cortex-M lowering: @@ -103,7 +104,7 @@ cortex_m.quantized_conv2d_nhwc.default: 2 cortex_m.transpose.default: 1 ``` -Before lowering, the graph contained two general convolution operations (stride-1 and stride-4). The `aten` prefix identifies PyTorch’s ATen operator namespace. These operators describe the computation, but not the hardware or kernel that will perform it. Lowering replaces both with `cortex_m.quantized_conv2d_nhwc`, an INT8 convolution using NHWC layout. +Before lowering, the graph contained two general convolution operations: stride-1 and stride-4. The `aten` prefix identifies the PyTorch ATen operator namespace. These operators describe the computation, but not the hardware or kernel that will perform it. Lowering replaces both with `cortex_m.quantized_conv2d_nhwc`, an INT8 convolution using NHWC layout. `aten.topk` is unchanged, so it will use the portable CPU kernel. The `cortex_m.quantize_*` and `cortex_m.dequantize_*` operators mark boundaries between floating-point (FP32) and INT8 @@ -111,11 +112,11 @@ regions. ## What you've accomplished and what's next -You have seen how Cortex-M lowering replaces supported patterns with optimized +You've seen how Cortex-M lowering replaces supported patterns with optimized Cortex-M operators. The convolutions use CMSIS-NN, quantize and dequantize use Helium vector implementations, and `topk` remains an ExecuTorch portable kernel. -Next, you will see how CMSIS-NN provides optimized CPU fallback when deploying a +Next, you'll see how CMSIS-NN provides optimized CPU fallback when deploying a model to an Ethos-U NPU. The resulting graph combines Ethos-U delegation, CMSIS-NN-backed Cortex-M operators, and a portable CPU kernel. diff --git a/content/learning-paths/embedded-and-microcontrollers/optimize-executorch-fallback-cortex-m/3-add-ethosu-fallback.md b/content/learning-paths/embedded-and-microcontrollers/optimize-executorch-fallback-cortex-m/3-add-ethosu-fallback.md index 167c75591c..e9a7b5d368 100644 --- a/content/learning-paths/embedded-and-microcontrollers/optimize-executorch-fallback-cortex-m/3-add-ethosu-fallback.md +++ b/content/learning-paths/embedded-and-microcontrollers/optimize-executorch-fallback-cortex-m/3-add-ethosu-fallback.md @@ -7,22 +7,25 @@ description: Partition TinyCNN for Ethos-U, lower the remaining convolution to C layout: learningpathall --- -## Deploying across Cortex-M and Ethos-U NPU +## Deploy across Cortex-M and Ethos-U NPU -We can re-use the same script as on the previous page, this time using 'Fallback mode'. This uses `EthosUPartitioner` to +After seeing what running the model exclusively on Cortex-M looks like, set up deployment across Cortex-M and the Ethos-U NPU. + +Re-use the same exporter script as earlier, this time creating a fallback. The exporter uses `EthosUPartitioner` to create an Ethos-U55 delegate region, represented by `executorch_call_delegate`. -The exporter then applies `CortexMPassManager` to operations left outside that -delegate, lowering its supported convolution to a registered Cortex-M operator +It then applies `CortexMPassManager` to operations left outside that +delegate. The exporter lowers its supported convolution to a registered Cortex-M operator implemented by CMSIS-NN. +### See how the export script creates a fallback + For supported neural-network operations, the expected order is Ethos-U NPU, -then CMSIS-NN on the Cortex-M CPU, then a portable CPU kernel. This keeps as much -work as possible on the NPU and gives unsupported quantized work an optimized +then CMSIS-NN on the Cortex-M CPU, then a portable CPU kernel. This keeps as much work as possible on the NPU. It gives unsupported quantized work an optimized CPU route before using a general implementation. ![Flow diagram showing that the graph is quantized, supported work is partitioned for Ethos-U, the supported remainder is lowered to Cortex-M operators, and the final remainder stays portable. This order preserves eligible NPU work before CPU lowering.#center](images/executorch-export-flow.svg "ExecuTorch partitioning and lowering order") -Ordering matters. If Cortex-M lowering runs first, it could rewrite a +The ordering matters. If Cortex-M lowering runs first, it can rewrite a convolution that should be offered to the NPU. The exporter first creates an Ethos-U55 compile specification and configures @@ -59,7 +62,9 @@ edge_program_manager._edge_programs["forward"] = CortexMPassManager( This run uses the `ethos-u55-128` target to create the predictable fallback described earlier. -Run the export script in mixed Cortex-M + Ethos-U mode: +### Export the model for Cortex-M and Ethos-U + +Run the export script in mixed Cortex-M and Ethos-U mode: {{< tabpane code=true >}} {{< tab header="Linux and macOS" language="bash">}} @@ -96,21 +101,25 @@ executorch_call_delegate: 1 ``` The final graph contains all three execution paths: -- `executorch_call_delegate` contains the stride-1 convolution accepted by +- `executorch_call_delegate` contains the stride-1 convolution that's accepted by Ethos-U55. -- `cortex_m.quantized_conv2d_nhwc` is the stride-4 convolution rejected by +- `cortex_m.quantized_conv2d_nhwc` is the stride-4 convolution that's rejected by Ethos-U55 and lowered to CMSIS-NN. - `aten.topk` remains a portable FP32 operation. -## Using the CMSIS-Executorch project workflow +## Use the CMSIS-Executorch project workflow + +The CMSIS-Executorch project workflow uses `create_ai_layer.py` to complete the following tasks: -The CMSIS-Executorch project workflow uses `create_ai_layer.py` to export a model, generate a `.pte`, and select the source components required to execute it. +- Model export +- `.pte` generation +- Selection of source components required to run the model -We have instead used a separate script for the previous examples. By using `create_ai_layer.py` instead, we will benefit from the rest of the setup. +So far, you've used a separate script for these tasks. By using `create_ai_layer.py` instead, you'll benefit from the rest of the setup. -The pre-existing `create_ai_layer.py` does not include CMSIS-NN lowering, so we will add this through a targeted patch that makes four key changes: +The pre-existing `create_ai_layer.py` doesn't include CMSIS-NN lowering. You'll add this through a targeted patch that makes four key changes: -- It adds `ARM::CMSIS-NN@8.0.0` to the solution's Pack list. +- It adds `ARM::CMSIS-NN@8.0.0` to the Pack list of the solution. - It applies Cortex-M lowering after Ethos-U partitioning. - It maps explicit-layout names such as `quantized_conv2d_nhwc` to their Pack component names. @@ -127,7 +136,7 @@ git --no-pager diff -- cmsis-executorch-u55.csolution.yml create_ai_layer.py No board, runner, or linker changes are needed. -## Generate the target description +### Generate the target description Resolve the declared Packs and active target: @@ -135,7 +144,7 @@ Resolve the declared Packs and active target: cbuild setup cmsis-executorch-u55.csolution.yml --active SSE-300-U55 --packs ``` -This one command installs missing packs through the public Pack index and +This command installs missing packs through the public Pack index and writes three useful descriptions: - `cmsis-executorch-u55.cbuild-pack.yml` locks the resolved Pack versions. @@ -143,7 +152,7 @@ writes three useful descriptions: Vela settings, and destination AI layer. - `cmsis-executorch-u55.cbuild-idx.yml` indexes the resolved build context. -## Generate the AI layer +### Generate the AI layer Use the MLOps description to export the model and write its CMSIS AI layer: @@ -156,21 +165,21 @@ python .\create_ai_layer.py .\cmsis-executorch-u55.cbuild-mlops.yml {{< /tab >}} {{< /tabpane >}} -The relevant final output is similar to: +The output is similar to: ```output [ai_layer] 7608 byte program, operators: ['Cortex-M dequantize_per_tensor', 'Cortex-M quantize_per_tensor', 'Cortex-M quantized_conv2d', 'Cortex-M transpose', 'Portable topk'] [ai_layer] wrote .../ai_layer/ai_layer.clayer.yml ``` -The generator writes the final `model.pte`, converts it to C data for the -firmware, and records the runtime and operator components needed to execute it. +The generator writes the final `model.pte` and converts the `.pte` file to C data for the +firmware. It then records the runtime and operator components that are needed to run the file. ## What you've accomplished and what's next -You have produced a model-specific AI layer with one Ethos-U55 delegate, one +You've produced a model-specific AI layer with one Ethos-U55 delegate, one CMSIS-NN-backed fallback convolution, and one portable operation. The split is decided ahead of time and stored in the ExecuTorch program. -Next, you will inspect how the two published source Packs supply the code behind +Next, you'll inspect how the two published source Packs supply the code behind those graph targets. diff --git a/content/learning-paths/embedded-and-microcontrollers/optimize-executorch-fallback-cortex-m/4-inspect-cmsis-pack.md b/content/learning-paths/embedded-and-microcontrollers/optimize-executorch-fallback-cortex-m/4-inspect-cmsis-pack.md index 32f9a1ea06..e4340566cb 100644 --- a/content/learning-paths/embedded-and-microcontrollers/optimize-executorch-fallback-cortex-m/4-inspect-cmsis-pack.md +++ b/content/learning-paths/embedded-and-microcontrollers/optimize-executorch-fallback-cortex-m/4-inspect-cmsis-pack.md @@ -9,19 +9,19 @@ layout: learningpathall ## Understand what the CMSIS Pack provides -The [ExecuTorch CMSIS Pack](https://www.keil.arm.com/packs/executorch-pytorch/overview/) is a *source Pack*, not a prebuilt runtime library. It supplies the ExecuTorch runtime, registration code, backends, and +After producing a model-specific AI layer using the CMSIS-ExecuTorch workflow, inspect what the CMSIS Pack provides to this implementation. + +The [ExecuTorch CMSIS Pack](https://www.keil.arm.com/packs/executorch-pytorch/overview/) is a source Pack, not a prebuilt runtime library. The Pack supplies the ExecuTorch runtime, registration code, backends, and operators as selectable CMSIS components. -A `.pack` file is a ZIP-compatible archive. Its Pack Description file, or -PDSC, records component names, source files, dependencies, versions, and -conditions. +A `.pack` file is a ZIP-compatible archive. Its Pack Description file (PDSC) records component names, source files, dependencies, versions, and conditions. CMSIS-Toolbox uses that metadata to add only the chosen components to the application build. A CMSIS project can select only the components required by its lowered graph instead of maintaining one large source list. Arm Compiler then compiles those sources for the Cortex-M55 target with the rest of the project. -## See which Packs were resolved +### See which Packs were resolved CMSIS-Toolbox has already acquired the software Packs needed by the project. Inspect the generated Pack lock: @@ -45,17 +45,17 @@ mixed model: They have different responsibilities: -- `PyTorch::ExecuTorch@1.5.1` supplies the ExecuTorch runtime, Ethos-U backend, - Cortex-M operator wrappers, registration code, and portable operators. -- `ARM::CMSIS-NN@8.0.0` supplies the optimized neural-network kernels called by +- `PyTorch::ExecuTorch@1.5.1` supplies the ExecuTorch runtime, Ethos-U backend, and + Cortex-M operator wrappers. It also supplies registration code and portable operators. +- `ARM::CMSIS-NN@8.0.0` supplies the optimized neural-network kernels that are called by the Cortex-M convolution wrapper. -The Pack lock records exact resolved versions so later builds don't silently +The Pack lock records exact resolved versions so that later builds don't silently move to newer installed Packs. -## Trace the graph into the AI layer +### Trace the graph into the AI layer -The AI layer is a generated CMSIS software layer that embeds the model and declares the runtime, backends, operators, and libraries needed to execute it. +The AI layer is a generated CMSIS software layer that embeds the model. It declares the runtime, backends, operators, and libraries needed to run the model. Open the AI layer generated from the `.pte` operator list: @@ -96,16 +96,17 @@ This file is the handover between model export and firmware build: The runtime, kernel utilities, and registration components provide the common machinery needed to load the `.pte` and dispatch its operators. -You will also see `ARM_NN_ENABLE_F32` and `ARM_NN_ENABLE_F16` definitions in +You'll also see `ARM_NN_ENABLE_F32` and `ARM_NN_ENABLE_F16` definitions in the generated layer. CMSIS-NN 8.0.0 needs them because its Pack component -compiles optional floating-point source files. The fallback convolution in -this model remains INT8; these definitions don't change its data type. +compiles optional floating-point source files. + +The fallback convolution in this model remains INT8. These definitions don't change its data type. ## What you've learned and what's next -You have followed graph targets into two versioned source Packs and a concrete +You've followed graph targets into two versioned source Packs and a concrete component list. Pack acquisition, dependency resolution, and component selection are now one connected workflow rather than separate downloads. -Next, you will see how the reusable CMSIS project combines this generated AI +Next, you'll see how the reusable CMSIS project combines this generated AI layer with the Corstone-300 board and application layers. diff --git a/content/learning-paths/embedded-and-microcontrollers/optimize-executorch-fallback-cortex-m/5-prepare-cmsis-runner.md b/content/learning-paths/embedded-and-microcontrollers/optimize-executorch-fallback-cortex-m/5-prepare-cmsis-runner.md index 4f3a3eaa5d..ff33f9d4cc 100644 --- a/content/learning-paths/embedded-and-microcontrollers/optimize-executorch-fallback-cortex-m/5-prepare-cmsis-runner.md +++ b/content/learning-paths/embedded-and-microcontrollers/optimize-executorch-fallback-cortex-m/5-prepare-cmsis-runner.md @@ -9,8 +9,10 @@ layout: learningpathall ## Understand the solution file +After understanding the CMSIS Packs needed by the project, explore how the project works. + `cmsis-executorch-u55.csolution.yml` defines the complete Ethos-U55 build context. -Open it and inspect: +The target definition in the solution file includes: ```yaml target-types: @@ -22,11 +24,11 @@ target-types: - AI-Layer: $SolutionDir()$/ai_layer/ai_layer.clayer.yml ``` -`SSE-300-U55` is the project's readable target name. The board and device +`SSE-300-U55` is the readable target name of the project. The board and device values identify records supplied by installed Packs. CMSIS-Toolbox uses those identities to resolve startup files, memory information, and device conditions. -The solution's `mlops:` node is the single source for the NPU and Vela target +The `mlops:` node in the solution file is the single source for the NPU and Vela target settings: ```yaml @@ -44,9 +46,9 @@ mlops: calibration-samples: 2 ``` -`cbuild setup` resolves this into the `*.cbuild-mlops.yml` file consumed by -`create_ai_layer.py`. The exporter therefore doesn't duplicate the project's -NPU configuration. +`cbuild setup` resolves this into the `*.cbuild-mlops.yml` file that's consumed by +`create_ai_layer.py`. The exporter therefore doesn't duplicate the +NPU configuration of the project. ## Follow the layers into the project @@ -69,20 +71,20 @@ layers: Each part has one job: -- The Board layer supplies Cortex-M55 startup, the memory layout, standard - output, the Ethos-U55 driver, and Corstone-300 initialization. +- The Board layer supplies Cortex-M55 startup, the memory layout, and standard + output. It also provides the Ethos-U55 driver and Corstone-300 initialization. - The generated AI layer supplies the embedded model and its exact ExecuTorch and CMSIS-NN component selection. - The App group initializes ExecuTorch, creates an input tensor, runs one inference, and prints the ten output values. -The FVP configuration in `board/Corstone-300/fvp_config_u55.txt` describes the -simulated hardware. It is separate from the Board layer because one configures -the simulator while the other builds software for the simulated target. +The Fixed Virtual Platform (FVP) configuration in `board/Corstone-300/fvp_config_u55.txt` describes the +simulated hardware. It's separate from the Board layer because one configures +the simulator, while the other builds software for the simulated target. ## See how the PTE enters the firmware -The AI-layer directory now contains these related model files: +The AI-layer directory now contains the following related model files: ```text ai_layer/model.pte @@ -91,24 +93,24 @@ ai_layer/model_pte.h ``` `model.pte` is the serialized ExecuTorch program. `model_pte.c` contains the -same bytes represented as a C array, which is why it appears to be a long list +same bytes represented as a C array. This is why it appears to be a long list of numbers. Embedding the bytes lets a bare-metal system load the program without a filesystem. `src/app_main.cpp` includes `model_pte.h`, wraps a deterministic `1 x 16 x 16 x 3` input buffer as an ExecuTorch tensor, and calls the runtime. -The runtime follows the PTE execution plan: it invokes the Ethos-U backend for +The runtime follows the PTE execution plan. It invokes the Ethos-U backend for the delegate and CPU kernels for the remaining operations. -Because the adapted model preserves the original input shape and ten-value -output, the runner doesn't need model-specific edits. A different model shape +The runner doesn't need model-specific edits because the adapted model preserves the original input shape and ten-value +output. A different model shape or output contract would need corresponding changes in `app_main.cpp`. ## What you've learned and what's next -You have traced the ready-made project from target selection to the embedded -PTE. The repository removes board bring-up work from the lesson while keeping +You've traced the ready-made project from target selection to the embedded +PTE. The repository removes board bring-up work while keeping the CMSIS structure visible and reusable. -Next, you will compile these parts, verify which Pack sources were used, and run +Next, you'll compile these parts, verify which Pack sources were used, and run the image on the Corstone-300 FVP. diff --git a/content/learning-paths/embedded-and-microcontrollers/optimize-executorch-fallback-cortex-m/6-consume-cmsis-pack.md b/content/learning-paths/embedded-and-microcontrollers/optimize-executorch-fallback-cortex-m/6-consume-cmsis-pack.md index cdeee27e8c..a3a6119536 100644 --- a/content/learning-paths/embedded-and-microcontrollers/optimize-executorch-fallback-cortex-m/6-consume-cmsis-pack.md +++ b/content/learning-paths/embedded-and-microcontrollers/optimize-executorch-fallback-cortex-m/6-consume-cmsis-pack.md @@ -9,10 +9,13 @@ layout: learningpathall ## Build the application -In VS Code's **CMSIS** view, confirm that -`cmsis-executorch-u55.csolution.yml` is the active solution and -`SSE-300-U55` is the selected target. Select **Build** to compile the application -using the AI layer generated in chapter 3. +Now that you've understood how the application works, build and run it. + +In the Visual Studio Code (VS Code) **CMSIS** view, confirm that +`cmsis-executorch-u55.csolution.yml` is the active solution. Confirm that +`SSE-300-U55` is the selected target. + +Then, select **Build** to compile the application using the AI layer that you generated earlier. CMSIS-Toolbox combines the App, Board, and AI layers, resolves their selected components, and invokes Arm Compiler for Embedded. Check that the build task @@ -24,14 +27,14 @@ out/cmsis-executorch/SSE-300-U55/Debug/ ``` The `.axf` file contains the linked executable and debug information. The -`.hex` file contains the image loaded into the FVP. +`.hex` file contains the image loaded into the Fixed Virtual Platform (FVP). ## Verify the compiled source paths A successful build proves that an image was produced, but it doesn't by itself -show which implementation supplied each operation. In the VS Code terminal, -with `.venv` activated and the project root as the current directory, run the -verification helper against the compilation database: +show which implementation supplied each operation. In the VS Code terminal, ensure that `.venv` is activated and you're in the project root directory. + +Then, run the verification helper against the compilation database: {{< tabpane code=true >}} {{< tab header="Linux and macOS" language="bash">}} @@ -55,16 +58,16 @@ PASS: ExecuTorch portable topk kernel was compiled from its declared CMSIS Pack ``` These checks distinguish the two layers of the optimized fallback. The -ExecuTorch Pack provides the `quantized_conv2d` wrapper, while the CMSIS-NN +ExecuTorch Pack provides the `quantized_conv2d` wrapper. The CMSIS-NN Pack provides the convolution implementation that wrapper calls. Together with `cmsis-executorch-u55.cbuild-pack.yml`, the compilation database -shows both the resolved Pack versions and the source files actually compiled. +shows that both the resolved Pack versions and the source files compiled. ## Run the image on the FVP In the same VS Code terminal, start the Corstone-300 model and load the generated -HEX image. On macOS, use the Docker wrapper configured during setup: +HEX image. On macOS, use the Docker wrapper that you configured during setup: {{< tabpane code=true >}} {{< tab header="Linux and Windows" language="console">}} @@ -87,33 +90,33 @@ Output: 10 element(s): 0.0532 -0.0239 0.0541 0.1064 0.0706 0.0395 0.0881 0.1340 Test_result: PASS ``` -The runner prints `Test_result: PASS` when inference returns successfully with a nonempty output list. Check that the preceding line also reports ten output values, as shown above. The runner does not assert the tensor shape, data type, or numerical accuracy. To validate a trained model, compare its outputs against a reference using the same input data and a tolerance appropriate to the quantization. +The runner prints `Test_result: PASS` when inference returns successfully with a nonempty output list. Check that the preceding line also reports ten output values, as shown. + +The runner doesn't assert the tensor shape, data type, or numerical accuracy. To validate a trained model, compare its outputs against a reference. Use the same input data and a tolerance appropriate to the quantization. {{% notice Note %}} -On Windows, the FVP can print warnings that `python3.dll` is unavailable and +On Windows, the FVP can print warnings indicating that `python3.dll` is unavailable and that the VIO or VSI bridges are disabled. This headless example doesn't use those bridges. If the run reaches `Test_result: PASS`, inference completed successfully. {{% /notice %}} -This run checks successful execution of the mixed graph. To measure latency or power, benchmark the complete graph on your target hardware, including delegation boundaries and tensor conversions. +This run checks that the mixed graph ran successfully. To measure latency or power, benchmark the complete graph on your target hardware, including delegation boundaries and tensor conversions. ## What you've accomplished -You have built and run one ExecuTorch program across three execution paths, and used CMSIS-Executorch to make setup easier: - -- The supported convolution runs in an Ethos-U55 delegate. -- The unsupported stride-4 convolution runs on Cortex-M55 through the - ExecuTorch wrapper and optimized CMSIS-NN kernel. -- `topk` runs through the portable ExecuTorch CPU kernel. +You've built and run one ExecuTorch program across three execution paths, and used CMSIS-Executorch to make setup easier. -You also checked the implementation: the exported graph identifies each execution path, the compilation database identifies the selected Pack sources, and the successful build and FVP run confirm that the combined firmware executes. +The supported convolution runs in an Ethos-U55 delegate. The unsupported stride-4 convolution runs on Cortex-M55 through the ExecuTorch wrapper and optimized CMSIS-NN kernel. `topk` runs through the portable ExecuTorch CPU kernel. This build uses Ethos-U55 to make one unsupported convolution predictable. The same Pack workflow applies to another Ethos-U target when its delegated graph leaves operations for Cortex-M execution. -To adapt the project, replace `model/model.py`, provide representative -calibration inputs, preserve or update the runner's tensor interface, and -regenerate the AI layer before rebuilding. +To adapt the project, complete the following steps: + +- Replace `model/model.py`. +- Provide representative calibration inputs. +- Preserve or update the tensor interface of the runner. +- Regenerate the AI layer before rebuilding. diff --git a/content/learning-paths/embedded-and-microcontrollers/optimize-executorch-fallback-cortex-m/_index.md b/content/learning-paths/embedded-and-microcontrollers/optimize-executorch-fallback-cortex-m/_index.md index e7156fa417..5eb1833975 100644 --- a/content/learning-paths/embedded-and-microcontrollers/optimize-executorch-fallback-cortex-m/_index.md +++ b/content/learning-paths/embedded-and-microcontrollers/optimize-executorch-fallback-cortex-m/_index.md @@ -1,9 +1,5 @@ --- -title: Optimize ML model deployment on microcontrollers with CMSIS-NN kernels - -draft: true -cascade: - draft: true +title: Optimize ExecuTorch fallback with CMSIS-NN on Cortex-M description: Build an ExecuTorch 1.5.1 application from the published ExecuTorch CMSIS Pack and use CMSIS-NN kernels for Cortex-M fallback. @@ -12,17 +8,71 @@ minutes_to_complete: 60 who_is_this_for: This Learning Path is for embedded machine learning developers building ExecuTorch applications for Cortex-M CPUs and Ethos-U NPUs. learning_objectives: - - Export an ExecuTorch graph with Ethos-U, CMSIS-NN, and portable-kernel execution regions - - Lower quantized CPU fallback operations to CMSIS-NN-backed Cortex-M operators - - Trace the exported operators to selected components in the published ExecuTorch 1.5.1 and CMSIS-NN Packs - - Build and run the application on a Corstone-300 Ethos-U55 FVP + - Export an ExecuTorch graph with Ethos-U, CMSIS-NN, and portable-kernel execution regions. + - Lower quantized CPU fallback operations to CMSIS-NN-backed Cortex-M operators. + - Trace the exported operators to selected components in the published ExecuTorch 1.5.1 and CMSIS-NN Packs. + - Build and run the application on a Corstone-300 Ethos-U55 Fixed Virtual Platform (FVP). prerequisites: - - A host machine - Windows or Linux PC, or an Apple silicon Mac running macOS 15 or later + - A Windows or Linux host machine, or an Apple silicon Mac running macOS 15 or later - Visual Studio Code installed - Familiarity with PyTorch - Basic familiarity with Cortex-M processors and Ethos-U NPUs +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-16T18:11:21Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: 5231760658ab4bce27bb5e1a7d4e422ad7b8c3ce6f2556d7641544dd3ab9fa1f + summary_generated_at: '2026-11-16T18:11:21Z' + summary_source_hash: 5231760658ab4bce27bb5e1a7d4e422ad7b8c3ce6f2556d7641544dd3ab9fa1f + faq_generated_at: '2026-11-16T18:11:21Z' + faq_source_hash: 5231760658ab4bce27bb5e1a7d4e422ad7b8c3ce6f2556d7641544dd3ab9fa1f + summary: >- + You'll build and validate an ExecuTorch application that runs across Ethos-U and Cortex-M, + with CMSIS-NN accelerating its fallback convolution. First, you'll export the model for + Cortex-M alone, then add Ethos-U delegation and identify the portable `topk` operation. + You'll trace the exported operations to versioned CMSIS Pack components and follow the + solution and generated AI layer into the firmware build. Finally, you'll verify the compiled + source paths and run the application on the Corstone-300 Ethos-U55 FVP. + faqs: + - question: How can I tell that the initial export uses only Cortex-M? + answer: >- + Check that the exported graph has no `executorch_call_delegate` node. You'll see + supported patterns lowered to `cortex_m.*` operators, while `aten.topk` remains + portable. In this model, the quantized convolutions use CMSIS-NN, but other + Cortex-M operators can use different implementations. + - question: Which execution paths does the mixed model use? + answer: >- + Inspect the exported operator list. You'll find the stride-1 convolution + in an Ethos-U55 delegate and the stride-4 convolution on Cortex-M55 through + CMSIS-NN. The remaining `topk` operation uses a portable ExecuTorch CPU kernel. + - question: How do I trace exported operations to CMSIS Pack components? + answer: >- + Inspect `cmsis-executorch-u55.cbuild-pack.yml` for the resolved ExecuTorch and + CMSIS-NN Pack versions, then inspect `ai_layer/ai_layer.clayer.yml` for the + components selected from those Packs. You'll find the Ethos-U backend, + Cortex-M operator wrappers, CMSIS-NN library, and portable `topk` component. + - question: How does the CMSIS project include the model and AI layer? + answer: >- + Inspect `cmsis-executorch-u55.csolution.yml` to see the `SSE-300-U55` target + and its Board and AI layer references. The generated AI layer selects the runtime components of the model. The project generates `model_pte.c` from + `model.pte`, so the bare-metal application can load the program without a + filesystem. + - question: What does the final FVP run verify? + answer: >- + `compile_commands.json` confirms that the build compiled the + expected ExecuTorch, Ethos-U, CMSIS-NN, and portable `topk` sources. On the FVP, + `Test_result: PASS` tells you that inference returned a nonempty output list. Check + that the output also reports ten values. You need a reference comparison to + assess numerical accuracy. +# END generated_summary_faq + author: - Matt Cossins - Kwashie Andoh diff --git a/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/_index.md b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/_index.md new file mode 100644 index 0000000000..93af102f35 --- /dev/null +++ b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/_index.md @@ -0,0 +1,67 @@ +--- +title: "Deploy PocketBeagle 2 temperature sensing to AWS IoT Core with Zephyr and Greengrass Lite" +description: Extend your PocketBeagle 2 Yocto image and Cortex-M4F Zephyr setup with two S3-backed Greengrass components that manage external temperature sensing and publish JSON to AWS IoT Core. + +draft: true +cascade: + draft: true + +minutes_to_complete: 120 + +who_is_this_for: Embedded Linux developers managing a Zephyr application and a Linux telemetry bridge through AWS IoT Greengrass. + +learning_objectives: + - Read calibrated temperature from an external BMP280 over I2C using Zephyr on the Cortex-M4F + - Implement the mailbox shutdown acknowledgment required by the Linux remoteproc driver + - Package firmware and a Linux bridge as two S3-backed Greengrass Lite custom components + - Publish JSON telemetry to ti/pocketbeagle2/temperature/external through Greengrass IPC + - Remove the components through a revised deployment and verify application cleanup + +prerequisites: + - Complete [Deploy a Hello World component to PocketBeagle 2 with Greengrass Lite](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/) and [Run Zephyr on the PocketBeagle 2 MCU alongside Yocto Linux](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/) on PocketBeagle 2 revision A1 with AM6254 + - Keep the Yocto image, Nucleus Lite 2.6.0 installation, device identity, Internet connection, and dedicated thing group + - Keep the Ubuntu build host, Zephyr v4.3.0 workspace, and Zephyr SDK 0.17.4 + - The supplied BMP280 I2C breakout with 3.3 V supply and logic, external I2C pull-ups, and jumper wires + - AWS CLI v2 and permission to publish components, revise deployments, create an S3 bucket, and extend the existing device role and certificate policy + +author: Doug Anson +generate_summary_faq: true +rerun_summary: false +rerun_faqs: false +skilllevels: Advanced +subjects: Embedded Linux + +armips: + - Cortex-A + - Cortex-M + +operatingsystems: + - Linux + - RTOS + +tools_software_languages: + - Yocto Project + - Zephyr + - AWS IoT Greengrass + - C + - Python + +further_reading: + - resource: + title: Deploy a Hello World component to PocketBeagle 2 with Greengrass Lite + link: /learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/ + type: learningpath + - resource: + title: Run Zephyr on the PocketBeagle 2 MCU alongside Yocto Linux + link: /learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/ + type: learningpath + - resource: + title: Nucleus Lite 2.6.0 recipe support + link: https://github.com/aws-greengrass/aws-greengrass-lite/blob/v2.6.0/docs/RECIPE_SUPPORT_CHANGES.md + type: documentation + +### FIXED, DO NOT MODIFY +weight: 1 +layout: "learningpathall" +learning_path_main_page: "yes" +--- diff --git a/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/_next-steps.md b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/_next-steps.md new file mode 100644 index 0000000000..e20dfa6d43 --- /dev/null +++ b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/_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/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/bridge.md b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/bridge.md new file mode 100644 index 0000000000..f4afe2cba7 --- /dev/null +++ b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/bridge.md @@ -0,0 +1,79 @@ +--- +title: "Package the Linux telemetry bridge" +description: Prepare offline AArch64 SDK dependencies and understand UART validation, Greengrass IPC, and bridge cleanup. +weight: 5 +layout: "learningpathall" +--- + +## Follow the bridge data flow + +`components/bridge.py` opens the dedicated Linux MAIN_UART0 port at 115200 8N1, reads newline-delimited frames, and accepts only the `pb2.external.temperature` schema. It checks integer types, counter signs, and the sensor's temperature range, bounds UART buffering, and ignores boot banners and error messages. + +For each valid frame it calls Greengrass IPC `PublishToIoTCore`, with QoS 1 and this exact topic: + +```text +ti/pocketbeagle2/temperature/external +``` + +An illustrative published message is: + +```json +{ + "schemaVersion": 1, + "thingName": "MyPocketBeagle2", + "sensor": "BMP280", + "location": "external", + "temperatureC": 25.08, + "sequence": 12, + "mcuUptimeMs": 60320, + "linuxBootId": "698a3054-59a4-4b6f-a4e3-bcf329b9d75a", + "timestamp": "2026-10-29T18:00:00.123+00:00" +} +``` + +`timestamp` is Linux's UTC receipt time, not an MCU wall clock. Keep the board's clock synchronized as in [Deploy a Hello World component to PocketBeagle 2 with Greengrass Lite](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/). `sequence` and `mcuUptimeMs` restart when the M4 restarts; `linuxBootId` identifies the Linux boot. QoS 1 can deliver duplicates. The bridge logs publish failures and drops the affected samples, then attempts later samples again. This exercise provides live monitoring without a persistent offline queue or a lossless-delivery promise. + +The bridge uses the [AWS IoT Device SDK for Python v2](https://github.com/aws/aws-iot-device-sdk-python-v2/tree/v1.26.0), pinned here as `awsiotsdk==1.26.0`, with its required `awscrt==0.28.1`. Greengrass provides the IPC socket and component authentication environment. The [MQTT IPC authorization guide](https://docs.aws.amazon.com/greengrass/v2/developerguide/ipc-iot-core-mqtt.html) defines the recipe's topic-limited `aws.greengrass.ipc.mqttproxy` permission. + +## Stage both components + +On the Ubuntu host, use the source workspace and the new ELF: + +```bash +cd "$HOME/pb2-temperature-part3" +sh tools/stage.sh \ + "$HOME/pb2-zephyr-workspace/build/pb2-external-temperature/zephyr/zephyr.elf" 312 +find staging -type f -print +``` + +The script downloads wheels for **Linux AArch64 and Python 3.12**, even when the build host is x86_64. It must produce an AArch64 `awscrt` wheel and a universal `awsiotsdk` wheel. Do not ship an x86_64 native wheel to the board or allow the component to compile a dependency during installation. + +The directory structure is: + +```text +staging/ + com.arm.PocketBeagle2.ZephyrExternalTemperature/1.0.0/ + firmware_manager.py + zephyr.elf + com.arm.PocketBeagle2.ExternalTemperatureBridge/1.0.0/ + bridge.py + bridge_lifecycle.sh + awsiotsdk-1.26.0-....whl + awscrt-0.28.1-...aarch64.whl +``` + +If Python differs on your image, rebuild the wheel selection for that interpreter and verify it on the target before deployment. The example assumes the unchanged Scarthgap image from [Deploy a Hello World component to PocketBeagle 2 with Greengrass Lite](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/) and its Python 3.12 and glibc environment. + +## Understand offline installation and cleanup + +Greengrass downloads each declared artifact from S3 **before** `install`. The bridge install script runs pip with `--no-index`, `--no-cache-dir`, `--find-links {artifacts:path}`, and a private `--target {work:path}/installed-`. Its digest covers the bridge, lifecycle script, and wheels so different versions can be staged independently. The board requires S3 access, but no PyPI access during deployment. Python, pip, and standard library modules come from the existing Yocto image. + +The foreground `run` supervisor starts the bridge in its own component control group. On normal SIGTERM it waits for Python to close the UART and IPC client, then removes the installed Python directory. The next start can rebuild that directory from the cached artifacts. It installs no separately enabled service, credential copy, or global Python package. + +Both bridge phases request root in this development example for direct serial-device access. For a production image, set up an appropriate device group and use an unprivileged bridge user; retain privilege only for the remoteproc operations that require it. + +The two custom components have no dependency on one another. They can be removed separately: removing the bridge leaves sensing on the M4; removing the firmware leaves a bridge that reports missing samples. Deploy and remove them together for the full exercise. Their startup order is immaterial because the MCU sends repeatedly and the bridge tolerates a quiet UART. + +## What you have learned + +You have learned how the Linux bridge validates MCU UART frames, converts them into JSON, and publishes them through Greengrass IPC to the required IoT Core topic. You can package the bridge with compatible AArch64 wheels for offline installation and explain its timestamp, delivery, and cleanup behavior. diff --git a/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/cleanup.md b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/cleanup.md new file mode 100644 index 0000000000..59ef94385f --- /dev/null +++ b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/cleanup.md @@ -0,0 +1,70 @@ +--- +title: "Cleaning up our deployment" +description: Revise desired deployment state, verify that firmware, bridge, and AWS IoTCore telemetry stop, and optionally try a clean redeployment to re-enable them. +weight: 8 +layout: "learningpathall" +--- + +## Remove the application through deployment state + +First, on the Ubuntu host, lets ensure we have the `jq` app installed: + +```bash +sudo apt install -y jq +``` + +Now, again the Ubuntu host, retrieve the **latest** deployment for this group again. Then, we revise the deployment and remove the two components that are referenced within the deployment: + +```bash +export CURRENT_DEPLOYMENT_ID=`aws greengrassv2 list-deployments --target-arn "$GROUP_ARN" --history-filter LATEST_ONLY | jq -r '.deployments[].deploymentId'` +aws greengrassv2 get-deployment --deployment-id "$CURRENT_DEPLOYMENT_ID" \ + > current-deployment.json +python3 - <<'PYTHON' +import json, os +from pathlib import Path +current = json.loads(Path('current-deployment.json').read_text()) +assert current['targetArn'] == os.environ['GROUP_ARN'] +components = current.get('components', {}).copy() +components.pop('com.arm.PocketBeagle2.ZephyrExternalTemperature', None) +components.pop('com.arm.PocketBeagle2.ExternalTemperatureBridge', None) +Path('remove-deployment.json').write_text(json.dumps({ + 'targetArn': os.environ['GROUP_ARN'], + 'deploymentName': 'Remove PocketBeagle2 temperature applications', + 'components': components +}, indent=2) + '\n') +PYTHON +export REMOVE_ID=$(aws greengrassv2 create-deployment \ + --cli-input-json file://remove-deployment.json --query deploymentId --output text) +aws greengrassv2 list-effective-deployments --core-device-thing-name "$THING_NAME" +aws greengrassv2 list-installed-components --core-device-thing-name "$THING_NAME" +``` + +Wait for `REMOVE_ID` to succeed. If another group deployment, a direct thing deployment, a local deployment, or another component dependency still requests either component, remove that request too. The two recipes in this Learning Path do not keep each other installed through dependencies. Canceling a deployment, deleting a component version, deleting the core-device cloud record, or merely removing thing-group membership does not provide this controlled teardown. + +## Check the actual stop behavior + +On PocketBeagle 2, in the SSH session retaining `FW_UNIT`, `BRIDGE_UNIT`, and the work paths: + +```bash +pb2-m4 status +``` + +You should see a `state=offline` indicating that the zephyr app has been halted. + +On the AWS console, you should be able to confirm, via inspection, that your Greengrass deployment now has zero components associated with it. This indicates that the deployment is empty and thus the removal was successful. + +## Prove the firmware can be deployed again + +Either via the CLI or via the AWS console, the deployment can be `re-filled` with the two custom components that we created. Upon selecting both components and deploying the updated deployment, the pocketbeagle2 should start sending telemetry once again into IoTCore. + +If using the CLI, the required lifecycle acceptance test is **deploy → remove → deploy → remove**, without a board reset between these steps. Reapply the saved `deployment.json` only if its retained component selection is still current: + +```bash +aws greengrassv2 create-deployment --cli-input-json file://deployment.json +``` + +Wait for both components to run again and observe new sensor messages. Then create a fresh removal revision using the latest deployment and repeat the cleanup checks. Successful repetition proves the new firmware handles the stop protocol and that the runtime can reinstall from artifacts. If this test fails, treat the integration as incomplete; do not describe a timeout, reset, or forced driver unbind as a successful component uninstall. + +## What you have learned + +You have learned how to remove both applications through revised deployment state and verify that the M4 stops, the bridge closes its resources, and installed application files are removed. You can test redeployment without rebooting, recognize an abnormal termination that needs recovery, and retire this path's cloud resources while preserving the setup from [Deploy a Hello World component to PocketBeagle 2 with Greengrass Lite](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/). diff --git a/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/deploy.md b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/deploy.md new file mode 100644 index 0000000000..72d041b396 --- /dev/null +++ b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/deploy.md @@ -0,0 +1,115 @@ +--- +title: "Deploy both components and verify live telemetry" +description: Preserve the existing group deployment, add both custom components, and observe real sensor JSON in AWS IoT Core. +weight: 7 +layout: "learningpathall" +--- + +## Preserve the existing group selection + +On the Ubuntu AWS workstation, retain the variables from the publishing page: + +```bash +export GROUP_ARN=$(aws iot describe-thing-group --thing-group-name "$THING_GROUP" \ + --query thingGroupArn --output text) +aws iot list-things-in-thing-group --thing-group-name "$THING_GROUP" +aws greengrassv2 list-deployments --target-arn "$GROUP_ARN" --history-filter LATEST_ONLY +``` + +Confirm `MyPocketBeagle2` is a member. Save the current group deployment rather than replacing its component selection blindly. Set `BASE_DEPLOYMENT_ID` to the latest deployment ID just listed: + +```bash +export BASE_DEPLOYMENT_ID=YOUR_LATEST_GROUP_DEPLOYMENT_ID +aws greengrassv2 get-deployment --deployment-id "$BASE_DEPLOYMENT_ID" \ + > previous-deployment.json +``` + +If the thing group from [Deploy a Hello World component to PocketBeagle 2 with Greengrass Lite](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/) has no deployment because it was never deployed, first complete that Learning Path. If its latest revision removes Hello World, an empty `components` object is valid. The following update preserves whichever components remain in that latest revision, including Hello World if retained: + +```bash +python3 - <<'PYTHON' +import json, os +from pathlib import Path +base = json.loads(Path('previous-deployment.json').read_text()) +assert base['targetArn'] == os.environ['GROUP_ARN'] +components = base.get('components', {}).copy() +components['com.arm.PocketBeagle2.ZephyrExternalTemperature'] = { + 'componentVersion': '1.0.0' +} +components['com.arm.PocketBeagle2.ExternalTemperatureBridge'] = { + 'componentVersion': '1.0.0', + 'configurationUpdate': {'merge': json.dumps({'serialDevice': '/dev/ttyS7'})} +} +request = { + 'targetArn': os.environ['GROUP_ARN'], + 'deploymentName': 'PocketBeagle2 external temperature', + 'components': components +} +Path('deployment.json').write_text(json.dumps(request, indent=2) + '\n') +PYTHON +python3 -m json.tool deployment.json +``` + +Change `serialDevice` only if the board checks identified a different MAIN_UART0 device. The generated request is the complete desired selection for **this target**. Check other group memberships and direct thing deployments as well; each can independently request components or constrain versions. + +## Deploy from the cloud + +```bash +export DEPLOYMENT_ID=$(aws greengrassv2 create-deployment \ + --cli-input-json file://deployment.json --query deploymentId --output text) +aws greengrassv2 get-deployment --deployment-id "$DEPLOYMENT_ID" +aws greengrassv2 list-effective-deployments --core-device-thing-name "$THING_NAME" +aws greengrassv2 list-installed-components --core-device-thing-name "$THING_NAME" +``` + +Wait for this deployment ID to report `SUCCEEDED` on the device, and both version `1.0.0` components to report running. A group's `ACTIVE` deployment status alone is insufficient. In the console, the equivalent workflow is to revise the existing group's deployment, retain its other components, and add both custom component versions. + +During delivery, Lite fetches the ELF, scripts, and wheels from S3, validates artifacts, runs each `install`, and starts its `run` unit. No manual `scp`, `pb2-m4 load`, board-side pip download, or separately enabled application service is part of deployment. + +## Inspect the component units on the board + +On the pocketbeagle2 via SSH as root: + +```bash +systemctl list-units --all --type=service --no-pager | grep -F PocketBeagle2 +pb2-m4 status +``` +Output should resemble: + +```output +ggl.com.arm.PocketBeagle2.ExternalTemperatureBridge.install.service loaded active exited ExternalTemperatureBridge +ggl.com.arm.PocketBeagle2.ExternalTemperatureBridge.service loaded active running ExternalTemperatureBridge +ggl.com.arm.PocketBeagle2.ZephyrExternalTemperature.install.service loaded active exited ZephyrExternalTemperature +ggl.com.arm.PocketBeagle2.ZephyrExternalTemperature.service loaded active running ZephyrExternalTemperature +device=/sys/class/remoteproc/remoteproc0 name=5000000.m4fss state=running firmware=pb2-gg-temperature-4a067009bc6f802a.elf +``` + +## Observe the AWS IoT Core messages + +In the same account and Region, open **AWS IoT Core > MQTT test client**, subscribe to `ti/pocketbeagle2/temperature/external`, and wait for successive JSON messages. The console identity needs its own test-client permissions. Verify: + +1. `thingName` identifies this board, `sensor` is `BMP280`, and `location` is `external`. +2. `sequence` and `mcuUptimeMs` advance, with a normal interval near five seconds. +3. The value is plausible for the external module's location. Gently warm the sensor package with a fingertip and observe the value rise, then recover after you release it. +4. Linux stays reachable, Greengrass stays healthy, and Hello World continues if retained. + +Disconnect power before changing sensor wiring. After a powered-down sensor disconnection and subsequent redeployment, sensor reads should fail and no fabricated temperature messages should appear. Reconnect with power off, then repeat deployment. A missing-sensor test is optional; the real-temperature response and the removal test on the next page are required. + +## Diagnose failures + +| Symptom | Check | +| --- | --- | +| S3 artifact `AccessDenied` | Existing role alias points to the role with the new prefix-scoped S3 policy; bucket/key/Region, boundaries, and bucket encryption match | +| No matching platform | Manifest contains `os=linux`, `architecture=aarch64`, and `runtime=aws_nucleus_lite` | +| Offline pip install fails | All pinned wheels are declared artifacts; `awscrt` is AArch64 and compatible with Python 3.12/glibc | +| Firmware manager refuses to run | M4 is offline, no other loader owns it, and no stale ownership record remains | +| M4 running, no valid samples | Sensor model/address, 3.3 V pull-ups, GPIO ownership, P2.07-to-P1.32 jumper, correct UART, and UART diagnostics | +| IPC unauthorized | Bridge recipe access-control key, operation, and exact topic | +| IPC accepted but nothing in test client | Certificate `iot:Publish` policy, endpoint/account/Region, connection logs, and test-client subscription permissions | +| Stop times out | New ELF contains mailbox shutdown handling and WFI; no old heartbeat or second mailbox consumer is running | + +For service and kernel errors, inspect `journalctl -u ggl.core.iotcored.service -b` and `dmesg`. Preserve error details before revising the deployment. A cloud status or a single log entry is not a substitute for observing real messages and completing the stop test. + +## What you have learned + +You have learned how to add both components to the existing thing-group deployment while retaining its other components. You can verify delivery on the board, inspect the component journals, observe changing BMP280 temperature in IoT Core, and diagnose failures along the sensor-to-cloud path. diff --git a/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/firmware.md b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/firmware.md new file mode 100644 index 0000000000..2fbd69df27 --- /dev/null +++ b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/firmware.md @@ -0,0 +1,207 @@ +--- +title: "Build the Zephyr sensor application and firmware component" +description: Compile BMP280 temperature acquisition and compensation, UART telemetry, and the Linux remoteproc shutdown handshake into the M4 ELF. +weight: 4 +layout: "learningpathall" +--- + +## Build with the Zephyr toolchain + +On the Ubuntu host, reactivate the virtual environment from [Run Zephyr on the PocketBeagle 2 MCU alongside Yocto Linux](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/) and verify the existing checkout: + +```bash +source "$HOME/pb2-zephyr-venv/bin/activate" +cd "$HOME/pb2-zephyr-workspace/zephyr" +git describe --tags --exact-match +cat SDK_VERSION +``` + +Expect `v4.3.0` and `0.17.4`. Use the working Python 3.12 environment from [Run Zephyr on the PocketBeagle 2 MCU alongside Yocto Linux](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/). If creating a new environment on Ubuntu 22.04, install Python **3.12 and its matching venv package**; that Learning Path's example package line names Python 3.11 even though its subsequent commands invoke 3.12. + +Build the new application from the west workspace: + +```bash +cd "$HOME/pb2-zephyr-workspace" +export ZEPHYR_TOOLCHAIN_VARIANT=zephyr +west build -p always -b pocketbeagle_2/am6254/m4 \ + "$HOME/pb2-temperature-part3/firmware" -d build/pb2-external-temperature +file build/pb2-external-temperature/zephyr/zephyr.elf +``` + +On the ubuntu host, install the `arm-zephyr-eabi-readelf` tool via snap: + +```bash +sudo snap install zephyr-crosstool-arm +``` + +The output must be a 32-bit Arm ELF for the M4. Keep it unstripped. Use your installed SDK's `arm-zephyr-eabi-readelf` to inspect sections and load segments: + +```bash +arm-zephyr-eabi-readelf -S -l build/pb2-external-temperature/zephyr/zephyr.elf +``` + +Output should resemble: + +```output +There are 34 section headers, starting at offset 0x6b6b4: + +Section Headers: + [Nr] Name Type Addr Off Size ES Flg Lk Inf Al + [ 0] NULL 00000000 000000 000000 00 0 0 0 + [ 1] rom_start PROGBITS 00000000 000114 000140 00 AX 0 0 4 + [ 2] text PROGBITS 00000140 000254 002fcc 00 AX 0 0 4 + [ 3] .ARM.exidx ARM_EXIDX 0000310c 003220 000008 00 AL 2 0 4 + [ 4] initlevel PROGBITS 00003114 003228 000038 00 A 0 0 4 + [ 5] device_area PROGBITS 0000314c 003260 000080 00 A 0 0 4 + [ 6] gpio_driver_api_a PROGBITS 000031cc 0032e0 000024 00 A 0 0 4 + [ 7] mbox_driver_api_a PROGBITS 000031f0 003304 000014 00 A 0 0 4 + [ 8] uart_driver_api_a PROGBITS 00003204 003318 000014 00 A 0 0 4 + [ 9] tbss NOBITS 00003218 00332c 000004 00 WAT 0 0 4 + [10] rodata PROGBITS 00003218 00332c 000634 00 A 0 0 4 + [11] .ramfunc PROGBITS 00030000 003c04 000000 00 W 0 0 1 + [12] datas PROGBITS 00030000 003960 000068 00 WA 0 0 8 + [13] sw_isr_table PROGBITS 00030068 0039c8 000200 00 WA 0 0 4 + [14] device_states PROGBITS 00030268 003bc8 000008 00 WA 0 0 1 + [15] k_sem_area PROGBITS 00030270 003bd0 000010 00 WA 0 0 4 + [16] .resource_table PROGBITS 9cc00000 003be4 000010 00 A 0 0 4 + [17] .comment PROGBITS 00000000 003c04 000020 01 MS 0 0 1 + [18] .debug_aranges PROGBITS 00000000 003c28 000c60 00 0 0 8 + [19] .debug_info PROGBITS 00000000 004888 02498b 00 0 0 1 + [20] .debug_abbrev PROGBITS 00000000 029213 007b4c 00 0 0 1 + [21] .debug_line PROGBITS 00000000 030d5f 014509 00 0 0 1 + [22] .debug_frame PROGBITS 00000000 045268 001aec 00 0 0 4 + [23] .debug_str PROGBITS 00000000 046d54 005f20 01 MS 0 0 1 + [24] .debug_loc PROGBITS 00000000 04cc74 010ced 00 0 0 1 + [25] .debug_ranges PROGBITS 00000000 05d968 002fa0 00 0 0 8 + [26] .ARM.attributes ARM_ATTRIBUTES 00000000 060908 000032 00 0 0 1 + [27] .last_section PROGBITS 00003acc 003be0 000004 00 WA 0 0 4 + [28] bss NOBITS 00030280 003be8 000289 00 WA 0 0 8 + [29] noinit NOBITS 00030510 003be8 001140 00 WA 0 0 8 + [30] .resource_table PROGBITS 9cc00010 003bf4 000010 00 WA 0 0 4 + [31] .symtab SYMTAB 00000000 06093c 005440 10 32 551 4 + [32] .strtab STRTAB 00000000 065d7c 0057c9 00 0 0 1 + [33] .shstrtab STRTAB 00000000 06b545 00016f 00 0 0 1 +Key to Flags: + W (write), A (alloc), X (execute), M (merge), S (strings), I (info), + L (link order), O (extra OS processing required), G (group), T (TLS), + C (compressed), x (unknown), o (OS specific), E (exclude), + y (purecode), p (processor specific) + +Elf file type is EXEC (Executable file) +Entry point 0xf49 +There are 7 program headers, starting at offset 52 + +Program Headers: + Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align + EXIDX 0x003220 0x0000310c 0x0000310c 0x00008 0x00008 R 0x4 + LOAD 0x000114 0x00000000 0x00000000 0x0384c 0x0384c RWE 0x4 + LOAD 0x003960 0x00030000 0x0000384c 0x00280 0x00280 RW 0x8 + LOAD 0x003be0 0x00003acc 0x00003acc 0x00004 0x00004 RW 0x4 + LOAD 0x000000 0x00030280 0x00030280 0x00000 0x013d0 RW 0x8 + LOAD 0x003be4 0x9cc00000 0x9cc00000 0x00020 0x00020 RW 0x4 + TLS 0x00332c 0x00003218 0x00003218 0x00000 0x00004 R 0x4 + + Section to Segment mapping: + Segment Sections... + 00 .ARM.exidx + 01 rom_start text .ARM.exidx initlevel device_area gpio_driver_api_area mbox_driver_api_area uart_driver_api_area rodata + 02 datas sw_isr_table device_states k_sem_area + 03 .last_section + 04 bss noinit + 05 .resource_table .resource_table + 06 tbss + ``` + +The SDK tool may require its full path under `zephyr-sdk-0.17.4/arm-zephyr-eabi/bin/`. Confirm a single `.resource_table` at `0x9cc00000`, with size 16 bytes and inclusion in a loadable segment. The app supplies a version-one table with zero entries; UART is the telemetry transport, so no RPMsg device is advertised. Its custom linker fragment uses the board's existing `RSC_TABLE` region and does not enable OpenAMP's resource-table generator. Never deploy `zephyr.bin` in place of the ELF. + +## Inspect acquisition and telemetry + +First, lets ensure we have a good serial terminal program on our ubuntu host: + +```bash +sudo apt install gtkterm +``` + +Also, using the A 3.3 V logic USB-to-UART adapter from [Run Zephyr on the PocketBeagle 2 MCU alongside Yocto Linux](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/), connect the ground (GND - black) to the pocketbeagle2's P2.22 pin. Temporarily unplug the P2.07 pin (should be jumpered to P1.32 as defined previously... we'll return the jumper when done) and temporarily connect the adapter's RX (orange) to P2.07. Connect the adapter itself to a USB port on your Ubuntu host. + +Bring up gtkterm in the Ubuntu host desktop and connect to /dev/ACM0 (should be your pocketbeagle2) at 115200 baud. + +Next, in a SSH terminal on the Ubuntu host, copy over the zephyr.elf file that we built for the temperature sensor reader: + +```bash +cd "$HOME/pb2-zephyr-workspace" +scp build/pb2-external-temperature/zephyr/zephyr.elf root@192.168.7.2:/root/pb2-temperature.elf +ssh root@192.168.7.2 +``` + +In the just opened SSH shell into your pocketbeagle2, load the temperature sensor binary to temporarily run it: + +```bash +pb2-m4 load /root/pb2-temperature.elf +pb2-m4 status +``` + +You should see output similar to this: + +```output +device=/sys/class/remoteproc/remoteproc0 name=5000000.m4fss state=running firmware=pb2-zephyr-heartbeat.elf +``` + +This indicates that the temperature sensor zephyr instance is running. On the Ubuntu host gtkterm app, you should also see: + +```json +{"type":"pb2.external.temperature","schema":1,"seq":12,"uptime_ms":60320,"temperature_uC":25080000} +``` +This indicates that the temperature sensor is properly wired and the Zephyr temperature sensor reader app is working. + +Lets shut down the Zephyr app now: + +```bash +echo stop > /sys/class/remoteproc/remoteproc0/state +pb2-m4 status +``` + +You should see output similar to: + +```output +device=/sys/class/remoteproc/remoteproc0 name=5000000.m4fss state=offline firmware=pb2-zephyr-heartbeat.elf +``` + +This indicates that the Zephyr temperature sensor app has halted. + +Lastly, please disconnect the P2.07 lead from your USB UART adapter and replace the jumper lead out of P1.32 back into P2.07 on your pocketbeagle2. + +### What we now have operational + +`firmware/app.overlay` enables MCU GPIO0 using the pinned board's P2.09/P2.11 pinctrl groups. `src/main.c` implements software I2C with external pull-ups, bounded waits, acknowledgments, and repeated START. It probes `0x76` and `0x77`, requires exactly one chip ID `0x58`, resets that BMP280, waits for calibration loading, and reads `dig_T1`, `dig_T2`, and `dig_T3` from `0x88`–`0x8d`. + +Each sample triggers a forced measurement with temperature oversampling ×1 and pressure skipped (`ctrl_meas=0x21`). After completion, it reads the 20-bit temperature value at `0xfa`–`0xfc`. `src/bmp280_temperature.h` implements the [Bosch integer compensation](https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp280-ds001.pdf) with wider intermediates. The 0.01 °C result is scaled into the existing integer `temperature_uC` transport field; that field does not imply microdegree measurement precision. A successful UART frame looks like (this will be jumpered): + +```json +{"type":"pb2.external.temperature","schema":1,"seq":12,"uptime_ms":60320,"temperature_uC":25080000} +``` + +The BMP280 returns to sleep between samples, approximately five seconds apart. An identification, calibration, acquisition, or range failure emits a diagnostic and **no temperature frame**. The app retries configuration on the next interval. Sensor diagnostics and Zephyr's boot banner share the UART; the bridge validates and filters input. + +## Implement actual M4 shutdown + +The pinned [Linux driver](https://github.com/beagleboard/linux/blob/2eea568f445af33f3280261904bf1027b02512d8/drivers/remoteproc/ti_k3_common.c) sends mailbox `0xffffff14`, waits for acknowledgment `0xffffff15`, checks CPU WFI, and asserts reset. The mailbox wiring in the Yocto image uses FIFO 1 toward the M4 and FIFO 0 toward Linux. The new app registers directly with Zephyr's mailbox driver; it does not also enable an IPM/OpenAMP consumer of the same channel. + +On a shutdown message, the interrupt callback wakes the main thread. The main thread finishes acquisition, requests BMP280 sleep, releases SCL/SDA, sends the acknowledgment, disables interrupts, and enters WFI. It also replies to the driver's echo request. This is the firmware support that the heartbeat firmware in [Run Zephyr on the PocketBeagle 2 MCU alongside Yocto Linux](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/) deliberately omitted. + +## Understand the Linux firmware manager + +`components/firmware_manager.py` is the first component's foreground process: + +1. **Install:** validate the ELF header and stage it under `{work:path}/installed`. The M4 is not started during installation. +2. **Run:** locate exactly one M4 by the `5000000` device name, require `offline`, and hold an exclusive lock. Save an ownership record, copy the ELF to a unique SHA-256-derived filename under `/lib/firmware`, select it, and write `start` to remoteproc. +3. **Supervise:** keep running in the component unit and detect an unexpected remoteproc state. +4. **Terminate:** request `stop`, require `offline`, restore the previous firmware filename, and delete the owned ELF, staged install directory, and ownership record. + +Both phases request root privileges because the manager writes remoteproc sysfs and `/lib/firmware`. The firmware is loaded into M4 memory; it does not flash the separate MSPM0. The manager does not overwrite TI's default firmware file or use the `pb2-m4 load` helper from [Run Zephyr on the PocketBeagle 2 MCU alongside Yocto Linux](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/), which was designed for a one-shot heartbeat. + +On a normal restart, the manager stages the immutable artifact again if cleanup removed the installed copy. A stop failure preserves the ownership record and reports an error; it must never be hidden as successful cleanup. The later deployment page makes repeated stop/start a required hardware acceptance test. + +## What you have learned + +You have learned how to build the M4 ELF, check its resource table, and acquire BMP280 temperature using the sensor's factory calibration. You also understand how UART frames carry the readings and how the firmware manager and mailbox shutdown protocol allow Linux to start and stop the M4 application cleanly. diff --git a/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/images/pb2-temperature-flow.png b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/images/pb2-temperature-flow.png new file mode 100644 index 0000000000..a0c013d11f Binary files /dev/null and b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/images/pb2-temperature-flow.png differ diff --git a/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/images/pb2-temperature-flow.svg b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/images/pb2-temperature-flow.svg new file mode 100644 index 0000000000..162b6a87bf --- /dev/null +++ b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/images/pb2-temperature-flow.svg @@ -0,0 +1,132 @@ + + PocketBeagle 2: BMP280 temperature to AWS IoT Core + Greengrass downloads two components from S3 and runs them on Yocto Linux on Cortex-A53. Component 1 loads and stops the Zephyr firmware on Cortex-M4F through remoteproc. The BMP280 sends temperature over I2C to Zephyr, which sends calibrated JSON frames over a UART jumper to Component 2, the Linux bridge. The bridge publishes through Greengrass IPC and the runtime's MQTT connection to AWS IoT Core. + + + + + + + + + + + + + + PocketBeagle 2: external temperature to the cloud + Two Greengrass components connect Zephyr sensing with an AWS IoT Core JSON topic. + + + + AWS CLOUD + + + + + + Greengrass group deployment + Recipes + component versions + Target: PocketBeagleDevices + + + + + S3 artifacts + Zephyr ELF + scripts + Bridge + offline SDK wheels + + + + AWS IoT Core + MQTT / TLS + JSON temperature messages + + + + PocketBeagle 2 · AM6254 + + CORTEX-A53 · YOCTO LINUX + + + + + + + Deployment + artifact download + + + + + COMPONENT 1 + Firmware manager + Install ELF; supervise M4 + + + + Greengrass Lite + Install / run lifecycle + IPC + device MQTT connection + + + + + + COMPONENT 2 + Linux telemetry bridge + + install / run + + + + + CORTEX-M4F + Zephyr app + Read + compensate + BMP280 temperature + + + + + + + BMP280 + External sensor module + 3.3 V · I2C 0x76 / 0x77 + + + + I2C + + + UART jumper · JSON + MCU_UART0 → MAIN_UART0 + + IPC + + + Publish to IoT Core + + remoteproc + load / start / stop + + + + IoT Core topic: + ti/pocketbeagle2/temperature/external + Temperature telemetry + Greengrass deployment / lifecycle + M4 firmware control + diff --git a/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/intro.md b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/intro.md new file mode 100644 index 0000000000..bfc9f60a8f --- /dev/null +++ b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/intro.md @@ -0,0 +1,55 @@ +--- +title: "Goal: Combine Linux, Zephyr, and cloud deployment" +description: Follow external sensor telemetry from a Greengrass-managed M4 application through a Linux bridge to AWS IoT Core. +weight: 2 +layout: "learningpathall" +--- + +## Extend the first two parts + +Use the existing Yocto image from [Deploy a Hello World component to PocketBeagle 2 with Greengrass Lite](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/) on the Cortex-A53 and the Zephyr toolchain from [Run Zephyr on the PocketBeagle 2 MCU alongside Yocto Linux](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/) for the AM6254 Cortex-M4F. You will publish two custom components and deploy them to the existing `PocketBeagleDevices` thing group. Linux runs both Greengrass lifecycle supervisors; the first supervisor loads the actual Zephyr ELF onto the M4. + +| Component | S3 artifacts | Install lifecycle | Run lifecycle and normal removal | +| --- | --- | --- | --- | +| `com.arm.PocketBeagle2.ZephyrExternalTemperature` | Zephyr ELF and Python firmware manager | Validate and stage firmware | Load and supervise the M4; on termination, stop it through remoteproc, restore its prior firmware filename, and remove the installed copy | +| `com.arm.PocketBeagle2.ExternalTemperatureBridge` | Python bridge, shell lifecycle script, and pinned SDK wheels | Install dependencies offline in component work storage | Read UART frames and publish JSON through Greengrass IPC; on termination, close UART/IPC and remove the installed Python files | + +![PocketBeagle 2 temperature flow: the BMP280 sends readings over I2C to Zephyr on Cortex-M4F, the UART bridge on Cortex-A53 publishes through Greengrass Lite to AWS IoT Core, and Greengrass deploys and manages both components from S3 artifacts.](images/pb2-temperature-flow.png) + +Solid teal arrows show telemetry, dashed purple arrows show Greengrass deployment and lifecycle operations, and slate arrows show M4 firmware control. + +The destination topic is exactly `ti/pocketbeagle2/temperature/external`. The bridge adds the thing name and UTC receipt time. It reuses Greengrass's authenticated IoT connection; no device private key is copied into either component. + +## Identify the external sensor + +This path targets the supplied **Bosch BMP280 module over I2C**, powered at 3.3 V. The firmware accepts one BMP280 at `0x76` or `0x77`, verifies its chip ID, and applies its factory temperature calibration. The pressure channel is disabled for this temperature exercise. The [BMP280 data sheet](https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp280-ds001.pdf) defines the address straps and compensation procedure. Its temperature reading reflects the external module's sensor die and can include PCB heat; it is not a calibrated measurement of free-air temperature. + +## Resolve the lifecycle differences + +The heartbeat firmware from [Run Zephyr on the PocketBeagle 2 MCU alongside Yocto Linux](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/) cannot acknowledge a Linux stop request. This path supplies new firmware that handles the pinned driver's shutdown message and enters WFI before reset. Do not reuse the heartbeat ELF as the temperature artifact. + +[Nucleus Lite 2.6.0](https://github.com/aws-greengrass/aws-greengrass-lite/blob/v2.6.0/docs/RECIPE_SUPPORT_CHANGES.md) does not implement a recipe `shutdown` step. These recipes use `install` and foreground `run` processes. Their SIGTERM handling performs cleanup when Lite stops the component's systemd unit. Do not replace the foreground process with `nohup`, a detached daemon, or a separately enabled application service. + +Here, **unpublish from the device** means revise every deployment that requests the component so it is no longer selected. Deleting a cloud component version or canceling a deployment does not perform device removal. Installed application files are cleaned during normal stops, removals, and version changes; Greengrass retains ownership of its artifact cache and work-directory infrastructure. + +This is a hardware integration example. The firmware, deployment, and cleanup sections describe the board and cloud checks needed to verify the complete path. + +## Additional References + +| Area | Primary source | +| --- | --- | +| Existing image, provisioning, and M4 baseline | [Deploy a Hello World component to PocketBeagle 2 with Greengrass Lite](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/) and [Run Zephyr on the PocketBeagle 2 MCU alongside Yocto Linux](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/) | +| Box contents and header wiring | [PocketBeagle 2 quick start](https://docs.beagleboard.org/boards/pocketbeagle-2/02-quick-start.html) and [expansion tables](https://docs.beagleboard.org/boards/pocketbeagle-2/04-expansion.html) | +| Zephyr M4 target, memory, and mailbox | [v4.3.0 board common DTS](https://github.com/zephyrproject-rtos/zephyr/blob/v4.3.0/boards/beagle/pocketbeagle_2/pocketbeagle_2_m4-common.dtsi), [SoC DTS](https://github.com/zephyrproject-rtos/zephyr/blob/v4.3.0/dts/arm/ti/am62x_m4.dtsi), and [mailbox driver](https://github.com/zephyrproject-rtos/zephyr/blob/v4.3.0/drivers/mbox/mbox_ti_omap.c) | +| GPIO pin groups and open-drain limitation | [v4.3.0 pinctrl groups](https://github.com/zephyrproject-rtos/zephyr/blob/v4.3.0/boards/beagle/pocketbeagle_2/pocketbeagle_2_m4-pinctrl.dtsi) and [DaVinci GPIO driver](https://github.com/zephyrproject-rtos/zephyr/blob/v4.3.0/drivers/gpio/gpio_davinci.c) | +| Linux's enabled UART and aliases | [Pinned PocketBeagle 2 DTS](https://github.com/beagleboard/linux/blob/2eea568f445af33f3280261904bf1027b02512d8/arch/arm64/boot/dts/ti/k3-am62-pocketbeagle2.dts) | +| Shutdown message, acknowledgment, and WFI requirement | [Pinned remoteproc common driver](https://github.com/beagleboard/linux/blob/2eea568f445af33f3280261904bf1027b02512d8/drivers/remoteproc/ti_k3_common.c) and [mailbox constants](https://github.com/beagleboard/linux/blob/2eea568f445af33f3280261904bf1027b02512d8/drivers/remoteproc/omap_remoteproc.h) | +| BMP280 wiring, registers, and temperature compensation | [Bosch BMP280 data sheet, revision 1.26](https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp280-ds001.pdf) | +| Lite lifecycle and removal implementation | [v2.6.0 recipe subset](https://github.com/aws-greengrass/aws-greengrass-lite/blob/v2.6.0/docs/RECIPE_SUPPORT_CHANGES.md), [unit generator](https://github.com/aws-greengrass/aws-greengrass-lite/blob/v2.6.0/modules/recipe2unit/src/unit_file_generator.c), and [stale-component removal](https://github.com/aws-greengrass/aws-greengrass-lite/blob/v2.6.0/modules/ggdeploymentd/src/stale_component.c) | +| Artifact, IPC, and deployment contracts | [Recipe reference](https://docs.aws.amazon.com/greengrass/v2/developerguide/component-recipe-reference.html), [device role / S3 access](https://docs.aws.amazon.com/greengrass/v2/developerguide/device-service-role.html), [MQTT IPC](https://docs.aws.amazon.com/greengrass/v2/developerguide/ipc-iot-core-mqtt.html), and [deployment creation](https://docs.aws.amazon.com/greengrass/v2/developerguide/create-deployments.html) | +| Pinned Python SDK API | [v1.26.0 IPC client](https://github.com/aws/aws-iot-device-sdk-python-v2/blob/v1.26.0/awsiot/greengrasscoreipc/clientv2.py) | + +## What you have learned + +You have learned how the two Greengrass components connect BMP280 sensing on the Cortex-M4F to AWS IoT Core through a Linux bridge on the Cortex-A53. You also understand why the firmware needs a shutdown handshake and how foreground lifecycle processes handle normal component removal in Nucleus Lite. + diff --git a/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/pb2-temperature-part3.zip b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/pb2-temperature-part3.zip new file mode 100644 index 0000000000..77587a856a Binary files /dev/null and b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/pb2-temperature-part3.zip differ diff --git a/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/prepare.md b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/prepare.md new file mode 100644 index 0000000000..2875fe7a15 --- /dev/null +++ b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/prepare.md @@ -0,0 +1,114 @@ +--- +title: "Prepare the board and wire the external sensor" +description: Start with an offline M4, reserve the MCU GPIOs, and connect external temperature sensing and an on-board UART bridge. +weight: 3 +layout: "learningpathall" +--- + +## Return the M4 to an offline state + +Save work, shut down Linux, disconnect power, and power up again to end the heartbeat firmware from [Run Zephyr on the PocketBeagle 2 MCU alongside Yocto Linux](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/). Do not issue `stop` against that older firmware: it has no shutdown acknowledgment. On the board, check: + +```bash +uname -m +pb2-m4 status +python3 -c 'import sys; print(sys.version)' +python3 -m pip --version +systemctl status --with-dependencies greengrass-lite.target +``` + +Expect `aarch64`, Python 3.12 from the Scarthgap image, healthy Greengrass services, and the M4 named `5000000.m4fss` in state `offline`. If it is attached or running after a power cycle, resolve bootloader ownership as described in [Run Zephyr on the PocketBeagle 2 MCU alongside Yocto Linux](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/) before continuing. No service should automatically load the heartbeat. + +## Check exclusive peripheral ownership + +This example uses MCU GPIO0 pins 16 and 15 for software I2C, and MCU_UART0 for telemetry. The Yocto image already disables Linux's MCU_UART0 and enables MAIN_UART0. The Zephyr GPIO driver initializes the entire MCU GPIO0 bank to inputs, so this application requires exclusive ownership of that bank. Do not use a cape or Linux GPIO consumer that controls it or any of the paired header pads. + +On the board, inspect line consumers and the UART mapping: + +```bash +gpioinfo +readlink -f /sys/class/tty/ttyS7/device +cat /proc/cmdline +systemctl status serial-getty@ttyS7.service +``` + +In the pinned board device tree, `serial7` is MAIN_UART0 at `0x02800000`; the device path for `ttyS7` must identify `2800000.serial`. It must not be a kernel console or a login terminal. If a serial getty is enabled on this dedicated port, disable it with `systemctl disable --now serial-getty@ttyS7.service`. Leave the Linux debug console on MAIN_UART6 available. If your numbering differs, identify MAIN_UART0 by its controller address and use that device in the bridge deployment configuration. + +Check pinctrl ownership where available: + +```bash +mountpoint -q /sys/kernel/debug || mount -t debugfs debugfs /sys/kernel/debug +grep -E '1d0|1d4|0408403c|04084040' /sys/kernel/debug/pinctrl/*/pinmux-pins +``` + +The paired MAIN pads on P2.09/P2.11 (`GPIO1_22/23`, offsets `0x1d0/0x1d4`) must remain unused inputs, and MCU pads `0x04084040/0x0408403c` belong to Zephyr. An active pinmux or GPIO consumer on these pads is a conflict to resolve before loading firmware. Debug output formats differ; do not treat an empty grep as proof of ownership. Use the running device tree, `gpioinfo`, and your cape configuration together. This path does not take over the PMIC I2C bus, the MSPM0 ADC/EEPROM, or Linux's header I2C2. + +## Wire while power is disconnected + +Use the [PocketBeagle 2 header tables](https://docs.beagleboard.org/boards/pocketbeagle-2/04-expansion.html) to confirm orientation. The same physical header pin can connect two processor pads; both sides must obey the ownership rules above. + +| Connection | PocketBeagle 2 pin | Notes | +| --- | --- | --- | +| BMP280 VCC / 3V3 | P1.14, 3.3 V | Use the module's documented 3.3 V power input | +| BMP280 GND | P1.16, GND | Common reference | +| BMP280 SCL / SCK | P2.09 | MCU_GPIO0_16; software I2C clock | +| BMP280 SDA / SDI | P2.11 | MCU_GPIO0_15; software I2C data | +| BMP280 CS / CSB, if exposed | P1.14, 3.3 V | Selects I2C; keep high from power-up | +| BMP280 SDO, if exposed | P1.16, GND | Selects `0x76`; 3.3 V selects `0x77` | +| Telemetry jumper | P2.07 to P1.32 | MCU_UART0 TX to MAIN_UART0 RX | + +Four-pin I2C modules normally strap CSB and the address internally; follow the module's labels and schematic. The firmware checks both legal addresses and requires exactly one BMP280. It rejects a BME280 chip ID. Confirm the detected address in the MCU UART diagnostic after deployment. The [Bosch connection diagram](https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bmp280-ds001.pdf) documents the underlying sensor pins; breakout connector order varies. + +Fit pull-ups from SCL and SDA to **3.3 V**, typically 4.7 kΩ, unless the breakout already provides suitable pull-ups. Keep wires short. The software releases a line by making it an input and drives it only low, because the pinned GPIO driver rejects hardware open-drain mode. No Linux `i2cdetect` scan can find this private software bus. + +Do not connect a 5 V pull-up, a UART adapter's power lead, or two UART transmitters together. P1.30, the Linux UART TX, is unused. You may retain the USB UART adapter from [Run Zephyr on the PocketBeagle 2 MCU alongside Yocto Linux](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/) as an output-only monitor on P2.07 and GND, with its TX lead disconnected. The bridge runs on PocketBeagle 2 and needs no USB UART adapter. + +Power up and rerun `pb2-m4 status`: + +```bash +pb2-m4 status +``` + +Output should resemble: + +```output +device=/sys/class/remoteproc/remoteproc0 name=5000000.m4fss state=offline firmware=am62-mcu-m4f0_0-fw +``` + +Leave the M4 offline until Greengrass deploys the new firmware. + +Since the pocketbeagle2 has been rebooted, open a SSH shell into the pocketbeagle2 from the ubuntu host and ensure that name resolution is enabled: + +```bash +echo "nameserver 8.8.8.8" >> /etc/resolv.conf +``` + +Confirm by pinging `google.com` from that shell: + +```bash +ping google.com +``` + +Output should resemble: + +```output +PING google.com (172.217.72.102) 56(84) bytes of data. +64 bytes from lcdfwna-in-f102.1e100.net (172.217.72.102): icmp_seq=1 ttl=106 time=26.3 ms +64 bytes from lcdfwna-in-f102.1e100.net (172.217.72.102): icmp_seq=2 ttl=106 time=23.8 ms +``` + +## Prepare the source bundle + +Download [the source bundle](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/pb2-temperature-part3.zip) to the Ubuntu host and extract it: + +```bash +mkdir -p "$HOME/pb2-temperature-part3" +unzip pb2-temperature-part3.zip -d "$HOME/pb2-temperature-part3" +cd "$HOME/pb2-temperature-part3" +``` + +When working from this sandbox checkout, copy the contents of this path's `bundle/` directory to that workspace instead. The workspace contains `firmware/`, `components/`, and `tools/`; it contains no credentials. + +## What you have learned + +You have learned how to prepare an offline M4, check peripheral ownership, and wire the BMP280 and UART jumper without conflicting with Linux. You can now identify the sensor's I2C mode and address connections, select the Linux UART for the bridge, and prepare the source workspace for building the firmware. diff --git a/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/publish.md b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/publish.md new file mode 100644 index 0000000000..81504df789 --- /dev/null +++ b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-gglite-zephyr-combined-part3/publish.md @@ -0,0 +1,169 @@ +--- +title: "Upload S3 artifacts and publish both components" +description: Grant artifact downloads and topic publishing, generate Lite-compatible recipes, and register immutable component versions. +weight: 6 +layout: "learningpathall" +--- + +## Confirm AWS CLI versioning + +On your Ubuntu host, lets first confirm that the aws cli version used is new enough: + +```bash +aws --version +``` + +If the version reported is earlier than 2.17.34, please update to the latest version: + +```bash +curl -fsSL https://awscli.amazonaws.com/v2/install.sh | bash +export PATH=${HOME}/.local/bin:${PATH} +which aws +aws --version +``` + +Your aws cli version should now be greater than 2.17.34. + +## Reuse the AWS identity + +Run this page on the Ubuntu administrative workstation, in the source workspace. Retain the actual Region and existing device role alias from [Deploy a Hello World component to PocketBeagle 2 with Greengrass Lite](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/): + +```bash +cd "$HOME/pb2-temperature-part3" +export AWS_REGION=us-east-1 +export THING_NAME=MyPocketBeagle2 +export THING_GROUP=PocketBeagleDevices +export ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text) +export IOT_ROLE_ALIAS=YOUR_EXISTING_ROLE_ALIAS +export YOUR_UNIQUE_SUFFIX=MySuffix +export ROLE_ARN=$(aws iot describe-role-alias --role-alias "$IOT_ROLE_ALIAS" \ + --query roleAliasDescription.roleArn --output text) +export ROLE_NAME=${ROLE_ARN##*/} +export ARTIFACT_BUCKET="pb2-temperature-${ACCOUNT_ID}-${AWS_REGION}-${YOUR_UNIQUE_SUFFIX}" +export ARTIFACT_PREFIX=pb2-temperature +``` + +Change `YOUR_EXISTING_ROLE_ALIAS` with your IoTCore Role alias used. Also customize `YOUR_UNIQUE_SUFFIX` as needed. + +Replace both uppercase placeholders, including the bucket suffix, before running commands. Use lowercase letters, digits, and hyphens in the bucket name. These commands assume the commercial AWS partition. Keep administrative credentials on the workstation. + +## Create a private artifact bucket + +Choose a globally unique bucket in the deployment Region: + +```bash +if [ "$AWS_REGION" = us-east-1 ]; then + aws s3api create-bucket --bucket "$ARTIFACT_BUCKET" --region "$AWS_REGION" +else + aws s3api create-bucket --bucket "$ARTIFACT_BUCKET" --region "$AWS_REGION" \ + --create-bucket-configuration "LocationConstraint=$AWS_REGION" +fi +aws s3api put-public-access-block --bucket "$ARTIFACT_BUCKET" \ + --public-access-block-configuration \ + BlockPublicAcls=true,IgnorePublicAcls=true,BlockPublicPolicy=true,RestrictPublicBuckets=true +aws s3api put-bucket-encryption --bucket "$ARTIFACT_BUCKET" \ + --server-side-encryption-configuration \ + '{"Rules":[{"ApplyServerSideEncryptionByDefault":{"SSEAlgorithm":"AES256"}}]}' +``` + +The example uses S3-managed encryption and a bucket in the same account. If using an existing bucket with customer-managed KMS encryption, its KMS and bucket policies must also authorize the device role. + +## Grant artifact downloads to the existing device role + +The inline Hello World component in [Deploy a Hello World component to PocketBeagle 2 with Greengrass Lite](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/) needed no S3 permission. Add the following narrowly scoped policy to its **existing token-exchange IAM role**, following [AWS's artifact-access guidance](https://docs.aws.amazon.com/greengrass/v2/developerguide/device-service-role.html#device-service-role-access-s3-bucket): + +```bash +python3 - <<'PYTHON' +import json, os +from pathlib import Path +bucket, prefix = os.environ['ARTIFACT_BUCKET'], os.environ['ARTIFACT_PREFIX'] +policy = {'Version': '2012-10-17', 'Statement': [ + {'Effect': 'Allow', 'Action': 's3:GetObject', + 'Resource': f'arn:aws:s3:::{bucket}/{prefix}/*'}, + {'Effect': 'Allow', 'Action': 's3:GetBucketLocation', + 'Resource': f'arn:aws:s3:::{bucket}'} +]} +Path('artifact-access.json').write_text(json.dumps(policy, indent=2) + '\n') +PYTHON +aws iam put-role-policy --role-name "$ROLE_NAME" \ + --policy-name PB2ExternalTemperatureArtifacts \ + --policy-document file://artifact-access.json +``` + +Use a fresh inline-policy name if that name is already used for another purpose. Preserve the role trust, permissions boundary, role alias, and existing policies. A boundary or explicit deny must also permit these reads. The role does not need S3 write access; the workstation identity performs uploads and component registration. + +## Grant the device certificate the exact MQTT topic + +There are three separate authorization checks: device-role S3 reads, component IPC publish authorization, and certificate IoT publish authorization. The recipe generator supplies the IPC permission. Add a supplemental certificate policy for the topic: + +```bash +python3 - <<'PYTHON' +import json, os +from pathlib import Path +arn = ('arn:aws:iot:' + os.environ['AWS_REGION'] + ':' + os.environ['ACCOUNT_ID'] + + ':topic/ti/pocketbeagle2/temperature/external') +Path('temperature-publish.json').write_text(json.dumps({ + 'Version': '2012-10-17', 'Statement': [ + {'Effect': 'Allow', 'Action': 'iot:Publish', 'Resource': arn} + ] +}, indent=2) + '\n') +PYTHON +aws iot list-thing-principals --thing-name "$THING_NAME" +``` + +Set `CERT_ARN` to the active certificate actually used by this board, from the returned principals. Then: + +```bash +export CERT_ARN=YOUR_DEVICE_CERTIFICATE_ARN +aws iot create-policy --policy-name PB2ExternalTemperaturePublish \ + --policy-document file://temperature-publish.json +aws iot attach-policy --policy-name PB2ExternalTemperaturePublish --target "$CERT_ARN" +``` + +If that supplemental policy already exists, inspect its default version and reuse it only if its contents match. Leave the original connection-kit policy attached. The device still needs its existing connection, deployment subscription, and role-alias permissions. Adding `iot:Publish` to the IAM role alone does not grant certificate MQTT publishing. + +## Generate both complete recipes + +```bash +python3 tools/make_recipes.py --bucket "$ARTIFACT_BUCKET" --prefix "$ARTIFACT_PREFIX" +python3 -m json.tool recipes/com.arm.PocketBeagle2.ZephyrExternalTemperature.json +python3 -m json.tool recipes/com.arm.PocketBeagle2.ExternalTemperatureBridge.json +``` + +The generator enumerates the actual staged files, including both wheel filenames, and creates version `1.0.0` of exactly two generic components. Both manifests select `linux`, `aarch64`, and `aws_nucleus_lite`. Every artifact has an explicit private `s3://` URI. There is no dependency on the Java nucleus, Java CLI component, or a third custom service. + +The firmware lifecycle is equivalent to: + +```output +{ + "install": { + "RequiresPrivilege": true, + "Script": "exec python3 -u \"{artifacts:path}/firmware_manager.py\" install --artifact \"{artifacts:path}/zephyr.elf\" --work \"{work:path}\"" + }, + "run": { + "RequiresPrivilege": true, + "Script": "exec python3 -u \"{artifacts:path}/firmware_manager.py\" run --artifact \"{artifacts:path}/zephyr.elf\" --work \"{work:path}\"" + } +} +``` + +The bridge lifecycle invokes its S3-delivered shell script with `install` or `run`, its artifact/work paths, the configured serial device, and `{iot:thingName}`. Its default configuration grants only `aws.greengrass#PublishToIoTCore` on `ti/pocketbeagle2/temperature/external` under `aws.greengrass.ipc.mqttproxy`. Review the generated full JSON before publishing. These fields follow the [recipe reference](https://docs.aws.amazon.com/greengrass/v2/developerguide/component-recipe-reference.html) and the pinned Lite subset; an unsupported `shutdown` field is intentionally absent. + +## Upload first, then register the versions + +```bash +python3 tools/upload.py --bucket "$ARTIFACT_BUCKET" --prefix "$ARTIFACT_PREFIX" +aws s3 ls "s3://$ARTIFACT_BUCKET/$ARTIFACT_PREFIX/" --recursive +aws greengrassv2 create-component-version \ + --inline-recipe fileb://recipes/com.arm.PocketBeagle2.ZephyrExternalTemperature.json +aws greengrassv2 create-component-version \ + --inline-recipe fileb://recipes/com.arm.PocketBeagle2.ExternalTemperatureBridge.json +``` + +Keep the returned version ARNs. The upload script uses [S3 conditional writes](https://docs.aws.amazon.com/cli/latest/reference/s3api/put-object.html) to refuse an existing key. If a partial upload is interrupted, compare existing objects with your staged files and upload only the missing ones; do not delete published artifacts merely to rerun the helper. Use a recent AWS CLI v2 if `--if-none-match` is unavailable. + +Never overwrite S3 objects behind a published component version: registration records artifact integrity information, and devices may already cache the old bytes. For an update, change the version in `make_recipes.py` and `stage.sh`, use new versioned S3 keys, restage into a clean staging tree, regenerate, upload, and publish a new component version. The old version and its artifacts remain available for rollback. + +## What you have learned + +You have learned how to authorize S3 artifact downloads, component IPC publishing, and certificate-based MQTT publishing as separate permissions. You can now generate both Lite-compatible recipes, upload their artifacts, and publish immutable component versions while preserving the board's existing AWS identity. diff --git a/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/_index.md b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/_index.md new file mode 100644 index 0000000000..307b736f7b --- /dev/null +++ b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/_index.md @@ -0,0 +1,73 @@ +--- +title: "Deploy a Hello World component to PocketBeagle 2 with Greengrass Lite" +description: Build a PocketBeagle 2 Yocto image, provision AWS IoT Greengrass nucleus lite, and deploy a Hello World component through an AWS IoT thing group. + +draft: true +cascade: + draft: true + +minutes_to_complete: 120 + +who_is_this_for: Embedded Linux developers connecting an Arm-based PocketBeagle 2 to AWS IoT Greengrass. + +learning_objectives: + - Build and boot the PocketBeagle 2 Yocto development image + - Provision a unique device identity for Greengrass nucleus lite + - Publish a simple Hello World component to AWS IoT Greengrass + - Deploy the component through a thing group and verify execution on the board + +prerequisites: + - A PocketBeagle 2, a 32 GB or larger microSD card, a card reader, and a USB-C data cable + - An x86_64 Ubuntu 22.04 or 24.04 build host with 16–32 GB RAM and 250–400 GB free disk on a Linux filesystem + - An AWS account with permission to manage IoT resources and Greengrass deployments, plus an approved token-exchange IAM role or permission to create one + - AWS CLI v2 configured on an administrative workstation and Python 3 for validating JSON and generating deployment documents + - Internet access for the build host and board, using host Internet sharing or a supported USB Ethernet adapter and host cape + +author: Doug Anson +generate_summary_faq: true +rerun_summary: false +rerun_faqs: false +skilllevels: Advanced +subjects: Embedded Linux + +armips: + - Cortex-A +operatingsystems: + - Linux + +tools_software_languages: + - Yocto Project + - AWS IoT Greengrass + - Python + +further_reading: + - resource: + title: Run Zephyr on the PocketBeagle 2 MCU alongside Yocto Linux + link: /learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/ + type: learningpath + - resource: + title: PocketBeagle 2 quick start + link: https://docs.beagleboard.org/boards/pocketbeagle-2/02-quick-start.html + type: documentation + - resource: + title: Yocto Scarthgap host requirements + link: https://docs.yoctoproject.org/scarthgap/ref-manual/system-requirements.html + type: documentation + - resource: + title: Nucleus Lite 2.6.0 provisioning + link: https://github.com/aws-greengrass/aws-greengrass-lite/blob/v2.6.0/docs/Provisioning.md + type: documentation + - resource: + title: Greengrass component recipe reference + link: https://docs.aws.amazon.com/greengrass/v2/developerguide/component-recipe-reference.html + type: documentation + - resource: + title: Create Greengrass deployments + link: https://docs.aws.amazon.com/greengrass/v2/developerguide/create-deployments.html + type: documentation + +### FIXED, DO NOT MODIFY +weight: 1 +layout: "learningpathall" +learning_path_main_page: "yes" +--- diff --git a/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/_next-steps.md b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/_next-steps.md new file mode 100644 index 0000000000..c3db0de5a2 --- /dev/null +++ b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/_next-steps.md @@ -0,0 +1,8 @@ +--- +# ================================================================================ +# FIXED, DO NOT MODIFY THIS FILE +# ================================================================================ +weight: 21 # Set to always be larger than the content in this path to be at the end of the navigation. +title: "Next Steps" # Always the same, html page title. +layout: "learningpathall" # All files under learning paths have this same wrapper for Hugo processing. +--- diff --git a/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/build.md b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/build.md new file mode 100644 index 0000000000..8a55953036 --- /dev/null +++ b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/build.md @@ -0,0 +1,72 @@ +--- +title: "Build the PocketBeagle 2 Yocto image" +description: Build a PocketBeagle 2 Yocto image with the supplied script and locate the image and optional SDK artifacts. +weight: 3 +layout: "learningpathall" +--- + +## Prepare the Linux build host + +Run this page's commands as a normal user on an x86_64 Linux host. On macOS, use a remote Linux host or x86_64 Linux VM with files stored on its Linux filesystem. Do not build in a macOS shared folder. + +Copy the downloaded archive to the Linux host. Extract it to a fixed location without spaces, then inspect the script's options: + +```bash +mkdir -p "$HOME/ti" +unzip pocketbeagle2-scarthgap-build.zip -d "$HOME/ti" +cd "$HOME/ti/pocketbeagle2" +chmod +x build-pocketbeagle2.sh +./build-pocketbeagle2.sh --help +``` + +The script requires its bundled layer. Copying only the shell script causes the layer check to fail. + +## Configure and validate dependencies + +Install host dependencies and generate the image and SDK task graphs before compiling: + +```bash +WORKDIR="$HOME/yocto-pocketbeagle2" JOBS=4 \ + ./build-pocketbeagle2.sh --install-deps --configure-only +``` + +`--install-deps` uses `sudo apt-get` and enables `en_US.UTF-8`; BitBake runs as your normal user. `WORKDIR` selects a dedicated build tree and `JOBS` controls parallel tasks and make jobs. The default is four jobs. Use the same `WORKDIR` on subsequent runs to reuse downloads and shared state. + +The script checks user and network namespaces before fetching sources. If Ubuntu 24.04 blocks them, read the bundled `ubuntu24-usernamespaces.txt` and have the build-host administrator apply a suitable configuration. Do not run BitBake as root to bypass this check. + +A successful configure-only run reports that parsing and requested task graphs passed. It does not prove compilation, image assembly, or boot. Inspect the generated revisions and graphs: + +```bash +cat "$HOME/yocto-pocketbeagle2/sources.lock" +ls "$HOME/yocto-pocketbeagle2/validation/image" +ls "$HOME/yocto-pocketbeagle2/validation/sdk" +``` + +## Build the image + +For this Hello World exercise, skip the optional cross-compilation SDK: + +```bash +WORKDIR="$HOME/yocto-pocketbeagle2" JOBS=4 \ + ./build-pocketbeagle2.sh --no-sdk +``` + +The script packages the board integration recipes, builds LTTng modules and Weston, and builds `pocketbeagle2-dev-image`. The image includes Nucleus Lite, Python, development tools, SSH, and USB Ethernet support. Weston is included but is not needed for Hello World. + +To support [Run Zephyr on the PocketBeagle 2 MCU alongside Yocto Linux](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/), the image also includes `pb2-m4`, the M4 remoteproc driver, and the AM6254 reserved-memory settings. + +Omit `--no-sdk` to build both image and SDK. The script regenerates `local.conf` and `bblayers.conf`. Store persistent overrides in `$WORKDIR/build/conf/pocketbeagle2-extra.conf`; keep the bundle at its original location because `bblayers.conf` references it. + +Locate the compressed image and matching block map: + +```bash +ls -lh "$HOME/yocto-pocketbeagle2/build/deploy-ti/images/pocketbeagle2/"*.wic* +``` + +Select `pocketbeagle2-dev-image-pocketbeagle2*.wic.xz` and its matching `.wic.bmap` from the same build. SDK installers, when requested, are under `$WORKDIR/build/deploy-ti/sdk/`. These are TI deployment paths rather than the usual `tmp/deploy` paths. + +If a build fails, fix the reported error and rerun with the same work directory. The script refuses to overwrite edits in upstream layer checkouts and rejects concurrent builds in one work directory. + +## What you have accomplished + +You have a built microSD image and a record of its upstream layer revisions. Next, write the image to a card and verify the board's network connection. diff --git a/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/component.md b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/component.md new file mode 100644 index 0000000000..8eb7f2c563 --- /dev/null +++ b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/component.md @@ -0,0 +1,71 @@ +--- +title: "Create and publish the Hello World component" +description: Publish an inline Hello World recipe for deployment to PocketBeagle 2 with AWS IoT Greengrass Lite. +weight: 6 +layout: "learningpathall" +--- + +## Prepare the component workspace + +Run this page's commands on the Ubuntu host, keeping the AWS account, Region, and variables from the provisioning page. Create a workspace outside the device-credential directory: + +```bash +mkdir -p "$HOME/pb2-hello-world" +cd "$HOME/pb2-hello-world" +``` + +## Create the component recipe + +Save the following JSON as `recipe.json` in the workspace. The component defines its application directly in the manifest's `run` lifecycle. It prints `Hello from Greengrass Lite on PocketBeagle2!` every 60 seconds. The empty `Artifacts` list means you do not need an S3 bucket, a separate shell script, or artifact download permissions. + +```json +{ + "RecipeFormatVersion": "2020-01-25", + "ComponentName": "com.arm.HelloGreengrassLiteWorld", + "ComponentVersion": "1.0.1", + "ComponentType": "aws.greengrass.generic", + "ComponentDescription": "A simple test component for Greengrass Lite", + "ComponentPublisher": "Arm", + "Manifests": [ + { + "Platform": { + "os": "linux", + "runtime": "aws_nucleus_lite", + "architecture": "aarch64" + }, + "Lifecycle": { + "run": "while true; do echo 'Hello from Greengrass Lite on PocketBeagle2!'; sleep 60; done" + }, + "Artifacts": [] + } + ], + "Lifecycle": {} +} +``` + +The platform selector targets Linux on `aarch64` with the `aws_nucleus_lite` runtime. The recipe has no dependency on the Java nucleus or its CLI component. + +Validate the JSON before publishing: + +```bash +python3 -m json.tool recipe.json +``` + +The command displays the formatted recipe. If it reports a parsing error, correct the JSON before continuing. + +## Publish the component + +Register version `1.0.1` as a private component in your account, then list its published versions: + +```bash +aws greengrassv2 create-component-version \ + --inline-recipe fileb://recipe.json +aws greengrassv2 list-component-versions \ + --arn "arn:aws:greengrass:$AWS_REGION:$(aws sts get-caller-identity --query Account --output text):components:com.arm.HelloGreengrassLiteWorld" +``` + +Confirm version `1.0.1` appears under **Greengrass devices > Components > My components** for `com.arm.HelloGreengrassLiteWorld`. Component versions are immutable: publish a new version when you change the recipe. If this version already exists, use the existing version only if its recipe matches this example. + +## What you have accomplished + +Your account contains a versioned Hello World component with its application defined in the recipe. Next, deploy it to the dedicated thing group and verify its output on PocketBeagle 2. diff --git a/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/deployment.md b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/deployment.md new file mode 100644 index 0000000000..f305b3e465 --- /dev/null +++ b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/deployment.md @@ -0,0 +1,137 @@ +--- +title: "Deploy to the thing group and verify Hello World" +description: Deploy the Hello World component to PocketBeagle 2 through an AWS IoT thing group and verify execution in the device journal. +weight: 7 +layout: "learningpathall" +--- + +## Deploy to the group + +On the Ubuntu host, confirm group membership and retrieve the group's ARN: + +```bash +aws iot list-things-in-thing-group --thing-group-name "$THING_GROUP" +export GROUP_ARN=$(aws iot describe-thing-group \ + --thing-group-name "$THING_GROUP" --query thingGroupArn --output text) +aws greengrassv2 list-deployments --target-arn "$GROUP_ARN" +``` + +The member list must include `MyPocketBeagle2`. This tutorial expects a dedicated group with no previous deployment. If a deployment already exists, inspect it before continuing. A new deployment to the same target replaces that target's previous component selection, so retain any components that you still need. See [Create deployments](https://docs.aws.amazon.com/greengrass/v2/developerguide/create-deployments.html). + +Create a deployment document targeting the group ARN, rather than the individual thing ARN: + +```bash +python3 - <<'PYTHON' +import json +import os +from pathlib import Path + +request = { + "targetArn": os.environ["GROUP_ARN"], + "deploymentName": "PocketBeagle2 Hello World group deployment", + "components": { + "com.arm.HelloGreengrassLiteWorld": { + "componentVersion": "1.0.1" + } + } +} +Path("deployment.json").write_text(json.dumps(request, indent=2) + "\n") +PYTHON +export DEPLOYMENT_ID=$(aws greengrassv2 create-deployment \ + --cli-input-json file://deployment.json --query deploymentId --output text) +printf '%s\n' "$DEPLOYMENT_ID" +``` + +Keep this deployment ID. The deployment intentionally contains only the custom component; it uses the Lite runtime already installed in the image. + +You can perform the same operation in the console by choosing **Greengrass devices > Deployments > Create**, selecting **Thing group**, choosing `PocketBeagle2HelloWorld`, and adding version `1.0.1` of `com.arm.HelloGreengrassLiteWorld`. Review the target and component version before choosing **Deploy**. Use either the CLI or console workflow once. + +## Check delivery to this device + +Inspect both the deployment and its effective status on the board: + +```bash +aws greengrassv2 get-deployment --deployment-id "$DEPLOYMENT_ID" +aws greengrassv2 list-effective-deployments \ + --core-device-thing-name "$THING_NAME" +aws greengrassv2 list-installed-components \ + --core-device-thing-name "$THING_NAME" +``` + +The group deployment can remain `ACTIVE` to serve group members. That status alone does not prove installation on a particular board. Wait for the matching deployment ID to report `SUCCEEDED` in the effective deployments response, and for component version `1.0.1` to appear as running in the installed-components response. Cloud status updates can lag behind device execution. + +## Observe the application on PocketBeagle 2 + +On the pocketbeagle2 board via SSH shell, inspect deployment logs and find the component's systemd service: + +```bash +journalctl -u ggl.core.ggdeploymentd.service -b --no-pager -n 100 +systemctl list-units --all --type=service | grep -F HelloGreengrassLiteWorld | awk '{print $1}' +export COMPONENT_UNIT=`systemctl list-units --all --type=service | grep -F HelloGreengrassLiteWorld | awk '{print $1}'` +``` + +Use the exact unit name reported by `systemctl` to inspect the component. Replace `COMPONENT_UNIT` with that name: + +```bash +systemctl status ${COMPONENT_UNIT} +``` + +You should see that the service is running normally. Next, type: + +```bash +journalctl -u ${COMPONENT_UNIT} -b -f +``` + +For this command (which will be ongoing...) the output should contain this (with additional ones added every 60 seconds): + +```output +Hello from Greengrass Lite on PocketBeagle2! +Hello from Greengrass Lite on PocketBeagle2! +``` + +The journal adds timestamps and service prefixes. Observe at least two messages about 60 seconds apart, then press **Ctrl+C** to stop following the journal. The component continues running. + +Successful completion requires all three observations: the thing belongs to the target group, this deployment succeeds on the device, and the application's repeated message appears in the device journal. This proves a cloud group deployment reached the runtime and executed the inline lifecycle command. + +## Troubleshoot a failed deployment + +| Symptom | What to check | +| --- | --- | +| No effective deployment | Same account and Region, correct group ARN, thing membership, and IoT connectivity | +| Authorization or token-exchange failure | Active certificate, attached IoT policy, role alias, and IAM role trust | +| No matching manifest | `uname -m` is `aarch64`, Linux is running, and the manifest selects `aws_nucleus_lite` | +| Component exits immediately | Component unit journal and the inline `run` lifecycle command | +| Edited YAML has no effect | Existing configuration database takes precedence; use supported configuration updates rather than resetting an established device | + +For service-level faults, inspect `systemctl --failed` and the `ggl.core.iotcored.service` and `ggl.core.ggdeploymentd.service` journals. Correct the reported cause before retrying; do not create another identity to work around an authorization error. + +## Optional: remove the test application + +If you are continuing to [Run Zephyr on the PocketBeagle 2 MCU alongside Yocto Linux](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/), keep the board provisioned and Greengrass running. You can keep the Hello World component deployed for the later verification. + +To stop the application through the same group target, revise the group's deployment to omit the component. This is accomplished on the Ubuntu host: + +```bash +python3 - <<'PYTHON' +import json +import os +from pathlib import Path + +Path("update-deployment.json").write_text(json.dumps({ + "targetArn": os.environ["GROUP_ARN"], + "deploymentName": "Remove PocketBeagle2 Hello World test", + "components": {} +}, indent=2) + "\n") +PYTHON +export DEPLOYMENT_ID=$(aws greengrassv2 create-deployment \ + --cli-input-json file://update-deployment.json --query deploymentId --output text) +printf '%s\n' "$DEPLOYMENT_ID" +``` + +Wait for this revision to succeed and confirm the application stops. If you added other components to the group deployment, retain them in the component selection. Canceling a deployment is not an uninstall operation. + +## What you have accomplished + +You built a Yocto image for an Arm board, provisioned its Greengrass identity, published a custom component, and verified execution after a thing group deployment. To extend the exercise, replace the message loop with a sensor application, publish a new component version, and revise the group deployment to select it. + +Continue with [Run Zephyr on the PocketBeagle 2 MCU alongside Yocto Linux](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/) to add a real-time application alongside Linux. diff --git a/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/intro.md b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/intro.md new file mode 100644 index 0000000000..53226f5650 --- /dev/null +++ b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/intro.md @@ -0,0 +1,43 @@ +--- +title: "Connect PocketBeagle 2 to Greengrass Lite" +description: Understand how a PocketBeagle 2 Yocto image, Greengrass Lite identity, and AWS IoT thing group enable cloud application deployment. +weight: 2 +layout: "learningpathall" +--- + +## Build an Arm edge device that receives cloud deployments + +Build a Yocto Linux image for PocketBeagle 2, register its AWS IoT identity, and deploy a Hello World application from AWS IoT Greengrass. The final test prints a message repeatedly on the device, proving that a cloud deployment reached the Arm board and started your application. + +PocketBeagle 2 uses a Texas Instruments AM6254 processor with Arm Cortex-A53 application cores. This tutorial targets 64-bit Linux on those cores. It does not target the original PocketBeagle or run the application on the board's microcontrollers. + +Greengrass nucleus lite is a native runtime for constrained Linux devices. It implements a subset of the Java-based Greengrass nucleus. This tutorial uses a generic component with a shell lifecycle and no IPC dependencies, suitable for the Lite runtime. + +## Follow the workflow + +The tasks progress from preparing the image to validating a cloud deployment: + +| Stage | Where you work | Result | +| --- | --- | --- | +| Build | x86_64 Linux host | Bootable microSD image with Nucleus Lite | +| Boot and connect | PocketBeagle 2 and attached computer | SSH and outbound Internet access | +| Provision | AWS workstation and board | Unique certificate, IoT thing, and connected core device | +| Publish | AWS workstation | Versioned Hello World component | +| Deploy | AWS and board | Thing group deployment and observed application output | + +A *thing* is the AWS IoT identity of one board. A *thing group* is a deployment target containing one or more things. Here, “group deployment” means a Greengrass V2 deployment to an AWS IoT thing group. Each board retains its own identity and certificate. + +## Use the supplied build bundle + +Download the [PocketBeagle 2 Scarthgap build bundle](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/pocketbeagle2-scarthgap-build.zip). It includes `build-pocketbeagle2.sh`, the `meta-pocketbeagle2-dev` layer, a provisioning helper, and a README. Keep these together: the script locates its layer relative to itself. + +The bundle pins Yocto Scarthgap layers and Greengrass nucleus lite 2.6.0. The generated `sources.lock` records the upstream revisions; see the bundled `AUDIT.txt` for verification limits. + +Allow several additional hours for a first uncached build beyond the hands-on time shown for this Learning Path. AWS services can incur charges; use a dedicated development thing group. + +This image also prepares the board for [Run Zephyr on the PocketBeagle 2 MCU alongside Yocto Linux](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/). To follow both Learning Paths, use PocketBeagle 2 revision A1 and have a 3.3 V USB-to-UART adapter and jumper wires. + +## What you have learned + +You know how the Yocto image, unique device identity, component version, and thing group fit together. Next, build the image that provides the runtime and board connectivity. + diff --git a/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/pocketbeagle2-scarthgap-build.zip b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/pocketbeagle2-scarthgap-build.zip new file mode 100644 index 0000000000..320c3c8f3a Binary files /dev/null and b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/pocketbeagle2-scarthgap-build.zip differ diff --git a/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/provision.md b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/provision.md new file mode 100644 index 0000000000..75d438e160 --- /dev/null +++ b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/provision.md @@ -0,0 +1,297 @@ +--- +title: "Register and provision the Greengrass core device" +description: Provision a unique AWS IoT identity on PocketBeagle 2 with the supplied helper and verify the Greengrass Lite cloud connection. +weight: 5 +layout: "learningpathall" +--- + +## Create the device identity in AWS + +Use the same AWS account and Region throughout this Learning Path. This page uses the Nucleus Lite connection-kit workflow documented in the [pinned upstream provisioning guide](https://github.com/aws-greengrass/aws-greengrass-lite/blob/v2.6.0/docs/Provisioning.md). It provisions one unique identity per board; it does not use a fleet provisioning claim certificate. + +In the AWS IoT console: + +1. Open **Greengrass devices**, then **Core devices**, and choose **Set up core device**. +2. Choose the option to set up one core device. Name it `MyPocketBeagle2` and select **Nucleus Lite**. +3. Create a dedicated thing group named `PocketBeagleDevices`, or add the device to that group if you created it separately. Do not use a group containing production devices. +4. Choose **Create thing**, then **Download connection kit**. Save it privately on your Ubuntu host that has the USB connection to the pocketbeagle2. + +The above workflow creates the IoT thing, device certificate, IoT policy, token-exchange IAM role, and IoT role alias. If the console offers software installation commands, use the runtime already in the Yocto image and the bundled provisioning helper instead of installing another runtime. + +## Prepare a credentials temp directory on pocketbeagle2 + +In an SSH shell on your pocketbeagle2, type: + +```bash +cd $HOME +mkdir ./gg-provision +``` + +We will use this directory to temporarily store the credential kit prior to installation. + +{{% notice Important Note %}} +Please delete this temporary directory after the configuration/provisioning of greengrass is complete. It will no longer be needed. +{{% /notice %}} + +On the Ubuntu host, configure variables used throughout the remaining pages. Replace the sample Region if needed, and use an authenticated AWS CLI v2 profile: + +```bash +export AWS_REGION=us-east-1 +export THING_NAME=MyPocketBeagle2 +export THING_GROUP=PocketBeagleDevices +aws sts get-caller-identity +aws iot list-thing-groups-for-thing --thing-name "$THING_NAME" +``` + +## Upload the connection kit to the pocketbeagle2 + +From the Ubuntu host connected to your pocketbeagle2, invoke a scp session to copy the connection kit to the pocketbeagle2: + +```bash +scp MyPocketBeagle2-connectionKit.zip root@192.168.7.2:./gg-provision +``` + +{{% notice Important Note %}} + +If your AWS account is restricted such that you get an error when pressing the **Create thing** button above, you may need to manually create your entire connection kit manually via the AWS CLI. If this is the case then + +## Optional - only if your organization requires a pre-approved role or permissions boundary + +Most users can use the role created by the connection kit and do not need to configure a permissions boundary. If your administrator requires a pre-approved role, keep its boundary and follow the [manual provisioning guide](https://github.com/aws-greengrass/aws-greengrass-lite/blob/v2.6.0/docs/Provisioning.md#manual-provisioning-by-creating-a-thing), reusing that role instead of creating one. + +For a device-specific alias, point it to the approved role with this command, replacing both placeholders: + +```bash +aws iot update-role-alias --role-alias YOUR_ROLE_ALIAS --role-arn YOUR_APPROVED_ROLE_ARN +``` + +Use `create-role-alias` with the same arguments if the alias does not exist. Your administrator must confirm the role's trust and certificate-policy permissions. Pass the alias **name** as `YOUR_ROLE_ALIAS` to the board's provisioning helper. After manual provisioning, continue with [Prepare the credentials](#prepare-the-credentials). + +## Prepare the credentials + +On your workstation, keep the connection kit or manually downloaded credentials in a private directory outside any source checkout. Extract the kit if you used one, and identify the device certificate, private key, and Amazon Root CA. Save copies with these filenames: `device.pem.crt`, `private.pem.key`, and `AmazonRootCA1.pem`. Do not confuse the device certificate with the CA certificate or public key. + +Protect the key and transfer these three files to the board. Run from the directory containing those files: + +```bash +chmod 600 private.pem.key +scp device.pem.crt private.pem.key AmazonRootCA1.pem \ + root@192.168.7.2:./gg-provision/ +``` + +AWS CLI credentials stay on the administrative workstation. The board authenticates with its device private key and certificate. + +The endpoints must match your recorded device settings. If you provisioned manually and the thing group does not exist, create it: + +```bash +aws iot create-thing-group --thing-group-name "$THING_GROUP" +``` + +The group list must contain `PocketBeagleDevices`. If the thing is not a member, add it: + +```bash +aws iot add-thing-to-thing-group --thing-name "$THING_NAME" \ + --thing-group-name "$THING_GROUP" +``` + +The command produces no output on success. Confirm membership before continuing: + +```bash +aws iot list-thing-groups-for-thing --thing-name "$THING_NAME" +``` + +Lastly, lets get our iot data endpoint and iot credential endpoint values for our specific account. Back on the Ubuntu host type: + +```bash +aws iot describe-endpoint --endpoint-type iot:Data-ATS +aws iot describe-endpoint --endpoint-type iot:CredentialProvider +``` + +Record the full `endpointAddress` from each command. It will be used in the next step. + +## Create the configuration yaml file + +Lastly, we need to create the config file for our credentials bundle. Create a file `config.yaml` with the following contents (replacing YOUR_IOT_DATA_ENDPOINT and YOUR_IOT_CRED_ENDPOINT with your actual endpoint url components from the previous command above). You may also need to update the `awsRegion` to reflect the region you wish to use: + +```yaml +--- +system: + certificateFilePath: "{{config_dir}}/device.pem.crt" + privateKeyPath: "{{config_dir}}/private.pem.key" + rootCaPath: "{{config_dir}}/AmazonRootCA1.pem" + thingName: "MyPocketBeagle2" +services: + {{nucleus_component}}: + componentType: "NUCLEUS" + configuration: + awsRegion: "us-east-1" + iotRoleAlias: "GreengrassV2TokenExchangeCoreDeviceRoleAlias" + iotDataEndpoint: "YOUR_IOT_DATA_ENDPOINT-ats.iot.us-east-1.amazonaws.com" + iotCredEndpoint: "YOUR_IOT_CRED_ENDPOINT.credentials.iot.us-east-1.amazonaws.com" +``` + +Save and copy this file up with our other created key files to your pocketbeagle2 from your Ubuntu host: + +```bash +scp config.yaml root@192.168.7.2:/root/gg-provision/ +``` + +On your pocketbeagle2 via a SSH shell confirm that you have the following files created: + +```bash +cd ~/gg-provision +ls -al +``` + +Your output should be: + +```output +-rw-r--r-- 1 root root 1188 Oct 21 15:36 AmazonRootCA1.pem +-rw-r--r-- 1 root root 528 Oct 21 15:36 config.yaml +-rw-r--r-- 1 root root 1220 Oct 21 15:36 device.pem.crt +-rw-r--r-- 1 root root 1675 Oct 21 15:36 private.pem.key +``` + +Please continue with the next section editing the `config.yaml` in this directory on your pocketbeagle2 file per instructions below by skipping to the `Prepare the credentials config file` step below. +{{% /notice %}} + +Inspect the downloaded configuration and record the thing name, Region, data endpoint, credential-provider endpoint, and role alias. Find the role alias in **Security > Role aliases** and record its associated IAM role name for troubleshooting token exchange. The inline Hello World component does not need an S3 permissions policy. + +Confirm the device certificate is **ACTIVE**, attached to this thing, and has the generated IoT policy attached. That policy must allow the device's IoT/Greengrass communication and `iot:AssumeRoleWithCertificate` on the role alias ARN. The IAM role must trust `credentials.iot.amazonaws.com`. For troubleshooting each association, see the linked Nucleus Lite 2.6.0 provisioning guide. + +## Prepare the credentials config file + +From the Ubuntu host connected to your pocketbeagle2, open a SSH session: + +```bash +ssh root@192.168.7.2 +``` + +Unzip the contents of the connection kit (zipped and not already placed there manually): + +```bash +cd $HOME +cd ./gg-provision +unzip ./MyPocketBeagle2-connectionKit.zip +``` + +Examine the `config.yaml` file: + +```bash +cat ./config.yaml +``` + +The contents of the `config.yaml` file should look like this: + +```yaml +--- +system: + certificateFilePath: "{{config_dir}}/device.pem.crt" + privateKeyPath: "{{config_dir}}/private.pem.key" + rootCaPath: "{{config_dir}}/AmazonRootCA1.pem" + thingName: "MyPocketBeagle2" +services: + {{nucleus_component}}: + componentType: "NUCLEUS" + configuration: + awsRegion: "us-east-1" + iotRoleAlias: "GreengrassV2TokenExchangeCoreDeviceRoleAlias" + iotDataEndpoint: "YOUR_IOT_DATA_ENDPOINT-ats.iot.us-east-1.amazonaws.com" + iotCredEndpoint: "YOUR_IOT_CRED_ENDPOINT.credentials.iot.us-east-1.amazonaws.com" +``` + +Replace `{{config_dir}}` with `/etc/greengrass` and `{{nucleus_component}}` with `aws.greengrass.NucleusLite`: + +```yaml +--- +system: + certificateFilePath: "/etc/greengrass/device.pem.crt" + privateKeyPath: "/etc/greengrass/private.pem.key" + rootCaPath: "/etc/greengrass/AmazonRootCA1.pem" + thingName: "MyPocketBeagle2" +services: + aws.greengrass.NucleusLite: + componentType: "NUCLEUS" + configuration: + awsRegion: "us-east-1" + iotRoleAlias: "GreengrassV2TokenExchangeCoreDeviceRoleAlias" + iotDataEndpoint: "YOUR_IOT_DATA_ENDPOINT-ats.iot.us-east-1.amazonaws.com" + iotCredEndpoint: "YOUR_IOT_CRED_ENDPOINT.credentials.iot.us-east-1.amazonaws.com" +``` + +Save the updated `config.yaml` file. + +## Finailize configuration of AWS IoT Greengrass + +Continuing with the SSH session into the pocketbeagle2, copy all contents from our updated connection kit to the greengrass config directory already setup on your pocketbeagle2: + +```bash +cd $HOME +cd ./gg-provision +cp * /etc/greengrass +chmod 640 /etc/greengrass/*key +chmod 640 /etc/greengrass/*pem +chmod 640 /etc/greengrass/*crt +chown ggcore:ggcore /etc/greengrass/*key /etc/greengrass/*pem /etc/greengrass/*crt +ls -al /etc/greengrass +``` + +The expected contents of `/etc/greengrass` should be: + +```output +root@pocketbeagle2:~/gg-provision# ls -al /etc/greengrass +total 28 +drwxr-xr-x 3 root root 4096 Oct 22 19:32 . +drwxr-xr-x 48 root root 4096 Oct 22 19:34 .. +-rw-r----- 1 ggcore ggcore 1188 Oct 22 19:35 AmazonRootCA1.pem +drwxr-xr-x 2 root root 4096 Mar 9 2018 config.d +-rw-r--r-- 1 root root 540 Oct 22 19:35 config.yaml +-rw-r----- 1 ggcore ggcore 1220 Oct 22 19:35 device.pem.crt +-rw-r----- 1 ggcore ggcore 1675 Oct 22 19:35 private.pem.key +root@pocketbeagle2:~/gg-provision# +``` + +Your pocketbeagle2's AWS IoT Greengrass configuration is now complete! Restart the greengrass services on the pocketbeagle2: + +```bash +systemctl restart greengrass-lite.target +systemctl status --with-dependencies greengrass-lite.target +``` + +Your pocketbeagle2's greengrass service should now be operational. + +## Verify the pocketbeagle2 greengrass operational status + +On the board, inspect service health and connection logs: + +```bash +systemctl status --with-dependencies greengrass-lite.target +systemctl --failed +journalctl -u ggl.core.iotcored.service -u ggl.core.ggdeploymentd.service -b --no-pager +``` + +The core services should be running without repeated certificate, authorization, or endpoint errors. On the Ubuntu host, query the registered core device: + +```bash +aws greengrassv2 get-core-device --core-device-thing-name "$THING_NAME" +``` + +Your output should resemble this (may or may not be actual json depending on how you have the aws CLI configured on your Ubuntu host): + +```output +{ + "coreDeviceThingName": "MyPocketBeagle2", + "coreVersion": "2.6.0", + "platform": "linux", + "architecture": "aarch64", + "status": "HEALTHY", + "lastStatusUpdateTimestamp": 1792697816.549, + "tags": {} +} +``` + +Wait for the device to appear under **Greengrass devices > Core devices** and report healthy connectivity. If it does not, check clock synchronization, outbound connectivity, certificate activation, IoT policy attachment, and Region consistency. An IoT thing's existence alone does not prove the Greengrass runtime connected. + +## What you have accomplished + +The board has a unique AWS identity and connects as a Greengrass core device. Next, publish an inline Hello World component for the device to run. diff --git a/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/setup.md b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/setup.md new file mode 100644 index 0000000000..7168041001 --- /dev/null +++ b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/setup.md @@ -0,0 +1,199 @@ +--- +title: "Boot the image and connect the board" +description: Flash the PocketBeagle 2 Yocto image and verify SSH access and outbound Internet connectivity before Greengrass Lite provisioning. +weight: 4 +layout: "learningpathall" +--- + +## Write the microSD card + +On a Linux computer with the card reader attached, install `bmap-tools` and identify the card: + +```bash +sudo apt-get install bmap-tools +lsblk -o NAME,SIZE,MODEL,MOUNTPOINTS +``` + +{{% notice warning %}} +Writing the image erases the selected device. Replace `/dev/sdX` with the entire microSD device, not a partition. Check its size and model, and unmount its mounted partitions before proceeding. +{{% /notice %}} + +Use the actual image and block-map paths from the previous page: + +```bash +sudo bmaptool copy --bmap /path/to/image.wic.bmap \ + /path/to/image.wic.xz /dev/sdX +sync +``` + +Insert the card in PocketBeagle 2 and connect its USB-C port with a data cable. A serial console is useful if boot or networking fails; the target debug UART uses 115200 baud, 8N1. Follow the [PocketBeagle 2 connection guide](https://docs.beagleboard.org/boards/pocketbeagle-2/02-quick-start.html) for debug hardware and power requirements. + +## Connect over USB Ethernet + +The supplied image creates interface `pb2usb0` with address `192.168.7.2/24`. Its DHCP server offers `192.168.7.1/24` to the attached computer. Linux and macOS use the default CDC-ECM gadget. Windows users should follow the bundled README's NCM/RNDIS instructions using the serial console first. + +From the attached computer, connect to the board: + +```bash +ssh root@192.168.7.2 +``` + +The development image initially permits passwordless root access. On the board, set a password and verify its architecture and included tools: + +```bash +passwd +uname -m +command -v pb2-provision-greengrass +command -v python3 +pb2-network-status +``` + +The architecture must be `aarch64`. The provisioning helper and Python must be present. This image includes `debug-tweaks`; use it on a controlled development network. A production image needs configured accounts and removal of that feature. + +## Provide outbound Internet access + +USB SSH access alone does not give the board Internet access. Choose either a USB Ethernet adapter on a supported USB host port/cape, or Internet sharing from the attached computer. For an adapter, the image uses DHCP on conventional Ethernet interfaces. Check `ip -br address`, `ip route`, and `resolvectl status` on the board. + +### Share an Ubuntu host connection + +Use a serial console for this change so you can recover if SSH disconnects. The image includes a USB serial console; a separate debug UART remains available even if you restart the USB gadget. First, confirm that Ubuntu can reach the board over USB before changing Internet sharing. + +On Ubuntu, identify the USB Ethernet interface and check its carrier. Replace `YOUR_USB_INTERFACE` with its actual name, such as `enx060cae3c4bd8`: + +```bash +export PB2_USB_IF=YOUR_USB_INTERFACE +ip -br link show dev "$PB2_USB_IF" +cat "/sys/class/net/$PB2_USB_IF/carrier" +``` + +Expect `LOWER_UP` in the link flags and a carrier value of `1`. An interface can be administratively `UP` while its route still shows `linkdown`; in that state, restore the USB link before configuring IP routing or DNS. See [Recover USB connectivity](#recover-usb-connectivity). + +On the board as root, keep the bundled static address `192.168.7.2/24` and disable its DHCP server. Set Ubuntu's `192.168.7.1` address as the gateway and DNS forwarder. This replaces the earlier DHCP-client drop-in if you already created it: + +```bash +mkdir -p /etc/systemd/network/20-pb2-usb.network.d +cat > /etc/systemd/network/20-pb2-usb.network.d/50-host-internet.conf <<'EOF' +[Network] +DHCP=no +DHCPServer=no +DNS=192.168.7.1 + +[Route] +Destination=0.0.0.0/0 +Gateway=192.168.7.1 +Metric=200 +EOF +networkctl reload +networkctl reconfigure pb2usb0 +ip link set dev pb2usb0 up +ip -4 address show dev pb2usb0 +``` + +Confirm that `192.168.7.2/24` remains assigned. The static address comes from the bundled `20-pb2-usb.network`; do not replace that main file or enable a DHCP client for this Ubuntu setup. + +On Ubuntu, create the shared profile only if it does not already exist: + +```bash +nmcli connection show pb2-usb-share +``` + +If NetworkManager reports an unknown connection, create it: + +```bash +sudo nmcli connection add type ethernet ifname "$PB2_USB_IF" con-name pb2-usb-share +``` + +Configure and activate the profile on the USB interface: + +```bash +sudo nmcli connection modify pb2-usb-share \ + connection.interface-name "$PB2_USB_IF" \ + ipv4.method shared ipv4.addresses 192.168.7.1/24 \ + ipv4.never-default yes ipv6.method disabled +sudo nmcli connection up pb2-usb-share ifname "$PB2_USB_IF" +ip -br link show dev "$PB2_USB_IF" +ping -c 3 192.168.7.2 +ssh root@192.168.7.2 +``` + +The USB route must no longer show `linkdown`. Ubuntu keeps its existing upstream default route; NetworkManager's [shared IPv4 mode](https://www.networkmanager.dev/docs/api/1.46.2/nm-settings-nmcli.html) provides sharing to the board. If a previous automatic profile takes over the same interface, reactivate `pb2-usb-share` rather than creating another profile. + +For macOS or Windows Internet sharing, use the platform instructions in the bundle's README. Their gateway and DHCP subnet can differ, so the Ubuntu-specific static gateway settings do not apply unchanged. + +{{% notice Recover USB connectivity %}} + +A host route ending in `linkdown` indicates that the link is not operational, even if the host has `192.168.7.1` assigned. Changing DNS or NAT rules will not restore the USB carrier. Keep the host's working upstream connection unchanged. + +From the board's serial console, inspect the interface and services: + +```bash +ip -br link show dev pb2usb0 +ip -4 address show dev pb2usb0 +systemctl status pb2-usb-gadget.service systemd-networkd.service sshd.service +journalctl -b -u pb2-usb-gadget.service -u systemd-networkd.service --no-pager -n 80 +``` + +If `pb2usb0` exists but is administratively down, bring it up: + +```bash +ip link set dev pb2usb0 up +``` + +On Ubuntu, activate the existing shared profile on the USB interface and check carrier again: + +```bash +sudo nmcli connection up pb2-usb-share ifname "$PB2_USB_IF" +cat "/sys/class/net/$PB2_USB_IF/carrier" +ping -c 3 192.168.7.2 +``` + +If carrier remains `0`, inspect the gadget service and USB enumeration before continuing. Reconnect the data cable and identify the interface again if it re-enumerates. Restart `pb2-usb-gadget.service` only from a separate debug UART: that restart disconnects both USB Ethernet and the USB serial console. + +If carrier is `1` but ping still fails, confirm the board still has `192.168.7.2/24`, inspect `ip neigh show dev "$PB2_USB_IF"` on Ubuntu, and check the board's networkd logs. Do not proceed to Internet tests until local USB access works. +{{% /notice %}} + +### Update /etc/resolv.conf + +On the pocketbeagle board either in a SSH shell or via the UART console, edit /etc/resolv.conf and add the following line: + +```bash +nameserver 8.8.8.8 +``` + +Save the file. + +### Verify outbound access + +On the board, verify routing, DNS, time, and HTTPS: + +```bash +ip route +resolvectl status +timedatectl status +ping -c 3 google.com +curl -I https://www.amazontrust.com/repository/AmazonRootCA1.pem +``` + +Expect a default route, usable DNS servers, a correct UTC time, proper pinging of google.com, and a successful HTTPS response. + +{{% notice Check clock time %}} +Correct the clock before provisioning: certificate validation fails when the time is wrong. The board needs outbound HTTPS and MQTT connectivity to AWS IoT; this exercise requires no inbound Internet port forwarding. + +In either the SSH session to the pocketbeagle or the UART console session, type: + +```bash +timedatectl set-ntp true +``` + +Then confirm that the time is correct: + +```bash +date +``` + +It is often the case that the yocto image is initially setup in UTC timezones as the default (and this should be OK). +{{% /notice %}} + +## What you have accomplished + +The board boots 64-bit Arm Linux, accepts SSH connections, and reaches the Internet. Next, create its unique AWS identity and initialize Nucleus Lite. diff --git a/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/_index.md b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/_index.md new file mode 100644 index 0000000000..822716f1cb --- /dev/null +++ b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/_index.md @@ -0,0 +1,73 @@ +--- +title: "Run Zephyr on the PocketBeagle 2 MCU alongside Yocto Linux" +description: Build a Zephyr heartbeat for the PocketBeagle 2 Cortex-M4F, load it from Yocto Linux with remoteproc, and verify Linux and MCU execution together. + +draft: true +cascade: + draft: true + +minutes_to_complete: 60 + +who_is_this_for: Embedded Linux developers adding a Zephyr application to the MCU on a PocketBeagle 2 running Yocto Linux. + +learning_objectives: + - Verify that your Yocto image enables the AM6254 M4 remote processor + - Build a Zephyr UART heartbeat for the Cortex-M4F + - Load the ELF firmware from Linux into an offline M4 + - Verify MCU heartbeat output while Linux and Greengrass continue running + +prerequisites: + - A PocketBeagle 2 revision A1 with AM6254, running the updated image from [Deploy a Hello World component to PocketBeagle 2 with Greengrass Lite](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/) + - SSH access and outbound networking configured as in [Deploy a Hello World component to PocketBeagle 2 with Greengrass Lite](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/) + - An Ubuntu 22.04 or 24.04 build host, from [Deploy a Hello World component to PocketBeagle 2 with Greengrass Lite](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/), with Git, Python 3, CMake, Ninja, west, and Zephyr SDK support for Arm + - A 3.3 V logic USB-to-UART adapter, jumper wires, and a serial terminal on your workstation + +author: Doug Anson + +generate_summary_faq: true +rerun_summary: false +rerun_faqs: false +skilllevels: Advanced +subjects: Embedded Linux + +armips: + - Cortex-A + - Cortex-M + +operatingsystems: + - Linux + - RTOS + +tools_software_languages: + - Yocto Project + - Zephyr + - C + - AWS IoT Greengrass + +further_reading: + - resource: + title: Deploy a Hello World component to PocketBeagle 2 with Greengrass Lite + link: /learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/ + type: learningpath + - resource: + title: Zephyr PocketBeagle 2 board documentation + link: https://docs.zephyrproject.org/latest/boards/beagle/pocketbeagle_2/doc/pocketbeagle_2.html + type: documentation + - resource: + title: Zephyr getting started guide + link: https://docs.zephyrproject.org/latest/develop/getting_started/index.html + type: documentation + - resource: + title: Zephyr v4.3.0 PocketBeagle 2 board sources + link: https://github.com/zephyrproject-rtos/zephyr/tree/v4.3.0/boards/beagle/pocketbeagle_2 + type: documentation + - resource: + title: Linux remoteproc framework + link: https://docs.kernel.org/staging/remoteproc.html + type: documentation + +### FIXED, DO NOT MODIFY +weight: 1 +layout: "learningpathall" +learning_path_main_page: "yes" +--- diff --git a/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/_next-steps.md b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/_next-steps.md new file mode 100644 index 0000000000..c3db0de5a2 --- /dev/null +++ b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/_next-steps.md @@ -0,0 +1,8 @@ +--- +# ================================================================================ +# FIXED, DO NOT MODIFY THIS FILE +# ================================================================================ +weight: 21 # Set to always be larger than the content in this path to be at the end of the navigation. +title: "Next Steps" # Always the same, html page title. +layout: "learningpathall" # All files under learning paths have this same wrapper for Hugo processing. +--- diff --git a/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/build.md b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/build.md new file mode 100644 index 0000000000..d6703e06f5 --- /dev/null +++ b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/build.md @@ -0,0 +1,100 @@ +--- +title: "Build the Zephyr Cortex-M4F heartbeat" +description: Compile the supplied heartbeat with Zephyr v4.3.0 for the PocketBeagle 2 AM6254 M4 target. +weight: 4 +layout: "learningpathall" +--- + +## Prepare the Zephyr workspace + +First, on our ubuntu build host, lets check if we have python v3.12: + +```bash +python3.12 --version +``` + +If a version string is returned, we can proceed to install the host dependencies for Zephyr. If python 3.12 is not installed (likely the case if our build host is ubuntu 22.04), lets install python3.12: + +```bash +sudo add-apt-repository ppa:deadsnakes/ppa +sudo apt update +sudo apt install python3.11 python3.11-venv +``` + +Install host dependencies using the [Zephyr getting started guide](https://docs.zephyrproject.org/latest/develop/getting_started/index.html), including a supported Python, CMake, Ninja, and compiler environment. Create a separate virtual environment and pin the source release: + +```bash +python3.12 -m venv "$HOME/pb2-zephyr-venv" +source "$HOME/pb2-zephyr-venv/bin/activate" +pip install west +west init -m https://github.com/zephyrproject-rtos/zephyr \ + --mr v4.3.0 "$HOME/pb2-zephyr-workspace" +cd "$HOME/pb2-zephyr-workspace" +west update +west zephyr-export +pip install -r zephyr/scripts/requirements.txt +``` + +Use this dedicated workspace so another project's west manifest does not select different board sources. Reactivate the virtual environment in each new terminal. + +Install the SDK version recommended by this checkout using west, then confirm your revision: + +```bash +cd "$HOME/pb2-zephyr-workspace/zephyr" +west sdk install +cat SDK_VERSION +git describe --tags --exact-match +``` + +For v4.3.0, `SDK_VERSION` is `0.17.4`, and the Git tag must be `v4.3.0`. The SDK installer chooses a host-compatible package. Check the [SDK installation guidance](https://docs.zephyrproject.org/latest/develop/toolchains/zephyr_sdk.html) if download or host-tool installation fails. + +## Inspect the sample + +Download the [heartbeat application](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/pb2-m4-heartbeat.zip), copy it to the `$HOME` directory on the Ubuntu host, and extract it into the workspace: + +```bash +cd "$HOME/pb2-zephyr-workspace" +unzip $HOME/pb2-m4-heartbeat.zip -d "$HOME/pb2-zephyr-workspace" +``` + +The archive contains `heartbeat/CMakeLists.txt`, `heartbeat/prj.conf`, `heartbeat/src/main.c`, and `heartbeat/src/resource_table.c`. The main source is: + +```c +/* SPDX-License-Identifier: Apache-2.0 */ +#include +#include + +int main(void) +{ + unsigned int count = 0; + + printk("PocketBeagle 2: Zephyr on Cortex-M4F\n"); + while (1) { + printk("M4 heartbeat %u\n", count++); + k_sleep(K_SECONDS(1)); + } + return 0; +} +``` + +`printk()` writes to the board target's MCU_UART0 console. `k_sleep()` yields the thread for one second between messages. The sample does not configure a GPIO, change the Linux heartbeat LED, or implement a mailbox shutdown protocol. + +## Build the ELF executable + +Build for the M4 qualifier, not the board's A53 target: + +```bash +cd "$HOME/pb2-zephyr-workspace" +export ZEPHYR_TOOLCHAIN_VARIANT=zephyr +west build -p always -b pocketbeagle_2/am6254/m4 \ + heartbeat -d build/pb2-m4-heartbeat +file build/pb2-m4-heartbeat/zephyr/zephyr.elf +``` + +The result must be a 32-bit Arm ELF executable. Linux remains 64-bit `aarch64`; the MCU firmware is a different executable for a different core. + +Use the SDK's `arm-zephyr-eabi-readelf` tool to inspect the ELF sections if needed. The board's SoC configuration reserves a section for an OpenAMP resource table. The sample's `resource_table.c` supplies a version-one table with zero resource entries because this UART-only application does not create RPMsg devices. The ELF must retain its `.resource_table` section. Do not strip the ELF or replace it with `zephyr.bin`: the Linux remoteproc loader needs the ELF program headers and resource information. + +## What you have accomplished + +You have a Zephyr ELF built for the Cortex-M4F and a source tree pinned to v4.3.0. Next, transfer it to the running board and start the offline M4 from Linux. diff --git a/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/intro.md b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/intro.md new file mode 100644 index 0000000000..ecdb4151bb --- /dev/null +++ b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/intro.md @@ -0,0 +1,33 @@ +--- +title: "Run Linux and Zephyr on separate Arm cores" +description: Understand how Yocto Linux loads a Zephyr UART heartbeat onto the PocketBeagle 2 Cortex-M4F. +weight: 2 +layout: "learningpathall" +--- + +## Add an MCU application to your Linux system + +Keep Yocto Linux and Greengrass Lite on the Cortex-A53 cores from [Deploy a Hello World component to PocketBeagle 2 with Greengrass Lite](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/), and add a small Zephyr application on the AM6254's Cortex-M4F microcontroller (MCU). The application prints a numbered heartbeat once per second on the serial UART console. You verify this output while Linux remains reachable over SSH. + +The [Zephyr board documentation](https://docs.zephyrproject.org/latest/boards/beagle/pocketbeagle_2/doc/pocketbeagle_2.html) identifies the Cortex-M4F target as `pocketbeagle_2/am6254/m4` and describes Linux remoteproc loading. This Learning Path uses Zephyr v4.3.0 and revision A1 hardware. It uses the M4 inside the AM6254, rather than the separate MSPM0L1105 used for board services. + +## Use a UART heartbeat as the test + +A repeating UART message provides the same visible liveness check as a blinking LED without taking control of a GPIO or user LED managed by Linux. The sample uses `printk()` and `k_sleep()`; it does not need an AWS deployment or changes to your Greengrass component. + +| Processor | Software | How you observe it | +| --- | --- | --- | +| Cortex-A53 | Yocto Linux and Greengrass Lite from [Deploy a Hello World component to PocketBeagle 2 with Greengrass Lite](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/) | SSH and the Linux journal | +| Cortex-M4F | Zephyr heartbeat | MCU_UART0 on the expansion header | + +Linux remoteproc, the remote-processor framework, loads the ELF firmware executable and starts the M4. Linux and Zephyr must agree on peripheral ownership: the updated image leaves MCU_UART0 to Zephyr. + +## Account for the pinned Linux driver + +The Yocto image from [Deploy a Hello World component to PocketBeagle 2 with Greengrass Lite](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/) uses a pinned Linux 6.12 kernel. Load the sample only when the M4 reports `offline`. Because this sample does not implement the shutdown handshake expected by the driver, plan a board restart before loading another build. + +## What you have learned + +You have learned how Yocto Linux on the Cortex-A53 cores loads Zephyr firmware onto the Cortex-M4F. The MCU sends its heartbeat to MCU_UART0 while Linux remains available over SSH. + +Next, check the M4 support in your image and connect the MCU serial console. diff --git a/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/load.md b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/load.md new file mode 100644 index 0000000000..07538271a6 --- /dev/null +++ b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/load.md @@ -0,0 +1,60 @@ +--- +title: "Load the firmware from running Yocto Linux" +description: Transfer the Zephyr ELF over SSH and start an offline Cortex-M4F through the supplied helper. +weight: 5 +layout: "learningpathall" +--- + +## Transfer the ELF to the board + +Keep the MCU serial terminal open. From the development host, copy the built executable over the network connection you set up in [Boot the image and connect the board](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/setup/): + +```bash +cd "$HOME/pb2-zephyr-workspace" +scp build/pb2-m4-heartbeat/zephyr/zephyr.elf root@192.168.7.2:/root/pb2-heartbeat.elf +ssh root@192.168.7.2 +``` + +Use the board's actual address if you changed its network setup. All remaining commands on this page run as root on PocketBeagle 2. + +## Check the M4's current state + +On the pocketbeagle2 via an SSH shell, inspect the remote processor and driver logs: + +```bash +pb2-m4 status +dmesg | grep -E 'remoteproc|m4f|5000000' +``` + +Continue only when the M4 reports `offline`; the helper refuses other states. `running` means firmware is already executing. `attached` or `detached` can indicate bootloader ownership. Changing the firmware name does not replace running code. + +The kernel can report a missing default `am62-mcu-m4f0_0-fw` file during boot. If the M4 still registers and remains offline, the sample helper can select its own firmware filename. Missing reserved-memory, mailbox, or driver errors need to be fixed before proceeding. + +## Start the heartbeat + +Load the sample while Yocto Linux is running: + +```bash +pb2-m4 load /root/pb2-heartbeat.elf +pb2-m4 status +``` + +The helper validates that the file is a 32-bit, little-endian Arm ELF, installs it as `/lib/firmware/pb2-zephyr-heartbeat.elf`, and writes that filename and `start` to the selected M4's remoteproc controls. It never overwrites TI's default firmware filename or resets the R5 system-management processor. + +The final status must show `state=running` and `firmware=pb2-zephyr-heartbeat.elf`. That proves the kernel started the core; the UART heartbeat on the next page proves that your application reached its loop. + +The helper does not configure automatic startup. The tutorial's ELF is loaded into MCU memory, rather than flashed to the MSPM0 or used as a replacement for Linux's boot image. + +## Plan another firmware run + +The [pinned driver's stop implementation](https://github.com/beagleboard/linux/blob/2eea568f445af33f3280261904bf1027b02512d8/drivers/remoteproc/ti_k3_common.c) waits for a firmware shutdown acknowledgment. This heartbeat does not implement that protocol. For this simple sample on the pinned kernel, use a controlled board restart before another load. Save work first: restarting interrupts SSH and Greengrass until Linux reconnects. Do not use a `stop` command, driver unbinding, or a forced reset as a workaround for the missing shutdown handshake. + +After a restart, check `pb2-m4 status` again. If a warm restart leaves the M4 attached or running, shut down Linux and power-cycle the board. If your bootloader is configured to preload M4 firmware, that configuration must be disabled before Linux can own an offline core. This tutorial does not replace a bootloader-owned firmware in place. + +Do not copy the sample over the default firmware filename to make it start automatically: boot-time ownership and shutdown handling need a separate integration design. + +## What you have accomplished + +You have transferred the Zephyr ELF to the board and used `pb2-m4` to start the offline Cortex-M4F. The M4 now runs your firmware alongside Yocto Linux on the Cortex-A53 cores. + +Next, observe the numbered heartbeat on MCU_UART0 and verify that Linux and Greengrass remain active. diff --git a/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/pb2-m4-heartbeat.zip b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/pb2-m4-heartbeat.zip new file mode 100644 index 0000000000..1848790567 Binary files /dev/null and b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/pb2-m4-heartbeat.zip differ diff --git a/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/prepare.md b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/prepare.md new file mode 100644 index 0000000000..14f6c25292 --- /dev/null +++ b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/prepare.md @@ -0,0 +1,72 @@ +--- +title: "Prepare Yocto Linux and the MCU serial console" +description: Check the M4 integration in your Yocto image and connect a 3.3 V serial adapter to MCU_UART0. +weight: 3 +layout: "learningpathall" +--- + +## Check the updated Yocto image + +Continue with the same pocketbeagle2 board, Yocto image, and Greengrass identity from [Deploy a Hello World component to PocketBeagle 2 with Greengrass Lite](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/). This Learning Path creates no new AWS resources or IAM roles. + +On the pocketbeagle2 board, check your Linux architecture and M4 support: + +```bash +uname -m +command -v pb2-m4 +pb2-m4 status +``` + +Expect `aarch64`, a path to `pb2-m4`, and a device name containing `5000000`. For a core ready to load, the output is similar to: + +```output +device=/sys/class/remoteproc/remoteproc0 name=5000000.m4fss state=offline firmware=am62-mcu-m4f0_0-fw +``` + +The remoteproc index can differ. The helper selects the M4 by its device name; it does not assume that index zero is the M4. The firmware value is a filename, not proof that firmware is running. + +{{% notice Important Note %}} + +### Update an earlier Yocto image build + +Skip this section if your image includes `pb2-m4` and the M4 device appears. If you built the image in [Deploy a Hello World component to PocketBeagle 2 with Greengrass Lite](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/) before the M4 additions, download its updated [build bundle](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/pocketbeagle2-scarthgap-build.zip). Back up your local bundle edits, then extract the new bundle over the original bundle directory on the Linux build host: + +```bash +unzip -o pocketbeagle2-scarthgap-build.zip -d "$HOME/ti" +cd "$HOME/ti/pocketbeagle2" +WORKDIR="$HOME/yocto-pocketbeagle2" JOBS=4 \ + ./build-pocketbeagle2.sh --no-sdk +``` + +Reuse the work directory from [Build the PocketBeagle 2 Yocto image](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/build/). The updated script packages `pb2-m4-tools` and builds a kernel with the M4 driver. Its AM6254 device-tree patch reserves the regions beginning at `0x9cb00000` and `0x9cc00000`, enables the M4 mailbox and remoteproc node, and leaves MCU_UART0 disabled in Linux. Other board revisions are outside this tutorial's scope. + +Boot the rebuilt image using the instructions in [Boot the image and connect the board](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/setup/). Use a spare card if you need to preserve the current installation. A fresh image does not contain your device credentials or configuration database: repeat [Boot the image and connect the board](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/setup/) and [Register and provision the Greengrass core device](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/provision/) before continuing, using the same board identity only on this board. Do not reset a working Greengrass configuration merely to install the MCU helper. + +Copying the helper alone is insufficient when the running device tree lacks the M4's reserved memory. Loading a new device tree requires a restart. After boot, rerun `pb2-m4 status` and confirm the core is `offline`. + +{{% /notice %}} + +## Connect the MCU UART + +Shut down the board and disconnect its power before wiring. Connect a USB-to-UART adapter with 3.3 V logic as follows: + +| PocketBeagle 2 connection | Adapter connection | Purpose | +| --- | --- | --- | +| P2.07, MCU_UART0 TX | RX | Read the heartbeat | +| Board GND | GND | Common reference | +| P2.05, MCU_UART0 RX | TX, optional | Not needed by this output-only sample | + +Leave the adapter's power lead disconnected. Do not use 5 V logic or an RS-232 voltage-level adapter. Confirm header orientation and a GND pin using the [PocketBeagle 2 hardware documentation](https://docs.beagleboard.org/boards/pocketbeagle-2/03-design-and-specifications.html). + +Power the board again and open the adapter's serial port at **115200 baud, eight data bits, no parity, one stop bit, and no flow control**. On an Ubuntu workstation with `picocom` installed, identify the adapter and open its actual device node: + +```bash +ls /dev/serial/by-id/ +picocom -b 115200 --flow n /dev/serial/by-id/YOUR_USB_UART_ADAPTER +``` + +Use a separate terminal for SSH. The MCU UART is not the Linux MAIN_UART6 debug connector and is not the USB gadget serial console. Open the MCU terminal before loading firmware so you capture the first message. + +## What you have accomplished + +Your image exposes the M4 loader and the workstation can listen on its UART. Next, build the heartbeat ELF on your development host. diff --git a/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/verify.md b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/verify.md new file mode 100644 index 0000000000..059aba5856 --- /dev/null +++ b/content/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-zephyr-part2/verify.md @@ -0,0 +1,79 @@ +--- +title: "Verify Zephyr and Linux running together" +description: Observe the MCU heartbeat, verify Linux and Greengrass health, and diagnose loading failures. +weight: 6 +layout: "learningpathall" +--- + +## Observe the MCU heartbeat + +Read the serial terminal connected to MCU_UART0. The output is similar to: + +```output +PocketBeagle 2: Zephyr on Cortex-M4F +M4 heartbeat 0 +M4 heartbeat 1 +M4 heartbeat 2 +``` + +The Zephyr boot banner can precede these lines. Observe the counter increasing approximately once per second. These messages come from the Cortex-M4F UART, not the Linux journal or the Greengrass Hello World component. + +## Verify the Linux side + +While heartbeat messages continue, run these commands in the SSH terminal: + +```bash +uname -m +uptime +pb2-m4 status +``` + +You should see something like this in the output: + +```output +root@pocketbeagle2:~# uname -m +aarch64 +root@pocketbeagle2:~# uptime + 22:09:27 up 2 days, 7:12, 2 users, load average: 0.00, 0.01, 0.00 +root@pocketbeagle2:~# pb2-m4 status +device=/sys/class/remoteproc/remoteproc0 name=5000000.m4fss state=running firmware=pb2-zephyr-heartbeat.elf +root@pocketbeagle2:~# +``` + +We can also verify that the AWS IoT Greengrass service, from [Deploy a Hello World component to PocketBeagle 2 with Greengrass Lite](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/), continues to run: + +```bash +systemctl status --with-dependencies greengrass-lite.target +``` + +Linux must still report `aarch64`, the M4 must report `running`, and Greengrass services should remain healthy. Use the verification steps in [Deploy to the thing group and verify Hello World](/learning-paths/embedded-and-microcontrollers/ti-pocketbeagle2-yocto-gglite-part1/deployment/) to confirm that `com.arm.HelloGreengrassLiteWorld` still produces its minute-by-minute message if you kept it deployed. + +Successful completion requires both observations at the same time: the MCU counter advances on MCU_UART0, and Linux remains reachable with its services running. Remoteproc's `running` state alone cannot prove the firmware prints correctly or that a peripheral is configured correctly. + +## Diagnose a failed run + +| Symptom | What to inspect | +| --- | --- | +| `pb2-m4` is missing | Boot the updated Yocto image; copying an older bundle does not update an installed root filesystem | +| No M4 remote processor | Loaded AM6254 DTB, M4 kernel driver, mailbox, reserved memory, and boot logs | +| Core is `attached` or `detached` | Bootloader ownership; obtain an offline core rather than forcing a live replacement | +| ELF header check fails | Use `zephyr.elf` from the M4 build, not an A53 executable or raw binary | +| Bad program-header address or missing resource table | Correct v4.3.0 board target, unstripped ELF, and matching Linux carveouts | +| Running state but no heartbeat | Adapter RX connected to P2.07, common ground, correct serial device, 115200 8N1, and pin ownership | +| `stop` times out | The pinned kernel waits for a shutdown handshake that the sample does not implement; restart the board for another run | + +For loader failures, inspect the relevant kernel log after attempting the load: + +```bash +dmesg | tail -n 100 +``` + +Do not change DDR addresses, enable the MCU UART in Linux, or reuse a different board's ELF to bypass an error. Match the firmware board target and the image's device tree first. + +## Finish the experiment + +The helper does not enable a startup service or change the default firmware filename. Save any other work, then shut down and power-cycle the development board to end the experiment. Check its remoteproc state on the next boot before reusing the M4. Keep the ELF and source on the development host for future builds. + +## What you have accomplished + +You built a Zephyr application for the AM6254 Cortex-M4F, loaded it through Linux remoteproc, and observed it executing alongside Yocto Linux and Greengrass. You can now extend the heartbeat with a peripheral that Linux explicitly releases to the MCU. Adding RPMsg communication or automatic firmware startup requires further work on shared resources and the firmware lifecycle. diff --git a/content/learning-paths/embedded-and-microcontrollers/yolo26-arm-runtime/_index.md b/content/learning-paths/embedded-and-microcontrollers/yolo26-arm-runtime/_index.md index 048147107f..7f86a0319c 100644 --- a/content/learning-paths/embedded-and-microcontrollers/yolo26-arm-runtime/_index.md +++ b/content/learning-paths/embedded-and-microcontrollers/yolo26-arm-runtime/_index.md @@ -38,33 +38,33 @@ generated_summary_faq: operations for reuse across frames. Finally, you'll export the checkpoint to NCNN and compare latency with the same dataset, input size, batch, and system conditions. - # faqs: - # - question: Does Arm Runtime use the Raspberry Pi 5 CPU or GPU? - # answer: >- - # You run inference on the Raspberry Pi 5 CPU. The runtime uses Cortex-A76 - # cores, a fixed schedule, planned memory reuse, and fused operations. - # - question: How do I run detection on my own video or a PiCamera feed? - # answer: >- - # For a video with at least 200 frames, run `make example-video - # VIDEO=/path/to/your-video.mp4`. For a live PiCamera feed, install the - # camera packages and run `make example-camera`. - # - question: What happens when I create the detector? - # answer: >- - # When you create the detector, the Python session checks the model - # manifest and binary, then loads the shared library. The runtime loads - # the converted model and prepares XNNPACK operations; the example - # reuses the detector across frames. - # - question: Which settings should I match for a fair NCNN comparison? - # answer: >- - # Use Ultralytics 8.4.108 and the same YOLO26n checkpoint, - # `coco-128-by-sa` dataset, 640 × 640 input, and batch size one. Stop - # other CPU workloads and use the same power, cooling, and CPU settings. - # - question: What should I check if the runtimes report different latency or accuracy? - # answer: >- - # Confirm both runs use the same checkpoint, dataset, input size, and - # batch size. Stop other CPU workloads and use matching power, cooling, - # and CPU settings; internal precision and operation fusion can still - # differ between runtimes. + faqs: + - question: Does Arm Runtime use the Raspberry Pi 5 CPU or GPU? + answer: >- + Inference runs on the Raspberry Pi 5 CPU. The runtime uses Cortex-A76 + cores, a fixed schedule, planned memory reuse, and fused operations. + - question: How do I run detection on my own video or a PiCamera feed? + answer: >- + For a video with at least 200 frames, run `make example-video + VIDEO=/path/to/your-video.mp4`. For a live PiCamera feed, install the + camera packages and run `make example-camera`. + - question: What happens when I create the detector? + answer: >- + When you create the detector, the Python session checks the model + manifest and binary, then loads the shared library. The runtime loads + the converted model and prepares XNNPACK operations. The example + reuses the detector across frames. + - question: Which settings should I match for a fair NCNN comparison? + answer: >- + Use Ultralytics 8.4.108 and the same YOLO26n checkpoint, + `coco-128-by-sa` dataset, 640 × 640 input, and batch size one. Stop + other CPU workloads and use the same power, cooling, and CPU settings. + - question: What should I check if the runtimes report different latency or accuracy? + answer: >- + Confirm both runs use the same checkpoint, dataset, input size, and + batch size. Stop other CPU workloads and use matching power, cooling, + and CPU settings. Internal precision and operation fusion can still + differ between runtimes. # END generated_summary_faq author: diff --git a/content/learning-paths/laptops-and-desktops/Implementing-a-Voice-Translation-Pipeline/_index.md b/content/learning-paths/laptops-and-desktops/Implementing-a-Voice-Translation-Pipeline/_index.md index 908db0d4fe..5ca50319c1 100644 --- a/content/learning-paths/laptops-and-desktops/Implementing-a-Voice-Translation-Pipeline/_index.md +++ b/content/learning-paths/laptops-and-desktops/Implementing-a-Voice-Translation-Pipeline/_index.md @@ -38,28 +38,28 @@ generated_summary_faq: translation with Gemma 4 E2B and LiteRT-LM, and speech synthesis with Supertonic 3. Finally, you'll connect these stages in Gradio and verify the transcript, translation, spoken result, and offline operation. -# faqs: -# - question: How do I confirm that my microphone transcription works before adding translation? -# answer: >- -# Run `python stt.py` to record five seconds of audio. Confirm that the transcript contains the -# words you spoke. If it's empty, check the selected microphone and your terminal's permission. -# - question: How do I test Spanish translation before connecting the microphone? -# answer: >- -# Run `python translate.py Spanish` and enter a short English sentence at the prompt. You should -# see the Spanish translation appear as Gemma generates it. -# - question: How do I test text-to-speech and verify audio playback? -# answer: >- -# Run `python tts.py Spanish` and paste a Spanish sentence to synthesize and play speech. If you -# don't hear audio, confirm that macOS has selected your intended output device. -# - question: Which files should exist before launching the Gradio app? -# answer: >- -# Make sure `stt.py`, `translate.py`, `tts.py`, and `languages.py` are in your project directory. -# Then create `app.py` to connect them to a local Gradio interface. -# - question: Can I translate into a language other than Spanish? -# answer: >- -# Yes. Select another language listed in `LANGUAGES`. To add a new supported target language, -# update `LANGUAGES` in `languages.py`. For a non-English source language, you need a different -# speech recognition model and configuration. + faqs: + - question: How do I confirm that my microphone transcription works before adding translation? + answer: >- + Run `python stt.py` to record five seconds of audio. Confirm that the transcript contains the + words you spoke. If it's empty, check the selected microphone and your terminal's permission. + - question: How do I test Spanish translation before connecting the microphone? + answer: >- + Run `python translate.py Spanish` and enter a short English sentence at the prompt. You should + see the Spanish translation appear as Gemma generates it. + - question: How do I test text-to-speech and verify audio playback? + answer: >- + Run `python tts.py Spanish` and paste a Spanish sentence to synthesize and play speech. If you + don't hear audio, confirm that macOS has selected your intended output device. + - question: Which files should exist before launching the Gradio app? + answer: >- + Make sure `stt.py`, `translate.py`, `tts.py`, and `languages.py` are in your project directory. + Then create `app.py` to connect them to a local Gradio interface. + - question: Can I translate into a language other than Spanish? + answer: >- + Yes. Select another language listed in `LANGUAGES`. To add a new supported target language, + update `LANGUAGES` in `languages.py`. For a non-English source language, you need a different + speech recognition model and configuration. # END generated_summary_faq author: Sammy Sahnine diff --git a/content/learning-paths/laptops-and-desktops/_index.md b/content/learning-paths/laptops-and-desktops/_index.md index b35fba6dfd..eb9885daa3 100644 --- a/content/learning-paths/laptops-and-desktops/_index.md +++ b/content/learning-paths/laptops-and-desktops/_index.md @@ -11,11 +11,11 @@ pinned_learning_paths: - dgx_spark_isaac_robotics - learning-paths/cross-platform/multiplying-matrices-with-sme2 operatingsystems_filter: -- Android: 3 +- Android: 4 - ChromeOS: 2 -- Linux: 54 -- macOS: 18 -- Windows: 50 +- Linux: 58 +- macOS: 21 +- Windows: 52 subjects_filter: - Agentic AI: 4 - AI/ML: 16 @@ -29,32 +29,36 @@ tools_software_languages_filter: - Alacritty: 1 - Android Studio: 1 - Arm Development Studio: 1 +- Arm Metis: 1 - Arm Performance Libraries: 2 - Arm64EC: 1 - Assembly: 2 - Bash: 7 -- C: 12 +- C: 13 - CCA: 1 - Clang: 14 - CMake: 6 +- Compute Flow: 1 - CPP: 13 - csharp: 6 - CSS: 1 -- Docker: 13 +- CUDA: 1 +- Docker: 14 - dotnet: 13 -- ExecuTorch: 2 +- ExecuTorch: 3 - FastAPI: 1 - FFmpeg: 1 - GCC: 13 - Gemma 4: 1 - Generative AI: 1 -- Git: 1 +- Git: 2 - GitHub: 3 - GitHub Actions: 1 - GitLab: 2 - Google Benchmark: 1 - Google Test: 1 - Gradio: 1 +- Hermes Agent: 1 - HTML: 2 - Hugging Face: 4 - Hyper-V: 1 @@ -63,6 +67,7 @@ tools_software_languages_filter: - IsaacLab: 2 - IsaacSim: 2 - JavaScript: 2 +- JSON: 1 - KleidiCV: 1 - Kubernetes: 1 - KVM: 1 @@ -80,6 +85,7 @@ tools_software_languages_filter: - MSVC: 1 - MTE: 1 - MuJoCo: 1 +- Muse Glimmer: 1 - Neon: 1 - Neovim: 1 - Node.js: 3 @@ -90,7 +96,7 @@ tools_software_languages_filter: - PGO: 1 - PowerShell: 1 - Pytest: 1 -- Python: 25 +- Python: 28 - PyTorch: 3 - QEMU: 1 - Qt: 2 @@ -101,8 +107,9 @@ tools_software_languages_filter: - RME: 1 - Runbook: 17 - Rust: 2 +- SARIF: 1 - Sherpa-ONNX: 1 -- SME2: 3 +- SME2: 4 - SmolVLA: 2 - SSH: 2 - Supertonic 3: 1 @@ -113,6 +120,7 @@ tools_software_languages_filter: - TorchAO: 1 - Trusted Firmware: 1 - Ubuntu: 1 +- uv: 1 - Visual Studio: 14 - Visual Studio Code: 14 - vLLM: 1 @@ -126,6 +134,4 @@ tools_software_languages_filter: - Xamarin Forms: 1 - XNNPACK: 1 weight: 2 -# auto-generated padding to avoid Hugo YAML alias limit -# auto-generated padding to avoid Hugo YAML alias limit --- diff --git a/content/learning-paths/laptops-and-desktops/dgx_spark_muse_glimmer_executorch_hermes/_index.md b/content/learning-paths/laptops-and-desktops/dgx_spark_muse_glimmer_executorch_hermes/_index.md index 0a7d578551..c3425adb8c 100644 --- a/content/learning-paths/laptops-and-desktops/dgx_spark_muse_glimmer_executorch_hermes/_index.md +++ b/content/learning-paths/laptops-and-desktops/dgx_spark_muse_glimmer_executorch_hermes/_index.md @@ -41,33 +41,33 @@ generated_summary_faq: release-summary image so that Hermes can identify the incorrect deployment decision, inspect the Python checker, and repair it. You'll run all four acceptance tests and review the code diff. Finally, you'll identify ways to extend the agent and add more capabilities. - # faqs: - # - question: How do you use the three SSH sessions? - # answer: >- - # Keep the model server running in the first SSH session. Use the second session to install - # and run Hermes after checking the endpoint. Open a third session temporarily to inspect the - # Docker container, then use it to run the host-side acceptance tests after the agent repair. - # - question: What should you check to confirm Hermes is installed before testing the model connection? - # answer: >- - # Run `~/muse-agent/bin/hermes chat --help`. Expect `Hermes installed` and the CLI help - # output; this confirms the CLI launches. Verify the model connection separately using the - # checks in this section. - # - question: Why do external network calls fail from Hermes tools? - # answer: >- - # Your terminal tool runs inside a Docker container with network access disabled, so external - # calls fail. To verify, inspect the container from your third SSH session and confirm its - # network mode is `none`. - # - question: How do you ask Hermes to interpret the image before it repairs the checker? - # answer: >- - # Start Hermes with `--image "$HOME/muse-agent/release-summary.png"` and ask it to report the - # passed, failed, and skipped counts, the displayed decision, and whether deployment should - # proceed. Tell it not to run tools or change files yet. Then use the image as context and ask - # it to diagnose and repair `/demo/output/release_tool.py`. - # - question: What should you expect after Hermes repairs the release checker? - # answer: >- - # Expect all four acceptance tests to pass and print `OK`. Read - # `~/muse-agent/demo/output/fix-notes.md` and inspect the diff to confirm that the notes match - # the code and test output. Confirm that failed tests block deployment. + faqs: + - question: How do I use the three SSH sessions? + answer: >- + Keep the model server running in the first SSH session. Use the second session to install + and run Hermes after checking the endpoint. Open a third session temporarily to inspect the + Docker container, then use it to run the host-side acceptance tests after the agent repair. + - question: What should I check to confirm Hermes is installed before testing the model connection? + answer: >- + Run `~/muse-agent/bin/hermes chat --help`. Expect `Hermes installed` and the CLI help + output. This confirms that the CLI launches. + - question: Why do external network calls fail from Hermes tools? + answer: >- + Your terminal tool runs inside a Docker container with network access disabled, so external + calls fail. To verify, inspect the container from your third SSH session and confirm its + network mode is `none`. + - question: How do I ask Hermes to interpret the image before it repairs the checker? + answer: >- + Start Hermes with `--image "$HOME/muse-agent/release-summary.png"` and ask it to report the + passed, failed, and skipped counts, the displayed decision, and whether deployment should + proceed. Tell it not to run tools or change files yet. Then use the image as context and ask + it to diagnose and repair `/demo/output/release_tool.py`. + - question: How do I verify a Hermes repair of the release checker? + answer: >- + Run all four acceptance tests and check for `OK`. If any test fails, use its output to + revise the repair and run the tests again. Read `~/muse-agent/demo/output/fix-notes.md` + and inspect the diff to confirm that the notes match the code and test output. + Confirm that failed tests block deployment. # END generated_summary_faq author: Matt Cossins diff --git a/content/learning-paths/laptops-and-desktops/disassemble-arm64-binaries/_index.md b/content/learning-paths/laptops-and-desktops/disassemble-arm64-binaries/_index.md index 039ebe3203..03c87d8427 100644 --- a/content/learning-paths/laptops-and-desktops/disassemble-arm64-binaries/_index.md +++ b/content/learning-paths/laptops-and-desktops/disassemble-arm64-binaries/_index.md @@ -33,28 +33,28 @@ generated_summary_faq: faq_source_hash: a97a3dc25f0e6079af133571a970e3ac8a2587589c0ad21e7db60d99f72f2230 summary: >- You'll build a small arm64 Mach-O fixture on macOS. Then, you'll use `otool` and `llvm-objdump` to inspect it for SME and SME2 instructions. You'll compare strings and symbols with decoded executable code, checking instruction bytes, operands, addresses, and surrounding context. You'll also test comparison binaries, then combine the `llvm-objdump` and `awk` checks in a reusable script. - # faqs: - # - question: How do I know I'm inspecting the correct architecture slice? - # answer: >- - # Select the `arm64` slice when you inspect a universal Mach-O binary. Use options such as - # `-arch arm64` with `otool`, `strings`, and `nm`, and confirm the slice with `lipo -info`. - # - question: Do SME2-related strings or symbols prove that the binary contains SME2 instructions? - # answer: >- - # No. Strings and symbol names can suggest that the program relates to SME2, but that alone - # doesn't establish that SME or SME2 instructions are present. Inspect decoded executable code instead. - # - question: How can I confirm that a decoded instruction matches its encoding? - # answer: >- - # Compare the instruction bytes, mnemonic, operands, and address in `llvm-objdump` output. - # Cross-check the decoded instruction and address with `otool` for the same binary. - # - question: What does finding SME2 instructions in the binary tell me about runtime behavior? - # answer: >- - # It confirms that the instructions are present in the inspected executable code. It doesn't - # show whether the application calls that code or whether running it improves performance. - # - question: How do I use the verification script with a comparison binary? - # answer: >- - # Put `verify-static-sme2.sh`, `strict-sme2.awk`, and the compiled binaries in the working - # directory. Run the script with the binary name; the positive fixture should pass, while - # the string-only control should report no matching instructions. + faqs: + - question: How do I know that I'm inspecting the correct architecture slice? + answer: >- + Select the `arm64` slice when you inspect a universal Mach-O binary. Use options such as + `-arch arm64` with `otool`, `strings`, and `nm`, and confirm the slice with `lipo -info`. + - question: Do SME2-related strings or symbols prove that the binary contains SME2 instructions? + answer: >- + No. Strings and symbol names can suggest that the program relates to SME2. However, they alone + don't establish that SME or SME2 instructions are present. Inspect decoded executable code instead. + - question: How can I confirm that a decoded instruction matches its encoding? + answer: >- + Compare the instruction bytes, mnemonic, operands, and address in `llvm-objdump` output. + Cross-check the decoded instruction and address with `otool` for the same binary. + - question: What does finding SME2 instructions in the binary tell me about runtime behavior? + answer: >- + It confirms that the instructions are present in the inspected executable code. It doesn't + show whether the application calls that code or whether running it improves performance. + - question: How do I use the verification script with a comparison binary? + answer: >- + Put `verify-static-sme2.sh`, `strict-sme2.awk`, and the compiled binaries in the working + directory. Run the script with the binary name. The positive fixture should pass, while + the string-only control should report no matching instructions. # END generated_summary_faq author: Geremy Cohen diff --git a/content/learning-paths/mobile-graphics-and-gaming/_index.md b/content/learning-paths/mobile-graphics-and-gaming/_index.md index 2c290f5c54..7aedf5e7eb 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/_index.md +++ b/content/learning-paths/mobile-graphics-and-gaming/_index.md @@ -13,13 +13,13 @@ pinned_learning_paths: - gemma4-kleidiai-sme2 - nfru-unreal operatingsystems_filter: -- Android: 59 -- Linux: 56 -- macOS: 27 -- Windows: 26 +- Android: 62 +- Linux: 58 +- macOS: 30 +- Windows: 27 subjects_filter: - Agentic AI: 0 -- AI/ML: 50 +- AI/ML: 51 - Gaming: 6 - Graphics: 11 - Performance and Architecture: 39 @@ -29,10 +29,12 @@ tools_software_languages_filter: - 7-Zip: 1 - ADB: 1 - adb: 2 +- Agent Skills: 1 - Android: 6 - Android NDK: 4 - Android SDK: 1 - Android Studio: 20 +- Antigravity: 1 - Arm AI Portal: 9 - Arm Development Studio: 1 - Arm Mobile Studio: 1 @@ -41,10 +43,12 @@ tools_software_languages_filter: - Bash: 2 - Bazel: 2 - C: 7 +- C++: 1 - CameraX: 1 - CCA: 1 - Clang: 13 - CMake: 6 +- Compute Flow: 1 - CPP: 22 - csharp: 3 - Docker: 2 @@ -56,6 +60,7 @@ tools_software_languages_filter: - Generative AI: 3 - glslc: 1 - Godot: 1 +- Google Cloud: 1 - Google Pixel 8: 1 - Google Test: 1 - Gradio: 1 @@ -63,16 +68,17 @@ tools_software_languages_filter: - Hugging Face: 16 - Java: 13 - Jupyter Notebook: 3 -- KleidiAI: 11 +- KleidiAI: 12 - Kotlin: 14 - LiteRT: 6 - LiteRT-LM: 1 -- llama.cpp: 5 +- llama.cpp: 6 - LLM: 3 - LLVM: 2 - llvm-mca: 1 - MCP: 1 - MediaPipe: 3 +- ML Drift: 1 - MLIA: 3 - Model Explorer: 3 - MTE: 2 @@ -80,8 +86,9 @@ tools_software_languages_filter: - NX: 14 - ONNX: 1 - ONNX Runtime: 5 +- OpenCL: 1 - OpenGL ES: 1 -- Python: 22 +- Python: 23 - PyTorch: 9 - QEMU: 1 - RenderDoc: 1 @@ -90,8 +97,8 @@ tools_software_languages_filter: - Rust: 2 - SDDiskTool: 1 - SME: 1 -- SME2: 14 -- Streamline: 2 +- SME2: 15 +- Streamline: 3 - SVE2: 4 - TensorFlow: 1 - Topo: 1 @@ -101,6 +108,7 @@ tools_software_languages_filter: - Trusted Firmware: 1 - Unity: 6 - Unreal Engine: 9 +- uv: 1 - VGF: 5 - Visual Studio: 4 - Visual Studio Code: 2 @@ -113,7 +121,4 @@ weight: 3 # auto-generated padding to avoid Hugo YAML alias limit # auto-generated padding to avoid Hugo YAML alias limit # auto-generated padding to avoid Hugo YAML alias limit -# auto-generated padding to avoid Hugo YAML alias limit -# auto-generated padding to avoid Hugo YAML alias limit -# auto-generated padding to avoid Hugo YAML alias limit --- diff --git a/content/learning-paths/mobile-graphics-and-gaming/ai-portal-mobile-image-classification/3-run-model.md b/content/learning-paths/mobile-graphics-and-gaming/ai-portal-mobile-image-classification/3-run-model.md index b155b0ee3a..e897d3f4d6 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ai-portal-mobile-image-classification/3-run-model.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ai-portal-mobile-image-classification/3-run-model.md @@ -22,7 +22,7 @@ The following commands use three default models. To use a different supported AI {{% notice Note %}} Arm AI Portal models are hosted on Hugging Face. The `download_model.py` script uses `huggingface_hub` and connects to `https://huggingface.co` by default. -MobileNetV3 Small ExecuTorch and CLIP both publish a file named `optimized.pte`, so the script gives those two files unique names when it downloads them. +Some models publish model packages with the same filename, so the download script gives those files unique names. {{% /notice %}} ## Run MobileNetV3 Small with LiteRT @@ -181,7 +181,10 @@ The application ranks only the descriptions that you enter. Change the descripti ## Use another supported model -The three default models keep the main workflow predictable. The application also supports the following Arm AI Portal model packages: +The three default models keep the main workflow predictable. The application also supports the following Arm AI Portal model packages. + +
+Show all 22 supported models | Model | Runtime | Repository ID | Import this file | Behavior | | --- | --- | --- | --- | --- | @@ -199,6 +202,16 @@ The three default models keep the main workflow predictable. The application als | [Swin Tiny ExecuTorch](https://huggingface.co/Arm/swin-tiny-int8-xnnpack-executorch) | ExecuTorch | `Arm/swin-tiny-int8-xnnpack-executorch` | `swin_tiny_dynamic_raspberry_executorch_optimized.pte` | Ranks 1,000 ImageNet classes | | [ViT Base ExecuTorch](https://huggingface.co/Arm/vit-base-int8-xnnpack-executorch) | ExecuTorch | `Arm/vit-base-int8-xnnpack-executorch` | `google__vit-base-patch16-224_raspberry_executorch_optimized.pte` | Ranks 1,000 ImageNet classes | | [CLIP ViT-B/32 ExecuTorch](https://huggingface.co/Arm/clip-vit-base-patch32-int8-xnnpack-executorch) (default) | ExecuTorch | `Arm/clip-vit-base-patch32-int8-xnnpack-executorch` | `clip-vit-base-patch32-int8-executorch.pte` | Ranks descriptions that you enter | +| [Wide ResNet-50 ExecuTorch](https://huggingface.co/Arm/wideresnet50-int8-xnnpack-executorch-vivo-x300) | ExecuTorch | `Arm/wideresnet50-int8-xnnpack-executorch-vivo-x300` | `wideresnet50-int8-executorch-vivo-x300.pte` | Ranks 1,000 ImageNet classes | +| [Inception V3 ExecuTorch](https://huggingface.co/Arm/inception-v3-int8-xnnpack-executorch-vivo-x300) | ExecuTorch | `Arm/inception-v3-int8-xnnpack-executorch-vivo-x300` | `inception-v3-int8-executorch-vivo-x300.pte` | Ranks 1,000 ImageNet classes | +| [EfficientNet-B4 ExecuTorch](https://huggingface.co/Arm/efficientnet-b4-int8-xnnpack-executorch-vivo-x300) | ExecuTorch | `Arm/efficientnet-b4-int8-xnnpack-executorch-vivo-x300` | `efficientnet-b4-int8-executorch-vivo-x300.pte` | Ranks 1,000 ImageNet classes | +| [SqueezeNet 1.0 ExecuTorch](https://huggingface.co/Arm/squeezenet-1-0-int8-xnnpack-executorch-vivo-x300) | ExecuTorch | `Arm/squeezenet-1-0-int8-xnnpack-executorch-vivo-x300` | `squeezenet-1-0-int8-executorch-vivo-x300.pte` | Ranks 1,000 ImageNet classes | +| [DeiT-Tiny (Nota) ExecuTorch](https://huggingface.co/Arm/nota-deit-tiny-int8-xnnpack-executorch-vivo-x300) | ExecuTorch | `Arm/nota-deit-tiny-int8-xnnpack-executorch-vivo-x300` | `nota-deit-tiny-int8-executorch-vivo-x300.pte` | Ranks 1,000 ImageNet classes | +| [Swin-T ExecuTorch](https://huggingface.co/Arm/swin-t-int8-xnnpack-executorch-vivo-x300) | ExecuTorch | `Arm/swin-t-int8-xnnpack-executorch-vivo-x300` | `swin-t-int8-executorch-vivo-x300.pte` | Ranks 1,000 ImageNet classes | +| [ViT-B/16 ExecuTorch](https://huggingface.co/Arm/vit-b-16-int8-xnnpack-executorch-vivo-x300) | ExecuTorch | `Arm/vit-b-16-int8-xnnpack-executorch-vivo-x300` | `vit-b-16-int8-executorch-vivo-x300.pte` | Ranks 1,000 ImageNet classes | +| [GoogLeNet (Nota) ExecuTorch](https://huggingface.co/Arm/nota-googlenet-int8-xnnpack-executorch-vivo-x300) | ExecuTorch | `Arm/nota-googlenet-int8-xnnpack-executorch-vivo-x300` | `nota-googlenet-int8-executorch-vivo-x300.pte` | Ranks 1,000 ImageNet classes | + +
Set `MODEL_ID` to a repository ID from the table and repeat the matching download and import workflow. diff --git a/content/learning-paths/mobile-graphics-and-gaming/ai-portal-mobile-image-classification/4-understand-app.md b/content/learning-paths/mobile-graphics-and-gaming/ai-portal-mobile-image-classification/4-understand-app.md index 45b9cbc597..1688ff9a35 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ai-portal-mobile-image-classification/4-understand-app.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ai-portal-mobile-image-classification/4-understand-app.md @@ -77,15 +77,22 @@ Model-specific preprocessing is important because a model can load and run with ### How Photo Insight runs an ExecuTorch classifier -`ExecuTorchImageClassificationAdapter.java` selects one of three preprocessing profiles for the imported model. It creates `ExecuTorchImageClassifier.java`, which memory-maps the `.pte` file, loads the `forward` method, and checks that the program declares the XNNPACK backend. +`ExecuTorchImageClassificationAdapter.java` selects the preprocessing profile registered for the imported model. It creates `ExecuTorchImageClassifier.java`, which memory-maps the `.pte` file, loads the `forward` method, and checks that the program declares the XNNPACK backend. The supported ExecuTorch classifiers share one execution contract: a float32 RGB tensor in `NCHW` layout and one float32 output tensor with shape `[1, 1000]`. Their preprocessing differs: | Profile | Resize and crop | Normalization | Current models | | --- | --- | --- | --- | -| `IMAGENET_CROP_256` | Resize the shorter edge to 256, then center-crop to `224 × 224` | ImageNet mean and standard deviation | DEiT Tiny, GoogLeNet, MobileNetV3 Small, ResNet-18, ResNet-50, ShuffleNet V2, SqueezeNet 1.1 | -| `IMAGENET_CROP_232` | Resize the shorter edge to 232, then center-crop to `224 × 224` | ImageNet mean and standard deviation | Swin Tiny | -| `SYMMETRIC_DIRECT_RESIZE` | Resize directly to `224 × 224` | Mean `0.5`, standard deviation `0.5` | ViT Base | +| `IMAGENET_CROP_256` | Bicubic resize of the shorter edge to 256, then center-crop to `224 × 224` | ImageNet mean and standard deviation | DEiT Tiny, GoogLeNet, MobileNetV3 Small, ResNet-18, ResNet-50, ShuffleNet V2, SqueezeNet 1.1 | +| `IMAGENET_BILINEAR_CROP_256` | Bilinear resize of the shorter edge to 256, then center-crop to `224 × 224` | ImageNet mean and standard deviation | Wide ResNet-50, SqueezeNet 1.0, ViT-B/16, GoogLeNet (Nota) | +| `IMAGENET_CROP_232` | Bicubic resize of the shorter edge to 232, then center-crop to `224 × 224` | ImageNet mean and standard deviation | Swin Tiny | +| `IMAGENET_CROP_384` | Bicubic resize of the shorter edge to 384, then center-crop to `384 × 384` | ImageNet mean and standard deviation | EfficientNet-B4 | +| `IMAGENET_DIRECT_RESIZE` | Bicubic resize directly to `224 × 224` | ImageNet mean and standard deviation | Swin-T | +| `SYMMETRIC_CROP_341` | Bicubic resize of the shorter edge to 341, then center-crop to `299 × 299` | Mean `0.5`, standard deviation `0.5` | Inception V3 | +| `SYMMETRIC_DIRECT_RESIZE` | Bicubic resize directly to `224 × 224` | Mean `0.5`, standard deviation `0.5` | ViT Base | +| `SYMMETRIC_BILINEAR_DIRECT_RESIZE` | Bilinear resize directly to `224 × 224` | Mean `0.5`, standard deviation `0.5` | DeiT-Tiny (Nota) | + +Profiles use the preprocessing configuration published with the model, or the linked upstream model's evaluation settings when the package doesn't include one. Model-specific resizing, cropping, and normalization matter even when two models have the same input shape. After one `forward` call, the classifier applies softmax, selects the five highest scores, and maps them to the ImageNet label file bundled with the application. diff --git a/content/learning-paths/mobile-graphics-and-gaming/ai-portal-mobile-object-detection/3-run-model.md b/content/learning-paths/mobile-graphics-and-gaming/ai-portal-mobile-object-detection/3-run-model.md index c29ae2f4e3..cd4eda62c9 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ai-portal-mobile-object-detection/3-run-model.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ai-portal-mobile-object-detection/3-run-model.md @@ -23,6 +23,8 @@ Start with YOLOv8s because it provides the shortest path to a result. You can us {{% notice Note %}} Arm AI Portal models are hosted on Hugging Face. The `download_model.py` script uses `huggingface_hub` and connects to `https://huggingface.co` by default. + +Some packages publish generic filenames, so the downloader gives those files unique import names. {{% /notice %}} ## Run YOLOv8s with ExecuTorch @@ -176,11 +178,12 @@ Scene Detector also supports the following Arm AI Portal model packages: | [YOLOv5s INT8](https://huggingface.co/Arm/yolov5s-int8-xnnpack-executorch) | ExecuTorch | `Arm/yolov5s-int8-xnnpack-executorch` | `yolov5s_raspberry_executorch_optimized.pte` | YOLOv5 objectness and class scores | | [YOLOv8s INT8](https://huggingface.co/Arm/yolov8s-int8-xnnpack-executorch) (default) | ExecuTorch | `Arm/yolov8s-int8-xnnpack-executorch` | `yolov8s_raspberry_executorch_optimized.pte` | YOLOv8 candidate decoding | | [YOLOv9s INT8](https://huggingface.co/Arm/yolov9s-int8-xnnpack-executorch) | ExecuTorch | `Arm/yolov9s-int8-xnnpack-executorch` | `yolov9s_raspberry_executorch_optimized.pte` | Letterboxing and multi-label decoding | +| [YOLOX-S INT8](https://huggingface.co/Arm/nota-yolox-s-int8-xnnpack-executorch-vivo-x300) | ExecuTorch | `Arm/nota-yolox-s-int8-xnnpack-executorch-vivo-x300` | `yolox-s-int8-executorch.pte` | Top-left letterboxing and separate prediction heads | | [YOLO26n FP16](https://huggingface.co/Arm/yolo26n-fp16-litert) | LiteRT | `Arm/yolo26n-fp16-litert` | `yolo26n_conv2d_f16_weights.tflite` | Forced FP16 execution and six-value detection rows | | [YOLO26n INT8 weight-only](https://huggingface.co/Arm/yolo26n-int8w-litert) | LiteRT | `Arm/yolo26n-int8w-litert` | `yolo26n_conv_fc_f16_int8w.tflite` | INT8 weights, FP16 execution, and six-value detection rows | | [YOLO11n INT8](https://huggingface.co/Arm/yolo11n-int8-litert-vivo-x300) | LiteRT | `Arm/yolo11n-int8-litert-vivo-x300` | `yolo11n_android_litert_optimized.tflite` | INT8 input and `[1, 84, 8400]` multi-label decoding | -To use one of these models, set `MODEL_ID` to a repository ID from the table and repeat the download and import workflow. +To use one of these models, set `MODEL_ID` to a repository ID from the table and repeat the download and import workflow. The registered profile sets the default confidence threshold: `75%` for YOLOv5s, YOLOv8s, and YOLOv9s, and `25%` for YOLOX-S and the LiteRT models. ## What you've accomplished and what's next diff --git a/content/learning-paths/mobile-graphics-and-gaming/ai-portal-mobile-object-detection/4-understand-app.md b/content/learning-paths/mobile-graphics-and-gaming/ai-portal-mobile-object-detection/4-understand-app.md index 631c256ea3..a954bb9f62 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/ai-portal-mobile-object-detection/4-understand-app.md +++ b/content/learning-paths/mobile-graphics-and-gaming/ai-portal-mobile-object-detection/4-understand-app.md @@ -19,7 +19,7 @@ Models share an adapter when they use the same runtime, import flow, confidence ### How Scene Detector resolves and validates the model -`ModelRegistry.java` records the exact filename, model name, and runtime label for each package. It also records adapter ID, detector configuration, and default confidence threshold. `ModelImporter.java` rejects unregistered filenames and files larger than 700 MB. +`ModelRegistry.java` records the exact filename, model name, and runtime label for each package. It also records adapter ID, detector configuration, and default confidence threshold. `ModelImporter.java` rejects unregistered filenames and files larger than 700 MB. The downloader assigns unique import names when a package publishes a generic filename, such as `model.pte`. The importer copies the file to temporary application-private storage. It then asks the adapter named by the descriptor to create and close a runner before the file replaces the installed model. @@ -54,29 +54,31 @@ The detector profiles isolate the parts that differ: | Strategy | Supplied models | Main responsibility | | --- | --- | --- | | `ExecuTorchYoloDetector.java` | YOLOv5s, YOLOv8s, and YOLOv9s | Select the matching YOLO input and output profile | +| `ExecuTorchYoloxDetector.java` | YOLOX-S | Prepare BGR input and decode separate prediction heads | | `LiteRtYoloDetector.java` | YOLO11n and YOLO26n | Select input precision, XNNPACK flags, and output decoding | ### How Scene Detector prepares and decodes YOLO models -`ExecuTorchYoloDetector.java` selects a profile from the descriptor. The three YOLO models share a float32 RGB tensor with shape `[1, 3, 640, 640]`, but they don't share the complete input and output contract. +`ExecuTorchYoloDetector.java`, `ExecuTorchYoloxDetector.java`, and `LiteRtYoloDetector.java` implement the registered detector profiles. The ExecuTorch models accept float32 tensors with shape `[1, 3, 640, 640]`. Their channel order, pixel range, image preparation, and outputs depend on the profile. -The following table compares output, score calculation, and non-maximum suppression (NMS) intersection-over-union (IoU) between the three YOLO models: +The following table compares image preparation, output, score calculation, and non-maximum suppression (NMS) intersection-over-union (IoU) between the profiles: | Profile | Image preparation | Output | Score calculation | NMS IoU | | --- | --- | --- | --- | --- | | YOLOv5 | Resize directly to `640 × 640`, values in `[0, 1]` | `[1, 25200, 85]` | Objectness × best class score | `0.45` | | YOLOv8 | Resize directly to `640 × 640`, values in `[0, 1]` | `[1, 84, N]` | Best class score | `0.45` | | YOLOv9 | Letterbox to `640 × 640`, padding with `114/255` | `[1, 84, 8400]` | Every class score above the threshold | `0.70` | +| YOLOX-S | Letterbox to `640 × 640`, top-left anchored, BGR values in `[0, 255]`, padding with `114` | Nine tensors: box `[1, 4, H, W]`, objectness `[1, 1, H, W]`, and class `[1, 80, H, W]` at `H = W = 80, 40, 20` | Sigmoid objectness × sigmoid best class logit | `0.65` | | YOLO26 | Letterbox to `640 × 640`, padding with `114/255` | `[1, 300, 6]` | Confidence supplied in each detection row | `0.40` | | YOLO11 | Letterbox to `640 × 640`, padding with `114/255`, then quantize to INT8 | `[1, 84, 8400]` | Every class score above the threshold | `0.70` | Direct resizing changes the image aspect ratio. The application scales the decoded coordinates independently across width and height to return to the original image. -Letterboxing preserves the aspect ratio. The application records the resize scale and padding, subtracts the padding from each decoded box, then divides by the scale. +Letterboxing preserves the aspect ratio. The application records the resize scale and padding, subtracts the padding from each decoded box, then divides by the scale. YOLOX-S anchors the resized image at the top left, so padding appears only below and to the right and the coordinate offsets are zero. ### How Scene Detector runs an ExecuTorch detector -The supplied YOLO detector memory-maps the imported `.pte` file, loads its `forward` method, and checks that the method declares the XNNPACK backend. It converts the prepared bitmap to a channels-first float array and runs one inference call. +The supplied ExecuTorch detectors memory-map the imported `.pte` file, load its `forward` method, and check that the method declares the XNNPACK backend. Each detector converts the prepared bitmap to a channels-first float array and runs one inference call. The model packages use INT8-quantized operations internally, but their application input and output tensors are float32. Quantization is part of the exported graph rather than an instruction to pass an INT8 bitmap from Java. @@ -90,9 +92,11 @@ YOLO26 accepts a float32 channels-first input and returns 300 six-value detectio YOLOv5, YOLOv8, YOLOv9, and YOLO11 output box coordinates as center `x`, center `y`, width, and height. The detector converts these values to left, top, right, and bottom coordinates. YOLO26 already returns left, top, right, and bottom coordinates. -YOLOv5 includes a separate objectness value. YOLOv8 and YOLOv9 don't. YOLOv9 also uses multi-label decoding, so one candidate can produce more than one class entry before filtering. +YOLOv5 and YOLOX-S include a separate objectness value. YOLOv8 and YOLOv9 don't. YOLOv9 also uses multi-label decoding, so one candidate can produce more than one class entry before filtering. -The application applies a sigmoid only when a score falls outside `[0, 1]`, which indicates that the package returned logits rather than probabilities. +YOLOX-S returns raw prediction heads at strides 8, 16, and 32. Its detector adds each cell's grid position to the predicted center offsets and multiplies by the stride. It exponentiates predicted widths and heights and multiplies them by the stride. It applies sigmoid to the objectness and class logits, multiplies objectness by the highest class probability, and maps retained boxes back to the original image. + +The YOLOv5, YOLOv8, YOLOv9, and LiteRT profiles apply sigmoid only when scores fall outside `[0, 1]`, indicating logits rather than probabilities. YOLOX-S always applies sigmoid because its separate prediction heads contain logits. ### How Scene Detector handles duplicate detections diff --git a/content/learning-paths/mobile-graphics-and-gaming/gemma4-kleidiai-sme2/_index.md b/content/learning-paths/mobile-graphics-and-gaming/gemma4-kleidiai-sme2/_index.md index 5977aa925c..e846718992 100755 --- a/content/learning-paths/mobile-graphics-and-gaming/gemma4-kleidiai-sme2/_index.md +++ b/content/learning-paths/mobile-graphics-and-gaming/gemma4-kleidiai-sme2/_index.md @@ -38,33 +38,33 @@ generated_summary_faq: and four CPU threads and compare prefill and decode throughput. Finally, you'll check the model response and use a separate profiled run to verify the accelerated operator. -# faqs: -# - question: How do I know my Mac supports SME2 before I start building? -# answer: >- -# Run `uname -m`, `sysctl hw.optional.arm.FEAT_SME`, and `sysctl hw.optional.arm.FEAT_SME2`. -# On a supported Apple M4 system, expect `arm64` and a value of `1` for both feature flags. -# If either flag reports `0`, the macOS performance comparison isn't valid. -# - question: Where should the Gemma 4 LiteRT-LM model land, and what files should I see after -# download? -# answer: >- -# You'll find the model under `$HOME/gemma4-prefill-bench/models/` in the -# `gemma-4-E2B-it-litert-lm/` directory. Verify that it contains -# `gemma-4-E2B-it.litertlm` using the checksum command in the download step. -# - question: Where do the build outputs and benchmark results get written so I can review them? -# answer: >- -# Look under `$HOME/gemma4-prefill-bench/`: `bazel-output-base/` holds Bazel state, -# `bin/` holds the saved binaries, and `results/` holds benchmark logs and metrics. -# - question: How do I compare the baseline and optimized XNNPACK variants correctly? -# answer: >- -# Run both variants with the provided function, using the same model and settings at one and -# four CPU threads. For each build and thread count, discard the first iteration as warm-up, -# then average `Prefill Speed` and `Decode Speed` from the second and third iterations separately. -# - question: What should I check if the throughput numbers look off or don’t match between runs? -# answer: >- -# Check that both variants use the same model, thread counts, and benchmark settings, with -# caches and profiling disabled for timed runs. To verify the optimized kernel, run the separate -# short benchmark with profiling enabled and look for `Fully Connected (NC, PQS8, QC2W)` in its -# summary. Results can vary by device and conditions. + faqs: + - question: How do I know that my Mac supports SME2? + answer: >- + Run `uname -m`, `sysctl hw.optional.arm.FEAT_SME`, and `sysctl hw.optional.arm.FEAT_SME2`. + On a supported Apple M4 system, expect `arm64` and a value of `1` for both feature flags. + If either flag reports `0`, the macOS performance comparison isn't valid. + - question: Where should the Gemma 4 LiteRT-LM model land, and what files should I see after + download? + answer: >- + You'll find the model under `$HOME/gemma4-prefill-bench/models/` in the + `gemma-4-E2B-it-litert-lm/` directory. Verify that it contains + `gemma-4-E2B-it.litertlm` using the checksum command in the download step. + - question: Where do the build outputs and benchmark results get written so I can review them? + answer: >- + Look under `$HOME/gemma4-prefill-bench/`: `bazel-output-base/` holds Bazel state, + `bin/` holds the saved binaries, and `results/` holds benchmark logs and metrics. + - question: How do I compare the baseline and optimized XNNPACK variants correctly? + answer: >- + Run both variants with the provided function, using the same model and settings at one and + four CPU threads. For each build and thread count, discard the first iteration as warm-up. + Average `Prefill Speed` and `Decode Speed` from the second and third iterations separately. + - question: What should I check if the throughput numbers look off or don’t match between runs? + answer: >- + Check that both variants use the same model, thread counts, and benchmark settings, with + caches and profiling disabled for timed runs. To verify the optimized kernel, run the separate + short benchmark with profiling enabled and look for `Fully Connected (NC, PQS8, QC2W)` in its + summary. Results can vary by device and conditions. # END generated_summary_faq author: Annie Tallund diff --git a/content/learning-paths/mobile-graphics-and-gaming/google-ddp-get-started/3-use-agent.md b/content/learning-paths/mobile-graphics-and-gaming/google-ddp-get-started/3-use-agent.md index 26f39e7495..010e53ea28 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/google-ddp-get-started/3-use-agent.md +++ b/content/learning-paths/mobile-graphics-and-gaming/google-ddp-get-started/3-use-agent.md @@ -85,7 +85,7 @@ adb -s localhost:51795 shell getprop ro.product.cpu.abi ## Review what Antigravity handled -Your request gave Antigravity a device, an outcome, and spending limits. Antigravity translated that into device discovery, a reservation, a connection, and a working screen. Its report should include the session expiration and the location of a saved screenshot. The report should also include enough device information to confirm that Antigraviity connected to the phone that you approved. +Your request gave Antigravity a device, an outcome, and spending limits. Antigravity translated that into device discovery, a reservation, a connection, and a working screen. Its report should include the session expiration and the location of a saved screenshot. The report should also include enough device information to confirm that Antigravity connected to the phone that you approved. Keep the same `agy` session open for the Arm performance experiment that you'll perform next. Antigravity will use this connection to install the tools, choose compatible Arm optimizations, measure their effect, and release the phone. diff --git a/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/_index.md b/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/_index.md new file mode 100644 index 0000000000..1fa93c0238 --- /dev/null +++ b/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/_index.md @@ -0,0 +1,58 @@ +--- +title: Run and Profile ML Drift on Arm Mali GPUs + +draft: true +cascade: + draft: true + +description: Build and run Stable Diffusion on an Android Mali GPU with ML Drift, inspect a unified shader, and profile GPU activity with Arm Streamline. +minutes_to_complete: 30 +lastmod: 2026-10-30 +who_is_this_for: GPU and system engineers who want to explore ML Drift and its unified shaders for GPU-accelerated workloads in custom graphics and inference runtimes. +learning_objectives: + - Build and run Stable Diffusion on an Android device with an Arm Mali GPU + - Capture and inspect Mali GPU activity with Arm Streamline +prerequisites: + - An Android device with an Arm Mali GPU + - Android Studio + - Arm Performance Studio + - Familiarity with C++ and command-line tools +author: Kieran Hejmadi + +generate_summary_faq: true +rerun_summary: false +rerun_faqs: false + +### Tags +skilllevels: Introductory +subjects: AI/ML +armips: + - Mali +tools_software_languages: + - C++ + - OpenCL + - ML Drift + - Streamline +operatingsystems: + - macOS + - Android +further_reading: + - resource: + title: ML Drift launch announcement + link: https://developers.googleblog.com/ml-drift-next-gen-gpu-aiml-inference-at-the-edge/ + type: blog + - resource: + title: ML Drift source repository + link: https://github.com/google-ai-edge/ml-drift + type: code + - resource: + title: Arm Streamline User Guide + link: https://support.arm.com/documentation/101816/latest/ + type: documentation + +### FIXED, DO NOT MODIFY +# ================================================================================ +weight: 1 # _index.md always has weight of 1 to order correctly +layout: "learningpathall" # All files under learning paths have this same wrapper +learning_path_main_page: "yes" # This should be surfaced when looking for related content. Only set for _index.md of learning path content. +--- diff --git a/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/_next-steps.md b/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/_next-steps.md new file mode 100644 index 0000000000..727b395ddd --- /dev/null +++ b/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/_next-steps.md @@ -0,0 +1,8 @@ +--- +# ================================================================================ +# FIXED, DO NOT MODIFY THIS FILE +# ================================================================================ +weight: 21 # The weight controls the order of the pages. _index.md always has weight 1. +title: "Next Steps" # Always the same, html page title. +layout: "learningpathall" # All files under learning paths have this same wrapper for Hugo processing. +--- diff --git a/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/add_debug_image.png b/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/add_debug_image.png new file mode 100644 index 0000000000..9d03dbb78a Binary files /dev/null and b/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/add_debug_image.png differ diff --git a/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/export_streamline_configuration.png b/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/export_streamline_configuration.png new file mode 100644 index 0000000000..cad9b4e0b6 Binary files /dev/null and b/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/export_streamline_configuration.png differ diff --git a/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/functions_tab.png b/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/functions_tab.png new file mode 100644 index 0000000000..aea636e0fb Binary files /dev/null and b/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/functions_tab.png differ diff --git a/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/mali-timeline.png b/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/mali-timeline.png new file mode 100644 index 0000000000..6bfd1d4716 Binary files /dev/null and b/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/mali-timeline.png differ diff --git a/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/profile.md b/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/profile.md new file mode 100644 index 0000000000..bf2a8c6b1a --- /dev/null +++ b/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/profile.md @@ -0,0 +1,127 @@ +--- +title: Profile GPU Activity +weight: 5 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +ML Drift’s unified shaders let you reuse computation across supported GPU backends, while performance still depends on the GPU architecture, driver, and workload. In this section, use Arm Streamline to see how the OpenCL sample uses Mali GPU resources. + +## Build with debug symbols + +Build the Android arm64 sample with release optimizations and debug symbols. This preserves runtime performance while providing function names and source mappings for Streamline analysis. + +```bash +bazel build -c opt --config=android_arm64 \ + --copt=-g \ + --strip=never \ + //ml_drift/samples/stable_diffusion:sd_gpu_opencl +``` + +Copy the debug executable to your Android device then make it runnable: + +```bash +adb push bazel-bin/ml_drift/samples/stable_diffusion/sd_gpu_opencl \ + /data/local/tmp/sd_gpu_opencl + +adb shell chmod +x /data/local/tmp/sd_gpu_opencl +``` + +## Deploy the profiling agent + +Set `STREAMLINE` to your Streamline installation directory. This example uses macOS; on x86 Linux, replace the path with your installation directory: + +```bash +export STREAMLINE="/Applications/Arm Performance Studio 2026.5/streamline" +``` + +Copy the Android arm64 profiling agent, `gatord`, to your device and make it runnable: + +```bash +adb push "$STREAMLINE/bin/android/arm64/gatord" /data/local/tmp/ +adb shell chmod +x /data/local/tmp/gatord +``` + +From the streamline GUI under the Configure Capture in the start menu, click `select counters` and use the pre-made template for specific Mali GPU as per the image below. Export the configuration for your specific Mali GPU with the export button. + +![Streamline counter selection showing the Mali G1-Ultra template selected and GPU events populated, identifying the counter configuration to export for capture.#center](./export_streamline_configuration.png) + +Copy the exported counter configuration to your Android device. Replace the first `configuration.xml` with the path to your exported file: + +```bash +adb push configuration.xml /data/local/tmp/configuration.xml +``` + +Finally enable the Android GPU driver perfetto tracing. + +```bash +adb shell setprop debug.graphics.gpu.profiler.perfetto 1 +``` + +## Capture idle and generation activity + +In **Terminal 1** on your host, start the sample on the Android device. Wait for the `Enter phrase:` prompt: + +```bash +adb shell -t 'cd /data/local/tmp && ./sd_gpu_opencl' +``` + +In **Terminal 2** on your host, start `gatord` on the Android device to profile the running sample with your exported counter configuration: + +```bash +adb shell 'cd /data/local/tmp && ./gatord \ + -c configuration.xml \ + -o sd_gpu_debug.apc \ + -i "$(pidof sd_gpu_opencl)"' +``` + +Wait a few seconds to capture idle activity. Then, in **Terminal 1**, enter the image description and diffusion step count when prompted: + +```text +image of a cat in space +10 +``` + +When `Enter phrase:` returns press **Ctrl+C** in **Terminal 1** to exit the sample and automatically terminate the capture. Copy the capture to your host’s Streamline data directory: + +```bash +mkdir -p "$HOME/Documents/Streamline" +adb pull /data/local/tmp/sd_gpu_debug.apc "$HOME/Documents/Streamline/" +``` + +## Inspect GPU activity + +Open `sd_gpu_debug` in Streamline’s **Streamline Data** view. If the capture is not listed, add `~/Documents/Streamline` to the data locations. In the **Analyze** dialog, add the exact executable used for the capture. For the optimized build with debug symbols created earlier, select `/bazel-out/arm64-v8a-opt/bin/ml_drift/samples/stable_diffusion/sd_gpu_opencl`. Select its **Use** checkbox to enable symbol loading, then start the analysis. + +![Streamline Analyze dialog showing an executable with code, symbols, debug information, and call frame information available.#center](./add_debug_image.png "Select the matching executable and enable Use for symbol loading") + +### Timeline view + +### Timeline view + +Use the Timeline view to explore how Mali GPU activity changes during image generation. Its charts provide a closer look at GPU components, including the programmable shader cores, arithmetic units, and memory system. These measurements help you understand how the workload uses the GPU. + +![Streamline Timeline showing GPU activity charts during ML Drift image generation.#center](./streamline_timeline_view.png "Mali GPU activity during image generation") + +### Mali Timeline + +Select **Mali Timeline** in the details panel below the charts to inspect GPU workload scheduling. Events are grouped by device, process, context, and stream. + +![Streamline showing GPU activity and compute queue utilization charts above Mali Timeline events in the application's Compute stream.#center](./mali-timeline.png "Mali Timeline aligns GPU compute workloads with activity and utilization charts") + +For this OpenCL sample, expand the application's **Compute stream** to see recorded GPU workloads. + +### Functions view + +Use the Functions view to see where sampled CPU execution occurs in ML Drift. Function names, sample counts, and source locations help you identify frequently sampled code and choose where to investigate further. This source attribution applies to CPU code, not the shaders executing on the GPU. + +![Streamline Functions tab showing resolved ML Drift function names, sample counts, and source filenames with line numbers, demonstrating CPU source attribution with debug information loaded.#center](./functions_tab.png "CPU function samples with source locations") + +## Summary + +You built and ran ML Drift’s Stable Diffusion sample on an Android device using the OpenCL backend. ML Drift combines portable, unified shaders with GPU-specific optimizations to support high-performance inference across platforms. Its tensor virtualization separates logical tensor access from GPU storage. + +You used Streamline to confirm sustained Mali GPU activity during image generation and inspect how the workload uses GPU resources. + +In a future Learning Path, you will go deeper into authoring your own portable GPU kernels with Unified Compute Language (UCL), integrating them as custom operations in ML Drift, and profiling their performance on Mali GPUs. diff --git a/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/quick_intro.md b/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/quick_intro.md new file mode 100644 index 0000000000..b631df8b16 --- /dev/null +++ b/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/quick_intro.md @@ -0,0 +1,19 @@ +--- +title: Understand ML Drift +weight: 2 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +## Explore GPU compute with ML Drift + +ML Drift is Google's open-source GPU compute engine for on-device AI and ML inference. It powers GPU acceleration in LiteRT and is available as a standalone library for custom graphics and inference runtimes. Its unified shaders separate computation from how data is stored and accessed through currently supported GPU APIs: OpenCL, Metal, WebGPU, and OpenGL ES 3.1 or later. ML Drift generates GPU-specific shader code at runtime, when preparing a workload for execution. This helps you share shader logic across supported platforms while retaining hardware-specific performance optimizations. + +Application developers can use ML Drift through LiteRT's GPU accelerator without writing shaders. For custom graphics and inference runtimes, you can use ML Drift's standalone C++ APIs to assemble and run GPU workloads. When you need custom computations, you can write portable shaders in ML Drift's Unified Compute Language (UCL). This Learning Path uses the OpenCL backend to run an existing workload on an Android device with an Arm Mali GPU. + +One example is the [Mali-specific tuning within ML Drift's general convolution implementation](https://github.com/google-ai-edge/ml-drift/blob/main/ml_drift/common/kernels/conv_generic.cc#L3007). Convolution applies filters to input data, a common operation in image-processing models. ML Drift adjusts how this work is divided across the GPU according to the GPU generation and workload. When you use this built-in operation, ML Drift applies these settings internally; you don't need to select them or write separate shaders for each GPU. + +You'll build the standalone Stable Diffusion command-line example, inspect one of its unified shaders, and profile execution on an Arm Mali GPU. You won't need a LiteRT application or changes to the ML Drift source. + +You now know where standalone ML Drift fits. Next, prepare your host tools and device connection. diff --git a/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/result-10-steps.bmp b/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/result-10-steps.bmp new file mode 100644 index 0000000000..4410add15b Binary files /dev/null and b/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/result-10-steps.bmp differ diff --git a/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/run.md b/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/run.md new file mode 100644 index 0000000000..37753bcbcd --- /dev/null +++ b/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/run.md @@ -0,0 +1,118 @@ +--- +title: Build and Run Stable Diffusion +weight: 4 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +## Prepare the model data + +From the ML Drift repository root, create a model data directory and download the text vocabulary. The original OpenAI vocabulary is available under an [MIT License](https://github.com/openai/CLIP/blob/main/LICENSE): + +```bash +mkdir -p /tmp/sd_1_5 +curl --fail --location \ + https://huggingface.co/OpenGVLab/ViCLIP-B-16-hf/resolve/main/bpe_simple_vocab_16e6.txt.gz \ + --output /tmp/sd_1_5/bpe_simple_vocab_16e6.txt.gz +``` + +Download the model weights in 16-bit floating-point format, available under the [CreativeML Open RAIL-M License](https://huggingface.co/spaces/CompVis/stable-diffusion-license). You need at least 2.13 GB of storage on both your host and Android device: + +```bash +curl --fail --location \ + https://huggingface.co/Comfy-Org/stable-diffusion-1.5/resolve/main/v1-5-pruned-emaonly-fp16.safetensors \ + --output /tmp/v1-5-pruned-emaonly-fp16.safetensors +``` + +On your host computer, decompress the vocabulary and extract the model weights into `/tmp/sd_1_5/`: + +```bash +gzip -dc /tmp/sd_1_5/bpe_simple_vocab_16e6.txt.gz > /tmp/sd_1_5/bpe_simple_vocab_16e6.txt +bazel run //ml_drift/samples/stable_diffusion:extract_weights -- \ + --model_path=/tmp/v1-5-pruned-emaonly-fp16.safetensors \ + --output_dir=/tmp/sd_1_5/ +``` + +## Build and deploy the executable + +Build the optimized OpenCL sample for Android arm64: + +```bash +bazel build -c opt --config=android_arm64 \ + //ml_drift/samples/stable_diffusion:sd_gpu_opencl +``` + +{{% notice %}} +On macOS, if the Android build fails while configuring the Apple C/C++ toolchain, disable that toolchain and retry: +```bash +export BAZEL_NO_APPLE_CPP_TOOLCHAIN=1 +``` +{{% /notice %}} + + +Copy the executable and model data to `/data/local/tmp/` on your Android device, then make the executable runnable: + +```bash +adb push bazel-bin/ml_drift/samples/stable_diffusion/sd_gpu_opencl /data/local/tmp/ +adb push /tmp/sd_1_5 /data/local/tmp/ +adb shell chmod +x /data/local/tmp/sd_gpu_opencl +``` + +Start the sample on your Android device from `/data/local/tmp/`: + +```bash +adb shell -t 'cd /data/local/tmp && ./sd_gpu_opencl' +``` + +At `Enter phrase:`, enter an image description. At `Enter steps:`, enter the number of diffusion steps. For example: + +```text +image of a cat in space +10 +``` + +After image generation, the sample prints timing measurements. The output is similar to this example from a Vivo X300 with a Mali G1-Ultra GPU; your timings will vary: + +```output +Init time: 20.07 ms. +Loop time: 11052.8 ms. +Decode time: 588.189 ms. +Total diffuser time: 11661 ms. +``` + +Init time: Time to prepare your text prompt and the starting noise for image generation. +Loop time: Time spent repeatedly removing noise to form an image that matches your prompt. +Decode time: Time to turn the model’s compact image representation into pixels and retrieve the result. +Total diffuser time: Total time for these three stages. It excludes loading the model at startup and saving the image file. + +## Retrieve the generated image + +When generation finishes and `Enter phrase:` returns, press **Ctrl+C** to exit the sample. On your Mac, copy the generated image from the device and open it: + +```bash +adb pull /data/local/tmp/result.bmp ./result.bmp +open ./result.bmp +``` + +This image was generated by the validated 10-step run on the Android Mali device. Your result can differ: + +![A cat against a space background generated by Stable Diffusion on the Android Mali device, showing the retrieved image output.#center](result-10-steps.bmp "Stable Diffusion output from a 10-step run on Mali-G1 Ultra") + +ML Drift lets you reuse unified shader code across GPU backends, reducing the need to maintain separate implementations for each API. Its standalone C++ APIs and custom operation framework let you integrate GPU-accelerated inference into your own runtime and extend it with specialized operations. + +## A unified shader in the sample + +The sample uses Unified Compute Language (UCL) as an abstraction layer over OpenCL. For example, `ml_drift/samples/stable_diffusion/ops/diffusion_step.cc` contains this excerpt from a kernel template stored in a C++ string: + +```cpp +int X = ucl::GetGlobalId<0>(); +int Y = ucl::GetGlobalId<1>(); +int S = ucl::GetGlobalId<2>(); +if (X >= args.dst.Width() || Y >= args.dst.Height() || S >= args.dst.Slices()) return; +Type eta_cond = args.etaCondIn.Read(X, Y, S); +``` + +`ucl::GetGlobalId` identifies the work item's coordinates, while `args.etaCondIn.Read` expresses a tensor read without specifying its underlying GPU storage. ML Drift translates these abstractions into OpenCL source for this backend, which the driver compiles for the GPU. The same unified shader logic can target other supported backends. + +You've built and run the OpenCL sample and retrieved its output. Next, use Streamline to confirm Mali GPU activity during image generation and assess how effectively the workload uses GPU compute and memory resources. diff --git a/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/setup.md b/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/setup.md new file mode 100644 index 0000000000..eb319b1f6d --- /dev/null +++ b/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/setup.md @@ -0,0 +1,87 @@ +--- +title: Setup +weight: 3 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +## Set up the host tools + +Use the command for your host operating system to set `ANDROID_HOME` to your Android SDK directory. Update the default path to match the actual SDK and tools installation location on your system. + +{{< tabpane-normal >}} +{{< tab header="MacOS" >}} +```bash +export ANDROID_HOME="$HOME/Library/Android/sdk" +export PATH="$ANDROID_HOME/platform-tools:$ANDROID_HOME/cmdline-tools/latest/bin:$PATH" +``` +{{< /tab >}} +{{< tab header="Linux x86" >}} +```bash +export ANDROID_HOME="$HOME/Android/Sdk" +export PATH="$ANDROID_HOME/platform-tools:$ANDROID_HOME/cmdline-tools/latest/bin:$PATH" +``` +{{< /tab >}} +{{< /tabpane-normal >}} + +Install the Android NDK and Platform-Tools using your existing Android CLI and set the `ANDROID_NDK_HOME` environment variable which is required at a later step: + +```bash +android --sdk="$ANDROID_HOME" sdk install platform-tools ndk/30.0.16248370 +export ANDROID_NDK_HOME="$ANDROID_HOME/ndk/30.0.16248370" +``` + +{{% notice Please Note %}} +This guide uses NDK r30 (`30.0.16248370`), the [2026 LTS release](https://github.com/android/ndk/wiki). Other NDK versions have not been tested with this guide but are expected to work. +{{%/ notice %}} + + + +Install Bazelisk using the commands for your host operating system. On macOS, [install Homebrew](https://brew.sh/) first if it is not already available. + +{{< tabpane >}} +{{< tab header="MacOS" >}} +brew install bazelisk +{{< /tab >}} +{{< tab header="Linux x86" >}} + +curl -fL -o bazelisk https://github.com/bazelbuild/bazelisk/releases/latest/download/bazelisk-linux-amd64 +mkdir -p "$HOME/.local/bin" +install -m 755 bazelisk "$HOME/.local/bin/bazel" +echo 'export PATH="$HOME/.local/bin:$PATH"' >> "$HOME/.bashrc" +source "$HOME/.bashrc" +bazel --version + +{{< /tab >}} +{{< /tabpane >}} + + +## Check your Android device + +Connect one Android device and authorize debugging from your host computer. Check the ADB connection, GPU model, and driver: + +```bash +adb devices +adb shell 'dumpsys SurfaceFlinger | grep GLES' +``` + +The output should resemble the example below, showing the connected device and its GPU. ML Drift supports different OpenCL backends, but profiling with Arm Streamline requires a device with a Mali GPU. + +```output +10.1.16.154:5555 device + + ------------RE GLES (Ganesh)------------ +GLES: ARM, Mali-G1-Ultra MC12, OpenGL ES 3.2 v1.r54p1-11eac0.5ac4efe.15f36b8c6518df15cadf5aced2a1638a.1c3d0d1d631f33b0b8a673ce08c68e340f851541 +``` + +## Get the source + +Clone ML Drift and enter the repository directory using the commands for your host operating system. The macOS commands also select the revision used for the validated Android build: + +```bash +git clone https://github.com/google-ai-edge/ml-drift.git +cd ml-drift +``` + +Your environment is ready. Next, build and run the sample. \ No newline at end of file diff --git a/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/streamline_timeline_view.png b/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/streamline_timeline_view.png new file mode 100644 index 0000000000..a82bdfaad8 Binary files /dev/null and b/content/learning-paths/mobile-graphics-and-gaming/ml_drift_run_and_profile/streamline_timeline_view.png differ diff --git a/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/_index.md b/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/_index.md index 97ba6564ae..077121ea61 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/_index.md +++ b/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/_index.md @@ -39,34 +39,35 @@ generated_summary_faq: compatibility. Then, you'll inspect performance reports and compare a smaller-input variant under the same target profile. If you have a compatible Android device, you can also capture and analyze measured performance. - # faqs: - # - question: How do I verify my host meets the wheel requirements before installing? - # answer: >- - # Run `uname -m`, `python3.12 --version`, and `getconf GNU_LIBC_VERSION`. You need `x86_64`, - # CPython `3.12.x`, and glibc `2.39` or later on Ubuntu 24.04. You can't use this wheel on - # Ubuntu 22.04, native macOS, or native Linux on Arm. - # - question: MLIA prompted me to install the NX Performance Estimator. What should I do? - # answer: >- - # Confirm the installation when prompted, read the Arm license, and continue only if you agree. - # If you've already installed the backend, you can proceed without repeating setup. - # - question: Which command do I use to check operator compatibility, and where do the results go? - # answer: >- - # Run `mlia check models/baseline.tflite --target-profile neural-technology --compatibility - # --output-dir runs/baseline-compatibility`. Read the result in - # `runs/baseline-compatibility/mlia-output/mlia-output.json`. Check that its compatibility - # status is `ok` and that no operator checks failed. - # - question: What result should I expect from the baseline performance check and how do I interpret it? - # answer: >- - # Run `mlia check models/baseline.tflite --target-profile neural-technology --performance - # --output-dir runs/baseline`. With the tested packages and profile, you should see about - # `136,962` total cycles and `0.09131 ms` per inference. Treat these as compiler estimates, - # not timings measured on a device. - # - question: How do I compare a smaller-input MobileNet variant with the baseline? - # answer: >- - # Run compatibility and performance checks for `models/smaller.tflite` with the same - # `neural-technology` target profile, writing each report to a separate directory. Compare - # your reports with the baseline, then validate task accuracy, preprocessing, and runtime - # behavior on representative data before deployment. + faqs: + - question: How do I verify my host meets the wheel requirements before installing? + answer: >- + Run `uname -m`, `python3.12 --version`, and `getconf GNU_LIBC_VERSION`. You need `x86_64`, + CPython `3.12.x`, and glibc `2.39` or later on Ubuntu 24.04. You can't use this wheel on + Ubuntu 22.04, macOS, or Linux on Arm. + - question: How do I complete the installation of NX Performance Estimator? + answer: >- + Confirm the installation when prompted, read the Arm license, and continue only if you agree. + If you've already installed the backend, proceed without repeating setup. + - question: Which command do I use to check operator compatibility, and where do the results go? + answer: >- + Run `mlia check models/baseline.tflite --target-profile neural-technology --compatibility + --output-dir runs/baseline-compatibility`. Read its report in + `runs/baseline-compatibility/mlia-output/mlia-output.json`. Check that its compatibility + status is `ok` and that no operator checks failed. + - question: How do I interpret the baseline performance estimate? + answer: >- + Run `mlia check models/baseline.tflite --target-profile neural-technology --performance + --output-dir runs/baseline`. The reference result of `136,962` total cycles and + `0.09131 ms` per inference used Neural Technology `0.2.0` and LiteRT converter `0.1.2`. + Your setup uses versions `0.3.0` and `0.1.3`, so use your generated report for the current + estimate. These are compiler estimates, not timings measured on a device. + - question: How do I compare a smaller-input MobileNet variant with the baseline? + answer: >- + Run compatibility and performance checks for `models/smaller.tflite` with the same + `neural-technology` target profile, writing each report to a separate directory. Compare + your reports with the baseline, then validate task accuracy, preprocessing, and runtime + behavior on representative data before deployment. # END generated_summary_faq author: Annie Tallund diff --git a/content/learning-paths/mobile-graphics-and-gaming/neural-graphics-playbook-integrate/_index.md b/content/learning-paths/mobile-graphics-and-gaming/neural-graphics-playbook-integrate/_index.md index 0578b3adbb..593e897f4a 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/neural-graphics-playbook-integrate/_index.md +++ b/content/learning-paths/mobile-graphics-and-gaming/neural-graphics-playbook-integrate/_index.md @@ -36,34 +36,34 @@ generated_summary_faq: criteria and test game content. Next, you'll decide whether NSSD merits experimental exploration with Arm. If a measured gap justifies model work, you'll use Model Gym, MLIA, and Streamline to assess candidates. You'll finish with an integration brief separating estimates from device measurements. -# faqs: -# - question: How do I choose between NFRU, NSS, and NSSD? -# answer: >- -# Start with your player-facing goal and the resources your engine can provide. Choose the public -# NFRU route for smoother presentation or the public NSS route for neural upscaling. If your -# lighting goals call for denoising and super sampling together, consider NSSD as an experimental -# exploration with Arm. You can start with a published model and defer custom model work. -# - question: What pass condition confirms NFRU is viable for my game? -# answer: >- -# Set your presentation, image-quality, latency, power, and thermal limits before testing. -# Compare the same representative action with NFRU disabled and enabled under fixed conditions. -# Continue only if your measured result meets your presentation target within those limits. -# - question: What should I record during the NFRU test run? -# answer: >- -# Record render FPS, present FPS, frame-time distribution, and your image-quality observations. -# Capture latency, power, and thermal data against the limits you set. Use the Project Moku case -# study to establish a repeatable capture method, then apply it to representative game content. -# - question: How should I treat desktop results from the ML Emulation Layer? -# answer: >- -# Use the ML Emulation Layer for desktop development and testing. Don't treat its performance -# as representative of production hardware. Validate performance-critical decisions on an Arm -# GPU with a neural accelerator (NX). -# - question: Which motion data does NFRU need, and how do I check it? -# answer: >- -# Supply color, depth, motion vectors, camera data, and metadata from your engine. Check the -# motion-vector format and coordinate system, and confirm that the data aligns with neighboring -# rendered frames. NFRU uses optical flow within its motion-estimation stage; you don't supply -# it as a separate engine input. + faqs: + - question: How do I choose between NFRU, NSS, and NSSD? + answer: >- + Start with your player-facing goal and the resources your engine can provide. Choose the public + NFRU route for smoother presentation or the public NSS route for neural upscaling. If your + lighting goals call for denoising and super sampling together, consider NSSD as an experimental + exploration with Arm. You can start with a published model and defer custom model work. + - question: What pass condition confirms NFRU is viable for my game? + answer: >- + Set your presentation, image-quality, latency, power, and thermal limits before testing. + Compare the same representative action with NFRU disabled and enabled under fixed conditions. + Continue only if your measured result meets your presentation target within those limits. + - question: What should I record during the NFRU test run? + answer: >- + Record render FPS, present FPS, frame-time distribution, and your image-quality observations. + Capture latency, power, and thermal data against the limits you set. Use the Project Moku case + study to establish a repeatable capture method, then apply it to representative game content. + - question: How should I treat desktop results from the ML Emulation Layer? + answer: >- + Use the ML Emulation Layer for desktop development and testing. Don't treat its performance + as representative of production hardware. Validate performance-critical decisions on an Arm + GPU with a neural accelerator. + - question: Which motion data does NFRU need, and how do I check it? + answer: >- + Supply color, depth, motion vectors, camera data, and metadata from your engine. Check the + motion-vector format and coordinate system. Confirm that the data aligns with neighboring + rendered frames. NFRU uses optical flow within its motion-estimation stage. You don't supply + it as a separate engine input. # END generated_summary_faq author: Annie Tallund diff --git a/content/learning-paths/mobile-graphics-and-gaming/omm-mali-intro/_index.md b/content/learning-paths/mobile-graphics-and-gaming/omm-mali-intro/_index.md index d885dd8db6..cbc8680519 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/omm-mali-intro/_index.md +++ b/content/learning-paths/mobile-graphics-and-gaming/omm-mali-intro/_index.md @@ -19,50 +19,50 @@ prerequisites: - (Optional) An Arm Mali G2-Ultra NX device and Vulkan capability tools for device validation # START generated_summary_faq -# generated_summary_faq: -# template_version: summary-faq-v3 -# generated_at: '2026-10-08T20:44:15Z' -# generator: ai -# ai_assisted: true -# ai_review_required: true -# model: gpt-5 -# prompt_template: summary-faq-v3 -# source_hash: 62c0dbe8121bd0ff6d93cb862a5cf5235782b0f2c6e598a19ce9931bac366354 -# summary_generated_at: '2026-10-08T20:44:15Z' -# summary_source_hash: 62c0dbe8121bd0ff6d93cb862a5cf5235782b0f2c6e598a19ce9931bac366354 -# faq_generated_at: '2026-10-08T20:44:15Z' -# faq_source_hash: 62c0dbe8121bd0ff6d93cb862a5cf5235782b0f2c6e598a19ce9931bac366354 -# summary: >- -# You'll evaluate whether an alpha-tested asset can benefit from OMM on Arm -# Mali G2-Ultra NX. First, you'll identify a suitable asset, classify microtriangle opacity states, and -# choose a format and subdivision level. Then, you'll trace baked data through Vulkan resource and -# acceleration-structure setup. You'll enable the appropriate traversal path and define an alpha-tested -# fallback. Finally, you'll compare image and runtime evidence to record an adoption decision. -# faqs: -# - question: Why should I use OMM for ray-traced assets? -# answer: >- -# Use OMM to let ray traversal resolve known opaque and transparent -# regions of an alpha-tested asset. With OMM, you can reduce repeated shader-side opacity checks when -# rays pass through assets such as foliage or fences. -# - question: What kinds of assets should I evaluate for OMM? -# answer: >- -# Start with alpha-tested assets that participate in ray tracing, have stable opacity masks, -# and receive repeated ray hits. You'll need an update policy for changing masks, while -# alpha-blended and rasterization-only assets belong on their existing paths. -# - question: Do I need OMM-capable hardware to complete this Learning Path? -# answer: >- -# No. You can work through asset decision and validation with the provided bake -# results and saved device capability report. If you have an Arm Mali G2-Ultra NX device, -# you can compare its reported capabilities with your chosen OMM strategy. -# - question: Will OMM change the geometry of my asset? -# answer: >- -# No. You keep the original mesh triangles and use OMM to describe opacity in smaller regions -# within them. You don't add polygons to the source model. -# - question: How do I know whether an OMM strategy is suitable for my asset? -# answer: >- -# Compare image quality with and without OMM, then check the asset's data cost and remaining -# shader-side work against your goals. You can use the Learning Path's sample evidence to -# practice that decision before testing it in your own renderer. +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-10-08T20:44:15Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: 62c0dbe8121bd0ff6d93cb862a5cf5235782b0f2c6e598a19ce9931bac366354 + summary_generated_at: '2026-10-08T20:44:15Z' + summary_source_hash: 62c0dbe8121bd0ff6d93cb862a5cf5235782b0f2c6e598a19ce9931bac366354 + faq_generated_at: '2026-10-08T20:44:15Z' + faq_source_hash: 62c0dbe8121bd0ff6d93cb862a5cf5235782b0f2c6e598a19ce9931bac366354 + summary: >- + You'll evaluate whether an alpha-tested asset can benefit from OMM on Arm + Mali G2-Ultra NX. First, you'll identify a suitable asset, classify microtriangle opacity states, and + choose a format and subdivision level. Then, you'll trace baked data through Vulkan resource and + acceleration-structure setup. You'll enable the appropriate traversal path and define an alpha-tested + fallback. Finally, you'll compare image and runtime evidence to record an adoption decision. + faqs: + - question: Why should I use OMM for ray-traced assets? + answer: >- + Use OMM to let ray traversal resolve known opaque and transparent + regions of an alpha-tested asset. With OMM, you can reduce repeated shader-side opacity checks when + rays pass through assets such as foliage or fences. + - question: What kinds of assets should I evaluate for OMM? + answer: >- + Start with alpha-tested assets that participate in ray tracing, have stable opacity masks, + and receive repeated ray hits. You'll need an update policy for changing masks, while + alpha-blended and rasterization-only assets belong on their existing paths. + - question: Do I need OMM-capable hardware to complete this Learning Path? + answer: >- + No. You can work through asset decision and validation with the provided bake + results and saved device capability report. If you have an Arm Mali G2-Ultra NX device, + you can compare its reported capabilities with your chosen OMM strategy. + - question: Will OMM change the geometry of my asset? + answer: >- + No. You keep the original mesh triangles and use OMM to describe opacity in smaller regions + within them. You don't add polygons to the source model. + - question: How do I know whether an OMM strategy is suitable for my asset? + answer: >- + Compare image quality with and without OMM, then check the asset's data cost and remaining + shader-side work against your goals. You can use the Learning Path's sample evidence to + practice that decision before testing it in your own renderer. # END generated_summary_faq author: Patrick Wang diff --git a/content/learning-paths/mobile-graphics-and-gaming/profile-nx-with-mlia-vscode/_index.md b/content/learning-paths/mobile-graphics-and-gaming/profile-nx-with-mlia-vscode/_index.md index 92c511021b..bcb95bd358 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/profile-nx-with-mlia-vscode/_index.md +++ b/content/learning-paths/mobile-graphics-and-gaming/profile-nx-with-mlia-vscode/_index.md @@ -41,31 +41,31 @@ generated_summary_faq: up the extension. Next, you'll prepare Scenario Runner and the device, then capture an NX dispatch. Finally, you'll load the capture and matching VGF. You'll inspect the cycle cost of the cascade, and trace an operation to Python source. -# faqs: -# - question: Which Scenario Runner APK should I build for the example? -# answer: >- -# Use a debuggable Android Arm64 Scenario Runner v0.11.0 APK. Follow the MLIA Scenario Runner -# build instructions, add `-b v2026.09.0` to `repo init`, use NDK r28c (`28.2.13676358`), -# and set `--package-version 0.11.0`. -# - question: What paths do I select in MLIA > New Analysis? -# answer: >- -# In **MLIA > New Analysis**, select **Profiling**. Add the directory that directly contains -# `capture.json` as **Profiling data**, then select the matching VGF as **Source model**. You -# can print both paths from the capture terminal before starting the analysis. -# - question: How do I know my capture succeeded before I switch to VS Code? -# answer: >- -# Check that your retrieved `CAPTURE_ROOT` directory contains `capture.json`. Keep the device -# connected until the helper finishes capturing the first dispatch in statistics mode `1` -# and restores the previous GPU debug settings. -# - question: I'm profiling my existing Android app. What do I do differently? -# answer: >- -# Follow the existing-application capture instructions to collect profiling data. When you -# create the analysis, select your capture directory and the VGF that matches your app's model. -# - question: What should I look for in Model Explorer to confirm the analysis is set up correctly? -# answer: >- -# You can inspect measured cycle counts for the captured NX dispatch in Model Explorer. -# Selecting a cascade highlights its corresponding operations in **Source Model**. Select -# a mapped operation there to open the matching Python source in VS Code. + faqs: + - question: Which Scenario Runner APK should I build? + answer: >- + Use a debuggable Android Arm64 Scenario Runner v0.11.0 APK. Follow the MLIA Scenario Runner + build instructions, add `-b v2026.09.0` to `repo init`, use NDK r28c (`28.2.13676358`), + and set `--package-version 0.11.0`. + - question: How do I select the capture and matching model? + answer: >- + In **MLIA > New Analysis**, select **Profiling**. Add the directory that directly contains + `capture.json` as **Profiling data**, then select the matching VGF as **Source model**. You + can print both paths from the capture terminal before starting the analysis. + - question: How do I know my capture succeeded before I switch to VS Code? + answer: >- + Check that your retrieved `CAPTURE_ROOT` directory contains `capture.json`. Keep the device + connected until the helper finishes capturing the first dispatch in statistics mode `1` + and restores the previous GPU debug settings. + - question: What do I do differently if I'm profiling my existing Android app? + answer: >- + Follow the existing-application capture instructions to collect profiling data. When you + create the analysis, select your capture directory and the VGF that matches your app's model. + - question: What should I look for in Model Explorer to confirm that the analysis is set up correctly? + answer: >- + Inspect measured cycle counts for the captured NX dispatch in Model Explorer. + Selecting a cascade highlights its corresponding operations in **Source Model**. Select + a mapped operation there to open the matching Python source in VS Code. # END generated_summary_faq author: Matthew Sloyan diff --git a/content/learning-paths/mobile-graphics-and-gaming/streamline-nx/_index.md b/content/learning-paths/mobile-graphics-and-gaming/streamline-nx/_index.md index 946395c413..53ee399337 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/streamline-nx/_index.md +++ b/content/learning-paths/mobile-graphics-and-gaming/streamline-nx/_index.md @@ -36,22 +36,22 @@ generated_summary_faq: faq_source_hash: 560b2a63a796a5c370b3c916b2e3192dd01be07b72252bd540af3da98f74109f summary: >- You'll use Arm Streamline to profile an Android ML for Vulkan workload and inspect NX activity, GPU timeline events, and graph-operation costs. First, you'll review how Vulkan graph dispatches can use NX and shader cores. Then, you'll prepare a debuggable app and Android device and capture about 30 seconds in the Streamline GUI. Finally, you'll analyze the capture using the Mali Timeline and Dispatch Graph Workloads views. - # faqs: - # - question: How can I check whether Streamline supports NX profiling? - # answer: >- - # In **Streamline**, select **About Streamline** and check the version. Use Streamline 9.9 or newer for the NX workflow. - # - question: How do I check that an Android device is ready for capture in Streamline? - # answer: >- - # In the **Start** view, select **Android (adb)** and check **Select device**. Confirm that `adb devices -l` lists the device with status `device`; if the status is `unauthorized`, accept the debugging authorization prompt. - # - question: Which application and counters should I select before recording? - # answer: >- - # Choose the template that matches the GPU. For the example GPU, select **Mali G2-Ultra - 5th Generation** and confirm **Mali Timeline events: Perfetto** appears in **Events to collect**. - # - question: What result should I expect after recording a 30-second capture? - # answer: >- - # After capture, check the device, app, and duration. Confirm NX activity during the intended workload and GPU workload events in **Mali Timeline**. Select **Dispatch Graph Workloads: Mali Timeline** separately to inspect graph-operation data; the data depends on the workload, template, Timeline layer, and statistics. - # - question: How do I interpret mixed NX and shader-core activity in the capture? - # answer: >- - # Check **Type** in **Dispatch Graph Workloads** to distinguish **NX** execution from shader-core execution. The mapping depends on the operation, tensor data types and shapes, and the capabilities of the target GPU and driver. + faqs: + - question: How can I check whether Streamline supports NX profiling? + answer: >- + On macOS, select **Streamline > About Streamline** to check the version. Use Streamline 9.9 or later for the NX workflow. + - question: How do I check that an Android device is ready for capture in Streamline? + answer: >- + In the **Start** view, select **Android (adb)** and check **Select device**. Confirm that `adb devices -l` lists the device with status `device`. If the status is `unauthorized`, accept the debugging authorization prompt. + - question: Which application and counters should I select before recording? + answer: >- + Choose the template that matches the GPU. For the example GPU, select **Mali G2-Ultra - 5th Generation** and confirm that **Mali Timeline events: Perfetto** appears in **Events to collect**. + - question: What result should I expect after recording a 30-second capture? + answer: >- + After recording the capture, check the device, app, and duration. Confirm NX activity during the intended workload and GPU workload events in **Mali Timeline**. Select **Dispatch Graph Workloads: Mali Timeline** separately to inspect graph-operation data. The data depends on the workload, template, Timeline layer, and statistics. + - question: How do I interpret mixed NX and shader-core activity in the capture? + answer: >- + Check **Type** in **Dispatch Graph Workloads** to distinguish **NX** execution from shader-core execution. The mapping depends on the operation, tensor data types and shapes, and the capabilities of the target GPU and driver. # END generated_summary_faq author: diff --git a/content/learning-paths/servers-and-cloud-computing/_index.md b/content/learning-paths/servers-and-cloud-computing/_index.md index 5706f3e7df..b7e574c7a4 100644 --- a/content/learning-paths/servers-and-cloud-computing/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/_index.md @@ -14,11 +14,11 @@ pinned_learning_paths: - sve2-match - performix-microarchitecture operatingsystems_filter: -- Android: 3 -- Linux: 286 -- macOS: 21 +- Android: 4 +- Linux: 290 +- macOS: 24 - other: 1 -- Windows: 18 +- Windows: 19 pinned_modules: - module: name: Recommended getting started learning paths @@ -61,6 +61,7 @@ tools_software_languages_filter: - Arm Compiler for Linux: 1 - Arm Development Studio: 3 - Arm ISA: 1 +- Arm Metis: 1 - Arm Performance Libraries: 3 - Arm Performix: 12 - Arm Streamline: 1 @@ -86,6 +87,7 @@ tools_software_languages_filter: - AWS Lambda: 1 - Azure: 2 - Azure CLI: 5 +- Azure Cobalt 200: 5 - Azure Portal: 1 - Bash: 9 - bash: 2 @@ -97,7 +99,7 @@ tools_software_languages_filter: - boto3: 1 - bpftool: 1 - Buildkite: 1 -- C: 16 +- C: 17 - Capstone: 1 - Cargo: 1 - cassandra-stress: 1 @@ -115,6 +117,7 @@ tools_software_languages_filter: - Cloud SQL: 1 - CMake: 7 - Codex: 1 +- Compute Flow: 1 - Confidential Containers: 1 - Couchbase: 1 - CPP: 22 @@ -128,7 +131,7 @@ tools_software_languages_filter: - Demo: 3 - DevStack: 1 - Django: 2 -- Docker: 43 +- Docker: 42 - Docker Buildx: 1 - dotnet: 5 - Dynatrace: 1 @@ -153,10 +156,10 @@ tools_software_languages_filter: - Gardener: 1 - GCC: 32 - gdb: 1 -- Gemma: 1 +- Gemma: 2 - Generative AI: 15 - Gerrit: 1 -- Git: 2 +- Git: 3 - GitHub: 3 - GitHub Actions: 4 - GitHub CLI: 1 @@ -173,12 +176,12 @@ tools_software_languages_filter: - Google Cloud: 2 - Google Cloud Pub/Sub: 1 - Google Dataflow: 1 -- Google Kubernetes Engine: 1 +- Google Kubernetes Engine: 2 - Google Test: 1 - Grafana: 1 - Groovy: 1 - gRPC: 1 -- gVisor: 1 +- gVisor: 2 - Hadoop: 1 - HammerDB: 1 - Helm: 4 @@ -199,7 +202,7 @@ tools_software_languages_filter: - JAX: 1 - Jenkins: 1 - JMH: 1 -- JSON: 1 +- JSON: 2 - K3s: 2 - Kafka: 2 - Kata Containers: 1 @@ -225,7 +228,7 @@ tools_software_languages_filter: - Linux kernel: 1 - Litmus7: 1 - llama-roofline: 1 -- llama.cpp: 5 +- llama.cpp: 6 - LlamaIndex: 1 - LLM: 13 - LLVM: 2 @@ -292,7 +295,7 @@ tools_software_languages_filter: - Puppet: 1 - Puppeteer: 1 - Pytest: 1 -- Python: 64 +- Python: 67 - PyTorch: 16 - Qdrant: 1 - QEMU: 1 @@ -311,7 +314,8 @@ tools_software_languages_filter: - RME: 10 - Ruby: 2 - Runbook: 72 -- Rust: 3 +- Rust: 4 +- SARIF: 1 - scikit-learn: 2 - Sentence Transformers: 1 - Service Mesh: 1 @@ -352,6 +356,7 @@ tools_software_languages_filter: - tuxmake: 1 - TypeScript: 2 - Ubuntu: 1 +- uv: 1 - Vectorscan: 1 - Velox: 1 - Veraison: 3 @@ -362,7 +367,9 @@ tools_software_languages_filter: - VMAS: 1 - VS Code: 1 - vvenc: 1 +- wasmCloud: 1 - Web Server: 1 +- WebAssembly: 1 - Whisper: 1 - WindowsPerf: 1 - WordPress: 3 @@ -378,8 +385,8 @@ tools_software_languages_filter: weight: 1 platforms_filter: - Arm AGI CPU: 26 -- AWS Graviton: 98 -- Google Axion: 119 -- Microsoft Azure Cobalt: 102 +- AWS Graviton: 100 +- Google Axion: 121 +- Microsoft Azure Cobalt: 103 - Oracle Cloud Infrastructure (OCI) Ampere Compute: 61 --- diff --git a/content/learning-paths/servers-and-cloud-computing/aks/_images/wordpress-setup.webp b/content/learning-paths/servers-and-cloud-computing/aks/_images/wordpress-setup.webp new file mode 100644 index 0000000000..1b13dc0a47 Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/aks/_images/wordpress-setup.webp differ diff --git a/content/learning-paths/servers-and-cloud-computing/aks/_index.md b/content/learning-paths/servers-and-cloud-computing/aks/_index.md index 929f376f2d..8efa3b5d0a 100644 --- a/content/learning-paths/servers-and-cloud-computing/aks/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/aks/_index.md @@ -1,18 +1,18 @@ --- title: Create an Arm-based cluster on Azure Kubernetes Service -description: Learn how to automate the deployment of an Arm-based Kubernetes cluster on Azure AKS using Terraform and deploy a sample WordPress application as a workload. +description: Learn how to automate the deployment of an Arm-based Kubernetes cluster on Azure AKS with Azure Cobalt 200 nodes using Terraform, and deploy a sample WordPress application as a workload. minutes_to_complete: 60 who_is_this_for: This is an advanced topic for software developers who want to deploy an Arm-based Kubernetes cluster using Azure Kubernetes Service (AKS). learning_objectives: - - Automate the deployment of an Arm-based AKS cluster using Terraform - - Install Wordpress on AKS as an example workload + - Automate the deployment of an Arm-based AKS cluster with Azure Cobalt 200 nodes using Terraform + - Install WordPress on AKS as an example workload prerequisites: - - An Azure account + - An Azure account with access to Cobalt 200 (Dpsv7) virtual machines and sufficient vCPU quota - A machine with [Terraform](/install-guides/terraform/), [Azure CLI](/install-guides/azure-cli), and [Kubectl](/install-guides/kubectl/) installed # START generated_summary_faq @@ -32,7 +32,7 @@ generated_summary_faq: summary: >- You'll automate an Arm-based Azure Kubernetes Service (AKS) cluster deployment with Terraform and then deploy a WordPress example workload. First, you'll configure AKS to use Azure - Dpsv5 virtual machines based on Ampere Altra Arm processors by following Terraform-driven + Dpsv7 virtual machines based on Azure Cobalt 200 Arm processors by following Terraform-driven provisioning steps. After the cluster is available, you'll use a concise Kubernetes setup to run WordPress backed by MySQL by creating three manifests: `kustomization.yaml`, `mysql-deployment.yaml`, and `wordpress-deployment.yaml`. The result is a working application on an Arm-based AKS node @@ -49,9 +49,10 @@ generated_summary_faq: can proceed after the cluster is up and reachable with your configured tooling. - question: How do I ensure the AKS node pool is Arm-based? answer: >- - Configure the node pool in Terraform to use an Azure Dpsv5 VM size, which runs on Ampere - Altra Arm-based processors. Confirm that the VM size in your configuration references a - Dpsv5 option. + Configure the node pool in Terraform to use an Azure Dpsv7 VM size, such as `Standard_D2ps_v7`, + which runs on Azure Cobalt 200 Arm-based processors. After the cluster is created, run + `kubectl get nodes -L node.kubernetes.io/instance-type,kubernetes.io/arch` and confirm that the + nodes show `arm64`. - question: Which files do I need to create for the WordPress example? answer: >- Create `kustomization.yaml`, `mysql-deployment.yaml`, and `wordpress-deployment.yaml` exactly @@ -89,8 +90,8 @@ operatingsystems: further_reading: - resource: - title: Azure Kubernetes Service on Arm based Ampere Altra processors - link: https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/aks-on-arm-based-ampere + title: Introducing Azure Cobalt 200 virtual machines + link: https://azure.microsoft.com/en-us/blog/new-azure-cobalt-200-vms-deliver-50-performance-improvement-fully-optimized-for-modern-agentic-ai-workloads/ type: blog - resource: title: AKS documentation diff --git a/content/learning-paths/servers-and-cloud-computing/aks/cluster_deployment.md b/content/learning-paths/servers-and-cloud-computing/aks/cluster_deployment.md index 9bb7ce088c..fe07ed5c5a 100644 --- a/content/learning-paths/servers-and-cloud-computing/aks/cluster_deployment.md +++ b/content/learning-paths/servers-and-cloud-computing/aks/cluster_deployment.md @@ -8,7 +8,9 @@ weight: 2 # 1 is first, 2 is second, etc. layout: "learningpathall" --- -You can run Azure Kubernetes Service (AKS), a fully managed Kubernetes platform, on the Azure Dpsv5 Virtual Machine series featuring Ampere Altra Arm–based processors. Dpsv5 virtual machines offer compelling price-performance. +You can run Azure Kubernetes Service (AKS), a fully managed Kubernetes platform, on Azure Cobalt 200 virtual machines. Azure Cobalt 200 is Microsoft's second-generation Arm-based processor, built on Arm Neoverse Compute Subsystems V3 (CSS V3). In this Learning Path, you use the general-purpose Dpsv7 virtual machine series for the AKS nodes. + +Your subscription and selected region must have access to Dpsv7 sizes and sufficient vCPU quota. This Learning Path was validated in **West US 2**. ## Before you begin @@ -61,7 +63,7 @@ terraform { required_providers { azurerm = { source = "hashicorp/azurerm" - version = "~>3.0" + version = "~>5.0" } random = { source = "hashicorp/random" @@ -87,7 +89,7 @@ variable "dns_prefix" { default = "arm-aks" } variable "resource_group_location" { - default = "eastus2" + default = "westus2" description = "Location of the resource group." } variable "resource_group_name_prefix" { @@ -105,6 +107,9 @@ variable "ssh_public_key" { output "resource_group_name" { value = azurerm_resource_group.rg.name } +output "cluster_name" { + value = azurerm_kubernetes_cluster.k8s.name +} ``` 4. Use a text editor to create the file `main.tf` with the code below: @@ -128,9 +133,12 @@ resource "azurerm_kubernetes_cluster" "k8s" { } default_node_pool { name = "demopool" - vm_size = "Standard_D2ps_v5" + vm_size = "Standard_D2ps_v7" node_count = var.agent_count } + node_provisioning_profile { + mode = "Manual" + } linux_profile { admin_username = "ubuntu" ssh_key { @@ -145,9 +153,11 @@ resource "azurerm_kubernetes_cluster" "k8s" { The block labeled `default_node_pool` is used to select the virtual machine type, size, and the number of nodes. -The nodes are specified to use the `Standard_D2ps_v5` virtual machine type which is a 2 vCPU Altra-based virtual machine with standard SSDs. +The nodes are specified to use the `Standard_D2ps_v7` virtual machine type, which is a 2 vCPU Cobalt 200 virtual machine. -There are various Arm-based virtual machines that can be selected. The [Azure VM series descriptions](https://azure.microsoft.com/en-us/pricing/details/virtual-machines/series/) shows that the Dpsv5, Dpdsv5, Dplsv5, Dpldsv5, Epsv5, Epdsv5 all use Ampere Altra. Any of these virtual machine types can be used to create an Arm-based cluster. +The `node_provisioning_profile` block is required by the current Azure provider for Terraform. Setting `mode` to `Manual` means that you choose the node pool size and VM type yourself. + +There are various Arm-based virtual machines that can be selected. The Cobalt 200 series include Dpsv7, Dpdsv7, Dplsv7, Dpldsv7, Epsv7, and Epdsv7. See the [Azure Cobalt 200 virtual machines overview](https://azure.microsoft.com/en-us/blog/new-azure-cobalt-200-vms-deliver-50-performance-improvement-fully-optimized-for-modern-agentic-ai-workloads/) for details. Any of these virtual machine types can be used to create an Arm-based cluster, provided your subscription and region have access to them. ### Run the Terraform commands @@ -168,11 +178,11 @@ Initializing the backend... Initializing provider plugins... - Finding hashicorp/random versions matching "~> 3.0"... -- Finding hashicorp/azurerm versions matching "~> 3.0"... -- Installing hashicorp/random v3.4.3... -- Installed hashicorp/random v3.4.3 (signed by HashiCorp) -- Installing hashicorp/azurerm v3.48.0... -- Installed hashicorp/azurerm v3.48.0 (signed by HashiCorp) +- Finding hashicorp/azurerm versions matching "~> 5.0"... +- Installing hashicorp/random v3.9.1... +- Installed hashicorp/random v3.9.1 (signed by HashiCorp) +- Installing hashicorp/azurerm v5.14.0... +- Installed hashicorp/azurerm v5.14.0 (signed by HashiCorp) Terraform has created a lock file .terraform.lock.hcl to record the provider selections it made above. Include this file in your version control repository @@ -198,45 +208,38 @@ Run `terraform apply` to create the infrastructure: terraform apply ``` -Answer yes to the prompt to confirm you want to create Google Cloud resources. +Answer `yes` at the prompt to confirm you want to create the Azure resources. -It will take about 5 minutes to create the resources. +It will take about 5 to 10 minutes to create the resources. -When it completes the name of the resource group is printed. +When it completes, the name of the resource group and the cluster are printed. ```output Apply complete! Resources: 3 added, 0 changed, 0 destroyed. Outputs: -resource_group_name = "arm-aks-demo-rg-exact-wombat" +cluster_name = "arm-aks-cluster-demo" +resource_group_name = "arm-aks-demo-rg-possible-mastiff" ``` ### Configure kubectl -1. In a browser, go to the Azure Kubernetes services console, select the cluster, and click on connect. - -![aks1 #center](https://github.com/ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/2b50015f-51fb-46f1-8ee1-28fc5db35154) - -Instructions for running `az account` and `az aks get-credentials` will be displayed. +1. Use the Terraform outputs to get the credentials for the new cluster and add them to your `kubectl` configuration: -![aks2 #center](https://github.com/ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/45732e69-fe88-4757-98d4-264bf392d10c) - -2. Copy the 2 commands and run them - -Run the `az account` and `az aks get-credentials` commands you copied. - -There is no output from the first command. +```console +az aks get-credentials --resource-group $(terraform output -raw resource_group_name) --name $(terraform output -raw cluster_name) +``` -The output from the second command is similar to: +The output is similar to: ```output Merged "arm-aks-cluster-demo" as current context in /home/ubuntu/.kube/config ``` -You are now ready to use `kubectl` +You are now ready to use `kubectl`. -3. Run the following command to see the status of the nodes. +2. Run the following command to see the status of the nodes. ```console kubectl get nodes @@ -245,71 +248,64 @@ kubectl get nodes Three nodes should be in the `Ready` state: ```output -NAME STATUS ROLES AGE VERSION -aks-demopool-40436376-vmss000000 Ready agent 10m v1.24.9 -aks-demopool-40436376-vmss000001 Ready agent 10m v1.24.9 -aks-demopool-40436376-vmss000002 Ready agent 10m v1.24.9 +NAME STATUS ROLES AGE VERSION +aks-demopool-15110407-vmss000000 Ready 2m5s v1.36.5 +aks-demopool-15110407-vmss000001 Ready 2m5s v1.36.5 +aks-demopool-15110407-vmss000002 Ready 2m4s v1.36.5 ``` -4. Run the following command to see the current pods running on the cluster. +3. Confirm the virtual machine size and architecture of the nodes: ```console -kubectl get pods -A +kubectl get nodes -L node.kubernetes.io/instance-type,kubernetes.io/arch ``` -The output will be similar to: +The output shows that the nodes are Cobalt 200 `Standard_D2ps_v7` virtual machines with the `arm64` architecture: ```output -NAMESPACE NAME READY STATUS RESTARTS AGE -kube-system azure-ip-masq-agent-fw66d 1/1 Running 0 12m -kube-system azure-ip-masq-agent-q7ltm 1/1 Running 0 12m -kube-system azure-ip-masq-agent-qs2rp 1/1 Running 0 12m -kube-system cloud-node-manager-k8fdg 1/1 Running 0 12m -kube-system cloud-node-manager-ml5jq 1/1 Running 0 12m -kube-system cloud-node-manager-phng2 1/1 Running 0 12m -kube-system coredns-59b6bf8b4f-msdzd 1/1 Running 0 13m -kube-system coredns-59b6bf8b4f-wbcgl 1/1 Running 0 11m -kube-system coredns-autoscaler-5655d66f64-g94zj 1/1 Running 0 13m -kube-system csi-azuredisk-node-9njln 3/3 Running 0 12m -kube-system csi-azuredisk-node-mnqnz 3/3 Running 0 12m -kube-system csi-azuredisk-node-rjmq7 3/3 Running 0 12m -kube-system csi-azurefile-node-7qmdn 3/3 Running 0 12m -kube-system csi-azurefile-node-fbpm7 3/3 Running 0 12m -kube-system csi-azurefile-node-j2sf5 3/3 Running 0 12m -kube-system konnectivity-agent-77467c5c84-52zsj 1/1 Running 0 2m19s -kube-system konnectivity-agent-77467c5c84-wdhms 1/1 Running 0 2m15s -kube-system kube-proxy-hnbpp 1/1 Running 0 12m -kube-system kube-proxy-wr6rm 1/1 Running 0 12m -kube-system kube-proxy-zssbf 1/1 Running 0 12m -kube-system metrics-server-5f8d84558d-5rtgs 2/2 Running 0 11m -kube-system metrics-server-5f8d84558d-lh2xk 2/2 Running 0 11m +NAME STATUS ROLES AGE VERSION INSTANCE-TYPE ARCH +aks-demopool-15110407-vmss000000 Ready 2m5s v1.36.5 Standard_D2ps_v7 arm64 +aks-demopool-15110407-vmss000001 Ready 2m5s v1.36.5 Standard_D2ps_v7 arm64 +aks-demopool-15110407-vmss000002 Ready 2m4s v1.36.5 Standard_D2ps_v7 arm64 ``` -5. Run `kubectl` to open a shell on one of the nodes. +4. Run the following command to see the current pods running on the cluster. ```console -kubectl debug node/aks-demopool-40436376-vmss000000 -it --image=ubuntu +kubectl get pods -A ``` -The terminal will open a shell with output similar to: +The output will be similar to: ```output -Creating debugging pod node-debugger-aks-demopool-40436376-vmss000000-b9tj5 with container debugger on node aks-demopool-40436376-vmss000000. -If you don't see a command prompt, try pressing enter. -root@aks-demopool-40436376-vmss000000:/# -``` - -6. At the new shell prompt, run the `uname` command: - -```console -uname -a +NAMESPACE NAME READY STATUS RESTARTS AGE +kube-system azure-cns-9hlcm 2/2 Running 0 4m8s +kube-system azure-cns-9zpvw 2/2 Running 0 4m7s +kube-system azure-cns-m6xqg 2/2 Running 0 4m8s +kube-system azure-ip-masq-agent-g8nr4 1/1 Running 0 4m7s +kube-system azure-ip-masq-agent-wv4zh 1/1 Running 0 4m8s +kube-system azure-ip-masq-agent-zhzq6 1/1 Running 0 4m8s +kube-system cloud-node-manager-8vxcc 1/1 Running 0 4m8s +kube-system cloud-node-manager-dr5m5 1/1 Running 0 4m8s +kube-system cloud-node-manager-vhkz5 1/1 Running 0 4m7s +kube-system coredns-5bf45f87d-95zhw 1/1 Running 0 4m34s +kube-system coredns-5bf45f87d-tgmx7 1/1 Running 0 3m42s +kube-system coredns-autoscaler-7467554f77-b5jvl 1/1 Running 0 4m34s +kube-system csi-azuredisk-node-8nstr 3/3 Running 0 4m7s +kube-system csi-azuredisk-node-jtjxn 3/3 Running 0 4m7s +kube-system csi-azuredisk-node-rwqqz 3/3 Running 0 4m8s +kube-system csi-azurefile-node-7pxf6 4/4 Running 0 4m7s +kube-system csi-azurefile-node-ljgdr 4/4 Running 0 4m7s +kube-system csi-azurefile-node-zgkx5 4/4 Running 0 4m8s +kube-system konnectivity-agent-7d7c8bcd59-8cr8d 1/1 Running 0 3m42s +kube-system konnectivity-agent-7d7c8bcd59-qmc7g 1/1 Running 0 4m21s +kube-system konnectivity-agent-autoscaler-5b658f6697-mhpkl 1/1 Running 0 4m21s +kube-system kube-proxy-4td8b 1/1 Running 0 4m7s +kube-system kube-proxy-p2rxj 1/1 Running 0 4m7s +kube-system kube-proxy-zdhdm 1/1 Running 0 4m8s +kube-system metrics-server-866c8cb87d-5ptrp 2/2 Running 0 3m36s +kube-system metrics-server-866c8cb87d-9jmmb 2/2 Running 0 3m36s ``` -The output confirm the node is an Arm instance: - -```output -Linux aks-demopool-40436376-vmss000000 5.15.0-1034-azure #41-Ubuntu SMP Fri Feb 10 19:59:55 UTC 2023 aarch64 aarch64 aarch64 GNU/Linux -``` - You have successfully created a Kubernetes cluster on AKS using Arm-based instances. diff --git a/content/learning-paths/servers-and-cloud-computing/aks/deploy_wordpress.md b/content/learning-paths/servers-and-cloud-computing/aks/deploy_wordpress.md index 735643d633..e7ff559863 100644 --- a/content/learning-paths/servers-and-cloud-computing/aks/deploy_wordpress.md +++ b/content/learning-paths/servers-and-cloud-computing/aks/deploy_wordpress.md @@ -16,7 +16,7 @@ You can use the cluster to deploy an example application, WordPress. ## Deploy WordPress Example -### Create Terraform files +### Create the Kubernetes manifest files The yaml files below are a modified version of the [Kubernetes WordPress Tutorial](https://kubernetes.io/docs/tutorials/stateful-application/mysql-wordpress-persistent-volume/) in the Kubernetes documentation. @@ -89,7 +89,7 @@ spec: tier: mysql spec: containers: - - image: mysql:8.0.30 + - image: mysql:8.4.13 name: mysql env: - name: MYSQL_DATABASE @@ -170,7 +170,7 @@ spec: tier: frontend spec: containers: - - image: wordpress:6.0.2-apache + - image: wordpress:7.1.5-apache name: wordpress env: - name: WORDPRESS_DB_HOST @@ -196,7 +196,7 @@ spec: claimName: wp-pv-claim ``` -### Apply the Terraform files +### Apply the manifests Run `kubectl apply` to update the configuration: @@ -218,7 +218,7 @@ deployment.apps/wordpress-mysql created ### Confirm WordPress is running -1. Check on volume claims to confirm the 20 Gb of storage has been created for MySQL and WordPress: +1. Check on volume claims to confirm the 20 GiB of storage has been created for MySQL and WordPress: ```console kubectl get pvc @@ -227,9 +227,9 @@ kubectl get pvc The output is similar to: ```output -NAME STATUS VOLUME CAPACITY ACCESS MODES STORAGECLASS AGE -mysql-pv-claim Bound pvc-b5ed7959-9a05-4759-a178-86f7e1393be0 20Gi RWO managed-csi 107s -wp-pv-claim Bound pvc-cb03c97b-adab-4e4f-ad91-fcfaa69b1a30 20Gi RWO managed-csi 107s +NAME STATUS VOLUME CAPACITY ACCESS MODES STORAGECLASS VOLUMEATTRIBUTESCLASS AGE +mysql-pv-claim Bound pvc-c1948fd9-1ba1-49e2-9b8e-734fe28bc03e 20Gi RWO managed-csi 11s +wp-pv-claim Bound pvc-91cf7663-f500-40eb-8011-5c9a27bed3a3 20Gi RWO managed-csi 11s ``` 2. Verify the WordPress and MySQL pods are running: @@ -242,8 +242,8 @@ The output is similar to: ```output NAME READY STATUS RESTARTS AGE -wordpress-6c5db6d5d7-zznww 1/1 Running 0 5m11s -wordpress-mysql-75467487bf-zs5vk 1/1 Running 0 5m11s +wordpress-7b75d8584c-sjt75 1/1 Running 0 61s +wordpress-mysql-585c4786dd-rq74n 1/1 Running 0 61s ``` 3. Verify that the persistent volumes have been attached: @@ -256,8 +256,8 @@ The output is similar to: ```output NAME ATTACHER PV NODE ATTACHED AGE -csi-643e8fc7abcd16d5e98eeffcb0cff690c20aa2fb90a55c38889a570295fa07d2 disk.csi.azure.com pvc-b5ed7959-9a05-4759-a178-86f7e1393be0 aks-demopool-85935132-vmss000001 true 5m52s -csi-eecaead981dd085e638d388afaa2a325019fcda81bfcda91e867b69d41fc4482 disk.csi.azure.com pvc-cb03c97b-adab-4e4f-ad91-fcfaa69b1a30 aks-demopool-85935132-vmss000001 true 5m52s +csi-0637ef93dc59f8511dc360b2ea1e1e27b06b2dc01333d1e9b54a2ebd1c5dbfca disk.csi.azure.com pvc-c1948fd9-1ba1-49e2-9b8e-734fe28bc03e aks-demopool-15110407-vmss000002 true 59s +csi-f2eaeaf495901df3b7c1aeeb21b006581f4a52b52da669417b6a7c876b1f8964 disk.csi.azure.com pvc-91cf7663-f500-40eb-8011-5c9a27bed3a3 aks-demopool-15110407-vmss000000 true 58s ``` 4. Get the external IP address of the WordPress deployment: @@ -269,25 +269,25 @@ kubectl get svc The output is similar to: ```output -NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE -kubernetes ClusterIP 10.0.0.1 443/TCP 21m -wordpress LoadBalancer 10.0.69.21 20.10.212.247 80:31829/TCP 7m23s -wordpress-mysql ClusterIP None 3306/TCP 7m22s +NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE +kubernetes ClusterIP 10.0.0.1 443/TCP 6m50s +wordpress LoadBalancer 10.0.90.248 172.193.248.164 80:32351/TCP 13s +wordpress-mysql ClusterIP None 3306/TCP 13s ``` The IP address in the `EXTERNAL-IP` column is the one to use. 5. Open the external IP in a browser. -The WordPress welcome screen will be displayed. +The WordPress language selection screen is displayed. -![aks3 #center](https://github.com/ArmDeveloperEcosystem/arm-learning-paths/assets/71631645/fb2ca43c-59d9-4a1f-8163-7d09759366b6) +![WordPress installation page with a language selection list and a Continue button #center](_images/wordpress-setup.webp "WordPress language selection screen") You have successfully installed WordPress on your Arm-based AKS cluster. ### Clean up resources -Run `terraform destroy` to delete all resources created. +Run `terraform destroy` in the directory that contains your Terraform files to delete the AKS cluster and the resource group. This also deletes the WordPress volumes and the load balancer. ```console terraform destroy diff --git a/content/learning-paths/servers-and-cloud-computing/axion-agent-studio/01-workflow.md b/content/learning-paths/servers-and-cloud-computing/axion-agent-studio/01-workflow.md index 8f4ad47d04..c2372d3408 100644 --- a/content/learning-paths/servers-and-cloud-computing/axion-agent-studio/01-workflow.md +++ b/content/learning-paths/servers-and-cloud-computing/axion-agent-studio/01-workflow.md @@ -15,7 +15,7 @@ The prepared repository contains a working storefront, catalog, and checkout. Yo ![Technical deployment diagram showing hosted Gemini outside GKE, an N4A manager, three separate Gemma sandbox Pods sharing one C4A VM, and an N4A validator. The manager coordinates all service calls and enables the shop only after validation passes.#center](images/architecture-technical.svg "Deployment boundaries and numbered workflow stages. VM capacity is distinct from Pod requests and limits.") -[Open the full-size architecture diagram (SVG)](../images/architecture-technical.svg) · [Download the high-resolution PNG](../images/architecture-technical.png) +[Open the full-size architecture diagram (SVG)](../images/architecture-technical.svg) · [Download the high-resolution PNG](../images/architecture-technical.webp) 1. The **manager** calls hosted Gemini through Vertex AI to extract a supported policy and a plan for three roles. 2. The **Backend Engineer** and **Frontend Engineer** run concurrently. Each calls its own local Gemma server. The backend produces `pricing.py`. The frontend produces four constrained fragments that the worker assembles into the existing `checkout.html`. diff --git a/content/learning-paths/servers-and-cloud-computing/axion-agent-studio/images/architecture-technical.png b/content/learning-paths/servers-and-cloud-computing/axion-agent-studio/images/architecture-technical.png deleted file mode 100644 index 0459867958..0000000000 Binary files a/content/learning-paths/servers-and-cloud-computing/axion-agent-studio/images/architecture-technical.png and /dev/null differ diff --git a/content/learning-paths/servers-and-cloud-computing/axion-agent-studio/images/architecture-technical.webp b/content/learning-paths/servers-and-cloud-computing/axion-agent-studio/images/architecture-technical.webp new file mode 100644 index 0000000000..e9941d8f1a Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/axion-agent-studio/images/architecture-technical.webp differ diff --git a/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/_images/azure-cobalt-vm.webp b/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/_images/azure-cobalt-vm.webp deleted file mode 100644 index 6728703cd7..0000000000 Binary files a/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/_images/azure-cobalt-vm.webp and /dev/null differ diff --git a/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/_images/github-run.webp b/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/_images/github-run.webp index 51175892e0..695161e9d6 100644 Binary files a/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/_images/github-run.webp and b/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/_images/github-run.webp differ diff --git a/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/_images/kubernetes-deployment.webp b/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/_images/kubernetes-deployment.webp deleted file mode 100644 index 8e9a8ccf13..0000000000 Binary files a/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/_images/kubernetes-deployment.webp and /dev/null differ diff --git a/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/_index.md b/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/_index.md index 02eed44034..8ff742d7ba 100644 --- a/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/_index.md @@ -1,14 +1,14 @@ --- -title: Deploy a .NET application on Microsoft Azure Cobalt 100 VMs -description: Learn how to configure a self-hosted GitHub runner on Azure Cobalt 100, create an AKS cluster with Terraform, and deploy a .NET application using GitHub Actions CI/CD. +title: Deploy a .NET application on Microsoft Azure Cobalt 200 VMs +description: Learn how to configure a self-hosted GitHub runner on Azure Cobalt 200, create an AKS cluster with Terraform, and deploy a .NET application using GitHub Actions CI/CD. minutes_to_complete: 60 -who_is_this_for: This is an advanced topic for software developers who want to develop cloud-native applications using GitHub Actions and Azure Kubernetes Service (AKS), and run them on Microsoft Azure Cobalt 100 VMs. +who_is_this_for: This is an advanced topic for software developers who want to develop cloud-native applications using GitHub Actions and Azure Kubernetes Service (AKS), and run them on Microsoft Azure Cobalt 200 VMs. learning_objectives: - - Configure an Azure Cobalt 100 VM as a self-hosted GitHub runner. - - Create an AKS cluster with Arm-based Azure Cobalt 100 nodes using Terraform. + - Configure an Azure Cobalt 200 VM as a self-hosted GitHub runner. + - Create an AKS cluster with Arm-based Azure Cobalt 200 nodes using Terraform. - Deploy a .NET application to AKS with GitHub Actions using the self-hosted Arm64-based runner. prerequisites: @@ -31,19 +31,19 @@ generated_summary_faq: faq_generated_at: '2026-06-26T18:33:18Z' faq_source_hash: b5bd3abde8d9dd3146e0f11f4819ac510417ad7f707b4d0970c02fd63801b358 summary: >- - You'll set up a self-hosted GitHub Actions runner on an Azure Cobalt 100 - VM and use it to build a .NET 8 web application for `arm64`. With Terraform, you'll create an - Azure Kubernetes Service (AKS) cluster backed by Cobalt 100-based nodes, then use a GitHub + You'll set up a self-hosted GitHub Actions runner on an Azure Cobalt 200 + VM and use it to build a .NET 10 web application for `arm64`. With Terraform, you'll create an + Azure Kubernetes Service (AKS) cluster backed by Cobalt 200-based nodes, then use a GitHub Actions workflow to deploy the application to the cluster. Along the way, you'll select an appropriate - Cobalt 100-based VM series for the runner, confirm the runner is available to execute jobs, and + Cobalt 200-based VM series for the runner, confirm the runner is available to execute jobs, and validate that the workload targets the Arm-based AKS nodes. The result is a working CI/CD - path from source to a running application on Azure Cobalt 100 infrastructure. + path from source to a running application on Azure Cobalt 200 infrastructure. faqs: - - question: Which Azure Cobalt 100 VM series should I use for the self-hosted runner? + - question: Which Azure Cobalt 200 VM series should I use for the self-hosted runner? answer: >- - Azure Cobalt 100 offers general-purpose Dpsv6/Dplsv6 and memory-optimized Epsv6 series. - Choose based on your build and deployment needs. The Learning Path doesn't prescribe a specific - size. + Azure Cobalt 200 offers general-purpose Dpsv7 and Dplsv7 series, among others. This + Learning Path uses a Dpsv7 VM. Your subscription and region must have access to Dpsv7 sizes and + sufficient vCPU quota. - question: Do I have to use a self-hosted runner, or can I use GitHub-hosted `arm64` runners? answer: >- GitHub-hosted `arm64` runners are generally available for Team and Enterprise Cloud accounts. @@ -51,11 +51,11 @@ generated_summary_faq: - question: How do I know the self-hosted GitHub Actions runner is ready before triggering the workflow? answer: >- - Confirm the runner is installed on the Azure Cobalt 100 VM and appears online in GitHub. + Confirm the runner is installed on the Azure Cobalt 200 VM and appears online in GitHub. Don't start the workflow until the runner reports an available status. - question: What result should I expect after applying the Terraform configuration? answer: >- - Terraform creates an AKS cluster with node pools based on Azure Cobalt 100. This cluster + Terraform creates an AKS cluster with node pools based on Azure Cobalt 200. This cluster is then targeted by the GitHub Actions workflow that deploys the .NET application. - question: How can I verify the .NET application is running on Arm-based nodes in AKS? answer: >- @@ -89,8 +89,8 @@ operatingsystems: further_reading: - resource: - title: Developing Cloud-native Applications with New Arm Neoverse CSS-based Microsoft Azure Cobalt 100 Virtual Machines - link: https://newsroom.arm.com/blog/microsoft-azure-cobalt-100-vm + title: Introducing Azure Cobalt 200 virtual machines + link: https://azure.microsoft.com/en-us/blog/new-azure-cobalt-200-vms-deliver-50-performance-improvement-fully-optimized-for-modern-agentic-ai-workloads/ type: blog - resource: title: AKS documentation diff --git a/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/azure-cobalt.md b/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/azure-cobalt.md index 5c2546d34b..77920e1d14 100644 --- a/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/azure-cobalt.md +++ b/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/azure-cobalt.md @@ -6,7 +6,7 @@ weight: 3 layout: "learningpathall" --- -In this Learning Path, you will build a .NET 8-based web application using a self-hosted GitHub Actions Arm64 runner. You will deploy the application in an Azure Kubernetes Cluster, running on Microsoft Cobalt 100-based VMs. Self-hosted runners offer increased control and flexibility in terms of infrastructure, operating systems, and tools, in comparison to GitHub-hosted runners. +You'll build a .NET 10 web application using a self-hosted GitHub Actions Arm64 runner and deploy it to an Azure Kubernetes Service cluster with Azure Cobalt 200-based VMs. Self-hosted runners offer increased control and flexibility in terms of infrastructure, operating systems, and tools, in comparison to GitHub-hosted runners. {{% notice Note %}} * GitHub-hosted Arm64 runners have now reached General Availability. If your GitHub account is part of a Team or an Enterprise Cloud plan, you can use GitHub-hosted Arm64 runners. @@ -15,13 +15,27 @@ In this Learning Path, you will build a .NET 8-based web application using a sel {{% /notice %}} ## How do I create an Azure Virtual Machine? -Creating a virtual machine based on Azure Cobalt 100 is no different from creating any other VM in Azure. To create an Azure virtual machine, launch the [Azure portal](https://portal.azure.com/) and navigate to Virtual Machines. +Creating a virtual machine based on Azure Cobalt 200 is no different from creating any other VM in Azure. To create an Azure virtual machine, launch the [Azure portal](https://portal.azure.com/) and navigate to Virtual Machines. -Select `Create Azure Virtual Machine`, and fill in the details such as `Name`, and `Region`. +Select **Create Azure Virtual Machine**, and fill in details such as **Name** and **Region**. Select **Ubuntu Server 24.04 LTS** as the image and **Arm64** as the VM architecture. -In the `Size` field, click on `See all sizes` and select the `D-Series v6` family of VMs. Select `D2psv6` from the list and create the VM. +In the **Size** field, select **See all sizes**. The Cobalt 200 sizes might appear under **Other sizes**. Select **D2ps_v7** from the **D-series v7** family, configure SSH public key authentication, and create the VM. -![azure-cobalt-vm #center](_images/azure-cobalt-vm.webp) +Your subscription and selected region must have access to Dpsv7 sizes and sufficient vCPU quota. This Learning Path was validated in **West US 2**. + +After the VM is running, connect with SSH and verify the architecture and CPU model: + +```console +uname -m +lscpu | grep 'Model name' +``` + +The output is similar to: + +```output +aarch64 +Model name: Neoverse-V3 +``` {{% notice Note %}} To learn more about Arm-based VMs in Azure, refer to "Getting Started with Microsoft Azure" in [*Get started with Arm-based cloud instances*](/learning-paths/servers-and-cloud-computing/csp/azure/). @@ -29,44 +43,96 @@ To learn more about Arm-based VMs in Azure, refer to "Getting Started with Micro ## How do I configure the GitHub repository? -The source code for the application and configuration files that you require to follow this Learning Path are hosted in this [msbuild-azure github repository](https://github.com/pbk8s/msbuild-azure). This repository also contains the Dockerfile and Kubernetes deployment manifests that you require to deploy the .NET 8 based application. +The source code and configuration files are hosted in the [msbuild-azure GitHub repository](https://github.com/pbk8s/msbuild-azure). The repository also contains the Dockerfile and Kubernetes deployment manifests. After forking it, you'll update the application to use .NET 10. + +Fork the repository first. Then prepare the VM and configure the runner. + +### Install the tools the workflow needs on the VM + +The workflow builds a container image, runs Azure CLI commands, and deploys with `kubectl` on the runner. Connect to the `D2ps_v7` VM you created in the previous step and install these tools before you configure the runner: + +* Docker Engine. Follow the [Docker Engine install guide](/install-guides/docker/docker-engine/). +* Azure CLI. Follow the [Azure CLI install guide](/install-guides/azure-cli/). +* `kubectl`. Follow the [kubectl install guide](/install-guides/kubectl/). + +Confirm that each tool works: + +```console +docker run --rm hello-world +az version +kubectl version --client +``` + +The `docker` command must work without `sudo`. -Follow these steps: +### Configure the runner -* Start by forking the repository. +1. In your fork, navigate to the **Settings** tab and select **Actions** in the navigation pane. -* Once the GitHub repository is forked, navigate to the `Settings` tab, and click on `Actions` in the left navigation pane. +2. In **Runners**, select **New self-hosted runner** to configure the runner. - * In `Runners`, select `New self-hosted runner`, which opens up a new page to configure the runner. +3. For **Runner image**, select **Linux**, and for **Architecture**, select **ARM64**. -* For `Runner image`, select `Linux`, and for `Architecture`, select `ARM64`. +4. Run the commands shown on the `D2ps_v7` VM to download, extract, and configure the runner. -* Using the commands shown, execute them on the `D2psv6` VM you created in the previous step. +5. After you run `config.sh`, install and start the runner as a service so it keeps running after you close your SSH session. Run these commands from the runner directory: -* Once you have configured the runner successfully, you will see a self-hosted runner appear on the same page in GitHub. + ```console + sudo ./svc.sh install + sudo ./svc.sh start + sudo ./svc.sh status + ``` + + The status output shows `active (running)` and `Listening for Jobs`. + +6. Confirm that the self-hosted runner appears on the same GitHub page with the **Idle** status. {{% notice Note %}} -To learn more about creating an Arm-based self-hosted runner, see this Learning Path [*Use Self-Hosted Arm64-based runners in GitHub Actions for CI/CD*](/learning-paths/laptops-and-desktops/self_hosted_cicd_github/). +To learn more about creating an Arm-based self-hosted runner, see [Use Self-Hosted Arm64-based runners in GitHub Actions for CI/CD](/learning-paths/laptops-and-desktops/self_hosted_cicd_github/). {{% /notice %}} -## How do I create an AKS cluster with Arm-based Azure Cobalt 100 nodes using Terraform? +## How do I create an AKS cluster with Arm-based Azure Cobalt 200 nodes using Terraform? + +To create an Arm-based AKS cluster, follow [Create an Arm-based Kubernetes cluster on Microsoft Azure Kubernetes Service](/learning-paths/servers-and-cloud-computing/aks/cluster_deployment/). The Terraform configuration in that Learning Path uses the Cobalt 200 `Standard_D2ps_v7` VM size for the cluster nodes and **West US 2** as the default region. + +Your subscription and selected region must have access to Dpsv7 sizes and sufficient vCPU quota. -You can create an Arm-based AKS cluster by following the steps in this Learning Path [*Create an Arm-based Kubernetes cluster on Microsoft Azure Kubernetes Service*](/learning-paths/servers-and-cloud-computing/aks/cluster_deployment/). +Note the `resource_group_name` and `cluster_name` values that Terraform prints. You use them later as the `CLUSTER_RESOURCE_GROUP_NAME` and `CLUSTER_NAME` GitHub secrets. -Make sure to update the `main.tf` file with the correct VM as shown below: +After the cluster is created, connect to it and confirm that the nodes use the Cobalt 200 VM size and the `arm64` architecture: ```console -`vm_size` = `Standard_D2ps_v6` +kubectl get nodes -L node.kubernetes.io/instance-type,kubernetes.io/arch ``` + +The output is similar to: + +```output +NAME STATUS ROLES AGE VERSION INSTANCE-TYPE ARCH +aks-demopool-33234337-vmss000000 Ready 2m43s v1.36.5 Standard_D2ps_v7 arm64 +aks-demopool-33234337-vmss000001 Ready 2m45s v1.36.5 Standard_D2ps_v7 arm64 +aks-demopool-33234337-vmss000002 Ready 2m19s v1.36.5 Standard_D2ps_v7 arm64 +``` + Once you have successfully created the cluster, you can proceed to the next section. ## How do I create a container registry with Azure Container Registry (ACR)? -To create a container registry in Azure Container Registry to host the Docker images for your application, use the following command: +To create a container registry in Azure Container Registry to host the Docker images for your application, use the following command. Replace `` and `` with your resource group and a globally unique registry name: ```console -az acr create --resource-group myResourceGroup --name mycontainerregistry +az acr create --resource-group --name --sku Basic ``` + +Use the registry name, without `.azurecr.io`, for the `ACR_Name` GitHub secret in the next section. + +Allow the AKS cluster to pull images from the registry. Replace the placeholders with your cluster resource group, cluster name, and registry name: + +```console +az aks update --resource-group --name --attach-acr +``` + +This command needs permission to create role assignments. For registries using repository-level ABAC permissions, follow the [AKS and ACR authentication guidance](https://learn.microsoft.com/en-us/azure/aks/cluster-container-registry-integration) instead. ## How do I set up GitHub Secrets? The next step allows GitHub Actions to access the Azure Container Registry to push application docker images and Azure Kubernetes Service to deploy application pods. @@ -74,38 +140,62 @@ The next step allows GitHub Actions to access the Azure Container Registry to pu Create the following secrets in your GitHub repository: - Populate `ACR_Name` with the name of your Azure Container Registry. -- Populate `AZURE_CREDENTIALS` with Azure Credentials of a Service Principal. +- Populate `AZURE_CREDENTIALS` with the JSON output of the service principal command in the next section. - Populate `CLUSTER_NAME` with the name of your AKS cluster. - Populate `CLUSTER_RESOURCE_GROUP_NAME` with the name of your resource group. -Refer to this [guide](https://learn.microsoft.com/en-us/azure/developer/github/connect-from-azure-secret) for further information about signing into Azure using GitHub Actions. +### Create a service principal for GitHub Actions -## Deploy a .NET-based application +The `AZURE_CREDENTIALS` secret holds a service principal that GitHub Actions uses to push images to the registry and deploy to the cluster. Get your subscription ID: -.NET added support for Arm64 applications starting with version 6. Several performance enhancements have been made in later versions. The latest version that supports Arm64 targets is .NET 9. In this Learning Path, you will use the .NET 8 SDK for application development. +```console +SUB=$(az account show --query id -o tsv) +echo $SUB +``` -Follow these steps: +Create the service principal with the Contributor role on the resource group that contains your registry. Replace `` with that resource group: + +```console +az ad sp create-for-rbac --name cobalt200-gh-actions --role contributor --scopes /subscriptions/$SUB/resourceGroups/ --json-auth +``` -* In your fork of the GitHub repository, inspect the `aks-ga-demo.csproj` file. +The command prints a JSON document that contains a client secret. Copy the entire JSON output, including the braces, into the `AZURE_CREDENTIALS` secret. You can't view the secret again later. Don't commit it or share it. -* Verify that the `TargetFramework` field has `net8.0` as the value. +{{% notice Note %}} +Some Azure CLI versions print a warning that `--sdk-auth` is deprecated when you use `--json-auth`. The output is the same, and you can ignore the warning. +{{% /notice %}} -The contents of the file are shown below: +Give the service principal the same role on the resource group that contains your AKS cluster. Replace `` with that resource group: ```console +APPID=$(az ad sp list --display-name cobalt200-gh-actions --query "[0].appId" -o tsv) +az role assignment create --assignee $APPID --role contributor --scope /subscriptions/$SUB/resourceGroups/ +``` + +If your registry and cluster are in the same resource group, skip this step. + +Refer to this [guide](https://learn.microsoft.com/en-us/azure/developer/github/connect-from-azure-secret) for further information about signing into Azure using GitHub Actions. + +## Deploy a .NET-based application + +.NET supports Arm64 applications. Update the example application to use the .NET 10 SDK and runtime. + +In your fork of the GitHub repository, edit `aks-ga-demo.csproj` and set `TargetFramework` to `net10.0`: + +```xml - net8.0 + net10.0 aks_ga_demo ``` -You can inspect the contents of the `Dockerfile` within your repository as well. This is a multi-stage Dockerfile with the following stages: +Update the `Dockerfile` in your fork to use .NET 10 in the base and build stages. Set `ASPNETCORE_URLS` so the application listens on port 80, matching the Kubernetes manifests. This is a multi-stage Dockerfile with the following stages: -1. `base` stage - prepares the base environment with the `.NET 8 SDK` and exposes ports 80 and 443. +1. `base` stage - prepares the base environment with the .NET 10 SDK and exposes ports 80 and 443. 2. `build` stage - restores dependencies and builds the application. @@ -113,13 +203,16 @@ You can inspect the contents of the `Dockerfile` within your repository as well. 4. `final` stage - copies the published application into the final image and sets the entry point to run the application. -```console -FROM mcr.microsoft.com/dotnet/sdk:8.0 AS base +Replace the contents of `Dockerfile` with: + +```dockerfile +FROM mcr.microsoft.com/dotnet/sdk:10.0 AS base WORKDIR /app EXPOSE 80 EXPOSE 443 +ENV ASPNETCORE_URLS=http://+:80 -FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build +FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build WORKDIR /src COPY ["aks-ga-demo.csproj", "./"] RUN dotnet restore "./aks-ga-demo.csproj" @@ -136,7 +229,7 @@ COPY --from=publish /app/publish . ENTRYPOINT ["dotnet", "aks-ga-demo.dll"] ``` -Next, navigate to the `k8s` folder and check the Kubernetes yaml files. The `deployment.yml` file defines a deployment for the application. It specifies the container image to use from ACR and exposes port 80 for the application. The deployment ensures that the application runs with the defined resource constraints and is accessible on the specified port. +Next, edit `k8s/deployment.yml` in your fork. Replace `msbuilddemo` in the image name with your own registry name, matching `ACR_Name`. The file defines the application deployment and exposes port 80. The following example uses `` as a placeholder; replace it with your registry name: ```yaml apiVersion: apps/v1 @@ -154,7 +247,7 @@ spec: spec: containers: - name: githubactions-aks-demo - image: msbuilddemo.azurecr.io/githubactions-aks-demo + image: .azurecr.io/githubactions-aks-demo resources: limits: memory: "128Mi" @@ -179,7 +272,7 @@ spec: targetPort: 80 ``` -Finally, have a look at the GitHub Actions file located at `.github/workflows/deploytoAKS.yml` +Finally, replace `.github/workflows/deploytoAKS.yml` in your fork with the following workflow. It uses the `ACR_Name` secret for registry login, image pushes, and deployment: ```yaml name: Deploy .NET app @@ -193,6 +286,8 @@ jobs: deploy: name: Deploy application runs-on: self-hosted + env: + ACR_NAME: ${{ secrets.ACR_Name }} steps: - name: Checkout repo @@ -207,12 +302,12 @@ jobs: creds: '${{ secrets.AZURE_CREDENTIALS }}' - name: ACR login - run: az acr login --name msbuilddemo + run: az acr login --name "$ACR_NAME" - name: Tag and push image run: | - docker tag githubactions-aks-demo:'${{github.sha}}' msbuilddemo.azurecr.io/githubactions-aks-demo:'${{github.sha}}' - docker push msbuilddemo.azurecr.io/githubactions-aks-demo:'${{github.sha}}' + docker tag githubactions-aks-demo:'${{github.sha}}' "$ACR_NAME.azurecr.io/githubactions-aks-demo:${{github.sha}}" + docker push "$ACR_NAME.azurecr.io/githubactions-aks-demo:${{github.sha}}" - name: Get AKS credentials env: @@ -232,9 +327,11 @@ jobs: k8s/deployment.yml k8s/service.yml images: | - msbuilddemo.azurecr.io/githubactions-aks-demo:${{github.sha }} + ${{ secrets.ACR_Name }}.azurecr.io/githubactions-aks-demo:${{ github.sha }} ``` +Commit and push the updated project file, Dockerfile, deployment manifest, and workflow to your fork. A push also triggers the workflow. + This GitHub Actions yaml file defines a workflow to deploy a .NET application to Azure Kubernetes Service (AKS). This workflow runs on the self-hosted GitHub Actions runner that you configured in a previous step. This workflow can be triggered manually, or on a push to the repository. It has the following main steps: @@ -249,14 +346,40 @@ It has the following main steps: ## How do I run the CI/CD pipeline? -The next step is to trigger the pipeline manually by navigating to `Actions` tab in the GitHub repository. Select `Deploy .NET app`, and click on `Run Workflow`. You can also execute the pipeline by making a commit to the repository. Once the pipeline executes successfully, you will see the Actions output in a format similar to what is shown below: +To trigger the pipeline manually, navigate to the **Actions** tab in the GitHub repository. Select **Deploy .NET app**, then select **Run Workflow**. You can also run the pipeline by making a commit to the repository. When the pipeline runs successfully, the Actions output looks similar to this: + +![GitHub Actions log showing the Deploy application step succeeding after kubectl creates the deployment and service #center](_images/github-run.webp "Successful Deploy application step") + +Check your Kubernetes cluster for the new application pod: + +```console +kubectl get pods -o wide +``` + +The output is similar to: + +```output +NAME READY STATUS RESTARTS AGE IP NODE NOMINATED NODE READINESS GATES +githubactions-aks-demo-8667bb85bc-w8tqq 1/1 Running 0 92s 10.244.2.185 aks-demopool-33234337-vmss000002 +``` -![github-run #center](_images/github-run.webp) +The pod runs on one of the `Standard_D2ps_v7` Arm64 nodes you created earlier. Next, check the service: -You can check your kubernetes cluster and see new application pods deployed on the cluster as shown below: +```console +kubectl get service githubactions-aks-demo-service +``` -![kubernetes-deployment #center](_images/kubernetes-deployment.webp) +The output is similar to: +```output +NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE +githubactions-aks-demo-service LoadBalancer 10.0.217.54 48.202.105.207 8080:31431/TCP 102s +``` +Use the `EXTERNAL-IP` value from your own output to test the application: +```console +curl -s -o /dev/null -w "%{http_code}\n" http://:8080/ +``` +The command prints `200`. You can also open `http://:8080/` in a browser. diff --git a/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/background.md b/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/background.md index 2648ea4c7f..4e41c21c32 100644 --- a/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/background.md +++ b/content/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/background.md @@ -6,16 +6,10 @@ weight: 2 layout: "learningpathall" --- -## What is the Azure Cobalt 100 Arm-based processor? +## What is the Azure Cobalt 200 Arm-based processor? -Cobalt 100 is Microsoft's first Arm-based server processor, built using the Armv9 Neoverse-N2 CPU. +Azure Cobalt 200 is Microsoft's second-generation Arm-based server processor, built on Arm Neoverse Compute Subsystems V3 (CSS V3). It is designed for cloud-native, scale-out Linux workloads such as the CI/CD runners and containerized applications in this Learning Path. -The Cobalt 100 processor is optimized for the performance of scale-out cloud-based applications. - -The Azure Cobalt 100 VM instances include two series: - -* The general-purpose `Dpsv6 and Dplsv6` virtual machine series. -* The memory-optimized `Epsv6` virtual machine series. - -To learn more about Azure Cobalt 100, refer to the blog ["Announcing the preview of new Azure VMs based on the Azure Cobalt 100 processor"](https://techcommunity.microsoft.com/t5/azure-compute-blog/announcing-the-preview-of-new-azure-vms-based-on-the-azure/ba-p/4146353). +Azure Cobalt 200 VMs include several series, such as the general-purpose Dpsv7 and Dplsv7 series and the memory-optimized Epsv7 series. In this Learning Path, you use the general-purpose Dpsv7 series. +To learn more about Azure Cobalt 200, see Microsoft's [introduction to Azure Cobalt 200 virtual machines](https://azure.microsoft.com/en-us/blog/new-azure-cobalt-200-vms-deliver-50-performance-improvement-fully-optimized-for-modern-agentic-ai-workloads/). diff --git a/content/learning-paths/servers-and-cloud-computing/cca-veraison-aws/cca-veraison-aws-upstream-fixes.tar.gz b/content/learning-paths/servers-and-cloud-computing/cca-veraison-aws/cca-veraison-aws-upstream-fixes.tar.gz new file mode 100644 index 0000000000..c869f8e2f3 Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/cca-veraison-aws/cca-veraison-aws-upstream-fixes.tar.gz differ diff --git a/content/learning-paths/servers-and-cloud-computing/cca-veraison-aws/deployment.md b/content/learning-paths/servers-and-cloud-computing/cca-veraison-aws/deployment.md index c5e99892f4..61196d4c72 100644 --- a/content/learning-paths/servers-and-cloud-computing/cca-veraison-aws/deployment.md +++ b/content/learning-paths/servers-and-cloud-computing/cca-veraison-aws/deployment.md @@ -6,33 +6,154 @@ weight: 5 layout: learningpathall --- +## Prepare your build environment + +Lets first establish what AWS region will be used. On your Ubuntu host: + +```bash +# Set this to the AWS region to be used +export AWS_REGION=us-east-1 +``` + +Now, still in your Ubuntu host, run the following: + +```bash +# Leave any previous python venv... +deactivate +hash -r + +# Install virtual-environment support for Ubuntu's Python 3.12. +sudo apt update +sudo apt install python3.12-venv jq + +# Use a fresh directory, preserving the existing ~/venv/aws environment. +export VERAISON_AWS_VENV="$HOME/venv/veraison-aws-py312" + +/usr/bin/python3.12 -m venv "$VERAISON_AWS_VENV" +source "$VERAISON_AWS_VENV/bin/activate" + +# Set this to fix issues with the make deploy scripts +export VERAISON_DEB= + +# Fixes and requirements for make deploy +sudo apt install gettext-base + +# Follows AWS_REGION +export AWS_DEFAULT_REGION=${AWS_REGION} + +# Verify what bootstrap will use. +python --version +python -m pip --version +``` + +You should see output similar to: + +```output +Python 3.12.3 +pip 24.0 from /usr/lib/python3/dist-packages/pip (python 3.12) +``` + +Your Ubuntu environment is now ready for creating the Veraison deployment + ## Create the Veraison Deployment Now that your AWS account, internet domain and certificate are prepared, you are ready to deploy the Veraison services into AWS. This process is highly automated, but will take between 30 to 60 minutes, as several resources need to be created in AWS. -The deployment process is documented in [Veraison's GitHub repository](https://github.com/veraison/services/blob/main/deployments/aws/README.md). +The deployment process is documented in [Veraison's GitHub repository](https://github.com/veraison/services/blob/ebadb733d44ba2f8ffefdae49a0f0d3c1bfc9800/deployments/aws/README.md). You can follow the instructions below to deploy the Veraison services into AWS: -Use the [Bootstrap](https://github.com/veraison/services/tree/main/deployments/aws#bootstrap) process first to clone the Veraison source code from GitHub and set up your build environment. This will take care of installing the dependencies that you need on your development machine. +Use the [Bootstrap](https://github.com/veraison/services/blob/ebadb733d44ba2f8ffefdae49a0f0d3c1bfc9800/deployments/aws/README.md#bootstrap) process first to clone the Veraison source code from GitHub and set up your build environment. This will take care of installing the dependencies that you need on your development machine. + +The pinned services revision uses CoRIM-store commit `a2a60b6a11ad`, as specified in its [dependency file](https://github.com/veraison/services/blob/ebadb733d44ba2f8ffefdae49a0f0d3c1bfc9800/go.mod#L44). Its AWS deployment script still selects an older CoRIM-store tool for the sentinel image. Update that tool's pin before creating the image so database initialization includes the migrations required by the services, including the `tokens` table. + +Lets initialize our deployment build environment: ```bash -cd $HOME +mkdir $HOME/cca_veraison +cd $HOME/cca_veraison git clone https://github.com/veraison/services.git -git -C services checkout ebadb73 +git -C services checkout 61cf6088c1dc4f69cdd08e6a05f75c9fd3b2c6a6 +``` + +Then, we can bootstrap our deployment: + +```bash cd services/deployments/aws make bootstrap ``` -Once your build environment is bootstrapped, you will use the [Quickstart](https://github.com/veraison/services/tree/main/deployments/aws#quickstart) procedure to provide some AWS configuration and create the deployment. -You'll provide AWS-specific settings, including the IDs for your VPC and subnets, and the CIDR block allowed access to the deployment. In this deployment, you will use `misc/arm.cfg` file for example. Make sure you update `VERAISON_AWS_REGION` to the same region where you created your AWS certificate for your new domain.`VERAISON_AWS_DNS_NAME` needs to match the domain name you chose. +Once your build environment is bootstrapped, you will use the [Quickstart](https://github.com/veraison/services/blob/ebadb733d44ba2f8ffefdae49a0f0d3c1bfc9800/deployments/aws/README.md#quickstart) procedure to provide some AWS configuration and create the deployment. -Once the account-specific config file is created, define `AWS_ACCOUNT_CFG` environment variable to point to it and then create the deployment. +Next lets confirm that we have some additional requirements setup for the deployment to succeed: ```bash source env/env.bash -export AWS_ACCOUNT_CFG=misc/arm.cfg # replace with path to your config + +# Ensure that we have the packages needed +"$VERAISON_AWS_VENV/bin/python" -m pip install --force-reinstall "envsubst==0.1.5" + +# Replace the venv's command wrapper with GNU envsubst. +ln -sf /usr/bin/envsubst "$VIRTUAL_ENV/bin/envsubst" +hash -r + +envsubst --version +"$VERAISON_AWS_VENV/bin/python" -c \ + 'from envsubst import envsubst; print("Python envsubst import OK")' +``` + +Your output should resemble: + +```output +envsubst (GNU gettext-runtime) 0.21 +Copyright (C) 2003-2020 Free Software Foundation, Inc. +License GPLv3+: GNU GPL version 3 or later +This is free software: you are free to change and redistribute it. +There is NO WARRANTY, to the extent permitted by law. +Written by Bruno Haible. +Python envsubst import OK +``` + +You'll provide AWS-specific settings, including the IDs for your VPC and subnets, and the CIDR block allowed access to the deployment. In this deployment, you will use `misc/arm.cfg` file for example. Make sure you update `VERAISON_AWS_REGION` to the same region where you created your AWS certificate for your new domain.`VERAISON_AWS_DNS_NAME` needs to match the domain name you chose. + +Please add the following to your `misc/arm.cfg` as well below `VERAISON_AWS_REGION`: + +```bash +AWS_DEFAULT_REGION="$VERAISON_AWS_REGION" +AWS_REGION="$VERAISON_AWS_REGION" +``` + +An example of a configured `misc/arm.cfg` looks something like this (your AWS region and DNS name may/will likely be different though): + +```output +############################################################################## +# Veraison Deployment Account-specific settings. +# These settings are specific to the Arm account used by the core development +# team. Users without access to this account must provide their own version of +# this file (or configure these settings inside deployment.cfg). +############################################################################## +VERAISON_AWS_REGION=us-east-1 +AWS_DEFAULT_REGION="$VERAISON_AWS_REGION" +AWS_REGION="$VERAISON_AWS_REGION" +VERAISON_AWS_ADMIN_CIDR=217.140.96.0/20 +VERAISON_AWS_VPC_CIDR=10.1.0.0/16 +VERAISON_AWS_DNS_NAME=veraison-example.com +IAM_LOGGER_ROLE_NAME= +IAM_INSTANCE_PROFILE_NAME= +IAM_PERMISSION_BOUNDARY_ARN= +``` + +{{% notice Note %}} +Some AWS accounts may have permissions boundaries enabled (such as assumed role accounts). In this case you will need to create the logger and instance profile roles and specify the permissions boundary arn specifically. Most standard AWS accounts do not require this though so you can just leave them empty. +{{% /notice %}} + +Once the account-specific config file is created, define `AWS_ACCOUNT_CFG` environment variable to point to it and then create the deployment: + +```bash +cp ./misc/arm.cfg $HOME/veraison-aws.cfg +export AWS_ACCOUNT_CFG="$HOME/veraison-aws.cfg" +source env/env.bash "$AWS_ACCOUNT_CFG" make deploy ``` @@ -59,7 +180,7 @@ This command outputs a status report for the deployment. If successful, it inclu Use the following command to test the REST API endpoint of the verification service. Remember to substitute `example-veraison.com` with the domain name that you used in the initial step, but you will need to keep the `services` prefix as shown. ```bash -curl https://services.example-veraison.com:8443/.well-known/veraison/verification +curl https://services.example-veraison.com:8443/.well-known/veraison/verification | jq ``` If it succeeds, this command produces some JSON output, including the EAR verification key. @@ -67,9 +188,9 @@ If it succeeds, this command produces some JSON output, including the EAR verifi Use the following command to test the REST API endpoint of the endorsement provisioning service. Remember to substitute `example-veraison.com` with the domain name that you used in the initial step. ```bash -curl https://services.example-veraison.com:9443/.well-known/veraison/provisioning +curl https://services.example-veraison.com:9443/.well-known/veraison/provisioning | jq ``` This command produces JSON output containing the list of supported media types for endorsement. -Your Veraison services are now successfully deployed - you're ready for the next step. \ No newline at end of file +Your Veraison services are now successfully deployed - you're ready for the next step. diff --git a/content/learning-paths/servers-and-cloud-computing/cca-veraison-aws/endorsements.md b/content/learning-paths/servers-and-cloud-computing/cca-veraison-aws/endorsements.md index db8e2f6066..f3d38c4f35 100644 --- a/content/learning-paths/servers-and-cloud-computing/cca-veraison-aws/endorsements.md +++ b/content/learning-paths/servers-and-cloud-computing/cca-veraison-aws/endorsements.md @@ -14,25 +14,52 @@ Now that your Veraison services are deployed into AWS, the next step is to provi Return to the command shell where you created the Veraison AWS deployment, and run the following command: ```bash -cd $HOME/services/end-to-end +# make sure we have cocli +mkdir -p "$HOME/.local/bin" + +GOBIN="$HOME/.local/bin" go install github.com/veraison/cocli@v0.1.0 +GOBIN="$HOME/.local/bin" go install github.com/veraison/evcli/v2@0e253e8 + +export PATH="$HOME/.local/bin:$PATH" +hash -r + +command -v cocli +command -v evcli + +cd $HOME/cca_veraison/services/end-to-end SCHEME=cca ./end-to-end-aws provision ``` This command sends the CCA endorsements to your AWS-hosted Veraison deployment. You should see output similar to the following: ```output -TO-DO +go: github.com/veraison/cocli@v0.1.0 requires go >= 1.25.0; switching to go1.26.11 +go: github.com/veraison/evcli/v2@v2.2.1-0.20261013091050-0e253e803cfb requires go >= 1.25.0; switching to go1.26.11 +/home/danson/.local/bin/cocli +/home/danson/.local/bin/evcli +cocli corim submit --config=/tmp/veraison-aws-client-configs/cocli/config.yaml --corim-file=/home/danson/cca_veraison/services/end-to-end/input/cca-endorsements.cbor '--media-type=application/rim+cbor; profile="tag:arm.com,2025:cca_platform#1.0.0"' +cocli corim submit --config=/tmp/veraison-aws-client-configs/cocli/config.yaml --corim-file=/home/danson/cca_veraison/services/end-to-end/input/cca-realm-endorsements.cbor '--media-type=application/rim+cbor; profile="tag:arm.com,2025:cca_realm#1.0.0"' ``` Next, run the following command: ```bash -cd $HOME/services/deployments/aws +cd $HOME/cca_veraison/services/deployments/aws veraison stores ``` This command will query Veraison's database stores. If the CCA endorsements were provisioned successfully, the output should look something like the example below. (You don't need to understand all of the detail here.) ```output -TO-DO +┌────┬────────┬───────────┬────────────────────────────────────────────────┬───────────┬─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐ +│ ID │ ACTIVE │ LABEL │ SOURCE │ TYPE │ ENVIRONMENT │ +├────┼────────┼───────────┼────────────────────────────────────────────────┼───────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┤ +│ │ │ │ manifest: 00000000-0000-0001-cca6-000000000001 │ │ class: 7f454c4602010100000000000000000003003e00010000005058000000000000 │ +│ 2 │ true │ 0/ARM_CCA │ module: ceb50b5a-a61e-4666-8b6b-33cb957b6801 │ attest │ instance: AQcGBQQDAgEADw4NDAsKCQgXFhUUExIREB8eHRwbGhkY │ +│ │ │ │ │ │ │ +│ 3 │ true │ 0/ARM_CCA │ manifest: 00000000-0000-0001-cca6-000000000001 │ reference │ class: 7f454c4602010100000000000000000003003e00010000005058000000000000 │ +│ │ │ │ module: 43bbe37f-2e61-4b33-aed3-53cff1428b16 │ │ │ +│ 4 │ true │ 0/ARM_CCA │ manifest: 00000000-0000-0001-cca4-000000000001 │ reference │ class: 43434343434343434343434343434343434343434343434343434343434343434343434343434343434343434343434343434343434343434343434343434343 │ +│ │ │ │ module: 43bbe37f-2e61-4b33-aed3-53cff1428b16 │ │ │ +└────┴────────┴───────────┴────────────────────────────────────────────────┴───────────┴─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘ ``` Your Veraison deployment is now ready to act as an attestation verification service for pre-silicon Arm CCA platforms. \ No newline at end of file diff --git a/content/learning-paths/servers-and-cloud-computing/cca-veraison-aws/use-verifier.md b/content/learning-paths/servers-and-cloud-computing/cca-veraison-aws/use-verifier.md index 5b9b0c5c67..5aaf044eb8 100644 --- a/content/learning-paths/servers-and-cloud-computing/cca-veraison-aws/use-verifier.md +++ b/content/learning-paths/servers-and-cloud-computing/cca-veraison-aws/use-verifier.md @@ -21,3 +21,53 @@ When cloning `evcli` source code use commit: ``` bash git -C evcli checkout 0e253e8 ``` + + +## Cleanup + +Once you are done with your AWS services for this learning path, you can clean things up to save on AWS costs. Back on the Ubuntu host: + +```bash +cd $HOME/cca_veraison/services/deployments/aws + +# Confirm that we still have the correct environment (both should be set prior) +echo $AWS_REGION +echo $VERAISON_DEB + +# Delete all AWS resources we created in this learning path (from veraison repo readme) +./bin/veraison delete-stack services +./bin/veraison delete-stack rds +./bin/veraison delete-image keycloak +./bin/veraison delete-image services +./bin/veraison delete-image sentinel +./bin/veraison delete-signing-key +./bin/veraison delete-key-pair +./bin/veraison delete-deb + +# Force delete the Cloud Formation stacks +aws cloudformation delete-stack --stack-name veraison-support +aws cloudformation wait stack-delete-complete --stack-name veraison-support || \ +aws cloudformation delete-stack --stack-name veraison-support --deletion-mode FORCE_DELETE_STACK + +aws cloudformation delete-stack --stack-name veraison-vpc +aws cloudformation wait stack-delete-complete --stack-name veraison-vpc || \ +aws cloudformation delete-stack --stack-name veraison-vpc --deletion-mode FORCE_DELETE_STACK + +# Force delete the secret without deletion delay +aws secretsmanager delete-secret \ + --secret-id veraison-ear-signer \ + --force-delete-without-recovery \ + --region ${AWS_REGION} + +# Clean up the local cache +state_dir="${XDG_DATA_HOME:-$HOME/.local/share}/veraison/aws" +state_backup="${state_dir}.backup-$(date +%Y%m%d-%H%M%S)" +cp -a -- "$state_dir" "$state_backup" +for entry in key vpc support services images signer-key-arn; do + ./bin/veraison --deployment-name veraison cache --delete "$entry" || break +done +``` + +{{% notice Note %}} +The above deletion steps will delete most of the AWS resources created by this learning path. However, any failed deployments may partially/wholly remain and will require manual deletion from the AWS console. Be sure to double check via the AWS console including examining AWS dashboards for: Cloud Formation, ElastiCache, RDS and Aurora, Secrets Manager, and EC2 for any residual resources that might be dangling after the above deletions. +{{% /notice %}} diff --git a/content/learning-paths/servers-and-cloud-computing/ceph-rbd-agi/_index.md b/content/learning-paths/servers-and-cloud-computing/ceph-rbd-agi/_index.md index c56a895c27..76034a5987 100644 --- a/content/learning-paths/servers-and-cloud-computing/ceph-rbd-agi/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/ceph-rbd-agi/_index.md @@ -41,32 +41,32 @@ generated_summary_faq: image, mount it, and verify file persistence on the single node. After authorizing cluster SSH access to the other nodes, you'll add their OSDs and increase replication. Finally, you'll stop and restart an OSD to check continued access and recovery. -# faqs: -# - question: Which `cephadm` release should I install on Ubuntu 26.04 and why? -# answer: >- -# Use `cephadm` 19.2.6 to match the Ceph Squid 19.2.6 cluster release. Ubuntu 26.04 repositories -# provide Ceph 20.2.0, so download `cephadm` 19.2.6 directly to keep the deployment tools and -# cluster on the same version. -# - question: 'Where do I run commands during each phase: host setup, VM prep, and cluster operations?' -# answer: >- -# Run VM creation commands on the Arm AGI CPU host. Run preparation commands inside each VM. -# During expansion, authorize the cluster's SSH key on the new nodes from the AGI host. Run -# cluster bootstrap, RBD usage, and the remaining expansion commands inside `ceph1`. -# - question: How do I know each VM is ready before bootstrapping Ceph? -# answer: >- -# Confirm each VM has 4 vCPUs, 4 GB memory, a 20 GB OS disk, a separate unused data disk of -# at least 10 GB, stable IP addressing, SSH access, hostname resolution, and synchronized -# clocks. Identify the empty data disk that Ceph will use on each node. -# - question: What device should appear after mapping the RBD image, and how do I verify persistence? -# answer: >- -# You should see a block device such as `/dev/rbd0`. Format and mount it, write a test file, then -# unmap and remap the image and compare checksums to verify the file persists in Ceph. -# - question: What changes when expanding to three nodes, and how is replication tested? -# answer: >- -# You add two more Ceph nodes so the cluster runs one OSD per node. A controlled OSD failure -# tests whether you can keep reading and writing the RBD volume. After the OSD returns, you -# verify that Ceph repairs changed objects and both the original and outage files retain their -# checksums. + faqs: + - question: Which cephadm release should I install on Ubuntu 26.04? + answer: >- + Use `cephadm` 19.2.6 to match the Ceph Squid 19.2.6 cluster release. Ubuntu 26.04 repositories + provide Ceph 20.2.0, so download `cephadm` 19.2.6 directly to keep the deployment tools and + cluster on the same version. + - question: Where do I run commands during the host setup, VM prep, and cluster operation phases? + answer: >- + Run VM creation commands on the Arm AGI CPU host. Run preparation commands inside each VM. + During expansion, authorize the cluster SSH key on the new nodes from the AGI host. Run + cluster bootstrap, RBD usage, and the remaining expansion commands inside `ceph1`. + - question: How do I know that each VM is ready before bootstrapping Ceph? + answer: >- + Confirm each VM has 4 vCPUs, 4 GB memory, a 20 GB OS disk, and a separate unused data disk of + at least 10 GB. Also ensure that each VM has stable IP addressing, SSH access, hostname resolution, and synchronized + clocks. Identify the empty data disk that Ceph will use on each node. + - question: What device should appear after mapping the RBD image, and how do I verify persistence? + answer: >- + You should see a block device such as `/dev/rbd0`. Format and mount it, write a test file, then + unmap and remap the image. Compare checksums to verify that the file persists in Ceph. + - question: What changes when expanding to three nodes, and how is replication tested? + answer: >- + You add two more Ceph nodes so that the cluster runs one OSD per node. A controlled OSD failure + tests whether you can keep reading and writing the RBD volume. After the OSD returns, you + verify that Ceph repairs changed objects and both the original and outage files retain their + checksums. # END generated_summary_faq author: Pareena Verma diff --git a/content/learning-paths/servers-and-cloud-computing/gke-agent-sandbox/_index.md b/content/learning-paths/servers-and-cloud-computing/gke-agent-sandbox/_index.md index 0082559c8c..dabf585041 100644 --- a/content/learning-paths/servers-and-cloud-computing/gke-agent-sandbox/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/gke-agent-sandbox/_index.md @@ -22,31 +22,31 @@ generated_summary_faq: warm pool, claim a sandbox, and verify its restrictions. Next, you'll correct a failing CSV analysis and retrieve reports. You'll then inspect the environment interactively, connect Antigravity to run code remotely, and clean up cloud resources. - # faqs: - # - question: Which node pool should I use to run sandboxes on Google Axion? - # answer: >- - # Use the Arm gVisor pool backed by `c4a-standard-2` machines. The provided - # `sandbox.yaml` selects that node pool for your Python sandbox workloads. - # - question: What should I set in my terminal before running the cluster commands? - # answer: >- - # Keep `LP_WORKDIR` set and run `cd "$LP_WORKDIR"` before continuing. If you open - # a new terminal, source `env.sh` if you saved it, or re-export variables such as - # `LOCATION`, `REGION`, `CLUSTER_NAME`, `NODE_POOL_NAME`, and `MACHINE_TYPE`. - # - question: How do I verify the sandbox runs as non-root and has restricted filesystem access? - # answer: >- - # Run the Python test and check that it reports UID 1000. You should also see a - # denied write under `/etc` and a successful write to `/workspace`. Later, use - # `kubectl exec` to inspect the running sandbox interactively. - # - question: What result should I expect from the CSV analysis demo? - # answer: >- - # Your first run with `analyze_sales_initial.py` fails as expected. The runner - # replaces it with `analyze_sales.py` in the same sandbox workspace, runs six - # tests, and retrieves `summary.json` and `report.html`. - # - question: How do I keep Antigravity from running code on my local machine? - # answer: >- - # In `agy`, open `/permissions` and select **Project**. Allow - # `mcp(gke-sandbox/*)` and deny `command(*)`, `read_file(*)`, and - # `write_file(*)`. Check that your session uses the `gke-sandbox` tools. + faqs: + - question: Which node pool should I use to run sandboxes on Google Axion? + answer: >- + Use the Arm gVisor pool backed by `c4a-standard-2` machines. The provided + `sandbox.yaml` selects that node pool for your Python sandbox workloads. + - question: What should I set in my terminal before running the cluster commands? + answer: >- + Keep `LP_WORKDIR` set and run `cd "$LP_WORKDIR"` before continuing. If you open + a new terminal, source `env.sh` if you saved it. Otherwise, re-export variables such as + `LOCATION`, `REGION`, `CLUSTER_NAME`, `NODE_POOL_NAME`, and `MACHINE_TYPE`. + - question: How do I verify that the sandbox runs as non-root and has restricted filesystem access? + answer: >- + Run the Python test and check that it reports UID `1000`. You should also see a + denied write under `/etc` and a successful write to `/workspace`. Later, use + `kubectl exec` to inspect the running sandbox interactively. + - question: What result should I expect from the CSV analysis demo? + answer: >- + Your first run with `analyze_sales_initial.py` fails as expected. The runner + replaces it with `analyze_sales.py` in the same sandbox workspace, runs six + tests, and retrieves `summary.json` and `report.html`. + - question: How do I block built-in Antigravity local tools? + answer: >- + In `agy`, open `/permissions` and select **Project**. Allow + `mcp(gke-sandbox/*)` and deny `command(*)`, `read_file(*)`, and + `write_file(*)`. Check that your session uses the `gke-sandbox` tools. # END generated_summary_faq author: Jason Andrews diff --git a/content/learning-paths/servers-and-cloud-computing/java-on-azure/benchmarking.md b/content/learning-paths/servers-and-cloud-computing/java-on-azure/benchmarking.md index 608fb38814..e48a8260dc 100644 --- a/content/learning-paths/servers-and-cloud-computing/java-on-azure/benchmarking.md +++ b/content/learning-paths/servers-and-cloud-computing/java-on-azure/benchmarking.md @@ -174,7 +174,7 @@ These results were collected on a **Standard_D4ps_v7** Cobalt 200 VM (4 vCPUs, 1 - **Mode (`thrpt`)** measures operations per unit of time. Here, one operation constructs and returns one response string. - **Cnt** is the number of measured iterations across all forks: two forks with three measurements each give six samples. - **Score** is the mean measured throughput in operations per second. -- **Error** is the half-width of JMH’s reported confidence interval; it is not the standard deviation. +- **Error** is the half-width of the confidence interval that JMH reports; it is not the standard deviation. - **Warmup** lets the JVM compile and optimize code before collecting measurements. Use `results.json` to inspect the per-iteration results and reported uncertainty. Longer measurements and additional forks can help investigate variability, but do not guarantee repeatability. diff --git a/content/learning-paths/servers-and-cloud-computing/java-on-azure/create-instance.md b/content/learning-paths/servers-and-cloud-computing/java-on-azure/create-instance.md index 166b3da82d..ae9064ac90 100644 --- a/content/learning-paths/servers-and-cloud-computing/java-on-azure/create-instance.md +++ b/content/learning-paths/servers-and-cloud-computing/java-on-azure/create-instance.md @@ -27,7 +27,7 @@ Now follow these steps: - In **Image**, choose **Ubuntu 24.04 LTS**, then set **Architecture** to **Arm64**. - In **Size**, select **See all sizes**, choose the **Dpsv7 (D-series v7)** family, then select **D4ps_v7**. - ![Azure portal VM size selection#center](images/instance.png "VM size selection in the Azure portal") + ![Azure portal VM size selection#center](images/instance.webp "VM size selection in the Azure portal") - Under **Administrator account**, set **Authentication type** to **SSH public key**. - Enter the `Username` for the VM. - Select **Generate new key pair**, select **SSH key type** (**ED25519** or **RSA**), and provide a **Key pair name**. diff --git a/content/learning-paths/servers-and-cloud-computing/java-on-azure/images/instance.png b/content/learning-paths/servers-and-cloud-computing/java-on-azure/images/instance.png deleted file mode 100755 index e43b24074d..0000000000 Binary files a/content/learning-paths/servers-and-cloud-computing/java-on-azure/images/instance.png and /dev/null differ diff --git a/content/learning-paths/servers-and-cloud-computing/java-on-azure/images/instance.webp b/content/learning-paths/servers-and-cloud-computing/java-on-azure/images/instance.webp new file mode 100644 index 0000000000..5a7762202e Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/java-on-azure/images/instance.webp differ diff --git a/content/learning-paths/servers-and-cloud-computing/mongodb-on-azure/create-instance.md b/content/learning-paths/servers-and-cloud-computing/mongodb-on-azure/create-instance.md index 445d62bfba..3de7c01b88 100644 --- a/content/learning-paths/servers-and-cloud-computing/mongodb-on-azure/create-instance.md +++ b/content/learning-paths/servers-and-cloud-computing/mongodb-on-azure/create-instance.md @@ -31,7 +31,7 @@ Now follow these steps: - Choose the image for your virtual machine (for example, **Ubuntu 24.04 LTS**) and select **Arm64** as the **VM architecture**. - In the **Size** field, select **See all sizes** and select the **D-series v7** family of virtual machines. Select **D4ps_v7** from the list. -![Azure portal VM size selection#center](images/instance.png "Select a VM size") +![Azure portal VM size selection#center](images/instance.webp "Select a VM size") - Next, select **SSH public key** as the **Authentication type**. Azure can generate an **SSH key pair** for you and store it for future use. This is a fast, simple, and secure way to connect to your virtual machine. - Enter the **Administrator username** for your VM. diff --git a/content/learning-paths/servers-and-cloud-computing/mongodb-on-azure/images/instance.png b/content/learning-paths/servers-and-cloud-computing/mongodb-on-azure/images/instance.png deleted file mode 100755 index e43b24074d..0000000000 Binary files a/content/learning-paths/servers-and-cloud-computing/mongodb-on-azure/images/instance.png and /dev/null differ diff --git a/content/learning-paths/servers-and-cloud-computing/mongodb-on-azure/images/instance.webp b/content/learning-paths/servers-and-cloud-computing/mongodb-on-azure/images/instance.webp new file mode 100644 index 0000000000..5a7762202e Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/mongodb-on-azure/images/instance.webp differ diff --git a/content/learning-paths/servers-and-cloud-computing/mysql-azure/create-instance.md b/content/learning-paths/servers-and-cloud-computing/mysql-azure/create-instance.md index fc4d2b09c6..165720c36e 100644 --- a/content/learning-paths/servers-and-cloud-computing/mysql-azure/create-instance.md +++ b/content/learning-paths/servers-and-cloud-computing/mysql-azure/create-instance.md @@ -31,7 +31,7 @@ Creating a virtual machine based on Azure Cobalt 200 is no different to creating - In the **Size** field, select **See all sizes** and select the D-series v7 family of virtual machines. - Select **D4ps_v7** from the list as shown in the diagram below: -![Azure portal VM creation example#center](images/instance.png "VM size selection in the Azure portal") +![Azure portal VM creation example#center](images/instance.webp "VM size selection in the Azure portal") - For **Authentication type**, select **SSH public key**. - Fill in the **Administrator username** for your VM. diff --git a/content/learning-paths/servers-and-cloud-computing/mysql-azure/images/instance.png b/content/learning-paths/servers-and-cloud-computing/mysql-azure/images/instance.png deleted file mode 100644 index e43b24074d..0000000000 Binary files a/content/learning-paths/servers-and-cloud-computing/mysql-azure/images/instance.png and /dev/null differ diff --git a/content/learning-paths/servers-and-cloud-computing/mysql-azure/images/instance.webp b/content/learning-paths/servers-and-cloud-computing/mysql-azure/images/instance.webp new file mode 100644 index 0000000000..5a7762202e Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/mysql-azure/images/instance.webp differ diff --git a/content/learning-paths/servers-and-cloud-computing/mysql/_index.md b/content/learning-paths/servers-and-cloud-computing/mysql/_index.md index 5759c28cf5..de010e1212 100644 --- a/content/learning-paths/servers-and-cloud-computing/mysql/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/mysql/_index.md @@ -33,30 +33,30 @@ generated_summary_faq: architecture and Docker connection. Then, you'll start an Arm64 MySQL container with a persistent volume. You'll connect to the MySQL client, create a test database, and add a sample table. Finally, you'll insert rows into the table and verify the stored data. - # faqs: - # - question: How do I check that my server is ready to run the Arm64 MySQL image? - # answer: >- - # Run `uname -m` and confirm that it prints `aarch64`. Then run `docker info` to check that - # your Docker client can reach Docker Engine. If it can't, use the linked Docker install guide. - # - question: How do I keep my MySQL data when I replace the container? - # answer: >- - # Create the `mysql-data` Docker volume and mount it at `/var/lib/mysql`, as shown in the - # `docker run` command. Your database files then remain in the volume when you replace the - # container. - # - question: What should I check if `docker exec` cannot connect to the MySQL container? - # answer: >- - # Run `docker ps --filter name=mysql-arm` to check that the container is running. Check - # `docker logs mysql-arm` and wait for MySQL to report that it is ready for connections. - # Use the container name you chose if it differs from `mysql-arm`. - # - question: How do I connect and create the sample database? - # answer: >- - # Run `docker exec -it mysql-arm mysql -uroot -p` and enter your root password. At the - # `mysql>` prompt, run `CREATE DATABASE arm_test;`. You can confirm its creation with - # `SHOW DATABASES;`. - # - question: How do I verify that the sample table stores data? - # answer: >- - # Select `arm_test`, create the `book` table, and insert the seven sample rows. Run - # `SELECT * FROM book;` and confirm that the query returns seven rows. + faqs: + - question: How do I check that my server is ready to run the Arm64 MySQL image? + answer: >- + Run `uname -m` and confirm that it prints `aarch64`. Then run `docker info` to check that + your Docker client can reach Docker Engine. If it can't, use the linked Docker install guide. + - question: How do I keep my MySQL data when I replace the container? + answer: >- + Create the `mysql-data` Docker volume and mount it at `/var/lib/mysql`, as shown in the + `docker run` command. Your database files then remain in the volume when you replace the + container. + - question: What should I check if Docker can't to the MySQL container? + answer: >- + Run `docker ps --filter name=mysql-arm` to check that the container is running. Check + `docker logs mysql-arm` and wait for MySQL to report that it's ready for connections. + Use the container name that you chose if it differs from `mysql-arm`. + - question: How do I connect and create the sample database? + answer: >- + Run `docker exec -it mysql-arm mysql -uroot -p` and enter your root password. At the + `mysql>` prompt, run `CREATE DATABASE arm_test;`. You can confirm its creation with + `SHOW DATABASES;`. + - question: How do I verify that the sample table stores data? + answer: >- + Select `arm_test`, create the `book` table, and insert the seven sample rows. Run + `SELECT * FROM book;` and confirm that the query returns seven rows. # END generated_summary_faq author: Jason Andrews diff --git a/content/learning-paths/servers-and-cloud-computing/nginx-on-azure/images/instance.png b/content/learning-paths/servers-and-cloud-computing/nginx-on-azure/images/instance.png deleted file mode 100644 index e43b24074d..0000000000 Binary files a/content/learning-paths/servers-and-cloud-computing/nginx-on-azure/images/instance.png and /dev/null differ diff --git a/content/learning-paths/servers-and-cloud-computing/nginx-on-azure/images/instance.webp b/content/learning-paths/servers-and-cloud-computing/nginx-on-azure/images/instance.webp new file mode 100644 index 0000000000..5a7762202e Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/nginx-on-azure/images/instance.webp differ diff --git a/content/learning-paths/servers-and-cloud-computing/nginx-on-azure/instance.md b/content/learning-paths/servers-and-cloud-computing/nginx-on-azure/instance.md index 441846bd09..e90bec4305 100644 --- a/content/learning-paths/servers-and-cloud-computing/nginx-on-azure/instance.md +++ b/content/learning-paths/servers-and-cloud-computing/nginx-on-azure/instance.md @@ -30,7 +30,7 @@ To get started, launch the Azure portal and navigate to **Virtual Machines**. Th - Select the image for your virtual machine (for example, Ubuntu 24.04 LTS) and select **Arm64** as the VM architecture. - In the **Size** field, select **See all sizes**, select the **D-series v7** family of virtual machines, then select **D4ps_v7**. -![Azure portal VM creation example#center](images/instance.png "VM size selection in the Azure portal") +![Azure portal VM creation example#center](images/instance.webp "VM size selection in the Azure portal") - Now select **SSH public key** as the authentication type. Azure can generate an SSH key pair for you and store it for future use. It is a fast, simple, and secure way to connect to your virtual machine. - Enter the **Administrator username** for your VM. diff --git a/content/learning-paths/servers-and-cloud-computing/openshift/_index.md b/content/learning-paths/servers-and-cloud-computing/openshift/_index.md index 7c1f00c86e..299a28de15 100644 --- a/content/learning-paths/servers-and-cloud-computing/openshift/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/openshift/_index.md @@ -14,9 +14,55 @@ prerequisites: - Familiarity with the `oc` CLI, container fundamentals, and basic Tekton concepts (Task, Pipeline, PipelineRun) - Cluster access with cluster-admin or equivalent permissions to configure nodes and pipelines +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-18T20:20:50Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: 6a861fcfd4e3dea4a2709a2c2c14708b65c1a5c99b1fa9bd86107572206aa571 + summary_generated_at: '2026-11-18T20:20:50Z' + summary_source_hash: 6a861fcfd4e3dea4a2709a2c2c14708b65c1a5c99b1fa9bd86107572206aa571 + faq_generated_at: '2026-11-18T20:20:50Z' + faq_source_hash: 6a861fcfd4e3dea4a2709a2c2c14708b65c1a5c99b1fa9bd86107572206aa571 + summary: >- + You'll extend an OpenShift Pipelines workflow on AWS to build and deploy an application for + arm64. First, you'll assess compatibility and enable multi-architecture support in the cluster. + Then, you'll add Arm nodes, configure scheduling, and rebuild container images with Tekton. + Finally, you'll deploy the rebuilt application to Arm nodes and verify that its pods run there + before removing x86 workers. + faqs: + - question: What do I need to check before enabling multi-architecture builds? + answer: >- + Confirm that Red Hat OpenShift Pipelines (Tekton) is installed and that you have + cluster-admin or equivalent permissions. Ensure that the baseline [OpenShift Pipelines Tutorial](https://github.com/openshift/pipelines-tutorial) + is running on x86 nodes so that you can extend it for arm64. + - question: How do I know an application is ready to run on Arm64 nodes? + answer: >- + After you assess compatibility, rebuild the container image for arm64 with your pipeline + and deploy it to Arm nodes. Check that the pods start there without image or runtime + errors. + - question: Which nodes should host the migrated workloads on AWS? + answer: >- + Add and configure Arm nodes on AWS Graviton and join them to your OpenShift cluster. + Schedule the rebuilt workloads onto these Arm-based nodes after images are verified. + - question: What result should I expect from the pipeline when targeting arm64? + answer: >- + Check that your `PipelineRun` produces and publishes an arm64 container image. Deploy that + image to Arm nodes and verify that its pods run there. + - question: When can I remove the x86 worker nodes? + answer: >- + Deploy your arm64 image to the Arm nodes and confirm that its pods run successfully. After + the pods are up, you can remove the x86 worker nodes and. If needed, you can remove the taints from + the Arm worker nodes. +# END generated_summary_faq + author: Jeff Young -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/openstack-on-azure/_index.md b/content/learning-paths/servers-and-cloud-computing/openstack-on-azure/_index.md index 8eba4b81d1..8dfddd5906 100644 --- a/content/learning-paths/servers-and-cloud-computing/openstack-on-azure/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/openstack-on-azure/_index.md @@ -1,5 +1,5 @@ --- -title: Deploy OpenStack on Azure Cobalt 100 Arm64 Virtual Machine +title: Deploy OpenStack on Arm64 virtual machines on Azure Cobalt 100 description: Deploy OpenStack on Azure Cobalt 100 Arm64 virtual machines using DevStack for development and Kolla-Ansible for containerized production deployments. minutes_to_complete: 90 @@ -7,12 +7,12 @@ minutes_to_complete: 90 who_is_this_for: This learning path is designed for developers, DevOps engineers, and platform engineers who want to deploy and manage OpenStack on Arm-based cloud environments using Kolla-Ansible and DevStack. learning_objectives: - - Deploy OpenStack on Azure Cobalt 100 Arm64 virtual machines - - Configure core OpenStack services (Keystone, Nova, Neutron, Glance, Cinder) - - Deploy containerized OpenStack using Kolla-Ansible - - Set up networking and storage for OpenStack - - Launch and manage virtual machine instances - - Access OpenStack using CLI and Horizon dashboard + - Deploy OpenStack on Azure Cobalt 100 Arm64 virtual machines (VMs). + - Configure core OpenStack services (Keystone, Nova, Neutron, Glance, Cinder). + - Deploy containerized OpenStack using Kolla-Ansible. + - Set up networking and storage for OpenStack. + - Launch and manage virtual machine instances. + - Access OpenStack using CLI and Horizon dashboard. prerequisites: - A [Microsoft Azure account](https://azure.microsoft.com/) with access to Cobalt 100 based instances (Dpsv6) @@ -20,9 +20,54 @@ prerequisites: - Familiarity with SSH and remote server access - Basic understanding of cloud computing and virtualization concepts +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-18T20:21:13Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: a0b28b8f7cc05d1d6b545a90222421d518c28d14c8ea86cac119e3c14ecaef96 + summary_generated_at: '2026-11-18T20:21:13Z' + summary_source_hash: a0b28b8f7cc05d1d6b545a90222421d518c28d14c8ea86cac119e3c14ecaef96 + faq_generated_at: '2026-11-18T20:21:13Z' + faq_source_hash: a0b28b8f7cc05d1d6b545a90222421d518c28d14c8ea86cac119e3c14ecaef96 + summary: >- + You'll deploy OpenStack on Arm-based Azure Cobalt 100 virtual machines using two approaches. + First, you'll create a VM and use DevStack to set up a development environment. Then, you'll + prepare a separate VM with two network interfaces and a data disk for Kolla-Ansible. + Finally, you'll deploy containerized services, verify them, and launch a VM through OpenStack. + faqs: + - question: Which Azure VM size should I use for DevStack, and do I need extra NICs or disks on my VM? + answer: >- + Use a single-NIC `D4ps_v6` instance with at least 80 GB of disk. You don't need an extra + NIC or a separate data disk for DevStack. + - question: Can I run DevStack and Kolla-Ansible on the same VM? + answer: >- + Use separate Azure VMs for DevStack and Kolla-Ansible. + - question: How do I decide between DevStack and Kolla-Ansible for what I need? + answer: >- + Use DevStack for a script-based, single-node environment aimed at development and testing. + Choose Kolla-Ansible to deploy OpenStack services as containers for a modular, + reproducible, production-like setup. + - question: What VM specs should I provision for the Kolla-Ansible host on Azure, and how should I assign the NICs? + answer: >- + Provision at least 4 vCPUs (8 recommended), 16 GB RAM, a 100 GB OS disk, and a 32 GB + data disk for Cinder/Docker on Ubuntu 24.04. Use two NICs: `eth0` for management and + `eth1` for external networking. + - question: How do I verify that my OpenStack deployment worked before I move on? + answer: >- + For DevStack, expect a single node running Keystone, Nova, Glance, and Horizon. Verify + access using the CLI and Horizon. For Kolla-Ansible, confirm that core services such as Nova, + Neutron, Keystone, and Glance are running in containers. Ensure that you can access the CLI + and Horizon to launch instances. +# END generated_summary_faq + author: Pareena Verma -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/openstack-on-azure/background.md b/content/learning-paths/servers-and-cloud-computing/openstack-on-azure/background.md index 1ad0ad1312..8c9ccc12e5 100644 --- a/content/learning-paths/servers-and-cloud-computing/openstack-on-azure/background.md +++ b/content/learning-paths/servers-and-cloud-computing/openstack-on-azure/background.md @@ -7,7 +7,7 @@ layout: "learningpathall" ## Azure Cobalt 100 Arm-based processor -Azure’s Cobalt 100 is Microsoft’s first-generation, in-house Arm-based processor. Built on Arm Neoverse N2, Cobalt 100 is a 64-bit CPU that delivers strong performance and energy efficiency for cloud-native, scale-out Linux workloads. These workloads include web and application servers, data analytics, open-source databases, and caching systems. Running at 3.4 GHz, Cobalt 100 allocates a dedicated physical core for each vCPU, which ensures consistent and predictable performance. +Azure Cobalt 100 is a first-generation, in-house Arm-based processor by Microsoft. Built on Arm Neoverse N2, Cobalt 100 is a 64-bit CPU that delivers strong performance and energy efficiency for cloud-native, scale-out Linux workloads. These workloads include web and application servers, data analytics, open-source databases, and caching systems. Running at 3.4 GHz, Cobalt 100 allocates a dedicated physical core for each vCPU, which ensures consistent and predictable performance. To learn more, see the Microsoft blog [Announcing the preview of new Azure VMs based on the Azure Cobalt 100 processor](https://techcommunity.microsoft.com/blog/azurecompute/announcing-the-preview-of-new-azure-vms-based-on-the-azure-cobalt-100-processor/4146353). @@ -76,6 +76,6 @@ Because the two approaches have different infrastructure requirements, you'll be ## What you've learned and what's next -In this section, you learned about Azure Cobalt 100 and OpenStack. You were introduced to two approaches for deploying OpenStack on Cobalt 100, and the infrastructure requirements for each approach. +You've learned about Azure Cobalt 100 and OpenStack. You were introduced to two approaches for deploying OpenStack on Cobalt 100, and the infrastructure requirements for each approach. -In the next section, you'll create the VM for the DevStack approach for deploying OpenStack on Cobalt 100. +Next, you'll create the VM for the DevStack approach for deploying OpenStack on Cobalt 100. diff --git a/content/learning-paths/servers-and-cloud-computing/openstack-on-azure/devtstack-deployment.md b/content/learning-paths/servers-and-cloud-computing/openstack-on-azure/devtstack-deployment.md index 4556ac86e2..e28bd619d0 100644 --- a/content/learning-paths/servers-and-cloud-computing/openstack-on-azure/devtstack-deployment.md +++ b/content/learning-paths/servers-and-cloud-computing/openstack-on-azure/devtstack-deployment.md @@ -10,7 +10,7 @@ layout: learningpathall --> -In this section, you'll deploy OpenStack using DevStack on the Arm-based Azure virtual machine (VM) running Azure Cobalt 100 that you created in the previous section. DevStack is a script-based installer designed for development and testing. It runs all OpenStack services directly on the host OS and deploys Nova, Keystone, Glance, and Horizon on a single node. +You'll deploy OpenStack using DevStack on the Arm-based Azure virtual machine (VM) running Azure Cobalt 100 that you created earlier. DevStack is a script-based installer designed for development and testing. It runs all OpenStack services directly on the host OS and deploys Nova, Keystone, Glance, and Horizon on a single node. The environment that you'll create will run OpenStack services on your Azure Cobalt 100 VM, provide access to the Horizon dashboard, and support Arm64 (`aarch64`) architecture. You'll be able to access the environment using both browser and CLI. @@ -325,9 +325,9 @@ The Kolla-Ansible deployment must run on a separate VM, so this step is optional ## What you've accomplished and what's next -In this section, you deployed OpenStack using DevStack on an Azure Cobalt 100 Arm64 VM. You then verified the deployment using the CLI and accessed the Horizon dashboard using a browser. +You've deployed OpenStack using DevStack on an Azure Cobalt 100 Arm64 VM. You then verified the deployment using the CLI and accessed the Horizon dashboard using a browser. -In the next section, you'll create a VM for deploying OpenStack using Kolla-Ansible. +Next, you'll create a VM for deploying OpenStack using Kolla-Ansible. diff --git a/content/learning-paths/servers-and-cloud-computing/openstack-on-azure/instance.md b/content/learning-paths/servers-and-cloud-computing/openstack-on-azure/instance.md index 4d9edf045a..884daa3c86 100644 --- a/content/learning-paths/servers-and-cloud-computing/openstack-on-azure/instance.md +++ b/content/learning-paths/servers-and-cloud-computing/openstack-on-azure/instance.md @@ -12,7 +12,7 @@ You can create an Arm-based Cobalt 100 virtual machine (VM) in the following way - The Azure CLI - An infrastructure as code (IaC) tool -In this section, you'll use the Azure Portal to create a virtual machine with the Arm-based Azure Cobalt 100 processor. +You'll use the Azure Portal to create a virtual machine with the Arm-based Azure Cobalt 100 processor. This Learning Path focuses on general-purpose virtual machines in the Dpsv6 series. For more information, see the [Microsoft Azure guide for the Dpsv6 size series](https://learn.microsoft.com/en-us/azure/virtual-machines/sizes/general-purpose/dpsv6-series). @@ -65,6 +65,6 @@ Your virtual machine should be ready and running in a few minutes. You can SSH i ## What you've accomplished and what's next -In this section, you created an Azure Cobalt 100 Arm-based virtual machine using Ubuntu Pro 24.04 LTS on a D4ps_v6 instance. This VM is your DevStack deployment target — a single-network interface instance with at least 80 GB of disk. +You've created an Arm-based Azure virtual machine using Ubuntu Pro 24.04 LTS on a D4ps_v6 instance. This VM is your DevStack deployment target. It's a single-network interface instance with at least 80 GB of disk. -In the next section, you'll deploy OpenStack on this VM using DevStack. After that, you'll create a second VM with additional networking and storage for the Kolla-Ansible deployment. +Next, you'll deploy OpenStack on this VM using DevStack. After that, you'll create a second VM with additional networking and storage for the Kolla-Ansible deployment. diff --git a/content/learning-paths/servers-and-cloud-computing/openstack-on-azure/kolla-ansible-deployment.md b/content/learning-paths/servers-and-cloud-computing/openstack-on-azure/kolla-ansible-deployment.md index a44f0ae165..d771a912cf 100644 --- a/content/learning-paths/servers-and-cloud-computing/openstack-on-azure/kolla-ansible-deployment.md +++ b/content/learning-paths/servers-and-cloud-computing/openstack-on-azure/kolla-ansible-deployment.md @@ -6,7 +6,7 @@ weight: 6 layout: learningpathall --- -In this section, you'll deploy OpenStack using Kolla-Ansible on the Azure Ubuntu 24.04 Arm64 virtual machine (VM) that you created in the previous section. +You'll deploy OpenStack using Kolla-Ansible on the Azure Ubuntu 24.04 Arm64 virtual machine (VM) that you created earlier. Kolla-Ansible deploys OpenStack services as Docker containers, making the deployment modular, reproducible, and easier to manage. @@ -335,7 +335,9 @@ All services should show `enabled` and state `up`. If any service shows `down`, ## What you've accomplished and what's next -In this section, you deployed OpenStack using Kolla-Ansible on an Azure Cobalt 100 Arm64 VM. The deployment ran all OpenStack services as Docker containers, including Nova, Neutron, Keystone, Glance, and Horizon. +You've now deployed OpenStack using Kolla-Ansible on an Azure Cobalt 100 Arm64 VM. The deployment ran all OpenStack services as Docker containers, including Nova, Neutron, Keystone, Glance, and Horizon. -Your environment is now ready to launch and manage virtual machines. In the next section, you'll validate the OpenStack deployment and launch a test VM instance. +Your environment is now ready to launch and manage virtual machines. + +Next, you'll validate the OpenStack deployment and launch a test VM instance. diff --git a/content/learning-paths/servers-and-cloud-computing/openstack-on-azure/prepare-vm-for-kolla-ansible.md b/content/learning-paths/servers-and-cloud-computing/openstack-on-azure/prepare-vm-for-kolla-ansible.md index 01adace3af..608c3419e8 100644 --- a/content/learning-paths/servers-and-cloud-computing/openstack-on-azure/prepare-vm-for-kolla-ansible.md +++ b/content/learning-paths/servers-and-cloud-computing/openstack-on-azure/prepare-vm-for-kolla-ansible.md @@ -6,7 +6,7 @@ weight: 5 layout: learningpathall --- -In the previous section, you completed the DevStack deployment on the first VM. The Kolla-Ansible deployment runs on a separate Azure VM with two network interfaces (NICs) and a dedicated data disk. +You completed the DevStack deployment on the first VM. The Kolla-Ansible deployment runs on a separate Azure VM with two network interfaces (NICs) and a dedicated data disk. Create a new VM using the [same base process](/learning-paths/servers-and-cloud-computing/openstack-on-azure/instance/) as the first VM with the following specifications: @@ -80,6 +80,6 @@ Using a separate disk keeps OpenStack data off the OS disk and avoids filling it ## What you've accomplished and what's next -In this section, you configured a second Azure Arm64 VM for Kolla-Ansible. The VM has a second NIC (`eth1`) for OpenStack's provider network, and a dedicated 32 GB data disk for Cinder and Docker volumes. +You've configured a second Azure Arm64 VM for Kolla-Ansible. The VM has a second NIC (`eth1`) for OpenStack's provider network, and a dedicated 32 GB data disk for Cinder and Docker volumes. -In the next section, you'll install Kolla-Ansible and deploy OpenStack as containers on this VM. +Next, you'll install Kolla-Ansible and deploy OpenStack as containers on this VM. diff --git a/content/learning-paths/servers-and-cloud-computing/openstack-on-azure/validation-vm-launch.md b/content/learning-paths/servers-and-cloud-computing/openstack-on-azure/validation-vm-launch.md index 1bb392dd20..156ea066f9 100644 --- a/content/learning-paths/servers-and-cloud-computing/openstack-on-azure/validation-vm-launch.md +++ b/content/learning-paths/servers-and-cloud-computing/openstack-on-azure/validation-vm-launch.md @@ -6,7 +6,7 @@ weight: 7 layout: learningpathall --- -In this section, you'll validate the Kolla-Ansible deployment by checking service health, uploading a test image, creating network resources, and launching a virtual machine instance. +You'll now validate the Kolla-Ansible deployment by checking service health, uploading a test image, creating network resources, and launching a virtual machine instance. If you closed your session since the Kolla-Ansible deployment, reactivate the virtual environment and reload the admin credentials: @@ -268,4 +268,6 @@ The following image shows a successfully launched instance in the OpenStack Hori ## What you've accomplished -You validated your Kolla-Ansible OpenStack deployment end-to-end. You checked service health, configured OVS bridges for Arm on Azure, uploaded an Arm-compatible Debian image, created network and compute resources, and launched a running virtual machine. Your OpenStack environment is now fully functional and ready for use. +You've validated your Kolla-Ansible OpenStack deployment end-to-end. + +Your OpenStack environment is now fully functional and ready for use. diff --git a/content/learning-paths/servers-and-cloud-computing/opentelemetry/_index.md b/content/learning-paths/servers-and-cloud-computing/opentelemetry/_index.md index 771771a42a..aacf481cc3 100644 --- a/content/learning-paths/servers-and-cloud-computing/opentelemetry/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/opentelemetry/_index.md @@ -6,19 +6,64 @@ minutes_to_complete: 40 who_is_this_for: This learning path is for DevOps engineers, platform engineers, and software developers who want to deploy and observe a cloud-native microservice on Arm64-based Google Cloud C4A Axion processors using OpenTelemetry. learning_objectives: - - Deploy an instrumented Python Flask microservice on Google Cloud C4A Axion processors - - Configure OpenTelemetry Collector to process and route distributed traces and metrics - - Integrate Prometheus and Jaeger for comprehensive metrics collection and distributed tracing visualization - - Generate and analyze telemetry data to monitor application performance on Arm-based infrastructure + - Deploy an instrumented Python Flask microservice on Google Cloud C4A Axion processors. + - Configure OpenTelemetry Collector to process and route distributed traces and metrics. + - Integrate Prometheus and Jaeger for comprehensive metrics collection and distributed tracing visualization. + - Generate and analyze telemetry data to monitor application performance on Arm-based infrastructure. prerequisites: - A [Google Cloud Platform (GCP)](https://cloud.google.com/free) account with billing enabled - Basic familiarity with Python and Flask - Basic understanding of containers and Kubernetes concepts +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-18T20:21:41Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: d795b2fa981f5baed1b0bc6ad05494aed765fc22a875d0e7b9aea3268387e3e7 + summary_generated_at: '2026-11-18T20:21:41Z' + summary_source_hash: d795b2fa981f5baed1b0bc6ad05494aed765fc22a875d0e7b9aea3268387e3e7 + faq_generated_at: '2026-11-18T20:21:41Z' + faq_source_hash: d795b2fa981f5baed1b0bc6ad05494aed765fc22a875d0e7b9aea3268387e3e7 + summary: >- + You'll run an instrumented Flask application and an OpenTelemetry stack on a Google Axion + C4A VM. First, you'll create the VM and allow application and telemetry traffic through the + firewall. Then, you'll build the application and deploy the Collector, Prometheus, and Jaeger. + Finally, you'll generate requests and inspect metrics and traces to verify the pipeline. + faqs: + - question: Which Google Cloud C4A instance type should I use? + answer: >- + Use a `c4a-standard-4` VM, which has four vCPUs and 16 GB of memory. Run the Flask + application and observability components on this instance. + - question: Which firewall ports should be opened to access the app and observability tools? + answer: >- + Open TCP ports `8080` for Flask, `16686` for Jaeger, and `9090` for Prometheus. Also open `4317` and + `4318` for OTLP, and `8889` for Collector metrics. Add the inbound firewall rule to your + Google Cloud VM. + - question: How do I know the Flask microservice is emitting telemetry correctly? + answer: >- + Generate traffic to the Flask service on port `8080`. Check that traces appear in the + Jaeger UI and metrics populate in Prometheus. If nothing appears, verify that the OpenTelemetry + Collector is running and reachable on the OTLP ports you opened. + - question: Should the application send OTLP over gRPC or HTTP? + answer: >- + Use OTLP gRPC on port `4317` for the `app.py` example, which configures the Python + exporters to send to `otel-collector:4317`. You can use OTLP HTTP on port `4318` if you + change the SDK configuration to match. + - question: Where do I view the telemetry after deployment? + answer: >- + Use a browser to connect to the IP address of the VM on port `16686` for Jaeger and port `9090` + for Prometheus. Confirm that the firewall rules allow inbound access to these ports. +# END generated_summary_faq + author: Pareena Verma -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/pac/_index.md b/content/learning-paths/servers-and-cloud-computing/pac/_index.md index 9a5996ae65..10a25891d2 100644 --- a/content/learning-paths/servers-and-cloud-computing/pac/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/pac/_index.md @@ -1,22 +1,64 @@ --- -title: Understand Arm Pointer Authentication +title: Understand pointer authentication on Arm minutes_to_complete: 30 -who_is_this_for: This is an advanced topic for software developers interested in understanding Arm Pointer Authentication. +who_is_this_for: This is an advanced topic for software developers interested in understanding Arm pointer authentication. learning_objectives: - - Create a simple application on an Arm server with Pointer Authentication - - Compile the application with and without Pointer Authentication to inspect the instructions generated - - Exploit the applications with and without Pointer Authentication to demonstrate how Pointer Authentication instructions enhance security. + - Create a simple application on an Arm server with pointer authentication. + - Compile the application with and without pointer authentication to inspect the instructions generated. + - Exploit the applications with and without pointer authentication to see how pointer authentication instructions enhance security. prerequisites: - - An Arm based instance from a cloud service provider, or an on-premise Arm server. - - If needed, review [Get started with Arm-based cloud instances](/learning-paths/servers-and-cloud-computing/csp/) to learn how to deploy Arm in the cloud. These learning paths also point to more advanced learning paths that show how to automate the deployment of Arm instances at different cloud providers. + - An Arm based instance from a [cloud service provider](/learning-paths/servers-and-cloud-computing/csp/), or an on-premise Arm server + +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-18T20:22:02Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: 389c20aec90a820d791237ed7444ec28dfb7334bb7fb0816134a76fc5ea60b8a + summary_generated_at: '2026-11-18T20:22:02Z' + summary_source_hash: 389c20aec90a820d791237ed7444ec28dfb7334bb7fb0816134a76fc5ea60b8a + faq_generated_at: '2026-11-18T20:22:02Z' + faq_source_hash: 389c20aec90a820d791237ed7444ec28dfb7334bb7fb0816134a76fc5ea60b8a + summary: >- + You'll compare an Arm application built with and without pointer authentication. First, you + prepare a vulnerable C example and inspect the instructions in both builds. Then, you run an + exploit against the unprotected binary and observe its effect. Finally, you try the same + exploit against the protected binary to see how pointer authentication changes the outcome. + faqs: + - question: Which binary should I point the exploit at? + answer: >- + Use the unprotected build named `main_nopac`. If your build uses a different name, select + the binary you built without pointer authentication. + - question: What result should I expect when the exploit succeeds on the unprotected app? + answer: >- + When the payload diverts control to `func2`, you should see the message "Hello from + func2!" and then an interactive shell. + - question: How do I confirm that my PAC-enabled build includes pointer authentication? + answer: >- + Inspect the disassembly of both binaries and look for pointer authentication instructions in the + protected build. Compare the instruction streams before you run the exploit. + - question: How do I know that the exploit is blocked on the PAC-enabled binary? + answer: >- + Run the same exploit against the protected binary and check that you don't reach `func2` + or spawn a shell. + - question: What should I check if exploit.py fails to run or does nothing? + answer: >- + Confirm that `pwntools` is installed and that the script targets the correct path to + the unprotected binary. Also verify that you're running on the Arm system where you built the + application. +# END generated_summary_faq author: Pareena Verma -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/pac/example.md b/content/learning-paths/servers-and-cloud-computing/pac/example.md index 4fdf9b7255..13c8c04714 100644 --- a/content/learning-paths/servers-and-cloud-computing/pac/example.md +++ b/content/learning-paths/servers-and-cloud-computing/pac/example.md @@ -1,13 +1,13 @@ --- # User change -title: Example application +title: Create an example application weight: 3 # 1 is first, 2 is second, etc. # Do not modify layout: "learningpathall" --- -Create a simple `hello world` type application to demonstrate how pointer authentication works. +Create a `hello world` application to see how pointer authentication works. The example contains a function `func2()` to start a shell, that is never called by the application. @@ -80,7 +80,7 @@ dump_pac: $(PROJ) gdb-multiarch -batch -ex "disassemble func1" $< ``` -## Understanding the compiler switches +## Understand the compiler switches Arm Compiler for Embedded, GCC, and LLVM can all produce code making use of pointer authentication. diff --git a/content/learning-paths/servers-and-cloud-computing/pac/exploit.md b/content/learning-paths/servers-and-cloud-computing/pac/exploit.md index 700e71d999..b292026678 100644 --- a/content/learning-paths/servers-and-cloud-computing/pac/exploit.md +++ b/content/learning-paths/servers-and-cloud-computing/pac/exploit.md @@ -1,6 +1,6 @@ --- # User change -title: "Exploit an app built without Pointer Authentication" +title: "Exploit an app built without pointer authentication" weight: 4 # 1 is first, 2 is second, etc. @@ -133,4 +133,4 @@ $ ls [*] Process './main_pac' stopped with exit code -11 (SIGSEGV) (pid 4605) [*] Got EOF while sending in interactive ``` -This demonstrates how the Armv8.3-A Pointer Authentication feature provides protection against software attacks. +This demonstrates how the Armv8.3-A pointer authentication feature provides protection against software attacks. diff --git a/content/learning-paths/servers-and-cloud-computing/pac/pac.md b/content/learning-paths/servers-and-cloud-computing/pac/pac.md index 58b375c053..fcc164382f 100644 --- a/content/learning-paths/servers-and-cloud-computing/pac/pac.md +++ b/content/learning-paths/servers-and-cloud-computing/pac/pac.md @@ -1,17 +1,17 @@ --- # User change -title: Pointer Authentication on Arm +title: Set up pointer authentication on Arm weight: 2 # 1 is first, 2 is second, etc. # Do not modify layout: "learningpathall" --- -## Basics of Pointer Authentication +## Basics of pointer authentication `Return Oriented Programming` (`ROP`) is a software attack where the attacker corrupts the return address stored in the stack to point it to somewhere in the application with a useful sequence of instructions, ending in an indirect branch. These sequences are known as `gadgets`, and are prevalent in most code. By chaining multiple gadgets, the attacker can mislead the program to perform actions that end up in a security compromise. An example of such a security compromise is spawning an interactive shell. -Pointer Authentication is a feature, available for `Armv8.3-A` and `Armv9.0-A` (and later) Arm architectures, to provide some protection against such attacks. A `Pointer Authentication Code` (`PAC`) is generated from the value of a given pointer, and is used to verify pointers before using them. +Pointer authentication is a feature, available for `Armv8.3-A` and `Armv9.0-A` (and later) Arm architectures, to provide some protection against such attacks. A `pointer authentication code` (`PAC`) is generated from the value of a given pointer, and is used to verify pointers before using them. If attackers attempt to modify such a pointer in memory they will also need to compute the right `PAC` signature for it. Using the ROP example, if the return address stored in the stack is signed and verified before returning to it, the attacker will not be able to control the program flow and an exception is raised. @@ -19,9 +19,9 @@ Generation and use of `PAC` in applications requires compiler support, as functi See [Code reuse attacks: the compiler story](https://community.arm.com/arm-community-blogs/b/tools-software-ides-blog/posts/code-reuse-attacks-the-compiler-story) for a deeper discussion. -## Arm CPU Pointer Authentication Support Table +## Arm CPU pointer authentication support table -Below is a table which lists which Arm processors support Pointer Authentication. +Below is a table which lists which Arm processors support pointer authentication. | CPU | Pointer Auth | Arm ISA version | Notes | |-------------|:------------:|:---------------:|:-----------------------------------:| @@ -32,9 +32,9 @@ Below is a table which lists which Arm processors support Pointer Authentication | Neoverse N1 | No | Armv8.2-A | | | Neoverse E1 | No | Armv8.2-A | | -If you are looking for cloud instances with Pointer Authentication, AWS instances with Graviton3 processors are a good place to start (C7g, M7g, and R7g). +If you are looking for cloud instances with pointer authentication, AWS instances with Graviton3 processors are a good place to start (C7g, M7g, and R7g). -## Preparation for exercise the following sections +## Before you begin Install [GCC](/install-guides/gcc/native/) and other tools. The commands for using the `apt` package manager are below. Similar commands are possible with other package managers (such as `yum`). @@ -43,13 +43,13 @@ sudo apt update sudo apt install gcc make gdb-multiarch -y ``` -## Configure Pointer Authentication in the Linux kernel +## Configure pointer authentication in the Linux kernel {{% notice Note %}} The information below explains how to disable pointer authentication. This not recommended, but you may want to do it for experimentation purposes. {{% /notice %}} -Pointer Authentication is a recommended security feature, and is enabled by default in Linux distributions. However, it is possible to turn off Pointer Authentication for debug or performance investigations. It can be disabled with a kernel configuration parameter, or if the the kernel was compiled with Pointer Authentication enabled, it can be disabled with a kernel boot parameter change. +Pointer authentication is a recommended security feature, and is enabled by default in Linux distributions. However, it is possible to turn off pointer authentication for debug or performance investigations. It can be disabled with a kernel configuration parameter, or if the the kernel was compiled with pointer authentication enabled, it can be disabled with a kernel boot parameter change. Kernel configuration: ``` @@ -59,4 +59,4 @@ CONFIG_ARM64_PTR_AUTH=n Kernel boot parameter: ``` abi.ptrauth_disabled=1 -``` \ No newline at end of file +``` diff --git a/content/learning-paths/servers-and-cloud-computing/performix-agentic-dynamic-insights-claude/_index.md b/content/learning-paths/servers-and-cloud-computing/performix-agentic-dynamic-insights-claude/_index.md index d5a491e2fb..4e0af0ef85 100644 --- a/content/learning-paths/servers-and-cloud-computing/performix-agentic-dynamic-insights-claude/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/performix-agentic-dynamic-insights-claude/_index.md @@ -40,31 +40,31 @@ generated_summary_faq: verify access to recipes and runs. You'll then create or select a supported run, request an insight with its run ID, and open it in Arm Performix. Finally, you'll identify the run and compare the recommendation with profile evidence. - # faqs: - # - question: How do I verify that Claude Code can reach the Arm Performix MCP server? - # answer: >- - # Ask Claude Code to use Arm Performix to list supported Code Hotspots runs, including the - # run ID, target, workload, and creation time. If Claude Code returns the run details, you’ve - # confirmed that it can access Performix through the MCP server. - # - question: Which MCP configuration method should I use? - # answer: >- - # Configure through the extension’s MCP interface, run `claude mcp add`, or edit - # `~/.claude.json`. The extension and Claude CLI share the same MCP configuration, so you - # only need one method. - # - question: Where should I configure the Performix MCP server when using VS Code? - # answer: >- - # Configure the server on the host where Claude Code runs. For a local VS Code session, set - # it up on the same machine. - # - question: What should I prepare before creating a new Code Hotspots run? - # answer: >- - # Choose a representative workload, specify the executable with an absolute path, and build - # with debug symbols when possible. Aim for at least 20 seconds of representative execution - # to capture useful samples. - # - question: How do I open the profiled run in Arm Performix to validate the AI recommendation? - # answer: >- - # From a terminal where `apx` is on your `PATH`, run `apx run info ""`. Use the - # returned workload, recipe, target, and timestamps to locate and open the matching run in - # the GUI. + faqs: + - question: How do I verify that Claude Code can reach the Arm Performix MCP server? + answer: >- + Ask Claude Code to list available Performix recipes and profiling runs. If it returns + recipes or targets, you've confirmed the MCP connection even when the run list is empty. + When runs are available, request their IDs, targets, workloads, and creation times to choose one. + - question: Which MCP configuration method should I use? + answer: >- + Configure through the MCP interface of the extension, run `claude mcp add`, or edit + `~/.claude.json`. The extension and Claude CLI share the same MCP configuration, so you + need only one method. + - question: Where should I configure the Performix MCP server when using VS Code? + answer: >- + Configure the server on the host where Claude Code runs. For a local VS Code session, set + it up on the same machine. + - question: What should I prepare before creating a new Code Hotspots run? + answer: >- + Choose a representative workload, specify the executable with an absolute path, and build + with debug symbols when possible. Aim for at least 20 seconds of representative execution + to capture useful samples. + - question: How do I open the profiled run in Arm Performix to validate the AI recommendation? + answer: >- + From a terminal where `apx` is on your `PATH`, run `apx run info ""`. Use the + returned workload, recipe, target, and timestamps to locate and open the matching run in + the GUI. # END generated_summary_faq author: diff --git a/content/learning-paths/servers-and-cloud-computing/performix-memory-access/_index.md b/content/learning-paths/servers-and-cloud-computing/performix-memory-access/_index.md index 27e0555708..8a92bc5cbf 100644 --- a/content/learning-paths/servers-and-cloud-computing/performix-memory-access/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/performix-memory-access/_index.md @@ -8,21 +8,66 @@ minutes_to_complete: 45 who_is_this_for: This is an introductory topic for C++ developers who want to use the Arm Performix MCP server to diagnose cache and address translation behavior in applications running on Arm Neoverse servers. learning_objectives: - - Explain how L1 cache hits, TLB misses, and page walks affect C++ application performance. + - Identify how L1 cache hits, TLB misses, and page walks affect C++ application performance. - Build and visualize the orbiting galaxies example on an Arm Neoverse server. - Inspect and optimize the particle data structure using insights from the memory access recipe. - Use the Arm Performix MCP server with an AI coding agent to support an optimization workflow. prerequisites: - - Access to an Arm Neoverse bare metal server. - - Basic understanding of memory hierarchy within a CPU. - - Basic C++ development experience. - - Familiarity with the Linux command line. - - An MCP-compatible coding assistant. The example uses OpenAI Codex, which requires an OpenAI account. + - Access to an Arm Neoverse bare metal server + - Basic understanding of memory hierarchy within a CPU + - Basic C++ development experience + - Familiarity with the Linux command line + - An MCP-compatible coding assistant, such as OpenAI Codex with an OpenAI account + +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-18T20:22:32Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: 83fc875bdd49b5c6e6aa9effaec1eec7a1927175e94714b0cd1712128d80a65c + summary_generated_at: '2026-11-18T20:22:32Z' + summary_source_hash: 83fc875bdd49b5c6e6aa9effaec1eec7a1927175e94714b0cd1712128d80a65c + faq_generated_at: '2026-11-18T20:22:32Z' + faq_source_hash: 83fc875bdd49b5c6e6aa9effaec1eec7a1927175e94714b0cd1712128d80a65c + summary: >- + You'll profile a C++ particle simulation on an Arm Neoverse server and improve its memory + access behavior. First, you'll review memory hierarchy concepts, build the sample, and run the + Arm Performix Memory Access recipe. Then, you'll inspect cache and translation results to find + the hot loop. Finally, you'll refactor the particle layout and compare profiles, with optional + help from the Performix MCP server. + faqs: + - question: Should I build and run the example on the remote Arm server or my local machine? + answer: >- + Use the remote Arm server for all build and run steps. Install and configure Arm Performix + on both your local machine and the remote server. + - question: How do I confirm the simulation works before profiling? + answer: >- + Run the provided visualization after you build the binaries. Check that it runs without + errors before you start profiling. + - question: Which source files do I inspect and where do I implement changes? + answer: >- + Inspect the baseline particle model in `src/baseline/particle.hpp`. Implement your + refactor in `src/users_solution`. Update associated function signatures and call sites + there. + - question: What should I look for in the Arm Performix results to guide my refactor? + answer: >- + Check where samples concentrate, the L1 cache hit rate, and whether TLB walks are + significant. Focus on `update_positions()` and the fields accessed in that loop, because + the baseline shows a low L1 hit rate with minimal TLB impact. + - question: How do I give my coding assistant useful context while using the MCP server? + answer: >- + Open the repository's `AGENTS.md` file to give your MCP-compatible coding assistant + project context during the refactor. +# END generated_summary_faq author: Kieran Hejmadi -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/performix-microarchitecture/_index.md b/content/learning-paths/servers-and-cloud-computing/performix-microarchitecture/_index.md index e5d3164f12..73f4f09a64 100644 --- a/content/learning-paths/servers-and-cloud-computing/performix-microarchitecture/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/performix-microarchitecture/_index.md @@ -6,23 +6,66 @@ minutes_to_complete: 60 who_is_this_for: This is an introductory topic for software developers who want to learn performance analysis methodologies for Linux applications on Arm Neoverse-based servers. learning_objectives: - - Identify CPU pipeline bottlenecks using the Arm Performix CPU Microarchitecture recipe - - Analyze instruction types and SIMD utilization using the Instruction Mix recipe - - Optimize application performance using vectorization and compiler flags - - Compare performance profiles to measure execution improvements + - Identify CPU pipeline bottlenecks using the Arm Performix CPU Microarchitecture recipe. + - Analyze instruction types and SIMD utilization using the Instruction Mix recipe. + - Optimize application performance using vectorization and compiler flags. + - Compare performance profiles to measure execution improvements. prerequisites: - - An Arm Neoverse-based server running Linux, such as an Arm AGI CPU platform. + - An Arm Neoverse-based server running Linux, such as an Arm AGI CPU platform - Bare-metal server or cloud bare-metal access is preferred for hardware performance counters - Familiarity with Linux command line - Basic understanding of CPU performance concepts +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-18T20:22:57Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: f07c3428c4322f5dd76ed331cef7ff89c682e26a7d6c13f5f44aeb4345f64b72 + summary_generated_at: '2026-11-18T20:22:57Z' + summary_source_hash: f07c3428c4322f5dd76ed331cef7ff89c682e26a7d6c13f5f44aeb4345f64b72 + faq_generated_at: '2026-11-18T20:22:57Z' + faq_source_hash: f07c3428c4322f5dd76ed331cef7ff89c682e26a7d6c13f5f44aeb4345f64b72 + summary: >- + You'll profile a C++ Mandelbrot application on an Arm Neoverse Linux system with Arm + Performix. First, you'll build the application and connect Performix to the target. Then, you'll + use CPU Microarchitecture results to identify latency bottlenecks, and Instruction Mix + results to inspect Single Instruction, Multiple Data (SIMD) use. Finally, you'll change the source or compiler settings and compare + new profiles with the baseline. + faqs: + - question: Which executable path should I enter when launching a recipe? + answer: >- + Enter the full path to your compiled C++ Mandelbrot executable on the target system. An + absolute path helps you avoid launching a different binary. + - question: Which option should I use for Analysis Mode in the Instruction Mix recipe? + answer: >- + Select **Dynamic** for **Analysis Mode** to collect the instruction categories that your + workload runs. + - question: How do I interpret the CPU Microarchitecture results to choose my next step? + answer: >- + Look for pipeline stages with the largest latency contribution. Use those results to + choose a source or compiler change, then collect another profile to compare. + - question: How do I know if the application uses SIMD instructions? + answer: >- + Check the **Instruction Mix** categories for Single Instruction, Multiple Data (SIMD) or vector instructions. If you see none, + consider whether vectorizing the hot functions can help your workload. + - question: How do I run the Mandelbrot generator with multiple threads? + answer: >- + Pass a thread-count argument to the Mandelbrot executable. If you omit it, the program + runs with one thread. You can increase the count to compare profiles. +# END generated_summary_faq + author: - Brendan Long - Kieran Hejmadi - Jason Andrews -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/performix-system-characterization/_index.md b/content/learning-paths/servers-and-cloud-computing/performix-system-characterization/_index.md index 8218557974..97ce832c64 100644 --- a/content/learning-paths/servers-and-cloud-computing/performix-system-characterization/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/performix-system-characterization/_index.md @@ -8,18 +8,60 @@ minutes_to_complete: 60 who_is_this_for: This is an introductory topic for developers and performance engineers who want to characterize the hardware performance of Arm-based Linux systems using Arm Performix. learning_objectives: - - Run Arm Performix's System Characterization recipe to understand hardware configuration and performance - - Interpret memory latency and bandwidth benchmark results - - Locate and interpret the generated plots and raw benchmark data in the output directory + - Run the Arm Performix System Characterization recipe to understand hardware configuration and performance. + - Interpret memory latency and bandwidth benchmark results. + - Locate and interpret the generated plots and raw benchmark data in the output directory. prerequisites: - - A Arm Linux target machine accessible via SSH to characterize. + - An Arm Linux target machine to characterize, that you can access using SSH + +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-18T20:23:22Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: 7dd0078146532b90ffb079d1b792537c985ac343918bac46ad9c84a4f1967130 + summary_generated_at: '2026-11-18T20:23:22Z' + summary_source_hash: 7dd0078146532b90ffb079d1b792537c985ac343918bac46ad9c84a4f1967130 + faq_generated_at: '2026-11-18T20:23:22Z' + faq_source_hash: 7dd0078146532b90ffb079d1b792537c985ac343918bac46ad9c84a4f1967130 + summary: >- + You'll characterize an Arm-based Linux system with the Arm Performix System Characterization + recipe. First, you'll connect a target and choose default, static, or individual benchmarks. + Then, you'll install collection tools if needed and run the recipe. Finally, you'll review memory + latency and bandwidth in Performix, and inspect generated plots and data files. + faqs: + - question: Which benchmark option should I choose when running System Characterization? + answer: >- + Use the default set for a broad overview. Choose the static configuration option to gather + only system details. Select individual benchmarks if you want to target specific tests. + - question: What should I do on a first run if the target isn't ready for collection? + answer: >- + Select **Install Tools** in the Performix interface to copy the collection tools to the + target. After the tools are installed, start the run again. + - question: How do I know if the run completed, and where do I see results in Performix? + answer: >- + Check the **Summary** page and benchmark views for populated results. You can open the + output directory from Performix to inspect generated files. + - question: Where can I find the raw data and generated plots for my run? + answer: >- + On the **Summary** page, select **Open Run Directory**. You can inspect `.png` plots and + `.json` files produced by the Arm System Characterization Tool. + - question: What should I look for in the Idle latency view? + answer: >- + Use the **Idle latency** view to compare memory latency across NUMA nodes while the system + is idle. Look for differences that can affect where you place a workload. +# END generated_summary_faq author: - Brendan Long - David Wong -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/php-on-gcp/_index.md b/content/learning-paths/servers-and-cloud-computing/php-on-gcp/_index.md index 852b6dfdd5..a8fc76e15a 100644 --- a/content/learning-paths/servers-and-cloud-computing/php-on-gcp/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/php-on-gcp/_index.md @@ -1,23 +1,65 @@ --- -title: Deploy PHP on Google Cloud C4A Arm-based Axion VMs +title: Deploy PHP on Arm-based C4A virtual machines on Google Cloud minutes_to_complete: 30 who_is_this_for: This is an introductory topic for developers migrating Hypertext Preprocessor (PHP) workloads from x86_64 to Arm-based servers, specifically on Google Cloud C4A virtual machines (VM) built on Axion processors. learning_objectives: - - Provision a SUSE Linux Enterprise Server (SLES) virtual machine on a Google Cloud C4A Arm-based Axion virtual machine - - Install PHP on a SUSE Arm64 C4A instance - - Validate PHP functionality by running baseline HTTP server tests - - Benchmark PHP performance using PHPBench on Arm64 architecture + - Provision a SUSE Linux Enterprise Server (SLES) virtual machine on a Google Cloud C4A Arm-based VM. + - Install PHP on a SUSE Arm64 C4A instance. + - Validate PHP functionality by running baseline HTTP server tests. + - Benchmark PHP performance using PHPBench on Arm64 architecture. prerequisites: - A [Google Cloud Platform (GCP)](https://cloud.google.com/free) account with billing enabled - Basic familiarity with web servers and PHP scripting +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-18T20:23:40Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: 71763ea67e42bb6ea6ce580db0bbdb155735f0e9d4202ad1f21fbe758013f27a + summary_generated_at: '2026-11-18T20:23:40Z' + summary_source_hash: 71763ea67e42bb6ea6ce580db0bbdb155735f0e9d4202ad1f21fbe758013f27a + faq_generated_at: '2026-11-18T20:23:40Z' + faq_source_hash: 71763ea67e42bb6ea6ce580db0bbdb155735f0e9d4202ad1f21fbe758013f27a + summary: >- + You'll set up a PHP web stack on a Google Axion C4A virtual machine. First, you'll provision a + SUSE Linux VM and install PHP and Apache. Then, you configure PHP-FPM through FastCGI and + check that Apache renders a PHP test page. Finally, you run PHPBench on the VM and record + its timing and throughput results as a baseline. + faqs: + - question: Which C4A machine type and OS image should I use? + answer: >- + Use the `c4a-standard-4` machine type and a SUSE Linux image. + - question: What result should I expect after configuring PHP-FPM and connecting it to Apache? + answer: >- + Request a test PHP page through Apache. You should see rendered output rather than PHP + source code when Apache passes the request to PHP-FPM through FastCGI. + - question: How do I know that the baseline HTTP server tests passed? + answer: >- + Check for an HTTP `200` response and the expected PHP-generated content. If you see source + code or a downloaded file, revisit your PHP, Apache, and PHP-FPM configuration. + - question: Where should I run PHPBench, and what outputs should I review? + answer: >- + Run PHPBench on the provisioned C4A VM after completing PHP installation and baseline + validation. Review the report for mode time, variance, and throughput. Record these + values as your baseline. + - question: What should I check if PHPBench fails to run or reports missing components? + answer: >- + Confirm that PHP and PHPBench are installed on the VM. Run PHPBench in the same + environment where you validated the PHP stack. +# END generated_summary_faq + author: Pareena Verma -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/pinning-threads/_index.md b/content/learning-paths/servers-and-cloud-computing/pinning-threads/_index.md index fd146a6f62..60821b51f0 100644 --- a/content/learning-paths/servers-and-cloud-computing/pinning-threads/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/pinning-threads/_index.md @@ -6,10 +6,10 @@ minutes_to_complete: 30 who_is_this_for: This is an advanced topic for developers, performance engineers, and system administrators looking to fine-tune the performance of their workload on many-core Arm-based systems. learning_objectives: - - Pin threads to specific CPU cores using taskset and source code modifications - - Measure cache performance improvements from thread pinning using perf - - Evaluate performance trade-offs between throughput and latency consistency - - Implement CPU affinity strategies for co-located workloads + - Pin threads to specific CPU cores using taskset and source code modifications. + - Measure cache performance improvements from thread pinning using perf. + - Evaluate performance trade-offs between throughput and latency consistency. + - Implement CPU affinity strategies for co-located workloads. prerequisites: - An Arm Linux system with four or more CPU cores @@ -17,9 +17,53 @@ prerequisites: - Understanding of build systems and computer architecture concepts - Familiarity with Linux command-line tools +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-18T20:24:03Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: 380cac309a91373ac3e476167048a760f80d38a448c653f0540c117b5a887715 + summary_generated_at: '2026-11-18T20:24:03Z' + summary_source_hash: 380cac309a91373ac3e476167048a760f80d38a448c653f0540c117b5a887715 + faq_generated_at: '2026-11-18T20:24:03Z' + faq_source_hash: 380cac309a91373ac3e476167048a760f80d38a448c653f0540c117b5a887715 + summary: >- + You'll control CPU placement for a workload on Arm-based Linux and measure the effects. + First, you'll inspect CPU topology and build a CPU-intensive example. Then, you'll use `taskset` + and source-level affinity to place processes and threads on selected cores. Finally, you'll + compare pinned and unpinned runs, and use `perf` metrics to assess cache behavior and runtime + stability. + faqs: + - question: How do I check whether my system uses a single NUMA node before pinning? + answer: >- + Run `lscpu | grep -i numa` and check the NUMA node count. + - question: Which cores should I choose when using taskset for the single-threaded benchmark? + answer: >- + On a uniform system, select an available core for your single-threaded test. For a + multithreaded test, select the specific cores that you intend to dedicate to its threads. + - question: How do I know that pinning with taskset actually changed behavior? + answer: >- + Compare unpinned and pinned runs for runtime stability and throughput. Use `perf` to + collect cache metrics. Look for differences in cache references and misses between the + two cases. + - question: Where should I place source-level affinity calls? + answer: >- + Set affinity immediately after creating a thread or before it enters the hot path that + does the critical work. Pin only the threads that you need to control. Leave the others managed + by the scheduler. + - question: What should I check if perf results don't show a clear difference after pinning? + answer: >- + Run enough iterations to reduce noise and ensure the system isn't under heavy background + load. Verify that the chosen affinity mask targets cores that are online and available. +# END generated_summary_faq + author: Kieran Hejmadi -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/pinning-threads/setup.md b/content/learning-paths/servers-and-cloud-computing/pinning-threads/setup.md index ad4d15aa9b..7257db1bbf 100644 --- a/content/learning-paths/servers-and-cloud-computing/pinning-threads/setup.md +++ b/content/learning-paths/servers-and-cloud-computing/pinning-threads/setup.md @@ -6,7 +6,7 @@ weight: 3 layout: learningpathall --- -## Setup +## Set up Linux system This Learning Path works on any Arm Linux system with four or more CPU cores. diff --git a/content/learning-paths/servers-and-cloud-computing/pmuv3_plugin_learning_path/_index.md b/content/learning-paths/servers-and-cloud-computing/pmuv3_plugin_learning_path/_index.md index fece12692c..3772ce5b69 100644 --- a/content/learning-paths/servers-and-cloud-computing/pmuv3_plugin_learning_path/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/pmuv3_plugin_learning_path/_index.md @@ -1,23 +1,65 @@ --- -title: Implement Code level Performance Analysis using the PMUv3 plugin +title: Implement code-level performance analysis using the PMUv3 plugin minutes_to_complete: 60 -who_is_this_for: Engineers who want to carry out C/C++ performance analysis by instrumenting code at the block level. +who_is_this_for: Engineers who want to carry out C or C++ performance analysis by instrumenting code at the block level. learning_objectives: - Generate a fine-grained, precise measurement of functions and other sections of code. - - Instrument your code to analyze a single section or multiple sections using the provided instrumentation scenarios. + - Instrument your code to analyze a single section or multiple sections. - Run and collect performance metrics and raw event values for any of the 15 event groups (bundles) in a single run. - Use a tool to plot raw PMU event values along with KPI metric values such as MPKI, stalls, and IPC to aid performance visualization. prerequisites: - - An Arm-based computer running Linux, such as an Arm AGI CPU platform. - - Some familiarity with Linux application performance analysis. + - An Arm-based computer running Linux, such as an Arm AGI CPU platform + - Some familiarity with Linux application performance analysis + +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-18T20:24:31Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: 996e16308e0deb510bb0872bbeb1111dc7c628318b9befae1f883e2dcd6fc369 + summary_generated_at: '2026-11-18T20:24:31Z' + summary_source_hash: 996e16308e0deb510bb0872bbeb1111dc7c628318b9befae1f883e2dcd6fc369 + faq_generated_at: '2026-11-18T20:24:31Z' + faq_source_hash: 996e16308e0deb510bb0872bbeb1111dc7c628318b9befae1f883e2dcd6fc369 + summary: >- + You'll instrument C code with the PMUv3 plugin to measure selected regions on Arm-based + Linux. First, you'll enable user-space PMU access and build the plugin. Then, you'll add headers + and measurement calls to one code section before extending to multiple sections. + Finally, you'll plot raw counter values and derived metrics to compare the measured regions. + faqs: + - question: How do I know userspace PMU access is enabled before I run the plugin? + answer: >- + Run `cat /proc/sys/kernel/perf_user_access` and check that it prints `1`. If needed, run + `sudo sysctl kernel/perf_user_access=1` to enable user-space access. + - question: What do I do if PMU access fails after a reboot? + answer: >- + Run `sudo sysctl kernel/perf_user_access=1` again after a reboot. The setting doesn't + persist across restarts. + - question: How should I organize my directories before I instrument my application? + answer: >- + Keep three parallel directories: the Linux kernel source tree, the PMUv3 plugin source, + and a test application directory. If your layout differs, adjust your build to locate the + plugin headers and libraries. + - question: How do I identify each code section when collecting PMUv3 counters? + answer: >- + Initialize the bundle once, then give each section its own marker and index in the start and stop calls. The output labels the measurements by section. + - question: What should I expect from the plotting tool, and how do I confirm my run captured data? + answer: >- + Use the Python plotting program to inspect raw PMU events and metrics such as MPKI, + stalls, and IPC. Check that your plots contain data for the instrumented regions. +# END generated_summary_faq author: Gayathri Narayana Yegna Narayanan -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/postgresql-cobalt/_index.md b/content/learning-paths/servers-and-cloud-computing/postgresql-cobalt/_index.md index 6d1257e61a..b60272b38d 100644 --- a/content/learning-paths/servers-and-cloud-computing/postgresql-cobalt/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/postgresql-cobalt/_index.md @@ -6,21 +6,63 @@ minutes_to_complete: 30 who_is_this_for: This learning path is designed for developers, DevOps engineers, and platform engineers who want to deploy, manage, and optimize PostgreSQL databases on Arm-based cloud infrastructure. learning_objectives: - - Install and configure PostgreSQL on Azure Cobalt 200 Arm64 virtual machines - - Deploy a relational database schema for transactional workloads - - Execute analytical SQL queries on operational data - - Benchmark PostgreSQL performance using pgbench - - Monitor and optimize query performance using built-in PostgreSQL tools + - Install and configure PostgreSQL on Azure Cobalt 200 Arm64 virtual machines. + - Deploy a relational database schema for transactional workloads. + - Execute analytical SQL queries on operational data. + - Benchmark PostgreSQL performance using pgbench. + - Monitor and optimize query performance using built-in PostgreSQL tools. prerequisites: - - A [Microsoft Azure account](https://azure.microsoft.com/) with access to Cobalt 200 based instances (Dpsv7) + - A [Microsoft Azure account](https://azure.microsoft.com/) with access to Cobalt 200-based instances (Dpsv7) - Basic knowledge of Linux command-line operations - Familiarity with SSH and remote server access - Basic understanding of databases and SQL +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-18T20:25:42Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: cea96a5447df4e23b499140de911456ca3c6b2fa72c62651ee9bc7dd329842bc + summary_generated_at: '2026-11-18T20:25:42Z' + summary_source_hash: cea96a5447df4e23b499140de911456ca3c6b2fa72c62651ee9bc7dd329842bc + faq_generated_at: '2026-11-18T20:25:42Z' + faq_source_hash: cea96a5447df4e23b499140de911456ca3c6b2fa72c62651ee9bc7dd329842bc + summary: >- + You'll deploy PostgreSQL on an Azure Cobalt 200-based VM and examine its performance. First, you'll + create the VM, install PostgreSQL, and configure a database user. Then, you'll create tables, + load sample data, and run analytical queries. Finally, you'll benchmark with `pgbench`, inspect + statement statistics, add indexes, and compare query behavior after tuning. + faqs: + - question: Which Azure VM option should I use for this deployment? + answer: >- + Use the `Standard_D4ps_v7` VM in the Dpsv7 series on Azure Cobalt 200. + - question: How do I verify PostgreSQL is running after installation? + answer: >- + Connect locally using `psql` as the postgres superuser. If the `psql` prompt opens without + errors, the service is running. + - question: What result should I expect after creating the schema and loading data? + answer: >- + Check that your `customers` and `orders` tables contain the sample data, and that the + analytical queries run without errors. Connect as the application user to validate access. + - question: What does running pgbench initialization change in my database? + answer: >- + Run `pgbench` initialization to prepare its benchmark dataset. It recreates the + `pgbench_*` tables in your target database. Leave `psql` with `\q` before running the + command in the VM terminal. + - question: How do I decide which indexes to add when tuning? + answer: >- + Use PostgreSQL built-in monitoring, such as `pg_stat_statements`, to identify statements that are high-latency or run frequently. Create indexes on relevant columns, then rerun the + queries or `pgbench` to compare results. +# END generated_summary_faq + author: Pareena Verma -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/postgresql-cobalt/images/instance.png b/content/learning-paths/servers-and-cloud-computing/postgresql-cobalt/images/instance.png deleted file mode 100755 index e43b24074d..0000000000 Binary files a/content/learning-paths/servers-and-cloud-computing/postgresql-cobalt/images/instance.png and /dev/null differ diff --git a/content/learning-paths/servers-and-cloud-computing/postgresql-cobalt/images/instance.webp b/content/learning-paths/servers-and-cloud-computing/postgresql-cobalt/images/instance.webp new file mode 100644 index 0000000000..5a7762202e Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/postgresql-cobalt/images/instance.webp differ diff --git a/content/learning-paths/servers-and-cloud-computing/postgresql-cobalt/instance.md b/content/learning-paths/servers-and-cloud-computing/postgresql-cobalt/instance.md index 355f9135c9..d85fafbcd4 100644 --- a/content/learning-paths/servers-and-cloud-computing/postgresql-cobalt/instance.md +++ b/content/learning-paths/servers-and-cloud-computing/postgresql-cobalt/instance.md @@ -36,7 +36,7 @@ Creating a virtual machine based on Azure Cobalt 200 is no different from creati - Select **D4ps_v7** from the list. -![Azure portal VM size selection#center](images/instance.png "VM size selection in the Azure portal") +![Azure portal VM size selection#center](images/instance.webp "VM size selection in the Azure portal") - For **Authentication type**, select **SSH public key**. diff --git a/content/learning-paths/servers-and-cloud-computing/postgresql/_index.md b/content/learning-paths/servers-and-cloud-computing/postgresql/_index.md index 43d4a87be0..03ec7c0122 100644 --- a/content/learning-paths/servers-and-cloud-computing/postgresql/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/postgresql/_index.md @@ -1,21 +1,64 @@ --- -title: Learn how to deploy PostgreSQL +title: Deploy PostgreSQL on Arm minutes_to_complete: 30 who_is_this_for: This is an introductory topic for software developers who want to deploy PostgreSQL on Arm. learning_objectives: - - Learn about the various ways PostgreSQL can be deployed. - - Learn how to interact with a PostgreSQL database using the psql client tool. + - Identify various ways that PostgreSQL can be deployed on Arm. + - Interact with a PostgreSQL database using the psql client tool. prerequisites: - An Arm based instance from a cloud service provider, or an on-premise Arm server. - If you do not have an Arm node, the next section discusses some options. +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-18T20:25:15Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: 95fb3d07b9161c973aed512687c3a2bd70e974e52df15e7a07bbb97725bf6f35 + summary_generated_at: '2026-11-18T20:25:15Z' + summary_source_hash: 95fb3d07b9161c973aed512687c3a2bd70e974e52df15e7a07bbb97725bf6f35 + faq_generated_at: '2026-11-18T20:25:15Z' + faq_source_hash: 95fb3d07b9161c973aed512687c3a2bd70e974e52df15e7a07bbb97725bf6f35 + summary: >- + You'll review ways to run PostgreSQL on Arm, including bare metal, cloud VMs, and managed + services. First, you'll compare deployment options and identify the relevant installation + documentation for your environment. Then, you'll inspect the PostgreSQL build configuration + with `pg_config`. Finally, you'll connect to a database with `psql` and try SQL commands to check that + your database responds. + faqs: + - question: Which PostgreSQL deployment option should I choose on Arm? + answer: >- + Review the self-managed options for bare metal or cloud VMs if you need control over the + server. Consider a managed service if you prefer provider-operated maintenance. + - question: How do I know PostgreSQL started correctly? + answer: >- + After you install PostgreSQL, use `psql` to connect to the database. A successful prompt + and basic SQL command show that your database responds. + - question: Can I use psql with a managed PostgreSQL service? + answer: >- + Use the hostname of your managed service and credentials with `psql`, then run a basic query to + check access. + - question: How can I inspect the PostgreSQL build configuration? + answer: >- + Run `pg_config` on your Arm server. Check the `CONFIGURE` line for compiler and linker flags, + including `CFLAGS`, `CXXFLAGS`, and `LDFLAGS`. + - question: What should I check if psql can't connect? + answer: >- + Check that your server or managed endpoint is running and reachable. Verify the database + name, user, and authentication settings before you retry `psql`. +# END generated_summary_faq + author: Jason Andrews -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/postgresql_tune/_index.md b/content/learning-paths/servers-and-cloud-computing/postgresql_tune/_index.md index e93fc29b39..07a27c03f3 100644 --- a/content/learning-paths/servers-and-cloud-computing/postgresql_tune/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/postgresql_tune/_index.md @@ -12,12 +12,58 @@ learning_objectives: - Evaluate storage, kernel, compiler, and library choices that can affect PostgreSQL performance. prerequisites: - - On-prem or cloud [installation of PostgreSQL](/learning-paths/servers-and-cloud-computing/postgresql/) + - On-premises or cloud [installation of PostgreSQL](/learning-paths/servers-and-cloud-computing/postgresql/) - A repeatable PostgreSQL workload or benchmark that you can run before and after tuning +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-18T20:26:14Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: 1b0b89b63d7ba6c8b55708fa735e48bbdb0a1b706de1fb56f91d3f066f9f6d88 + summary_generated_at: '2026-11-18T20:26:14Z' + summary_source_hash: 1b0b89b63d7ba6c8b55708fa735e48bbdb0a1b706de1fb56f91d3f066f9f6d88 + faq_generated_at: '2026-11-18T20:26:14Z' + faq_source_hash: 1b0b89b63d7ba6c8b55708fa735e48bbdb0a1b706de1fb56f91d3f066f9f6d88 + summary: >- + You'll evaluate PostgreSQL tuning choices on Arm-based Linux using repeatable measurements. + First, you'll establish a baseline and review storage, kernel, compiler, and library + considerations. Then, you'll examine PostgreSQL settings for memory, logging, planning, and + concurrency. Finally, you'll test one change at a time with a representative workload or + HammerDB, and compare the results before adopting a setting. + faqs: + - question: Which PostgreSQL configuration method should I use for persistent tuning changes in my environment? + answer: >- + Set parameters in `postgresql.conf` or with `ALTER SYSTEM`. For persistent tuning, use a + method that you can review, version control, and apply consistently on restart. Reserve + per-database, role, or session settings for scoped changes. + - question: How should I design my measurements when I test a tuning change? + answer: >- + Treat tuning as a measurement process: change one parameter at a time, run a designed + experiment, and compare profiles. You can also use automation or AI-assisted tools to + explore a larger configuration space. + - question: When should I use HammerDB TPROC-C versus my own workload? + answer: >- + Use HammerDB TPROC-C to compare your baseline with a tuned configuration under a + repeatable workload. Also test with the SQL, data size, concurrency, and + latency requirements of your application. + - question: What should I check about my storage setup before I tune PostgreSQL parameters? + answer: >- + Compare the storage choices available to you before changing PostgreSQL parameters. Test + their effects on throughput and latency with your workload. + - question: How do I decide how many huge pages I need for PostgreSQL? + answer: >- + Size huge pages to cover the PostgreSQL shared memory area. Calculate the number you need + from your shared memory configuration. +# END generated_summary_faq + author: Julio Suarez -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/processwatch/_index.md b/content/learning-paths/servers-and-cloud-computing/processwatch/_index.md index f2ba94c87e..1a2e402575 100644 --- a/content/learning-paths/servers-and-cloud-computing/processwatch/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/processwatch/_index.md @@ -13,9 +13,54 @@ prerequisites: - An Arm-based system (bare metal server, cloud instance, or developer board) running Linux with kernel version 5.8.0 or later. - Root access, or the ability to run the sudo command. +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-18T20:26:43Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: 3774f8cd7c5738f948d43bbb27b92b8d4d88d83a31f4eb5b44c9a5d31adeec8e + summary_generated_at: '2026-11-18T20:26:43Z' + summary_source_hash: 3774f8cd7c5738f948d43bbb27b92b8d4d88d83a31f4eb5b44c9a5d31adeec8e + faq_generated_at: '2026-11-18T20:26:43Z' + faq_source_hash: 3774f8cd7c5738f948d43bbb27b92b8d4d88d83a31f4eb5b44c9a5d31adeec8e + summary: >- + You'll build Process Watch on Arm-based Linux and use it to inspect instruction activity. + First, you'll install dependencies, clone the source with submodules, and configure access for + running the tool. Then, you'll learn how its sampled instruction counters appear by process. + Finally, you'll compile and run a small C workload and check its Process Watch output for the + expected instruction groups. + faqs: + - question: Do I need to clone submodules when getting the source? + answer: >- + Yes. Use `git clone --recursive` to ensure that all submodules are fetched with the Process + Watch repository. + - question: Should I run Process Watch as root, or can I enable it for a non-root user? + answer: >- + Run Process Watch as root for the documented setup. For non-root use, set capabilities + with `sudo setcap CAP_PERFMON,CAP_BPF=+ep ./processwatch` and adjust + `kernel.perf_event_paranoid` and `kernel.unprivileged_bpf_disabled`. + - question: How do I see the available command-line options? + answer: >- + Run `sudo ./processwatch -h` to display the supported arguments and usage information. + - question: What should I look for in the output to confirm specific Arm instructions are used? + answer: >- + Check the columns for `FPArmv8`, `NEON`, `SVE`, and `SVE2`. Look for non-zero counts for the `PID` + and `NAME` of your workload, along with `%TOTAL` and `TOTAL` values that reflect sampled + instructions. + - question: How do I verify that Process Watch is observing my test workload? + answer: >- + Compile `workload.c`, run the resulting executable in the background, and note its PID. + Start Process Watch with `-p` set to that PID. Check the workload row for changing totals + and instruction counts. +# END generated_summary_faq + author: Graham Woodward -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/profiling-for-neoverse/_index.md b/content/learning-paths/servers-and-cloud-computing/profiling-for-neoverse/_index.md index d33de9e4fa..bb07890fab 100644 --- a/content/learning-paths/servers-and-cloud-computing/profiling-for-neoverse/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/profiling-for-neoverse/_index.md @@ -6,15 +6,59 @@ minutes_to_complete: 15 who_is_this_for: This is an introductory guide for developers who want to measure and optimize the performance of applications running on Arm Neoverse™-based servers. learning_objectives: - - Describe Arm's top-down profiling methodology. + - Identify the Arm top-down profiling methodology. - Use Streamline CLI tools to capture and analyze performance data from an application. prerequisites: - - An Arm Neoverse-based (N1, N2 or V1) computer running Linux. For your host OS, you can use Amazon Linux 2023 or newer, Debian 10 or newer, RHEL 8 or newer, or Ubuntu 20.04 or newer. + - An Arm Neoverse-based (N1, N2 or V1) computer running Amazon Linux 2023 or later, Debian 10 or later, RHEL 8 or later, or Ubuntu 20.04 or later + +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-19T15:57:10Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: 2869c5b6c97f5a7b831917816ddfd0358987f040072a1ae5466ff1eb46ffec1c + summary_generated_at: '2026-11-19T15:57:10Z' + summary_source_hash: 2869c5b6c97f5a7b831917816ddfd0358987f040072a1ae5466ff1eb46ffec1c + faq_generated_at: '2026-11-19T15:57:10Z' + faq_source_hash: 2869c5b6c97f5a7b831917816ddfd0358987f040072a1ae5466ff1eb46ffec1c + summary: >- + You'll profile applications on Arm Neoverse Linux servers with Streamline CLI tools and + top-down analysis. First, you'll check hardware profiling support with Arm Sysreport and + learn how pipeline slots reveal performance bottlenecks. You'll then build with debug + information, capture samples with `sl-record`, analyze them with `sl-analyze`, and format + the report with `sl-format.py`. Finally, you'll use function metrics to prioritize + optimization. + faqs: + - question: How do I check whether my system supports hardware-assisted profiling? + answer: >- + Run Arm Sysreport and review its performance counter and Statistical Profiling Extension + (SPE) entries. You can see the available CPU counters and whether SPE is present. + - question: How do I include function names in the report? + answer: >- + Build your application with debug information before recording. You can then map sampled + instructions to functions in the analysis. + - question: Which Streamline CLI tools do I run, and in what order? + answer: >- + Use `sl-record` to capture samples, `sl-analyze` to create function metrics, and + `sl-format.py` to format the results. + - question: Which metrics help me identify a bottleneck? + answer: >- + Review `Retiring%`, `FE bound%`, `Bad spec%`, and `BE bound%` in the functions report. + You can use their relative values to decide which functions need closer inspection. + - question: What can I try if a hot function has instruction cache misses? + answer: >- + Consider profile-guided optimization to reduce less important code and leave more + instruction cache space for critical paths. Measure again to check the effect. +# END generated_summary_faq author: Julie Gaskin -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/puppet-on-gcp/_index.md b/content/learning-paths/servers-and-cloud-computing/puppet-on-gcp/_index.md index 8ed4a39c59..a8b903a3ea 100644 --- a/content/learning-paths/servers-and-cloud-computing/puppet-on-gcp/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/puppet-on-gcp/_index.md @@ -6,21 +6,63 @@ minutes_to_complete: 30 who_is_this_for: This is an introductory topic for developers deploying and optimizing Puppet workloads on Arm Linux environments, specifically using Google Cloud C4A virtual machines powered by Axion processors. learning_objectives: - - Provision an Arm-based SUSE SLES (SUSE Linux Enterprise Server) virtual machine (VM) on Google Cloud C4A with Axion processors - - Install Puppet on a SUSE Arm64 C4A instance - - Verify Puppet by applying a test manifest and confirming successful resource creation on Arm64 - - Benchmark Puppet by measuring catalog compile time, apply speed, and resource usage on Arm64 + - Provision an Arm-based SUSE SLES (SUSE Linux Enterprise Server) virtual machine (VM) on Google Cloud C4A with Axion processors. + - Install Puppet on a SUSE Arm64 C4A instance. + - Verify Puppet by applying a test manifest and confirming successful resource creation on Arm64. + - Benchmark Puppet by measuring catalog compile time, apply speed, and resource usage on Arm64. + +prerequisites: + - A [Google Cloud Platform (GCP)](https://cloud.google.com/free) account with billing enabled + - Basic familiarity with [Puppet](https://www.puppet.com/) + +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-19T15:57:44Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: ed729f599b63ca1094a46c3e2623e876345f833c37bc265a985acc718df8ffde + summary_generated_at: '2026-11-19T15:57:44Z' + summary_source_hash: ed729f599b63ca1094a46c3e2623e876345f833c37bc265a985acc718df8ffde + faq_generated_at: '2026-11-19T15:57:44Z' + faq_source_hash: ed729f599b63ca1094a46c3e2623e876345f833c37bc265a985acc718df8ffde + summary: >- + You'll install and validate Puppet on a Google Axion C4A VM running SUSE Linux. After + provisioning a `c4a-standard-4` instance, you'll install dependencies and build Ruby before + installing Puppet. You'll then check Puppet and Facter versions, apply a test manifest, and + inspect the created resource. Finally, you'll run a standalone benchmark to measure local + catalog compilation and apply performance. + faqs: + - question: Which machine type and image should I select? + answer: >- + Choose `c4a-standard-4` and a SUSE Linux Enterprise Server arm64 image. + - question: Which command do I use to run the standalone Puppet benchmark? + answer: >- + Run `time puppet apply benchmark.pp --verbose` from `~/puppet-benchmark`. + You can review the catalog compilation and elapsed time in the output. + - question: How do I verify Puppet and Facter before applying a manifest? + answer: >- + Run `puppet --version` and `facter --version`. You should see a version from each + command. + - question: How do I verify that the test manifest worked? + answer: >- + Apply the manifest, then run `cat /tmp/puppet_test.txt` to inspect the file that it creates. + You can also review the Puppet resource change output. + - question: Where do I put the benchmark manifest? + answer: >- + Create `~/puppet-benchmark` and place the provided manifest there. You can then run the + benchmark and record its catalog compile time, apply speed, and resource usage. +# END generated_summary_faq author: Pareena Verma -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false -prerequisites: - - A [Google Cloud Platform (GCP)](https://cloud.google.com/free) account with billing enabled - - Basic familiarity with [Puppet](https://www.puppet.com/) - ##### Tags skilllevels: Introductory subjects: Performance and Architecture diff --git a/content/learning-paths/servers-and-cloud-computing/puppeteer-headless-chrome/_index.md b/content/learning-paths/servers-and-cloud-computing/puppeteer-headless-chrome/_index.md index d10b21108c..949372f722 100644 --- a/content/learning-paths/servers-and-cloud-computing/puppeteer-headless-chrome/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/puppeteer-headless-chrome/_index.md @@ -37,32 +37,32 @@ generated_summary_faq: Then, you'll run three scripts against a local Hugo site to check page content, validate a documentation link, and capture a screenshot. Finally, you'll add a workflow that runs the scripts on an Arm runner. -# faqs: -# - question: Which Chrome package should I install on my distribution, and how do I verify it -# installed correctly? -# answer: >- -# Use the official arm64 Chrome package that matches your distribution: Debian-based for Ubuntu -# 24.04 or RPM-based for Amazon Linux 2023. After installation, run `google-chrome --version` -# and expect a Chrome version number. -# - question: How do I confirm my Node.js version meets Puppeteer’s requirement? -# answer: >- -# You need Node.js 18 or later for Puppeteer. Install Node.js v20 as shown, then run -# `node --version` and `npm --version` to verify the installed versions. -# - question: What do I need in my repository before writing and running the tests against the -# Hugo site? -# answer: >- -# You authenticate with GitHub using `gh auth login`, then fork and clone the Ecosystem Dashboard -# for Arm repository. Add your Puppeteer scripts inside the clone so you can commit them for the -# workflow. -# - question: How do I verify the GitHub Actions workflow? -# answer: >- -# You can trigger it manually with **Run workflow** on the `main` branch. In a successful run, -# the three test steps and screenshot upload show green check marks, and you can download the -# `dashboard-screenshot` artifact from the run summary. -# - question: Which runner architecture should I choose for GitHub Actions? -# answer: >- -# Use `runs-on: ubuntu-24.04-arm` to select a GitHub-hosted runner with 64-bit Arm hardware, -# matching your Arm server's architecture. + faqs: + - question: Which Chrome package should I install on my distribution, and how do I verify it + installed correctly? + answer: >- + Use the official arm64 Chrome package that matches your distribution: Debian-based for Ubuntu + 24.04 or RPM-based for Amazon Linux 2023. After installation, run `google-chrome --version` + and expect a Chrome version number. + - question: How do I confirm my Node.js version meets Puppeteer requirements? + answer: >- + Install Node.js 22, then run `node --version` to confirm it reports 22.12 or later. + Run `npm --version` to confirm that npm is available. + - question: What do I need in my repository before writing and running the tests against the + Hugo site? + answer: >- + Authenticate with GitHub using `gh auth login`, then fork and clone the Ecosystem Dashboard + for Arm repository. Add your Puppeteer scripts inside the clone so that you can commit them for the + workflow. + - question: How do I verify the GitHub Actions workflow? + answer: >- + You can run it manually with **Run workflow** on the `main` branch. In a successful run, + the three test steps and screenshot upload show green check marks. You can download the + `dashboard-screenshot` artifact from the run summary. + - question: Which runner architecture should I choose for GitHub Actions? + answer: >- + Use `runs-on: ubuntu-24.04-arm` to select a GitHub-hosted runner with 64-bit Arm hardware, + matching the architecture of your Arm server. # END generated_summary_faq author: Jason Andrews diff --git a/content/learning-paths/servers-and-cloud-computing/puppeteer-headless-chrome/ci.md b/content/learning-paths/servers-and-cloud-computing/puppeteer-headless-chrome/ci.md index e7d00dc0dd..ec61b01f73 100644 --- a/content/learning-paths/servers-and-cloud-computing/puppeteer-headless-chrome/ci.md +++ b/content/learning-paths/servers-and-cloud-computing/puppeteer-headless-chrome/ci.md @@ -9,11 +9,7 @@ layout: "learningpathall" ## Run tests on pull requests -You can run Puppeteer tests automatically on pull requests to check changes before merging them. You'll create a workflow that performs the following tasks: - -- Checks out the repository -- Starts Hugo -- Runs all three Puppeteer scripts +You can run Puppeteer tests automatically on pull requests to check changes before merging them. You'll create a workflow that checks out the repository, starts Hugo, and runs all three Puppeteer scripts. If any script exits with a non-zero code, the workflow fails. @@ -70,7 +66,7 @@ jobs: - name: Set up Node.js uses: actions/setup-node@v4 with: - node-version: '20' + node-version: '22' - name: Install Chrome run: | @@ -116,7 +112,7 @@ Each step in the workflow accomplishes the following tasks: - `actions/checkout@v4` clones the repository onto the runner. - `peaceiris/actions-hugo@v3` installs the Hugo extended binary at the pinned version. The `extended: true` flag is required because the dashboard uses Hugo Pipes for asset processing. - `hugo server --port 1313 &` starts the development server in the background. The `&` is essential because without it, the step never finishes. -- `actions/setup-node@v4` installs Node.js 20 and adds `npm` to the path. +- `actions/setup-node@v4` installs Node.js 22 and adds `npm` to the path. - `Install Chrome` downloads the official Google arm64 `.deb` package and installs it with `apt`. This is the same package that you installed on your server earlier. - `Install Puppeteer` runs `npm install puppeteer-core` inside the `puppeteer-tests` directory where your test scripts live. - `npx wait-on` polls `http://localhost:1313` until Hugo responds or the 30-second timeout expires. This prevents the test steps from starting before the server is ready. diff --git a/content/learning-paths/servers-and-cloud-computing/puppeteer-headless-chrome/setup.md b/content/learning-paths/servers-and-cloud-computing/puppeteer-headless-chrome/setup.md index 12781cf553..dd07502c91 100644 --- a/content/learning-paths/servers-and-cloud-computing/puppeteer-headless-chrome/setup.md +++ b/content/learning-paths/servers-and-cloud-computing/puppeteer-headless-chrome/setup.md @@ -1,6 +1,6 @@ --- title: "Set up Chrome and Node.js for headless testing" -description: "Install and verify Google Chrome and Node.js v20 on Ubuntu 24.04 or Amazon Linux 2023 (arm64) for headless testing." +description: "Install and verify Google Chrome and Node.js 22 on Ubuntu 24.04 or Amazon Linux 2023 (arm64) for headless testing." weight: 3 @@ -25,15 +25,15 @@ Google Chrome 155.0.8059.84 ## Install and verify Node.js -Puppeteer requires Node.js 18 or later. Install Node.js v20 LTS by using the package manager for your distribution: +Puppeteer requires Node.js 22.12 or later. Install Node.js 22 by using the package manager for your distribution: {{< tabpane code=true >}} {{< tab header="Ubuntu 24.04" language="bash" >}} -curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash - +curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash - sudo apt install -y nodejs {{< /tab >}} {{< tab header="Amazon Linux 2023" language="bash" >}} -sudo dnf install -y nodejs npm +sudo dnf install -y nodejs22 nodejs22-npm {{< /tab >}} {{< /tabpane >}} @@ -44,12 +44,7 @@ node --version npm --version ``` -The output is similar to: - -```output -v20.20.2 -10.8.2 -``` +Confirm that Node.js reports version 22.12 or later. The npm version can vary. ## What you've accomplished and what's next diff --git a/content/learning-paths/servers-and-cloud-computing/pytorch-llama/_index.md b/content/learning-paths/servers-and-cloud-computing/pytorch-llama/_index.md index cfb5f8217e..30a28c0d49 100644 --- a/content/learning-paths/servers-and-cloud-computing/pytorch-llama/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/pytorch-llama/_index.md @@ -3,7 +3,7 @@ title: Run a PyTorch LLM chatbot with KleidiAI on Arm minutes_to_complete: 30 -who_is_this_for: This is an introductory topic for software developers interested in running LLMs using PyTorch on Arm-based servers. +who_is_this_for: This is an introductory topic for software developers interested in running large language models (LLMs) using PyTorch on Arm-based servers. learning_objectives: - Download the Meta Llama 3.1 model from the Meta Hugging Face repository. @@ -13,14 +13,55 @@ learning_objectives: - Measure performance metrics of the LLM inference running on an Arm-based CPU. prerequisites: - - An [Arm-based instance](/learning-paths/servers-and-cloud-computing/csp/) with at least 16 CPUs from a cloud service provider or an on-premise Arm server. + - An [Arm-based instance](/learning-paths/servers-and-cloud-computing/csp/) with at least 16 CPUs from a cloud service provider, or an on-premise Arm server + +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-19T15:58:37Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: de0c91f69925ca664abbb3d7383c52a0196ecf72864260599ef6afbf4032319c + summary_generated_at: '2026-11-19T15:58:37Z' + summary_source_hash: de0c91f69925ca664abbb3d7383c52a0196ecf72864260599ef6afbf4032319c + faq_generated_at: '2026-11-19T15:58:37Z' + faq_source_hash: de0c91f69925ca664abbb3d7383c52a0196ecf72864260599ef6afbf4032319c + summary: >- + You'll run a PyTorch chatbot with KleidiAI INT4 kernels on an Arm server. First, you'll prepare + a Python environment and download Meta Llama 3.1 from Hugging Face. You'll quantize the model + to four bits and run CPU inference. Then, you'll start the Torchchat backend and Streamlit + frontend, test a prompt in the browser, and capture basic inference performance + measurements. + faqs: + - question: What Arm server do I need before starting? + answer: >- + Use an Arm server with Ubuntu 24.04 LTS, at least 16 cores, 64 GB of memory, and 50 GB + of storage. You can use the tested AWS Graviton4 `r8g.4xlarge` setup as reference. + - question: Which model do I download? + answer: >- + Download Meta Llama 3.1 from its Meta repository on Hugging Face. + - question: Which Python environment do I activate for the frontend? + answer: >- + Run `source torch_env/bin/activate` before you install the frontend dependencies. + - question: How do I resolve the httpx proxies error? + answer: >- + Install `httpx==0.27.2`, then restart the + frontend. + - question: How do I check that the chatbot works end to end? + answer: >- + Start the Torchchat backend and Streamlit frontend. Open the web interface, enter a + prompt, and check that you receive a model response. +# END generated_summary_faq author: - Nikhil Gupta - Pareena Verma - Nobel Chowdary Mandepudi -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/qdrant-on-axion/_index.md b/content/learning-paths/servers-and-cloud-computing/qdrant-on-axion/_index.md index 990b66796c..7abcb1f6d2 100644 --- a/content/learning-paths/servers-and-cloud-computing/qdrant-on-axion/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/qdrant-on-axion/_index.md @@ -7,11 +7,11 @@ minutes_to_complete: 30 who_is_this_for: This is an introductory topic for developers, data engineers, and platform engineers who want to build semantic search systems and chatbot retrieval pipelines on Arm64-based Google Cloud C4A Axion processors using the Qdrant vector database. learning_objectives: - - Deploy and run the Qdrant vector database on Google Cloud C4A Axion processors - - Generate vector embeddings using transformer models - - Store and index embeddings efficiently using Qdrant - - Perform semantic similarity search using vector queries - - Build a simple chatbot retrieval system powered by vector search + - Deploy and run the Qdrant vector database on Google Cloud C4A Axion processors. + - Generate vector embeddings using transformer models. + - Store and index embeddings efficiently using Qdrant. + - Perform semantic similarity search using vector queries. + - Build a simple chatbot retrieval system powered by vector search. prerequisites: - A [Google Cloud Platform (GCP)](https://cloud.google.com/free) account with billing enabled @@ -19,9 +19,50 @@ prerequisites: - Basic understanding of machine learning embeddings - Familiarity with Linux command-line operations +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-19T15:59:16Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: 439ba306b67ab6a2e1f442ab548e8d6eb330b90f52434fa2a8ee6143a1bb944b + summary_generated_at: '2026-11-19T15:59:16Z' + summary_source_hash: 439ba306b67ab6a2e1f442ab548e8d6eb330b90f52434fa2a8ee6143a1bb944b + faq_generated_at: '2026-11-19T15:59:16Z' + faq_source_hash: 439ba306b67ab6a2e1f442ab548e8d6eb330b90f52434fa2a8ee6143a1bb944b + summary: >- + You'll deploy Qdrant on a Google Axion C4A VM and use vector embeddings for semantic search. + You'll provision a SUSE Linux arm64 instance, prepare Qdrant, and generate embeddings from + sample text with Sentence Transformers. After storing the vectors in a Qdrant collection, + you'll run similarity queries and connect retrieval to a chatbot. You can then test whether + responses use relevant stored content. + faqs: + - question: What do I need before provisioning the virtual machine? + answer: >- + You need a Google Cloud account with billing enabled. + - question: Which C4A machine type should I choose? + answer: >- + Select `c4a-standard-4` in the Google Cloud console. + - question: Which operating system image should I use? + answer: >- + Choose a SUSE Linux Enterprise Server arm64 image for the C4A VM. + - question: What should I see after indexing embeddings? + answer: >- + You should have a Qdrant collection containing vectors generated from the sample text. + You can then query that collection for similar content. + - question: How do I check whether semantic search is working? + answer: >- + Run a similarity query and inspect the ranked matches. If the matches seem unrelated, check + that you inserted the embeddings. Ensure that you used the same Sentence Transformers model for + indexing and querying. +# END generated_summary_faq + author: Pareena Verma -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/quantlib/_index.md b/content/learning-paths/servers-and-cloud-computing/quantlib/_index.md index 42775ecb1f..42e9e41252 100644 --- a/content/learning-paths/servers-and-cloud-computing/quantlib/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/quantlib/_index.md @@ -8,19 +8,64 @@ minutes_to_complete: 60 who_is_this_for: This is an advanced topic for developers who want to build and benchmark QuantLib on Arm-based cloud instances. learning_objectives: - - Understand why QuantLib is a useful benchmark for Arm-based cloud systems - - Create and connect to an Arm64 Azure Cobalt virtual machine running Ubuntu - - Build QuantLib from source with benchmark support enabled - - Run QuantLib benchmark workloads with different sizes and thread counts - - Record and compare benchmark results in a repeatable way + - Identify why QuantLib is a useful benchmark for Arm-based cloud systems. + - Create and connect to an Arm64 Azure Cobalt virtual machine running Ubuntu. + - Build QuantLib from source with benchmark support enabled. + - Run QuantLib benchmark workloads with different sizes and thread counts. + - Record and compare benchmark results in a repeatable way. prerequisites: - An Azure account with permission to create virtual machines - Basic familiarity with the Linux command line and SSH - Basic experience building C++ software from source + +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-19T15:59:43Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: 7a0e1bc938569aaa47aa021d5993f8f40503ed629fbe97eee8d99cec5d2ed3d8 + summary_generated_at: '2026-11-19T15:59:43Z' + summary_source_hash: 7a0e1bc938569aaa47aa021d5993f8f40503ed629fbe97eee8d99cec5d2ed3d8 + faq_generated_at: '2026-11-19T15:59:43Z' + faq_source_hash: 7a0e1bc938569aaa47aa021d5993f8f40503ed629fbe97eee8d99cec5d2ed3d8 + summary: >- + You'll build and benchmark QuantLib on an Azure Cobalt-based Arm virtual machine. You'll provision an Ubuntu + virtual machine and build QuantLib from source with benchmark support and CPU-specific compiler flags. Then, you'll + run the benchmark executable. After a baseline run, you'll keep the workload size fixed and + change the number of worker processes. You'll then compare reported throughput and runtime + across runs to study scaling. + faqs: + - question: What Azure virtual machine configuration should I use? + answer: >- + Choose an Arm64 VM in a region that offers Azure Cobalt, such as West US 2. Use the `Standard_D4ps_v5` machine type and + Ubuntu Server 22.04 LTS. + - question: Where do I run the QuantLib benchmark? + answer: >- + Change to `~/QuantLib-$QL_VER/test-suite` and run `./quantlib-benchmark` after the + build. + - question: How do I vary workload size or worker count? + answer: >- + Use `--size` for the workload size and `--nProc` for the number of worker processes. + Keep `--size` fixed when you compare worker counts. + - question: How do I check that benchmark support was built? + answer: >- + Use the source `--enable-benchmark` configure option and `CFLAGS` and `CXXFLAGS` + settings. You'll then find a runnable `quantlib-benchmark` executable in the test + suite. + - question: What should I record from each benchmark run? + answer: >- + Record your `--size` and `--nProc` values alongside reported throughput in tasks per + second and runtime. You can compare your runs with the example results. +# END generated_summary_faq + author: Chris Moroney -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/_index.md b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/_index.md index 1c4b46b4ea..bed320d510 100644 --- a/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/rabbitmq-gcp/_index.md @@ -1,27 +1,66 @@ --- -title: Deploy RabbitMQ on Arm64 Cloud Platforms (Azure and GCP) +title: Deploy RabbitMQ on Arm64 on Microsoft Azure and Google Cloud minutes_to_complete: 30 who_is_this_for: This is an introductory topic for software engineers and platform engineers migrating messaging and event-driven workloads from x86_64 to Arm-based servers, specifically on Microsoft Azure Cobalt 100 Arm processors and Google Cloud C4A virtual machines powered by Axion processors. learning_objectives: - - Provision Arm-based Linux virtual machines on Google Cloud (C4A with Axion processors) and Microsoft Azure (Cobalt 100) - - Provision an Arm-based SUSE SLES virtual machine on Google Cloud (C4A with Axion processors) - - Install and configure RabbitMQ on Arm64 Linux (SUSE SLES on GCP and Ubuntu Pro 24.04 on Azure) - - Build and configure required Erlang versions for RabbitMQ on Arm64 - - Validate RabbitMQ deployments using baseline messaging and connectivity tests - - Implement practical RabbitMQ use cases such as event-driven processing and notification pipelines on Arm-based infrastructure + - Provision Arm-based Linux virtual machines (VMs) on Google Cloud and Microsoft Azure. + - Provision an Arm-based SUSE SLES VM on Google Cloud. + - Install and configure RabbitMQ on SUSE SLES on Google Cloud and Ubuntu Pro 24.04 on Azure. + - Build and configure required Erlang versions for RabbitMQ on Arm64. + - Validate RabbitMQ deployments using baseline messaging and connectivity tests. + - Implement practical RabbitMQ use cases such as event-driven processing and notification pipelines. prerequisites: - - A [Microsoft Azure](https://azure.microsoft.com/) account with access to Cobalt 100-based instances (Dpsv6). + - A [Microsoft Azure](https://azure.microsoft.com/) account with access to Cobalt 100-based instances (Dpsv6) - A [Google Cloud Platform (GCP)](https://cloud.google.com/free) account with billing enabled - - Basic understanding of message queues and messaging concepts (publishers, consumers) + - Basic understanding of message queues and messaging concepts such as publishers and consumers - Familiarity with Linux command-line operations +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-19T16:00:22Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: 952b6e5049d77bc49e9d51ffd3726f0a651623812d458923807ab59885e779af + summary_generated_at: '2026-11-19T16:00:22Z' + summary_source_hash: 952b6e5049d77bc49e9d51ffd3726f0a651623812d458923807ab59885e779af + faq_generated_at: '2026-11-19T16:00:22Z' + faq_source_hash: 952b6e5049d77bc49e9d51ffd3726f0a651623812d458923807ab59885e779af + summary: >- + You'll deploy and verify RabbitMQ on Arm-based Azure and Google Cloud VMs. First, you'll install + Erlang and RabbitMQ on an Azure Cobalt VM, enable the management plugin, and check the + service and versions. You'll then provision a Google Axion C4A VM, install RabbitMQ, and + configure a VPC firewall rule for management access. Finally, you'll check broker + connectivity and the management interface. + faqs: + - question: Which Azure virtual machine size should I use? + answer: >- + Select a Dpsv6 series VM backed by Azure Cobalt 100. + - question: Which image should I use for the Azure virtual machine? + answer: >- + Use Ubuntu Pro 24.04 for Arm64. + - question: How do I verify RabbitMQ on the Azure VM? + answer: >- + Run `sudo systemctl status rabbitmq` and check for `active (running)`. + - question: How do I check the Erlang version on Azure? + answer: >- + Run `erl -eval` and check that the output reports Erlang/OTP 26. + - question: How do I fix not being able to open the management interface on the Google Cloud VM? + answer: >- + Check that your VPC firewall rule allows inbound TCP port `15672` and that its target + tag is applied to the VM. You can compare the rule with the `allow-tcp-15672` example. +# END generated_summary_faq + author: Pareena Verma -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/rag/_index.md b/content/learning-paths/servers-and-cloud-computing/rag/_index.md index bc4ecb7405..b689ce0e58 100644 --- a/content/learning-paths/servers-and-cloud-computing/rag/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/rag/_index.md @@ -13,15 +13,57 @@ learning_objectives: - Monitor and analyze inference performance metrics. prerequisites: - - A Google Cloud Axion (or other Arm) compute instance with at least 16 cores, 8GB of RAM, and 32GB disk space. - - Basic understanding of Python and ML concepts. - - Familiarity with REST APIs and web services. - - Basic knowledge of vector databases. - - Understanding of LLM fundamentals. + - A Google Cloud Axion (or other Arm) compute instance with at least 16 cores, 8GB of RAM, and 32GB disk space + - Basic understanding of Python and ML concepts + - Familiarity with REST APIs and web services + - Basic knowledge of vector databases + - Understanding of LLM fundamentals + +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-19T16:01:02Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: 1f6f741dee3f86b86de1acaf18a51e807b000f19d8da40b0a4dfdb6d356e4d54 + summary_generated_at: '2026-11-19T16:01:02Z' + summary_source_hash: 1f6f741dee3f86b86de1acaf18a51e807b000f19d8da40b0a4dfdb6d356e4d54 + faq_generated_at: '2026-11-19T16:01:02Z' + faq_source_hash: 1f6f741dee3f86b86de1acaf18a51e807b000f19d8da40b0a4dfdb6d356e4d54 + summary: >- + You'll build a retrieval augmented chatbot with KleidiAI on an Arm-based Google Axion server. + You'll prepare a llama-cpp-python backend with FAISS retrieval and expose its API through + Flask. Then, you'll start a Streamlit frontend, upload PDF files, and ask questions that use + retrieved context. Finally, you'll open the app in a browser and verify that the backend and + frontend communicate. + faqs: + - question: How do I check whether backend.py is running? + answer: >- + Start `backend.py` and check that Flask listens on port `5000` without errors. You can + then use the frontend to test a response. + - question: What should I check when Streamlit loads but chat requests fail? + answer: >- + Check that the backend is running and that the `API_URL` in `frontend.py` points to its + address and port. Restart Streamlit after changing the URL. + - question: How do I open the app from outside the virtual machine? + answer: >- + Open `http://[your instance ip]:8501` in your browser. If you can't connect, allow inbound TCP port `8501` from your IP address. + - question: Where do I upload content for retrieval? + answer: >- + Upload PDF files through the Streamlit interface. You can then ask questions about the + content indexed in FAISS. + - question: Do I run the backend and frontend in separate terminals? + answer: >- + Yes. Activate the virtual environment and run the Flask backend in one terminal. Open + another terminal, activate the environment, and start the Streamlit frontend. +# END generated_summary_faq author: Nobel Chowdary Mandepudi -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/ran/_index.md b/content/learning-paths/servers-and-cloud-computing/ran/_index.md index b67014d269..e7f001915d 100644 --- a/content/learning-paths/servers-and-cloud-computing/ran/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/ran/_index.md @@ -1,5 +1,5 @@ --- -title: Get started with the Arm 5G RAN Acceleration Library (ArmRAL) +title: Build and run the Arm 5G RAN Acceleration Library minutes_to_complete: 15 @@ -7,16 +7,56 @@ who_is_this_for: This is an introductory topic for software developers new to th Arm RAN Acceleration Library (ArmRAL). learning_objectives: -- Build and install the Arm RAN Acceleration Library -- Test the capabilities of your platform +- Build and install the Arm RAN Acceleration Library. +- Test the capabilities of your platform. prerequisites: -- An Arm computer running Linux. Cloud instances can be used, refer to the list of - [Arm cloud service providers](/learning-paths/servers-and-cloud-computing/csp/). +- An Arm computer running Linux, or a [cloud instance](/learning-paths/servers-and-cloud-computing/csp/) + +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-19T16:01:59Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: 3496670e85ea5fd32e280256d6bb5b45a5fd873dba57aacb053ae69d293afd2f + summary_generated_at: '2026-11-19T16:01:59Z' + summary_source_hash: 3496670e85ea5fd32e280256d6bb5b45a5fd873dba57aacb053ae69d293afd2f + faq_generated_at: '2026-11-19T16:01:59Z' + faq_source_hash: 3496670e85ea5fd32e280256d6bb5b45a5fd873dba57aacb053ae69d293afd2f + summary: >- + You'll build and test the Arm RAN Acceleration Library on an Arm-based Linux system. First, you'll + prepare the development environment, obtain the source, and compile the library with GCC. + You'll then run `make check` to exercise its test suite and inspect the results. Finally, you'll end with a working ArmRAL build to explore telecommunications functions that are used in radio access + networks. + faqs: + - question: Which compiler and build command do I use? + answer: >- + Use GCC on an Arm-based Linux system to build the source. You can + then run `make check` in the build directory. + - question: Can I use an Arm cloud virtual machine instead of local hardware? + answer: >- + Yes, you can follow the build on an Arm-based cloud virtual machine running Linux. + - question: How do I verify the ArmRAL build? + answer: >- + Run `make check` after building. You should see the test suite complete without + failures. + - question: How do I choose the ArmRAL build target for my CPU? + answer: >- + Run `cat /proc/cpuinfo` and check the flags for `asimd`, `sve`, or `sve2`. + Set `ARMRAL_ARCH` to `NEON`, `SVE`, or `SVE2` to match a feature that your CPU supports. + - question: What should I do if the check fails? + answer: >- + Review the failing test in the `make check` output. Check that you built with the + required compiler and dependencies on your Arm Linux system. +# END generated_summary_faq author: Ronan Synnott -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/ray-on-axion/_index.md b/content/learning-paths/servers-and-cloud-computing/ray-on-axion/_index.md index e5c8c9a278..069adacddc 100644 --- a/content/learning-paths/servers-and-cloud-computing/ray-on-axion/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/ray-on-axion/_index.md @@ -1,24 +1,65 @@ --- -title: Scale AI workloads with Ray on Google Cloud C4A Axion VM -description: Deploy and run distributed AI workloads using Ray on Google Cloud Axion C4A Arm-based VMs, covering parallel tasks, hyperparameter tuning, and model serving with Ray Core, Train, Tune, and Serve. +title: Scale AI workloads with Ray on an Arm-based Google Cloud C4A VM +description: Deploy and run distributed AI workloads using Ray on Google Cloud C4A Arm-based VMs powered by Axion, covering parallel tasks, hyperparameter tuning, and model serving with Ray Core, Train, Tune, and Serve. minutes_to_complete: 30 -who_is_this_for: This is an introductory topic for DevOps engineers, ML engineers, and software developers who want to deploy and run distributed workloads using Ray on SUSE Linux Enterprise Server (SLES) Arm64, execute parallel tasks, perform hyperparameter tuning, and serve models at scale. +who_is_this_for: This is an introductory topic for DevOps engineers, ML engineers, and software developers who want to deploy and run distributed workloads using Ray on SUSE Linux Enterprise Server (SLES) Arm64, run parallel tasks, perform hyperparameter tuning, and serve models at scale. learning_objectives: - - Install and configure Ray on Google Cloud C4A Axion processors for Arm64 - - Run distributed tasks and parallel workloads using Ray Core - - Perform distributed training and hyperparameter tuning using Ray Train and Ray Tune - - Deploy scalable APIs using Ray Serve and validate end-to-end execution + - Install and configure Ray on Google Cloud C4A Axion processors for Arm64. + - Run distributed tasks and parallel workloads using Ray Core. + - Perform distributed training and hyperparameter tuning using Ray Train and Ray Tune. + - Deploy scalable APIs using Ray Serve and validate end-to-end execution. prerequisites: - A [Google Cloud Platform (GCP)](https://cloud.google.com/free) account with billing enabled - Basic familiarity with Python and distributed systems concepts +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-19T16:02:33Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: c4924540b24617061378fbf4f2037973c30cd2b5a3dec1de80119721fa618d6a + summary_generated_at: '2026-11-19T16:02:33Z' + summary_source_hash: c4924540b24617061378fbf4f2037973c30cd2b5a3dec1de80119721fa618d6a + faq_generated_at: '2026-11-19T16:02:33Z' + faq_source_hash: c4924540b24617061378fbf4f2037973c30cd2b5a3dec1de80119721fa618d6a + summary: >- + You'll run Ray on a single Google Cloud C4A VM with SUSE Linux. You'll provision a + `c4a-standard-4` instance and configure firewall access for the Ray Dashboard and Ray Serve. + After installing Ray, you'll initialize the runtime and run `ray_test.py` to verify parallel + tasks. You'll then explore distributed training and hyperparameter tuning, using task output + and the Ray Dashboard to inspect execution. + faqs: + - question: Which Google Cloud machine type should I select? + answer: >- + Choose `c4a-standard-4`, which provides four vCPUs and 16 GB of memory. + - question: How do I verify that Ray runs on the virtual machine? + answer: >- + Run `ray_test.py`. You should see `Results:` followed by squared values from 0 through + 81. + - question: Which ports do I need for Ray Dashboard and Ray Serve? + answer: >- + Allow TCP port `8265` for the Dashboard and TCP port `8000` for Serve. Check that the + firewall rule applies to your VM. Use its external IP to connect. + - question: Do I need a multi-node cluster? + answer: >- + No. You can complete these steps on one C4A VM with a single-node Ray runtime. + - question: What should I check if I can't connect to the Ray cluster? + answer: >- + Check whether you started the Ray head node with `ray start --head`, then run `ray + status` to inspect the cluster before retrying your script. +# END generated_summary_faq + author: Pareena Verma -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/redis-cobalt/_index.md b/content/learning-paths/servers-and-cloud-computing/redis-cobalt/_index.md index beadbe4f4b..acc16f0c71 100644 --- a/content/learning-paths/servers-and-cloud-computing/redis-cobalt/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/redis-cobalt/_index.md @@ -7,20 +7,63 @@ minutes_to_complete: 30 who_is_this_for: This is an introductory topic for developers, DevOps engineers, and platform engineers who want to build real-time messaging systems and event-driven applications using Redis on Arm-based cloud environments. learning_objectives: - - Install and configure Redis on Azure Cobalt 100 Arm64 virtual machines - - Implement real-time messaging using Redis Pub/Sub - - Build event-driven pipelines using Redis Streams and consumer groups - - Benchmark Redis performance and validate throughput and latency on Arm + - Install and configure Redis on Arm64 virtual machines powered by Azure Cobalt 100. + - Implement real-time messaging using Redis Pub/Sub. + - Build event-driven pipelines using Redis Streams and consumer groups. + - Benchmark Redis performance and validate throughput and latency on Arm. prerequisites: - - A [Microsoft Azure account](https://azure.microsoft.com/) with access to Cobalt 100 based instances (Dpsv6) + - A [Microsoft Azure account](https://azure.microsoft.com/) with access to Cobalt 100-based instances (Dpsv6) - Basic knowledge of Linux command-line operations - Familiarity with SSH and remote server access - Basic understanding of databases, caching, and messaging systems +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-19T16:03:25Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: 06b2317b6273703a23729a1c59e8c11450d494f7634699020778ff53a573edad + summary_generated_at: '2026-11-19T16:03:25Z' + summary_source_hash: 06b2317b6273703a23729a1c59e8c11450d494f7634699020778ff53a573edad + faq_generated_at: '2026-11-19T16:03:25Z' + faq_source_hash: 06b2317b6273703a23729a1c59e8c11450d494f7634699020778ff53a573edad + summary: >- + You'll deploy Redis on an Azure Cobalt VM and use it for messaging and event processing. First, you'll + provision a Dpsv6 instance, install Redis, and check server connectivity. You'll then publish + and subscribe to messages, create Streams and consumer groups, and acknowledge processed + events. Finally, you'll use Python workload scripts and `redis-benchmark` to measure + throughput and latency on the Arm-based VM. + faqs: + - question: How do I verify that the Redis server started? + answer: >- + Run `src/redis-cli` after starting Redis, then enter `PING` at the CLI prompt. You + should receive `PONG` before testing messaging. + - question: Do I need multiple terminals for Pub/Sub and Streams? + answer: >- + Yes. Keep the Redis server running in one terminal and use other terminals for the + publisher and consumers. + - question: What should I see when Pub/Sub works? + answer: >- + Subscribe to a channel, then publish a message from another terminal. You should see + that message arrive in the subscriber terminal. + - question: When should I use Pub/Sub or Streams? + answer: >- + Use Pub/Sub for immediate message delivery to active subscribers. Use Streams and + consumer groups when you need to distribute and acknowledge queued work. + - question: How do I run a Redis benchmark? + answer: >- + Run `src/redis-benchmark -q -n 100000 -c 50` from the Redis source directory. You can + review the reported request rates for each operation. +# END generated_summary_faq + author: Pareena Verma -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/redis-data-searching/_index.md b/content/learning-paths/servers-and-cloud-computing/redis-data-searching/_index.md index 0fde9d5d33..79280f34ab 100644 --- a/content/learning-paths/servers-and-cloud-computing/redis-data-searching/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/redis-data-searching/_index.md @@ -3,21 +3,61 @@ title: Deploy Redis for data searching on Google Cloud C4A minutes_to_complete: 30 -who_is_this_for: This is an introductory topic for developers deploying and optimizing Redis-based data searching workloads on Linux/Arm64 environments, specifically using Google Cloud C4A virtual machines powered by Axion processors. +who_is_this_for: This is an introductory topic for developers deploying and optimizing Redis-based data searching workloads on Linux/Arm64 environments, specifically using Google Cloud C4A virtual machines (VMs) powered by Axion processors. learning_objectives: - - Provision an Arm-based SUSE SLES virtual machine on Google Cloud (C4A with Axion processors) - - Install Redis on a SUSE Arm64 (C4A) instance - - Verify Redis functionality by running the server and performing baseline data insertion and retrieval tests on the Arm64 VM - - Measure Redis SET (write) and GET (read) performance using the official redis-benchmark tool to evaluate throughput and latency on Arm64 (AArch64) + - Provision an Arm-based SUSE SLES C4A virtual machine on Google Cloud. + - Install Redis on a SUSE Arm64 instance. + - Verify Redis functionality by running the server and performing baseline data insertion and retrieval tests on the Arm64 VM. + - Measure Redis SET (write) and GET (read) performance using the official redis-benchmark tool to evaluate throughput and latency on Arm64 (AArch64). prerequisites: - A [Google Cloud Platform (GCP)](https://cloud.google.com/free) account with billing enabled - - Basic familiarity with [Redis](https://redis.io/) + - Basic familiarity with [Redis](https://redis.io/) + +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-19T16:03:54Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: 3932c64a3ffa2252da47514025674e19c9f77e6543acb992654d62828e7fe8fd + summary_generated_at: '2026-11-19T16:03:54Z' + summary_source_hash: 3932c64a3ffa2252da47514025674e19c9f77e6543acb992654d62828e7fe8fd + faq_generated_at: '2026-11-19T16:03:54Z' + faq_source_hash: 3932c64a3ffa2252da47514025674e19c9f77e6543acb992654d62828e7fe8fd + summary: >- + You'll install Redis on a Google Axion C4A VM and test data search on SUSE Linux. First, you'll + provision a `c4a-standard-4` instance, build Redis from source, and verify the server with + `redis-cli ping`. You'll then insert sample data, retrieve keys, and compare pattern searches + with `SCAN`. Finally, you'll run SET and GET benchmarks to inspect request rates and latency + on Arm. + faqs: + - question: What virtual machine type and image should I use? + answer: >- + Select `c4a-standard-4` and a SUSE arm64 image. + - question: What do I install before building Redis? + answer: >- + Use `zypper` to install `gcc`, `gcc-c++`, and `make`, as well as `tcl`, `openssl-devel`, and `wget` + after refreshing repositories. + - question: Which Redis version do I build? + answer: >- + Download and build Redis `8.2.2` from its official GitHub source archive. + - question: How do I check that Redis is running? + answer: >- + Start Redis with `redis-server &`, then run `redis-cli ping`. You should receive `PONG`. + - question: How do I compare write and read performance? + answer: >- + Run `redis-benchmark -t set -n 100000 -c 50` for SET and `redis-benchmark -t get -n + 100000 -c 50` for GET. You can compare their throughput and latency output. +# END generated_summary_faq author: Pareena Verma -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/redis/_index.md b/content/learning-paths/servers-and-cloud-computing/redis/_index.md index 6d59d83f0c..a6d3e71c77 100644 --- a/content/learning-paths/servers-and-cloud-computing/redis/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/redis/_index.md @@ -6,17 +6,54 @@ minutes_to_complete: 30 who_is_this_for: This is an introductory topic for developers who want to deploy Redis on Arm based virtual machines. learning_objectives: - - Understand Redis deployment configurations - - Install and run Redis in a single-node Arm based instance + - Identify Redis deployment configurations. + - Install and run Redis in a single-node Arm based instance. prerequisites: - - An Arm based instance from a cloud service provider, or an on-premise Arm server. - - If you do not have an Arm node, the next section discusses some options. + - An Arm based instance from a cloud service provider, or an on-premise Arm server + +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-19T16:03:01Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: e8e8c501fb3a45836ddd838ba397139f4a050e39d750dda05e2baa9333c6a782 + summary_generated_at: '2026-11-19T16:03:01Z' + summary_source_hash: e8e8c501fb3a45836ddd838ba397139f4a050e39d750dda05e2baa9333c6a782 + faq_generated_at: '2026-11-19T16:03:01Z' + faq_source_hash: e8e8c501fb3a45836ddd838ba397139f4a050e39d750dda05e2baa9333c6a782 + summary: >- + You'll deploy a single-node Redis server on an Arm-based Linux instance. First, you'll install Redis, + start the service, and confirm a local connection. You'll then set the `bind` directive in `redis.conf`, and use + `redis-cli` to check connectivity from another machine. + faqs: + - question: What address does Redis listen on by default? + answer: >- + By default, Redis listens on `127.0.0.1:6379`. + - question: Why can't I connect from another machine? + answer: >- + Redis binds to `127.0.0.1` by default. Set the `bind` directive in `redis.conf` to + `0.0.0.0`, then restart Redis. + - question: How do I test a remote connection? + answer: >- + Run `redis-cli -h -p 6379` from your client, then send `PING`. You + should receive `PONG`. + - question: Which port does this deployment use? + answer: >- + Use the Redis default TCP port, `6379`, for local and remote connection checks. + - question: How do I check that Redis stores and retrieves data? + answer: >- + In `redis-cli`, run `SET name test`, then `GET name`. You should receive `"test"`. +# END generated_summary_faq author: Elham Harirpoush -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/redis/single-node_deployment.md b/content/learning-paths/servers-and-cloud-computing/redis/single-node_deployment.md index 2ddf11da19..62a021d6cc 100644 --- a/content/learning-paths/servers-and-cloud-computing/redis/single-node_deployment.md +++ b/content/learning-paths/servers-and-cloud-computing/redis/single-node_deployment.md @@ -30,7 +30,7 @@ To connect to the remote Redis server, you need to use Redis Client (`redis-cli` ### Connect to the Redis server from local machine -Execute the steps below to connect to the remote Redis server from your local machine. +Run the following steps to connect to the remote Redis server from your local machine. 1. Install redis-tools to interact with redis-server: ```console diff --git a/content/learning-paths/servers-and-cloud-computing/redis_cache/_index.md b/content/learning-paths/servers-and-cloud-computing/redis_cache/_index.md index 05fbf8d9b0..02cd4b72f2 100644 --- a/content/learning-paths/servers-and-cloud-computing/redis_cache/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/redis_cache/_index.md @@ -3,11 +3,11 @@ title: Deploy Redis as a cache for MySQL and PostgreSQL on Arm servers minutes_to_complete: 90 -who_is_this_for: This is an advanced topic for developers who want to deploy Redis as a cache on Arm based virtual machines. +who_is_this_for: This is an advanced topic for developers who want to deploy Redis as a cache on Arm-based virtual machines (VMs). learning_objectives: - - Deploy Redis as a cache for MySQL on AWS, Azure and GCP Arm based instance - - Deploy Redis as a cache for Postgres on AWS, Azure and GCP Arm based instance + - Deploy Redis as a cache for MySQL on AWS, Azure and GCP Arm based instance. + - Deploy Redis as a cache for Postgres on AWS, Azure and GCP Arm based instance. prerequisites: - An Amazon Web Services (AWS) [account](https://aws.amazon.com/) @@ -15,9 +15,52 @@ prerequisites: - A Google Cloud [account](https://console.cloud.google.com/) - A machine with [Terraform](/install-guides/terraform/), [AWS CLI](/install-guides/aws-cli), [Google Cloud CLI](/install-guides/gcloud), [Azure CLI](/install-guides/azure-cli), [AWS IAM authenticator](https://docs.aws.amazon.com/eks/latest/userguide/install-aws-iam-authenticator.html), and [Ansible](/install-guides/ansible/) installed +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-19T16:04:26Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: ea2a08e991d4de8363d55711b8f0984b977c395cee4840e31524cad2973e613f + summary_generated_at: '2026-11-19T16:04:26Z' + summary_source_hash: ea2a08e991d4de8363d55711b8f0984b977c395cee4840e31524cad2973e613f + faq_generated_at: '2026-11-19T16:04:26Z' + faq_source_hash: ea2a08e991d4de8363d55711b8f0984b977c395cee4840e31524cad2973e613f + summary: >- + You'll deploy Redis as a cache for MySQL or PostgreSQL on Arm-based AWS, Microsoft Azure, and Google Cloud VMs. You'll use + Terraform to provision infrastructure and Ansible to configure Redis with the selected + database. Finally, you'll run the example application for your provider and database pairing + to check cached data access. + faqs: + - question: How do I confirm that a query result came from Redis? + answer: >- + Run the example Python query twice with the same key. On the first run, you should see + a message that Redis was updated. On the second, look for `Loaded data from redis`. + - question: How do I check that the provisioned virtual machine uses Arm? + answer: >- + Check the instance type shown by the cloud provider after provisioning. You should see + the Arm-based family selected in the corresponding section. + - question: How do I configure the database after provisioning the virtual machines? + answer: >- + After using `terraform apply` to create the instances, run + `ansible-playbook playbook.yaml -i /tmp/inventory` to install and configure MySQL or + PostgreSQL. + - question: Can I cache PostgreSQL queries on Google Cloud? + answer: >- + Yes. Follow `redis_psql_gcp.md` to provision the Google Cloud environment and configure + Redis as a cache for PostgreSQL. + - question: How long do the examples keep a query result in Redis? + answer: >- + You get a cached result for up to 120 seconds. The example Python scripts set that + expiration when they store a database query result in Redis. +# END generated_summary_faq + author: Jason Andrews -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/redis_tune/_index.md b/content/learning-paths/servers-and-cloud-computing/redis_tune/_index.md index bca5a069f3..554b062712 100644 --- a/content/learning-paths/servers-and-cloud-computing/redis_tune/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/redis_tune/_index.md @@ -1,24 +1,67 @@ --- -title: Learn how to tune Redis +title: Tune Redis performance on Arm minutes_to_complete: 30 who_is_this_for: This is an advanced topic for software developers who want to tune Redis on Arm-based servers and evaluate performance-sensitive configuration settings. learning_objectives: - - Learn about kernel parameters that can impact Redis performance - - Learn about compiler and libraries that can impact Redis performance - - Tune Redis server configuration for improved performance + - Identify kernel parameters that can impact Redis performance. + - Identify compiler and libraries that can impact Redis performance. + - Tune Redis server configuration for improved performance. prerequisites: - - Cloud or bare-metal installation of a Redis server - - Review [Learn how to deploy Redis](/learning-paths/servers-and-cloud-computing/redis/) if you do not already have Redis setup + - Cloud or bare-metal installation of a Redis server on Arm + - Completion of [Learn how to deploy Redis](/learning-paths/servers-and-cloud-computing/redis/) if you don't already have Redis set up + +# START generated_summary_faq +generated_summary_faq: + template_version: summary-faq-v3 + generated_at: '2026-11-19T16:04:57Z' + generator: ai + ai_assisted: true + ai_review_required: true + model: gpt-5 + prompt_template: summary-faq-v3 + source_hash: d5d0565161d6897a2b00af3ba2261a9b9755468797df67deacd3efe5c0395460 + summary_generated_at: '2026-11-19T16:04:57Z' + summary_source_hash: d5d0565161d6897a2b00af3ba2261a9b9755468797df67deacd3efe5c0395460 + faq_generated_at: '2026-11-19T16:04:57Z' + faq_source_hash: d5d0565161d6897a2b00af3ba2261a9b9755468797df67deacd3efe5c0395460 + summary: >- + You'll tune Redis on Arm-based Linux by measuring the effect of each change. First, you'll + examine kernel settings, compiler options, and OpenSSL choices. You'll then start from a + minimal `redis.conf`, adjust one server setting at a time, and compare throughput, + latency, memory, and CPU use. Finally, you'll evaluate client-side pipelining against your + workload to see whether it improves performance. + faqs: + - question: How do I apply and persist kernel parameter changes? + answer: >- + Use `sysctl -w` to apply a setting immediately. Add it to a file under `/etc/sysctl.d/` + if you want it to persist after a reboot. + - question: How should I compare Redis configuration changes? + answer: >- + Start with the baseline `redis.conf`, change one setting, and measure throughput, + latency, memory use, and CPU use before changing another. + - question: Why isn't one configuration recommended for every workload? + answer: >- + Your request mix and deployment conditions affect the best settings. Measure each option + with your workload before keeping a configuration. + - question: Should I also test compiler and OpenSSL choices? + answer: >- + Yes. Evaluate the compiler and OpenSSL options described in the Learning Path + and compare their measured effect. + - question: How should I test client-side pipelining? + answer: >- + Start with pipeline depth `1`, then test `4`, `8`, `16`, and `32`. Compare throughput, + tail latency, and client-side memory use before choosing a depth for your workload. +# END generated_summary_faq author: - Elham Harirpoush - Kelsey Steele -generate_summary_faq: true +generate_summary_faq: false rerun_summary: false rerun_faqs: false diff --git a/content/learning-paths/servers-and-cloud-computing/sve2-match/_index.md b/content/learning-paths/servers-and-cloud-computing/sve2-match/_index.md index 5cade2f63e..ca86af6c4c 100644 --- a/content/learning-paths/servers-and-cloud-computing/sve2-match/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/sve2-match/_index.md @@ -8,12 +8,13 @@ who_is_this_for: This is an introductory topic for database developers, performa learning_objectives: - Understand the purpose and function of SVE2 MATCH instructions. - - Implement a search algorithm using both scalar and SVE2-based MATCH approaches. + - Implement a search algorithm using both scalar and Scalable Vector Extension 2 (SVE2)-based MATCH approaches. - Benchmark and compare performance between scalar and vectorized implementations. - Analyze speedups and efficiency gains on Arm Neoverse-based instances with SVE2. prerequisites: -- Access to an [AWS Graviton, Google Axion, or Azure Cobalt 100 virtual machine](/learning-paths/servers-and-cloud-computing/csp/) from a cloud service provider, or an Arm AGI CPU platform. +- An [Arm-based Ubuntu 24.04 virtual machine](/learning-paths/servers-and-cloud-computing/csp/) with SVE2 support, or an Arm AGI CPU platform running Ubuntu 24.04 +- A GCC compiler with SVE support # START generated_summary_faq generated_summary_faq: @@ -34,26 +35,26 @@ generated_summary_faq: arrays on an Arm server. First, you'll learn how MATCH compares vector elements with search keys. Then, you'll write scalar, vectorized, and unrolled search functions. Finally, you'll add a benchmark harness, compile the program, and compare latency, throughput, and speedups at different hit rates. -# faqs: -# - question: What should I check before building and running the code? -# answer: >- -# You need an Arm-based instance with SVE2 support or an Arm AGI CPU platform running Ubuntu -# 24.04. You also need a GCC compiler with SVE support. -# - question: Where do I add the scalar and SVE2 MATCH implementations? -# answer: >- -# Add the search functions to `sve2_match_demo.c`, then append the benchmark harness after -# those functions. -# - question: What does a successful search return? -# answer: >- -# A successful search returns `1` when any array element matches any key, and `0` otherwise. -# - question: How does hit rate affect the SVE2 MATCH comparison? -# answer: >- -# You'll see larger speedups at low hit rates in the sample results. As matches become more -# frequent, early termination narrows the difference between SVE2 MATCH and scalar search. -# - question: How do I change the benchmark’s hit rate? -# answer: >- -# Pass a hit probability as the third argument to `./sve2_match_demo`, after the array -# length and iteration count. + faqs: + - question: What should I check before building and running the code? + answer: >- + Check that you're using an Arm system with SVE2 support running Ubuntu 24.04, such as an Arm AGI CPU platform. Ensure that you're using a GCC compiler + with SVE support. + - question: Where do I add the scalar and SVE2 MATCH implementations? + answer: >- + Add the search functions to `sve2_match_demo.c`, then append the benchmark harness after + those functions. + - question: What does a successful search return? + answer: >- + A successful search returns `1` when any array element matches any key, and `0` otherwise. + - question: How does hit rate affect the SVE2 MATCH comparison? + answer: >- + You'll see larger speedups at low hit rates in the sample results. As matches become more + frequent, early termination narrows the difference between SVE2 MATCH and scalar search. + - question: How do I change the hit rate of the benchmark? + answer: >- + Pass a hit probability as the third argument to `./sve2_match_demo`, after the array + length and iteration count. # END generated_summary_faq author: Pareena Verma diff --git a/content/learning-paths/servers-and-cloud-computing/vllm-moe/_index.md b/content/learning-paths/servers-and-cloud-computing/vllm-moe/_index.md index ca5d6494fb..6a80c59d86 100644 --- a/content/learning-paths/servers-and-cloud-computing/vllm-moe/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/vllm-moe/_index.md @@ -38,37 +38,35 @@ generated_summary_faq: checkpoints, serve each model, and validate a chat response. Next, you'll prepare model-specific ShareGPT subsets and benchmark concurrent requests. Finally, you'll compare throughput and latency using matching workloads and concurrency values. -# faqs: -# - question: How do I know the vLLM server is ready to receive requests? -# answer: >- -# Wait for `Application startup complete` in the server terminal to confirm that the server -# is listening on port `8000`. Then send a test request with `curl` to -# `/v1/chat/completions`; a response with generated text confirms that inference works. -# - question: What should I check if the test request fails or I get a port error? -# answer: >- -# Check that only one vLLM server is using port `8000`. If another server is running, -# stop it with **Ctrl+C** and wait for it to exit. Start the desired model server, -# wait for it to become ready, and retry your request. -# - question: Which model IDs should I use for the BF16 and INT8/W8A8 runs? -# answer: >- -# For BF16, use `google/gemma-4-26B-A4B-it`, `unsloth/gpt-oss-20b-BF16`, or -# `Qwen/Qwen3-30B-A3B-Thinking-2507`. For INT8/W8A8, use -# `RedHatAI/Qwen3-30B-A3B-Thinking-2507-quantized.w8a8`. Set the same model ID in -# your serving and test-request terminals. -# - question: How do I run the benchmark against the active server? -# answer: >- -# Keep the model server running. In another terminal, activate `vllm_env_new` and set -# `MODEL` to the running model ID. Prepare the ShareGPT subset selected with that model's -# tokenizer, then run `vllm bench serve` against `/v1/chat/completions` with the matching -# subset file. -# - question: How should I interpret and compare the reported metrics? -# answer: >- -# Compare request and output-token throughput, time to first token (TTFT), and time per -# output token (TPOT) at matching concurrency values and workloads. Calculate throughput -# speedup as optimized throughput divided by baseline throughput: `3.25x` means a 225% -# increase. Calculate latency reduction as `(baseline - optimized) / baseline × 100%`. -# You can't recreate the historical pre-optimization baseline with this guide, and you -# don't evaluate model quality here. + faqs: + - question: How do I know that the vLLM server is ready to receive requests? + answer: >- + Wait for `Application startup complete` in the server terminal to confirm that the server + is listening on port `8000`. Then, send a test request with `curl` to + `/v1/chat/completions`. A response with generated text confirms that inference works. + - question: What should I check if the test request fails or I get a port error? + answer: >- + Check that only one vLLM server is using port `8000`. If another server is running, + stop it with **Ctrl+C** and wait for it to exit. Start the desired model server, + wait for it to become ready, and retry your request. + - question: Which model IDs should I use for the BF16 and INT8/W8A8 runs? + answer: >- + For BF16, use `google/gemma-4-26B-A4B-it`, `unsloth/gpt-oss-20b-BF16`, or + `Qwen/Qwen3-30B-A3B-Thinking-2507`. For INT8/W8A8, use + `RedHatAI/Qwen3-30B-A3B-Thinking-2507-quantized.w8a8`. Set the same model ID in + your serving and test-request terminals. + - question: How do I run the benchmark against the active server? + answer: >- + Keep the model server running. In another terminal, activate `vllm_env_new` and set + `MODEL` to the running model ID. Prepare the ShareGPT subset selected with the model + tokenizer, then run `vllm bench serve` against `/v1/chat/completions` with the matching + subset file. + - question: What metrics should I interpret and compare while benchmarking? + answer: >- + Compare request and output-token throughput, time to first token (TTFT), and time per + output token (TPOT) at matching concurrency values and workloads. Calculate throughput + speedup as optimized throughput divided by baseline throughput: `3.25x` means a 225% + increase. Calculate latency reduction as `(baseline - optimized) / baseline × 100%`. # END generated_summary_faq author: diff --git a/content/learning-paths/servers-and-cloud-computing/wasmcloud/_index.md b/content/learning-paths/servers-and-cloud-computing/wasmcloud/_index.md index efa2d0c6c3..6742277742 100644 --- a/content/learning-paths/servers-and-cloud-computing/wasmcloud/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/wasmcloud/_index.md @@ -37,30 +37,30 @@ generated_summary_faq: `wash dev` and verify its response. Then, you'll measure warm request time, latency, and throughput under one connection and concurrent load. Finally, you'll interpret the results and consider when wasmCloud instance pooling can help your application. - # faqs: - # - question: How do I know the wasmCloud development host started correctly? - # answer: >- - # Wait until `wash dev` prints `INFO listening for HTTP requests address=http://127.0.0.1:8000`. - # Keep that terminal running while you send requests from your second SSH terminal. - # - question: Which endpoint should I send HTTP requests to during testing? - # answer: >- - # Send requests to `http://127.0.0.1:8000/` from the second SSH terminal on the same server. - # The development host listens on the server's loopback interface. - # - question: Where do I modify the HTTP response, and how do I confirm the change? - # answer: >- - # Change the greeting in `src/lib.rs`, stop `wash dev` with **Ctrl+C**, and start `wash dev` - # again. After the listener message appears, send another request and check that the body - # says `hello from Graviton`. - # - question: What metrics should I record for each test? - # answer: >- - # For the five timed `curl` requests, record the HTTP status and total time. For the - # one-connection and 32-connection `wrk` tests, save latency, requests per second, and any - # errors or timeouts. - # - question: What should I check if my results vary between runs? - # answer: >- - # Keep `wash dev` running and stop other load tests or builds. Run the client on the same - # server, then repeat each test with the same duration, thread count, and connection count. - # Compare complete runs before drawing conclusions from small differences. + faqs: + - question: How do I know that the wasmCloud development host started correctly? + answer: >- + Wait until `wash dev` prints `INFO listening for HTTP requests address=http://127.0.0.1:8000`. + Keep that terminal running while you send requests from your second SSH terminal. + - question: Which endpoint should I send HTTP requests to during testing? + answer: >- + Send requests to `http://127.0.0.1:8000/` from the second SSH terminal on the same server. + The development host listens on the server loopback interface. + - question: Where do I modify the HTTP response, and how do I confirm the change? + answer: >- + Change the greeting in `src/lib.rs`, stop `wash dev` with **Ctrl+C**, and start `wash dev` + again. After the listener message appears, send another request and check that the body + says `hello from Graviton`. + - question: What metrics should I record for each test? + answer: >- + For the five timed `curl` requests, record the HTTP status and total time. For the + one-connection and 32-connection `wrk` tests, save latency, requests per second, and any + errors or timeouts. + - question: What should I check if my results vary between runs? + answer: >- + Keep `wash dev` running and stop other load tests or builds. Run the client on the same + server, then repeat each test with the same duration, thread count, and connection count. + Compare complete runs before drawing conclusions from small differences. # END generated_summary_faq author: diff --git a/content/migration/_index.md b/content/migration/_index.md index f4dbb20f01..469b131edf 100644 --- a/content/migration/_index.md +++ b/content/migration/_index.md @@ -1,7 +1,7 @@ --- title: "How can I migrate applications to Arm Neoverse?" layout: "migration" # Easier for dynamic content loading, keep the same -description: Software developers are embracing the Arm architecture for its superior price performance and energy efficiency across a wide range of applications, including containerized workloads, cloud managed services, and Linux applications. To achieve higher performance and lower cost, you can migrate your self-managed workloads to Arm virtual machines and make sure to select Arm for managed services. A three step migration process covers the most common scenarios, and provides links to additional resources. +description: Software developers are embracing the Arm architecture for its superior price-performance and energy efficiency across a wide range of applications, including containerized workloads, cloud managed services, and Linux applications. To achieve higher performance and lower cost, you can migrate your self-managed workloads to Arm virtual machines and make sure to select Arm for managed services. A 3-step migration process covers the most common scenarios, and provides links to additional resources. --- ## Learn and explore @@ -16,12 +16,12 @@ Below is a list of Neoverse CPUs, the architecture versions, and the key additio | CPU | Architecture version | Key additions | | ----------- | -------------------- | --------------------------------------------------------- | -| Neoverse-N1 | Armv8.2-A | LSE - Large System Extensions improves multi-threaded performance. | -| Neoverse-V1 | Armv8.4-A | SVE - Scalable Vector Extension adds high performance vector processing for HPC and AI workloads. | -| Neoverse-N2 | Armv9.0-A | SVE2 - Extends SVE for improved data parallelism and wider vectors. | -| Neoverse-V2 | Armv9.0-A | SVE2 - Targets high single threaded performance for HPC and AI workloads. | -| Neoverse-N3 | Armv9.2-A | Balanced performance and power with extended SVE2 and crypto performance. | -| Neoverse-V3 | Armv9.2-A | High performance, confidential compute, and extended SVE2 and crypto performance. | +| Neoverse N1 | Armv8.2-A | LSE - Large System Extensions improves multi-threaded performance. | +| Neoverse V1 | Armv8.4-A | SVE - Scalable Vector Extension adds high-performance vector processing for HPC and AI workloads. | +| Neoverse N2 | Armv9.0-A | SVE2 - Extends SVE for improved data parallelism and wider vectors. | +| Neoverse V2 | Armv9.0-A | SVE2 - Targets high single threaded performance for HPC and AI workloads. | +| Neoverse N3 | Armv9.2-A | Balanced performance and power with extended SVE2 and crypto performance. | +| Neoverse V3 | Armv9.2-A | High performance, confidential compute, and extended SVE2 and crypto performance. | ### What cloud hardware is available today? @@ -30,40 +30,52 @@ Review each cloud service provider below to learn about Arm-based servers. {{< tabpane-normal >}} {{< tab header="AWS">}} -AWS offers more than [150 instance types with Graviton processors](https://aws.amazon.com/ec2/graviton/). The largest instance has 192 vCPUs and 1.5 TB of memory. A wide variety of instance sizes are available, including bare-metal (look for '.metal'). To find instances with Graviton processors look for 'g' in the name (C7g, M7g, and R7g). +AWS offers more than [150 instance types with Graviton processors](https://aws.amazon.com/ec2/graviton/). The largest instance has 192 vCPUs and 1.5 TB of memory. A wide variety of instance sizes are available, including bare-metal (look for '.metal'). To find instances with Graviton processors, look for 'g' in the name (C7g, R8g, M9g). + +The table lists example instance families for each generation. Performance figures are AWS estimates and vary by workload. | Generation | Arm CPU | Instance types | Comments | |---------------|--------------|----------------|-----------------------------------------------------------------------------| -| Graviton | Cortex-A72 | A1 | First Arm-based instance. -| Graviton2 | Neoverse-N1 | C6g, M6g, R6g | 600% performance and efficiency increases. | -| Graviton3 | Neoverse-V1 | C7g, M7g, R7g | 25% performance increase, DDR5 memory added, 50% more memory bandwidth. | -| Graviton4 | Neoverse-V2 | R8g | 75% more memory bandwidth, up to 40% faster for databases and 30% faster for web applications. | -| Graviton5 | Neoverse-V3 | M9g | 25% higher performance and 5X larger L3 cache. | +| Graviton | Cortex-A72 | A1 | First Arm-based EC2 instance. | +| Graviton2 | Neoverse N1 | C6g, M6g, R6g | Up to 7 times the processor performance of the first Graviton generation. | +| Graviton3 | Neoverse V1 | C7g, M7g, R7g | Up to 25% better compute performance than Graviton2; DDR5 memory. | +| Graviton4 | Neoverse V2 | R8g | Up to 30% better compute performance than Graviton3. | +| Graviton5 | Neoverse V3 | C9g, C9gd, M9g, M9gd, R9g, R9gd | Up to 25% better compute performance than Graviton4. | {{< /tab >}} {{< tab header="Google GCP">}} -Google GCP offers a variety of [virtual machine instances with Arm processors](https://cloud.google.com/compute/docs/instances/arm-on-compute). The latest generation of Arm-based VMs are based on Google Axion processor. The largest instance has 72 vCPUs and 576 Gb of RAM. It does not offer bare-metal instances. It offers `highcpu` and `highmem` VM instances for compute and memory intensive workloads respectively. +Google Cloud offers a variety of [instances with Arm processors](https://cloud.google.com/compute/docs/instances/arm-on-compute), including bare-metal options. Its Arm-based instances use Google Axion, Ampere Altra, and NVIDIA processors. The `highcpu` and `highmem` machine types support compute-intensive and memory-intensive workloads, respectively. | Generation | Arm CPU | Instance types | Comments | | --------------|--------------|--------------------|-----------| -| T2A | Neoverse-N1 | t2a-standard | Optimized for general-purpose workloads - web servers, and microservices. | -| Axion C4A | Neoverse-V2 | c4a-standard, c4a-highmem, c4a-highcpu | General-purpose, AI/ML workloads and high performance computing. | -| Axion N4A | Neoverse-N3 | n4a-standard, n4a-highmem, n4a-highcpu | General-purpose, efficient for multi-threaded workloads. | -| A4X | Neoverse-V2 | a4x-highgpu-4g | 140 vCPUs and 884 GB of memory using NVIDIA GB200 Superchips, which have B200 GPUs that offer 186 GB memory per GPU. | -| A4X Max | Neoverse-V2 | a4x-maxgpu-4g-metal | 144 vCPUs and 960 GB of memory using NVIDIA GB300 Superchips, which have B300 GPUs that offer 279 GB memory per GPU. | +| T2A | Neoverse N1 | t2a-standard | Optimized for general-purpose workloads - web servers, and microservices. | +| Axion C4A | Neoverse V2 | c4a-standard, c4a-highmem, c4a-highcpu, c4a-standard-96-metal, c4a-highmem-96-metal | General-purpose, AI/ML workloads and high-performance computing. | +| Axion N4A | Neoverse N3 | n4a-standard, n4a-highmem, n4a-highcpu | General-purpose, efficient for multi-threaded workloads. | +| A4X | Neoverse V2 | a4x-highgpu-4g | 140 vCPUs and 884 GB of memory using NVIDIA GB200 Superchips, which have B200 GPUs that offer 186 GB memory per GPU. | +| A4X Max | Neoverse V2 | a4x-maxgpu-4g-metal | 144 vCPUs and 960 GB of memory using NVIDIA GB300 Superchips, which have B300 GPUs that offer 279 GB memory per GPU. | +| A5X | NVIDIA Vera | a5x-highgpu-4g-metal | Bare-metal instance with 176 vCPUs, 1,440 GB of memory, and four NVIDIA Rubin GPUs. | {{< /tab >}} {{< tab header="Microsoft Azure">}} -Microsoft Azure offers a variety of [virtual machine instances with Arm Neoverse processors](https://learn.microsoft.com/en-us/azure/virtual-machines/sizes/general-purpose/dpsv6-series). The current generation of Arm-based VMs are based on Cobalt 100 CPU. The largest instance has 96 vCPUs and 384 Gb of RAM in the 'D96ps_v6' format. It does not offer bare-metal instances. It offers compute for general-purpose workloads (Dps and Dpls) and memory-optimized workloads (Eps). The next generation VMs are based on [Azure Cobalt 200](https://techcommunity.microsoft.com/blog/azureinfrastructureblog/announcing-cobalt-200-azure’s-next-cloud-native-cpu/4469807). +Microsoft Azure offers a variety of [virtual machine instances with Arm Neoverse processors](https://learn.microsoft.com/en-us/azure/virtual-machines/sizes/cobalt-overview). The latest generation uses the Cobalt 200 processor and offers general-purpose, memory-optimized, and storage-optimized VMs, with up to 128 vCPUs. Availability varies by region. -| Generation | Arm CPU | Instance types | Comments | +| Generation | Arm CPU | Instance types | Comments | | --------------|--------------|--------------------|-----------| -| Dpsv5 | Neoverse-N1 | Dpsv5, Epsv5 | General purpose and memory optimized instances. | -| Dpsv6 | Neoverse-N2 | Dpsv6, Dpls6, Epsv6 | Cobalt 100 processor improves performance, Dpsv6 (general purpose 4:1 mem:cpu ratio), Dplsv6 (general purpose, 2:1 mem:cpu ratio), Epsv6 (memory-optimized, 8:1 mem:cpu ratio). | +| Ampere Altra | Neoverse N1 | Dplsv5, Dpldsv5 | General-purpose instances for workloads with lower memory needs. | +| Ampere Altra | Neoverse N1 | Dpsv5, Dpdsv5 | General-purpose instances. | +| Ampere Altra | Neoverse N1 | Epsv5, Epdsv5 | Memory-optimized instances. | +| Cobalt 100 | Neoverse N2 | Dplsv6, Dpldsv6 | General-purpose instances for workloads with lower memory needs. | +| Cobalt 100 | Neoverse N2 | Dpsv6, Dpdsv6 | General-purpose instances. | +| Cobalt 100 | Neoverse N2 | Epsv6, Epdsv6 | Memory-optimized instances. | +| Cobalt 200 | Neoverse V3 | Dplsv7, Dpldsv7 | General-purpose instances with 2 GiB of memory per vCPU. | +| Cobalt 200 | Neoverse V3 | Dpsv7, Dpdsv7 | General-purpose instances with 4 GiB of memory per vCPU. | +| Cobalt 200 | Neoverse V3 | Epsv7, Epdsv7 | Memory-optimized instances with 8 GiB of memory per vCPU. | +| Cobalt 200 | Neoverse V3 | Mpsv4, Mpdsv4 | High-memory instances with 16 GiB of memory per vCPU. | +| Cobalt 200 | Neoverse V3 | Lpsv5 | Storage-optimized instances with local NVMe storage. | {{< /tab >}} {{< tab header="Oracle OCI">}} -Oracle Cloud Infrastructure (OCI) Ampere [Arm-based compute](https://www.oracle.com/cloud/compute/arm/) provides market-leading price-performance for AI, containers, big data, web services, and related workloads. The largest intsance has 160 vCPUs and 1024 Gb of RAM in the 'BM.Standard.A1' format. It offers bare-metal instances (look for 'BM' as opposed to 'VM'). +Oracle Cloud Infrastructure (OCI) Ampere [Arm-based compute](https://www.oracle.com/cloud/compute/arm/) provides market-leading price-performance for AI, containers, big data, web services, and related workloads. The `BM.Standard.A1.160` bare-metal shape has 160 OCPUs and 1,024 GB of RAM. OCI offers bare-metal instances (look for 'BM' as opposed to 'VM'). | Generation | Arm CPU | Instance types | Comments | | --------------|--------------|--------------------|-----------| @@ -77,7 +89,7 @@ Alibaba Cloud offers [3 instance types](https://www.alibabacloud.com/help/en/ecs | Generation | Arm CPU | Instance types | Comments | | --------------|--------------|--------------------|-----------| -| Yitian710 | Neoverse-N2 | c8y, g8y, r8y | Arm based instance| +| Yitian710 | Neoverse N2 | c8y, g8y, r8y | Arm based instance| {{< /tab >}} {{< /tabpane-normal >}} @@ -85,39 +97,42 @@ Read [Get started with Servers and Cloud Computing](/learning-paths/servers-and- ## STEP 1: Plan your transition -Newer software is generally easier to migrate because Arm support continues to improve and performance optimizations are typically better in newer versions. Interpreted languages and Jit compilers, such as Python, Java, PHP, and Node.js are easiest to migrate. Compiled languages such as C/C++, Go, and Rust are slightly more difficult because they need to be recompiled. The most difficult situations involve a language, runtime, operating system, or something else which is not available on Arm or would be difficult to run on Arm. +Newer software is generally easier to migrate because Arm support continues to improve and performance optimizations are typically better in newer versions. Interpreted languages and JIT compilers, such as Python, Java, PHP, and Node.js are easiest to migrate. Compiled languages such as C/C++, Go, and Rust are slightly more difficult because they need to be recompiled. The most difficult situations involve a language, runtime, operating system, or something else which is not available on Arm or would be difficult to run on Arm. -### 1.1 Survey your software stack +### Survey your software stack Step one in a typical migration journey is understanding the software stack. Make notes about operating system versions, programming languages, development tools, container tools, performance analysis tools, and any other important scripts included in the project. You can reference **Migrating applications to Arm servers** below for tips on how to get started - setting up a development machine, common challenges, and tips to proceed at pace. [Migrating applications to Arm servers](/learning-paths/servers-and-cloud-computing/migration/) -### 1.2 Discover Arm compatibility +### Discover Arm compatibility Step two is to look through your scripts and build files and see if you spot architecture specific files. Software migration typically falls into 3 categories: 1. **Automatic:** The Linux package manager installs software from the main repositories without any changes, totally seamless. 2. **Small modifications:** Software installed using scripts or binary downloads requires minor changes to strings, such as changing “x86_64” and “amd64” to “arm64” or “aarch64”. -3. **Challenging:** A few software projects still don't support Arm Linux, some are well known projects like the Edge browser, and the others are smaller projects that haven't added Arm support, yet. Some could be blockers and others may be easy to compile yourself. +3. **Challenging:** A few software projects still don't support Arm Linux, some are well known projects like the Edge browser, and the others are smaller projects that haven't added Arm support yet. Some could be blockers and others may be easy to compile yourself. You can quickly find out if software dependencies are available for Arm using the **Software Ecosystem Dashboard for Arm** link below - search for your package and find out which versions work on Arm and review the getting started tips. The dashboard is actively growing, and is a good place to understand if your software stack will run on Arm servers. [Software Ecosystem Dashboard for Arm.](https://www.arm.com/developer-hub/ecosystem-dashboard/) -### 1.3 Find resources to help +### Find resources to help The below resources are curated to address migration challenges on specific cloud providers. Look through them for additional context. - [Porting architecture specific intrinsics](/learning-paths/cross-platform/intrinsics/) - perfect for porting intrinsics from another architecture. - [Arm software install guides](/install-guides/) - good for quickly installing common tools and software. - [simd.info](https://simd.info/) - a searchable reference tool for C intrinsics for SIMD engines. - [migrate-ease](https://github.com/migrate-ease/migrate-ease) - scan your source code for suggestions to migrate to Arm Neoverse, get started with [Migrate applications to Arm servers using migrate-ease](/learning-paths/servers-and-cloud-computing/migrate-ease/). +- [Automate x86-to-Arm application migration using Arm MCP Server](/learning-paths/servers-and-cloud-computing/arm-mcp-server/) - use an AI coding assistant to check compatibility and help migrate code and containers. The Learning Path includes [setup guidance for supported assistants](/learning-paths/servers-and-cloud-computing/arm-mcp-server/1-overview/#setting-up-the-arm-mcp-server). - [Arm Infrastructure Solutions blog](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/) - an Arm-specific technical blog. - [Arm Learning Paths for Servers and Cloud](/learning-paths/servers-and-cloud-computing/) - general tutorials for Arm servers. You can search for specific platforms, including [Arm AGI](/learning-paths/servers-and-cloud-computing/?platforms-filter=arm-agi/#), [AWS](/learning-paths/servers-and-cloud-computing/?platforms-filter=aws/#), [Google Cloud](/learning-paths/servers-and-cloud-computing/?platforms-filter=google-cloud/#), [Microsoft Azure](/learning-paths/servers-and-cloud-computing/?platforms-filter=microsoft-azure/#), and [Oracle](/learning-paths/servers-and-cloud-computing/?platforms-filter=oracle/#). - AWS has additional resources such as the [Porting Advisor for Graviton](/install-guides/porting-advisor/) and [AWS Graviton Technical Guide](https://github.com/aws/aws-graviton-getting-started). +To find Learning Paths on other topics, use [Arm Learning Paths search](/search/). + Lastly, below are some specific migration helpers for various types of software: {{< tabpane-normal >}} @@ -134,6 +149,7 @@ Which tools are available for building and running containers on Arm servers? | GitHub Actions (GitHub runners) | [Build multi-architecture container images with GitHub Arm-hosted runners](/learning-paths/cross-platform/github-arm-runners/) | [Arm64 on GitHub Actions: Powering faster, more efficient build systems](https://github.blog/news-insights/product-news/arm64-on-github-actions-powering-faster-more-efficient-build-systems/) | | GitHub Actions (AWS Graviton runners) | [Managed, self-hosted Arm runners for GitHub Actions](/learning-paths/servers-and-cloud-computing/github-actions-runner/) | | GitLab (GitLab runners) | [Build a CI/CD pipeline with GitLab on Google Axion](/learning-paths/cross-platform/gitlab/) | | +| Kubernetes | [Migrate containers to Arm using KubeArchInspect](/learning-paths/servers-and-cloud-computing/kubearchinspect/) | | {{< /tab >}} @@ -151,8 +167,8 @@ Which programming languages work on Arm servers? - Nearly all of them. | | | [Optimizing Java Workloads on Azure General Purpose D-series v5 VMs with Microsoft's Build of OpenJDK](https://techcommunity.microsoft.com/t5/azure-compute-blog/optimizing-java-workloads-on-azure-general-purpose-d-series-v5/ba-p/3827610) | | | | [Improving Java performance on OCI Ampere A1 compute instances](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/performance-of-specjbb2015-on-oci-ampere-a1-compute-instances) | | Go | [Go Install Guide](/install-guides/go/) | [Making your Go workloads up to 20% faster with Go 1.18 and AWS Graviton](https://aws.amazon.com/blogs/compute/making-your-go-workloads-up-to-20-faster-with-go-1-18-and-aws-graviton/)| -| .NET | [.NET Install Guide](/install-guides/dotnet/) | [Arm64 Performance Improvements in .NET 7](https://devblogs.microsoft.com/dotnet/arm64-performance-improvements-in-dotnet-7/) | -| | [Deploy .NET application on Azure Cobalt 100 VMs](/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/) | [Arm64 Performance Improvements in .NET 8](https://devblogs.microsoft.com/dotnet/this-arm64-performance-in-dotnet-8/) | +| .NET | [.NET Install Guide](/install-guides/dotnet/) | [Performance improvements in .NET 10](https://devblogs.microsoft.com/dotnet/performance-improvements-in-net-10/) | +| | [Deploy a .NET application on Microsoft Azure Cobalt 200 VMs](/learning-paths/servers-and-cloud-computing/azure-cobalt-cicd-aks/) | [Performance improvements in .NET 11](https://devblogs.microsoft.com/dotnet/performance-improvements-in-net-11/) | | Python | | [Python on Arm](https://community.arm.com/arm-community-blogs/b/tools-software-ides-blog/posts/python-on-arm)| | PHP | | [Improving performance of PHP for Arm64 and impact on AWS Graviton2 based EC2 instances](https://aws.amazon.com/blogs/compute/improving-performance-of-php-for-arm64-and-impact-on-amazon-ec2-m6g-instances/) | @@ -163,11 +179,11 @@ Which key libraries are optimized for Arm servers? | Library/Framework | Learn More | Blogs | |-------------------|------------|-------| -| x264/x265 | [Run x265 (H.265 codec) on Arm servers](/learning-paths/servers-and-cloud-computing/codec/) | [Improve video encoding price/performance by up to 36% with Arm Neoverse based Amazon EC2 C6g instances](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/thirty-six-percent-better-video-encoding-with-aws-graviton2_2d00_based-c6g) | +| x264/x265 | [Run x265 (H.265 codec) on Arm servers](/learning-paths/servers-and-cloud-computing/codec/) | [Improve video encoding price-performance by up to 36% with Arm Neoverse based Amazon EC2 C6g instances](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/thirty-six-percent-better-video-encoding-with-aws-graviton2_2d00_based-c6g) | | | | [Reduce H.265 High-Res Encoding Costs by over 80% with AWS Graviton2](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/reduce-h-265-high-res-encoding-costs-by-over-80-with-aws-graviton2-1207706725) | | | | [Ampere Altra Max Delivers Sustainable High-Resolution H.265 Encoding](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/ampere-altra-max-delivers-sustainable-high-resolution-h-265-video-encoding-without-compromise) | | | | [OCI Ampere A1 Compute instances can significantly reduce video encoding costs versus modern CPUs](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/oracle-cloud-infrastructure-arm-based-a1) | -| ArmPL | [Arm Performance Libraries install guide](/install-guides/armpl/) | [Arm Compiler for Linux and Arm Performance Libraries 24.04](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/arm-compiler-for-linux-and-arm-performance-libraries-24-04) | +| ArmPL | [Arm Performance Libraries install guide](/install-guides/armpl/) | [Arm Toolchain for Linux 22.1 release](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/arm-toolchain-for-linux-22-1-release) | | ArmRAL | [Get started with the Arm 5G RAN Acceleration Library (ArmRAL)](/learning-paths/servers-and-cloud-computing/ran/) | [The next chapter for Arm RAN Acceleration Library: Open-sourcing the code base & accelerating adoption](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/arm-ral-is-now-open-source) | | OpenSSL | | | | VP9 | [Run the AV1 and VP9 codecs on Arm Linux](/learning-paths/servers-and-cloud-computing/codec1/) | [Arm-based cloud instances outperform x86 instances by up to 64% on VP9 encoding](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/arm-outperforms-x86-by-up-to-64-percent-on-vp9) | @@ -176,7 +192,7 @@ Which key libraries are optimized for Arm servers? | AV1 | [Run the AV1 and VP9 codecs on Arm Linux](/learning-paths/servers-and-cloud-computing/codec1/) | | | AES | | [AWS Graviton3 delivers leading AES-GCM encryption performance](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/aes-gcm-optimizations-for-armv8-4-on-neoverse-v1-graviton3) | | Snappy | [Measure performance of compression libraries on Arm servers](/learning-paths/servers-and-cloud-computing/snappy/) | [Comparing data compression algorithm performance on AWS Graviton2](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/comparing-data-compression-algorithm-performance-on-aws-graviton2-342166113) | -| Cloudflare zlib | [Learn how to build and use Cloudflare zlib on Arm servers](/learning-paths/servers-and-cloud-computing/zlib/) | | +| zlib-ng | [Improve data compression performance on Arm servers with zlib-ng](/learning-paths/servers-and-cloud-computing/zlib/) | | {{< /tab >}} @@ -192,13 +208,14 @@ Which databases are available on Arm servers? | MySQL | [Learn how to Tune MySQL](/learning-paths/servers-and-cloud-computing/mysql_tune/) | | | PostgreSQL | [Learn how to deploy PostgreSQL](/learning-paths/servers-and-cloud-computing/postgresql/) | | | Flink | [Benchmark the performance of Flink on Arm servers](/learning-paths/servers-and-cloud-computing/flink/) | -| Clickhouse | [Measure performance of ClickHouse on Arm servers](/learning-paths/servers-and-cloud-computing/clickhouse/) | [Improve ClickHouse Performance up to 26% by using AWS Graviton3](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/improve-clickhouse-performance-up-to-26-by-using-aws-graviton3) | +| ClickHouse | [Measure performance of ClickHouse on Arm servers](/learning-paths/servers-and-cloud-computing/clickhouse/) | [Improve ClickHouse Performance up to 26% by using AWS Graviton3](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/improve-clickhouse-performance-up-to-26-by-using-aws-graviton3) | +| ClickHouse | [Build a ClickHouse analytics pipeline on Google Axion](/learning-paths/servers-and-cloud-computing/clickhouse-gcp/) | | | MongoDB | [Test the performance of MongoDB on Arm servers](/learning-paths/servers-and-cloud-computing/mongodb/) | [MongoDB performance on Arm Neoverse based AWS Graviton2 processors](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/mongodb-performance-on-aws-with-the-arm-graviton2) | | Redis | [Deploy Redis on Arm](/learning-paths/servers-and-cloud-computing/redis/) | [Improve Redis performance up to 36% by deploying on Alibaba Cloud Yitian 710 instances](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/improve-redis-performance-by-deploying-on-alibaba-cloud-yitian-710-instances) | | Spark | [Learn how to deploy Spark on AWS Graviton2](/learning-paths/servers-and-cloud-computing/spark/) | [Spark on AWS Graviton2 best practices: K-Means clustering case study](https://developer.arm.com/community/arm-community-blogs/b/servers-and-cloud-computing-blog/posts/optimize-spark-on-aws-graviton2-best-practices-k-means-clustering) | | MariaDB | [Deploy MariaDB on Arm servers](/learning-paths/servers-and-cloud-computing/mariadb/) | -| Elasticsearch/Opensearch | | -| Spark+Gluten+Velox | | +| Elasticsearch/OpenSearch | [Deploy Elasticsearch on Azure Cobalt 100](/learning-paths/servers-and-cloud-computing/elasticsearch-on-azure/) | | +| Spark + Gluten + Velox | [Run Apache Spark SQL with Gluten and Velox on Azure Cobalt 100](/learning-paths/servers-and-cloud-computing/spark-velox-cobalt/) | | | Pinecone | | {{< /tab >}} @@ -230,6 +247,7 @@ Which AI/ML software stack can I run on Arm servers? | Software | Learning Paths | Other Content (Blogs/Videos) | |-----------|----------------|----------------------------------------| | MLPerf | [Measure Machine Learning Inference Performance on Arm servers](/learning-paths/servers-and-cloud-computing/ml-perf/) | | +| PyTorch | [Measure and accelerate PyTorch inference on Arm servers](/learning-paths/servers-and-cloud-computing/torchbench/) | | | vLLM | [Run vLLM inference with INT4 quantization on Arm servers](/learning-paths/servers-and-cloud-computing/vllm-acceleration/) | | | KleidiAI | [Accelerate Generative AI workloads using KleidiAI](/learning-paths/cross-platform/kleidiai-explainer/) | | | Llama.cpp | [Run distributed inference with llama.cpp on Arm-based AWS Graviton4 instances](/learning-paths/servers-and-cloud-computing/distributed-inference-with-llama-cpp/) | | @@ -241,19 +259,19 @@ Which AI/ML software stack can I run on Arm servers? Based on your initial research, decide how to proceed with trying your software on Arm. In general, you can use a top-down or bottom-up strategy to migrate to Arm. Select a methodology and use the resources above to build and run your application. -### 2.1 Top-down methodology +### Top-down methodology Top-down porting involves moving the complete software stack to an Arm machine and trying to build and run it straightaway. You will almost certainly face errors, which you can address one at a time until the full application runs on Arm. -![Top-down porting methodology](/migration/top-down.png) +![Top-down migration: move the full application from x86 to Arm, then fix library errors one at a time until the application runs.](/migration/top-down.png) This methodology is great for simpler stacks, when breaking down the problem would take more time than fixing errors iteratively. -### 2.2 Bottom-up methodology +### Bottom-up methodology Bottom-up porting is more systematic. Here, you break apart your software stack, starting with the foundations of your app to get those running on an Arm server first. Then add back one or two software packages at a time, and recompile and run to ensure it works on Arm. If errors arise, fix them or replace the incompatible package with an Arm compatible version. Continue building back your stack until it is fully formed on an Arm server. -![Bottom-up porting methodology](/migration/bottom-up.png) +![Bottom-up migration: start with a minimal application stack on Arm, fix errors, and add components until the full application runs.](/migration/bottom-up.png) This methodology is sensible for large stacks, where running the whole app on Arm immediately would cause too many errors to effectively work through. @@ -261,9 +279,9 @@ This methodology is sensible for large stacks, where running the whole app on Ar If you've reached this step, congratulations! Your application is running on Arm. The next action is to ensure it is running optimally. -### 3.1 Measure performance +### Measure performance -Once the application is running you can measure performance. This can be as simple as timing an application or may involve using performance analysis tools. +Once the application is running, you can measure performance. This can be as simple as timing an application or may involve using performance analysis tools. You may have some performance analysis methodologies you already follow, continue to use those. @@ -276,13 +294,13 @@ Below are some additional performance analysis tips and methodologies specific t - [Learn about Large System Extensions (LSE)](/learning-paths/servers-and-cloud-computing/lse/) - [Compare Arm Neoverse and Intel x86 top-down performance analysis with PMU counters](/learning-paths/cross-platform/topdown-compare/) -### 3.2 Ask for help +### Ask for help -Your goal is to understand if the performance you see will translate into the expected price performance advantages. If you are unsure or need additional help you can ask the Arm developer community for help. Join the [Arm Developer Program](https://www.arm.com/resources/developer-program) and talk directly to other developers and Arm Experts on Discord. +Your goal is to understand if the performance you see will translate into the expected price-performance advantages. If you are unsure or need additional help, you can ask the Arm developer community for help. Join the [Arm Developer Program](https://www.arm.com/resources/developer-program) and talk directly to other developers and Arm Experts on Discord. -### DELIVER: Deploy your application to users +### Deploy your application to users -Once the price performance gains are confirmed, you can plan for a larger deployment. +Once the price-performance gains are confirmed, you can plan for a larger deployment. Deployment is outside the scope of this guide, but here are some concepts to keep in mind: - Experiment with different virtual machine sizes and instance types to find the best fit for your application. @@ -294,4 +312,4 @@ Make sure to research the details needed for these tasks by checking any places ## Summary -With this 3 step process and the provided resources, you are well positioned to migrate your applications to Arm. Happy porting! +With this 3-step process and the provided resources, you are well positioned to migrate your applications to Arm. Happy porting! diff --git a/content/migration/arm-migration-overview.png b/content/migration/arm-migration-overview.png index 337519f31d..3d3b846abb 100644 Binary files a/content/migration/arm-migration-overview.png and b/content/migration/arm-migration-overview.png differ diff --git a/content/stats/content_over_time.png b/content/stats/content_over_time.png index 5f9d64ba08..67aa23d80a 100644 Binary files a/content/stats/content_over_time.png and b/content/stats/content_over_time.png differ diff --git a/data/stats_weekly_data.yml b/data/stats_weekly_data.yml index b9700860fc..ce59a59996 100644 --- a/data/stats_weekly_data.yml +++ b/data/stats_weekly_data.yml @@ -11480,3 +11480,210 @@ stars: 156 forks: 342 open_prs: 20 +- date: '2026-11-16' + content: + total: 630 + install-guides: 115 + automotive: 15 + cross-platform: 58 + embedded-and-microcontrollers: 97 + laptops-and-desktops: 96 + mobile-graphics-and-gaming: 102 + servers-and-cloud-computing: 289 + individual_authors: + adnan-alsinan: 3 + ajeet-singh-raina: 1 + akash-malik: 2 + alaaeddine-chakroun: 2 + albin-bernhardsson: 2 + alejandro-martinez-vicente: 1 + alex-su: 1 + alexandre-romana: 1 + alexandros-lamprineas: 1 + amarbold-batzorig: 1 + andreas-mullen: 1 + andrew-choi: 2 + andrew-kilroy: 1 + andrew-pickard: 1 + ann-cheng: 1 + anna-mayne: 1 + annie-tallund: 21 + anton-antonov: 3 + anupras-mohapatra: 4 + arnaud-de-grandmaison: 7 + arnaud-grasset: 1 + aryan-bhusari: 1 + ash-naik: 2 + asher-dobrescu: 1 + asier-arranz: 1 + aude-vuilliomenet: 2 + austin-hill: 1 + ayoub-bourjilat: 2 + barbara-corriero: 2 + basma-el-gaabouri: 1 + ben-clark: 4 + bhanu-arya: 1 + bolt-liu: 2 + brenda-strech: 1 + brendan-long: 2 + bright-edudzi-gershon-kordorwu: 1 + chaodong-gong: 1 + chen-zhang: 1 + chenying-kuo: 1 + chris-moroney: 1 + christophe-favergeon: 1 + christopher-seidl: 10 + claudio-martino: 1 + cyril-rohr: 1 + damien-dooley: 1 + daniel-gubay: 1 + daniel-nguyen: 2 + daniel-schleicher: 1 + dave-neary: 2 + david-spickett: 2 + david-torres: 1 + david-wong: 1 + dawid-borycki: 35 + diego-russo: 2 + dominica-abena-o.-amanfo: 2 + doug-anson: 7 + elad-gross: 1 + elham-harirpoush: 2 + fadi-arafeh: 1 + felix-johnny-thomasmathibalan: 1 + fidel-makatia-omusilibwa: 3 + florent-lebeau: 5 + frédéric--lefred--descamps: 2 + gabriel-peterson: 6 + gary-carroll: 1 + gauri-sahnan: 1 + gayathri-narayana-yegna-narayanan: 2 + georgios-mermigkis: 1 + geremy-cohen: 8 + gian-marco-iodice: 1 + graham-woodward: 1 + habib-ogunbanwo: 3 + han-yin: 1 + henry-wang: 1 + iago-calvo-lista: 1 + jai-adam-schrem: 1 + jaidev-singh-chadha: 1 + james-whitaker: 1 + jason-andrews: 126 + jason-zhu: 1 + jaxson-han: 1 + jeff-young: 1 + jett-zhou: 3 + jiaming-guo: 1 + joana-cruz: 2 + joe-stech: 8 + johanna-skinnider: 2 + john-o'hara: 1 + johnny-nunez: 2 + jonathan-davies: 2 + jose-emilio-munoz-lopez: 1 + joshua-marshall-law: 5 + julie-gaskin: 9 + julien-jayat: 2 + julien-simon: 2 + julio-suarez: 6 + jun-he: 1 + karthik-gopalakrishnan: 1 + kasper-mecklenburg: 1 + kavya-sri-chennoju: 2 + kelsey-steele: 1 + ken-zhang: 1 + ker-liu: 1 + kiel-friedt: 1 + kieran-hejmadi: 23 + koki-mitsunami: 3 + konstantinos-margaritis: 8 + kostiantyn-perehuda: 4 + kristof-beyls: 1 + kwashie-andoh: 8 + leandro-nunes: 1 + liam-randall: 1 + manu-nicholas-jacob: 2 + marek-michałowski: 1 + mark-thurman: 1 + martin-ma: 1 + masoud-koleini: 2 + mathias-brossard: 1 + matt-cossins: 14 + matthew-sloyan: 1 + michael-hall: 6 + mohamad-najem: 1 + mohamed-ismail: 1 + na-li: 2 + nader-zouaoui: 2 + neethu-elizabeth-simon: 1 + nii-osae-osae-dade: 2 + nikhil-gupta: 3 + nina-drozd: 2 + nobel-chowdary-mandepudi: 6 + odin-shen: 29 + oliver-grainge: 1 + owen-wu: 2 + pareena-verma: 106 + parichay-das: 1 + paschalis-mpeis: 3 + patrick-wang: 1 + paul-howard: 2 + peter-harris: 1 + phalani-paladugu: 1 + pinru-wang: 1 + powen-yang: 2 + pranay-bakre: 5 + preema-merlin-dsouza: 1 + prince-agyeman: 1 + przemyslaw-wirkus: 2 + qixiang-xu: 3 + rachel-belachew: 2 + rani-chowdary-mandepudi: 3 + raymond-lo: 1 + richard-burton: 2 + roberto-lopez-mendez: 2 + ronan-synnott: 38 + roy-jamil: 1 + rui-chang: 1 + ruifeng-wang: 1 + sabika-tasneem: 1 + sagar-surendran: 1 + sammy-sahnine: 1 + sayandip-pal: 2 + shuheng-deng: 1 + stephan-gomer: 1 + steve-jordahl: 1 + steve-suzuki: 1 + sue-wu: 2 + tianyu-li: 2 + tirui-wu: 1 + tom-dunkle: 1 + tom-pilar: 1 + tomas-agustin-gonzalez-orlando: 2 + tony-morri: 2 + tyler-mullenbach: 1 + uma-ramalingam: 1 + usamah-zaheer: 4 + varun-chari: 4 + victor-do-nascimento: 1 + waheed-brown: 4 + willen-yang: 1 + william-liang: 1 + william-watson: 1 + yahya-abouelseoud: 1 + ying-yu: 4 + yiyang-fan: 1 + yogesh-deshpande: 1 + zach-lasiuk: 2 + zbynek-roubalik: 1 + zenon-zhilong-xiu: 4 + zhengjun-xing: 2 + éliás-bálint: 1 + contributions: + internal: 623 + external: 128 + github: + stars: 156 + forks: 339 + open_prs: 11 diff --git a/static/apps/sme-visualisations/asset-manifest.json b/static/apps/sme-visualisations/asset-manifest.json index 82a10ec321..fb80bb10bb 100644 --- a/static/apps/sme-visualisations/asset-manifest.json +++ b/static/apps/sme-visualisations/asset-manifest.json @@ -1,15 +1,15 @@ { "files": { - "main.css": "/apps/sme-visualisations/static/css/main.05a1c7d9.css", - "main.js": "/apps/sme-visualisations/static/js/main.b8decb63.js", + "main.css": "/apps/sme-visualisations/static/css/main.790bcbb3.css", + "main.js": "/apps/sme-visualisations/static/js/main.eaa0d45d.js", "static/media/Lato-Black.ttf": "/apps/sme-visualisations/static/media/Lato-Black.0f56360fd2c505dd13fa.ttf", "static/media/Lato-Regular.ttf": "/apps/sme-visualisations/static/media/Lato-Regular.2b7b7f6c8554ad96436b.ttf", "index.html": "/apps/sme-visualisations/index.html", - "main.05a1c7d9.css.map": "/apps/sme-visualisations/static/css/main.05a1c7d9.css.map", - "main.b8decb63.js.map": "/apps/sme-visualisations/static/js/main.b8decb63.js.map" + "main.790bcbb3.css.map": "/apps/sme-visualisations/static/css/main.790bcbb3.css.map", + "main.eaa0d45d.js.map": "/apps/sme-visualisations/static/js/main.eaa0d45d.js.map" }, "entrypoints": [ - "static/css/main.05a1c7d9.css", - "static/js/main.b8decb63.js" + "static/css/main.790bcbb3.css", + "static/js/main.eaa0d45d.js" ] } \ No newline at end of file diff --git a/static/apps/sme-visualisations/index.html b/static/apps/sme-visualisations/index.html index 8d6c0f81bb..1cf9cd0a66 100644 --- a/static/apps/sme-visualisations/index.html +++ b/static/apps/sme-visualisations/index.html @@ -1 +1 @@ -Algorithm Kitchen - AArch64
\ No newline at end of file +Arm SME Visualizations
\ No newline at end of file diff --git a/static/apps/sme-visualisations/static/css/main.05a1c7d9.css b/static/apps/sme-visualisations/static/css/main.790bcbb3.css similarity index 99% rename from static/apps/sme-visualisations/static/css/main.05a1c7d9.css rename to static/apps/sme-visualisations/static/css/main.790bcbb3.css index e4ef94d172..9f4ce1eb4d 100644 --- a/static/apps/sme-visualisations/static/css/main.05a1c7d9.css +++ b/static/apps/sme-visualisations/static/css/main.790bcbb3.css @@ -6,5 +6,5 @@ * * Arm SME visualisations * Copyright 2026 Arm limited - */:root,[data-bs-theme=light]{--bs-blue:#0d6efd;--bs-indigo:#6610f2;--bs-purple:#6f42c1;--bs-pink:#d63384;--bs-red:#dc3545;--bs-orange:#fd7e14;--bs-yellow:#ffc107;--bs-green:#198754;--bs-teal:#20c997;--bs-cyan:#0dcaf0;--bs-black:#000;--bs-white:#fff;--bs-gray:#6c757d;--bs-gray-dark:#343a40;--bs-gray-100:#f8f9fa;--bs-gray-200:#e9ecef;--bs-gray-300:#dee2e6;--bs-gray-400:#ced4da;--bs-gray-500:#adb5bd;--bs-gray-600:#6c757d;--bs-gray-700:#495057;--bs-gray-800:#343a40;--bs-gray-900:#212529;--bs-primary:#0d6efd;--bs-secondary:#6c757d;--bs-success:#198754;--bs-info:#0dcaf0;--bs-warning:#ffc107;--bs-danger:#dc3545;--bs-light:#f8f9fa;--bs-dark:#212529;--bs-primary-rgb:13,110,253;--bs-secondary-rgb:108,117,125;--bs-success-rgb:25,135,84;--bs-info-rgb:13,202,240;--bs-warning-rgb:255,193,7;--bs-danger-rgb:220,53,69;--bs-light-rgb:248,249,250;--bs-dark-rgb:33,37,41;--bs-primary-text-emphasis:#052c65;--bs-secondary-text-emphasis:#2b2f32;--bs-success-text-emphasis:#0a3622;--bs-info-text-emphasis:#055160;--bs-warning-text-emphasis:#664d03;--bs-danger-text-emphasis:#58151c;--bs-light-text-emphasis:#495057;--bs-dark-text-emphasis:#495057;--bs-primary-bg-subtle:#cfe2ff;--bs-secondary-bg-subtle:#e2e3e5;--bs-success-bg-subtle:#d1e7dd;--bs-info-bg-subtle:#cff4fc;--bs-warning-bg-subtle:#fff3cd;--bs-danger-bg-subtle:#f8d7da;--bs-light-bg-subtle:#fcfcfd;--bs-dark-bg-subtle:#ced4da;--bs-primary-border-subtle:#9ec5fe;--bs-secondary-border-subtle:#c4c8cb;--bs-success-border-subtle:#a3cfbb;--bs-info-border-subtle:#9eeaf9;--bs-warning-border-subtle:#ffe69c;--bs-danger-border-subtle:#f1aeb5;--bs-light-border-subtle:#e9ecef;--bs-dark-border-subtle:#adb5bd;--bs-white-rgb:255,255,255;--bs-black-rgb:0,0,0;--bs-font-sans-serif:system-ui,-apple-system,"Segoe UI",Roboto,"Helvetica Neue","Noto Sans","Liberation Sans",Arial,sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji";--bs-font-monospace:SFMono-Regular,Menlo,Monaco,Consolas,"Liberation Mono","Courier New",monospace;--bs-gradient:linear-gradient(180deg,hsla(0,0%,100%,.15),hsla(0,0%,100%,0));--bs-body-font-family:var(--bs-font-sans-serif);--bs-body-font-size:1rem;--bs-body-font-weight:400;--bs-body-line-height:1.5;--bs-body-color:#212529;--bs-body-color-rgb:33,37,41;--bs-body-bg:#fff;--bs-body-bg-rgb:255,255,255;--bs-emphasis-color:#000;--bs-emphasis-color-rgb:0,0,0;--bs-secondary-color:rgba(33,37,41,.75);--bs-secondary-color-rgb:33,37,41;--bs-secondary-bg:#e9ecef;--bs-secondary-bg-rgb:233,236,239;--bs-tertiary-color:rgba(33,37,41,.5);--bs-tertiary-color-rgb:33,37,41;--bs-tertiary-bg:#f8f9fa;--bs-tertiary-bg-rgb:248,249,250;--bs-heading-color:inherit;--bs-link-color:#0d6efd;--bs-link-color-rgb:13,110,253;--bs-link-decoration:underline;--bs-link-hover-color:#0a58ca;--bs-link-hover-color-rgb:10,88,202;--bs-code-color:#d63384;--bs-highlight-color:#212529;--bs-highlight-bg:#fff3cd;--bs-border-width:1px;--bs-border-style:solid;--bs-border-color:#dee2e6;--bs-border-color-translucent:rgba(0,0,0,.175);--bs-border-radius:0.375rem;--bs-border-radius-sm:0.25rem;--bs-border-radius-lg:0.5rem;--bs-border-radius-xl:1rem;--bs-border-radius-xxl:2rem;--bs-border-radius-2xl:var(--bs-border-radius-xxl);--bs-border-radius-pill:50rem;--bs-box-shadow:0 0.5rem 1rem rgba(0,0,0,.15);--bs-box-shadow-sm:0 0.125rem 0.25rem rgba(0,0,0,.075);--bs-box-shadow-lg:0 1rem 3rem rgba(0,0,0,.175);--bs-box-shadow-inset:inset 0 1px 2px rgba(0,0,0,.075);--bs-focus-ring-width:0.25rem;--bs-focus-ring-opacity:0.25;--bs-focus-ring-color:rgba(13,110,253,.25);--bs-form-valid-color:#198754;--bs-form-valid-border-color:#198754;--bs-form-invalid-color:#dc3545;--bs-form-invalid-border-color:#dc3545}[data-bs-theme=dark]{--bs-body-color:#dee2e6;--bs-body-color-rgb:222,226,230;--bs-body-bg:#212529;--bs-body-bg-rgb:33,37,41;--bs-emphasis-color:#fff;--bs-emphasis-color-rgb:255,255,255;--bs-secondary-color:rgba(222,226,230,.75);--bs-secondary-color-rgb:222,226,230;--bs-secondary-bg:#343a40;--bs-secondary-bg-rgb:52,58,64;--bs-tertiary-color:rgba(222,226,230,.5);--bs-tertiary-color-rgb:222,226,230;--bs-tertiary-bg:#2b3035;--bs-tertiary-bg-rgb:43,48,53;--bs-primary-text-emphasis:#6ea8fe;--bs-secondary-text-emphasis:#a7acb1;--bs-success-text-emphasis:#75b798;--bs-info-text-emphasis:#6edff6;--bs-warning-text-emphasis:#ffda6a;--bs-danger-text-emphasis:#ea868f;--bs-light-text-emphasis:#f8f9fa;--bs-dark-text-emphasis:#dee2e6;--bs-primary-bg-subtle:#031633;--bs-secondary-bg-subtle:#161719;--bs-success-bg-subtle:#051b11;--bs-info-bg-subtle:#032830;--bs-warning-bg-subtle:#332701;--bs-danger-bg-subtle:#2c0b0e;--bs-light-bg-subtle:#343a40;--bs-dark-bg-subtle:#1a1d20;--bs-primary-border-subtle:#084298;--bs-secondary-border-subtle:#41464b;--bs-success-border-subtle:#0f5132;--bs-info-border-subtle:#087990;--bs-warning-border-subtle:#997404;--bs-danger-border-subtle:#842029;--bs-light-border-subtle:#495057;--bs-dark-border-subtle:#343a40;--bs-heading-color:inherit;--bs-link-color:#6ea8fe;--bs-link-hover-color:#8bb9fe;--bs-link-color-rgb:110,168,254;--bs-link-hover-color-rgb:139,185,254;--bs-code-color:#e685b5;--bs-highlight-color:#dee2e6;--bs-highlight-bg:#664d03;--bs-border-color:#495057;--bs-border-color-translucent:hsla(0,0%,100%,.15);--bs-form-valid-color:#75b798;--bs-form-valid-border-color:#75b798;--bs-form-invalid-color:#ea868f;--bs-form-invalid-border-color:#ea868f;color-scheme:dark}*,:after,:before{box-sizing:border-box}@media (prefers-reduced-motion:no-preference){:root{scroll-behavior:smooth}}body{-webkit-text-size-adjust:100%;-webkit-tap-highlight-color:rgba(0,0,0,0);background-color:#fff;background-color:var(--bs-body-bg);color:#212529;color:var(--bs-body-color);font-family:system-ui,-apple-system,Segoe UI,Roboto,Helvetica Neue,Noto Sans,Liberation Sans,Arial,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol,Noto Color Emoji;font-family:var(--bs-body-font-family);font-size:1rem;font-size:var(--bs-body-font-size);font-weight:400;font-weight:var(--bs-body-font-weight);line-height:1.5;line-height:var(--bs-body-line-height);text-align:var(--bs-body-text-align)}hr{border:0;border-top:1px solid;border-top:var(--bs-border-width) solid;color:inherit;margin:1rem 0;opacity:.25}.h1,.h2,.h3,.h4,.h5,.h6,h1,h2,h3,h4,h5,h6{color:inherit;color:var(--bs-heading-color);font-weight:500;line-height:1.2;margin-bottom:.5rem;margin-top:0}.h1,h1{font-size:calc(1.375rem + 1.5vw)}@media (min-width:1200px){.h1,h1{font-size:2.5rem}}.h2,h2{font-size:calc(1.325rem + .9vw)}@media (min-width:1200px){.h2,h2{font-size:2rem}}.h3,h3{font-size:calc(1.3rem + .6vw)}@media (min-width:1200px){.h3,h3{font-size:1.75rem}}.h4,h4{font-size:calc(1.275rem + .3vw)}@media (min-width:1200px){.h4,h4{font-size:1.5rem}}.h5,h5{font-size:1.25rem}.h6,h6{font-size:1rem}p{margin-bottom:1rem;margin-top:0}abbr[title]{cursor:help;-webkit-text-decoration:underline dotted;text-decoration:underline dotted;-webkit-text-decoration-skip-ink:none;text-decoration-skip-ink:none}address{font-style:normal;line-height:inherit;margin-bottom:1rem}ol,ul{padding-left:2rem}dl,ol,ul{margin-bottom:1rem;margin-top:0}ol ol,ol ul,ul ol,ul ul{margin-bottom:0}dt{font-weight:700}dd{margin-bottom:.5rem;margin-left:0}blockquote{margin:0 0 1rem}b,strong{font-weight:bolder}.small,small{font-size:.875em}.mark,mark{background-color:#fff3cd;background-color:var(--bs-highlight-bg);color:#212529;color:var(--bs-highlight-color);padding:.1875em}sub,sup{font-size:.75em;line-height:0;position:relative;vertical-align:initial}sub{bottom:-.25em}sup{top:-.5em}a{color:#0d6efd;color:rgba(var(--bs-link-color-rgb),var(--bs-link-opacity,1));text-decoration:underline}a:hover{--bs-link-color-rgb:var(--bs-link-hover-color-rgb)}a:not([href]):not([class]),a:not([href]):not([class]):hover{color:inherit;text-decoration:none}code,kbd,pre,samp{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,monospace;font-family:var(--bs-font-monospace);font-size:1em}pre{display:block;font-size:.875em;margin-bottom:1rem;margin-top:0;overflow:auto}pre code{color:inherit;font-size:inherit;word-break:normal}code{word-wrap:break-word;color:#d63384;color:var(--bs-code-color);font-size:.875em}a>code{color:inherit}kbd{background-color:#212529;background-color:var(--bs-body-color);border-radius:.25rem;color:#fff;color:var(--bs-body-bg);font-size:.875em;padding:.1875rem .375rem}kbd kbd{font-size:1em;padding:0}figure{margin:0 0 1rem}img,svg{vertical-align:middle}table{border-collapse:collapse;caption-side:bottom}caption{color:rgba(33,37,41,.75);color:var(--bs-secondary-color);padding-bottom:.5rem;padding-top:.5rem;text-align:left}th{text-align:inherit;text-align:-webkit-match-parent}tbody,td,tfoot,th,thead,tr{border:0 solid;border-color:inherit}label{display:inline-block}button{border-radius:0}button:focus:not(:focus-visible){outline:0}button,input,optgroup,select,textarea{font-family:inherit;font-size:inherit;line-height:inherit;margin:0}button,select{text-transform:none}[role=button]{cursor:pointer}select{word-wrap:normal}select:disabled{opacity:1}[list]:not([type=date]):not([type=datetime-local]):not([type=month]):not([type=week]):not([type=time])::-webkit-calendar-picker-indicator{display:none!important}[type=button],[type=reset],[type=submit],button{-webkit-appearance:button}[type=button]:not(:disabled),[type=reset]:not(:disabled),[type=submit]:not(:disabled),button:not(:disabled){cursor:pointer}::-moz-focus-inner{border-style:none;padding:0}textarea{resize:vertical}fieldset{border:0;margin:0;min-width:0;padding:0}legend{float:left;font-size:calc(1.275rem + .3vw);line-height:inherit;margin-bottom:.5rem;padding:0;width:100%}@media (min-width:1200px){legend{font-size:1.5rem}}legend+*{clear:left}::-webkit-datetime-edit-day-field,::-webkit-datetime-edit-fields-wrapper,::-webkit-datetime-edit-hour-field,::-webkit-datetime-edit-minute,::-webkit-datetime-edit-month-field,::-webkit-datetime-edit-text,::-webkit-datetime-edit-year-field{padding:0}::-webkit-inner-spin-button{height:auto}[type=search]{-webkit-appearance:textfield;outline-offset:-2px}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-color-swatch-wrapper{padding:0}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}::file-selector-button{-webkit-appearance:button;font:inherit}output{display:inline-block}iframe{border:0}summary{cursor:pointer;display:list-item}progress{vertical-align:initial}[hidden]{display:none!important}.lead{font-size:1.25rem;font-weight:300}.display-1{font-size:calc(1.625rem + 4.5vw);font-weight:300;line-height:1.2}@media (min-width:1200px){.display-1{font-size:5rem}}.display-2{font-size:calc(1.575rem + 3.9vw);font-weight:300;line-height:1.2}@media (min-width:1200px){.display-2{font-size:4.5rem}}.display-3{font-size:calc(1.525rem + 3.3vw);font-weight:300;line-height:1.2}@media (min-width:1200px){.display-3{font-size:4rem}}.display-4{font-size:calc(1.475rem + 2.7vw);font-weight:300;line-height:1.2}@media (min-width:1200px){.display-4{font-size:3.5rem}}.display-5{font-size:calc(1.425rem + 2.1vw);font-weight:300;line-height:1.2}@media (min-width:1200px){.display-5{font-size:3rem}}.display-6{font-size:calc(1.375rem + 1.5vw);font-weight:300;line-height:1.2}@media (min-width:1200px){.display-6{font-size:2.5rem}}.list-inline,.list-unstyled{list-style:none;padding-left:0}.list-inline-item{display:inline-block}.list-inline-item:not(:last-child){margin-right:.5rem}.initialism{font-size:.875em;text-transform:uppercase}.blockquote{font-size:1.25rem;margin-bottom:1rem}.blockquote>:last-child{margin-bottom:0}.blockquote-footer{color:#6c757d;font-size:.875em;margin-bottom:1rem;margin-top:-1rem}.blockquote-footer:before{content:"— "}.img-fluid,.img-thumbnail{height:auto;max-width:100%}.img-thumbnail{background-color:#fff;background-color:var(--bs-body-bg);border:1px solid #dee2e6;border:var(--bs-border-width) solid var(--bs-border-color);border-radius:.375rem;border-radius:var(--bs-border-radius);padding:.25rem}.figure{display:inline-block}.figure-img{line-height:1;margin-bottom:.5rem}.figure-caption{color:rgba(33,37,41,.75);color:var(--bs-secondary-color);font-size:.875em}.container,.container-fluid,.container-lg,.container-md,.container-sm,.container-xl,.container-xxl{--bs-gutter-x:1.5rem;--bs-gutter-y:0;margin-left:auto;margin-right:auto;padding-left:calc(var(--bs-gutter-x)*.5);padding-right:calc(var(--bs-gutter-x)*.5);width:100%}@media (min-width:576px){.container,.container-sm{max-width:540px}}@media (min-width:768px){.container,.container-md,.container-sm{max-width:720px}}@media (min-width:992px){.container,.container-lg,.container-md,.container-sm{max-width:960px}}@media (min-width:1200px){.container,.container-lg,.container-md,.container-sm,.container-xl{max-width:1140px}}@media (min-width:1400px){.container,.container-lg,.container-md,.container-sm,.container-xl,.container-xxl{max-width:1320px}}:root{--bs-breakpoint-xs:0;--bs-breakpoint-sm:576px;--bs-breakpoint-md:768px;--bs-breakpoint-lg:992px;--bs-breakpoint-xl:1200px;--bs-breakpoint-xxl:1400px}.row{--bs-gutter-x:1.5rem;--bs-gutter-y:0;display:flex;flex-wrap:wrap;margin-left:calc(var(--bs-gutter-x)*-.5);margin-right:calc(var(--bs-gutter-x)*-.5);margin-top:calc(var(--bs-gutter-y)*-1)}.row>*{flex-shrink:0;margin-top:var(--bs-gutter-y);max-width:100%;padding-left:calc(var(--bs-gutter-x)*.5);padding-right:calc(var(--bs-gutter-x)*.5);width:100%}.col{flex:1 0}.row-cols-auto>*{flex:0 0 auto;width:auto}.row-cols-1>*{flex:0 0 auto;width:100%}.row-cols-2>*{flex:0 0 auto;width:50%}.row-cols-3>*{flex:0 0 auto;width:33.33333333%}.row-cols-4>*{flex:0 0 auto;width:25%}.row-cols-5>*{flex:0 0 auto;width:20%}.row-cols-6>*{flex:0 0 auto;width:16.66666667%}.col-auto{flex:0 0 auto;width:auto}.col-1{flex:0 0 auto;width:8.33333333%}.col-2{flex:0 0 auto;width:16.66666667%}.col-3{flex:0 0 auto;width:25%}.col-4{flex:0 0 auto;width:33.33333333%}.col-5{flex:0 0 auto;width:41.66666667%}.col-6{flex:0 0 auto;width:50%}.col-7{flex:0 0 auto;width:58.33333333%}.col-8{flex:0 0 auto;width:66.66666667%}.col-9{flex:0 0 auto;width:75%}.col-10{flex:0 0 auto;width:83.33333333%}.col-11{flex:0 0 auto;width:91.66666667%}.col-12{flex:0 0 auto;width:100%}.offset-1{margin-left:8.33333333%}.offset-2{margin-left:16.66666667%}.offset-3{margin-left:25%}.offset-4{margin-left:33.33333333%}.offset-5{margin-left:41.66666667%}.offset-6{margin-left:50%}.offset-7{margin-left:58.33333333%}.offset-8{margin-left:66.66666667%}.offset-9{margin-left:75%}.offset-10{margin-left:83.33333333%}.offset-11{margin-left:91.66666667%}.g-0,.gx-0{--bs-gutter-x:0}.g-0,.gy-0{--bs-gutter-y:0}.g-1,.gx-1{--bs-gutter-x:0.25rem}.g-1,.gy-1{--bs-gutter-y:0.25rem}.g-2,.gx-2{--bs-gutter-x:0.5rem}.g-2,.gy-2{--bs-gutter-y:0.5rem}.g-3,.gx-3{--bs-gutter-x:1rem}.g-3,.gy-3{--bs-gutter-y:1rem}.g-4,.gx-4{--bs-gutter-x:1.5rem}.g-4,.gy-4{--bs-gutter-y:1.5rem}.g-5,.gx-5{--bs-gutter-x:3rem}.g-5,.gy-5{--bs-gutter-y:3rem}@media (min-width:576px){.col-sm{flex:1 0}.row-cols-sm-auto>*{flex:0 0 auto;width:auto}.row-cols-sm-1>*{flex:0 0 auto;width:100%}.row-cols-sm-2>*{flex:0 0 auto;width:50%}.row-cols-sm-3>*{flex:0 0 auto;width:33.33333333%}.row-cols-sm-4>*{flex:0 0 auto;width:25%}.row-cols-sm-5>*{flex:0 0 auto;width:20%}.row-cols-sm-6>*{flex:0 0 auto;width:16.66666667%}.col-sm-auto{flex:0 0 auto;width:auto}.col-sm-1{flex:0 0 auto;width:8.33333333%}.col-sm-2{flex:0 0 auto;width:16.66666667%}.col-sm-3{flex:0 0 auto;width:25%}.col-sm-4{flex:0 0 auto;width:33.33333333%}.col-sm-5{flex:0 0 auto;width:41.66666667%}.col-sm-6{flex:0 0 auto;width:50%}.col-sm-7{flex:0 0 auto;width:58.33333333%}.col-sm-8{flex:0 0 auto;width:66.66666667%}.col-sm-9{flex:0 0 auto;width:75%}.col-sm-10{flex:0 0 auto;width:83.33333333%}.col-sm-11{flex:0 0 auto;width:91.66666667%}.col-sm-12{flex:0 0 auto;width:100%}.offset-sm-0{margin-left:0}.offset-sm-1{margin-left:8.33333333%}.offset-sm-2{margin-left:16.66666667%}.offset-sm-3{margin-left:25%}.offset-sm-4{margin-left:33.33333333%}.offset-sm-5{margin-left:41.66666667%}.offset-sm-6{margin-left:50%}.offset-sm-7{margin-left:58.33333333%}.offset-sm-8{margin-left:66.66666667%}.offset-sm-9{margin-left:75%}.offset-sm-10{margin-left:83.33333333%}.offset-sm-11{margin-left:91.66666667%}.g-sm-0,.gx-sm-0{--bs-gutter-x:0}.g-sm-0,.gy-sm-0{--bs-gutter-y:0}.g-sm-1,.gx-sm-1{--bs-gutter-x:0.25rem}.g-sm-1,.gy-sm-1{--bs-gutter-y:0.25rem}.g-sm-2,.gx-sm-2{--bs-gutter-x:0.5rem}.g-sm-2,.gy-sm-2{--bs-gutter-y:0.5rem}.g-sm-3,.gx-sm-3{--bs-gutter-x:1rem}.g-sm-3,.gy-sm-3{--bs-gutter-y:1rem}.g-sm-4,.gx-sm-4{--bs-gutter-x:1.5rem}.g-sm-4,.gy-sm-4{--bs-gutter-y:1.5rem}.g-sm-5,.gx-sm-5{--bs-gutter-x:3rem}.g-sm-5,.gy-sm-5{--bs-gutter-y:3rem}}@media (min-width:768px){.col-md{flex:1 0}.row-cols-md-auto>*{flex:0 0 auto;width:auto}.row-cols-md-1>*{flex:0 0 auto;width:100%}.row-cols-md-2>*{flex:0 0 auto;width:50%}.row-cols-md-3>*{flex:0 0 auto;width:33.33333333%}.row-cols-md-4>*{flex:0 0 auto;width:25%}.row-cols-md-5>*{flex:0 0 auto;width:20%}.row-cols-md-6>*{flex:0 0 auto;width:16.66666667%}.col-md-auto{flex:0 0 auto;width:auto}.col-md-1{flex:0 0 auto;width:8.33333333%}.col-md-2{flex:0 0 auto;width:16.66666667%}.col-md-3{flex:0 0 auto;width:25%}.col-md-4{flex:0 0 auto;width:33.33333333%}.col-md-5{flex:0 0 auto;width:41.66666667%}.col-md-6{flex:0 0 auto;width:50%}.col-md-7{flex:0 0 auto;width:58.33333333%}.col-md-8{flex:0 0 auto;width:66.66666667%}.col-md-9{flex:0 0 auto;width:75%}.col-md-10{flex:0 0 auto;width:83.33333333%}.col-md-11{flex:0 0 auto;width:91.66666667%}.col-md-12{flex:0 0 auto;width:100%}.offset-md-0{margin-left:0}.offset-md-1{margin-left:8.33333333%}.offset-md-2{margin-left:16.66666667%}.offset-md-3{margin-left:25%}.offset-md-4{margin-left:33.33333333%}.offset-md-5{margin-left:41.66666667%}.offset-md-6{margin-left:50%}.offset-md-7{margin-left:58.33333333%}.offset-md-8{margin-left:66.66666667%}.offset-md-9{margin-left:75%}.offset-md-10{margin-left:83.33333333%}.offset-md-11{margin-left:91.66666667%}.g-md-0,.gx-md-0{--bs-gutter-x:0}.g-md-0,.gy-md-0{--bs-gutter-y:0}.g-md-1,.gx-md-1{--bs-gutter-x:0.25rem}.g-md-1,.gy-md-1{--bs-gutter-y:0.25rem}.g-md-2,.gx-md-2{--bs-gutter-x:0.5rem}.g-md-2,.gy-md-2{--bs-gutter-y:0.5rem}.g-md-3,.gx-md-3{--bs-gutter-x:1rem}.g-md-3,.gy-md-3{--bs-gutter-y:1rem}.g-md-4,.gx-md-4{--bs-gutter-x:1.5rem}.g-md-4,.gy-md-4{--bs-gutter-y:1.5rem}.g-md-5,.gx-md-5{--bs-gutter-x:3rem}.g-md-5,.gy-md-5{--bs-gutter-y:3rem}}@media (min-width:992px){.col-lg{flex:1 0}.row-cols-lg-auto>*{flex:0 0 auto;width:auto}.row-cols-lg-1>*{flex:0 0 auto;width:100%}.row-cols-lg-2>*{flex:0 0 auto;width:50%}.row-cols-lg-3>*{flex:0 0 auto;width:33.33333333%}.row-cols-lg-4>*{flex:0 0 auto;width:25%}.row-cols-lg-5>*{flex:0 0 auto;width:20%}.row-cols-lg-6>*{flex:0 0 auto;width:16.66666667%}.col-lg-auto{flex:0 0 auto;width:auto}.col-lg-1{flex:0 0 auto;width:8.33333333%}.col-lg-2{flex:0 0 auto;width:16.66666667%}.col-lg-3{flex:0 0 auto;width:25%}.col-lg-4{flex:0 0 auto;width:33.33333333%}.col-lg-5{flex:0 0 auto;width:41.66666667%}.col-lg-6{flex:0 0 auto;width:50%}.col-lg-7{flex:0 0 auto;width:58.33333333%}.col-lg-8{flex:0 0 auto;width:66.66666667%}.col-lg-9{flex:0 0 auto;width:75%}.col-lg-10{flex:0 0 auto;width:83.33333333%}.col-lg-11{flex:0 0 auto;width:91.66666667%}.col-lg-12{flex:0 0 auto;width:100%}.offset-lg-0{margin-left:0}.offset-lg-1{margin-left:8.33333333%}.offset-lg-2{margin-left:16.66666667%}.offset-lg-3{margin-left:25%}.offset-lg-4{margin-left:33.33333333%}.offset-lg-5{margin-left:41.66666667%}.offset-lg-6{margin-left:50%}.offset-lg-7{margin-left:58.33333333%}.offset-lg-8{margin-left:66.66666667%}.offset-lg-9{margin-left:75%}.offset-lg-10{margin-left:83.33333333%}.offset-lg-11{margin-left:91.66666667%}.g-lg-0,.gx-lg-0{--bs-gutter-x:0}.g-lg-0,.gy-lg-0{--bs-gutter-y:0}.g-lg-1,.gx-lg-1{--bs-gutter-x:0.25rem}.g-lg-1,.gy-lg-1{--bs-gutter-y:0.25rem}.g-lg-2,.gx-lg-2{--bs-gutter-x:0.5rem}.g-lg-2,.gy-lg-2{--bs-gutter-y:0.5rem}.g-lg-3,.gx-lg-3{--bs-gutter-x:1rem}.g-lg-3,.gy-lg-3{--bs-gutter-y:1rem}.g-lg-4,.gx-lg-4{--bs-gutter-x:1.5rem}.g-lg-4,.gy-lg-4{--bs-gutter-y:1.5rem}.g-lg-5,.gx-lg-5{--bs-gutter-x:3rem}.g-lg-5,.gy-lg-5{--bs-gutter-y:3rem}}@media (min-width:1200px){.col-xl{flex:1 0}.row-cols-xl-auto>*{flex:0 0 auto;width:auto}.row-cols-xl-1>*{flex:0 0 auto;width:100%}.row-cols-xl-2>*{flex:0 0 auto;width:50%}.row-cols-xl-3>*{flex:0 0 auto;width:33.33333333%}.row-cols-xl-4>*{flex:0 0 auto;width:25%}.row-cols-xl-5>*{flex:0 0 auto;width:20%}.row-cols-xl-6>*{flex:0 0 auto;width:16.66666667%}.col-xl-auto{flex:0 0 auto;width:auto}.col-xl-1{flex:0 0 auto;width:8.33333333%}.col-xl-2{flex:0 0 auto;width:16.66666667%}.col-xl-3{flex:0 0 auto;width:25%}.col-xl-4{flex:0 0 auto;width:33.33333333%}.col-xl-5{flex:0 0 auto;width:41.66666667%}.col-xl-6{flex:0 0 auto;width:50%}.col-xl-7{flex:0 0 auto;width:58.33333333%}.col-xl-8{flex:0 0 auto;width:66.66666667%}.col-xl-9{flex:0 0 auto;width:75%}.col-xl-10{flex:0 0 auto;width:83.33333333%}.col-xl-11{flex:0 0 auto;width:91.66666667%}.col-xl-12{flex:0 0 auto;width:100%}.offset-xl-0{margin-left:0}.offset-xl-1{margin-left:8.33333333%}.offset-xl-2{margin-left:16.66666667%}.offset-xl-3{margin-left:25%}.offset-xl-4{margin-left:33.33333333%}.offset-xl-5{margin-left:41.66666667%}.offset-xl-6{margin-left:50%}.offset-xl-7{margin-left:58.33333333%}.offset-xl-8{margin-left:66.66666667%}.offset-xl-9{margin-left:75%}.offset-xl-10{margin-left:83.33333333%}.offset-xl-11{margin-left:91.66666667%}.g-xl-0,.gx-xl-0{--bs-gutter-x:0}.g-xl-0,.gy-xl-0{--bs-gutter-y:0}.g-xl-1,.gx-xl-1{--bs-gutter-x:0.25rem}.g-xl-1,.gy-xl-1{--bs-gutter-y:0.25rem}.g-xl-2,.gx-xl-2{--bs-gutter-x:0.5rem}.g-xl-2,.gy-xl-2{--bs-gutter-y:0.5rem}.g-xl-3,.gx-xl-3{--bs-gutter-x:1rem}.g-xl-3,.gy-xl-3{--bs-gutter-y:1rem}.g-xl-4,.gx-xl-4{--bs-gutter-x:1.5rem}.g-xl-4,.gy-xl-4{--bs-gutter-y:1.5rem}.g-xl-5,.gx-xl-5{--bs-gutter-x:3rem}.g-xl-5,.gy-xl-5{--bs-gutter-y:3rem}}@media (min-width:1400px){.col-xxl{flex:1 0}.row-cols-xxl-auto>*{flex:0 0 auto;width:auto}.row-cols-xxl-1>*{flex:0 0 auto;width:100%}.row-cols-xxl-2>*{flex:0 0 auto;width:50%}.row-cols-xxl-3>*{flex:0 0 auto;width:33.33333333%}.row-cols-xxl-4>*{flex:0 0 auto;width:25%}.row-cols-xxl-5>*{flex:0 0 auto;width:20%}.row-cols-xxl-6>*{flex:0 0 auto;width:16.66666667%}.col-xxl-auto{flex:0 0 auto;width:auto}.col-xxl-1{flex:0 0 auto;width:8.33333333%}.col-xxl-2{flex:0 0 auto;width:16.66666667%}.col-xxl-3{flex:0 0 auto;width:25%}.col-xxl-4{flex:0 0 auto;width:33.33333333%}.col-xxl-5{flex:0 0 auto;width:41.66666667%}.col-xxl-6{flex:0 0 auto;width:50%}.col-xxl-7{flex:0 0 auto;width:58.33333333%}.col-xxl-8{flex:0 0 auto;width:66.66666667%}.col-xxl-9{flex:0 0 auto;width:75%}.col-xxl-10{flex:0 0 auto;width:83.33333333%}.col-xxl-11{flex:0 0 auto;width:91.66666667%}.col-xxl-12{flex:0 0 auto;width:100%}.offset-xxl-0{margin-left:0}.offset-xxl-1{margin-left:8.33333333%}.offset-xxl-2{margin-left:16.66666667%}.offset-xxl-3{margin-left:25%}.offset-xxl-4{margin-left:33.33333333%}.offset-xxl-5{margin-left:41.66666667%}.offset-xxl-6{margin-left:50%}.offset-xxl-7{margin-left:58.33333333%}.offset-xxl-8{margin-left:66.66666667%}.offset-xxl-9{margin-left:75%}.offset-xxl-10{margin-left:83.33333333%}.offset-xxl-11{margin-left:91.66666667%}.g-xxl-0,.gx-xxl-0{--bs-gutter-x:0}.g-xxl-0,.gy-xxl-0{--bs-gutter-y:0}.g-xxl-1,.gx-xxl-1{--bs-gutter-x:0.25rem}.g-xxl-1,.gy-xxl-1{--bs-gutter-y:0.25rem}.g-xxl-2,.gx-xxl-2{--bs-gutter-x:0.5rem}.g-xxl-2,.gy-xxl-2{--bs-gutter-y:0.5rem}.g-xxl-3,.gx-xxl-3{--bs-gutter-x:1rem}.g-xxl-3,.gy-xxl-3{--bs-gutter-y:1rem}.g-xxl-4,.gx-xxl-4{--bs-gutter-x:1.5rem}.g-xxl-4,.gy-xxl-4{--bs-gutter-y:1.5rem}.g-xxl-5,.gx-xxl-5{--bs-gutter-x:3rem}.g-xxl-5,.gy-xxl-5{--bs-gutter-y:3rem}}.table{--bs-table-color-type:initial;--bs-table-bg-type:initial;--bs-table-color-state:initial;--bs-table-bg-state:initial;--bs-table-color:var(--bs-emphasis-color);--bs-table-bg:var(--bs-body-bg);--bs-table-border-color:var(--bs-border-color);--bs-table-accent-bg:transparent;--bs-table-striped-color:var(--bs-emphasis-color);--bs-table-striped-bg:rgba(var(--bs-emphasis-color-rgb),0.05);--bs-table-active-color:var(--bs-emphasis-color);--bs-table-active-bg:rgba(var(--bs-emphasis-color-rgb),0.1);--bs-table-hover-color:var(--bs-emphasis-color);--bs-table-hover-bg:rgba(var(--bs-emphasis-color-rgb),0.075);border-color:var(--bs-table-border-color);margin-bottom:1rem;vertical-align:top;width:100%}.table>:not(caption)>*>*{background-color:var(--bs-table-bg);border-bottom-width:1px;border-bottom-width:var(--bs-border-width);box-shadow:inset 0 0 0 9999px var(--bs-table-accent-bg);box-shadow:inset 0 0 0 9999px var(--bs-table-bg-state,var(--bs-table-bg-type,var(--bs-table-accent-bg)));color:var(--bs-table-color);color:var(--bs-table-color-state,var(--bs-table-color-type,var(--bs-table-color)));padding:.5rem}.table>tbody{vertical-align:inherit}.table>thead{vertical-align:bottom}.table-group-divider{border-top:2px solid;border-top:calc(var(--bs-border-width)*2) solid}.caption-top{caption-side:top}.table-sm>:not(caption)>*>*{padding:.25rem}.table-bordered>:not(caption)>*{border-width:1px 0;border-width:var(--bs-border-width) 0}.table-bordered>:not(caption)>*>*{border-width:0 1px;border-width:0 var(--bs-border-width)}.table-borderless>:not(caption)>*>*{border-bottom-width:0}.table-borderless>:not(:first-child){border-top-width:0}.table-striped-columns>:not(caption)>tr>:nth-child(2n),.table-striped>tbody>tr:nth-of-type(odd)>*{--bs-table-color-type:var(--bs-table-striped-color);--bs-table-bg-type:var(--bs-table-striped-bg)}.table-active{--bs-table-color-state:var(--bs-table-active-color);--bs-table-bg-state:var(--bs-table-active-bg)}.table-hover>tbody>tr:hover>*{--bs-table-color-state:var(--bs-table-hover-color);--bs-table-bg-state:var(--bs-table-hover-bg)}.table-primary{--bs-table-color:#000;--bs-table-bg:#cfe2ff;--bs-table-border-color:#a6b5cc;--bs-table-striped-bg:#c5d7f2;--bs-table-striped-color:#000;--bs-table-active-bg:#bacbe6;--bs-table-active-color:#000;--bs-table-hover-bg:#bfd1ec;--bs-table-hover-color:#000}.table-primary,.table-secondary{border-color:var(--bs-table-border-color);color:var(--bs-table-color)}.table-secondary{--bs-table-color:#000;--bs-table-bg:#e2e3e5;--bs-table-border-color:#b5b6b7;--bs-table-striped-bg:#d7d8da;--bs-table-striped-color:#000;--bs-table-active-bg:#cbccce;--bs-table-active-color:#000;--bs-table-hover-bg:#d1d2d4;--bs-table-hover-color:#000}.table-success{--bs-table-color:#000;--bs-table-bg:#d1e7dd;--bs-table-border-color:#a7b9b1;--bs-table-striped-bg:#c7dbd2;--bs-table-striped-color:#000;--bs-table-active-bg:#bcd0c7;--bs-table-active-color:#000;--bs-table-hover-bg:#c1d6cc;--bs-table-hover-color:#000}.table-info,.table-success{border-color:var(--bs-table-border-color);color:var(--bs-table-color)}.table-info{--bs-table-color:#000;--bs-table-bg:#cff4fc;--bs-table-border-color:#a6c3ca;--bs-table-striped-bg:#c5e8ef;--bs-table-striped-color:#000;--bs-table-active-bg:#badce3;--bs-table-active-color:#000;--bs-table-hover-bg:#bfe2e9;--bs-table-hover-color:#000}.table-warning{--bs-table-color:#000;--bs-table-bg:#fff3cd;--bs-table-border-color:#ccc2a4;--bs-table-striped-bg:#f2e7c3;--bs-table-striped-color:#000;--bs-table-active-bg:#e6dbb9;--bs-table-active-color:#000;--bs-table-hover-bg:#ece1be;--bs-table-hover-color:#000}.table-danger,.table-warning{border-color:var(--bs-table-border-color);color:var(--bs-table-color)}.table-danger{--bs-table-color:#000;--bs-table-bg:#f8d7da;--bs-table-border-color:#c6acae;--bs-table-striped-bg:#eccccf;--bs-table-striped-color:#000;--bs-table-active-bg:#dfc2c4;--bs-table-active-color:#000;--bs-table-hover-bg:#e5c7ca;--bs-table-hover-color:#000}.table-light{--bs-table-color:#000;--bs-table-bg:#f8f9fa;--bs-table-border-color:#c6c7c8;--bs-table-striped-bg:#ecedee;--bs-table-striped-color:#000;--bs-table-active-bg:#dfe0e1;--bs-table-active-color:#000;--bs-table-hover-bg:#e5e6e7;--bs-table-hover-color:#000}.table-dark,.table-light{border-color:var(--bs-table-border-color);color:var(--bs-table-color)}.table-dark{--bs-table-color:#fff;--bs-table-bg:#212529;--bs-table-border-color:#4d5154;--bs-table-striped-bg:#2c3034;--bs-table-striped-color:#fff;--bs-table-active-bg:#373b3e;--bs-table-active-color:#fff;--bs-table-hover-bg:#323539;--bs-table-hover-color:#fff}.table-responsive{-webkit-overflow-scrolling:touch;overflow-x:auto}@media (max-width:575.98px){.table-responsive-sm{-webkit-overflow-scrolling:touch;overflow-x:auto}}@media (max-width:767.98px){.table-responsive-md{-webkit-overflow-scrolling:touch;overflow-x:auto}}@media (max-width:991.98px){.table-responsive-lg{-webkit-overflow-scrolling:touch;overflow-x:auto}}@media (max-width:1199.98px){.table-responsive-xl{-webkit-overflow-scrolling:touch;overflow-x:auto}}@media (max-width:1399.98px){.table-responsive-xxl{-webkit-overflow-scrolling:touch;overflow-x:auto}}.form-label{margin-bottom:.5rem}.col-form-label{font-size:inherit;line-height:1.5;margin-bottom:0;padding-bottom:calc(.375rem + 1px);padding-bottom:calc(.375rem + var(--bs-border-width));padding-top:calc(.375rem + 1px);padding-top:calc(.375rem + var(--bs-border-width))}.col-form-label-lg{font-size:1.25rem;padding-bottom:calc(.5rem + 1px);padding-bottom:calc(.5rem + var(--bs-border-width));padding-top:calc(.5rem + 1px);padding-top:calc(.5rem + var(--bs-border-width))}.col-form-label-sm{font-size:.875rem;padding-bottom:calc(.25rem + 1px);padding-bottom:calc(.25rem + var(--bs-border-width));padding-top:calc(.25rem + 1px);padding-top:calc(.25rem + var(--bs-border-width))}.form-text{color:rgba(33,37,41,.75);color:var(--bs-secondary-color);font-size:.875em;margin-top:.25rem}.form-control{-webkit-appearance:none;appearance:none;background-clip:padding-box;background-color:#fff;background-color:var(--bs-body-bg);border:1px solid #dee2e6;border:var(--bs-border-width) solid var(--bs-border-color);border-radius:.375rem;border-radius:var(--bs-border-radius);color:#212529;color:var(--bs-body-color);display:block;font-size:1rem;font-weight:400;line-height:1.5;padding:.375rem .75rem;transition:border-color .15s ease-in-out,box-shadow .15s ease-in-out;width:100%}@media (prefers-reduced-motion:reduce){.form-control{transition:none}}.form-control[type=file]{overflow:hidden}.form-control[type=file]:not(:disabled):not([readonly]){cursor:pointer}.form-control:focus{background-color:#fff;background-color:var(--bs-body-bg);border-color:#86b7fe;box-shadow:0 0 0 .25rem rgba(13,110,253,.25);color:#212529;color:var(--bs-body-color);outline:0}.form-control::-webkit-date-and-time-value{height:1.5em;margin:0;min-width:85px}.form-control::-webkit-datetime-edit{display:block;padding:0}.form-control::-webkit-input-placeholder{color:rgba(33,37,41,.75);color:var(--bs-secondary-color);opacity:1}.form-control::placeholder{color:rgba(33,37,41,.75);color:var(--bs-secondary-color);opacity:1}.form-control:disabled{background-color:#e9ecef;background-color:var(--bs-secondary-bg);opacity:1}.form-control::-webkit-file-upload-button{-webkit-margin-end:.75rem;background-color:#f8f9fa;background-color:var(--bs-tertiary-bg);border:0 solid;border-color:inherit;border-inline-end-width:1px;border-inline-end-width:var(--bs-border-width);border-radius:0;color:#212529;color:var(--bs-body-color);margin:-.375rem -.75rem;margin-inline-end:.75rem;padding:.375rem .75rem;pointer-events:none;-webkit-transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out}.form-control::file-selector-button{-webkit-margin-end:.75rem;background-color:#f8f9fa;background-color:var(--bs-tertiary-bg);border:0 solid;border-color:inherit;border-inline-end-width:1px;border-inline-end-width:var(--bs-border-width);border-radius:0;color:#212529;color:var(--bs-body-color);margin:-.375rem -.75rem;margin-inline-end:.75rem;padding:.375rem .75rem;pointer-events:none;transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out}@media (prefers-reduced-motion:reduce){.form-control::-webkit-file-upload-button{-webkit-transition:none;transition:none}.form-control::file-selector-button{transition:none}}.form-control:hover:not(:disabled):not([readonly])::-webkit-file-upload-button{background-color:#e9ecef;background-color:var(--bs-secondary-bg)}.form-control:hover:not(:disabled):not([readonly])::file-selector-button{background-color:#e9ecef;background-color:var(--bs-secondary-bg)}.form-control-plaintext{background-color:initial;border:solid transparent;border-width:1px 0;border-width:var(--bs-border-width) 0;color:#212529;color:var(--bs-body-color);display:block;line-height:1.5;margin-bottom:0;padding:.375rem 0;width:100%}.form-control-plaintext:focus{outline:0}.form-control-plaintext.form-control-lg,.form-control-plaintext.form-control-sm{padding-left:0;padding-right:0}.form-control-sm{border-radius:.25rem;border-radius:var(--bs-border-radius-sm);font-size:.875rem;min-height:calc(1.5em + .5rem + 2px);min-height:calc(1.5em + .5rem + var(--bs-border-width)*2);padding:.25rem .5rem}.form-control-sm::-webkit-file-upload-button{-webkit-margin-end:.5rem;margin:-.25rem -.5rem;margin-inline-end:.5rem;padding:.25rem .5rem}.form-control-sm::file-selector-button{-webkit-margin-end:.5rem;margin:-.25rem -.5rem;margin-inline-end:.5rem;padding:.25rem .5rem}.form-control-lg{border-radius:.5rem;border-radius:var(--bs-border-radius-lg);font-size:1.25rem;min-height:calc(1.5em + 1rem + 2px);min-height:calc(1.5em + 1rem + var(--bs-border-width)*2);padding:.5rem 1rem}.form-control-lg::-webkit-file-upload-button{-webkit-margin-end:1rem;margin:-.5rem -1rem;margin-inline-end:1rem;padding:.5rem 1rem}.form-control-lg::file-selector-button{-webkit-margin-end:1rem;margin:-.5rem -1rem;margin-inline-end:1rem;padding:.5rem 1rem}textarea.form-control{min-height:calc(1.5em + .75rem + 2px);min-height:calc(1.5em + .75rem + var(--bs-border-width)*2)}textarea.form-control-sm{min-height:calc(1.5em + .5rem + 2px);min-height:calc(1.5em + .5rem + var(--bs-border-width)*2)}textarea.form-control-lg{min-height:calc(1.5em + 1rem + 2px);min-height:calc(1.5em + 1rem + var(--bs-border-width)*2)}.form-control-color{height:calc(1.5em + .75rem + 2px);height:calc(1.5em + .75rem + var(--bs-border-width)*2);padding:.375rem;width:3rem}.form-control-color:not(:disabled):not([readonly]){cursor:pointer}.form-control-color::-moz-color-swatch{border:0!important;border-radius:.375rem;border-radius:var(--bs-border-radius)}.form-control-color::-webkit-color-swatch{border:0!important;border-radius:.375rem;border-radius:var(--bs-border-radius)}.form-control-color.form-control-sm{height:calc(1.5em + .5rem + 2px);height:calc(1.5em + .5rem + var(--bs-border-width)*2)}.form-control-color.form-control-lg{height:calc(1.5em + 1rem + 2px);height:calc(1.5em + 1rem + var(--bs-border-width)*2)}.form-select{--bs-form-select-bg-img:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3E%3Cpath fill='none' stroke='%23343a40' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' d='m2 5 6 6 6-6'/%3E%3C/svg%3E");-webkit-appearance:none;appearance:none;background-color:#fff;background-color:var(--bs-body-bg);background-image:var(--bs-form-select-bg-img),none;background-image:var(--bs-form-select-bg-img),var(--bs-form-select-bg-icon,none);background-position:right .75rem center;background-repeat:no-repeat;background-size:16px 12px;border:1px solid #dee2e6;border:var(--bs-border-width) solid var(--bs-border-color);border-radius:.375rem;border-radius:var(--bs-border-radius);color:#212529;color:var(--bs-body-color);display:block;font-size:1rem;font-weight:400;line-height:1.5;padding:.375rem 2.25rem .375rem .75rem;transition:border-color .15s ease-in-out,box-shadow .15s ease-in-out;width:100%}@media (prefers-reduced-motion:reduce){.form-select{transition:none}}.form-select:focus{border-color:#86b7fe;box-shadow:0 0 0 .25rem rgba(13,110,253,.25);outline:0}.form-select[multiple],.form-select[size]:not([size="1"]){background-image:none;padding-right:.75rem}.form-select:disabled{background-color:#e9ecef;background-color:var(--bs-secondary-bg)}.form-select:-moz-focusring{color:transparent;text-shadow:0 0 0 #212529;text-shadow:0 0 0 var(--bs-body-color)}.form-select-sm{border-radius:.25rem;border-radius:var(--bs-border-radius-sm);font-size:.875rem;padding-bottom:.25rem;padding-left:.5rem;padding-top:.25rem}.form-select-lg{border-radius:.5rem;border-radius:var(--bs-border-radius-lg);font-size:1.25rem;padding-bottom:.5rem;padding-left:1rem;padding-top:.5rem}[data-bs-theme=dark] .form-select{--bs-form-select-bg-img:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3E%3Cpath fill='none' stroke='%23dee2e6' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' d='m2 5 6 6 6-6'/%3E%3C/svg%3E")}.form-check{display:block;margin-bottom:.125rem;min-height:1.5rem;padding-left:1.5em}.form-check .form-check-input{float:left;margin-left:-1.5em}.form-check-reverse{padding-left:0;padding-right:1.5em;text-align:right}.form-check-reverse .form-check-input{float:right;margin-left:0;margin-right:-1.5em}.form-check-input{--bs-form-check-bg:var(--bs-body-bg);-webkit-appearance:none;appearance:none;background-color:var(--bs-form-check-bg);background-image:var(--bs-form-check-bg-image);background-position:50%;background-repeat:no-repeat;background-size:contain;border:1px solid #dee2e6;border:var(--bs-border-width) solid var(--bs-border-color);flex-shrink:0;height:1em;margin-top:.25em;-webkit-print-color-adjust:exact;print-color-adjust:exact;vertical-align:top;width:1em}.form-check-input[type=checkbox]{border-radius:.25em}.form-check-input[type=radio]{border-radius:50%}.form-check-input:active{-webkit-filter:brightness(90%);filter:brightness(90%)}.form-check-input:focus{border-color:#86b7fe;box-shadow:0 0 0 .25rem rgba(13,110,253,.25);outline:0}.form-check-input:checked{background-color:#0d6efd;border-color:#0d6efd}.form-check-input:checked[type=checkbox]{--bs-form-check-bg-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 20 20'%3E%3Cpath fill='none' stroke='%23fff' stroke-linecap='round' stroke-linejoin='round' stroke-width='3' d='m6 10 3 3 6-6'/%3E%3C/svg%3E")}.form-check-input:checked[type=radio]{--bs-form-check-bg-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='-4 -4 8 8'%3E%3Ccircle r='2' fill='%23fff'/%3E%3C/svg%3E")}.form-check-input[type=checkbox]:indeterminate{--bs-form-check-bg-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 20 20'%3E%3Cpath fill='none' stroke='%23fff' stroke-linecap='round' stroke-linejoin='round' stroke-width='3' d='M6 10h8'/%3E%3C/svg%3E");background-color:#0d6efd;border-color:#0d6efd}.form-check-input:disabled{-webkit-filter:none;filter:none;opacity:.5;pointer-events:none}.form-check-input:disabled~.form-check-label,.form-check-input[disabled]~.form-check-label{cursor:default;opacity:.5}.form-switch{padding-left:2.5em}.form-switch .form-check-input{--bs-form-switch-bg:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='-4 -4 8 8'%3E%3Ccircle r='3' fill='rgba(0, 0, 0, 0.25)'/%3E%3C/svg%3E");background-image:var(--bs-form-switch-bg);background-position:0;border-radius:2em;margin-left:-2.5em;transition:background-position .15s ease-in-out;width:2em}@media (prefers-reduced-motion:reduce){.form-switch .form-check-input{transition:none}}.form-switch .form-check-input:focus{--bs-form-switch-bg:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='-4 -4 8 8'%3E%3Ccircle r='3' fill='%2386b7fe'/%3E%3C/svg%3E")}.form-switch .form-check-input:checked{--bs-form-switch-bg:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='-4 -4 8 8'%3E%3Ccircle r='3' fill='%23fff'/%3E%3C/svg%3E");background-position:100%}.form-switch.form-check-reverse{padding-left:0;padding-right:2.5em}.form-switch.form-check-reverse .form-check-input{margin-left:0;margin-right:-2.5em}.form-check-inline{display:inline-block;margin-right:1rem}.btn-check{clip:rect(0,0,0,0);pointer-events:none;position:absolute}.btn-check:disabled+.btn,.btn-check[disabled]+.btn{-webkit-filter:none;filter:none;opacity:.65;pointer-events:none}[data-bs-theme=dark] .form-switch .form-check-input:not(:checked):not(:focus){--bs-form-switch-bg:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='-4 -4 8 8'%3E%3Ccircle r='3' fill='rgba(255, 255, 255, 0.25)'/%3E%3C/svg%3E")}.form-range{-webkit-appearance:none;appearance:none;background-color:initial;height:1.5rem;padding:0;width:100%}.form-range:focus{outline:0}.form-range:focus::-webkit-slider-thumb{box-shadow:0 0 0 1px #fff,0 0 0 .25rem rgba(13,110,253,.25)}.form-range:focus::-moz-range-thumb{box-shadow:0 0 0 1px #fff,0 0 0 .25rem rgba(13,110,253,.25)}.form-range::-moz-focus-outer{border:0}.form-range::-webkit-slider-thumb{-webkit-appearance:none;appearance:none;background-color:#0d6efd;border:0;border-radius:1rem;height:1rem;margin-top:-.25rem;-webkit-transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;width:1rem}@media (prefers-reduced-motion:reduce){.form-range::-webkit-slider-thumb{-webkit-transition:none;transition:none}}.form-range::-webkit-slider-thumb:active{background-color:#b6d4fe}.form-range::-webkit-slider-runnable-track{background-color:#e9ecef;background-color:var(--bs-secondary-bg);border-color:transparent;border-radius:1rem;color:transparent;cursor:pointer;height:.5rem;width:100%}.form-range::-moz-range-thumb{appearance:none;background-color:#0d6efd;border:0;border-radius:1rem;height:1rem;-moz-transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;width:1rem}@media (prefers-reduced-motion:reduce){.form-range::-moz-range-thumb{-moz-transition:none;transition:none}}.form-range::-moz-range-thumb:active{background-color:#b6d4fe}.form-range::-moz-range-track{background-color:#e9ecef;background-color:var(--bs-secondary-bg);border-color:transparent;border-radius:1rem;color:transparent;cursor:pointer;height:.5rem;width:100%}.form-range:disabled{pointer-events:none}.form-range:disabled::-webkit-slider-thumb{background-color:rgba(33,37,41,.75);background-color:var(--bs-secondary-color)}.form-range:disabled::-moz-range-thumb{background-color:rgba(33,37,41,.75);background-color:var(--bs-secondary-color)}.form-floating{position:relative}.form-floating>.form-control,.form-floating>.form-control-plaintext,.form-floating>.form-select{height:calc(3.5rem + 2px);height:calc(3.5rem + var(--bs-border-width)*2);line-height:1.25;min-height:calc(3.5rem + 2px);min-height:calc(3.5rem + var(--bs-border-width)*2)}.form-floating>label{border:1px solid transparent;border:var(--bs-border-width) solid transparent;height:100%;left:0;overflow:hidden;padding:1rem .75rem;pointer-events:none;position:absolute;text-align:start;text-overflow:ellipsis;top:0;-webkit-transform-origin:0 0;transform-origin:0 0;transition:opacity .1s ease-in-out,-webkit-transform .1s ease-in-out;transition:opacity .1s ease-in-out,transform .1s ease-in-out;transition:opacity .1s ease-in-out,transform .1s ease-in-out,-webkit-transform .1s ease-in-out;white-space:nowrap;z-index:2}@media (prefers-reduced-motion:reduce){.form-floating>label{transition:none}}.form-floating>.form-control,.form-floating>.form-control-plaintext{padding:1rem .75rem}.form-floating>.form-control-plaintext::-webkit-input-placeholder,.form-floating>.form-control::-webkit-input-placeholder{color:transparent}.form-floating>.form-control-plaintext::placeholder,.form-floating>.form-control::placeholder{color:transparent}.form-floating>.form-control-plaintext:focus,.form-floating>.form-control-plaintext:not(:placeholder-shown),.form-floating>.form-control:focus,.form-floating>.form-control:not(:placeholder-shown){padding-bottom:.625rem;padding-top:1.625rem}.form-floating>.form-control-plaintext:-webkit-autofill,.form-floating>.form-control:-webkit-autofill{padding-bottom:.625rem;padding-top:1.625rem}.form-floating>.form-select{padding-bottom:.625rem;padding-top:1.625rem}.form-floating>.form-control-plaintext~label,.form-floating>.form-control:focus~label,.form-floating>.form-control:not(:placeholder-shown)~label,.form-floating>.form-select~label{color:rgba(33,37,41,.65);color:rgba(var(--bs-body-color-rgb),.65);-webkit-transform:scale(.85) translateY(-.5rem) translateX(.15rem);transform:scale(.85) translateY(-.5rem) translateX(.15rem)}.form-floating>.form-control-plaintext~label:after,.form-floating>.form-control:focus~label:after,.form-floating>.form-control:not(:placeholder-shown)~label:after,.form-floating>.form-select~label:after{background-color:#fff;background-color:var(--bs-body-bg);border-radius:.375rem;border-radius:var(--bs-border-radius);content:"";height:1.5em;inset:1rem .375rem;position:absolute;z-index:-1}.form-floating>.form-control:-webkit-autofill~label{color:rgba(33,37,41,.65);color:rgba(var(--bs-body-color-rgb),.65);-webkit-transform:scale(.85) translateY(-.5rem) translateX(.15rem);transform:scale(.85) translateY(-.5rem) translateX(.15rem)}.form-floating>.form-control-plaintext~label{border-width:1px 0;border-width:var(--bs-border-width) 0}.form-floating>.form-control:disabled~label,.form-floating>:disabled~label{color:#6c757d}.form-floating>.form-control:disabled~label:after,.form-floating>:disabled~label:after{background-color:#e9ecef;background-color:var(--bs-secondary-bg)}.input-group{align-items:stretch;display:flex;flex-wrap:wrap;position:relative;width:100%}.input-group>.form-control,.input-group>.form-floating,.input-group>.form-select{flex:1 1 auto;min-width:0;position:relative;width:1%}.input-group>.form-control:focus,.input-group>.form-floating:focus-within,.input-group>.form-select:focus{z-index:5}.input-group .btn{position:relative;z-index:2}.input-group .btn:focus{z-index:5}.input-group-text{align-items:center;background-color:#f8f9fa;background-color:var(--bs-tertiary-bg);border:1px solid #dee2e6;border:var(--bs-border-width) solid var(--bs-border-color);border-radius:.375rem;border-radius:var(--bs-border-radius);color:#212529;color:var(--bs-body-color);display:flex;font-size:1rem;font-weight:400;line-height:1.5;padding:.375rem .75rem;text-align:center;white-space:nowrap}.input-group-lg>.btn,.input-group-lg>.form-control,.input-group-lg>.form-select,.input-group-lg>.input-group-text{border-radius:.5rem;border-radius:var(--bs-border-radius-lg);font-size:1.25rem;padding:.5rem 1rem}.input-group-sm>.btn,.input-group-sm>.form-control,.input-group-sm>.form-select,.input-group-sm>.input-group-text{border-radius:.25rem;border-radius:var(--bs-border-radius-sm);font-size:.875rem;padding:.25rem .5rem}.input-group-lg>.form-select,.input-group-sm>.form-select{padding-right:3rem}.input-group.has-validation>.dropdown-toggle:nth-last-child(n+4),.input-group.has-validation>.form-floating:nth-last-child(n+3)>.form-control,.input-group.has-validation>.form-floating:nth-last-child(n+3)>.form-select,.input-group.has-validation>:nth-last-child(n+3):not(.dropdown-toggle):not(.dropdown-menu):not(.form-floating),.input-group:not(.has-validation)>.dropdown-toggle:nth-last-child(n+3),.input-group:not(.has-validation)>.form-floating:not(:last-child)>.form-control,.input-group:not(.has-validation)>.form-floating:not(:last-child)>.form-select,.input-group:not(.has-validation)>:not(:last-child):not(.dropdown-toggle):not(.dropdown-menu):not(.form-floating){border-bottom-right-radius:0;border-top-right-radius:0}.input-group>:not(:first-child):not(.dropdown-menu):not(.valid-tooltip):not(.valid-feedback):not(.invalid-tooltip):not(.invalid-feedback){border-bottom-left-radius:0;border-top-left-radius:0;margin-left:-1px;margin-left:calc(var(--bs-border-width)*-1)}.input-group>.form-floating:not(:first-child)>.form-control,.input-group>.form-floating:not(:first-child)>.form-select{border-bottom-left-radius:0;border-top-left-radius:0}.valid-feedback{color:#198754;color:var(--bs-form-valid-color);display:none;font-size:.875em;margin-top:.25rem;width:100%}.valid-tooltip{background-color:#198754;background-color:var(--bs-success);border-radius:.375rem;border-radius:var(--bs-border-radius);color:#fff;display:none;font-size:.875rem;margin-top:.1rem;max-width:100%;padding:.25rem .5rem;position:absolute;top:100%;z-index:5}.is-valid~.valid-feedback,.is-valid~.valid-tooltip,.was-validated :valid~.valid-feedback,.was-validated :valid~.valid-tooltip{display:block}.form-control.is-valid,.was-validated .form-control:valid{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 8 8'%3E%3Cpath fill='%23198754' d='M2.3 6.73.6 4.53c-.4-1.04.46-1.4 1.1-.8l1.1 1.4 3.4-3.8c.6-.63 1.6-.27 1.2.7l-4 4.6c-.43.5-.8.4-1.1.1z'/%3E%3C/svg%3E");background-position:right calc(.375em + .1875rem) center;background-repeat:no-repeat;background-size:calc(.75em + .375rem) calc(.75em + .375rem);border-color:#198754;border-color:var(--bs-form-valid-border-color);padding-right:calc(1.5em + .75rem)}.form-control.is-valid:focus,.was-validated .form-control:valid:focus{border-color:#198754;border-color:var(--bs-form-valid-border-color);box-shadow:0 0 0 .25rem rgba(25,135,84,.25);box-shadow:0 0 0 .25rem rgba(var(--bs-success-rgb),.25)}.was-validated textarea.form-control:valid,textarea.form-control.is-valid{background-position:top calc(.375em + .1875rem) right calc(.375em + .1875rem);padding-right:calc(1.5em + .75rem)}.form-select.is-valid,.was-validated .form-select:valid{border-color:#198754;border-color:var(--bs-form-valid-border-color)}.form-select.is-valid:not([multiple]):not([size]),.form-select.is-valid:not([multiple])[size="1"],.was-validated .form-select:valid:not([multiple]):not([size]),.was-validated .form-select:valid:not([multiple])[size="1"]{--bs-form-select-bg-icon:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 8 8'%3E%3Cpath fill='%23198754' d='M2.3 6.73.6 4.53c-.4-1.04.46-1.4 1.1-.8l1.1 1.4 3.4-3.8c.6-.63 1.6-.27 1.2.7l-4 4.6c-.43.5-.8.4-1.1.1z'/%3E%3C/svg%3E");background-position:right .75rem center,center right 2.25rem;background-size:16px 12px,calc(.75em + .375rem) calc(.75em + .375rem);padding-right:4.125rem}.form-select.is-valid:focus,.was-validated .form-select:valid:focus{border-color:#198754;border-color:var(--bs-form-valid-border-color);box-shadow:0 0 0 .25rem rgba(25,135,84,.25);box-shadow:0 0 0 .25rem rgba(var(--bs-success-rgb),.25)}.form-control-color.is-valid,.was-validated .form-control-color:valid{width:calc(3.75rem + 1.5em)}.form-check-input.is-valid,.was-validated .form-check-input:valid{border-color:#198754;border-color:var(--bs-form-valid-border-color)}.form-check-input.is-valid:checked,.was-validated .form-check-input:valid:checked{background-color:#198754;background-color:var(--bs-form-valid-color)}.form-check-input.is-valid:focus,.was-validated .form-check-input:valid:focus{box-shadow:0 0 0 .25rem rgba(25,135,84,.25);box-shadow:0 0 0 .25rem rgba(var(--bs-success-rgb),.25)}.form-check-input.is-valid~.form-check-label,.was-validated .form-check-input:valid~.form-check-label{color:#198754;color:var(--bs-form-valid-color)}.form-check-inline .form-check-input~.valid-feedback{margin-left:.5em}.input-group>.form-control:not(:focus).is-valid,.input-group>.form-floating:not(:focus-within).is-valid,.input-group>.form-select:not(:focus).is-valid,.was-validated .input-group>.form-control:not(:focus):valid,.was-validated .input-group>.form-floating:not(:focus-within):valid,.was-validated .input-group>.form-select:not(:focus):valid{z-index:3}.invalid-feedback{color:#dc3545;color:var(--bs-form-invalid-color);display:none;font-size:.875em;margin-top:.25rem;width:100%}.invalid-tooltip{background-color:#dc3545;background-color:var(--bs-danger);border-radius:.375rem;border-radius:var(--bs-border-radius);color:#fff;display:none;font-size:.875rem;margin-top:.1rem;max-width:100%;padding:.25rem .5rem;position:absolute;top:100%;z-index:5}.is-invalid~.invalid-feedback,.is-invalid~.invalid-tooltip,.was-validated :invalid~.invalid-feedback,.was-validated :invalid~.invalid-tooltip{display:block}.form-control.is-invalid,.was-validated .form-control:invalid{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' fill='none' stroke='%23dc3545'%3E%3Ccircle cx='6' cy='6' r='4.5'/%3E%3Cpath stroke-linejoin='round' d='M5.8 3.6h.4L6 6.5z'/%3E%3Ccircle cx='6' cy='8.2' r='.6' fill='%23dc3545' stroke='none'/%3E%3C/svg%3E");background-position:right calc(.375em + .1875rem) center;background-repeat:no-repeat;background-size:calc(.75em + .375rem) calc(.75em + .375rem);border-color:#dc3545;border-color:var(--bs-form-invalid-border-color);padding-right:calc(1.5em + .75rem)}.form-control.is-invalid:focus,.was-validated .form-control:invalid:focus{border-color:#dc3545;border-color:var(--bs-form-invalid-border-color);box-shadow:0 0 0 .25rem rgba(220,53,69,.25);box-shadow:0 0 0 .25rem rgba(var(--bs-danger-rgb),.25)}.was-validated textarea.form-control:invalid,textarea.form-control.is-invalid{background-position:top calc(.375em + .1875rem) right calc(.375em + .1875rem);padding-right:calc(1.5em + .75rem)}.form-select.is-invalid,.was-validated .form-select:invalid{border-color:#dc3545;border-color:var(--bs-form-invalid-border-color)}.form-select.is-invalid:not([multiple]):not([size]),.form-select.is-invalid:not([multiple])[size="1"],.was-validated .form-select:invalid:not([multiple]):not([size]),.was-validated .form-select:invalid:not([multiple])[size="1"]{--bs-form-select-bg-icon:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' fill='none' stroke='%23dc3545'%3E%3Ccircle cx='6' cy='6' r='4.5'/%3E%3Cpath stroke-linejoin='round' d='M5.8 3.6h.4L6 6.5z'/%3E%3Ccircle cx='6' cy='8.2' r='.6' fill='%23dc3545' stroke='none'/%3E%3C/svg%3E");background-position:right .75rem center,center right 2.25rem;background-size:16px 12px,calc(.75em + .375rem) calc(.75em + .375rem);padding-right:4.125rem}.form-select.is-invalid:focus,.was-validated .form-select:invalid:focus{border-color:#dc3545;border-color:var(--bs-form-invalid-border-color);box-shadow:0 0 0 .25rem rgba(220,53,69,.25);box-shadow:0 0 0 .25rem rgba(var(--bs-danger-rgb),.25)}.form-control-color.is-invalid,.was-validated .form-control-color:invalid{width:calc(3.75rem + 1.5em)}.form-check-input.is-invalid,.was-validated .form-check-input:invalid{border-color:#dc3545;border-color:var(--bs-form-invalid-border-color)}.form-check-input.is-invalid:checked,.was-validated .form-check-input:invalid:checked{background-color:#dc3545;background-color:var(--bs-form-invalid-color)}.form-check-input.is-invalid:focus,.was-validated .form-check-input:invalid:focus{box-shadow:0 0 0 .25rem rgba(220,53,69,.25);box-shadow:0 0 0 .25rem rgba(var(--bs-danger-rgb),.25)}.form-check-input.is-invalid~.form-check-label,.was-validated .form-check-input:invalid~.form-check-label{color:#dc3545;color:var(--bs-form-invalid-color)}.form-check-inline .form-check-input~.invalid-feedback{margin-left:.5em}.input-group>.form-control:not(:focus).is-invalid,.input-group>.form-floating:not(:focus-within).is-invalid,.input-group>.form-select:not(:focus).is-invalid,.was-validated .input-group>.form-control:not(:focus):invalid,.was-validated .input-group>.form-floating:not(:focus-within):invalid,.was-validated .input-group>.form-select:not(:focus):invalid{z-index:4}.btn{--bs-btn-padding-x:0.75rem;--bs-btn-padding-y:0.375rem;--bs-btn-font-family: ;--bs-btn-font-size:1rem;--bs-btn-font-weight:400;--bs-btn-line-height:1.5;--bs-btn-color:var(--bs-body-color);--bs-btn-bg:transparent;--bs-btn-border-width:var(--bs-border-width);--bs-btn-border-color:transparent;--bs-btn-border-radius:var(--bs-border-radius);--bs-btn-hover-border-color:transparent;--bs-btn-box-shadow:inset 0 1px 0 hsla(0,0%,100%,.15),0 1px 1px rgba(0,0,0,.075);--bs-btn-disabled-opacity:0.65;--bs-btn-focus-box-shadow:0 0 0 0.25rem rgba(var(--bs-btn-focus-shadow-rgb),.5);background-color:var(--bs-btn-bg);border:var(--bs-btn-border-width) solid var(--bs-btn-border-color);border-radius:var(--bs-btn-border-radius);color:var(--bs-btn-color);cursor:pointer;display:inline-block;font-family:var(--bs-btn-font-family);font-size:var(--bs-btn-font-size);font-weight:var(--bs-btn-font-weight);line-height:var(--bs-btn-line-height);padding:var(--bs-btn-padding-y) var(--bs-btn-padding-x);text-align:center;text-decoration:none;transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;-webkit-user-select:none;user-select:none;vertical-align:middle}@media (prefers-reduced-motion:reduce){.btn{transition:none}}.btn:hover{background-color:var(--bs-btn-hover-bg);border-color:var(--bs-btn-hover-border-color);color:var(--bs-btn-hover-color)}.btn-check+.btn:hover{background-color:var(--bs-btn-bg);border-color:var(--bs-btn-border-color);color:var(--bs-btn-color)}.btn:focus-visible{background-color:var(--bs-btn-hover-bg);border-color:var(--bs-btn-hover-border-color);box-shadow:var(--bs-btn-focus-box-shadow);color:var(--bs-btn-hover-color);outline:0}.btn-check:focus-visible+.btn{border-color:var(--bs-btn-hover-border-color);box-shadow:var(--bs-btn-focus-box-shadow);outline:0}.btn-check:checked+.btn,.btn.active,.btn.show,.btn:first-child:active,:not(.btn-check)+.btn:active{background-color:var(--bs-btn-active-bg);border-color:var(--bs-btn-active-border-color);color:var(--bs-btn-active-color)}.btn-check:checked+.btn:focus-visible,.btn.active:focus-visible,.btn.show:focus-visible,.btn:first-child:active:focus-visible,:not(.btn-check)+.btn:active:focus-visible{box-shadow:var(--bs-btn-focus-box-shadow)}.btn.disabled,.btn:disabled,fieldset:disabled .btn{background-color:var(--bs-btn-disabled-bg);border-color:var(--bs-btn-disabled-border-color);color:var(--bs-btn-disabled-color);opacity:var(--bs-btn-disabled-opacity);pointer-events:none}.btn-primary{--bs-btn-color:#fff;--bs-btn-bg:#0d6efd;--bs-btn-border-color:#0d6efd;--bs-btn-hover-color:#fff;--bs-btn-hover-bg:#0b5ed7;--bs-btn-hover-border-color:#0a58ca;--bs-btn-focus-shadow-rgb:49,132,253;--bs-btn-active-color:#fff;--bs-btn-active-bg:#0a58ca;--bs-btn-active-border-color:#0a53be;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#fff;--bs-btn-disabled-bg:#0d6efd;--bs-btn-disabled-border-color:#0d6efd}.btn-secondary{--bs-btn-color:#fff;--bs-btn-bg:#6c757d;--bs-btn-border-color:#6c757d;--bs-btn-hover-color:#fff;--bs-btn-hover-bg:#5c636a;--bs-btn-hover-border-color:#565e64;--bs-btn-focus-shadow-rgb:130,138,145;--bs-btn-active-color:#fff;--bs-btn-active-bg:#565e64;--bs-btn-active-border-color:#51585e;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#fff;--bs-btn-disabled-bg:#6c757d;--bs-btn-disabled-border-color:#6c757d}.btn-success{--bs-btn-color:#fff;--bs-btn-bg:#198754;--bs-btn-border-color:#198754;--bs-btn-hover-color:#fff;--bs-btn-hover-bg:#157347;--bs-btn-hover-border-color:#146c43;--bs-btn-focus-shadow-rgb:60,153,110;--bs-btn-active-color:#fff;--bs-btn-active-bg:#146c43;--bs-btn-active-border-color:#13653f;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#fff;--bs-btn-disabled-bg:#198754;--bs-btn-disabled-border-color:#198754}.btn-info{--bs-btn-color:#000;--bs-btn-bg:#0dcaf0;--bs-btn-border-color:#0dcaf0;--bs-btn-hover-color:#000;--bs-btn-hover-bg:#31d2f2;--bs-btn-hover-border-color:#25cff2;--bs-btn-focus-shadow-rgb:11,172,204;--bs-btn-active-color:#000;--bs-btn-active-bg:#3dd5f3;--bs-btn-active-border-color:#25cff2;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#000;--bs-btn-disabled-bg:#0dcaf0;--bs-btn-disabled-border-color:#0dcaf0}.btn-warning{--bs-btn-color:#000;--bs-btn-bg:#ffc107;--bs-btn-border-color:#ffc107;--bs-btn-hover-color:#000;--bs-btn-hover-bg:#ffca2c;--bs-btn-hover-border-color:#ffc720;--bs-btn-focus-shadow-rgb:217,164,6;--bs-btn-active-color:#000;--bs-btn-active-bg:#ffcd39;--bs-btn-active-border-color:#ffc720;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#000;--bs-btn-disabled-bg:#ffc107;--bs-btn-disabled-border-color:#ffc107}.btn-danger{--bs-btn-color:#fff;--bs-btn-bg:#dc3545;--bs-btn-border-color:#dc3545;--bs-btn-hover-color:#fff;--bs-btn-hover-bg:#bb2d3b;--bs-btn-hover-border-color:#b02a37;--bs-btn-focus-shadow-rgb:225,83,97;--bs-btn-active-color:#fff;--bs-btn-active-bg:#b02a37;--bs-btn-active-border-color:#a52834;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#fff;--bs-btn-disabled-bg:#dc3545;--bs-btn-disabled-border-color:#dc3545}.btn-light{--bs-btn-color:#000;--bs-btn-bg:#f8f9fa;--bs-btn-border-color:#f8f9fa;--bs-btn-hover-color:#000;--bs-btn-hover-bg:#d3d4d5;--bs-btn-hover-border-color:#c6c7c8;--bs-btn-focus-shadow-rgb:211,212,213;--bs-btn-active-color:#000;--bs-btn-active-bg:#c6c7c8;--bs-btn-active-border-color:#babbbc;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#000;--bs-btn-disabled-bg:#f8f9fa;--bs-btn-disabled-border-color:#f8f9fa}.btn-dark{--bs-btn-color:#fff;--bs-btn-bg:#212529;--bs-btn-border-color:#212529;--bs-btn-hover-color:#fff;--bs-btn-hover-bg:#424649;--bs-btn-hover-border-color:#373b3e;--bs-btn-focus-shadow-rgb:66,70,73;--bs-btn-active-color:#fff;--bs-btn-active-bg:#4d5154;--bs-btn-active-border-color:#373b3e;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#fff;--bs-btn-disabled-bg:#212529;--bs-btn-disabled-border-color:#212529}.btn-outline-primary{--bs-btn-color:#0d6efd;--bs-btn-border-color:#0d6efd;--bs-btn-hover-color:#fff;--bs-btn-hover-bg:#0d6efd;--bs-btn-hover-border-color:#0d6efd;--bs-btn-focus-shadow-rgb:13,110,253;--bs-btn-active-color:#fff;--bs-btn-active-bg:#0d6efd;--bs-btn-active-border-color:#0d6efd;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#0d6efd;--bs-btn-disabled-bg:transparent;--bs-btn-disabled-border-color:#0d6efd;--bs-gradient:none}.btn-outline-secondary{--bs-btn-color:#6c757d;--bs-btn-border-color:#6c757d;--bs-btn-hover-color:#fff;--bs-btn-hover-bg:#6c757d;--bs-btn-hover-border-color:#6c757d;--bs-btn-focus-shadow-rgb:108,117,125;--bs-btn-active-color:#fff;--bs-btn-active-bg:#6c757d;--bs-btn-active-border-color:#6c757d;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#6c757d;--bs-btn-disabled-bg:transparent;--bs-btn-disabled-border-color:#6c757d;--bs-gradient:none}.btn-outline-success{--bs-btn-color:#198754;--bs-btn-border-color:#198754;--bs-btn-hover-color:#fff;--bs-btn-hover-bg:#198754;--bs-btn-hover-border-color:#198754;--bs-btn-focus-shadow-rgb:25,135,84;--bs-btn-active-color:#fff;--bs-btn-active-bg:#198754;--bs-btn-active-border-color:#198754;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#198754;--bs-btn-disabled-bg:transparent;--bs-btn-disabled-border-color:#198754;--bs-gradient:none}.btn-outline-info{--bs-btn-color:#0dcaf0;--bs-btn-border-color:#0dcaf0;--bs-btn-hover-color:#000;--bs-btn-hover-bg:#0dcaf0;--bs-btn-hover-border-color:#0dcaf0;--bs-btn-focus-shadow-rgb:13,202,240;--bs-btn-active-color:#000;--bs-btn-active-bg:#0dcaf0;--bs-btn-active-border-color:#0dcaf0;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#0dcaf0;--bs-btn-disabled-bg:transparent;--bs-btn-disabled-border-color:#0dcaf0;--bs-gradient:none}.btn-outline-warning{--bs-btn-color:#ffc107;--bs-btn-border-color:#ffc107;--bs-btn-hover-color:#000;--bs-btn-hover-bg:#ffc107;--bs-btn-hover-border-color:#ffc107;--bs-btn-focus-shadow-rgb:255,193,7;--bs-btn-active-color:#000;--bs-btn-active-bg:#ffc107;--bs-btn-active-border-color:#ffc107;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#ffc107;--bs-btn-disabled-bg:transparent;--bs-btn-disabled-border-color:#ffc107;--bs-gradient:none}.btn-outline-danger{--bs-btn-color:#dc3545;--bs-btn-border-color:#dc3545;--bs-btn-hover-color:#fff;--bs-btn-hover-bg:#dc3545;--bs-btn-hover-border-color:#dc3545;--bs-btn-focus-shadow-rgb:220,53,69;--bs-btn-active-color:#fff;--bs-btn-active-bg:#dc3545;--bs-btn-active-border-color:#dc3545;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#dc3545;--bs-btn-disabled-bg:transparent;--bs-btn-disabled-border-color:#dc3545;--bs-gradient:none}.btn-outline-light{--bs-btn-color:#f8f9fa;--bs-btn-border-color:#f8f9fa;--bs-btn-hover-color:#000;--bs-btn-hover-bg:#f8f9fa;--bs-btn-hover-border-color:#f8f9fa;--bs-btn-focus-shadow-rgb:248,249,250;--bs-btn-active-color:#000;--bs-btn-active-bg:#f8f9fa;--bs-btn-active-border-color:#f8f9fa;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#f8f9fa;--bs-btn-disabled-bg:transparent;--bs-btn-disabled-border-color:#f8f9fa;--bs-gradient:none}.btn-outline-dark{--bs-btn-color:#212529;--bs-btn-border-color:#212529;--bs-btn-hover-color:#fff;--bs-btn-hover-bg:#212529;--bs-btn-hover-border-color:#212529;--bs-btn-focus-shadow-rgb:33,37,41;--bs-btn-active-color:#fff;--bs-btn-active-bg:#212529;--bs-btn-active-border-color:#212529;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#212529;--bs-btn-disabled-bg:transparent;--bs-btn-disabled-border-color:#212529;--bs-gradient:none}.btn-link{--bs-btn-font-weight:400;--bs-btn-color:var(--bs-link-color);--bs-btn-bg:transparent;--bs-btn-border-color:transparent;--bs-btn-hover-color:var(--bs-link-hover-color);--bs-btn-hover-border-color:transparent;--bs-btn-active-color:var(--bs-link-hover-color);--bs-btn-active-border-color:transparent;--bs-btn-disabled-color:#6c757d;--bs-btn-disabled-border-color:transparent;--bs-btn-box-shadow:0 0 0 #000;--bs-btn-focus-shadow-rgb:49,132,253;text-decoration:underline}.btn-link:focus-visible{color:var(--bs-btn-color)}.btn-link:hover{color:var(--bs-btn-hover-color)}.btn-group-lg>.btn,.btn-lg{--bs-btn-padding-y:0.5rem;--bs-btn-padding-x:1rem;--bs-btn-font-size:1.25rem;--bs-btn-border-radius:var(--bs-border-radius-lg)}.btn-group-sm>.btn,.btn-sm{--bs-btn-padding-y:0.25rem;--bs-btn-padding-x:0.5rem;--bs-btn-font-size:0.875rem;--bs-btn-border-radius:var(--bs-border-radius-sm)}.fade{transition:opacity .15s linear}@media (prefers-reduced-motion:reduce){.fade{transition:none}}.fade:not(.show){opacity:0}.collapse:not(.show){display:none}.collapsing{height:0;overflow:hidden;transition:height .35s ease}@media (prefers-reduced-motion:reduce){.collapsing{transition:none}}.collapsing.collapse-horizontal{height:auto;transition:width .35s ease;width:0}@media (prefers-reduced-motion:reduce){.collapsing.collapse-horizontal{transition:none}}.dropdown,.dropdown-center,.dropend,.dropstart,.dropup,.dropup-center{position:relative}.dropdown-toggle{white-space:nowrap}.dropdown-toggle:after{border-bottom:0;border-left:.3em solid transparent;border-right:.3em solid transparent;border-top:.3em solid;content:"";display:inline-block;margin-left:.255em;vertical-align:.255em}.dropdown-toggle:empty:after{margin-left:0}.dropdown-menu{--bs-dropdown-zindex:1000;--bs-dropdown-min-width:10rem;--bs-dropdown-padding-x:0;--bs-dropdown-padding-y:0.5rem;--bs-dropdown-spacer:0.125rem;--bs-dropdown-font-size:1rem;--bs-dropdown-color:var(--bs-body-color);--bs-dropdown-bg:var(--bs-body-bg);--bs-dropdown-border-color:var(--bs-border-color-translucent);--bs-dropdown-border-radius:var(--bs-border-radius);--bs-dropdown-border-width:var(--bs-border-width);--bs-dropdown-inner-border-radius:calc(var(--bs-border-radius) - var(--bs-border-width));--bs-dropdown-divider-bg:var(--bs-border-color-translucent);--bs-dropdown-divider-margin-y:0.5rem;--bs-dropdown-box-shadow:var(--bs-box-shadow);--bs-dropdown-link-color:var(--bs-body-color);--bs-dropdown-link-hover-color:var(--bs-body-color);--bs-dropdown-link-hover-bg:var(--bs-tertiary-bg);--bs-dropdown-link-active-color:#fff;--bs-dropdown-link-active-bg:#0d6efd;--bs-dropdown-link-disabled-color:var(--bs-tertiary-color);--bs-dropdown-item-padding-x:1rem;--bs-dropdown-item-padding-y:0.25rem;--bs-dropdown-header-color:#6c757d;--bs-dropdown-header-padding-x:1rem;--bs-dropdown-header-padding-y:0.5rem;background-clip:padding-box;background-color:var(--bs-dropdown-bg);border:var(--bs-dropdown-border-width) solid var(--bs-dropdown-border-color);border-radius:var(--bs-dropdown-border-radius);color:var(--bs-dropdown-color);display:none;font-size:var(--bs-dropdown-font-size);list-style:none;margin:0;min-width:var(--bs-dropdown-min-width);padding:var(--bs-dropdown-padding-y) var(--bs-dropdown-padding-x);position:absolute;text-align:left;z-index:var(--bs-dropdown-zindex)}.dropdown-menu[data-bs-popper]{left:0;margin-top:var(--bs-dropdown-spacer);top:100%}.dropdown-menu-start{--bs-position:start}.dropdown-menu-start[data-bs-popper]{left:0;right:auto}.dropdown-menu-end{--bs-position:end}.dropdown-menu-end[data-bs-popper]{left:auto;right:0}@media (min-width:576px){.dropdown-menu-sm-start{--bs-position:start}.dropdown-menu-sm-start[data-bs-popper]{left:0;right:auto}.dropdown-menu-sm-end{--bs-position:end}.dropdown-menu-sm-end[data-bs-popper]{left:auto;right:0}}@media (min-width:768px){.dropdown-menu-md-start{--bs-position:start}.dropdown-menu-md-start[data-bs-popper]{left:0;right:auto}.dropdown-menu-md-end{--bs-position:end}.dropdown-menu-md-end[data-bs-popper]{left:auto;right:0}}@media (min-width:992px){.dropdown-menu-lg-start{--bs-position:start}.dropdown-menu-lg-start[data-bs-popper]{left:0;right:auto}.dropdown-menu-lg-end{--bs-position:end}.dropdown-menu-lg-end[data-bs-popper]{left:auto;right:0}}@media (min-width:1200px){.dropdown-menu-xl-start{--bs-position:start}.dropdown-menu-xl-start[data-bs-popper]{left:0;right:auto}.dropdown-menu-xl-end{--bs-position:end}.dropdown-menu-xl-end[data-bs-popper]{left:auto;right:0}}@media (min-width:1400px){.dropdown-menu-xxl-start{--bs-position:start}.dropdown-menu-xxl-start[data-bs-popper]{left:0;right:auto}.dropdown-menu-xxl-end{--bs-position:end}.dropdown-menu-xxl-end[data-bs-popper]{left:auto;right:0}}.dropup .dropdown-menu[data-bs-popper]{bottom:100%;margin-bottom:var(--bs-dropdown-spacer);margin-top:0;top:auto}.dropup .dropdown-toggle:after{border-bottom:.3em solid;border-left:.3em solid transparent;border-right:.3em solid transparent;border-top:0;content:"";display:inline-block;margin-left:.255em;vertical-align:.255em}.dropup .dropdown-toggle:empty:after{margin-left:0}.dropend .dropdown-menu[data-bs-popper]{left:100%;margin-left:var(--bs-dropdown-spacer);margin-top:0;right:auto;top:0}.dropend .dropdown-toggle:after{border-bottom:.3em solid transparent;border-left:.3em solid;border-right:0;border-top:.3em solid transparent;content:"";display:inline-block;margin-left:.255em;vertical-align:.255em}.dropend .dropdown-toggle:empty:after{margin-left:0}.dropend .dropdown-toggle:after{vertical-align:0}.dropstart .dropdown-menu[data-bs-popper]{left:auto;margin-right:var(--bs-dropdown-spacer);margin-top:0;right:100%;top:0}.dropstart .dropdown-toggle:after{content:"";display:inline-block;display:none;margin-left:.255em;vertical-align:.255em}.dropstart .dropdown-toggle:before{border-bottom:.3em solid transparent;border-right:.3em solid;border-top:.3em solid transparent;content:"";display:inline-block;margin-right:.255em;vertical-align:.255em}.dropstart .dropdown-toggle:empty:after{margin-left:0}.dropstart .dropdown-toggle:before{vertical-align:0}.dropdown-divider{border-top:1px solid var(--bs-dropdown-divider-bg);height:0;margin:var(--bs-dropdown-divider-margin-y) 0;opacity:1;overflow:hidden}.dropdown-item{background-color:initial;border:0;border-radius:0;border-radius:var(--bs-dropdown-item-border-radius,0);clear:both;color:var(--bs-dropdown-link-color);display:block;font-weight:400;padding:var(--bs-dropdown-item-padding-y) var(--bs-dropdown-item-padding-x);text-align:inherit;text-decoration:none;white-space:nowrap;width:100%}.dropdown-item:focus,.dropdown-item:hover{background-color:var(--bs-dropdown-link-hover-bg);color:var(--bs-dropdown-link-hover-color)}.dropdown-item.active,.dropdown-item:active{background-color:var(--bs-dropdown-link-active-bg);color:var(--bs-dropdown-link-active-color);text-decoration:none}.dropdown-item.disabled,.dropdown-item:disabled{background-color:initial;color:var(--bs-dropdown-link-disabled-color);pointer-events:none}.dropdown-menu.show{display:block}.dropdown-header{color:var(--bs-dropdown-header-color);display:block;font-size:.875rem;margin-bottom:0;padding:var(--bs-dropdown-header-padding-y) var(--bs-dropdown-header-padding-x);white-space:nowrap}.dropdown-item-text{color:var(--bs-dropdown-link-color);display:block;padding:var(--bs-dropdown-item-padding-y) var(--bs-dropdown-item-padding-x)}.dropdown-menu-dark{--bs-dropdown-color:#dee2e6;--bs-dropdown-bg:#343a40;--bs-dropdown-border-color:var(--bs-border-color-translucent);--bs-dropdown-box-shadow: ;--bs-dropdown-link-color:#dee2e6;--bs-dropdown-link-hover-color:#fff;--bs-dropdown-divider-bg:var(--bs-border-color-translucent);--bs-dropdown-link-hover-bg:hsla(0,0%,100%,.15);--bs-dropdown-link-active-color:#fff;--bs-dropdown-link-active-bg:#0d6efd;--bs-dropdown-link-disabled-color:#adb5bd;--bs-dropdown-header-color:#adb5bd}.btn-group,.btn-group-vertical{display:inline-flex;position:relative;vertical-align:middle}.btn-group-vertical>.btn,.btn-group>.btn{flex:1 1 auto;position:relative}.btn-group-vertical>.btn-check:checked+.btn,.btn-group-vertical>.btn-check:focus+.btn,.btn-group-vertical>.btn.active,.btn-group-vertical>.btn:active,.btn-group-vertical>.btn:focus,.btn-group-vertical>.btn:hover,.btn-group>.btn-check:checked+.btn,.btn-group>.btn-check:focus+.btn,.btn-group>.btn.active,.btn-group>.btn:active,.btn-group>.btn:focus,.btn-group>.btn:hover{z-index:1}.btn-toolbar{display:flex;flex-wrap:wrap;justify-content:flex-start}.btn-toolbar .input-group{width:auto}.btn-group{border-radius:.375rem;border-radius:var(--bs-border-radius)}.btn-group>.btn-group:not(:first-child),.btn-group>:not(.btn-check:first-child)+.btn{margin-left:-1px;margin-left:calc(var(--bs-border-width)*-1)}.btn-group>.btn-group:not(:last-child)>.btn,.btn-group>.btn.dropdown-toggle-split:first-child,.btn-group>.btn:not(:last-child):not(.dropdown-toggle){border-bottom-right-radius:0;border-top-right-radius:0}.btn-group>.btn-group:not(:first-child)>.btn,.btn-group>.btn:nth-child(n+3),.btn-group>:not(.btn-check)+.btn{border-bottom-left-radius:0;border-top-left-radius:0}.dropdown-toggle-split{padding-left:.5625rem;padding-right:.5625rem}.dropdown-toggle-split:after,.dropend .dropdown-toggle-split:after,.dropup .dropdown-toggle-split:after{margin-left:0}.dropstart .dropdown-toggle-split:before{margin-right:0}.btn-group-sm>.btn+.dropdown-toggle-split,.btn-sm+.dropdown-toggle-split{padding-left:.375rem;padding-right:.375rem}.btn-group-lg>.btn+.dropdown-toggle-split,.btn-lg+.dropdown-toggle-split{padding-left:.75rem;padding-right:.75rem}.btn-group-vertical{align-items:flex-start;flex-direction:column;justify-content:center}.btn-group-vertical>.btn,.btn-group-vertical>.btn-group{width:100%}.btn-group-vertical>.btn-group:not(:first-child),.btn-group-vertical>.btn:not(:first-child){margin-top:-1px;margin-top:calc(var(--bs-border-width)*-1)}.btn-group-vertical>.btn-group:not(:last-child)>.btn,.btn-group-vertical>.btn:not(:last-child):not(.dropdown-toggle){border-bottom-left-radius:0;border-bottom-right-radius:0}.btn-group-vertical>.btn-group:not(:first-child)>.btn,.btn-group-vertical>.btn~.btn{border-top-left-radius:0;border-top-right-radius:0}.nav{--bs-nav-link-padding-x:1rem;--bs-nav-link-padding-y:0.5rem;--bs-nav-link-font-weight: ;--bs-nav-link-color:var(--bs-link-color);--bs-nav-link-hover-color:var(--bs-link-hover-color);--bs-nav-link-disabled-color:var(--bs-secondary-color);display:flex;flex-wrap:wrap;list-style:none;margin-bottom:0;padding-left:0}.nav-link{background:none;border:0;color:var(--bs-nav-link-color);display:block;font-size:var(--bs-nav-link-font-size);font-weight:var(--bs-nav-link-font-weight);padding:var(--bs-nav-link-padding-y) var(--bs-nav-link-padding-x);text-decoration:none;transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out}@media (prefers-reduced-motion:reduce){.nav-link{transition:none}}.nav-link:focus,.nav-link:hover{color:var(--bs-nav-link-hover-color)}.nav-link:focus-visible{box-shadow:0 0 0 .25rem rgba(13,110,253,.25);outline:0}.nav-link.disabled,.nav-link:disabled{color:var(--bs-nav-link-disabled-color);cursor:default;pointer-events:none}.nav-tabs{--bs-nav-tabs-border-width:var(--bs-border-width);--bs-nav-tabs-border-color:var(--bs-border-color);--bs-nav-tabs-border-radius:var(--bs-border-radius);--bs-nav-tabs-link-hover-border-color:var(--bs-secondary-bg) var(--bs-secondary-bg) var(--bs-border-color);--bs-nav-tabs-link-active-color:var(--bs-emphasis-color);--bs-nav-tabs-link-active-bg:var(--bs-body-bg);--bs-nav-tabs-link-active-border-color:var(--bs-border-color) var(--bs-border-color) var(--bs-body-bg);border-bottom:var(--bs-nav-tabs-border-width) solid var(--bs-nav-tabs-border-color)}.nav-tabs .nav-link{border:var(--bs-nav-tabs-border-width) solid transparent;border-top-left-radius:var(--bs-nav-tabs-border-radius);border-top-right-radius:var(--bs-nav-tabs-border-radius);margin-bottom:calc(var(--bs-nav-tabs-border-width)*-1)}.nav-tabs .nav-link:focus,.nav-tabs .nav-link:hover{border-color:var(--bs-nav-tabs-link-hover-border-color);isolation:isolate}.nav-tabs .nav-item.show .nav-link,.nav-tabs .nav-link.active{background-color:var(--bs-nav-tabs-link-active-bg);border-color:var(--bs-nav-tabs-link-active-border-color);color:var(--bs-nav-tabs-link-active-color)}.nav-tabs .dropdown-menu{border-top-left-radius:0;border-top-right-radius:0;margin-top:calc(var(--bs-nav-tabs-border-width)*-1)}.nav-pills{--bs-nav-pills-border-radius:var(--bs-border-radius);--bs-nav-pills-link-active-color:#fff;--bs-nav-pills-link-active-bg:#0d6efd}.nav-pills .nav-link{border-radius:var(--bs-nav-pills-border-radius)}.nav-pills .nav-link.active,.nav-pills .show>.nav-link{background-color:var(--bs-nav-pills-link-active-bg);color:var(--bs-nav-pills-link-active-color)}.nav-underline{--bs-nav-underline-gap:1rem;--bs-nav-underline-border-width:0.125rem;--bs-nav-underline-link-active-color:var(--bs-emphasis-color);gap:var(--bs-nav-underline-gap)}.nav-underline .nav-link{border-bottom:var(--bs-nav-underline-border-width) solid transparent;padding-left:0;padding-right:0}.nav-underline .nav-link:focus,.nav-underline .nav-link:hover{border-bottom-color:initial}.nav-underline .nav-link.active,.nav-underline .show>.nav-link{border-bottom-color:initial;color:var(--bs-nav-underline-link-active-color);font-weight:700}.nav-fill .nav-item,.nav-fill>.nav-link{flex:1 1 auto;text-align:center}.nav-justified .nav-item,.nav-justified>.nav-link{flex-basis:0;flex-grow:1;text-align:center}.nav-fill .nav-item .nav-link,.nav-justified .nav-item .nav-link{width:100%}.tab-content>.tab-pane{display:none}.tab-content>.active{display:block}.navbar{--bs-navbar-padding-x:0;--bs-navbar-padding-y:0.5rem;--bs-navbar-color:rgba(var(--bs-emphasis-color-rgb),0.65);--bs-navbar-hover-color:rgba(var(--bs-emphasis-color-rgb),0.8);--bs-navbar-disabled-color:rgba(var(--bs-emphasis-color-rgb),0.3);--bs-navbar-active-color:rgba(var(--bs-emphasis-color-rgb),1);--bs-navbar-brand-padding-y:0.3125rem;--bs-navbar-brand-margin-end:1rem;--bs-navbar-brand-font-size:1.25rem;--bs-navbar-brand-color:rgba(var(--bs-emphasis-color-rgb),1);--bs-navbar-brand-hover-color:rgba(var(--bs-emphasis-color-rgb),1);--bs-navbar-nav-link-padding-x:0.5rem;--bs-navbar-toggler-padding-y:0.25rem;--bs-navbar-toggler-padding-x:0.75rem;--bs-navbar-toggler-font-size:1.25rem;--bs-navbar-toggler-icon-bg:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 30 30'%3E%3Cpath stroke='rgba(33, 37, 41, 0.75)' stroke-linecap='round' stroke-miterlimit='10' stroke-width='2' d='M4 7h22M4 15h22M4 23h22'/%3E%3C/svg%3E");--bs-navbar-toggler-border-color:rgba(var(--bs-emphasis-color-rgb),0.15);--bs-navbar-toggler-border-radius:var(--bs-border-radius);--bs-navbar-toggler-focus-width:0.25rem;--bs-navbar-toggler-transition:box-shadow 0.15s ease-in-out;align-items:center;display:flex;flex-wrap:wrap;justify-content:space-between;padding:var(--bs-navbar-padding-y) var(--bs-navbar-padding-x);position:relative}.navbar>.container,.navbar>.container-fluid,.navbar>.container-lg,.navbar>.container-md,.navbar>.container-sm,.navbar>.container-xl,.navbar>.container-xxl{align-items:center;display:flex;flex-wrap:inherit;justify-content:space-between}.navbar-brand{color:var(--bs-navbar-brand-color);font-size:var(--bs-navbar-brand-font-size);margin-right:var(--bs-navbar-brand-margin-end);padding-bottom:var(--bs-navbar-brand-padding-y);padding-top:var(--bs-navbar-brand-padding-y);text-decoration:none;white-space:nowrap}.navbar-brand:focus,.navbar-brand:hover{color:var(--bs-navbar-brand-hover-color)}.navbar-nav{--bs-nav-link-padding-x:0;--bs-nav-link-padding-y:0.5rem;--bs-nav-link-font-weight: ;--bs-nav-link-color:var(--bs-navbar-color);--bs-nav-link-hover-color:var(--bs-navbar-hover-color);--bs-nav-link-disabled-color:var(--bs-navbar-disabled-color);display:flex;flex-direction:column;list-style:none;margin-bottom:0;padding-left:0}.navbar-nav .nav-link.active,.navbar-nav .nav-link.show{color:var(--bs-navbar-active-color)}.navbar-nav .dropdown-menu{position:static}.navbar-text{color:var(--bs-navbar-color);padding-bottom:.5rem;padding-top:.5rem}.navbar-text a,.navbar-text a:focus,.navbar-text a:hover{color:var(--bs-navbar-active-color)}.navbar-collapse{align-items:center;flex-basis:100%;flex-grow:1}.navbar-toggler{background-color:initial;border:var(--bs-border-width) solid var(--bs-navbar-toggler-border-color);border-radius:var(--bs-navbar-toggler-border-radius);color:var(--bs-navbar-color);font-size:var(--bs-navbar-toggler-font-size);line-height:1;padding:var(--bs-navbar-toggler-padding-y) var(--bs-navbar-toggler-padding-x);transition:var(--bs-navbar-toggler-transition)}@media (prefers-reduced-motion:reduce){.navbar-toggler{transition:none}}.navbar-toggler:hover{text-decoration:none}.navbar-toggler:focus{box-shadow:0 0 0 var(--bs-navbar-toggler-focus-width);outline:0;text-decoration:none}.navbar-toggler-icon{background-image:var(--bs-navbar-toggler-icon-bg);background-position:50%;background-repeat:no-repeat;background-size:100%;display:inline-block;height:1.5em;vertical-align:middle;width:1.5em}.navbar-nav-scroll{max-height:75vh;max-height:var(--bs-scroll-height,75vh);overflow-y:auto}@media (min-width:576px){.navbar-expand-sm{flex-wrap:nowrap;justify-content:flex-start}.navbar-expand-sm .navbar-nav{flex-direction:row}.navbar-expand-sm .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-sm .navbar-nav .nav-link{padding-left:var(--bs-navbar-nav-link-padding-x);padding-right:var(--bs-navbar-nav-link-padding-x)}.navbar-expand-sm .navbar-nav-scroll{overflow:visible}.navbar-expand-sm .navbar-collapse{display:flex!important;flex-basis:auto}.navbar-expand-sm .navbar-toggler{display:none}.navbar-expand-sm .offcanvas{background-color:initial!important;border:0!important;flex-grow:1;height:auto!important;position:static;-webkit-transform:none!important;transform:none!important;transition:none;visibility:visible!important;width:auto!important;z-index:auto}.navbar-expand-sm .offcanvas .offcanvas-header{display:none}.navbar-expand-sm .offcanvas .offcanvas-body{display:flex;flex-grow:0;overflow-y:visible;padding:0}}@media (min-width:768px){.navbar-expand-md{flex-wrap:nowrap;justify-content:flex-start}.navbar-expand-md .navbar-nav{flex-direction:row}.navbar-expand-md .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-md .navbar-nav .nav-link{padding-left:var(--bs-navbar-nav-link-padding-x);padding-right:var(--bs-navbar-nav-link-padding-x)}.navbar-expand-md .navbar-nav-scroll{overflow:visible}.navbar-expand-md .navbar-collapse{display:flex!important;flex-basis:auto}.navbar-expand-md .navbar-toggler{display:none}.navbar-expand-md .offcanvas{background-color:initial!important;border:0!important;flex-grow:1;height:auto!important;position:static;-webkit-transform:none!important;transform:none!important;transition:none;visibility:visible!important;width:auto!important;z-index:auto}.navbar-expand-md .offcanvas .offcanvas-header{display:none}.navbar-expand-md .offcanvas .offcanvas-body{display:flex;flex-grow:0;overflow-y:visible;padding:0}}@media (min-width:992px){.navbar-expand-lg{flex-wrap:nowrap;justify-content:flex-start}.navbar-expand-lg .navbar-nav{flex-direction:row}.navbar-expand-lg .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-lg .navbar-nav .nav-link{padding-left:var(--bs-navbar-nav-link-padding-x);padding-right:var(--bs-navbar-nav-link-padding-x)}.navbar-expand-lg .navbar-nav-scroll{overflow:visible}.navbar-expand-lg .navbar-collapse{display:flex!important;flex-basis:auto}.navbar-expand-lg .navbar-toggler{display:none}.navbar-expand-lg .offcanvas{background-color:initial!important;border:0!important;flex-grow:1;height:auto!important;position:static;-webkit-transform:none!important;transform:none!important;transition:none;visibility:visible!important;width:auto!important;z-index:auto}.navbar-expand-lg .offcanvas .offcanvas-header{display:none}.navbar-expand-lg .offcanvas .offcanvas-body{display:flex;flex-grow:0;overflow-y:visible;padding:0}}@media (min-width:1200px){.navbar-expand-xl{flex-wrap:nowrap;justify-content:flex-start}.navbar-expand-xl .navbar-nav{flex-direction:row}.navbar-expand-xl .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-xl .navbar-nav .nav-link{padding-left:var(--bs-navbar-nav-link-padding-x);padding-right:var(--bs-navbar-nav-link-padding-x)}.navbar-expand-xl .navbar-nav-scroll{overflow:visible}.navbar-expand-xl .navbar-collapse{display:flex!important;flex-basis:auto}.navbar-expand-xl .navbar-toggler{display:none}.navbar-expand-xl .offcanvas{background-color:initial!important;border:0!important;flex-grow:1;height:auto!important;position:static;-webkit-transform:none!important;transform:none!important;transition:none;visibility:visible!important;width:auto!important;z-index:auto}.navbar-expand-xl .offcanvas .offcanvas-header{display:none}.navbar-expand-xl .offcanvas .offcanvas-body{display:flex;flex-grow:0;overflow-y:visible;padding:0}}@media (min-width:1400px){.navbar-expand-xxl{flex-wrap:nowrap;justify-content:flex-start}.navbar-expand-xxl .navbar-nav{flex-direction:row}.navbar-expand-xxl .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-xxl .navbar-nav .nav-link{padding-left:var(--bs-navbar-nav-link-padding-x);padding-right:var(--bs-navbar-nav-link-padding-x)}.navbar-expand-xxl .navbar-nav-scroll{overflow:visible}.navbar-expand-xxl .navbar-collapse{display:flex!important;flex-basis:auto}.navbar-expand-xxl .navbar-toggler{display:none}.navbar-expand-xxl .offcanvas{background-color:initial!important;border:0!important;flex-grow:1;height:auto!important;position:static;-webkit-transform:none!important;transform:none!important;transition:none;visibility:visible!important;width:auto!important;z-index:auto}.navbar-expand-xxl .offcanvas .offcanvas-header{display:none}.navbar-expand-xxl .offcanvas .offcanvas-body{display:flex;flex-grow:0;overflow-y:visible;padding:0}}.navbar-expand{flex-wrap:nowrap;justify-content:flex-start}.navbar-expand .navbar-nav{flex-direction:row}.navbar-expand .navbar-nav .dropdown-menu{position:absolute}.navbar-expand .navbar-nav .nav-link{padding-left:var(--bs-navbar-nav-link-padding-x);padding-right:var(--bs-navbar-nav-link-padding-x)}.navbar-expand .navbar-nav-scroll{overflow:visible}.navbar-expand .navbar-collapse{display:flex!important;flex-basis:auto}.navbar-expand .navbar-toggler{display:none}.navbar-expand .offcanvas{background-color:initial!important;border:0!important;flex-grow:1;height:auto!important;position:static;-webkit-transform:none!important;transform:none!important;transition:none;visibility:visible!important;width:auto!important;z-index:auto}.navbar-expand .offcanvas .offcanvas-header{display:none}.navbar-expand .offcanvas .offcanvas-body{display:flex;flex-grow:0;overflow-y:visible;padding:0}.navbar-dark,.navbar[data-bs-theme=dark]{--bs-navbar-color:hsla(0,0%,100%,.55);--bs-navbar-hover-color:hsla(0,0%,100%,.75);--bs-navbar-disabled-color:hsla(0,0%,100%,.25);--bs-navbar-active-color:#fff;--bs-navbar-brand-color:#fff;--bs-navbar-brand-hover-color:#fff;--bs-navbar-toggler-border-color:hsla(0,0%,100%,.1)}.navbar-dark,.navbar[data-bs-theme=dark],[data-bs-theme=dark] .navbar-toggler-icon{--bs-navbar-toggler-icon-bg:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 30 30'%3E%3Cpath stroke='rgba(255, 255, 255, 0.55)' stroke-linecap='round' stroke-miterlimit='10' stroke-width='2' d='M4 7h22M4 15h22M4 23h22'/%3E%3C/svg%3E")}.card{--bs-card-spacer-y:1rem;--bs-card-spacer-x:1rem;--bs-card-title-spacer-y:0.5rem;--bs-card-title-color: ;--bs-card-subtitle-color: ;--bs-card-border-width:var(--bs-border-width);--bs-card-border-color:var(--bs-border-color-translucent);--bs-card-border-radius:var(--bs-border-radius);--bs-card-box-shadow: ;--bs-card-inner-border-radius:calc(var(--bs-border-radius) - var(--bs-border-width));--bs-card-cap-padding-y:0.5rem;--bs-card-cap-padding-x:1rem;--bs-card-cap-bg:rgba(var(--bs-body-color-rgb),0.03);--bs-card-cap-color: ;--bs-card-height: ;--bs-card-color: ;--bs-card-bg:var(--bs-body-bg);--bs-card-img-overlay-padding:1rem;--bs-card-group-margin:0.75rem;word-wrap:break-word;background-clip:initial;background-color:var(--bs-card-bg);border:var(--bs-card-border-width) solid var(--bs-card-border-color);border-radius:var(--bs-card-border-radius);color:#212529;color:var(--bs-body-color);display:flex;flex-direction:column;height:var(--bs-card-height);min-width:0;position:relative}.card>hr{margin-left:0;margin-right:0}.card>.list-group{border-bottom:inherit;border-top:inherit}.card>.list-group:first-child{border-top-left-radius:var(--bs-card-inner-border-radius);border-top-right-radius:var(--bs-card-inner-border-radius);border-top-width:0}.card>.list-group:last-child{border-bottom-left-radius:var(--bs-card-inner-border-radius);border-bottom-right-radius:var(--bs-card-inner-border-radius);border-bottom-width:0}.card>.card-header+.list-group,.card>.list-group+.card-footer{border-top:0}.card-body{color:var(--bs-card-color);flex:1 1 auto;padding:var(--bs-card-spacer-y) var(--bs-card-spacer-x)}.card-title{color:var(--bs-card-title-color);margin-bottom:var(--bs-card-title-spacer-y)}.card-subtitle{color:var(--bs-card-subtitle-color);margin-top:calc(var(--bs-card-title-spacer-y)*-.5)}.card-subtitle,.card-text:last-child{margin-bottom:0}.card-link+.card-link{margin-left:var(--bs-card-spacer-x)}.card-header{background-color:var(--bs-card-cap-bg);border-bottom:var(--bs-card-border-width) solid var(--bs-card-border-color);color:var(--bs-card-cap-color);margin-bottom:0;padding:var(--bs-card-cap-padding-y) var(--bs-card-cap-padding-x)}.card-header:first-child{border-radius:var(--bs-card-inner-border-radius) var(--bs-card-inner-border-radius) 0 0}.card-footer{background-color:var(--bs-card-cap-bg);border-top:var(--bs-card-border-width) solid var(--bs-card-border-color);color:var(--bs-card-cap-color);padding:var(--bs-card-cap-padding-y) var(--bs-card-cap-padding-x)}.card-footer:last-child{border-radius:0 0 var(--bs-card-inner-border-radius) var(--bs-card-inner-border-radius)}.card-header-tabs{border-bottom:0;margin-bottom:calc(var(--bs-card-cap-padding-y)*-1);margin-left:calc(var(--bs-card-cap-padding-x)*-.5);margin-right:calc(var(--bs-card-cap-padding-x)*-.5)}.card-header-tabs .nav-link.active{background-color:var(--bs-card-bg);border-bottom-color:var(--bs-card-bg)}.card-header-pills{margin-left:calc(var(--bs-card-cap-padding-x)*-.5);margin-right:calc(var(--bs-card-cap-padding-x)*-.5)}.card-img-overlay{border-radius:var(--bs-card-inner-border-radius);bottom:0;left:0;padding:var(--bs-card-img-overlay-padding);position:absolute;right:0;top:0}.card-img,.card-img-bottom,.card-img-top{width:100%}.card-img,.card-img-top{border-top-left-radius:var(--bs-card-inner-border-radius);border-top-right-radius:var(--bs-card-inner-border-radius)}.card-img,.card-img-bottom{border-bottom-left-radius:var(--bs-card-inner-border-radius);border-bottom-right-radius:var(--bs-card-inner-border-radius)}.card-group>.card{margin-bottom:var(--bs-card-group-margin)}@media (min-width:576px){.card-group{display:flex;flex-flow:row wrap}.card-group>.card{flex:1 0;margin-bottom:0}.card-group>.card+.card{border-left:0;margin-left:0}.card-group>.card:not(:last-child){border-bottom-right-radius:0;border-top-right-radius:0}.card-group>.card:not(:last-child) .card-header,.card-group>.card:not(:last-child) .card-img-top{border-top-right-radius:0}.card-group>.card:not(:last-child) .card-footer,.card-group>.card:not(:last-child) .card-img-bottom{border-bottom-right-radius:0}.card-group>.card:not(:first-child){border-bottom-left-radius:0;border-top-left-radius:0}.card-group>.card:not(:first-child) .card-header,.card-group>.card:not(:first-child) .card-img-top{border-top-left-radius:0}.card-group>.card:not(:first-child) .card-footer,.card-group>.card:not(:first-child) .card-img-bottom{border-bottom-left-radius:0}}.accordion{--bs-accordion-color:var(--bs-body-color);--bs-accordion-bg:var(--bs-body-bg);--bs-accordion-transition:color 0.15s ease-in-out,background-color 0.15s ease-in-out,border-color 0.15s ease-in-out,box-shadow 0.15s ease-in-out,border-radius 0.15s ease;--bs-accordion-border-color:var(--bs-border-color);--bs-accordion-border-width:var(--bs-border-width);--bs-accordion-border-radius:var(--bs-border-radius);--bs-accordion-inner-border-radius:calc(var(--bs-border-radius) - var(--bs-border-width));--bs-accordion-btn-padding-x:1.25rem;--bs-accordion-btn-padding-y:1rem;--bs-accordion-btn-color:var(--bs-body-color);--bs-accordion-btn-bg:var(--bs-accordion-bg);--bs-accordion-btn-icon:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='%23212529'%3E%3Cpath fill-rule='evenodd' d='M1.646 4.646a.5.5 0 0 1 .708 0L8 10.293l5.646-5.647a.5.5 0 0 1 .708.708l-6 6a.5.5 0 0 1-.708 0l-6-6a.5.5 0 0 1 0-.708z'/%3E%3C/svg%3E");--bs-accordion-btn-icon-width:1.25rem;--bs-accordion-btn-icon-transform:rotate(-180deg);--bs-accordion-btn-icon-transition:transform 0.2s ease-in-out;--bs-accordion-btn-active-icon:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='%23052c65'%3E%3Cpath fill-rule='evenodd' d='M1.646 4.646a.5.5 0 0 1 .708 0L8 10.293l5.646-5.647a.5.5 0 0 1 .708.708l-6 6a.5.5 0 0 1-.708 0l-6-6a.5.5 0 0 1 0-.708z'/%3E%3C/svg%3E");--bs-accordion-btn-focus-border-color:#86b7fe;--bs-accordion-btn-focus-box-shadow:0 0 0 0.25rem rgba(13,110,253,.25);--bs-accordion-body-padding-x:1.25rem;--bs-accordion-body-padding-y:1rem;--bs-accordion-active-color:var(--bs-primary-text-emphasis);--bs-accordion-active-bg:var(--bs-primary-bg-subtle)}.accordion-button{align-items:center;background-color:var(--bs-accordion-btn-bg);border:0;border-radius:0;color:var(--bs-accordion-btn-color);display:flex;font-size:1rem;overflow-anchor:none;padding:var(--bs-accordion-btn-padding-y) var(--bs-accordion-btn-padding-x);position:relative;text-align:left;transition:var(--bs-accordion-transition);width:100%}@media (prefers-reduced-motion:reduce){.accordion-button{transition:none}}.accordion-button:not(.collapsed){background-color:var(--bs-accordion-active-bg);box-shadow:inset 0 calc(var(--bs-accordion-border-width)*-1) 0 var(--bs-accordion-border-color);color:var(--bs-accordion-active-color)}.accordion-button:not(.collapsed):after{background-image:var(--bs-accordion-btn-active-icon);-webkit-transform:var(--bs-accordion-btn-icon-transform);transform:var(--bs-accordion-btn-icon-transform)}.accordion-button:after{background-image:var(--bs-accordion-btn-icon);background-repeat:no-repeat;background-size:var(--bs-accordion-btn-icon-width);content:"";flex-shrink:0;height:var(--bs-accordion-btn-icon-width);margin-left:auto;transition:var(--bs-accordion-btn-icon-transition);width:var(--bs-accordion-btn-icon-width)}@media (prefers-reduced-motion:reduce){.accordion-button:after{transition:none}}.accordion-button:hover{z-index:2}.accordion-button:focus{border-color:var(--bs-accordion-btn-focus-border-color);box-shadow:var(--bs-accordion-btn-focus-box-shadow);outline:0;z-index:3}.accordion-header{margin-bottom:0}.accordion-item{background-color:var(--bs-accordion-bg);border:var(--bs-accordion-border-width) solid var(--bs-accordion-border-color);color:var(--bs-accordion-color)}.accordion-item:first-of-type{border-top-left-radius:var(--bs-accordion-border-radius);border-top-right-radius:var(--bs-accordion-border-radius)}.accordion-item:first-of-type .accordion-button{border-top-left-radius:var(--bs-accordion-inner-border-radius);border-top-right-radius:var(--bs-accordion-inner-border-radius)}.accordion-item:not(:first-of-type){border-top:0}.accordion-item:last-of-type{border-bottom-left-radius:var(--bs-accordion-border-radius);border-bottom-right-radius:var(--bs-accordion-border-radius)}.accordion-item:last-of-type .accordion-button.collapsed{border-bottom-left-radius:var(--bs-accordion-inner-border-radius);border-bottom-right-radius:var(--bs-accordion-inner-border-radius)}.accordion-item:last-of-type .accordion-collapse{border-bottom-left-radius:var(--bs-accordion-border-radius);border-bottom-right-radius:var(--bs-accordion-border-radius)}.accordion-body{padding:var(--bs-accordion-body-padding-y) var(--bs-accordion-body-padding-x)}.accordion-flush .accordion-collapse{border-width:0}.accordion-flush .accordion-item{border-left:0;border-radius:0;border-right:0}.accordion-flush .accordion-item:first-child{border-top:0}.accordion-flush .accordion-item:last-child{border-bottom:0}.accordion-flush .accordion-item .accordion-button,.accordion-flush .accordion-item .accordion-button.collapsed{border-radius:0}[data-bs-theme=dark] .accordion-button:after{--bs-accordion-btn-icon:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='%236ea8fe'%3E%3Cpath fill-rule='evenodd' d='M1.646 4.646a.5.5 0 0 1 .708 0L8 10.293l5.646-5.647a.5.5 0 0 1 .708.708l-6 6a.5.5 0 0 1-.708 0l-6-6a.5.5 0 0 1 0-.708z'/%3E%3C/svg%3E");--bs-accordion-btn-active-icon:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='%236ea8fe'%3E%3Cpath fill-rule='evenodd' d='M1.646 4.646a.5.5 0 0 1 .708 0L8 10.293l5.646-5.647a.5.5 0 0 1 .708.708l-6 6a.5.5 0 0 1-.708 0l-6-6a.5.5 0 0 1 0-.708z'/%3E%3C/svg%3E")}.breadcrumb{--bs-breadcrumb-padding-x:0;--bs-breadcrumb-padding-y:0;--bs-breadcrumb-margin-bottom:1rem;--bs-breadcrumb-bg: ;--bs-breadcrumb-border-radius: ;--bs-breadcrumb-divider-color:var(--bs-secondary-color);--bs-breadcrumb-item-padding-x:0.5rem;--bs-breadcrumb-item-active-color:var(--bs-secondary-color);background-color:var(--bs-breadcrumb-bg);border-radius:var(--bs-breadcrumb-border-radius);display:flex;flex-wrap:wrap;font-size:var(--bs-breadcrumb-font-size);list-style:none;margin-bottom:var(--bs-breadcrumb-margin-bottom);padding:var(--bs-breadcrumb-padding-y) var(--bs-breadcrumb-padding-x)}.breadcrumb-item+.breadcrumb-item{padding-left:var(--bs-breadcrumb-item-padding-x)}.breadcrumb-item+.breadcrumb-item:before{color:var(--bs-breadcrumb-divider-color);content:"/";content:var(--bs-breadcrumb-divider,"/");float:left;padding-right:var(--bs-breadcrumb-item-padding-x)}.breadcrumb-item.active{color:var(--bs-breadcrumb-item-active-color)}.pagination{--bs-pagination-padding-x:0.75rem;--bs-pagination-padding-y:0.375rem;--bs-pagination-font-size:1rem;--bs-pagination-color:var(--bs-link-color);--bs-pagination-bg:var(--bs-body-bg);--bs-pagination-border-width:var(--bs-border-width);--bs-pagination-border-color:var(--bs-border-color);--bs-pagination-border-radius:var(--bs-border-radius);--bs-pagination-hover-color:var(--bs-link-hover-color);--bs-pagination-hover-bg:var(--bs-tertiary-bg);--bs-pagination-hover-border-color:var(--bs-border-color);--bs-pagination-focus-color:var(--bs-link-hover-color);--bs-pagination-focus-bg:var(--bs-secondary-bg);--bs-pagination-focus-box-shadow:0 0 0 0.25rem rgba(13,110,253,.25);--bs-pagination-active-color:#fff;--bs-pagination-active-bg:#0d6efd;--bs-pagination-active-border-color:#0d6efd;--bs-pagination-disabled-color:var(--bs-secondary-color);--bs-pagination-disabled-bg:var(--bs-secondary-bg);--bs-pagination-disabled-border-color:var(--bs-border-color);display:flex;list-style:none;padding-left:0}.page-link{background-color:var(--bs-pagination-bg);border:var(--bs-pagination-border-width) solid var(--bs-pagination-border-color);color:var(--bs-pagination-color);display:block;font-size:var(--bs-pagination-font-size);padding:var(--bs-pagination-padding-y) var(--bs-pagination-padding-x);position:relative;text-decoration:none;transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out}@media (prefers-reduced-motion:reduce){.page-link{transition:none}}.page-link:hover{background-color:var(--bs-pagination-hover-bg);border-color:var(--bs-pagination-hover-border-color);color:var(--bs-pagination-hover-color);z-index:2}.page-link:focus{background-color:var(--bs-pagination-focus-bg);box-shadow:var(--bs-pagination-focus-box-shadow);color:var(--bs-pagination-focus-color);outline:0;z-index:3}.active>.page-link,.page-link.active{background-color:var(--bs-pagination-active-bg);border-color:var(--bs-pagination-active-border-color);color:var(--bs-pagination-active-color);z-index:3}.disabled>.page-link,.page-link.disabled{background-color:var(--bs-pagination-disabled-bg);border-color:var(--bs-pagination-disabled-border-color);color:var(--bs-pagination-disabled-color);pointer-events:none}.page-item:not(:first-child) .page-link{margin-left:-1px;margin-left:calc(var(--bs-border-width)*-1)}.page-item:first-child .page-link{border-bottom-left-radius:var(--bs-pagination-border-radius);border-top-left-radius:var(--bs-pagination-border-radius)}.page-item:last-child .page-link{border-bottom-right-radius:var(--bs-pagination-border-radius);border-top-right-radius:var(--bs-pagination-border-radius)}.pagination-lg{--bs-pagination-padding-x:1.5rem;--bs-pagination-padding-y:0.75rem;--bs-pagination-font-size:1.25rem;--bs-pagination-border-radius:var(--bs-border-radius-lg)}.pagination-sm{--bs-pagination-padding-x:0.5rem;--bs-pagination-padding-y:0.25rem;--bs-pagination-font-size:0.875rem;--bs-pagination-border-radius:var(--bs-border-radius-sm)}.badge{--bs-badge-padding-x:0.65em;--bs-badge-padding-y:0.35em;--bs-badge-font-size:0.75em;--bs-badge-font-weight:700;--bs-badge-color:#fff;--bs-badge-border-radius:var(--bs-border-radius);border-radius:var(--bs-badge-border-radius);color:var(--bs-badge-color);display:inline-block;font-size:var(--bs-badge-font-size);font-weight:var(--bs-badge-font-weight);line-height:1;padding:var(--bs-badge-padding-y) var(--bs-badge-padding-x);text-align:center;vertical-align:initial;white-space:nowrap}.badge:empty{display:none}.btn .badge{position:relative;top:-1px}.alert{--bs-alert-bg:transparent;--bs-alert-padding-x:1rem;--bs-alert-padding-y:1rem;--bs-alert-margin-bottom:1rem;--bs-alert-color:inherit;--bs-alert-border-color:transparent;--bs-alert-border:var(--bs-border-width) solid var(--bs-alert-border-color);--bs-alert-border-radius:var(--bs-border-radius);--bs-alert-link-color:inherit;background-color:var(--bs-alert-bg);border:var(--bs-alert-border);border-radius:var(--bs-alert-border-radius);color:var(--bs-alert-color);margin-bottom:var(--bs-alert-margin-bottom);padding:var(--bs-alert-padding-y) var(--bs-alert-padding-x);position:relative}.alert-heading{color:inherit}.alert-link{color:var(--bs-alert-link-color);font-weight:700}.alert-dismissible{padding-right:3rem}.alert-dismissible .btn-close{padding:1.25rem 1rem;position:absolute;right:0;top:0;z-index:2}.alert-primary{--bs-alert-color:var(--bs-primary-text-emphasis);--bs-alert-bg:var(--bs-primary-bg-subtle);--bs-alert-border-color:var(--bs-primary-border-subtle);--bs-alert-link-color:var(--bs-primary-text-emphasis)}.alert-secondary{--bs-alert-color:var(--bs-secondary-text-emphasis);--bs-alert-bg:var(--bs-secondary-bg-subtle);--bs-alert-border-color:var(--bs-secondary-border-subtle);--bs-alert-link-color:var(--bs-secondary-text-emphasis)}.alert-success{--bs-alert-color:var(--bs-success-text-emphasis);--bs-alert-bg:var(--bs-success-bg-subtle);--bs-alert-border-color:var(--bs-success-border-subtle);--bs-alert-link-color:var(--bs-success-text-emphasis)}.alert-info{--bs-alert-color:var(--bs-info-text-emphasis);--bs-alert-bg:var(--bs-info-bg-subtle);--bs-alert-border-color:var(--bs-info-border-subtle);--bs-alert-link-color:var(--bs-info-text-emphasis)}.alert-warning{--bs-alert-color:var(--bs-warning-text-emphasis);--bs-alert-bg:var(--bs-warning-bg-subtle);--bs-alert-border-color:var(--bs-warning-border-subtle);--bs-alert-link-color:var(--bs-warning-text-emphasis)}.alert-danger{--bs-alert-color:var(--bs-danger-text-emphasis);--bs-alert-bg:var(--bs-danger-bg-subtle);--bs-alert-border-color:var(--bs-danger-border-subtle);--bs-alert-link-color:var(--bs-danger-text-emphasis)}.alert-light{--bs-alert-color:var(--bs-light-text-emphasis);--bs-alert-bg:var(--bs-light-bg-subtle);--bs-alert-border-color:var(--bs-light-border-subtle);--bs-alert-link-color:var(--bs-light-text-emphasis)}.alert-dark{--bs-alert-color:var(--bs-dark-text-emphasis);--bs-alert-bg:var(--bs-dark-bg-subtle);--bs-alert-border-color:var(--bs-dark-border-subtle);--bs-alert-link-color:var(--bs-dark-text-emphasis)}@-webkit-keyframes progress-bar-stripes{0%{background-position-x:1rem}}@keyframes progress-bar-stripes{0%{background-position-x:1rem}}.progress,.progress-stacked{--bs-progress-height:1rem;--bs-progress-font-size:0.75rem;--bs-progress-bg:var(--bs-secondary-bg);--bs-progress-border-radius:var(--bs-border-radius);--bs-progress-box-shadow:var(--bs-box-shadow-inset);--bs-progress-bar-color:#fff;--bs-progress-bar-bg:#0d6efd;--bs-progress-bar-transition:width 0.6s ease;background-color:var(--bs-progress-bg);border-radius:var(--bs-progress-border-radius);display:flex;font-size:var(--bs-progress-font-size);height:var(--bs-progress-height);overflow:hidden}.progress-bar{background-color:var(--bs-progress-bar-bg);color:var(--bs-progress-bar-color);display:flex;flex-direction:column;justify-content:center;overflow:hidden;text-align:center;transition:var(--bs-progress-bar-transition);white-space:nowrap}@media (prefers-reduced-motion:reduce){.progress-bar{transition:none}}.progress-bar-striped{background-image:linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent);background-size:var(--bs-progress-height) var(--bs-progress-height)}.progress-stacked>.progress{overflow:visible}.progress-stacked>.progress>.progress-bar{width:100%}.progress-bar-animated{-webkit-animation:progress-bar-stripes 1s linear infinite;animation:progress-bar-stripes 1s linear infinite}@media (prefers-reduced-motion:reduce){.progress-bar-animated{-webkit-animation:none;animation:none}}.list-group{--bs-list-group-color:var(--bs-body-color);--bs-list-group-bg:var(--bs-body-bg);--bs-list-group-border-color:var(--bs-border-color);--bs-list-group-border-width:var(--bs-border-width);--bs-list-group-border-radius:var(--bs-border-radius);--bs-list-group-item-padding-x:1rem;--bs-list-group-item-padding-y:0.5rem;--bs-list-group-action-color:var(--bs-secondary-color);--bs-list-group-action-hover-color:var(--bs-emphasis-color);--bs-list-group-action-hover-bg:var(--bs-tertiary-bg);--bs-list-group-action-active-color:var(--bs-body-color);--bs-list-group-action-active-bg:var(--bs-secondary-bg);--bs-list-group-disabled-color:var(--bs-secondary-color);--bs-list-group-disabled-bg:var(--bs-body-bg);--bs-list-group-active-color:#fff;--bs-list-group-active-bg:#0d6efd;--bs-list-group-active-border-color:#0d6efd;border-radius:var(--bs-list-group-border-radius);display:flex;flex-direction:column;margin-bottom:0;padding-left:0}.list-group-numbered{counter-reset:section;list-style-type:none}.list-group-numbered>.list-group-item:before{content:counters(section,".") ". ";counter-increment:section}.list-group-item-action{color:var(--bs-list-group-action-color);text-align:inherit;width:100%}.list-group-item-action:focus,.list-group-item-action:hover{background-color:var(--bs-list-group-action-hover-bg);color:var(--bs-list-group-action-hover-color);text-decoration:none;z-index:1}.list-group-item-action:active{background-color:var(--bs-list-group-action-active-bg);color:var(--bs-list-group-action-active-color)}.list-group-item{background-color:var(--bs-list-group-bg);border:var(--bs-list-group-border-width) solid var(--bs-list-group-border-color);color:var(--bs-list-group-color);display:block;padding:var(--bs-list-group-item-padding-y) var(--bs-list-group-item-padding-x);position:relative;text-decoration:none}.list-group-item:first-child{border-top-left-radius:inherit;border-top-right-radius:inherit}.list-group-item:last-child{border-bottom-left-radius:inherit;border-bottom-right-radius:inherit}.list-group-item.disabled,.list-group-item:disabled{background-color:var(--bs-list-group-disabled-bg);color:var(--bs-list-group-disabled-color);pointer-events:none}.list-group-item.active{background-color:var(--bs-list-group-active-bg);border-color:var(--bs-list-group-active-border-color);color:var(--bs-list-group-active-color);z-index:2}.list-group-item+.list-group-item{border-top-width:0}.list-group-item+.list-group-item.active{border-top-width:var(--bs-list-group-border-width);margin-top:calc(var(--bs-list-group-border-width)*-1)}.list-group-horizontal{flex-direction:row}.list-group-horizontal>.list-group-item:first-child:not(:last-child){border-bottom-left-radius:var(--bs-list-group-border-radius);border-top-right-radius:0}.list-group-horizontal>.list-group-item:last-child:not(:first-child){border-bottom-left-radius:0;border-top-right-radius:var(--bs-list-group-border-radius)}.list-group-horizontal>.list-group-item.active{margin-top:0}.list-group-horizontal>.list-group-item+.list-group-item{border-left-width:0;border-top-width:var(--bs-list-group-border-width)}.list-group-horizontal>.list-group-item+.list-group-item.active{border-left-width:var(--bs-list-group-border-width);margin-left:calc(var(--bs-list-group-border-width)*-1)}@media (min-width:576px){.list-group-horizontal-sm{flex-direction:row}.list-group-horizontal-sm>.list-group-item:first-child:not(:last-child){border-bottom-left-radius:var(--bs-list-group-border-radius);border-top-right-radius:0}.list-group-horizontal-sm>.list-group-item:last-child:not(:first-child){border-bottom-left-radius:0;border-top-right-radius:var(--bs-list-group-border-radius)}.list-group-horizontal-sm>.list-group-item.active{margin-top:0}.list-group-horizontal-sm>.list-group-item+.list-group-item{border-left-width:0;border-top-width:var(--bs-list-group-border-width)}.list-group-horizontal-sm>.list-group-item+.list-group-item.active{border-left-width:var(--bs-list-group-border-width);margin-left:calc(var(--bs-list-group-border-width)*-1)}}@media (min-width:768px){.list-group-horizontal-md{flex-direction:row}.list-group-horizontal-md>.list-group-item:first-child:not(:last-child){border-bottom-left-radius:var(--bs-list-group-border-radius);border-top-right-radius:0}.list-group-horizontal-md>.list-group-item:last-child:not(:first-child){border-bottom-left-radius:0;border-top-right-radius:var(--bs-list-group-border-radius)}.list-group-horizontal-md>.list-group-item.active{margin-top:0}.list-group-horizontal-md>.list-group-item+.list-group-item{border-left-width:0;border-top-width:var(--bs-list-group-border-width)}.list-group-horizontal-md>.list-group-item+.list-group-item.active{border-left-width:var(--bs-list-group-border-width);margin-left:calc(var(--bs-list-group-border-width)*-1)}}@media (min-width:992px){.list-group-horizontal-lg{flex-direction:row}.list-group-horizontal-lg>.list-group-item:first-child:not(:last-child){border-bottom-left-radius:var(--bs-list-group-border-radius);border-top-right-radius:0}.list-group-horizontal-lg>.list-group-item:last-child:not(:first-child){border-bottom-left-radius:0;border-top-right-radius:var(--bs-list-group-border-radius)}.list-group-horizontal-lg>.list-group-item.active{margin-top:0}.list-group-horizontal-lg>.list-group-item+.list-group-item{border-left-width:0;border-top-width:var(--bs-list-group-border-width)}.list-group-horizontal-lg>.list-group-item+.list-group-item.active{border-left-width:var(--bs-list-group-border-width);margin-left:calc(var(--bs-list-group-border-width)*-1)}}@media (min-width:1200px){.list-group-horizontal-xl{flex-direction:row}.list-group-horizontal-xl>.list-group-item:first-child:not(:last-child){border-bottom-left-radius:var(--bs-list-group-border-radius);border-top-right-radius:0}.list-group-horizontal-xl>.list-group-item:last-child:not(:first-child){border-bottom-left-radius:0;border-top-right-radius:var(--bs-list-group-border-radius)}.list-group-horizontal-xl>.list-group-item.active{margin-top:0}.list-group-horizontal-xl>.list-group-item+.list-group-item{border-left-width:0;border-top-width:var(--bs-list-group-border-width)}.list-group-horizontal-xl>.list-group-item+.list-group-item.active{border-left-width:var(--bs-list-group-border-width);margin-left:calc(var(--bs-list-group-border-width)*-1)}}@media (min-width:1400px){.list-group-horizontal-xxl{flex-direction:row}.list-group-horizontal-xxl>.list-group-item:first-child:not(:last-child){border-bottom-left-radius:var(--bs-list-group-border-radius);border-top-right-radius:0}.list-group-horizontal-xxl>.list-group-item:last-child:not(:first-child){border-bottom-left-radius:0;border-top-right-radius:var(--bs-list-group-border-radius)}.list-group-horizontal-xxl>.list-group-item.active{margin-top:0}.list-group-horizontal-xxl>.list-group-item+.list-group-item{border-left-width:0;border-top-width:var(--bs-list-group-border-width)}.list-group-horizontal-xxl>.list-group-item+.list-group-item.active{border-left-width:var(--bs-list-group-border-width);margin-left:calc(var(--bs-list-group-border-width)*-1)}}.list-group-flush{border-radius:0}.list-group-flush>.list-group-item{border-width:0 0 var(--bs-list-group-border-width)}.list-group-flush>.list-group-item:last-child{border-bottom-width:0}.list-group-item-primary{--bs-list-group-color:var(--bs-primary-text-emphasis);--bs-list-group-bg:var(--bs-primary-bg-subtle);--bs-list-group-border-color:var(--bs-primary-border-subtle);--bs-list-group-action-hover-color:var(--bs-emphasis-color);--bs-list-group-action-hover-bg:var(--bs-primary-border-subtle);--bs-list-group-action-active-color:var(--bs-emphasis-color);--bs-list-group-action-active-bg:var(--bs-primary-border-subtle);--bs-list-group-active-color:var(--bs-primary-bg-subtle);--bs-list-group-active-bg:var(--bs-primary-text-emphasis);--bs-list-group-active-border-color:var(--bs-primary-text-emphasis)}.list-group-item-secondary{--bs-list-group-color:var(--bs-secondary-text-emphasis);--bs-list-group-bg:var(--bs-secondary-bg-subtle);--bs-list-group-border-color:var(--bs-secondary-border-subtle);--bs-list-group-action-hover-color:var(--bs-emphasis-color);--bs-list-group-action-hover-bg:var(--bs-secondary-border-subtle);--bs-list-group-action-active-color:var(--bs-emphasis-color);--bs-list-group-action-active-bg:var(--bs-secondary-border-subtle);--bs-list-group-active-color:var(--bs-secondary-bg-subtle);--bs-list-group-active-bg:var(--bs-secondary-text-emphasis);--bs-list-group-active-border-color:var(--bs-secondary-text-emphasis)}.list-group-item-success{--bs-list-group-color:var(--bs-success-text-emphasis);--bs-list-group-bg:var(--bs-success-bg-subtle);--bs-list-group-border-color:var(--bs-success-border-subtle);--bs-list-group-action-hover-color:var(--bs-emphasis-color);--bs-list-group-action-hover-bg:var(--bs-success-border-subtle);--bs-list-group-action-active-color:var(--bs-emphasis-color);--bs-list-group-action-active-bg:var(--bs-success-border-subtle);--bs-list-group-active-color:var(--bs-success-bg-subtle);--bs-list-group-active-bg:var(--bs-success-text-emphasis);--bs-list-group-active-border-color:var(--bs-success-text-emphasis)}.list-group-item-info{--bs-list-group-color:var(--bs-info-text-emphasis);--bs-list-group-bg:var(--bs-info-bg-subtle);--bs-list-group-border-color:var(--bs-info-border-subtle);--bs-list-group-action-hover-color:var(--bs-emphasis-color);--bs-list-group-action-hover-bg:var(--bs-info-border-subtle);--bs-list-group-action-active-color:var(--bs-emphasis-color);--bs-list-group-action-active-bg:var(--bs-info-border-subtle);--bs-list-group-active-color:var(--bs-info-bg-subtle);--bs-list-group-active-bg:var(--bs-info-text-emphasis);--bs-list-group-active-border-color:var(--bs-info-text-emphasis)}.list-group-item-warning{--bs-list-group-color:var(--bs-warning-text-emphasis);--bs-list-group-bg:var(--bs-warning-bg-subtle);--bs-list-group-border-color:var(--bs-warning-border-subtle);--bs-list-group-action-hover-color:var(--bs-emphasis-color);--bs-list-group-action-hover-bg:var(--bs-warning-border-subtle);--bs-list-group-action-active-color:var(--bs-emphasis-color);--bs-list-group-action-active-bg:var(--bs-warning-border-subtle);--bs-list-group-active-color:var(--bs-warning-bg-subtle);--bs-list-group-active-bg:var(--bs-warning-text-emphasis);--bs-list-group-active-border-color:var(--bs-warning-text-emphasis)}.list-group-item-danger{--bs-list-group-color:var(--bs-danger-text-emphasis);--bs-list-group-bg:var(--bs-danger-bg-subtle);--bs-list-group-border-color:var(--bs-danger-border-subtle);--bs-list-group-action-hover-color:var(--bs-emphasis-color);--bs-list-group-action-hover-bg:var(--bs-danger-border-subtle);--bs-list-group-action-active-color:var(--bs-emphasis-color);--bs-list-group-action-active-bg:var(--bs-danger-border-subtle);--bs-list-group-active-color:var(--bs-danger-bg-subtle);--bs-list-group-active-bg:var(--bs-danger-text-emphasis);--bs-list-group-active-border-color:var(--bs-danger-text-emphasis)}.list-group-item-light{--bs-list-group-color:var(--bs-light-text-emphasis);--bs-list-group-bg:var(--bs-light-bg-subtle);--bs-list-group-border-color:var(--bs-light-border-subtle);--bs-list-group-action-hover-color:var(--bs-emphasis-color);--bs-list-group-action-hover-bg:var(--bs-light-border-subtle);--bs-list-group-action-active-color:var(--bs-emphasis-color);--bs-list-group-action-active-bg:var(--bs-light-border-subtle);--bs-list-group-active-color:var(--bs-light-bg-subtle);--bs-list-group-active-bg:var(--bs-light-text-emphasis);--bs-list-group-active-border-color:var(--bs-light-text-emphasis)}.list-group-item-dark{--bs-list-group-color:var(--bs-dark-text-emphasis);--bs-list-group-bg:var(--bs-dark-bg-subtle);--bs-list-group-border-color:var(--bs-dark-border-subtle);--bs-list-group-action-hover-color:var(--bs-emphasis-color);--bs-list-group-action-hover-bg:var(--bs-dark-border-subtle);--bs-list-group-action-active-color:var(--bs-emphasis-color);--bs-list-group-action-active-bg:var(--bs-dark-border-subtle);--bs-list-group-active-color:var(--bs-dark-bg-subtle);--bs-list-group-active-bg:var(--bs-dark-text-emphasis);--bs-list-group-active-border-color:var(--bs-dark-text-emphasis)}.btn-close{--bs-btn-close-color:#000;--bs-btn-close-bg:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3E%3Cpath d='M.293.293a1 1 0 0 1 1.414 0L8 6.586 14.293.293a1 1 0 1 1 1.414 1.414L9.414 8l6.293 6.293a1 1 0 0 1-1.414 1.414L8 9.414l-6.293 6.293a1 1 0 0 1-1.414-1.414L6.586 8 .293 1.707a1 1 0 0 1 0-1.414z'/%3E%3C/svg%3E");--bs-btn-close-opacity:0.5;--bs-btn-close-hover-opacity:0.75;--bs-btn-close-focus-shadow:0 0 0 0.25rem rgba(13,110,253,.25);--bs-btn-close-focus-opacity:1;--bs-btn-close-disabled-opacity:0.25;--bs-btn-close-white-filter:invert(1) grayscale(100%) brightness(200%);background:transparent var(--bs-btn-close-bg) center/1em auto no-repeat;border:0;border-radius:.375rem;box-sizing:initial;height:1em;opacity:var(--bs-btn-close-opacity);padding:.25em;width:1em}.btn-close,.btn-close:hover{color:var(--bs-btn-close-color)}.btn-close:hover{opacity:var(--bs-btn-close-hover-opacity);text-decoration:none}.btn-close:focus{box-shadow:var(--bs-btn-close-focus-shadow);opacity:var(--bs-btn-close-focus-opacity);outline:0}.btn-close.disabled,.btn-close:disabled{opacity:var(--bs-btn-close-disabled-opacity);pointer-events:none;-webkit-user-select:none;user-select:none}.btn-close-white,[data-bs-theme=dark] .btn-close{-webkit-filter:var(--bs-btn-close-white-filter);filter:var(--bs-btn-close-white-filter)}.toast{--bs-toast-zindex:1090;--bs-toast-padding-x:0.75rem;--bs-toast-padding-y:0.5rem;--bs-toast-spacing:1.5rem;--bs-toast-max-width:350px;--bs-toast-font-size:0.875rem;--bs-toast-color: ;--bs-toast-bg:rgba(var(--bs-body-bg-rgb),0.85);--bs-toast-border-width:var(--bs-border-width);--bs-toast-border-color:var(--bs-border-color-translucent);--bs-toast-border-radius:var(--bs-border-radius);--bs-toast-box-shadow:var(--bs-box-shadow);--bs-toast-header-color:var(--bs-secondary-color);--bs-toast-header-bg:rgba(var(--bs-body-bg-rgb),0.85);--bs-toast-header-border-color:var(--bs-border-color-translucent);background-clip:padding-box;background-color:var(--bs-toast-bg);border:var(--bs-toast-border-width) solid var(--bs-toast-border-color);border-radius:var(--bs-toast-border-radius);box-shadow:var(--bs-toast-box-shadow);color:var(--bs-toast-color);font-size:var(--bs-toast-font-size);max-width:100%;pointer-events:auto;width:var(--bs-toast-max-width)}.toast.showing{opacity:0}.toast:not(.show){display:none}.toast-container{--bs-toast-zindex:1090;max-width:100%;pointer-events:none;position:absolute;width:-webkit-max-content;width:max-content;z-index:var(--bs-toast-zindex)}.toast-container>:not(:last-child){margin-bottom:var(--bs-toast-spacing)}.toast-header{align-items:center;background-clip:padding-box;background-color:var(--bs-toast-header-bg);border-bottom:var(--bs-toast-border-width) solid var(--bs-toast-header-border-color);border-top-left-radius:calc(var(--bs-toast-border-radius) - var(--bs-toast-border-width));border-top-right-radius:calc(var(--bs-toast-border-radius) - var(--bs-toast-border-width));color:var(--bs-toast-header-color);display:flex;padding:var(--bs-toast-padding-y) var(--bs-toast-padding-x)}.toast-header .btn-close{margin-left:var(--bs-toast-padding-x);margin-right:calc(var(--bs-toast-padding-x)*-.5)}.toast-body{word-wrap:break-word;padding:var(--bs-toast-padding-x)}.modal{--bs-modal-zindex:1055;--bs-modal-width:500px;--bs-modal-padding:1rem;--bs-modal-margin:0.5rem;--bs-modal-color: ;--bs-modal-bg:var(--bs-body-bg);--bs-modal-border-color:var(--bs-border-color-translucent);--bs-modal-border-width:var(--bs-border-width);--bs-modal-border-radius:var(--bs-border-radius-lg);--bs-modal-box-shadow:var(--bs-box-shadow-sm);--bs-modal-inner-border-radius:calc(var(--bs-border-radius-lg) - var(--bs-border-width));--bs-modal-header-padding-x:1rem;--bs-modal-header-padding-y:1rem;--bs-modal-header-padding:1rem 1rem;--bs-modal-header-border-color:var(--bs-border-color);--bs-modal-header-border-width:var(--bs-border-width);--bs-modal-title-line-height:1.5;--bs-modal-footer-gap:0.5rem;--bs-modal-footer-bg: ;--bs-modal-footer-border-color:var(--bs-border-color);--bs-modal-footer-border-width:var(--bs-border-width);display:none;height:100%;left:0;outline:0;overflow-x:hidden;overflow-y:auto;position:fixed;top:0;width:100%;z-index:var(--bs-modal-zindex)}.modal-dialog{margin:var(--bs-modal-margin);pointer-events:none;position:relative;width:auto}.modal.fade .modal-dialog{-webkit-transform:translateY(-50px);transform:translateY(-50px);transition:-webkit-transform .3s ease-out;transition:transform .3s ease-out;transition:transform .3s ease-out,-webkit-transform .3s ease-out}@media (prefers-reduced-motion:reduce){.modal.fade .modal-dialog{transition:none}}.modal.show .modal-dialog{-webkit-transform:none;transform:none}.modal.modal-static .modal-dialog{-webkit-transform:scale(1.02);transform:scale(1.02)}.modal-dialog-scrollable{height:calc(100% - var(--bs-modal-margin)*2)}.modal-dialog-scrollable .modal-content{max-height:100%;overflow:hidden}.modal-dialog-scrollable .modal-body{overflow-y:auto}.modal-dialog-centered{align-items:center;display:flex;min-height:calc(100% - var(--bs-modal-margin)*2)}.modal-content{background-clip:padding-box;background-color:var(--bs-modal-bg);border:var(--bs-modal-border-width) solid var(--bs-modal-border-color);border-radius:var(--bs-modal-border-radius);color:var(--bs-modal-color);display:flex;flex-direction:column;outline:0;pointer-events:auto;position:relative;width:100%}.modal-backdrop{--bs-backdrop-zindex:1050;--bs-backdrop-bg:#000;--bs-backdrop-opacity:0.5;background-color:var(--bs-backdrop-bg);height:100vh;left:0;position:fixed;top:0;width:100vw;z-index:var(--bs-backdrop-zindex)}.modal-backdrop.fade{opacity:0}.modal-backdrop.show{opacity:var(--bs-backdrop-opacity)}.modal-header{align-items:center;border-bottom:var(--bs-modal-header-border-width) solid var(--bs-modal-header-border-color);border-top-left-radius:var(--bs-modal-inner-border-radius);border-top-right-radius:var(--bs-modal-inner-border-radius);display:flex;flex-shrink:0;justify-content:space-between;padding:var(--bs-modal-header-padding)}.modal-header .btn-close{margin:calc(var(--bs-modal-header-padding-y)*-.5) calc(var(--bs-modal-header-padding-x)*-.5) calc(var(--bs-modal-header-padding-y)*-.5) auto;padding:calc(var(--bs-modal-header-padding-y)*.5) calc(var(--bs-modal-header-padding-x)*.5)}.modal-title{line-height:var(--bs-modal-title-line-height);margin-bottom:0}.modal-body{flex:1 1 auto;padding:var(--bs-modal-padding);position:relative}.modal-footer{align-items:center;background-color:var(--bs-modal-footer-bg);border-bottom-left-radius:var(--bs-modal-inner-border-radius);border-bottom-right-radius:var(--bs-modal-inner-border-radius);border-top:var(--bs-modal-footer-border-width) solid var(--bs-modal-footer-border-color);display:flex;flex-shrink:0;flex-wrap:wrap;justify-content:flex-end;padding:calc(var(--bs-modal-padding) - var(--bs-modal-footer-gap)*.5)}.modal-footer>*{margin:calc(var(--bs-modal-footer-gap)*.5)}@media (min-width:576px){.modal{--bs-modal-margin:1.75rem;--bs-modal-box-shadow:var(--bs-box-shadow)}.modal-dialog{margin-left:auto;margin-right:auto;max-width:var(--bs-modal-width)}.modal-sm{--bs-modal-width:300px}}@media (min-width:992px){.modal-lg,.modal-xl{--bs-modal-width:800px}}@media (min-width:1200px){.modal-xl{--bs-modal-width:1140px}}.modal-fullscreen{height:100%;margin:0;max-width:none;width:100vw}.modal-fullscreen .modal-content{border:0;border-radius:0;height:100%}.modal-fullscreen .modal-footer,.modal-fullscreen .modal-header{border-radius:0}.modal-fullscreen .modal-body{overflow-y:auto}@media (max-width:575.98px){.modal-fullscreen-sm-down{height:100%;margin:0;max-width:none;width:100vw}.modal-fullscreen-sm-down .modal-content{border:0;border-radius:0;height:100%}.modal-fullscreen-sm-down .modal-footer,.modal-fullscreen-sm-down .modal-header{border-radius:0}.modal-fullscreen-sm-down .modal-body{overflow-y:auto}}@media (max-width:767.98px){.modal-fullscreen-md-down{height:100%;margin:0;max-width:none;width:100vw}.modal-fullscreen-md-down .modal-content{border:0;border-radius:0;height:100%}.modal-fullscreen-md-down .modal-footer,.modal-fullscreen-md-down .modal-header{border-radius:0}.modal-fullscreen-md-down .modal-body{overflow-y:auto}}@media (max-width:991.98px){.modal-fullscreen-lg-down{height:100%;margin:0;max-width:none;width:100vw}.modal-fullscreen-lg-down .modal-content{border:0;border-radius:0;height:100%}.modal-fullscreen-lg-down .modal-footer,.modal-fullscreen-lg-down .modal-header{border-radius:0}.modal-fullscreen-lg-down .modal-body{overflow-y:auto}}@media (max-width:1199.98px){.modal-fullscreen-xl-down{height:100%;margin:0;max-width:none;width:100vw}.modal-fullscreen-xl-down .modal-content{border:0;border-radius:0;height:100%}.modal-fullscreen-xl-down .modal-footer,.modal-fullscreen-xl-down .modal-header{border-radius:0}.modal-fullscreen-xl-down .modal-body{overflow-y:auto}}@media (max-width:1399.98px){.modal-fullscreen-xxl-down{height:100%;margin:0;max-width:none;width:100vw}.modal-fullscreen-xxl-down .modal-content{border:0;border-radius:0;height:100%}.modal-fullscreen-xxl-down .modal-footer,.modal-fullscreen-xxl-down .modal-header{border-radius:0}.modal-fullscreen-xxl-down .modal-body{overflow-y:auto}}.tooltip{--bs-tooltip-zindex:1080;--bs-tooltip-max-width:200px;--bs-tooltip-padding-x:0.5rem;--bs-tooltip-padding-y:0.25rem;--bs-tooltip-margin: ;--bs-tooltip-font-size:0.875rem;--bs-tooltip-color:var(--bs-body-bg);--bs-tooltip-bg:var(--bs-emphasis-color);--bs-tooltip-border-radius:var(--bs-border-radius);--bs-tooltip-opacity:0.9;--bs-tooltip-arrow-width:0.8rem;--bs-tooltip-arrow-height:0.4rem;word-wrap:break-word;display:block;font-family:system-ui,-apple-system,Segoe UI,Roboto,Helvetica Neue,Noto Sans,Liberation Sans,Arial,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol,Noto Color Emoji;font-family:var(--bs-font-sans-serif);font-size:var(--bs-tooltip-font-size);font-style:normal;font-weight:400;letter-spacing:normal;line-break:auto;line-height:1.5;margin:var(--bs-tooltip-margin);opacity:0;text-align:left;text-align:start;text-decoration:none;text-shadow:none;text-transform:none;white-space:normal;word-break:normal;word-spacing:normal;z-index:var(--bs-tooltip-zindex)}.tooltip.show{opacity:var(--bs-tooltip-opacity)}.tooltip .tooltip-arrow{display:block;height:var(--bs-tooltip-arrow-height);width:var(--bs-tooltip-arrow-width)}.tooltip .tooltip-arrow:before{border-color:transparent;border-style:solid;content:"";position:absolute}.bs-tooltip-auto[data-popper-placement^=top] .tooltip-arrow,.bs-tooltip-top .tooltip-arrow{bottom:calc(var(--bs-tooltip-arrow-height)*-1)}.bs-tooltip-auto[data-popper-placement^=top] .tooltip-arrow:before,.bs-tooltip-top .tooltip-arrow:before{border-top-color:var(--bs-tooltip-bg);border-width:var(--bs-tooltip-arrow-height) calc(var(--bs-tooltip-arrow-width)*.5) 0;top:-1px}.bs-tooltip-auto[data-popper-placement^=right] .tooltip-arrow,.bs-tooltip-end .tooltip-arrow{height:var(--bs-tooltip-arrow-width);left:calc(var(--bs-tooltip-arrow-height)*-1);width:var(--bs-tooltip-arrow-height)}.bs-tooltip-auto[data-popper-placement^=right] .tooltip-arrow:before,.bs-tooltip-end .tooltip-arrow:before{border-right-color:var(--bs-tooltip-bg);border-width:calc(var(--bs-tooltip-arrow-width)*.5) var(--bs-tooltip-arrow-height) calc(var(--bs-tooltip-arrow-width)*.5) 0;right:-1px}.bs-tooltip-auto[data-popper-placement^=bottom] .tooltip-arrow,.bs-tooltip-bottom .tooltip-arrow{top:calc(var(--bs-tooltip-arrow-height)*-1)}.bs-tooltip-auto[data-popper-placement^=bottom] .tooltip-arrow:before,.bs-tooltip-bottom .tooltip-arrow:before{border-bottom-color:var(--bs-tooltip-bg);border-width:0 calc(var(--bs-tooltip-arrow-width)*.5) var(--bs-tooltip-arrow-height);bottom:-1px}.bs-tooltip-auto[data-popper-placement^=left] .tooltip-arrow,.bs-tooltip-start .tooltip-arrow{height:var(--bs-tooltip-arrow-width);right:calc(var(--bs-tooltip-arrow-height)*-1);width:var(--bs-tooltip-arrow-height)}.bs-tooltip-auto[data-popper-placement^=left] .tooltip-arrow:before,.bs-tooltip-start .tooltip-arrow:before{border-left-color:var(--bs-tooltip-bg);border-width:calc(var(--bs-tooltip-arrow-width)*.5) 0 calc(var(--bs-tooltip-arrow-width)*.5) var(--bs-tooltip-arrow-height);left:-1px}.tooltip-inner{background-color:var(--bs-tooltip-bg);border-radius:var(--bs-tooltip-border-radius);color:var(--bs-tooltip-color);max-width:var(--bs-tooltip-max-width);padding:var(--bs-tooltip-padding-y) var(--bs-tooltip-padding-x);text-align:center}.popover{--bs-popover-zindex:1070;--bs-popover-max-width:276px;--bs-popover-font-size:0.875rem;--bs-popover-bg:var(--bs-body-bg);--bs-popover-border-width:var(--bs-border-width);--bs-popover-border-color:var(--bs-border-color-translucent);--bs-popover-border-radius:var(--bs-border-radius-lg);--bs-popover-inner-border-radius:calc(var(--bs-border-radius-lg) - var(--bs-border-width));--bs-popover-box-shadow:var(--bs-box-shadow);--bs-popover-header-padding-x:1rem;--bs-popover-header-padding-y:0.5rem;--bs-popover-header-font-size:1rem;--bs-popover-header-color:inherit;--bs-popover-header-bg:var(--bs-secondary-bg);--bs-popover-body-padding-x:1rem;--bs-popover-body-padding-y:1rem;--bs-popover-body-color:var(--bs-body-color);--bs-popover-arrow-width:1rem;--bs-popover-arrow-height:0.5rem;--bs-popover-arrow-border:var(--bs-popover-border-color);word-wrap:break-word;background-clip:padding-box;background-color:var(--bs-popover-bg);border:var(--bs-popover-border-width) solid var(--bs-popover-border-color);border-radius:var(--bs-popover-border-radius);display:block;font-family:system-ui,-apple-system,Segoe UI,Roboto,Helvetica Neue,Noto Sans,Liberation Sans,Arial,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol,Noto Color Emoji;font-family:var(--bs-font-sans-serif);font-size:var(--bs-popover-font-size);font-style:normal;font-weight:400;letter-spacing:normal;line-break:auto;line-height:1.5;max-width:var(--bs-popover-max-width);text-align:left;text-align:start;text-decoration:none;text-shadow:none;text-transform:none;white-space:normal;word-break:normal;word-spacing:normal;z-index:var(--bs-popover-zindex)}.popover .popover-arrow{display:block;height:var(--bs-popover-arrow-height);width:var(--bs-popover-arrow-width)}.popover .popover-arrow:after,.popover .popover-arrow:before{border:0 solid transparent;content:"";display:block;position:absolute}.bs-popover-auto[data-popper-placement^=top]>.popover-arrow,.bs-popover-top>.popover-arrow{bottom:calc((var(--bs-popover-arrow-height))*-1 - var(--bs-popover-border-width))}.bs-popover-auto[data-popper-placement^=top]>.popover-arrow:after,.bs-popover-auto[data-popper-placement^=top]>.popover-arrow:before,.bs-popover-top>.popover-arrow:after,.bs-popover-top>.popover-arrow:before{border-width:var(--bs-popover-arrow-height) calc(var(--bs-popover-arrow-width)*.5) 0}.bs-popover-auto[data-popper-placement^=top]>.popover-arrow:before,.bs-popover-top>.popover-arrow:before{border-top-color:var(--bs-popover-arrow-border);bottom:0}.bs-popover-auto[data-popper-placement^=top]>.popover-arrow:after,.bs-popover-top>.popover-arrow:after{border-top-color:var(--bs-popover-bg);bottom:var(--bs-popover-border-width)}.bs-popover-auto[data-popper-placement^=right]>.popover-arrow,.bs-popover-end>.popover-arrow{height:var(--bs-popover-arrow-width);left:calc((var(--bs-popover-arrow-height))*-1 - var(--bs-popover-border-width));width:var(--bs-popover-arrow-height)}.bs-popover-auto[data-popper-placement^=right]>.popover-arrow:after,.bs-popover-auto[data-popper-placement^=right]>.popover-arrow:before,.bs-popover-end>.popover-arrow:after,.bs-popover-end>.popover-arrow:before{border-width:calc(var(--bs-popover-arrow-width)*.5) var(--bs-popover-arrow-height) calc(var(--bs-popover-arrow-width)*.5) 0}.bs-popover-auto[data-popper-placement^=right]>.popover-arrow:before,.bs-popover-end>.popover-arrow:before{border-right-color:var(--bs-popover-arrow-border);left:0}.bs-popover-auto[data-popper-placement^=right]>.popover-arrow:after,.bs-popover-end>.popover-arrow:after{border-right-color:var(--bs-popover-bg);left:var(--bs-popover-border-width)}.bs-popover-auto[data-popper-placement^=bottom]>.popover-arrow,.bs-popover-bottom>.popover-arrow{top:calc((var(--bs-popover-arrow-height))*-1 - var(--bs-popover-border-width))}.bs-popover-auto[data-popper-placement^=bottom]>.popover-arrow:after,.bs-popover-auto[data-popper-placement^=bottom]>.popover-arrow:before,.bs-popover-bottom>.popover-arrow:after,.bs-popover-bottom>.popover-arrow:before{border-width:0 calc(var(--bs-popover-arrow-width)*.5) var(--bs-popover-arrow-height)}.bs-popover-auto[data-popper-placement^=bottom]>.popover-arrow:before,.bs-popover-bottom>.popover-arrow:before{border-bottom-color:var(--bs-popover-arrow-border);top:0}.bs-popover-auto[data-popper-placement^=bottom]>.popover-arrow:after,.bs-popover-bottom>.popover-arrow:after{border-bottom-color:var(--bs-popover-bg);top:var(--bs-popover-border-width)}.bs-popover-auto[data-popper-placement^=bottom] .popover-header:before,.bs-popover-bottom .popover-header:before{border-bottom:var(--bs-popover-border-width) solid var(--bs-popover-header-bg);content:"";display:block;left:50%;margin-left:calc(var(--bs-popover-arrow-width)*-.5);position:absolute;top:0;width:var(--bs-popover-arrow-width)}.bs-popover-auto[data-popper-placement^=left]>.popover-arrow,.bs-popover-start>.popover-arrow{height:var(--bs-popover-arrow-width);right:calc((var(--bs-popover-arrow-height))*-1 - var(--bs-popover-border-width));width:var(--bs-popover-arrow-height)}.bs-popover-auto[data-popper-placement^=left]>.popover-arrow:after,.bs-popover-auto[data-popper-placement^=left]>.popover-arrow:before,.bs-popover-start>.popover-arrow:after,.bs-popover-start>.popover-arrow:before{border-width:calc(var(--bs-popover-arrow-width)*.5) 0 calc(var(--bs-popover-arrow-width)*.5) var(--bs-popover-arrow-height)}.bs-popover-auto[data-popper-placement^=left]>.popover-arrow:before,.bs-popover-start>.popover-arrow:before{border-left-color:var(--bs-popover-arrow-border);right:0}.bs-popover-auto[data-popper-placement^=left]>.popover-arrow:after,.bs-popover-start>.popover-arrow:after{border-left-color:var(--bs-popover-bg);right:var(--bs-popover-border-width)}.popover-header{background-color:var(--bs-popover-header-bg);border-bottom:var(--bs-popover-border-width) solid var(--bs-popover-border-color);border-top-left-radius:var(--bs-popover-inner-border-radius);border-top-right-radius:var(--bs-popover-inner-border-radius);color:var(--bs-popover-header-color);font-size:var(--bs-popover-header-font-size);margin-bottom:0;padding:var(--bs-popover-header-padding-y) var(--bs-popover-header-padding-x)}.popover-header:empty{display:none}.popover-body{color:var(--bs-popover-body-color);padding:var(--bs-popover-body-padding-y) var(--bs-popover-body-padding-x)}.carousel{position:relative}.carousel.pointer-event{touch-action:pan-y}.carousel-inner{overflow:hidden;position:relative;width:100%}.carousel-inner:after{clear:both;content:"";display:block}.carousel-item{-webkit-backface-visibility:hidden;backface-visibility:hidden;display:none;float:left;margin-right:-100%;position:relative;transition:-webkit-transform .6s ease-in-out;transition:transform .6s ease-in-out;transition:transform .6s ease-in-out,-webkit-transform .6s ease-in-out;width:100%}@media (prefers-reduced-motion:reduce){.carousel-item{transition:none}}.carousel-item-next,.carousel-item-prev,.carousel-item.active{display:block}.active.carousel-item-end,.carousel-item-next:not(.carousel-item-start){-webkit-transform:translateX(100%);transform:translateX(100%)}.active.carousel-item-start,.carousel-item-prev:not(.carousel-item-end){-webkit-transform:translateX(-100%);transform:translateX(-100%)}.carousel-fade .carousel-item{opacity:0;-webkit-transform:none;transform:none;transition-property:opacity}.carousel-fade .carousel-item-next.carousel-item-start,.carousel-fade .carousel-item-prev.carousel-item-end,.carousel-fade .carousel-item.active{opacity:1;z-index:1}.carousel-fade .active.carousel-item-end,.carousel-fade .active.carousel-item-start{opacity:0;transition:opacity 0s .6s;z-index:0}@media (prefers-reduced-motion:reduce){.carousel-fade .active.carousel-item-end,.carousel-fade .active.carousel-item-start{transition:none}}.carousel-control-next,.carousel-control-prev{align-items:center;background:none;border:0;bottom:0;color:#fff;display:flex;justify-content:center;opacity:.5;padding:0;position:absolute;text-align:center;top:0;transition:opacity .15s ease;width:15%;z-index:1}@media (prefers-reduced-motion:reduce){.carousel-control-next,.carousel-control-prev{transition:none}}.carousel-control-next:focus,.carousel-control-next:hover,.carousel-control-prev:focus,.carousel-control-prev:hover{color:#fff;opacity:.9;outline:0;text-decoration:none}.carousel-control-prev{left:0}.carousel-control-next{right:0}.carousel-control-next-icon,.carousel-control-prev-icon{background-position:50%;background-repeat:no-repeat;background-size:100% 100%;display:inline-block;height:2rem;width:2rem}.carousel-control-prev-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='%23fff'%3E%3Cpath d='M11.354 1.646a.5.5 0 0 1 0 .708L5.707 8l5.647 5.646a.5.5 0 0 1-.708.708l-6-6a.5.5 0 0 1 0-.708l6-6a.5.5 0 0 1 .708 0z'/%3E%3C/svg%3E")}.carousel-control-next-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='%23fff'%3E%3Cpath d='M4.646 1.646a.5.5 0 0 1 .708 0l6 6a.5.5 0 0 1 0 .708l-6 6a.5.5 0 0 1-.708-.708L10.293 8 4.646 2.354a.5.5 0 0 1 0-.708z'/%3E%3C/svg%3E")}.carousel-indicators{bottom:0;display:flex;justify-content:center;left:0;margin-bottom:1rem;margin-left:15%;margin-right:15%;padding:0;position:absolute;right:0;z-index:2}.carousel-indicators [data-bs-target]{background-clip:padding-box;background-color:#fff;border:0;border-bottom:10px solid transparent;border-top:10px solid transparent;box-sizing:initial;cursor:pointer;flex:0 1 auto;height:3px;margin-left:3px;margin-right:3px;opacity:.5;padding:0;text-indent:-999px;transition:opacity .6s ease;width:30px}@media (prefers-reduced-motion:reduce){.carousel-indicators [data-bs-target]{transition:none}}.carousel-indicators .active{opacity:1}.carousel-caption{bottom:1.25rem;color:#fff;left:15%;padding-bottom:1.25rem;padding-top:1.25rem;position:absolute;right:15%;text-align:center}.carousel-dark .carousel-control-next-icon,.carousel-dark .carousel-control-prev-icon{-webkit-filter:invert(1) grayscale(100);filter:invert(1) grayscale(100)}.carousel-dark .carousel-indicators [data-bs-target]{background-color:#000}.carousel-dark .carousel-caption{color:#000}[data-bs-theme=dark] .carousel .carousel-control-next-icon,[data-bs-theme=dark] .carousel .carousel-control-prev-icon,[data-bs-theme=dark].carousel .carousel-control-next-icon,[data-bs-theme=dark].carousel .carousel-control-prev-icon{-webkit-filter:invert(1) grayscale(100);filter:invert(1) grayscale(100)}[data-bs-theme=dark] .carousel .carousel-indicators [data-bs-target],[data-bs-theme=dark].carousel .carousel-indicators [data-bs-target]{background-color:#000}[data-bs-theme=dark] .carousel .carousel-caption,[data-bs-theme=dark].carousel .carousel-caption{color:#000}.spinner-border,.spinner-grow{-webkit-animation:var(--bs-spinner-animation-speed) linear infinite var(--bs-spinner-animation-name);animation:var(--bs-spinner-animation-speed) linear infinite var(--bs-spinner-animation-name);border-radius:50%;display:inline-block;height:var(--bs-spinner-height);vertical-align:var(--bs-spinner-vertical-align);width:var(--bs-spinner-width)}@-webkit-keyframes spinner-border{to{-webkit-transform:rotate(1turn);transform:rotate(1turn)}}@keyframes spinner-border{to{-webkit-transform:rotate(1turn);transform:rotate(1turn)}}.spinner-border{--bs-spinner-width:2rem;--bs-spinner-height:2rem;--bs-spinner-vertical-align:-0.125em;--bs-spinner-border-width:0.25em;--bs-spinner-animation-speed:0.75s;--bs-spinner-animation-name:spinner-border;border-right-color:currentcolor;border:var(--bs-spinner-border-width) solid;border-right:var(--bs-spinner-border-width) solid transparent}.spinner-border-sm{--bs-spinner-width:1rem;--bs-spinner-height:1rem;--bs-spinner-border-width:0.2em}@-webkit-keyframes spinner-grow{0%{-webkit-transform:scale(0);transform:scale(0)}50%{opacity:1;-webkit-transform:none;transform:none}}@keyframes spinner-grow{0%{-webkit-transform:scale(0);transform:scale(0)}50%{opacity:1;-webkit-transform:none;transform:none}}.spinner-grow{--bs-spinner-width:2rem;--bs-spinner-height:2rem;--bs-spinner-vertical-align:-0.125em;--bs-spinner-animation-speed:0.75s;--bs-spinner-animation-name:spinner-grow;background-color:currentcolor;opacity:0}.spinner-grow-sm{--bs-spinner-width:1rem;--bs-spinner-height:1rem}@media (prefers-reduced-motion:reduce){.spinner-border,.spinner-grow{--bs-spinner-animation-speed:1.5s}}.offcanvas,.offcanvas-lg,.offcanvas-md,.offcanvas-sm,.offcanvas-xl,.offcanvas-xxl{--bs-offcanvas-zindex:1045;--bs-offcanvas-width:400px;--bs-offcanvas-height:30vh;--bs-offcanvas-padding-x:1rem;--bs-offcanvas-padding-y:1rem;--bs-offcanvas-color:var(--bs-body-color);--bs-offcanvas-bg:var(--bs-body-bg);--bs-offcanvas-border-width:var(--bs-border-width);--bs-offcanvas-border-color:var(--bs-border-color-translucent);--bs-offcanvas-box-shadow:var(--bs-box-shadow-sm);--bs-offcanvas-transition:transform 0.3s ease-in-out;--bs-offcanvas-title-line-height:1.5}@media (max-width:575.98px){.offcanvas-sm{background-clip:padding-box;background-color:var(--bs-offcanvas-bg);bottom:0;color:var(--bs-offcanvas-color);display:flex;flex-direction:column;max-width:100%;outline:0;position:fixed;transition:var(--bs-offcanvas-transition);visibility:hidden;z-index:var(--bs-offcanvas-zindex)}}@media (max-width:575.98px) and (prefers-reduced-motion:reduce){.offcanvas-sm{transition:none}}@media (max-width:575.98px){.offcanvas-sm.offcanvas-start{border-right:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);left:0;top:0;-webkit-transform:translateX(-100%);transform:translateX(-100%);width:var(--bs-offcanvas-width)}.offcanvas-sm.offcanvas-end{border-left:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);right:0;top:0;-webkit-transform:translateX(100%);transform:translateX(100%);width:var(--bs-offcanvas-width)}.offcanvas-sm.offcanvas-top{border-bottom:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);top:0;-webkit-transform:translateY(-100%);transform:translateY(-100%)}.offcanvas-sm.offcanvas-bottom,.offcanvas-sm.offcanvas-top{height:var(--bs-offcanvas-height);left:0;max-height:100%;right:0}.offcanvas-sm.offcanvas-bottom{border-top:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);-webkit-transform:translateY(100%);transform:translateY(100%)}.offcanvas-sm.show:not(.hiding),.offcanvas-sm.showing{-webkit-transform:none;transform:none}.offcanvas-sm.hiding,.offcanvas-sm.show,.offcanvas-sm.showing{visibility:visible}}@media (min-width:576px){.offcanvas-sm{--bs-offcanvas-height:auto;--bs-offcanvas-border-width:0;background-color:initial!important}.offcanvas-sm .offcanvas-header{display:none}.offcanvas-sm .offcanvas-body{background-color:initial!important;display:flex;flex-grow:0;overflow-y:visible;padding:0}}@media (max-width:767.98px){.offcanvas-md{background-clip:padding-box;background-color:var(--bs-offcanvas-bg);bottom:0;color:var(--bs-offcanvas-color);display:flex;flex-direction:column;max-width:100%;outline:0;position:fixed;transition:var(--bs-offcanvas-transition);visibility:hidden;z-index:var(--bs-offcanvas-zindex)}}@media (max-width:767.98px) and (prefers-reduced-motion:reduce){.offcanvas-md{transition:none}}@media (max-width:767.98px){.offcanvas-md.offcanvas-start{border-right:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);left:0;top:0;-webkit-transform:translateX(-100%);transform:translateX(-100%);width:var(--bs-offcanvas-width)}.offcanvas-md.offcanvas-end{border-left:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);right:0;top:0;-webkit-transform:translateX(100%);transform:translateX(100%);width:var(--bs-offcanvas-width)}.offcanvas-md.offcanvas-top{border-bottom:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);top:0;-webkit-transform:translateY(-100%);transform:translateY(-100%)}.offcanvas-md.offcanvas-bottom,.offcanvas-md.offcanvas-top{height:var(--bs-offcanvas-height);left:0;max-height:100%;right:0}.offcanvas-md.offcanvas-bottom{border-top:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);-webkit-transform:translateY(100%);transform:translateY(100%)}.offcanvas-md.show:not(.hiding),.offcanvas-md.showing{-webkit-transform:none;transform:none}.offcanvas-md.hiding,.offcanvas-md.show,.offcanvas-md.showing{visibility:visible}}@media (min-width:768px){.offcanvas-md{--bs-offcanvas-height:auto;--bs-offcanvas-border-width:0;background-color:initial!important}.offcanvas-md .offcanvas-header{display:none}.offcanvas-md .offcanvas-body{background-color:initial!important;display:flex;flex-grow:0;overflow-y:visible;padding:0}}@media (max-width:991.98px){.offcanvas-lg{background-clip:padding-box;background-color:var(--bs-offcanvas-bg);bottom:0;color:var(--bs-offcanvas-color);display:flex;flex-direction:column;max-width:100%;outline:0;position:fixed;transition:var(--bs-offcanvas-transition);visibility:hidden;z-index:var(--bs-offcanvas-zindex)}}@media (max-width:991.98px) and (prefers-reduced-motion:reduce){.offcanvas-lg{transition:none}}@media (max-width:991.98px){.offcanvas-lg.offcanvas-start{border-right:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);left:0;top:0;-webkit-transform:translateX(-100%);transform:translateX(-100%);width:var(--bs-offcanvas-width)}.offcanvas-lg.offcanvas-end{border-left:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);right:0;top:0;-webkit-transform:translateX(100%);transform:translateX(100%);width:var(--bs-offcanvas-width)}.offcanvas-lg.offcanvas-top{border-bottom:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);top:0;-webkit-transform:translateY(-100%);transform:translateY(-100%)}.offcanvas-lg.offcanvas-bottom,.offcanvas-lg.offcanvas-top{height:var(--bs-offcanvas-height);left:0;max-height:100%;right:0}.offcanvas-lg.offcanvas-bottom{border-top:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);-webkit-transform:translateY(100%);transform:translateY(100%)}.offcanvas-lg.show:not(.hiding),.offcanvas-lg.showing{-webkit-transform:none;transform:none}.offcanvas-lg.hiding,.offcanvas-lg.show,.offcanvas-lg.showing{visibility:visible}}@media (min-width:992px){.offcanvas-lg{--bs-offcanvas-height:auto;--bs-offcanvas-border-width:0;background-color:initial!important}.offcanvas-lg .offcanvas-header{display:none}.offcanvas-lg .offcanvas-body{background-color:initial!important;display:flex;flex-grow:0;overflow-y:visible;padding:0}}@media (max-width:1199.98px){.offcanvas-xl{background-clip:padding-box;background-color:var(--bs-offcanvas-bg);bottom:0;color:var(--bs-offcanvas-color);display:flex;flex-direction:column;max-width:100%;outline:0;position:fixed;transition:var(--bs-offcanvas-transition);visibility:hidden;z-index:var(--bs-offcanvas-zindex)}}@media (max-width:1199.98px) and (prefers-reduced-motion:reduce){.offcanvas-xl{transition:none}}@media (max-width:1199.98px){.offcanvas-xl.offcanvas-start{border-right:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);left:0;top:0;-webkit-transform:translateX(-100%);transform:translateX(-100%);width:var(--bs-offcanvas-width)}.offcanvas-xl.offcanvas-end{border-left:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);right:0;top:0;-webkit-transform:translateX(100%);transform:translateX(100%);width:var(--bs-offcanvas-width)}.offcanvas-xl.offcanvas-top{border-bottom:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);top:0;-webkit-transform:translateY(-100%);transform:translateY(-100%)}.offcanvas-xl.offcanvas-bottom,.offcanvas-xl.offcanvas-top{height:var(--bs-offcanvas-height);left:0;max-height:100%;right:0}.offcanvas-xl.offcanvas-bottom{border-top:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);-webkit-transform:translateY(100%);transform:translateY(100%)}.offcanvas-xl.show:not(.hiding),.offcanvas-xl.showing{-webkit-transform:none;transform:none}.offcanvas-xl.hiding,.offcanvas-xl.show,.offcanvas-xl.showing{visibility:visible}}@media (min-width:1200px){.offcanvas-xl{--bs-offcanvas-height:auto;--bs-offcanvas-border-width:0;background-color:initial!important}.offcanvas-xl .offcanvas-header{display:none}.offcanvas-xl .offcanvas-body{background-color:initial!important;display:flex;flex-grow:0;overflow-y:visible;padding:0}}@media (max-width:1399.98px){.offcanvas-xxl{background-clip:padding-box;background-color:var(--bs-offcanvas-bg);bottom:0;color:var(--bs-offcanvas-color);display:flex;flex-direction:column;max-width:100%;outline:0;position:fixed;transition:var(--bs-offcanvas-transition);visibility:hidden;z-index:var(--bs-offcanvas-zindex)}}@media (max-width:1399.98px) and (prefers-reduced-motion:reduce){.offcanvas-xxl{transition:none}}@media (max-width:1399.98px){.offcanvas-xxl.offcanvas-start{border-right:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);left:0;top:0;-webkit-transform:translateX(-100%);transform:translateX(-100%);width:var(--bs-offcanvas-width)}.offcanvas-xxl.offcanvas-end{border-left:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);right:0;top:0;-webkit-transform:translateX(100%);transform:translateX(100%);width:var(--bs-offcanvas-width)}.offcanvas-xxl.offcanvas-top{border-bottom:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);top:0;-webkit-transform:translateY(-100%);transform:translateY(-100%)}.offcanvas-xxl.offcanvas-bottom,.offcanvas-xxl.offcanvas-top{height:var(--bs-offcanvas-height);left:0;max-height:100%;right:0}.offcanvas-xxl.offcanvas-bottom{border-top:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);-webkit-transform:translateY(100%);transform:translateY(100%)}.offcanvas-xxl.show:not(.hiding),.offcanvas-xxl.showing{-webkit-transform:none;transform:none}.offcanvas-xxl.hiding,.offcanvas-xxl.show,.offcanvas-xxl.showing{visibility:visible}}@media (min-width:1400px){.offcanvas-xxl{--bs-offcanvas-height:auto;--bs-offcanvas-border-width:0;background-color:initial!important}.offcanvas-xxl .offcanvas-header{display:none}.offcanvas-xxl .offcanvas-body{background-color:initial!important;display:flex;flex-grow:0;overflow-y:visible;padding:0}}.offcanvas{background-clip:padding-box;background-color:var(--bs-offcanvas-bg);bottom:0;color:var(--bs-offcanvas-color);display:flex;flex-direction:column;max-width:100%;outline:0;position:fixed;transition:var(--bs-offcanvas-transition);visibility:hidden;z-index:var(--bs-offcanvas-zindex)}@media (prefers-reduced-motion:reduce){.offcanvas{transition:none}}.offcanvas.offcanvas-start{border-right:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);left:0;top:0;-webkit-transform:translateX(-100%);transform:translateX(-100%);width:var(--bs-offcanvas-width)}.offcanvas.offcanvas-end{border-left:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);right:0;top:0;-webkit-transform:translateX(100%);transform:translateX(100%);width:var(--bs-offcanvas-width)}.offcanvas.offcanvas-top{border-bottom:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);top:0;-webkit-transform:translateY(-100%);transform:translateY(-100%)}.offcanvas.offcanvas-bottom,.offcanvas.offcanvas-top{height:var(--bs-offcanvas-height);left:0;max-height:100%;right:0}.offcanvas.offcanvas-bottom{border-top:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);-webkit-transform:translateY(100%);transform:translateY(100%)}.offcanvas.show:not(.hiding),.offcanvas.showing{-webkit-transform:none;transform:none}.offcanvas.hiding,.offcanvas.show,.offcanvas.showing{visibility:visible}.offcanvas-backdrop{background-color:#000;height:100vh;left:0;position:fixed;top:0;width:100vw;z-index:1040}.offcanvas-backdrop.fade{opacity:0}.offcanvas-backdrop.show{opacity:.5}.offcanvas-header{align-items:center;display:flex;justify-content:space-between;padding:var(--bs-offcanvas-padding-y) var(--bs-offcanvas-padding-x)}.offcanvas-header .btn-close{margin-bottom:calc(var(--bs-offcanvas-padding-y)*-.5);margin-right:calc(var(--bs-offcanvas-padding-x)*-.5);margin-top:calc(var(--bs-offcanvas-padding-y)*-.5);padding:calc(var(--bs-offcanvas-padding-y)*.5) calc(var(--bs-offcanvas-padding-x)*.5)}.offcanvas-title{line-height:var(--bs-offcanvas-title-line-height);margin-bottom:0}.offcanvas-body{flex-grow:1;overflow-y:auto;padding:var(--bs-offcanvas-padding-y) var(--bs-offcanvas-padding-x)}.placeholder{background-color:currentcolor;cursor:wait;display:inline-block;min-height:1em;opacity:.5;vertical-align:middle}.placeholder.btn:before{content:"";display:inline-block}.placeholder-xs{min-height:.6em}.placeholder-sm{min-height:.8em}.placeholder-lg{min-height:1.2em}.placeholder-glow .placeholder{-webkit-animation:placeholder-glow 2s ease-in-out infinite;animation:placeholder-glow 2s ease-in-out infinite}@-webkit-keyframes placeholder-glow{50%{opacity:.2}}@keyframes placeholder-glow{50%{opacity:.2}}.placeholder-wave{-webkit-animation:placeholder-wave 2s linear infinite;animation:placeholder-wave 2s linear infinite;-webkit-mask-image:linear-gradient(130deg,#000 55%,rgba(0,0,0,.8) 75%,#000 95%);mask-image:linear-gradient(130deg,#000 55%,rgba(0,0,0,.8) 75%,#000 95%);-webkit-mask-size:200% 100%;mask-size:200% 100%}@-webkit-keyframes placeholder-wave{to{-webkit-mask-position:-200% 0;mask-position:-200% 0}}@keyframes placeholder-wave{to{-webkit-mask-position:-200% 0;mask-position:-200% 0}}.clearfix:after{clear:both;content:"";display:block}.text-bg-primary{background-color:#0d6efd!important;background-color:RGBA(var(--bs-primary-rgb),var(--bs-bg-opacity,1))!important;color:#fff!important}.text-bg-secondary{background-color:#6c757d!important;background-color:RGBA(var(--bs-secondary-rgb),var(--bs-bg-opacity,1))!important;color:#fff!important}.text-bg-success{background-color:#198754!important;background-color:RGBA(var(--bs-success-rgb),var(--bs-bg-opacity,1))!important;color:#fff!important}.text-bg-info{background-color:#0dcaf0!important;background-color:RGBA(var(--bs-info-rgb),var(--bs-bg-opacity,1))!important;color:#000!important}.text-bg-warning{background-color:#ffc107!important;background-color:RGBA(var(--bs-warning-rgb),var(--bs-bg-opacity,1))!important;color:#000!important}.text-bg-danger{background-color:#dc3545!important;background-color:RGBA(var(--bs-danger-rgb),var(--bs-bg-opacity,1))!important;color:#fff!important}.text-bg-light{background-color:#f8f9fa!important;background-color:RGBA(var(--bs-light-rgb),var(--bs-bg-opacity,1))!important;color:#000!important}.text-bg-dark{background-color:#212529!important;background-color:RGBA(var(--bs-dark-rgb),var(--bs-bg-opacity,1))!important;color:#fff!important}.link-primary{color:#0d6efd!important;color:RGBA(var(--bs-primary-rgb),var(--bs-link-opacity,1))!important;text-decoration-color:#0d6efd!important;text-decoration-color:RGBA(var(--bs-primary-rgb),var(--bs-link-underline-opacity,1))!important}.link-primary:focus,.link-primary:hover{color:#0a58ca!important;color:RGBA(10,88,202,var(--bs-link-opacity,1))!important;text-decoration-color:#0a58ca!important;text-decoration-color:RGBA(10,88,202,var(--bs-link-underline-opacity,1))!important}.link-secondary{color:#6c757d!important;color:RGBA(var(--bs-secondary-rgb),var(--bs-link-opacity,1))!important;text-decoration-color:#6c757d!important;text-decoration-color:RGBA(var(--bs-secondary-rgb),var(--bs-link-underline-opacity,1))!important}.link-secondary:focus,.link-secondary:hover{color:#565e64!important;color:RGBA(86,94,100,var(--bs-link-opacity,1))!important;text-decoration-color:#565e64!important;text-decoration-color:RGBA(86,94,100,var(--bs-link-underline-opacity,1))!important}.link-success{color:#198754!important;color:RGBA(var(--bs-success-rgb),var(--bs-link-opacity,1))!important;text-decoration-color:#198754!important;text-decoration-color:RGBA(var(--bs-success-rgb),var(--bs-link-underline-opacity,1))!important}.link-success:focus,.link-success:hover{color:#146c43!important;color:RGBA(20,108,67,var(--bs-link-opacity,1))!important;text-decoration-color:#146c43!important;text-decoration-color:RGBA(20,108,67,var(--bs-link-underline-opacity,1))!important}.link-info{color:#0dcaf0!important;color:RGBA(var(--bs-info-rgb),var(--bs-link-opacity,1))!important;text-decoration-color:#0dcaf0!important;text-decoration-color:RGBA(var(--bs-info-rgb),var(--bs-link-underline-opacity,1))!important}.link-info:focus,.link-info:hover{color:#3dd5f3!important;color:RGBA(61,213,243,var(--bs-link-opacity,1))!important;text-decoration-color:#3dd5f3!important;text-decoration-color:RGBA(61,213,243,var(--bs-link-underline-opacity,1))!important}.link-warning{color:#ffc107!important;color:RGBA(var(--bs-warning-rgb),var(--bs-link-opacity,1))!important;text-decoration-color:#ffc107!important;text-decoration-color:RGBA(var(--bs-warning-rgb),var(--bs-link-underline-opacity,1))!important}.link-warning:focus,.link-warning:hover{color:#ffcd39!important;color:RGBA(255,205,57,var(--bs-link-opacity,1))!important;text-decoration-color:#ffcd39!important;text-decoration-color:RGBA(255,205,57,var(--bs-link-underline-opacity,1))!important}.link-danger{color:#dc3545!important;color:RGBA(var(--bs-danger-rgb),var(--bs-link-opacity,1))!important;text-decoration-color:#dc3545!important;text-decoration-color:RGBA(var(--bs-danger-rgb),var(--bs-link-underline-opacity,1))!important}.link-danger:focus,.link-danger:hover{color:#b02a37!important;color:RGBA(176,42,55,var(--bs-link-opacity,1))!important;text-decoration-color:#b02a37!important;text-decoration-color:RGBA(176,42,55,var(--bs-link-underline-opacity,1))!important}.link-light{color:#f8f9fa!important;color:RGBA(var(--bs-light-rgb),var(--bs-link-opacity,1))!important;text-decoration-color:#f8f9fa!important;text-decoration-color:RGBA(var(--bs-light-rgb),var(--bs-link-underline-opacity,1))!important}.link-light:focus,.link-light:hover{color:#f9fafb!important;color:RGBA(249,250,251,var(--bs-link-opacity,1))!important;text-decoration-color:#f9fafb!important;text-decoration-color:RGBA(249,250,251,var(--bs-link-underline-opacity,1))!important}.link-dark{color:#212529!important;color:RGBA(var(--bs-dark-rgb),var(--bs-link-opacity,1))!important;text-decoration-color:#212529!important;text-decoration-color:RGBA(var(--bs-dark-rgb),var(--bs-link-underline-opacity,1))!important}.link-dark:focus,.link-dark:hover{color:#1a1e21!important;color:RGBA(26,30,33,var(--bs-link-opacity,1))!important;text-decoration-color:#1a1e21!important;text-decoration-color:RGBA(26,30,33,var(--bs-link-underline-opacity,1))!important}.link-body-emphasis{color:#000!important;color:RGBA(var(--bs-emphasis-color-rgb),var(--bs-link-opacity,1))!important;text-decoration-color:#000!important;text-decoration-color:RGBA(var(--bs-emphasis-color-rgb),var(--bs-link-underline-opacity,1))!important}.link-body-emphasis:focus,.link-body-emphasis:hover{color:rgba(0,0,0,.75)!important;color:RGBA(var(--bs-emphasis-color-rgb),var(--bs-link-opacity,.75))!important;text-decoration-color:rgba(0,0,0,.75)!important;text-decoration-color:RGBA(var(--bs-emphasis-color-rgb),var(--bs-link-underline-opacity,.75))!important}.focus-ring:focus{box-shadow:0 0 0 .25rem rgba(13,110,253,.25);box-shadow:var(--bs-focus-ring-x,0) var(--bs-focus-ring-y,0) var(--bs-focus-ring-blur,0) var(--bs-focus-ring-width) var(--bs-focus-ring-color);outline:0}.icon-link{align-items:center;-webkit-backface-visibility:hidden;backface-visibility:hidden;display:inline-flex;gap:.375rem;text-decoration-color:rgba(13,110,253,.5);text-decoration-color:rgba(var(--bs-link-color-rgb),var(--bs-link-opacity,.5));text-underline-offset:.25em}.icon-link>.bi{fill:currentcolor;flex-shrink:0;height:1em;transition:transform .2s ease-in-out;width:1em}@media (prefers-reduced-motion:reduce){.icon-link>.bi{transition:none}}.icon-link-hover:focus-visible>.bi,.icon-link-hover:hover>.bi{-webkit-transform:translate3d(.25em,0,0);transform:translate3d(.25em,0,0);-webkit-transform:var(--bs-icon-link-transform,translate3d(.25em,0,0));transform:var(--bs-icon-link-transform,translate3d(.25em,0,0))}.ratio{position:relative;width:100%}.ratio:before{content:"";display:block;padding-top:var(--bs-aspect-ratio)}.ratio>*{height:100%;left:0;position:absolute;top:0;width:100%}.ratio-1x1{--bs-aspect-ratio:100%}.ratio-4x3{--bs-aspect-ratio:75%}.ratio-16x9{--bs-aspect-ratio:56.25%}.ratio-21x9{--bs-aspect-ratio:42.8571428571%}.fixed-top{top:0}.fixed-bottom,.fixed-top{left:0;position:fixed;right:0;z-index:1030}.fixed-bottom{bottom:0}.sticky-top{top:0}.sticky-bottom,.sticky-top{position:-webkit-sticky;position:sticky;z-index:1020}.sticky-bottom{bottom:0}@media (min-width:576px){.sticky-sm-top{top:0}.sticky-sm-bottom,.sticky-sm-top{position:-webkit-sticky;position:sticky;z-index:1020}.sticky-sm-bottom{bottom:0}}@media (min-width:768px){.sticky-md-top{top:0}.sticky-md-bottom,.sticky-md-top{position:-webkit-sticky;position:sticky;z-index:1020}.sticky-md-bottom{bottom:0}}@media (min-width:992px){.sticky-lg-top{top:0}.sticky-lg-bottom,.sticky-lg-top{position:-webkit-sticky;position:sticky;z-index:1020}.sticky-lg-bottom{bottom:0}}@media (min-width:1200px){.sticky-xl-top{top:0}.sticky-xl-bottom,.sticky-xl-top{position:-webkit-sticky;position:sticky;z-index:1020}.sticky-xl-bottom{bottom:0}}@media (min-width:1400px){.sticky-xxl-top{top:0}.sticky-xxl-bottom,.sticky-xxl-top{position:-webkit-sticky;position:sticky;z-index:1020}.sticky-xxl-bottom{bottom:0}}.hstack{align-items:center;flex-direction:row}.hstack,.vstack{align-self:stretch;display:flex}.vstack{flex:1 1 auto;flex-direction:column}.visually-hidden,.visually-hidden-focusable:not(:focus):not(:focus-within){clip:rect(0,0,0,0)!important;border:0!important;height:1px!important;margin:-1px!important;overflow:hidden!important;padding:0!important;white-space:nowrap!important;width:1px!important}.visually-hidden-focusable:not(:focus):not(:focus-within):not(caption),.visually-hidden:not(caption){position:absolute!important}.stretched-link:after{bottom:0;content:"";left:0;position:absolute;right:0;top:0;z-index:1}.text-truncate{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.vr{align-self:stretch;background-color:currentcolor;display:inline-block;min-height:1em;opacity:.25;width:1px;width:var(--bs-border-width)}.align-baseline{vertical-align:initial!important}.align-top{vertical-align:top!important}.align-middle{vertical-align:middle!important}.align-bottom{vertical-align:bottom!important}.align-text-bottom{vertical-align:text-bottom!important}.align-text-top{vertical-align:text-top!important}.float-start{float:left!important}.float-end{float:right!important}.float-none{float:none!important}.object-fit-contain{object-fit:contain!important}.object-fit-cover{object-fit:cover!important}.object-fit-fill{object-fit:fill!important}.object-fit-scale{object-fit:scale-down!important}.object-fit-none{object-fit:none!important}.opacity-0{opacity:0!important}.opacity-25{opacity:.25!important}.opacity-50{opacity:.5!important}.opacity-75{opacity:.75!important}.opacity-100{opacity:1!important}.overflow-auto{overflow:auto!important}.overflow-hidden{overflow:hidden!important}.overflow-visible{overflow:visible!important}.overflow-scroll{overflow:scroll!important}.overflow-x-auto{overflow-x:auto!important}.overflow-x-hidden{overflow-x:hidden!important}.overflow-x-visible{overflow-x:visible!important}.overflow-x-scroll{overflow-x:scroll!important}.overflow-y-auto{overflow-y:auto!important}.overflow-y-hidden{overflow-y:hidden!important}.overflow-y-visible{overflow-y:visible!important}.overflow-y-scroll{overflow-y:scroll!important}.d-inline{display:inline!important}.d-inline-block{display:inline-block!important}.d-block{display:block!important}.d-grid{display:grid!important}.d-inline-grid{display:inline-grid!important}.d-table{display:table!important}.d-table-row{display:table-row!important}.d-table-cell{display:table-cell!important}.d-flex{display:flex!important}.d-inline-flex{display:inline-flex!important}.d-none{display:none!important}.shadow{box-shadow:0 .5rem 1rem rgba(0,0,0,.15)!important;box-shadow:var(--bs-box-shadow)!important}.shadow-sm{box-shadow:0 .125rem .25rem rgba(0,0,0,.075)!important;box-shadow:var(--bs-box-shadow-sm)!important}.shadow-lg{box-shadow:0 1rem 3rem rgba(0,0,0,.175)!important;box-shadow:var(--bs-box-shadow-lg)!important}.shadow-none{box-shadow:none!important}.focus-ring-primary{--bs-focus-ring-color:rgba(var(--bs-primary-rgb),var(--bs-focus-ring-opacity))}.focus-ring-secondary{--bs-focus-ring-color:rgba(var(--bs-secondary-rgb),var(--bs-focus-ring-opacity))}.focus-ring-success{--bs-focus-ring-color:rgba(var(--bs-success-rgb),var(--bs-focus-ring-opacity))}.focus-ring-info{--bs-focus-ring-color:rgba(var(--bs-info-rgb),var(--bs-focus-ring-opacity))}.focus-ring-warning{--bs-focus-ring-color:rgba(var(--bs-warning-rgb),var(--bs-focus-ring-opacity))}.focus-ring-danger{--bs-focus-ring-color:rgba(var(--bs-danger-rgb),var(--bs-focus-ring-opacity))}.focus-ring-light{--bs-focus-ring-color:rgba(var(--bs-light-rgb),var(--bs-focus-ring-opacity))}.focus-ring-dark{--bs-focus-ring-color:rgba(var(--bs-dark-rgb),var(--bs-focus-ring-opacity))}.position-static{position:static!important}.position-relative{position:relative!important}.position-absolute{position:absolute!important}.position-fixed{position:fixed!important}.position-sticky{position:-webkit-sticky!important;position:sticky!important}.top-0{top:0!important}.top-50{top:50%!important}.top-100{top:100%!important}.bottom-0{bottom:0!important}.bottom-50{bottom:50%!important}.bottom-100{bottom:100%!important}.start-0{left:0!important}.start-50{left:50%!important}.start-100{left:100%!important}.end-0{right:0!important}.end-50{right:50%!important}.end-100{right:100%!important}.translate-middle{-webkit-transform:translate(-50%,-50%)!important;transform:translate(-50%,-50%)!important}.translate-middle-x{-webkit-transform:translateX(-50%)!important;transform:translateX(-50%)!important}.translate-middle-y{-webkit-transform:translateY(-50%)!important;transform:translateY(-50%)!important}.border{border:1px solid #dee2e6!important;border:var(--bs-border-width) var(--bs-border-style) var(--bs-border-color)!important}.border-0{border:0!important}.border-top{border-top:1px solid #dee2e6!important;border-top:var(--bs-border-width) var(--bs-border-style) var(--bs-border-color)!important}.border-top-0{border-top:0!important}.border-end{border-right:1px solid #dee2e6!important;border-right:var(--bs-border-width) var(--bs-border-style) var(--bs-border-color)!important}.border-end-0{border-right:0!important}.border-bottom{border-bottom:1px solid #dee2e6!important;border-bottom:var(--bs-border-width) var(--bs-border-style) var(--bs-border-color)!important}.border-bottom-0{border-bottom:0!important}.border-start{border-left:1px solid #dee2e6!important;border-left:var(--bs-border-width) var(--bs-border-style) var(--bs-border-color)!important}.border-start-0{border-left:0!important}.border-primary{--bs-border-opacity:1;border-color:rgba(var(--bs-primary-rgb),var(--bs-border-opacity))!important}.border-secondary{--bs-border-opacity:1;border-color:rgba(var(--bs-secondary-rgb),var(--bs-border-opacity))!important}.border-success{--bs-border-opacity:1;border-color:rgba(var(--bs-success-rgb),var(--bs-border-opacity))!important}.border-info{--bs-border-opacity:1;border-color:rgba(var(--bs-info-rgb),var(--bs-border-opacity))!important}.border-warning{--bs-border-opacity:1;border-color:rgba(var(--bs-warning-rgb),var(--bs-border-opacity))!important}.border-danger{--bs-border-opacity:1;border-color:rgba(var(--bs-danger-rgb),var(--bs-border-opacity))!important}.border-light{--bs-border-opacity:1;border-color:rgba(var(--bs-light-rgb),var(--bs-border-opacity))!important}.border-dark{--bs-border-opacity:1;border-color:rgba(var(--bs-dark-rgb),var(--bs-border-opacity))!important}.border-black{--bs-border-opacity:1;border-color:rgba(var(--bs-black-rgb),var(--bs-border-opacity))!important}.border-white{--bs-border-opacity:1;border-color:rgba(var(--bs-white-rgb),var(--bs-border-opacity))!important}.border-primary-subtle{border-color:#9ec5fe!important;border-color:var(--bs-primary-border-subtle)!important}.border-secondary-subtle{border-color:#c4c8cb!important;border-color:var(--bs-secondary-border-subtle)!important}.border-success-subtle{border-color:#a3cfbb!important;border-color:var(--bs-success-border-subtle)!important}.border-info-subtle{border-color:#9eeaf9!important;border-color:var(--bs-info-border-subtle)!important}.border-warning-subtle{border-color:#ffe69c!important;border-color:var(--bs-warning-border-subtle)!important}.border-danger-subtle{border-color:#f1aeb5!important;border-color:var(--bs-danger-border-subtle)!important}.border-light-subtle{border-color:#e9ecef!important;border-color:var(--bs-light-border-subtle)!important}.border-dark-subtle{border-color:#adb5bd!important;border-color:var(--bs-dark-border-subtle)!important}.border-1{border-width:1px!important}.border-2{border-width:2px!important}.border-3{border-width:3px!important}.border-4{border-width:4px!important}.border-5{border-width:5px!important}.border-opacity-10{--bs-border-opacity:0.1}.border-opacity-25{--bs-border-opacity:0.25}.border-opacity-50{--bs-border-opacity:0.5}.border-opacity-75{--bs-border-opacity:0.75}.border-opacity-100{--bs-border-opacity:1}.w-25{width:25%!important}.w-50{width:50%!important}.w-75{width:75%!important}.w-100{width:100%!important}.w-auto{width:auto!important}.mw-100{max-width:100%!important}.vw-100{width:100vw!important}.min-vw-100{min-width:100vw!important}.h-25{height:25%!important}.h-50{height:50%!important}.h-75{height:75%!important}.h-100{height:100%!important}.h-auto{height:auto!important}.mh-100{max-height:100%!important}.vh-100{height:100vh!important}.min-vh-100{min-height:100vh!important}.flex-fill{flex:1 1 auto!important}.flex-row{flex-direction:row!important}.flex-column{flex-direction:column!important}.flex-row-reverse{flex-direction:row-reverse!important}.flex-column-reverse{flex-direction:column-reverse!important}.flex-grow-0{flex-grow:0!important}.flex-grow-1{flex-grow:1!important}.flex-shrink-0{flex-shrink:0!important}.flex-shrink-1{flex-shrink:1!important}.flex-wrap{flex-wrap:wrap!important}.flex-nowrap{flex-wrap:nowrap!important}.flex-wrap-reverse{flex-wrap:wrap-reverse!important}.justify-content-start{justify-content:flex-start!important}.justify-content-end{justify-content:flex-end!important}.justify-content-center{justify-content:center!important}.justify-content-between{justify-content:space-between!important}.justify-content-around{justify-content:space-around!important}.justify-content-evenly{justify-content:space-evenly!important}.align-items-start{align-items:flex-start!important}.align-items-end{align-items:flex-end!important}.align-items-center{align-items:center!important}.align-items-baseline{align-items:baseline!important}.align-items-stretch{align-items:stretch!important}.align-content-start{align-content:flex-start!important}.align-content-end{align-content:flex-end!important}.align-content-center{align-content:center!important}.align-content-between{align-content:space-between!important}.align-content-around{align-content:space-around!important}.align-content-stretch{align-content:stretch!important}.align-self-auto{align-self:auto!important}.align-self-start{align-self:flex-start!important}.align-self-end{align-self:flex-end!important}.align-self-center{align-self:center!important}.align-self-baseline{align-self:baseline!important}.align-self-stretch{align-self:stretch!important}.order-first{order:-1!important}.order-0{order:0!important}.order-1{order:1!important}.order-2{order:2!important}.order-3{order:3!important}.order-4{order:4!important}.order-5{order:5!important}.order-last{order:6!important}.m-0{margin:0!important}.m-1{margin:.25rem!important}.m-2{margin:.5rem!important}.m-3{margin:1rem!important}.m-4{margin:1.5rem!important}.m-5{margin:3rem!important}.m-auto{margin:auto!important}.mx-0{margin-left:0!important;margin-right:0!important}.mx-1{margin-left:.25rem!important;margin-right:.25rem!important}.mx-2{margin-left:.5rem!important;margin-right:.5rem!important}.mx-3{margin-left:1rem!important;margin-right:1rem!important}.mx-4{margin-left:1.5rem!important;margin-right:1.5rem!important}.mx-5{margin-left:3rem!important;margin-right:3rem!important}.mx-auto{margin-left:auto!important;margin-right:auto!important}.my-0{margin-bottom:0!important;margin-top:0!important}.my-1{margin-bottom:.25rem!important;margin-top:.25rem!important}.my-2{margin-bottom:.5rem!important;margin-top:.5rem!important}.my-3{margin-bottom:1rem!important;margin-top:1rem!important}.my-4{margin-bottom:1.5rem!important;margin-top:1.5rem!important}.my-5{margin-bottom:3rem!important;margin-top:3rem!important}.my-auto{margin-bottom:auto!important;margin-top:auto!important}.mt-0{margin-top:0!important}.mt-1{margin-top:.25rem!important}.mt-2{margin-top:.5rem!important}.mt-3{margin-top:1rem!important}.mt-4{margin-top:1.5rem!important}.mt-5{margin-top:3rem!important}.mt-auto{margin-top:auto!important}.me-0{margin-right:0!important}.me-1{margin-right:.25rem!important}.me-2{margin-right:.5rem!important}.me-3{margin-right:1rem!important}.me-4{margin-right:1.5rem!important}.me-5{margin-right:3rem!important}.me-auto{margin-right:auto!important}.mb-0{margin-bottom:0!important}.mb-1{margin-bottom:.25rem!important}.mb-2{margin-bottom:.5rem!important}.mb-3{margin-bottom:1rem!important}.mb-4{margin-bottom:1.5rem!important}.mb-5{margin-bottom:3rem!important}.mb-auto{margin-bottom:auto!important}.ms-0{margin-left:0!important}.ms-1{margin-left:.25rem!important}.ms-2{margin-left:.5rem!important}.ms-3{margin-left:1rem!important}.ms-4{margin-left:1.5rem!important}.ms-5{margin-left:3rem!important}.ms-auto{margin-left:auto!important}.p-0{padding:0!important}.p-1{padding:.25rem!important}.p-2{padding:.5rem!important}.p-3{padding:1rem!important}.p-4{padding:1.5rem!important}.p-5{padding:3rem!important}.px-0{padding-left:0!important;padding-right:0!important}.px-1{padding-left:.25rem!important;padding-right:.25rem!important}.px-2{padding-left:.5rem!important;padding-right:.5rem!important}.px-3{padding-left:1rem!important;padding-right:1rem!important}.px-4{padding-left:1.5rem!important;padding-right:1.5rem!important}.px-5{padding-left:3rem!important;padding-right:3rem!important}.py-0{padding-bottom:0!important;padding-top:0!important}.py-1{padding-bottom:.25rem!important;padding-top:.25rem!important}.py-2{padding-bottom:.5rem!important;padding-top:.5rem!important}.py-3{padding-bottom:1rem!important;padding-top:1rem!important}.py-4{padding-bottom:1.5rem!important;padding-top:1.5rem!important}.py-5{padding-bottom:3rem!important;padding-top:3rem!important}.pt-0{padding-top:0!important}.pt-1{padding-top:.25rem!important}.pt-2{padding-top:.5rem!important}.pt-3{padding-top:1rem!important}.pt-4{padding-top:1.5rem!important}.pt-5{padding-top:3rem!important}.pe-0{padding-right:0!important}.pe-1{padding-right:.25rem!important}.pe-2{padding-right:.5rem!important}.pe-3{padding-right:1rem!important}.pe-4{padding-right:1.5rem!important}.pe-5{padding-right:3rem!important}.pb-0{padding-bottom:0!important}.pb-1{padding-bottom:.25rem!important}.pb-2{padding-bottom:.5rem!important}.pb-3{padding-bottom:1rem!important}.pb-4{padding-bottom:1.5rem!important}.pb-5{padding-bottom:3rem!important}.ps-0{padding-left:0!important}.ps-1{padding-left:.25rem!important}.ps-2{padding-left:.5rem!important}.ps-3{padding-left:1rem!important}.ps-4{padding-left:1.5rem!important}.ps-5{padding-left:3rem!important}.gap-0{gap:0!important}.gap-1{gap:.25rem!important}.gap-2{gap:.5rem!important}.gap-3{gap:1rem!important}.gap-4{gap:1.5rem!important}.gap-5{gap:3rem!important}.row-gap-0{row-gap:0!important}.row-gap-1{row-gap:.25rem!important}.row-gap-2{row-gap:.5rem!important}.row-gap-3{row-gap:1rem!important}.row-gap-4{row-gap:1.5rem!important}.row-gap-5{row-gap:3rem!important}.column-gap-0{-webkit-column-gap:0!important;column-gap:0!important}.column-gap-1{-webkit-column-gap:.25rem!important;column-gap:.25rem!important}.column-gap-2{-webkit-column-gap:.5rem!important;column-gap:.5rem!important}.column-gap-3{-webkit-column-gap:1rem!important;column-gap:1rem!important}.column-gap-4{-webkit-column-gap:1.5rem!important;column-gap:1.5rem!important}.column-gap-5{-webkit-column-gap:3rem!important;column-gap:3rem!important}.font-monospace{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,monospace!important;font-family:var(--bs-font-monospace)!important}.fs-1{font-size:calc(1.375rem + 1.5vw)!important}.fs-2{font-size:calc(1.325rem + .9vw)!important}.fs-3{font-size:calc(1.3rem + .6vw)!important}.fs-4{font-size:calc(1.275rem + .3vw)!important}.fs-5{font-size:1.25rem!important}.fs-6{font-size:1rem!important}.fst-italic{font-style:italic!important}.fst-normal{font-style:normal!important}.fw-lighter{font-weight:lighter!important}.fw-light{font-weight:300!important}.fw-normal{font-weight:400!important}.fw-medium{font-weight:500!important}.fw-semibold{font-weight:600!important}.fw-bold{font-weight:700!important}.fw-bolder{font-weight:bolder!important}.lh-1{line-height:1!important}.lh-sm{line-height:1.25!important}.lh-base{line-height:1.5!important}.lh-lg{line-height:2!important}.text-start{text-align:left!important}.text-end{text-align:right!important}.text-center{text-align:center!important}.text-decoration-none{text-decoration:none!important}.text-decoration-underline{text-decoration:underline!important}.text-decoration-line-through{text-decoration:line-through!important}.text-lowercase{text-transform:lowercase!important}.text-uppercase{text-transform:uppercase!important}.text-capitalize{text-transform:capitalize!important}.text-wrap{white-space:normal!important}.text-nowrap{white-space:nowrap!important}.text-break{word-wrap:break-word!important;word-break:break-word!important}.text-primary{--bs-text-opacity:1;color:rgba(13,110,253,var(--bs-text-opacity))!important;color:rgba(var(--bs-primary-rgb),var(--bs-text-opacity))!important}.text-secondary{--bs-text-opacity:1;color:rgba(108,117,125,var(--bs-text-opacity))!important;color:rgba(var(--bs-secondary-rgb),var(--bs-text-opacity))!important}.text-success{--bs-text-opacity:1;color:rgba(25,135,84,var(--bs-text-opacity))!important;color:rgba(var(--bs-success-rgb),var(--bs-text-opacity))!important}.text-info{--bs-text-opacity:1;color:rgba(13,202,240,var(--bs-text-opacity))!important;color:rgba(var(--bs-info-rgb),var(--bs-text-opacity))!important}.text-warning{--bs-text-opacity:1;color:rgba(255,193,7,var(--bs-text-opacity))!important;color:rgba(var(--bs-warning-rgb),var(--bs-text-opacity))!important}.text-danger{--bs-text-opacity:1;color:rgba(220,53,69,var(--bs-text-opacity))!important;color:rgba(var(--bs-danger-rgb),var(--bs-text-opacity))!important}.text-light{--bs-text-opacity:1;color:rgba(248,249,250,var(--bs-text-opacity))!important;color:rgba(var(--bs-light-rgb),var(--bs-text-opacity))!important}.text-dark{--bs-text-opacity:1;color:rgba(33,37,41,var(--bs-text-opacity))!important;color:rgba(var(--bs-dark-rgb),var(--bs-text-opacity))!important}.text-black{--bs-text-opacity:1;color:rgba(0,0,0,var(--bs-text-opacity))!important;color:rgba(var(--bs-black-rgb),var(--bs-text-opacity))!important}.text-white{--bs-text-opacity:1;color:rgba(255,255,255,var(--bs-text-opacity))!important;color:rgba(var(--bs-white-rgb),var(--bs-text-opacity))!important}.text-body{--bs-text-opacity:1;color:rgba(33,37,41,var(--bs-text-opacity))!important;color:rgba(var(--bs-body-color-rgb),var(--bs-text-opacity))!important}.text-muted{--bs-text-opacity:1;color:rgba(33,37,41,.75)!important;color:var(--bs-secondary-color)!important}.text-black-50{--bs-text-opacity:1;color:rgba(0,0,0,.5)!important}.text-white-50{--bs-text-opacity:1;color:hsla(0,0%,100%,.5)!important}.text-body-secondary{--bs-text-opacity:1;color:rgba(33,37,41,.75)!important;color:var(--bs-secondary-color)!important}.text-body-tertiary{--bs-text-opacity:1;color:rgba(33,37,41,.5)!important;color:var(--bs-tertiary-color)!important}.text-body-emphasis{--bs-text-opacity:1;color:#000!important;color:var(--bs-emphasis-color)!important}.text-reset{--bs-text-opacity:1;color:inherit!important}.text-opacity-25{--bs-text-opacity:0.25}.text-opacity-50{--bs-text-opacity:0.5}.text-opacity-75{--bs-text-opacity:0.75}.text-opacity-100{--bs-text-opacity:1}.text-primary-emphasis{color:#052c65!important;color:var(--bs-primary-text-emphasis)!important}.text-secondary-emphasis{color:#2b2f32!important;color:var(--bs-secondary-text-emphasis)!important}.text-success-emphasis{color:#0a3622!important;color:var(--bs-success-text-emphasis)!important}.text-info-emphasis{color:#055160!important;color:var(--bs-info-text-emphasis)!important}.text-warning-emphasis{color:#664d03!important;color:var(--bs-warning-text-emphasis)!important}.text-danger-emphasis{color:#58151c!important;color:var(--bs-danger-text-emphasis)!important}.text-light-emphasis{color:#495057!important;color:var(--bs-light-text-emphasis)!important}.text-dark-emphasis{color:#495057!important;color:var(--bs-dark-text-emphasis)!important}.link-opacity-10,.link-opacity-10-hover:hover{--bs-link-opacity:0.1}.link-opacity-25,.link-opacity-25-hover:hover{--bs-link-opacity:0.25}.link-opacity-50,.link-opacity-50-hover:hover{--bs-link-opacity:0.5}.link-opacity-75,.link-opacity-75-hover:hover{--bs-link-opacity:0.75}.link-opacity-100,.link-opacity-100-hover:hover{--bs-link-opacity:1}.link-offset-1,.link-offset-1-hover:hover{text-underline-offset:.125em!important}.link-offset-2,.link-offset-2-hover:hover{text-underline-offset:.25em!important}.link-offset-3,.link-offset-3-hover:hover{text-underline-offset:.375em!important}.link-underline-primary{--bs-link-underline-opacity:1;text-decoration-color:rgba(13,110,253,var(--bs-link-underline-opacity))!important;text-decoration-color:rgba(var(--bs-primary-rgb),var(--bs-link-underline-opacity))!important}.link-underline-secondary{--bs-link-underline-opacity:1;text-decoration-color:rgba(108,117,125,var(--bs-link-underline-opacity))!important;text-decoration-color:rgba(var(--bs-secondary-rgb),var(--bs-link-underline-opacity))!important}.link-underline-success{--bs-link-underline-opacity:1;text-decoration-color:rgba(25,135,84,var(--bs-link-underline-opacity))!important;text-decoration-color:rgba(var(--bs-success-rgb),var(--bs-link-underline-opacity))!important}.link-underline-info{--bs-link-underline-opacity:1;text-decoration-color:rgba(13,202,240,var(--bs-link-underline-opacity))!important;text-decoration-color:rgba(var(--bs-info-rgb),var(--bs-link-underline-opacity))!important}.link-underline-warning{--bs-link-underline-opacity:1;text-decoration-color:rgba(255,193,7,var(--bs-link-underline-opacity))!important;text-decoration-color:rgba(var(--bs-warning-rgb),var(--bs-link-underline-opacity))!important}.link-underline-danger{--bs-link-underline-opacity:1;text-decoration-color:rgba(220,53,69,var(--bs-link-underline-opacity))!important;text-decoration-color:rgba(var(--bs-danger-rgb),var(--bs-link-underline-opacity))!important}.link-underline-light{--bs-link-underline-opacity:1;text-decoration-color:rgba(248,249,250,var(--bs-link-underline-opacity))!important;text-decoration-color:rgba(var(--bs-light-rgb),var(--bs-link-underline-opacity))!important}.link-underline-dark{--bs-link-underline-opacity:1;text-decoration-color:rgba(33,37,41,var(--bs-link-underline-opacity))!important;text-decoration-color:rgba(var(--bs-dark-rgb),var(--bs-link-underline-opacity))!important}.link-underline{--bs-link-underline-opacity:1;text-decoration-color:#0d6efd!important;text-decoration-color:rgba(var(--bs-link-color-rgb),var(--bs-link-underline-opacity,1))!important}.link-underline-opacity-0,.link-underline-opacity-0-hover:hover{--bs-link-underline-opacity:0}.link-underline-opacity-10,.link-underline-opacity-10-hover:hover{--bs-link-underline-opacity:0.1}.link-underline-opacity-25,.link-underline-opacity-25-hover:hover{--bs-link-underline-opacity:0.25}.link-underline-opacity-50,.link-underline-opacity-50-hover:hover{--bs-link-underline-opacity:0.5}.link-underline-opacity-75,.link-underline-opacity-75-hover:hover{--bs-link-underline-opacity:0.75}.link-underline-opacity-100,.link-underline-opacity-100-hover:hover{--bs-link-underline-opacity:1}.bg-primary{--bs-bg-opacity:1;background-color:rgba(13,110,253,var(--bs-bg-opacity))!important;background-color:rgba(var(--bs-primary-rgb),var(--bs-bg-opacity))!important}.bg-secondary{--bs-bg-opacity:1;background-color:rgba(108,117,125,var(--bs-bg-opacity))!important;background-color:rgba(var(--bs-secondary-rgb),var(--bs-bg-opacity))!important}.bg-success{--bs-bg-opacity:1;background-color:rgba(25,135,84,var(--bs-bg-opacity))!important;background-color:rgba(var(--bs-success-rgb),var(--bs-bg-opacity))!important}.bg-info{--bs-bg-opacity:1;background-color:rgba(13,202,240,var(--bs-bg-opacity))!important;background-color:rgba(var(--bs-info-rgb),var(--bs-bg-opacity))!important}.bg-warning{--bs-bg-opacity:1;background-color:rgba(255,193,7,var(--bs-bg-opacity))!important;background-color:rgba(var(--bs-warning-rgb),var(--bs-bg-opacity))!important}.bg-danger{--bs-bg-opacity:1;background-color:rgba(220,53,69,var(--bs-bg-opacity))!important;background-color:rgba(var(--bs-danger-rgb),var(--bs-bg-opacity))!important}.bg-light{--bs-bg-opacity:1;background-color:rgba(248,249,250,var(--bs-bg-opacity))!important;background-color:rgba(var(--bs-light-rgb),var(--bs-bg-opacity))!important}.bg-dark{--bs-bg-opacity:1;background-color:rgba(33,37,41,var(--bs-bg-opacity))!important;background-color:rgba(var(--bs-dark-rgb),var(--bs-bg-opacity))!important}.bg-black{--bs-bg-opacity:1;background-color:rgba(0,0,0,var(--bs-bg-opacity))!important;background-color:rgba(var(--bs-black-rgb),var(--bs-bg-opacity))!important}.bg-white{--bs-bg-opacity:1;background-color:rgba(255,255,255,var(--bs-bg-opacity))!important;background-color:rgba(var(--bs-white-rgb),var(--bs-bg-opacity))!important}.bg-body{--bs-bg-opacity:1;background-color:rgba(255,255,255,var(--bs-bg-opacity))!important;background-color:rgba(var(--bs-body-bg-rgb),var(--bs-bg-opacity))!important}.bg-transparent{--bs-bg-opacity:1;background-color:initial!important}.bg-body-secondary{--bs-bg-opacity:1;background-color:rgba(233,236,239,var(--bs-bg-opacity))!important;background-color:rgba(var(--bs-secondary-bg-rgb),var(--bs-bg-opacity))!important}.bg-body-tertiary{--bs-bg-opacity:1;background-color:rgba(248,249,250,var(--bs-bg-opacity))!important;background-color:rgba(var(--bs-tertiary-bg-rgb),var(--bs-bg-opacity))!important}.bg-opacity-10{--bs-bg-opacity:0.1}.bg-opacity-25{--bs-bg-opacity:0.25}.bg-opacity-50{--bs-bg-opacity:0.5}.bg-opacity-75{--bs-bg-opacity:0.75}.bg-opacity-100{--bs-bg-opacity:1}.bg-primary-subtle{background-color:#cfe2ff!important;background-color:var(--bs-primary-bg-subtle)!important}.bg-secondary-subtle{background-color:#e2e3e5!important;background-color:var(--bs-secondary-bg-subtle)!important}.bg-success-subtle{background-color:#d1e7dd!important;background-color:var(--bs-success-bg-subtle)!important}.bg-info-subtle{background-color:#cff4fc!important;background-color:var(--bs-info-bg-subtle)!important}.bg-warning-subtle{background-color:#fff3cd!important;background-color:var(--bs-warning-bg-subtle)!important}.bg-danger-subtle{background-color:#f8d7da!important;background-color:var(--bs-danger-bg-subtle)!important}.bg-light-subtle{background-color:#fcfcfd!important;background-color:var(--bs-light-bg-subtle)!important}.bg-dark-subtle{background-color:#ced4da!important;background-color:var(--bs-dark-bg-subtle)!important}.bg-gradient{background-image:linear-gradient(180deg,hsla(0,0%,100%,.15),hsla(0,0%,100%,0))!important;background-image:var(--bs-gradient)!important}.user-select-all{-webkit-user-select:all!important;user-select:all!important}.user-select-auto{-webkit-user-select:auto!important;user-select:auto!important}.user-select-none{-webkit-user-select:none!important;user-select:none!important}.pe-none{pointer-events:none!important}.pe-auto{pointer-events:auto!important}.rounded{border-radius:.375rem!important;border-radius:var(--bs-border-radius)!important}.rounded-0{border-radius:0!important}.rounded-1{border-radius:.25rem!important;border-radius:var(--bs-border-radius-sm)!important}.rounded-2{border-radius:.375rem!important;border-radius:var(--bs-border-radius)!important}.rounded-3{border-radius:.5rem!important;border-radius:var(--bs-border-radius-lg)!important}.rounded-4{border-radius:1rem!important;border-radius:var(--bs-border-radius-xl)!important}.rounded-5{border-radius:2rem!important;border-radius:var(--bs-border-radius-xxl)!important}.rounded-circle{border-radius:50%!important}.rounded-pill{border-radius:50rem!important;border-radius:var(--bs-border-radius-pill)!important}.rounded-top{border-top-left-radius:.375rem!important;border-top-left-radius:var(--bs-border-radius)!important;border-top-right-radius:.375rem!important;border-top-right-radius:var(--bs-border-radius)!important}.rounded-top-0{border-top-left-radius:0!important;border-top-right-radius:0!important}.rounded-top-1{border-top-left-radius:.25rem!important;border-top-left-radius:var(--bs-border-radius-sm)!important;border-top-right-radius:.25rem!important;border-top-right-radius:var(--bs-border-radius-sm)!important}.rounded-top-2{border-top-left-radius:.375rem!important;border-top-left-radius:var(--bs-border-radius)!important;border-top-right-radius:.375rem!important;border-top-right-radius:var(--bs-border-radius)!important}.rounded-top-3{border-top-left-radius:.5rem!important;border-top-left-radius:var(--bs-border-radius-lg)!important;border-top-right-radius:.5rem!important;border-top-right-radius:var(--bs-border-radius-lg)!important}.rounded-top-4{border-top-left-radius:1rem!important;border-top-left-radius:var(--bs-border-radius-xl)!important;border-top-right-radius:1rem!important;border-top-right-radius:var(--bs-border-radius-xl)!important}.rounded-top-5{border-top-left-radius:2rem!important;border-top-left-radius:var(--bs-border-radius-xxl)!important;border-top-right-radius:2rem!important;border-top-right-radius:var(--bs-border-radius-xxl)!important}.rounded-top-circle{border-top-left-radius:50%!important;border-top-right-radius:50%!important}.rounded-top-pill{border-top-left-radius:50rem!important;border-top-left-radius:var(--bs-border-radius-pill)!important;border-top-right-radius:50rem!important;border-top-right-radius:var(--bs-border-radius-pill)!important}.rounded-end{border-bottom-right-radius:.375rem!important;border-bottom-right-radius:var(--bs-border-radius)!important;border-top-right-radius:.375rem!important;border-top-right-radius:var(--bs-border-radius)!important}.rounded-end-0{border-bottom-right-radius:0!important;border-top-right-radius:0!important}.rounded-end-1{border-bottom-right-radius:.25rem!important;border-bottom-right-radius:var(--bs-border-radius-sm)!important;border-top-right-radius:.25rem!important;border-top-right-radius:var(--bs-border-radius-sm)!important}.rounded-end-2{border-bottom-right-radius:.375rem!important;border-bottom-right-radius:var(--bs-border-radius)!important;border-top-right-radius:.375rem!important;border-top-right-radius:var(--bs-border-radius)!important}.rounded-end-3{border-bottom-right-radius:.5rem!important;border-bottom-right-radius:var(--bs-border-radius-lg)!important;border-top-right-radius:.5rem!important;border-top-right-radius:var(--bs-border-radius-lg)!important}.rounded-end-4{border-bottom-right-radius:1rem!important;border-bottom-right-radius:var(--bs-border-radius-xl)!important;border-top-right-radius:1rem!important;border-top-right-radius:var(--bs-border-radius-xl)!important}.rounded-end-5{border-bottom-right-radius:2rem!important;border-bottom-right-radius:var(--bs-border-radius-xxl)!important;border-top-right-radius:2rem!important;border-top-right-radius:var(--bs-border-radius-xxl)!important}.rounded-end-circle{border-bottom-right-radius:50%!important;border-top-right-radius:50%!important}.rounded-end-pill{border-bottom-right-radius:50rem!important;border-bottom-right-radius:var(--bs-border-radius-pill)!important;border-top-right-radius:50rem!important;border-top-right-radius:var(--bs-border-radius-pill)!important}.rounded-bottom{border-bottom-left-radius:.375rem!important;border-bottom-left-radius:var(--bs-border-radius)!important;border-bottom-right-radius:.375rem!important;border-bottom-right-radius:var(--bs-border-radius)!important}.rounded-bottom-0{border-bottom-left-radius:0!important;border-bottom-right-radius:0!important}.rounded-bottom-1{border-bottom-left-radius:.25rem!important;border-bottom-left-radius:var(--bs-border-radius-sm)!important;border-bottom-right-radius:.25rem!important;border-bottom-right-radius:var(--bs-border-radius-sm)!important}.rounded-bottom-2{border-bottom-left-radius:.375rem!important;border-bottom-left-radius:var(--bs-border-radius)!important;border-bottom-right-radius:.375rem!important;border-bottom-right-radius:var(--bs-border-radius)!important}.rounded-bottom-3{border-bottom-left-radius:.5rem!important;border-bottom-left-radius:var(--bs-border-radius-lg)!important;border-bottom-right-radius:.5rem!important;border-bottom-right-radius:var(--bs-border-radius-lg)!important}.rounded-bottom-4{border-bottom-left-radius:1rem!important;border-bottom-left-radius:var(--bs-border-radius-xl)!important;border-bottom-right-radius:1rem!important;border-bottom-right-radius:var(--bs-border-radius-xl)!important}.rounded-bottom-5{border-bottom-left-radius:2rem!important;border-bottom-left-radius:var(--bs-border-radius-xxl)!important;border-bottom-right-radius:2rem!important;border-bottom-right-radius:var(--bs-border-radius-xxl)!important}.rounded-bottom-circle{border-bottom-left-radius:50%!important;border-bottom-right-radius:50%!important}.rounded-bottom-pill{border-bottom-left-radius:50rem!important;border-bottom-left-radius:var(--bs-border-radius-pill)!important;border-bottom-right-radius:50rem!important;border-bottom-right-radius:var(--bs-border-radius-pill)!important}.rounded-start{border-bottom-left-radius:.375rem!important;border-bottom-left-radius:var(--bs-border-radius)!important;border-top-left-radius:.375rem!important;border-top-left-radius:var(--bs-border-radius)!important}.rounded-start-0{border-bottom-left-radius:0!important;border-top-left-radius:0!important}.rounded-start-1{border-bottom-left-radius:.25rem!important;border-bottom-left-radius:var(--bs-border-radius-sm)!important;border-top-left-radius:.25rem!important;border-top-left-radius:var(--bs-border-radius-sm)!important}.rounded-start-2{border-bottom-left-radius:.375rem!important;border-bottom-left-radius:var(--bs-border-radius)!important;border-top-left-radius:.375rem!important;border-top-left-radius:var(--bs-border-radius)!important}.rounded-start-3{border-bottom-left-radius:.5rem!important;border-bottom-left-radius:var(--bs-border-radius-lg)!important;border-top-left-radius:.5rem!important;border-top-left-radius:var(--bs-border-radius-lg)!important}.rounded-start-4{border-bottom-left-radius:1rem!important;border-bottom-left-radius:var(--bs-border-radius-xl)!important;border-top-left-radius:1rem!important;border-top-left-radius:var(--bs-border-radius-xl)!important}.rounded-start-5{border-bottom-left-radius:2rem!important;border-bottom-left-radius:var(--bs-border-radius-xxl)!important;border-top-left-radius:2rem!important;border-top-left-radius:var(--bs-border-radius-xxl)!important}.rounded-start-circle{border-bottom-left-radius:50%!important;border-top-left-radius:50%!important}.rounded-start-pill{border-bottom-left-radius:50rem!important;border-bottom-left-radius:var(--bs-border-radius-pill)!important;border-top-left-radius:50rem!important;border-top-left-radius:var(--bs-border-radius-pill)!important}.visible{visibility:visible!important}.invisible{visibility:hidden!important}.z-n1{z-index:-1!important}.z-0{z-index:0!important}.z-1{z-index:1!important}.z-2{z-index:2!important}.z-3{z-index:3!important}@media (min-width:576px){.float-sm-start{float:left!important}.float-sm-end{float:right!important}.float-sm-none{float:none!important}.object-fit-sm-contain{object-fit:contain!important}.object-fit-sm-cover{object-fit:cover!important}.object-fit-sm-fill{object-fit:fill!important}.object-fit-sm-scale{object-fit:scale-down!important}.object-fit-sm-none{object-fit:none!important}.d-sm-inline{display:inline!important}.d-sm-inline-block{display:inline-block!important}.d-sm-block{display:block!important}.d-sm-grid{display:grid!important}.d-sm-inline-grid{display:inline-grid!important}.d-sm-table{display:table!important}.d-sm-table-row{display:table-row!important}.d-sm-table-cell{display:table-cell!important}.d-sm-flex{display:flex!important}.d-sm-inline-flex{display:inline-flex!important}.d-sm-none{display:none!important}.flex-sm-fill{flex:1 1 auto!important}.flex-sm-row{flex-direction:row!important}.flex-sm-column{flex-direction:column!important}.flex-sm-row-reverse{flex-direction:row-reverse!important}.flex-sm-column-reverse{flex-direction:column-reverse!important}.flex-sm-grow-0{flex-grow:0!important}.flex-sm-grow-1{flex-grow:1!important}.flex-sm-shrink-0{flex-shrink:0!important}.flex-sm-shrink-1{flex-shrink:1!important}.flex-sm-wrap{flex-wrap:wrap!important}.flex-sm-nowrap{flex-wrap:nowrap!important}.flex-sm-wrap-reverse{flex-wrap:wrap-reverse!important}.justify-content-sm-start{justify-content:flex-start!important}.justify-content-sm-end{justify-content:flex-end!important}.justify-content-sm-center{justify-content:center!important}.justify-content-sm-between{justify-content:space-between!important}.justify-content-sm-around{justify-content:space-around!important}.justify-content-sm-evenly{justify-content:space-evenly!important}.align-items-sm-start{align-items:flex-start!important}.align-items-sm-end{align-items:flex-end!important}.align-items-sm-center{align-items:center!important}.align-items-sm-baseline{align-items:baseline!important}.align-items-sm-stretch{align-items:stretch!important}.align-content-sm-start{align-content:flex-start!important}.align-content-sm-end{align-content:flex-end!important}.align-content-sm-center{align-content:center!important}.align-content-sm-between{align-content:space-between!important}.align-content-sm-around{align-content:space-around!important}.align-content-sm-stretch{align-content:stretch!important}.align-self-sm-auto{align-self:auto!important}.align-self-sm-start{align-self:flex-start!important}.align-self-sm-end{align-self:flex-end!important}.align-self-sm-center{align-self:center!important}.align-self-sm-baseline{align-self:baseline!important}.align-self-sm-stretch{align-self:stretch!important}.order-sm-first{order:-1!important}.order-sm-0{order:0!important}.order-sm-1{order:1!important}.order-sm-2{order:2!important}.order-sm-3{order:3!important}.order-sm-4{order:4!important}.order-sm-5{order:5!important}.order-sm-last{order:6!important}.m-sm-0{margin:0!important}.m-sm-1{margin:.25rem!important}.m-sm-2{margin:.5rem!important}.m-sm-3{margin:1rem!important}.m-sm-4{margin:1.5rem!important}.m-sm-5{margin:3rem!important}.m-sm-auto{margin:auto!important}.mx-sm-0{margin-left:0!important;margin-right:0!important}.mx-sm-1{margin-left:.25rem!important;margin-right:.25rem!important}.mx-sm-2{margin-left:.5rem!important;margin-right:.5rem!important}.mx-sm-3{margin-left:1rem!important;margin-right:1rem!important}.mx-sm-4{margin-left:1.5rem!important;margin-right:1.5rem!important}.mx-sm-5{margin-left:3rem!important;margin-right:3rem!important}.mx-sm-auto{margin-left:auto!important;margin-right:auto!important}.my-sm-0{margin-bottom:0!important;margin-top:0!important}.my-sm-1{margin-bottom:.25rem!important;margin-top:.25rem!important}.my-sm-2{margin-bottom:.5rem!important;margin-top:.5rem!important}.my-sm-3{margin-bottom:1rem!important;margin-top:1rem!important}.my-sm-4{margin-bottom:1.5rem!important;margin-top:1.5rem!important}.my-sm-5{margin-bottom:3rem!important;margin-top:3rem!important}.my-sm-auto{margin-bottom:auto!important;margin-top:auto!important}.mt-sm-0{margin-top:0!important}.mt-sm-1{margin-top:.25rem!important}.mt-sm-2{margin-top:.5rem!important}.mt-sm-3{margin-top:1rem!important}.mt-sm-4{margin-top:1.5rem!important}.mt-sm-5{margin-top:3rem!important}.mt-sm-auto{margin-top:auto!important}.me-sm-0{margin-right:0!important}.me-sm-1{margin-right:.25rem!important}.me-sm-2{margin-right:.5rem!important}.me-sm-3{margin-right:1rem!important}.me-sm-4{margin-right:1.5rem!important}.me-sm-5{margin-right:3rem!important}.me-sm-auto{margin-right:auto!important}.mb-sm-0{margin-bottom:0!important}.mb-sm-1{margin-bottom:.25rem!important}.mb-sm-2{margin-bottom:.5rem!important}.mb-sm-3{margin-bottom:1rem!important}.mb-sm-4{margin-bottom:1.5rem!important}.mb-sm-5{margin-bottom:3rem!important}.mb-sm-auto{margin-bottom:auto!important}.ms-sm-0{margin-left:0!important}.ms-sm-1{margin-left:.25rem!important}.ms-sm-2{margin-left:.5rem!important}.ms-sm-3{margin-left:1rem!important}.ms-sm-4{margin-left:1.5rem!important}.ms-sm-5{margin-left:3rem!important}.ms-sm-auto{margin-left:auto!important}.p-sm-0{padding:0!important}.p-sm-1{padding:.25rem!important}.p-sm-2{padding:.5rem!important}.p-sm-3{padding:1rem!important}.p-sm-4{padding:1.5rem!important}.p-sm-5{padding:3rem!important}.px-sm-0{padding-left:0!important;padding-right:0!important}.px-sm-1{padding-left:.25rem!important;padding-right:.25rem!important}.px-sm-2{padding-left:.5rem!important;padding-right:.5rem!important}.px-sm-3{padding-left:1rem!important;padding-right:1rem!important}.px-sm-4{padding-left:1.5rem!important;padding-right:1.5rem!important}.px-sm-5{padding-left:3rem!important;padding-right:3rem!important}.py-sm-0{padding-bottom:0!important;padding-top:0!important}.py-sm-1{padding-bottom:.25rem!important;padding-top:.25rem!important}.py-sm-2{padding-bottom:.5rem!important;padding-top:.5rem!important}.py-sm-3{padding-bottom:1rem!important;padding-top:1rem!important}.py-sm-4{padding-bottom:1.5rem!important;padding-top:1.5rem!important}.py-sm-5{padding-bottom:3rem!important;padding-top:3rem!important}.pt-sm-0{padding-top:0!important}.pt-sm-1{padding-top:.25rem!important}.pt-sm-2{padding-top:.5rem!important}.pt-sm-3{padding-top:1rem!important}.pt-sm-4{padding-top:1.5rem!important}.pt-sm-5{padding-top:3rem!important}.pe-sm-0{padding-right:0!important}.pe-sm-1{padding-right:.25rem!important}.pe-sm-2{padding-right:.5rem!important}.pe-sm-3{padding-right:1rem!important}.pe-sm-4{padding-right:1.5rem!important}.pe-sm-5{padding-right:3rem!important}.pb-sm-0{padding-bottom:0!important}.pb-sm-1{padding-bottom:.25rem!important}.pb-sm-2{padding-bottom:.5rem!important}.pb-sm-3{padding-bottom:1rem!important}.pb-sm-4{padding-bottom:1.5rem!important}.pb-sm-5{padding-bottom:3rem!important}.ps-sm-0{padding-left:0!important}.ps-sm-1{padding-left:.25rem!important}.ps-sm-2{padding-left:.5rem!important}.ps-sm-3{padding-left:1rem!important}.ps-sm-4{padding-left:1.5rem!important}.ps-sm-5{padding-left:3rem!important}.gap-sm-0{gap:0!important}.gap-sm-1{gap:.25rem!important}.gap-sm-2{gap:.5rem!important}.gap-sm-3{gap:1rem!important}.gap-sm-4{gap:1.5rem!important}.gap-sm-5{gap:3rem!important}.row-gap-sm-0{row-gap:0!important}.row-gap-sm-1{row-gap:.25rem!important}.row-gap-sm-2{row-gap:.5rem!important}.row-gap-sm-3{row-gap:1rem!important}.row-gap-sm-4{row-gap:1.5rem!important}.row-gap-sm-5{row-gap:3rem!important}.column-gap-sm-0{-webkit-column-gap:0!important;column-gap:0!important}.column-gap-sm-1{-webkit-column-gap:.25rem!important;column-gap:.25rem!important}.column-gap-sm-2{-webkit-column-gap:.5rem!important;column-gap:.5rem!important}.column-gap-sm-3{-webkit-column-gap:1rem!important;column-gap:1rem!important}.column-gap-sm-4{-webkit-column-gap:1.5rem!important;column-gap:1.5rem!important}.column-gap-sm-5{-webkit-column-gap:3rem!important;column-gap:3rem!important}.text-sm-start{text-align:left!important}.text-sm-end{text-align:right!important}.text-sm-center{text-align:center!important}}@media (min-width:768px){.float-md-start{float:left!important}.float-md-end{float:right!important}.float-md-none{float:none!important}.object-fit-md-contain{object-fit:contain!important}.object-fit-md-cover{object-fit:cover!important}.object-fit-md-fill{object-fit:fill!important}.object-fit-md-scale{object-fit:scale-down!important}.object-fit-md-none{object-fit:none!important}.d-md-inline{display:inline!important}.d-md-inline-block{display:inline-block!important}.d-md-block{display:block!important}.d-md-grid{display:grid!important}.d-md-inline-grid{display:inline-grid!important}.d-md-table{display:table!important}.d-md-table-row{display:table-row!important}.d-md-table-cell{display:table-cell!important}.d-md-flex{display:flex!important}.d-md-inline-flex{display:inline-flex!important}.d-md-none{display:none!important}.flex-md-fill{flex:1 1 auto!important}.flex-md-row{flex-direction:row!important}.flex-md-column{flex-direction:column!important}.flex-md-row-reverse{flex-direction:row-reverse!important}.flex-md-column-reverse{flex-direction:column-reverse!important}.flex-md-grow-0{flex-grow:0!important}.flex-md-grow-1{flex-grow:1!important}.flex-md-shrink-0{flex-shrink:0!important}.flex-md-shrink-1{flex-shrink:1!important}.flex-md-wrap{flex-wrap:wrap!important}.flex-md-nowrap{flex-wrap:nowrap!important}.flex-md-wrap-reverse{flex-wrap:wrap-reverse!important}.justify-content-md-start{justify-content:flex-start!important}.justify-content-md-end{justify-content:flex-end!important}.justify-content-md-center{justify-content:center!important}.justify-content-md-between{justify-content:space-between!important}.justify-content-md-around{justify-content:space-around!important}.justify-content-md-evenly{justify-content:space-evenly!important}.align-items-md-start{align-items:flex-start!important}.align-items-md-end{align-items:flex-end!important}.align-items-md-center{align-items:center!important}.align-items-md-baseline{align-items:baseline!important}.align-items-md-stretch{align-items:stretch!important}.align-content-md-start{align-content:flex-start!important}.align-content-md-end{align-content:flex-end!important}.align-content-md-center{align-content:center!important}.align-content-md-between{align-content:space-between!important}.align-content-md-around{align-content:space-around!important}.align-content-md-stretch{align-content:stretch!important}.align-self-md-auto{align-self:auto!important}.align-self-md-start{align-self:flex-start!important}.align-self-md-end{align-self:flex-end!important}.align-self-md-center{align-self:center!important}.align-self-md-baseline{align-self:baseline!important}.align-self-md-stretch{align-self:stretch!important}.order-md-first{order:-1!important}.order-md-0{order:0!important}.order-md-1{order:1!important}.order-md-2{order:2!important}.order-md-3{order:3!important}.order-md-4{order:4!important}.order-md-5{order:5!important}.order-md-last{order:6!important}.m-md-0{margin:0!important}.m-md-1{margin:.25rem!important}.m-md-2{margin:.5rem!important}.m-md-3{margin:1rem!important}.m-md-4{margin:1.5rem!important}.m-md-5{margin:3rem!important}.m-md-auto{margin:auto!important}.mx-md-0{margin-left:0!important;margin-right:0!important}.mx-md-1{margin-left:.25rem!important;margin-right:.25rem!important}.mx-md-2{margin-left:.5rem!important;margin-right:.5rem!important}.mx-md-3{margin-left:1rem!important;margin-right:1rem!important}.mx-md-4{margin-left:1.5rem!important;margin-right:1.5rem!important}.mx-md-5{margin-left:3rem!important;margin-right:3rem!important}.mx-md-auto{margin-left:auto!important;margin-right:auto!important}.my-md-0{margin-bottom:0!important;margin-top:0!important}.my-md-1{margin-bottom:.25rem!important;margin-top:.25rem!important}.my-md-2{margin-bottom:.5rem!important;margin-top:.5rem!important}.my-md-3{margin-bottom:1rem!important;margin-top:1rem!important}.my-md-4{margin-bottom:1.5rem!important;margin-top:1.5rem!important}.my-md-5{margin-bottom:3rem!important;margin-top:3rem!important}.my-md-auto{margin-bottom:auto!important;margin-top:auto!important}.mt-md-0{margin-top:0!important}.mt-md-1{margin-top:.25rem!important}.mt-md-2{margin-top:.5rem!important}.mt-md-3{margin-top:1rem!important}.mt-md-4{margin-top:1.5rem!important}.mt-md-5{margin-top:3rem!important}.mt-md-auto{margin-top:auto!important}.me-md-0{margin-right:0!important}.me-md-1{margin-right:.25rem!important}.me-md-2{margin-right:.5rem!important}.me-md-3{margin-right:1rem!important}.me-md-4{margin-right:1.5rem!important}.me-md-5{margin-right:3rem!important}.me-md-auto{margin-right:auto!important}.mb-md-0{margin-bottom:0!important}.mb-md-1{margin-bottom:.25rem!important}.mb-md-2{margin-bottom:.5rem!important}.mb-md-3{margin-bottom:1rem!important}.mb-md-4{margin-bottom:1.5rem!important}.mb-md-5{margin-bottom:3rem!important}.mb-md-auto{margin-bottom:auto!important}.ms-md-0{margin-left:0!important}.ms-md-1{margin-left:.25rem!important}.ms-md-2{margin-left:.5rem!important}.ms-md-3{margin-left:1rem!important}.ms-md-4{margin-left:1.5rem!important}.ms-md-5{margin-left:3rem!important}.ms-md-auto{margin-left:auto!important}.p-md-0{padding:0!important}.p-md-1{padding:.25rem!important}.p-md-2{padding:.5rem!important}.p-md-3{padding:1rem!important}.p-md-4{padding:1.5rem!important}.p-md-5{padding:3rem!important}.px-md-0{padding-left:0!important;padding-right:0!important}.px-md-1{padding-left:.25rem!important;padding-right:.25rem!important}.px-md-2{padding-left:.5rem!important;padding-right:.5rem!important}.px-md-3{padding-left:1rem!important;padding-right:1rem!important}.px-md-4{padding-left:1.5rem!important;padding-right:1.5rem!important}.px-md-5{padding-left:3rem!important;padding-right:3rem!important}.py-md-0{padding-bottom:0!important;padding-top:0!important}.py-md-1{padding-bottom:.25rem!important;padding-top:.25rem!important}.py-md-2{padding-bottom:.5rem!important;padding-top:.5rem!important}.py-md-3{padding-bottom:1rem!important;padding-top:1rem!important}.py-md-4{padding-bottom:1.5rem!important;padding-top:1.5rem!important}.py-md-5{padding-bottom:3rem!important;padding-top:3rem!important}.pt-md-0{padding-top:0!important}.pt-md-1{padding-top:.25rem!important}.pt-md-2{padding-top:.5rem!important}.pt-md-3{padding-top:1rem!important}.pt-md-4{padding-top:1.5rem!important}.pt-md-5{padding-top:3rem!important}.pe-md-0{padding-right:0!important}.pe-md-1{padding-right:.25rem!important}.pe-md-2{padding-right:.5rem!important}.pe-md-3{padding-right:1rem!important}.pe-md-4{padding-right:1.5rem!important}.pe-md-5{padding-right:3rem!important}.pb-md-0{padding-bottom:0!important}.pb-md-1{padding-bottom:.25rem!important}.pb-md-2{padding-bottom:.5rem!important}.pb-md-3{padding-bottom:1rem!important}.pb-md-4{padding-bottom:1.5rem!important}.pb-md-5{padding-bottom:3rem!important}.ps-md-0{padding-left:0!important}.ps-md-1{padding-left:.25rem!important}.ps-md-2{padding-left:.5rem!important}.ps-md-3{padding-left:1rem!important}.ps-md-4{padding-left:1.5rem!important}.ps-md-5{padding-left:3rem!important}.gap-md-0{gap:0!important}.gap-md-1{gap:.25rem!important}.gap-md-2{gap:.5rem!important}.gap-md-3{gap:1rem!important}.gap-md-4{gap:1.5rem!important}.gap-md-5{gap:3rem!important}.row-gap-md-0{row-gap:0!important}.row-gap-md-1{row-gap:.25rem!important}.row-gap-md-2{row-gap:.5rem!important}.row-gap-md-3{row-gap:1rem!important}.row-gap-md-4{row-gap:1.5rem!important}.row-gap-md-5{row-gap:3rem!important}.column-gap-md-0{-webkit-column-gap:0!important;column-gap:0!important}.column-gap-md-1{-webkit-column-gap:.25rem!important;column-gap:.25rem!important}.column-gap-md-2{-webkit-column-gap:.5rem!important;column-gap:.5rem!important}.column-gap-md-3{-webkit-column-gap:1rem!important;column-gap:1rem!important}.column-gap-md-4{-webkit-column-gap:1.5rem!important;column-gap:1.5rem!important}.column-gap-md-5{-webkit-column-gap:3rem!important;column-gap:3rem!important}.text-md-start{text-align:left!important}.text-md-end{text-align:right!important}.text-md-center{text-align:center!important}}@media (min-width:992px){.float-lg-start{float:left!important}.float-lg-end{float:right!important}.float-lg-none{float:none!important}.object-fit-lg-contain{object-fit:contain!important}.object-fit-lg-cover{object-fit:cover!important}.object-fit-lg-fill{object-fit:fill!important}.object-fit-lg-scale{object-fit:scale-down!important}.object-fit-lg-none{object-fit:none!important}.d-lg-inline{display:inline!important}.d-lg-inline-block{display:inline-block!important}.d-lg-block{display:block!important}.d-lg-grid{display:grid!important}.d-lg-inline-grid{display:inline-grid!important}.d-lg-table{display:table!important}.d-lg-table-row{display:table-row!important}.d-lg-table-cell{display:table-cell!important}.d-lg-flex{display:flex!important}.d-lg-inline-flex{display:inline-flex!important}.d-lg-none{display:none!important}.flex-lg-fill{flex:1 1 auto!important}.flex-lg-row{flex-direction:row!important}.flex-lg-column{flex-direction:column!important}.flex-lg-row-reverse{flex-direction:row-reverse!important}.flex-lg-column-reverse{flex-direction:column-reverse!important}.flex-lg-grow-0{flex-grow:0!important}.flex-lg-grow-1{flex-grow:1!important}.flex-lg-shrink-0{flex-shrink:0!important}.flex-lg-shrink-1{flex-shrink:1!important}.flex-lg-wrap{flex-wrap:wrap!important}.flex-lg-nowrap{flex-wrap:nowrap!important}.flex-lg-wrap-reverse{flex-wrap:wrap-reverse!important}.justify-content-lg-start{justify-content:flex-start!important}.justify-content-lg-end{justify-content:flex-end!important}.justify-content-lg-center{justify-content:center!important}.justify-content-lg-between{justify-content:space-between!important}.justify-content-lg-around{justify-content:space-around!important}.justify-content-lg-evenly{justify-content:space-evenly!important}.align-items-lg-start{align-items:flex-start!important}.align-items-lg-end{align-items:flex-end!important}.align-items-lg-center{align-items:center!important}.align-items-lg-baseline{align-items:baseline!important}.align-items-lg-stretch{align-items:stretch!important}.align-content-lg-start{align-content:flex-start!important}.align-content-lg-end{align-content:flex-end!important}.align-content-lg-center{align-content:center!important}.align-content-lg-between{align-content:space-between!important}.align-content-lg-around{align-content:space-around!important}.align-content-lg-stretch{align-content:stretch!important}.align-self-lg-auto{align-self:auto!important}.align-self-lg-start{align-self:flex-start!important}.align-self-lg-end{align-self:flex-end!important}.align-self-lg-center{align-self:center!important}.align-self-lg-baseline{align-self:baseline!important}.align-self-lg-stretch{align-self:stretch!important}.order-lg-first{order:-1!important}.order-lg-0{order:0!important}.order-lg-1{order:1!important}.order-lg-2{order:2!important}.order-lg-3{order:3!important}.order-lg-4{order:4!important}.order-lg-5{order:5!important}.order-lg-last{order:6!important}.m-lg-0{margin:0!important}.m-lg-1{margin:.25rem!important}.m-lg-2{margin:.5rem!important}.m-lg-3{margin:1rem!important}.m-lg-4{margin:1.5rem!important}.m-lg-5{margin:3rem!important}.m-lg-auto{margin:auto!important}.mx-lg-0{margin-left:0!important;margin-right:0!important}.mx-lg-1{margin-left:.25rem!important;margin-right:.25rem!important}.mx-lg-2{margin-left:.5rem!important;margin-right:.5rem!important}.mx-lg-3{margin-left:1rem!important;margin-right:1rem!important}.mx-lg-4{margin-left:1.5rem!important;margin-right:1.5rem!important}.mx-lg-5{margin-left:3rem!important;margin-right:3rem!important}.mx-lg-auto{margin-left:auto!important;margin-right:auto!important}.my-lg-0{margin-bottom:0!important;margin-top:0!important}.my-lg-1{margin-bottom:.25rem!important;margin-top:.25rem!important}.my-lg-2{margin-bottom:.5rem!important;margin-top:.5rem!important}.my-lg-3{margin-bottom:1rem!important;margin-top:1rem!important}.my-lg-4{margin-bottom:1.5rem!important;margin-top:1.5rem!important}.my-lg-5{margin-bottom:3rem!important;margin-top:3rem!important}.my-lg-auto{margin-bottom:auto!important;margin-top:auto!important}.mt-lg-0{margin-top:0!important}.mt-lg-1{margin-top:.25rem!important}.mt-lg-2{margin-top:.5rem!important}.mt-lg-3{margin-top:1rem!important}.mt-lg-4{margin-top:1.5rem!important}.mt-lg-5{margin-top:3rem!important}.mt-lg-auto{margin-top:auto!important}.me-lg-0{margin-right:0!important}.me-lg-1{margin-right:.25rem!important}.me-lg-2{margin-right:.5rem!important}.me-lg-3{margin-right:1rem!important}.me-lg-4{margin-right:1.5rem!important}.me-lg-5{margin-right:3rem!important}.me-lg-auto{margin-right:auto!important}.mb-lg-0{margin-bottom:0!important}.mb-lg-1{margin-bottom:.25rem!important}.mb-lg-2{margin-bottom:.5rem!important}.mb-lg-3{margin-bottom:1rem!important}.mb-lg-4{margin-bottom:1.5rem!important}.mb-lg-5{margin-bottom:3rem!important}.mb-lg-auto{margin-bottom:auto!important}.ms-lg-0{margin-left:0!important}.ms-lg-1{margin-left:.25rem!important}.ms-lg-2{margin-left:.5rem!important}.ms-lg-3{margin-left:1rem!important}.ms-lg-4{margin-left:1.5rem!important}.ms-lg-5{margin-left:3rem!important}.ms-lg-auto{margin-left:auto!important}.p-lg-0{padding:0!important}.p-lg-1{padding:.25rem!important}.p-lg-2{padding:.5rem!important}.p-lg-3{padding:1rem!important}.p-lg-4{padding:1.5rem!important}.p-lg-5{padding:3rem!important}.px-lg-0{padding-left:0!important;padding-right:0!important}.px-lg-1{padding-left:.25rem!important;padding-right:.25rem!important}.px-lg-2{padding-left:.5rem!important;padding-right:.5rem!important}.px-lg-3{padding-left:1rem!important;padding-right:1rem!important}.px-lg-4{padding-left:1.5rem!important;padding-right:1.5rem!important}.px-lg-5{padding-left:3rem!important;padding-right:3rem!important}.py-lg-0{padding-bottom:0!important;padding-top:0!important}.py-lg-1{padding-bottom:.25rem!important;padding-top:.25rem!important}.py-lg-2{padding-bottom:.5rem!important;padding-top:.5rem!important}.py-lg-3{padding-bottom:1rem!important;padding-top:1rem!important}.py-lg-4{padding-bottom:1.5rem!important;padding-top:1.5rem!important}.py-lg-5{padding-bottom:3rem!important;padding-top:3rem!important}.pt-lg-0{padding-top:0!important}.pt-lg-1{padding-top:.25rem!important}.pt-lg-2{padding-top:.5rem!important}.pt-lg-3{padding-top:1rem!important}.pt-lg-4{padding-top:1.5rem!important}.pt-lg-5{padding-top:3rem!important}.pe-lg-0{padding-right:0!important}.pe-lg-1{padding-right:.25rem!important}.pe-lg-2{padding-right:.5rem!important}.pe-lg-3{padding-right:1rem!important}.pe-lg-4{padding-right:1.5rem!important}.pe-lg-5{padding-right:3rem!important}.pb-lg-0{padding-bottom:0!important}.pb-lg-1{padding-bottom:.25rem!important}.pb-lg-2{padding-bottom:.5rem!important}.pb-lg-3{padding-bottom:1rem!important}.pb-lg-4{padding-bottom:1.5rem!important}.pb-lg-5{padding-bottom:3rem!important}.ps-lg-0{padding-left:0!important}.ps-lg-1{padding-left:.25rem!important}.ps-lg-2{padding-left:.5rem!important}.ps-lg-3{padding-left:1rem!important}.ps-lg-4{padding-left:1.5rem!important}.ps-lg-5{padding-left:3rem!important}.gap-lg-0{gap:0!important}.gap-lg-1{gap:.25rem!important}.gap-lg-2{gap:.5rem!important}.gap-lg-3{gap:1rem!important}.gap-lg-4{gap:1.5rem!important}.gap-lg-5{gap:3rem!important}.row-gap-lg-0{row-gap:0!important}.row-gap-lg-1{row-gap:.25rem!important}.row-gap-lg-2{row-gap:.5rem!important}.row-gap-lg-3{row-gap:1rem!important}.row-gap-lg-4{row-gap:1.5rem!important}.row-gap-lg-5{row-gap:3rem!important}.column-gap-lg-0{-webkit-column-gap:0!important;column-gap:0!important}.column-gap-lg-1{-webkit-column-gap:.25rem!important;column-gap:.25rem!important}.column-gap-lg-2{-webkit-column-gap:.5rem!important;column-gap:.5rem!important}.column-gap-lg-3{-webkit-column-gap:1rem!important;column-gap:1rem!important}.column-gap-lg-4{-webkit-column-gap:1.5rem!important;column-gap:1.5rem!important}.column-gap-lg-5{-webkit-column-gap:3rem!important;column-gap:3rem!important}.text-lg-start{text-align:left!important}.text-lg-end{text-align:right!important}.text-lg-center{text-align:center!important}}@media (min-width:1200px){.float-xl-start{float:left!important}.float-xl-end{float:right!important}.float-xl-none{float:none!important}.object-fit-xl-contain{object-fit:contain!important}.object-fit-xl-cover{object-fit:cover!important}.object-fit-xl-fill{object-fit:fill!important}.object-fit-xl-scale{object-fit:scale-down!important}.object-fit-xl-none{object-fit:none!important}.d-xl-inline{display:inline!important}.d-xl-inline-block{display:inline-block!important}.d-xl-block{display:block!important}.d-xl-grid{display:grid!important}.d-xl-inline-grid{display:inline-grid!important}.d-xl-table{display:table!important}.d-xl-table-row{display:table-row!important}.d-xl-table-cell{display:table-cell!important}.d-xl-flex{display:flex!important}.d-xl-inline-flex{display:inline-flex!important}.d-xl-none{display:none!important}.flex-xl-fill{flex:1 1 auto!important}.flex-xl-row{flex-direction:row!important}.flex-xl-column{flex-direction:column!important}.flex-xl-row-reverse{flex-direction:row-reverse!important}.flex-xl-column-reverse{flex-direction:column-reverse!important}.flex-xl-grow-0{flex-grow:0!important}.flex-xl-grow-1{flex-grow:1!important}.flex-xl-shrink-0{flex-shrink:0!important}.flex-xl-shrink-1{flex-shrink:1!important}.flex-xl-wrap{flex-wrap:wrap!important}.flex-xl-nowrap{flex-wrap:nowrap!important}.flex-xl-wrap-reverse{flex-wrap:wrap-reverse!important}.justify-content-xl-start{justify-content:flex-start!important}.justify-content-xl-end{justify-content:flex-end!important}.justify-content-xl-center{justify-content:center!important}.justify-content-xl-between{justify-content:space-between!important}.justify-content-xl-around{justify-content:space-around!important}.justify-content-xl-evenly{justify-content:space-evenly!important}.align-items-xl-start{align-items:flex-start!important}.align-items-xl-end{align-items:flex-end!important}.align-items-xl-center{align-items:center!important}.align-items-xl-baseline{align-items:baseline!important}.align-items-xl-stretch{align-items:stretch!important}.align-content-xl-start{align-content:flex-start!important}.align-content-xl-end{align-content:flex-end!important}.align-content-xl-center{align-content:center!important}.align-content-xl-between{align-content:space-between!important}.align-content-xl-around{align-content:space-around!important}.align-content-xl-stretch{align-content:stretch!important}.align-self-xl-auto{align-self:auto!important}.align-self-xl-start{align-self:flex-start!important}.align-self-xl-end{align-self:flex-end!important}.align-self-xl-center{align-self:center!important}.align-self-xl-baseline{align-self:baseline!important}.align-self-xl-stretch{align-self:stretch!important}.order-xl-first{order:-1!important}.order-xl-0{order:0!important}.order-xl-1{order:1!important}.order-xl-2{order:2!important}.order-xl-3{order:3!important}.order-xl-4{order:4!important}.order-xl-5{order:5!important}.order-xl-last{order:6!important}.m-xl-0{margin:0!important}.m-xl-1{margin:.25rem!important}.m-xl-2{margin:.5rem!important}.m-xl-3{margin:1rem!important}.m-xl-4{margin:1.5rem!important}.m-xl-5{margin:3rem!important}.m-xl-auto{margin:auto!important}.mx-xl-0{margin-left:0!important;margin-right:0!important}.mx-xl-1{margin-left:.25rem!important;margin-right:.25rem!important}.mx-xl-2{margin-left:.5rem!important;margin-right:.5rem!important}.mx-xl-3{margin-left:1rem!important;margin-right:1rem!important}.mx-xl-4{margin-left:1.5rem!important;margin-right:1.5rem!important}.mx-xl-5{margin-left:3rem!important;margin-right:3rem!important}.mx-xl-auto{margin-left:auto!important;margin-right:auto!important}.my-xl-0{margin-bottom:0!important;margin-top:0!important}.my-xl-1{margin-bottom:.25rem!important;margin-top:.25rem!important}.my-xl-2{margin-bottom:.5rem!important;margin-top:.5rem!important}.my-xl-3{margin-bottom:1rem!important;margin-top:1rem!important}.my-xl-4{margin-bottom:1.5rem!important;margin-top:1.5rem!important}.my-xl-5{margin-bottom:3rem!important;margin-top:3rem!important}.my-xl-auto{margin-bottom:auto!important;margin-top:auto!important}.mt-xl-0{margin-top:0!important}.mt-xl-1{margin-top:.25rem!important}.mt-xl-2{margin-top:.5rem!important}.mt-xl-3{margin-top:1rem!important}.mt-xl-4{margin-top:1.5rem!important}.mt-xl-5{margin-top:3rem!important}.mt-xl-auto{margin-top:auto!important}.me-xl-0{margin-right:0!important}.me-xl-1{margin-right:.25rem!important}.me-xl-2{margin-right:.5rem!important}.me-xl-3{margin-right:1rem!important}.me-xl-4{margin-right:1.5rem!important}.me-xl-5{margin-right:3rem!important}.me-xl-auto{margin-right:auto!important}.mb-xl-0{margin-bottom:0!important}.mb-xl-1{margin-bottom:.25rem!important}.mb-xl-2{margin-bottom:.5rem!important}.mb-xl-3{margin-bottom:1rem!important}.mb-xl-4{margin-bottom:1.5rem!important}.mb-xl-5{margin-bottom:3rem!important}.mb-xl-auto{margin-bottom:auto!important}.ms-xl-0{margin-left:0!important}.ms-xl-1{margin-left:.25rem!important}.ms-xl-2{margin-left:.5rem!important}.ms-xl-3{margin-left:1rem!important}.ms-xl-4{margin-left:1.5rem!important}.ms-xl-5{margin-left:3rem!important}.ms-xl-auto{margin-left:auto!important}.p-xl-0{padding:0!important}.p-xl-1{padding:.25rem!important}.p-xl-2{padding:.5rem!important}.p-xl-3{padding:1rem!important}.p-xl-4{padding:1.5rem!important}.p-xl-5{padding:3rem!important}.px-xl-0{padding-left:0!important;padding-right:0!important}.px-xl-1{padding-left:.25rem!important;padding-right:.25rem!important}.px-xl-2{padding-left:.5rem!important;padding-right:.5rem!important}.px-xl-3{padding-left:1rem!important;padding-right:1rem!important}.px-xl-4{padding-left:1.5rem!important;padding-right:1.5rem!important}.px-xl-5{padding-left:3rem!important;padding-right:3rem!important}.py-xl-0{padding-bottom:0!important;padding-top:0!important}.py-xl-1{padding-bottom:.25rem!important;padding-top:.25rem!important}.py-xl-2{padding-bottom:.5rem!important;padding-top:.5rem!important}.py-xl-3{padding-bottom:1rem!important;padding-top:1rem!important}.py-xl-4{padding-bottom:1.5rem!important;padding-top:1.5rem!important}.py-xl-5{padding-bottom:3rem!important;padding-top:3rem!important}.pt-xl-0{padding-top:0!important}.pt-xl-1{padding-top:.25rem!important}.pt-xl-2{padding-top:.5rem!important}.pt-xl-3{padding-top:1rem!important}.pt-xl-4{padding-top:1.5rem!important}.pt-xl-5{padding-top:3rem!important}.pe-xl-0{padding-right:0!important}.pe-xl-1{padding-right:.25rem!important}.pe-xl-2{padding-right:.5rem!important}.pe-xl-3{padding-right:1rem!important}.pe-xl-4{padding-right:1.5rem!important}.pe-xl-5{padding-right:3rem!important}.pb-xl-0{padding-bottom:0!important}.pb-xl-1{padding-bottom:.25rem!important}.pb-xl-2{padding-bottom:.5rem!important}.pb-xl-3{padding-bottom:1rem!important}.pb-xl-4{padding-bottom:1.5rem!important}.pb-xl-5{padding-bottom:3rem!important}.ps-xl-0{padding-left:0!important}.ps-xl-1{padding-left:.25rem!important}.ps-xl-2{padding-left:.5rem!important}.ps-xl-3{padding-left:1rem!important}.ps-xl-4{padding-left:1.5rem!important}.ps-xl-5{padding-left:3rem!important}.gap-xl-0{gap:0!important}.gap-xl-1{gap:.25rem!important}.gap-xl-2{gap:.5rem!important}.gap-xl-3{gap:1rem!important}.gap-xl-4{gap:1.5rem!important}.gap-xl-5{gap:3rem!important}.row-gap-xl-0{row-gap:0!important}.row-gap-xl-1{row-gap:.25rem!important}.row-gap-xl-2{row-gap:.5rem!important}.row-gap-xl-3{row-gap:1rem!important}.row-gap-xl-4{row-gap:1.5rem!important}.row-gap-xl-5{row-gap:3rem!important}.column-gap-xl-0{-webkit-column-gap:0!important;column-gap:0!important}.column-gap-xl-1{-webkit-column-gap:.25rem!important;column-gap:.25rem!important}.column-gap-xl-2{-webkit-column-gap:.5rem!important;column-gap:.5rem!important}.column-gap-xl-3{-webkit-column-gap:1rem!important;column-gap:1rem!important}.column-gap-xl-4{-webkit-column-gap:1.5rem!important;column-gap:1.5rem!important}.column-gap-xl-5{-webkit-column-gap:3rem!important;column-gap:3rem!important}.text-xl-start{text-align:left!important}.text-xl-end{text-align:right!important}.text-xl-center{text-align:center!important}}@media (min-width:1400px){.float-xxl-start{float:left!important}.float-xxl-end{float:right!important}.float-xxl-none{float:none!important}.object-fit-xxl-contain{object-fit:contain!important}.object-fit-xxl-cover{object-fit:cover!important}.object-fit-xxl-fill{object-fit:fill!important}.object-fit-xxl-scale{object-fit:scale-down!important}.object-fit-xxl-none{object-fit:none!important}.d-xxl-inline{display:inline!important}.d-xxl-inline-block{display:inline-block!important}.d-xxl-block{display:block!important}.d-xxl-grid{display:grid!important}.d-xxl-inline-grid{display:inline-grid!important}.d-xxl-table{display:table!important}.d-xxl-table-row{display:table-row!important}.d-xxl-table-cell{display:table-cell!important}.d-xxl-flex{display:flex!important}.d-xxl-inline-flex{display:inline-flex!important}.d-xxl-none{display:none!important}.flex-xxl-fill{flex:1 1 auto!important}.flex-xxl-row{flex-direction:row!important}.flex-xxl-column{flex-direction:column!important}.flex-xxl-row-reverse{flex-direction:row-reverse!important}.flex-xxl-column-reverse{flex-direction:column-reverse!important}.flex-xxl-grow-0{flex-grow:0!important}.flex-xxl-grow-1{flex-grow:1!important}.flex-xxl-shrink-0{flex-shrink:0!important}.flex-xxl-shrink-1{flex-shrink:1!important}.flex-xxl-wrap{flex-wrap:wrap!important}.flex-xxl-nowrap{flex-wrap:nowrap!important}.flex-xxl-wrap-reverse{flex-wrap:wrap-reverse!important}.justify-content-xxl-start{justify-content:flex-start!important}.justify-content-xxl-end{justify-content:flex-end!important}.justify-content-xxl-center{justify-content:center!important}.justify-content-xxl-between{justify-content:space-between!important}.justify-content-xxl-around{justify-content:space-around!important}.justify-content-xxl-evenly{justify-content:space-evenly!important}.align-items-xxl-start{align-items:flex-start!important}.align-items-xxl-end{align-items:flex-end!important}.align-items-xxl-center{align-items:center!important}.align-items-xxl-baseline{align-items:baseline!important}.align-items-xxl-stretch{align-items:stretch!important}.align-content-xxl-start{align-content:flex-start!important}.align-content-xxl-end{align-content:flex-end!important}.align-content-xxl-center{align-content:center!important}.align-content-xxl-between{align-content:space-between!important}.align-content-xxl-around{align-content:space-around!important}.align-content-xxl-stretch{align-content:stretch!important}.align-self-xxl-auto{align-self:auto!important}.align-self-xxl-start{align-self:flex-start!important}.align-self-xxl-end{align-self:flex-end!important}.align-self-xxl-center{align-self:center!important}.align-self-xxl-baseline{align-self:baseline!important}.align-self-xxl-stretch{align-self:stretch!important}.order-xxl-first{order:-1!important}.order-xxl-0{order:0!important}.order-xxl-1{order:1!important}.order-xxl-2{order:2!important}.order-xxl-3{order:3!important}.order-xxl-4{order:4!important}.order-xxl-5{order:5!important}.order-xxl-last{order:6!important}.m-xxl-0{margin:0!important}.m-xxl-1{margin:.25rem!important}.m-xxl-2{margin:.5rem!important}.m-xxl-3{margin:1rem!important}.m-xxl-4{margin:1.5rem!important}.m-xxl-5{margin:3rem!important}.m-xxl-auto{margin:auto!important}.mx-xxl-0{margin-left:0!important;margin-right:0!important}.mx-xxl-1{margin-left:.25rem!important;margin-right:.25rem!important}.mx-xxl-2{margin-left:.5rem!important;margin-right:.5rem!important}.mx-xxl-3{margin-left:1rem!important;margin-right:1rem!important}.mx-xxl-4{margin-left:1.5rem!important;margin-right:1.5rem!important}.mx-xxl-5{margin-left:3rem!important;margin-right:3rem!important}.mx-xxl-auto{margin-left:auto!important;margin-right:auto!important}.my-xxl-0{margin-bottom:0!important;margin-top:0!important}.my-xxl-1{margin-bottom:.25rem!important;margin-top:.25rem!important}.my-xxl-2{margin-bottom:.5rem!important;margin-top:.5rem!important}.my-xxl-3{margin-bottom:1rem!important;margin-top:1rem!important}.my-xxl-4{margin-bottom:1.5rem!important;margin-top:1.5rem!important}.my-xxl-5{margin-bottom:3rem!important;margin-top:3rem!important}.my-xxl-auto{margin-bottom:auto!important;margin-top:auto!important}.mt-xxl-0{margin-top:0!important}.mt-xxl-1{margin-top:.25rem!important}.mt-xxl-2{margin-top:.5rem!important}.mt-xxl-3{margin-top:1rem!important}.mt-xxl-4{margin-top:1.5rem!important}.mt-xxl-5{margin-top:3rem!important}.mt-xxl-auto{margin-top:auto!important}.me-xxl-0{margin-right:0!important}.me-xxl-1{margin-right:.25rem!important}.me-xxl-2{margin-right:.5rem!important}.me-xxl-3{margin-right:1rem!important}.me-xxl-4{margin-right:1.5rem!important}.me-xxl-5{margin-right:3rem!important}.me-xxl-auto{margin-right:auto!important}.mb-xxl-0{margin-bottom:0!important}.mb-xxl-1{margin-bottom:.25rem!important}.mb-xxl-2{margin-bottom:.5rem!important}.mb-xxl-3{margin-bottom:1rem!important}.mb-xxl-4{margin-bottom:1.5rem!important}.mb-xxl-5{margin-bottom:3rem!important}.mb-xxl-auto{margin-bottom:auto!important}.ms-xxl-0{margin-left:0!important}.ms-xxl-1{margin-left:.25rem!important}.ms-xxl-2{margin-left:.5rem!important}.ms-xxl-3{margin-left:1rem!important}.ms-xxl-4{margin-left:1.5rem!important}.ms-xxl-5{margin-left:3rem!important}.ms-xxl-auto{margin-left:auto!important}.p-xxl-0{padding:0!important}.p-xxl-1{padding:.25rem!important}.p-xxl-2{padding:.5rem!important}.p-xxl-3{padding:1rem!important}.p-xxl-4{padding:1.5rem!important}.p-xxl-5{padding:3rem!important}.px-xxl-0{padding-left:0!important;padding-right:0!important}.px-xxl-1{padding-left:.25rem!important;padding-right:.25rem!important}.px-xxl-2{padding-left:.5rem!important;padding-right:.5rem!important}.px-xxl-3{padding-left:1rem!important;padding-right:1rem!important}.px-xxl-4{padding-left:1.5rem!important;padding-right:1.5rem!important}.px-xxl-5{padding-left:3rem!important;padding-right:3rem!important}.py-xxl-0{padding-bottom:0!important;padding-top:0!important}.py-xxl-1{padding-bottom:.25rem!important;padding-top:.25rem!important}.py-xxl-2{padding-bottom:.5rem!important;padding-top:.5rem!important}.py-xxl-3{padding-bottom:1rem!important;padding-top:1rem!important}.py-xxl-4{padding-bottom:1.5rem!important;padding-top:1.5rem!important}.py-xxl-5{padding-bottom:3rem!important;padding-top:3rem!important}.pt-xxl-0{padding-top:0!important}.pt-xxl-1{padding-top:.25rem!important}.pt-xxl-2{padding-top:.5rem!important}.pt-xxl-3{padding-top:1rem!important}.pt-xxl-4{padding-top:1.5rem!important}.pt-xxl-5{padding-top:3rem!important}.pe-xxl-0{padding-right:0!important}.pe-xxl-1{padding-right:.25rem!important}.pe-xxl-2{padding-right:.5rem!important}.pe-xxl-3{padding-right:1rem!important}.pe-xxl-4{padding-right:1.5rem!important}.pe-xxl-5{padding-right:3rem!important}.pb-xxl-0{padding-bottom:0!important}.pb-xxl-1{padding-bottom:.25rem!important}.pb-xxl-2{padding-bottom:.5rem!important}.pb-xxl-3{padding-bottom:1rem!important}.pb-xxl-4{padding-bottom:1.5rem!important}.pb-xxl-5{padding-bottom:3rem!important}.ps-xxl-0{padding-left:0!important}.ps-xxl-1{padding-left:.25rem!important}.ps-xxl-2{padding-left:.5rem!important}.ps-xxl-3{padding-left:1rem!important}.ps-xxl-4{padding-left:1.5rem!important}.ps-xxl-5{padding-left:3rem!important}.gap-xxl-0{gap:0!important}.gap-xxl-1{gap:.25rem!important}.gap-xxl-2{gap:.5rem!important}.gap-xxl-3{gap:1rem!important}.gap-xxl-4{gap:1.5rem!important}.gap-xxl-5{gap:3rem!important}.row-gap-xxl-0{row-gap:0!important}.row-gap-xxl-1{row-gap:.25rem!important}.row-gap-xxl-2{row-gap:.5rem!important}.row-gap-xxl-3{row-gap:1rem!important}.row-gap-xxl-4{row-gap:1.5rem!important}.row-gap-xxl-5{row-gap:3rem!important}.column-gap-xxl-0{-webkit-column-gap:0!important;column-gap:0!important}.column-gap-xxl-1{-webkit-column-gap:.25rem!important;column-gap:.25rem!important}.column-gap-xxl-2{-webkit-column-gap:.5rem!important;column-gap:.5rem!important}.column-gap-xxl-3{-webkit-column-gap:1rem!important;column-gap:1rem!important}.column-gap-xxl-4{-webkit-column-gap:1.5rem!important;column-gap:1.5rem!important}.column-gap-xxl-5{-webkit-column-gap:3rem!important;column-gap:3rem!important}.text-xxl-start{text-align:left!important}.text-xxl-end{text-align:right!important}.text-xxl-center{text-align:center!important}}@media (min-width:1200px){.fs-1{font-size:2.5rem!important}.fs-2{font-size:2rem!important}.fs-3{font-size:1.75rem!important}.fs-4{font-size:1.5rem!important}}@media print{.d-print-inline{display:inline!important}.d-print-inline-block{display:inline-block!important}.d-print-block{display:block!important}.d-print-grid{display:grid!important}.d-print-inline-grid{display:inline-grid!important}.d-print-table{display:table!important}.d-print-table-row{display:table-row!important}.d-print-table-cell{display:table-cell!important}.d-print-flex{display:flex!important}.d-print-inline-flex{display:inline-flex!important}.d-print-none{display:none!important}}@font-face{font-display:swap;font-family:Lato;font-style:normal;font-weight:400;src:url(/apps/sme-visualisations/static/media/Lato-Regular.2b7b7f6c8554ad96436b.ttf) format("truetype")}@font-face{font-display:swap;font-family:Lato;font-style:normal;font-weight:700 900;src:url(/apps/sme-visualisations/static/media/Lato-Black.0f56360fd2c505dd13fa.ttf) format("truetype")}:root{--silicon-ink:#263d45;--silicon-cyan:#006d7a;--silicon-paper:#f4f8f8;--silicon-line:#c5d5d8;--silicon-yellow:#ffc700;--silicon-red:#ba302c}body{-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;background-color:#f4f8f8;background-color:var(--silicon-paper);background-image:radial-gradient(#c5d5d866 .7px,transparent 0);background-size:16px 16px;color:#263d45;color:var(--silicon-ink);font-family:Lato,sans-serif;margin:0}code{color:#006d7a;color:var(--silicon-cyan);font-family:ui-monospace,Menlo,Consolas,monospace}h1,h2{text-wrap:balance;font-weight:900}h1{font-size:clamp(1.65rem,3vw,2.75rem);letter-spacing:-.025em}h2{font-size:clamp(1.05rem,1.8vw,1.5rem)}a{color:#006d7a;color:var(--silicon-cyan)}:focus-visible{outline:3px solid #006d7a;outline:3px solid var(--silicon-cyan);outline-offset:4px}#root>.container-fluid{padding:clamp(1rem,3vw,3rem)}#root>.container-fluid>header{border-bottom:1px solid #c5d5d8;border-bottom:1px solid var(--silicon-line);margin-bottom:2rem;padding:1rem 0 1.75rem;row-gap:1.5rem}#description{margin:.75rem auto 0;max-width:65ch}.btn{border-radius:2px;box-shadow:0 3px 5px #263d4514;font-weight:700;min-height:42px;transition:background-color .14s ease-out,box-shadow .14s ease-out}.btn-primary{background-color:#006d7a;background-color:var(--silicon-cyan);border-color:#006d7a;border-color:var(--silicon-cyan);color:#fff}.btn-primary.active,.btn-primary:active,.btn-primary:focus,.btn-primary:hover{background-color:#004e59;border-color:#004e59;color:#fff}.btn-primary:disabled{background-color:#006d7a;background-color:var(--silicon-cyan);border-color:#006d7a;border-color:var(--silicon-cyan)}.btn:focus-visible{box-shadow:none;outline:3px solid #006d7a;outline:3px solid var(--silicon-cyan);outline-offset:3px}.btn:disabled{box-shadow:none}.text-danger{color:#ba302c!important;color:var(--silicon-red)!important}.silicon-grid{-webkit-font-feature-settings:"tnum";font-feature-settings:"tnum";font-variant-numeric:tabular-nums;overflow:visible;width:100%}.silicon-grid-cell{shape-rendering:crispEdges}.silicon-grid-depth{fill:#6a858d;pointer-events:none}#root>.silicon-directory{max-width:1240px;padding:clamp(1.5rem,5vw,5rem) clamp(1.25rem,5vw,4rem)}.directory-heading{align-items:center;display:flex;gap:2rem;justify-content:space-between;margin-bottom:clamp(2rem,5vw,4rem)}.directory-heading h1{color:#006d7a;color:var(--silicon-cyan);font-size:clamp(2.75rem,6vw,5rem);line-height:1.05;margin:0;max-width:11ch}.directory-die{flex:0 0 auto;image-rendering:pixelated;width:clamp(112px,20vw,210px)}.directory-board{background:#dce9eb;-webkit-clip-path:polygon(0 0,calc(100% - 16px) 0,100% 16px,100% 100%,16px 100%,0 calc(100% - 16px));clip-path:polygon(0 0,calc(100% - 16px) 0,100% 16px,100% 100%,16px 100%,0 calc(100% - 16px));padding:clamp(1rem,2.8vw,2rem)}.die-directory{grid-gap:1.25rem;display:grid;gap:1.25rem;grid-template-columns:repeat(3,minmax(0,1fr))}.die-directory .nav-item{min-width:0}.die-directory .nav-link{align-items:flex-end;background:#263d45;background:var(--silicon-ink);box-shadow:3px 5px 7px #263d4526;color:#fff;display:flex;font-size:1.05rem;font-weight:700;height:100%;line-height:1.4;min-height:145px;padding:2.25rem 1.25rem 1.25rem;position:relative;transition:background-color .16s ease-out,-webkit-transform .16s ease-out;transition:background-color .16s ease-out,transform .16s ease-out;transition:background-color .16s ease-out,transform .16s ease-out,-webkit-transform .16s ease-out}.die-directory .nav-link:before{background:#a8dde0;box-shadow:12px 0 #a8dde0,24px 0 #a8dde0;content:"";height:8px;left:20px;pointer-events:none;position:absolute;top:16px;width:8px}.die-directory .nav-link:focus-visible:before,.die-directory .nav-link:hover:before{background:#ffc700;background:var(--silicon-yellow)}.die-directory .nav-link:hover{background:#005966;-webkit-transform:translateY(-2px);transform:translateY(-2px)}.die-directory .nav-link:focus-visible{outline-color:#006d7a;outline-color:var(--silicon-cyan);outline-offset:4px}@media (max-width:700px){#root>.container-fluid>header>.col{flex:1 0 100%}.directory-heading{gap:1rem}.directory-heading h1{font-size:clamp(2rem,7.5vw,3.25rem)}.directory-die{width:88px}.die-directory{gap:1rem;grid-template-columns:repeat(2,minmax(0,1fr))}.die-directory .nav-link{font-size:.95rem;min-height:144px;padding:2.25rem .85rem 1rem}}@media (max-width:360px){.directory-die{width:72px}.directory-heading h1{font-size:1.8rem}}@media (prefers-reduced-motion:reduce){.btn,.die-directory .nav-link{transition:none}.die-directory .nav-link:hover{-webkit-transform:none;transform:none}}#root>.container,#root>.container-fluid{min-height:0}.silicon-grid{display:block;height:auto;margin-left:auto;margin-right:auto;max-width:100%} -/*# sourceMappingURL=main.05a1c7d9.css.map*/ \ No newline at end of file + */:root,[data-bs-theme=light]{--bs-blue:#0d6efd;--bs-indigo:#6610f2;--bs-purple:#6f42c1;--bs-pink:#d63384;--bs-red:#dc3545;--bs-orange:#fd7e14;--bs-yellow:#ffc107;--bs-green:#198754;--bs-teal:#20c997;--bs-cyan:#0dcaf0;--bs-black:#000;--bs-white:#fff;--bs-gray:#6c757d;--bs-gray-dark:#343a40;--bs-gray-100:#f8f9fa;--bs-gray-200:#e9ecef;--bs-gray-300:#dee2e6;--bs-gray-400:#ced4da;--bs-gray-500:#adb5bd;--bs-gray-600:#6c757d;--bs-gray-700:#495057;--bs-gray-800:#343a40;--bs-gray-900:#212529;--bs-primary:#0d6efd;--bs-secondary:#6c757d;--bs-success:#198754;--bs-info:#0dcaf0;--bs-warning:#ffc107;--bs-danger:#dc3545;--bs-light:#f8f9fa;--bs-dark:#212529;--bs-primary-rgb:13,110,253;--bs-secondary-rgb:108,117,125;--bs-success-rgb:25,135,84;--bs-info-rgb:13,202,240;--bs-warning-rgb:255,193,7;--bs-danger-rgb:220,53,69;--bs-light-rgb:248,249,250;--bs-dark-rgb:33,37,41;--bs-primary-text-emphasis:#052c65;--bs-secondary-text-emphasis:#2b2f32;--bs-success-text-emphasis:#0a3622;--bs-info-text-emphasis:#055160;--bs-warning-text-emphasis:#664d03;--bs-danger-text-emphasis:#58151c;--bs-light-text-emphasis:#495057;--bs-dark-text-emphasis:#495057;--bs-primary-bg-subtle:#cfe2ff;--bs-secondary-bg-subtle:#e2e3e5;--bs-success-bg-subtle:#d1e7dd;--bs-info-bg-subtle:#cff4fc;--bs-warning-bg-subtle:#fff3cd;--bs-danger-bg-subtle:#f8d7da;--bs-light-bg-subtle:#fcfcfd;--bs-dark-bg-subtle:#ced4da;--bs-primary-border-subtle:#9ec5fe;--bs-secondary-border-subtle:#c4c8cb;--bs-success-border-subtle:#a3cfbb;--bs-info-border-subtle:#9eeaf9;--bs-warning-border-subtle:#ffe69c;--bs-danger-border-subtle:#f1aeb5;--bs-light-border-subtle:#e9ecef;--bs-dark-border-subtle:#adb5bd;--bs-white-rgb:255,255,255;--bs-black-rgb:0,0,0;--bs-font-sans-serif:system-ui,-apple-system,"Segoe UI",Roboto,"Helvetica Neue","Noto Sans","Liberation Sans",Arial,sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji";--bs-font-monospace:SFMono-Regular,Menlo,Monaco,Consolas,"Liberation Mono","Courier New",monospace;--bs-gradient:linear-gradient(180deg,hsla(0,0%,100%,.15),hsla(0,0%,100%,0));--bs-body-font-family:var(--bs-font-sans-serif);--bs-body-font-size:1rem;--bs-body-font-weight:400;--bs-body-line-height:1.5;--bs-body-color:#212529;--bs-body-color-rgb:33,37,41;--bs-body-bg:#fff;--bs-body-bg-rgb:255,255,255;--bs-emphasis-color:#000;--bs-emphasis-color-rgb:0,0,0;--bs-secondary-color:rgba(33,37,41,.75);--bs-secondary-color-rgb:33,37,41;--bs-secondary-bg:#e9ecef;--bs-secondary-bg-rgb:233,236,239;--bs-tertiary-color:rgba(33,37,41,.5);--bs-tertiary-color-rgb:33,37,41;--bs-tertiary-bg:#f8f9fa;--bs-tertiary-bg-rgb:248,249,250;--bs-heading-color:inherit;--bs-link-color:#0d6efd;--bs-link-color-rgb:13,110,253;--bs-link-decoration:underline;--bs-link-hover-color:#0a58ca;--bs-link-hover-color-rgb:10,88,202;--bs-code-color:#d63384;--bs-highlight-color:#212529;--bs-highlight-bg:#fff3cd;--bs-border-width:1px;--bs-border-style:solid;--bs-border-color:#dee2e6;--bs-border-color-translucent:rgba(0,0,0,.175);--bs-border-radius:0.375rem;--bs-border-radius-sm:0.25rem;--bs-border-radius-lg:0.5rem;--bs-border-radius-xl:1rem;--bs-border-radius-xxl:2rem;--bs-border-radius-2xl:var(--bs-border-radius-xxl);--bs-border-radius-pill:50rem;--bs-box-shadow:0 0.5rem 1rem rgba(0,0,0,.15);--bs-box-shadow-sm:0 0.125rem 0.25rem rgba(0,0,0,.075);--bs-box-shadow-lg:0 1rem 3rem rgba(0,0,0,.175);--bs-box-shadow-inset:inset 0 1px 2px rgba(0,0,0,.075);--bs-focus-ring-width:0.25rem;--bs-focus-ring-opacity:0.25;--bs-focus-ring-color:rgba(13,110,253,.25);--bs-form-valid-color:#198754;--bs-form-valid-border-color:#198754;--bs-form-invalid-color:#dc3545;--bs-form-invalid-border-color:#dc3545}[data-bs-theme=dark]{--bs-body-color:#dee2e6;--bs-body-color-rgb:222,226,230;--bs-body-bg:#212529;--bs-body-bg-rgb:33,37,41;--bs-emphasis-color:#fff;--bs-emphasis-color-rgb:255,255,255;--bs-secondary-color:rgba(222,226,230,.75);--bs-secondary-color-rgb:222,226,230;--bs-secondary-bg:#343a40;--bs-secondary-bg-rgb:52,58,64;--bs-tertiary-color:rgba(222,226,230,.5);--bs-tertiary-color-rgb:222,226,230;--bs-tertiary-bg:#2b3035;--bs-tertiary-bg-rgb:43,48,53;--bs-primary-text-emphasis:#6ea8fe;--bs-secondary-text-emphasis:#a7acb1;--bs-success-text-emphasis:#75b798;--bs-info-text-emphasis:#6edff6;--bs-warning-text-emphasis:#ffda6a;--bs-danger-text-emphasis:#ea868f;--bs-light-text-emphasis:#f8f9fa;--bs-dark-text-emphasis:#dee2e6;--bs-primary-bg-subtle:#031633;--bs-secondary-bg-subtle:#161719;--bs-success-bg-subtle:#051b11;--bs-info-bg-subtle:#032830;--bs-warning-bg-subtle:#332701;--bs-danger-bg-subtle:#2c0b0e;--bs-light-bg-subtle:#343a40;--bs-dark-bg-subtle:#1a1d20;--bs-primary-border-subtle:#084298;--bs-secondary-border-subtle:#41464b;--bs-success-border-subtle:#0f5132;--bs-info-border-subtle:#087990;--bs-warning-border-subtle:#997404;--bs-danger-border-subtle:#842029;--bs-light-border-subtle:#495057;--bs-dark-border-subtle:#343a40;--bs-heading-color:inherit;--bs-link-color:#6ea8fe;--bs-link-hover-color:#8bb9fe;--bs-link-color-rgb:110,168,254;--bs-link-hover-color-rgb:139,185,254;--bs-code-color:#e685b5;--bs-highlight-color:#dee2e6;--bs-highlight-bg:#664d03;--bs-border-color:#495057;--bs-border-color-translucent:hsla(0,0%,100%,.15);--bs-form-valid-color:#75b798;--bs-form-valid-border-color:#75b798;--bs-form-invalid-color:#ea868f;--bs-form-invalid-border-color:#ea868f;color-scheme:dark}*,:after,:before{box-sizing:border-box}@media (prefers-reduced-motion:no-preference){:root{scroll-behavior:smooth}}body{-webkit-text-size-adjust:100%;-webkit-tap-highlight-color:rgba(0,0,0,0);background-color:#fff;background-color:var(--bs-body-bg);color:#212529;color:var(--bs-body-color);font-family:system-ui,-apple-system,Segoe UI,Roboto,Helvetica Neue,Noto Sans,Liberation Sans,Arial,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol,Noto Color Emoji;font-family:var(--bs-body-font-family);font-size:1rem;font-size:var(--bs-body-font-size);font-weight:400;font-weight:var(--bs-body-font-weight);line-height:1.5;line-height:var(--bs-body-line-height);text-align:var(--bs-body-text-align)}hr{border:0;border-top:1px solid;border-top:var(--bs-border-width) solid;color:inherit;margin:1rem 0;opacity:.25}.h1,.h2,.h3,.h4,.h5,.h6,h1,h2,h3,h4,h5,h6{color:inherit;color:var(--bs-heading-color);font-weight:500;line-height:1.2;margin-bottom:.5rem;margin-top:0}.h1,h1{font-size:calc(1.375rem + 1.5vw)}@media (min-width:1200px){.h1,h1{font-size:2.5rem}}.h2,h2{font-size:calc(1.325rem + .9vw)}@media (min-width:1200px){.h2,h2{font-size:2rem}}.h3,h3{font-size:calc(1.3rem + .6vw)}@media (min-width:1200px){.h3,h3{font-size:1.75rem}}.h4,h4{font-size:calc(1.275rem + .3vw)}@media (min-width:1200px){.h4,h4{font-size:1.5rem}}.h5,h5{font-size:1.25rem}.h6,h6{font-size:1rem}p{margin-bottom:1rem;margin-top:0}abbr[title]{cursor:help;-webkit-text-decoration:underline dotted;text-decoration:underline dotted;-webkit-text-decoration-skip-ink:none;text-decoration-skip-ink:none}address{font-style:normal;line-height:inherit;margin-bottom:1rem}ol,ul{padding-left:2rem}dl,ol,ul{margin-bottom:1rem;margin-top:0}ol ol,ol ul,ul ol,ul ul{margin-bottom:0}dt{font-weight:700}dd{margin-bottom:.5rem;margin-left:0}blockquote{margin:0 0 1rem}b,strong{font-weight:bolder}.small,small{font-size:.875em}.mark,mark{background-color:#fff3cd;background-color:var(--bs-highlight-bg);color:#212529;color:var(--bs-highlight-color);padding:.1875em}sub,sup{font-size:.75em;line-height:0;position:relative;vertical-align:initial}sub{bottom:-.25em}sup{top:-.5em}a{color:#0d6efd;color:rgba(var(--bs-link-color-rgb),var(--bs-link-opacity,1));text-decoration:underline}a:hover{--bs-link-color-rgb:var(--bs-link-hover-color-rgb)}a:not([href]):not([class]),a:not([href]):not([class]):hover{color:inherit;text-decoration:none}code,kbd,pre,samp{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,monospace;font-family:var(--bs-font-monospace);font-size:1em}pre{display:block;font-size:.875em;margin-bottom:1rem;margin-top:0;overflow:auto}pre code{color:inherit;font-size:inherit;word-break:normal}code{word-wrap:break-word;color:#d63384;color:var(--bs-code-color);font-size:.875em}a>code{color:inherit}kbd{background-color:#212529;background-color:var(--bs-body-color);border-radius:.25rem;color:#fff;color:var(--bs-body-bg);font-size:.875em;padding:.1875rem .375rem}kbd kbd{font-size:1em;padding:0}figure{margin:0 0 1rem}img,svg{vertical-align:middle}table{border-collapse:collapse;caption-side:bottom}caption{color:rgba(33,37,41,.75);color:var(--bs-secondary-color);padding-bottom:.5rem;padding-top:.5rem;text-align:left}th{text-align:inherit;text-align:-webkit-match-parent}tbody,td,tfoot,th,thead,tr{border:0 solid;border-color:inherit}label{display:inline-block}button{border-radius:0}button:focus:not(:focus-visible){outline:0}button,input,optgroup,select,textarea{font-family:inherit;font-size:inherit;line-height:inherit;margin:0}button,select{text-transform:none}[role=button]{cursor:pointer}select{word-wrap:normal}select:disabled{opacity:1}[list]:not([type=date]):not([type=datetime-local]):not([type=month]):not([type=week]):not([type=time])::-webkit-calendar-picker-indicator{display:none!important}[type=button],[type=reset],[type=submit],button{-webkit-appearance:button}[type=button]:not(:disabled),[type=reset]:not(:disabled),[type=submit]:not(:disabled),button:not(:disabled){cursor:pointer}::-moz-focus-inner{border-style:none;padding:0}textarea{resize:vertical}fieldset{border:0;margin:0;min-width:0;padding:0}legend{float:left;font-size:calc(1.275rem + .3vw);line-height:inherit;margin-bottom:.5rem;padding:0;width:100%}@media (min-width:1200px){legend{font-size:1.5rem}}legend+*{clear:left}::-webkit-datetime-edit-day-field,::-webkit-datetime-edit-fields-wrapper,::-webkit-datetime-edit-hour-field,::-webkit-datetime-edit-minute,::-webkit-datetime-edit-month-field,::-webkit-datetime-edit-text,::-webkit-datetime-edit-year-field{padding:0}::-webkit-inner-spin-button{height:auto}[type=search]{-webkit-appearance:textfield;outline-offset:-2px}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-color-swatch-wrapper{padding:0}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}::file-selector-button{-webkit-appearance:button;font:inherit}output{display:inline-block}iframe{border:0}summary{cursor:pointer;display:list-item}progress{vertical-align:initial}[hidden]{display:none!important}.lead{font-size:1.25rem;font-weight:300}.display-1{font-size:calc(1.625rem + 4.5vw);font-weight:300;line-height:1.2}@media (min-width:1200px){.display-1{font-size:5rem}}.display-2{font-size:calc(1.575rem + 3.9vw);font-weight:300;line-height:1.2}@media (min-width:1200px){.display-2{font-size:4.5rem}}.display-3{font-size:calc(1.525rem + 3.3vw);font-weight:300;line-height:1.2}@media (min-width:1200px){.display-3{font-size:4rem}}.display-4{font-size:calc(1.475rem + 2.7vw);font-weight:300;line-height:1.2}@media (min-width:1200px){.display-4{font-size:3.5rem}}.display-5{font-size:calc(1.425rem + 2.1vw);font-weight:300;line-height:1.2}@media (min-width:1200px){.display-5{font-size:3rem}}.display-6{font-size:calc(1.375rem + 1.5vw);font-weight:300;line-height:1.2}@media (min-width:1200px){.display-6{font-size:2.5rem}}.list-inline,.list-unstyled{list-style:none;padding-left:0}.list-inline-item{display:inline-block}.list-inline-item:not(:last-child){margin-right:.5rem}.initialism{font-size:.875em;text-transform:uppercase}.blockquote{font-size:1.25rem;margin-bottom:1rem}.blockquote>:last-child{margin-bottom:0}.blockquote-footer{color:#6c757d;font-size:.875em;margin-bottom:1rem;margin-top:-1rem}.blockquote-footer:before{content:"— "}.img-fluid,.img-thumbnail{height:auto;max-width:100%}.img-thumbnail{background-color:#fff;background-color:var(--bs-body-bg);border:1px solid #dee2e6;border:var(--bs-border-width) solid var(--bs-border-color);border-radius:.375rem;border-radius:var(--bs-border-radius);padding:.25rem}.figure{display:inline-block}.figure-img{line-height:1;margin-bottom:.5rem}.figure-caption{color:rgba(33,37,41,.75);color:var(--bs-secondary-color);font-size:.875em}.container,.container-fluid,.container-lg,.container-md,.container-sm,.container-xl,.container-xxl{--bs-gutter-x:1.5rem;--bs-gutter-y:0;margin-left:auto;margin-right:auto;padding-left:calc(var(--bs-gutter-x)*.5);padding-right:calc(var(--bs-gutter-x)*.5);width:100%}@media (min-width:576px){.container,.container-sm{max-width:540px}}@media (min-width:768px){.container,.container-md,.container-sm{max-width:720px}}@media (min-width:992px){.container,.container-lg,.container-md,.container-sm{max-width:960px}}@media (min-width:1200px){.container,.container-lg,.container-md,.container-sm,.container-xl{max-width:1140px}}@media (min-width:1400px){.container,.container-lg,.container-md,.container-sm,.container-xl,.container-xxl{max-width:1320px}}:root{--bs-breakpoint-xs:0;--bs-breakpoint-sm:576px;--bs-breakpoint-md:768px;--bs-breakpoint-lg:992px;--bs-breakpoint-xl:1200px;--bs-breakpoint-xxl:1400px}.row{--bs-gutter-x:1.5rem;--bs-gutter-y:0;display:flex;flex-wrap:wrap;margin-left:calc(var(--bs-gutter-x)*-.5);margin-right:calc(var(--bs-gutter-x)*-.5);margin-top:calc(var(--bs-gutter-y)*-1)}.row>*{flex-shrink:0;margin-top:var(--bs-gutter-y);max-width:100%;padding-left:calc(var(--bs-gutter-x)*.5);padding-right:calc(var(--bs-gutter-x)*.5);width:100%}.col{flex:1 0}.row-cols-auto>*{flex:0 0 auto;width:auto}.row-cols-1>*{flex:0 0 auto;width:100%}.row-cols-2>*{flex:0 0 auto;width:50%}.row-cols-3>*{flex:0 0 auto;width:33.33333333%}.row-cols-4>*{flex:0 0 auto;width:25%}.row-cols-5>*{flex:0 0 auto;width:20%}.row-cols-6>*{flex:0 0 auto;width:16.66666667%}.col-auto{flex:0 0 auto;width:auto}.col-1{flex:0 0 auto;width:8.33333333%}.col-2{flex:0 0 auto;width:16.66666667%}.col-3{flex:0 0 auto;width:25%}.col-4{flex:0 0 auto;width:33.33333333%}.col-5{flex:0 0 auto;width:41.66666667%}.col-6{flex:0 0 auto;width:50%}.col-7{flex:0 0 auto;width:58.33333333%}.col-8{flex:0 0 auto;width:66.66666667%}.col-9{flex:0 0 auto;width:75%}.col-10{flex:0 0 auto;width:83.33333333%}.col-11{flex:0 0 auto;width:91.66666667%}.col-12{flex:0 0 auto;width:100%}.offset-1{margin-left:8.33333333%}.offset-2{margin-left:16.66666667%}.offset-3{margin-left:25%}.offset-4{margin-left:33.33333333%}.offset-5{margin-left:41.66666667%}.offset-6{margin-left:50%}.offset-7{margin-left:58.33333333%}.offset-8{margin-left:66.66666667%}.offset-9{margin-left:75%}.offset-10{margin-left:83.33333333%}.offset-11{margin-left:91.66666667%}.g-0,.gx-0{--bs-gutter-x:0}.g-0,.gy-0{--bs-gutter-y:0}.g-1,.gx-1{--bs-gutter-x:0.25rem}.g-1,.gy-1{--bs-gutter-y:0.25rem}.g-2,.gx-2{--bs-gutter-x:0.5rem}.g-2,.gy-2{--bs-gutter-y:0.5rem}.g-3,.gx-3{--bs-gutter-x:1rem}.g-3,.gy-3{--bs-gutter-y:1rem}.g-4,.gx-4{--bs-gutter-x:1.5rem}.g-4,.gy-4{--bs-gutter-y:1.5rem}.g-5,.gx-5{--bs-gutter-x:3rem}.g-5,.gy-5{--bs-gutter-y:3rem}@media (min-width:576px){.col-sm{flex:1 0}.row-cols-sm-auto>*{flex:0 0 auto;width:auto}.row-cols-sm-1>*{flex:0 0 auto;width:100%}.row-cols-sm-2>*{flex:0 0 auto;width:50%}.row-cols-sm-3>*{flex:0 0 auto;width:33.33333333%}.row-cols-sm-4>*{flex:0 0 auto;width:25%}.row-cols-sm-5>*{flex:0 0 auto;width:20%}.row-cols-sm-6>*{flex:0 0 auto;width:16.66666667%}.col-sm-auto{flex:0 0 auto;width:auto}.col-sm-1{flex:0 0 auto;width:8.33333333%}.col-sm-2{flex:0 0 auto;width:16.66666667%}.col-sm-3{flex:0 0 auto;width:25%}.col-sm-4{flex:0 0 auto;width:33.33333333%}.col-sm-5{flex:0 0 auto;width:41.66666667%}.col-sm-6{flex:0 0 auto;width:50%}.col-sm-7{flex:0 0 auto;width:58.33333333%}.col-sm-8{flex:0 0 auto;width:66.66666667%}.col-sm-9{flex:0 0 auto;width:75%}.col-sm-10{flex:0 0 auto;width:83.33333333%}.col-sm-11{flex:0 0 auto;width:91.66666667%}.col-sm-12{flex:0 0 auto;width:100%}.offset-sm-0{margin-left:0}.offset-sm-1{margin-left:8.33333333%}.offset-sm-2{margin-left:16.66666667%}.offset-sm-3{margin-left:25%}.offset-sm-4{margin-left:33.33333333%}.offset-sm-5{margin-left:41.66666667%}.offset-sm-6{margin-left:50%}.offset-sm-7{margin-left:58.33333333%}.offset-sm-8{margin-left:66.66666667%}.offset-sm-9{margin-left:75%}.offset-sm-10{margin-left:83.33333333%}.offset-sm-11{margin-left:91.66666667%}.g-sm-0,.gx-sm-0{--bs-gutter-x:0}.g-sm-0,.gy-sm-0{--bs-gutter-y:0}.g-sm-1,.gx-sm-1{--bs-gutter-x:0.25rem}.g-sm-1,.gy-sm-1{--bs-gutter-y:0.25rem}.g-sm-2,.gx-sm-2{--bs-gutter-x:0.5rem}.g-sm-2,.gy-sm-2{--bs-gutter-y:0.5rem}.g-sm-3,.gx-sm-3{--bs-gutter-x:1rem}.g-sm-3,.gy-sm-3{--bs-gutter-y:1rem}.g-sm-4,.gx-sm-4{--bs-gutter-x:1.5rem}.g-sm-4,.gy-sm-4{--bs-gutter-y:1.5rem}.g-sm-5,.gx-sm-5{--bs-gutter-x:3rem}.g-sm-5,.gy-sm-5{--bs-gutter-y:3rem}}@media (min-width:768px){.col-md{flex:1 0}.row-cols-md-auto>*{flex:0 0 auto;width:auto}.row-cols-md-1>*{flex:0 0 auto;width:100%}.row-cols-md-2>*{flex:0 0 auto;width:50%}.row-cols-md-3>*{flex:0 0 auto;width:33.33333333%}.row-cols-md-4>*{flex:0 0 auto;width:25%}.row-cols-md-5>*{flex:0 0 auto;width:20%}.row-cols-md-6>*{flex:0 0 auto;width:16.66666667%}.col-md-auto{flex:0 0 auto;width:auto}.col-md-1{flex:0 0 auto;width:8.33333333%}.col-md-2{flex:0 0 auto;width:16.66666667%}.col-md-3{flex:0 0 auto;width:25%}.col-md-4{flex:0 0 auto;width:33.33333333%}.col-md-5{flex:0 0 auto;width:41.66666667%}.col-md-6{flex:0 0 auto;width:50%}.col-md-7{flex:0 0 auto;width:58.33333333%}.col-md-8{flex:0 0 auto;width:66.66666667%}.col-md-9{flex:0 0 auto;width:75%}.col-md-10{flex:0 0 auto;width:83.33333333%}.col-md-11{flex:0 0 auto;width:91.66666667%}.col-md-12{flex:0 0 auto;width:100%}.offset-md-0{margin-left:0}.offset-md-1{margin-left:8.33333333%}.offset-md-2{margin-left:16.66666667%}.offset-md-3{margin-left:25%}.offset-md-4{margin-left:33.33333333%}.offset-md-5{margin-left:41.66666667%}.offset-md-6{margin-left:50%}.offset-md-7{margin-left:58.33333333%}.offset-md-8{margin-left:66.66666667%}.offset-md-9{margin-left:75%}.offset-md-10{margin-left:83.33333333%}.offset-md-11{margin-left:91.66666667%}.g-md-0,.gx-md-0{--bs-gutter-x:0}.g-md-0,.gy-md-0{--bs-gutter-y:0}.g-md-1,.gx-md-1{--bs-gutter-x:0.25rem}.g-md-1,.gy-md-1{--bs-gutter-y:0.25rem}.g-md-2,.gx-md-2{--bs-gutter-x:0.5rem}.g-md-2,.gy-md-2{--bs-gutter-y:0.5rem}.g-md-3,.gx-md-3{--bs-gutter-x:1rem}.g-md-3,.gy-md-3{--bs-gutter-y:1rem}.g-md-4,.gx-md-4{--bs-gutter-x:1.5rem}.g-md-4,.gy-md-4{--bs-gutter-y:1.5rem}.g-md-5,.gx-md-5{--bs-gutter-x:3rem}.g-md-5,.gy-md-5{--bs-gutter-y:3rem}}@media (min-width:992px){.col-lg{flex:1 0}.row-cols-lg-auto>*{flex:0 0 auto;width:auto}.row-cols-lg-1>*{flex:0 0 auto;width:100%}.row-cols-lg-2>*{flex:0 0 auto;width:50%}.row-cols-lg-3>*{flex:0 0 auto;width:33.33333333%}.row-cols-lg-4>*{flex:0 0 auto;width:25%}.row-cols-lg-5>*{flex:0 0 auto;width:20%}.row-cols-lg-6>*{flex:0 0 auto;width:16.66666667%}.col-lg-auto{flex:0 0 auto;width:auto}.col-lg-1{flex:0 0 auto;width:8.33333333%}.col-lg-2{flex:0 0 auto;width:16.66666667%}.col-lg-3{flex:0 0 auto;width:25%}.col-lg-4{flex:0 0 auto;width:33.33333333%}.col-lg-5{flex:0 0 auto;width:41.66666667%}.col-lg-6{flex:0 0 auto;width:50%}.col-lg-7{flex:0 0 auto;width:58.33333333%}.col-lg-8{flex:0 0 auto;width:66.66666667%}.col-lg-9{flex:0 0 auto;width:75%}.col-lg-10{flex:0 0 auto;width:83.33333333%}.col-lg-11{flex:0 0 auto;width:91.66666667%}.col-lg-12{flex:0 0 auto;width:100%}.offset-lg-0{margin-left:0}.offset-lg-1{margin-left:8.33333333%}.offset-lg-2{margin-left:16.66666667%}.offset-lg-3{margin-left:25%}.offset-lg-4{margin-left:33.33333333%}.offset-lg-5{margin-left:41.66666667%}.offset-lg-6{margin-left:50%}.offset-lg-7{margin-left:58.33333333%}.offset-lg-8{margin-left:66.66666667%}.offset-lg-9{margin-left:75%}.offset-lg-10{margin-left:83.33333333%}.offset-lg-11{margin-left:91.66666667%}.g-lg-0,.gx-lg-0{--bs-gutter-x:0}.g-lg-0,.gy-lg-0{--bs-gutter-y:0}.g-lg-1,.gx-lg-1{--bs-gutter-x:0.25rem}.g-lg-1,.gy-lg-1{--bs-gutter-y:0.25rem}.g-lg-2,.gx-lg-2{--bs-gutter-x:0.5rem}.g-lg-2,.gy-lg-2{--bs-gutter-y:0.5rem}.g-lg-3,.gx-lg-3{--bs-gutter-x:1rem}.g-lg-3,.gy-lg-3{--bs-gutter-y:1rem}.g-lg-4,.gx-lg-4{--bs-gutter-x:1.5rem}.g-lg-4,.gy-lg-4{--bs-gutter-y:1.5rem}.g-lg-5,.gx-lg-5{--bs-gutter-x:3rem}.g-lg-5,.gy-lg-5{--bs-gutter-y:3rem}}@media (min-width:1200px){.col-xl{flex:1 0}.row-cols-xl-auto>*{flex:0 0 auto;width:auto}.row-cols-xl-1>*{flex:0 0 auto;width:100%}.row-cols-xl-2>*{flex:0 0 auto;width:50%}.row-cols-xl-3>*{flex:0 0 auto;width:33.33333333%}.row-cols-xl-4>*{flex:0 0 auto;width:25%}.row-cols-xl-5>*{flex:0 0 auto;width:20%}.row-cols-xl-6>*{flex:0 0 auto;width:16.66666667%}.col-xl-auto{flex:0 0 auto;width:auto}.col-xl-1{flex:0 0 auto;width:8.33333333%}.col-xl-2{flex:0 0 auto;width:16.66666667%}.col-xl-3{flex:0 0 auto;width:25%}.col-xl-4{flex:0 0 auto;width:33.33333333%}.col-xl-5{flex:0 0 auto;width:41.66666667%}.col-xl-6{flex:0 0 auto;width:50%}.col-xl-7{flex:0 0 auto;width:58.33333333%}.col-xl-8{flex:0 0 auto;width:66.66666667%}.col-xl-9{flex:0 0 auto;width:75%}.col-xl-10{flex:0 0 auto;width:83.33333333%}.col-xl-11{flex:0 0 auto;width:91.66666667%}.col-xl-12{flex:0 0 auto;width:100%}.offset-xl-0{margin-left:0}.offset-xl-1{margin-left:8.33333333%}.offset-xl-2{margin-left:16.66666667%}.offset-xl-3{margin-left:25%}.offset-xl-4{margin-left:33.33333333%}.offset-xl-5{margin-left:41.66666667%}.offset-xl-6{margin-left:50%}.offset-xl-7{margin-left:58.33333333%}.offset-xl-8{margin-left:66.66666667%}.offset-xl-9{margin-left:75%}.offset-xl-10{margin-left:83.33333333%}.offset-xl-11{margin-left:91.66666667%}.g-xl-0,.gx-xl-0{--bs-gutter-x:0}.g-xl-0,.gy-xl-0{--bs-gutter-y:0}.g-xl-1,.gx-xl-1{--bs-gutter-x:0.25rem}.g-xl-1,.gy-xl-1{--bs-gutter-y:0.25rem}.g-xl-2,.gx-xl-2{--bs-gutter-x:0.5rem}.g-xl-2,.gy-xl-2{--bs-gutter-y:0.5rem}.g-xl-3,.gx-xl-3{--bs-gutter-x:1rem}.g-xl-3,.gy-xl-3{--bs-gutter-y:1rem}.g-xl-4,.gx-xl-4{--bs-gutter-x:1.5rem}.g-xl-4,.gy-xl-4{--bs-gutter-y:1.5rem}.g-xl-5,.gx-xl-5{--bs-gutter-x:3rem}.g-xl-5,.gy-xl-5{--bs-gutter-y:3rem}}@media (min-width:1400px){.col-xxl{flex:1 0}.row-cols-xxl-auto>*{flex:0 0 auto;width:auto}.row-cols-xxl-1>*{flex:0 0 auto;width:100%}.row-cols-xxl-2>*{flex:0 0 auto;width:50%}.row-cols-xxl-3>*{flex:0 0 auto;width:33.33333333%}.row-cols-xxl-4>*{flex:0 0 auto;width:25%}.row-cols-xxl-5>*{flex:0 0 auto;width:20%}.row-cols-xxl-6>*{flex:0 0 auto;width:16.66666667%}.col-xxl-auto{flex:0 0 auto;width:auto}.col-xxl-1{flex:0 0 auto;width:8.33333333%}.col-xxl-2{flex:0 0 auto;width:16.66666667%}.col-xxl-3{flex:0 0 auto;width:25%}.col-xxl-4{flex:0 0 auto;width:33.33333333%}.col-xxl-5{flex:0 0 auto;width:41.66666667%}.col-xxl-6{flex:0 0 auto;width:50%}.col-xxl-7{flex:0 0 auto;width:58.33333333%}.col-xxl-8{flex:0 0 auto;width:66.66666667%}.col-xxl-9{flex:0 0 auto;width:75%}.col-xxl-10{flex:0 0 auto;width:83.33333333%}.col-xxl-11{flex:0 0 auto;width:91.66666667%}.col-xxl-12{flex:0 0 auto;width:100%}.offset-xxl-0{margin-left:0}.offset-xxl-1{margin-left:8.33333333%}.offset-xxl-2{margin-left:16.66666667%}.offset-xxl-3{margin-left:25%}.offset-xxl-4{margin-left:33.33333333%}.offset-xxl-5{margin-left:41.66666667%}.offset-xxl-6{margin-left:50%}.offset-xxl-7{margin-left:58.33333333%}.offset-xxl-8{margin-left:66.66666667%}.offset-xxl-9{margin-left:75%}.offset-xxl-10{margin-left:83.33333333%}.offset-xxl-11{margin-left:91.66666667%}.g-xxl-0,.gx-xxl-0{--bs-gutter-x:0}.g-xxl-0,.gy-xxl-0{--bs-gutter-y:0}.g-xxl-1,.gx-xxl-1{--bs-gutter-x:0.25rem}.g-xxl-1,.gy-xxl-1{--bs-gutter-y:0.25rem}.g-xxl-2,.gx-xxl-2{--bs-gutter-x:0.5rem}.g-xxl-2,.gy-xxl-2{--bs-gutter-y:0.5rem}.g-xxl-3,.gx-xxl-3{--bs-gutter-x:1rem}.g-xxl-3,.gy-xxl-3{--bs-gutter-y:1rem}.g-xxl-4,.gx-xxl-4{--bs-gutter-x:1.5rem}.g-xxl-4,.gy-xxl-4{--bs-gutter-y:1.5rem}.g-xxl-5,.gx-xxl-5{--bs-gutter-x:3rem}.g-xxl-5,.gy-xxl-5{--bs-gutter-y:3rem}}.table{--bs-table-color-type:initial;--bs-table-bg-type:initial;--bs-table-color-state:initial;--bs-table-bg-state:initial;--bs-table-color:var(--bs-emphasis-color);--bs-table-bg:var(--bs-body-bg);--bs-table-border-color:var(--bs-border-color);--bs-table-accent-bg:transparent;--bs-table-striped-color:var(--bs-emphasis-color);--bs-table-striped-bg:rgba(var(--bs-emphasis-color-rgb),0.05);--bs-table-active-color:var(--bs-emphasis-color);--bs-table-active-bg:rgba(var(--bs-emphasis-color-rgb),0.1);--bs-table-hover-color:var(--bs-emphasis-color);--bs-table-hover-bg:rgba(var(--bs-emphasis-color-rgb),0.075);border-color:var(--bs-table-border-color);margin-bottom:1rem;vertical-align:top;width:100%}.table>:not(caption)>*>*{background-color:var(--bs-table-bg);border-bottom-width:1px;border-bottom-width:var(--bs-border-width);box-shadow:inset 0 0 0 9999px var(--bs-table-accent-bg);box-shadow:inset 0 0 0 9999px var(--bs-table-bg-state,var(--bs-table-bg-type,var(--bs-table-accent-bg)));color:var(--bs-table-color);color:var(--bs-table-color-state,var(--bs-table-color-type,var(--bs-table-color)));padding:.5rem}.table>tbody{vertical-align:inherit}.table>thead{vertical-align:bottom}.table-group-divider{border-top:2px solid;border-top:calc(var(--bs-border-width)*2) solid}.caption-top{caption-side:top}.table-sm>:not(caption)>*>*{padding:.25rem}.table-bordered>:not(caption)>*{border-width:1px 0;border-width:var(--bs-border-width) 0}.table-bordered>:not(caption)>*>*{border-width:0 1px;border-width:0 var(--bs-border-width)}.table-borderless>:not(caption)>*>*{border-bottom-width:0}.table-borderless>:not(:first-child){border-top-width:0}.table-striped-columns>:not(caption)>tr>:nth-child(2n),.table-striped>tbody>tr:nth-of-type(odd)>*{--bs-table-color-type:var(--bs-table-striped-color);--bs-table-bg-type:var(--bs-table-striped-bg)}.table-active{--bs-table-color-state:var(--bs-table-active-color);--bs-table-bg-state:var(--bs-table-active-bg)}.table-hover>tbody>tr:hover>*{--bs-table-color-state:var(--bs-table-hover-color);--bs-table-bg-state:var(--bs-table-hover-bg)}.table-primary{--bs-table-color:#000;--bs-table-bg:#cfe2ff;--bs-table-border-color:#a6b5cc;--bs-table-striped-bg:#c5d7f2;--bs-table-striped-color:#000;--bs-table-active-bg:#bacbe6;--bs-table-active-color:#000;--bs-table-hover-bg:#bfd1ec;--bs-table-hover-color:#000}.table-primary,.table-secondary{border-color:var(--bs-table-border-color);color:var(--bs-table-color)}.table-secondary{--bs-table-color:#000;--bs-table-bg:#e2e3e5;--bs-table-border-color:#b5b6b7;--bs-table-striped-bg:#d7d8da;--bs-table-striped-color:#000;--bs-table-active-bg:#cbccce;--bs-table-active-color:#000;--bs-table-hover-bg:#d1d2d4;--bs-table-hover-color:#000}.table-success{--bs-table-color:#000;--bs-table-bg:#d1e7dd;--bs-table-border-color:#a7b9b1;--bs-table-striped-bg:#c7dbd2;--bs-table-striped-color:#000;--bs-table-active-bg:#bcd0c7;--bs-table-active-color:#000;--bs-table-hover-bg:#c1d6cc;--bs-table-hover-color:#000}.table-info,.table-success{border-color:var(--bs-table-border-color);color:var(--bs-table-color)}.table-info{--bs-table-color:#000;--bs-table-bg:#cff4fc;--bs-table-border-color:#a6c3ca;--bs-table-striped-bg:#c5e8ef;--bs-table-striped-color:#000;--bs-table-active-bg:#badce3;--bs-table-active-color:#000;--bs-table-hover-bg:#bfe2e9;--bs-table-hover-color:#000}.table-warning{--bs-table-color:#000;--bs-table-bg:#fff3cd;--bs-table-border-color:#ccc2a4;--bs-table-striped-bg:#f2e7c3;--bs-table-striped-color:#000;--bs-table-active-bg:#e6dbb9;--bs-table-active-color:#000;--bs-table-hover-bg:#ece1be;--bs-table-hover-color:#000}.table-danger,.table-warning{border-color:var(--bs-table-border-color);color:var(--bs-table-color)}.table-danger{--bs-table-color:#000;--bs-table-bg:#f8d7da;--bs-table-border-color:#c6acae;--bs-table-striped-bg:#eccccf;--bs-table-striped-color:#000;--bs-table-active-bg:#dfc2c4;--bs-table-active-color:#000;--bs-table-hover-bg:#e5c7ca;--bs-table-hover-color:#000}.table-light{--bs-table-color:#000;--bs-table-bg:#f8f9fa;--bs-table-border-color:#c6c7c8;--bs-table-striped-bg:#ecedee;--bs-table-striped-color:#000;--bs-table-active-bg:#dfe0e1;--bs-table-active-color:#000;--bs-table-hover-bg:#e5e6e7;--bs-table-hover-color:#000}.table-dark,.table-light{border-color:var(--bs-table-border-color);color:var(--bs-table-color)}.table-dark{--bs-table-color:#fff;--bs-table-bg:#212529;--bs-table-border-color:#4d5154;--bs-table-striped-bg:#2c3034;--bs-table-striped-color:#fff;--bs-table-active-bg:#373b3e;--bs-table-active-color:#fff;--bs-table-hover-bg:#323539;--bs-table-hover-color:#fff}.table-responsive{-webkit-overflow-scrolling:touch;overflow-x:auto}@media (max-width:575.98px){.table-responsive-sm{-webkit-overflow-scrolling:touch;overflow-x:auto}}@media (max-width:767.98px){.table-responsive-md{-webkit-overflow-scrolling:touch;overflow-x:auto}}@media (max-width:991.98px){.table-responsive-lg{-webkit-overflow-scrolling:touch;overflow-x:auto}}@media (max-width:1199.98px){.table-responsive-xl{-webkit-overflow-scrolling:touch;overflow-x:auto}}@media (max-width:1399.98px){.table-responsive-xxl{-webkit-overflow-scrolling:touch;overflow-x:auto}}.form-label{margin-bottom:.5rem}.col-form-label{font-size:inherit;line-height:1.5;margin-bottom:0;padding-bottom:calc(.375rem + 1px);padding-bottom:calc(.375rem + var(--bs-border-width));padding-top:calc(.375rem + 1px);padding-top:calc(.375rem + var(--bs-border-width))}.col-form-label-lg{font-size:1.25rem;padding-bottom:calc(.5rem + 1px);padding-bottom:calc(.5rem + var(--bs-border-width));padding-top:calc(.5rem + 1px);padding-top:calc(.5rem + var(--bs-border-width))}.col-form-label-sm{font-size:.875rem;padding-bottom:calc(.25rem + 1px);padding-bottom:calc(.25rem + var(--bs-border-width));padding-top:calc(.25rem + 1px);padding-top:calc(.25rem + var(--bs-border-width))}.form-text{color:rgba(33,37,41,.75);color:var(--bs-secondary-color);font-size:.875em;margin-top:.25rem}.form-control{-webkit-appearance:none;appearance:none;background-clip:padding-box;background-color:#fff;background-color:var(--bs-body-bg);border:1px solid #dee2e6;border:var(--bs-border-width) solid var(--bs-border-color);border-radius:.375rem;border-radius:var(--bs-border-radius);color:#212529;color:var(--bs-body-color);display:block;font-size:1rem;font-weight:400;line-height:1.5;padding:.375rem .75rem;transition:border-color .15s ease-in-out,box-shadow .15s ease-in-out;width:100%}@media (prefers-reduced-motion:reduce){.form-control{transition:none}}.form-control[type=file]{overflow:hidden}.form-control[type=file]:not(:disabled):not([readonly]){cursor:pointer}.form-control:focus{background-color:#fff;background-color:var(--bs-body-bg);border-color:#86b7fe;box-shadow:0 0 0 .25rem rgba(13,110,253,.25);color:#212529;color:var(--bs-body-color);outline:0}.form-control::-webkit-date-and-time-value{height:1.5em;margin:0;min-width:85px}.form-control::-webkit-datetime-edit{display:block;padding:0}.form-control::-webkit-input-placeholder{color:rgba(33,37,41,.75);color:var(--bs-secondary-color);opacity:1}.form-control::placeholder{color:rgba(33,37,41,.75);color:var(--bs-secondary-color);opacity:1}.form-control:disabled{background-color:#e9ecef;background-color:var(--bs-secondary-bg);opacity:1}.form-control::-webkit-file-upload-button{-webkit-margin-end:.75rem;background-color:#f8f9fa;background-color:var(--bs-tertiary-bg);border:0 solid;border-color:inherit;border-inline-end-width:1px;border-inline-end-width:var(--bs-border-width);border-radius:0;color:#212529;color:var(--bs-body-color);margin:-.375rem -.75rem;margin-inline-end:.75rem;padding:.375rem .75rem;pointer-events:none;-webkit-transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out}.form-control::file-selector-button{-webkit-margin-end:.75rem;background-color:#f8f9fa;background-color:var(--bs-tertiary-bg);border:0 solid;border-color:inherit;border-inline-end-width:1px;border-inline-end-width:var(--bs-border-width);border-radius:0;color:#212529;color:var(--bs-body-color);margin:-.375rem -.75rem;margin-inline-end:.75rem;padding:.375rem .75rem;pointer-events:none;transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out}@media (prefers-reduced-motion:reduce){.form-control::-webkit-file-upload-button{-webkit-transition:none;transition:none}.form-control::file-selector-button{transition:none}}.form-control:hover:not(:disabled):not([readonly])::-webkit-file-upload-button{background-color:#e9ecef;background-color:var(--bs-secondary-bg)}.form-control:hover:not(:disabled):not([readonly])::file-selector-button{background-color:#e9ecef;background-color:var(--bs-secondary-bg)}.form-control-plaintext{background-color:initial;border:solid transparent;border-width:1px 0;border-width:var(--bs-border-width) 0;color:#212529;color:var(--bs-body-color);display:block;line-height:1.5;margin-bottom:0;padding:.375rem 0;width:100%}.form-control-plaintext:focus{outline:0}.form-control-plaintext.form-control-lg,.form-control-plaintext.form-control-sm{padding-left:0;padding-right:0}.form-control-sm{border-radius:.25rem;border-radius:var(--bs-border-radius-sm);font-size:.875rem;min-height:calc(1.5em + .5rem + 2px);min-height:calc(1.5em + .5rem + var(--bs-border-width)*2);padding:.25rem .5rem}.form-control-sm::-webkit-file-upload-button{-webkit-margin-end:.5rem;margin:-.25rem -.5rem;margin-inline-end:.5rem;padding:.25rem .5rem}.form-control-sm::file-selector-button{-webkit-margin-end:.5rem;margin:-.25rem -.5rem;margin-inline-end:.5rem;padding:.25rem .5rem}.form-control-lg{border-radius:.5rem;border-radius:var(--bs-border-radius-lg);font-size:1.25rem;min-height:calc(1.5em + 1rem + 2px);min-height:calc(1.5em + 1rem + var(--bs-border-width)*2);padding:.5rem 1rem}.form-control-lg::-webkit-file-upload-button{-webkit-margin-end:1rem;margin:-.5rem -1rem;margin-inline-end:1rem;padding:.5rem 1rem}.form-control-lg::file-selector-button{-webkit-margin-end:1rem;margin:-.5rem -1rem;margin-inline-end:1rem;padding:.5rem 1rem}textarea.form-control{min-height:calc(1.5em + .75rem + 2px);min-height:calc(1.5em + .75rem + var(--bs-border-width)*2)}textarea.form-control-sm{min-height:calc(1.5em + .5rem + 2px);min-height:calc(1.5em + .5rem + var(--bs-border-width)*2)}textarea.form-control-lg{min-height:calc(1.5em + 1rem + 2px);min-height:calc(1.5em + 1rem + var(--bs-border-width)*2)}.form-control-color{height:calc(1.5em + .75rem + 2px);height:calc(1.5em + .75rem + var(--bs-border-width)*2);padding:.375rem;width:3rem}.form-control-color:not(:disabled):not([readonly]){cursor:pointer}.form-control-color::-moz-color-swatch{border:0!important;border-radius:.375rem;border-radius:var(--bs-border-radius)}.form-control-color::-webkit-color-swatch{border:0!important;border-radius:.375rem;border-radius:var(--bs-border-radius)}.form-control-color.form-control-sm{height:calc(1.5em + .5rem + 2px);height:calc(1.5em + .5rem + var(--bs-border-width)*2)}.form-control-color.form-control-lg{height:calc(1.5em + 1rem + 2px);height:calc(1.5em + 1rem + var(--bs-border-width)*2)}.form-select{--bs-form-select-bg-img:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3E%3Cpath fill='none' stroke='%23343a40' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' d='m2 5 6 6 6-6'/%3E%3C/svg%3E");-webkit-appearance:none;appearance:none;background-color:#fff;background-color:var(--bs-body-bg);background-image:var(--bs-form-select-bg-img),none;background-image:var(--bs-form-select-bg-img),var(--bs-form-select-bg-icon,none);background-position:right .75rem center;background-repeat:no-repeat;background-size:16px 12px;border:1px solid #dee2e6;border:var(--bs-border-width) solid var(--bs-border-color);border-radius:.375rem;border-radius:var(--bs-border-radius);color:#212529;color:var(--bs-body-color);display:block;font-size:1rem;font-weight:400;line-height:1.5;padding:.375rem 2.25rem .375rem .75rem;transition:border-color .15s ease-in-out,box-shadow .15s ease-in-out;width:100%}@media (prefers-reduced-motion:reduce){.form-select{transition:none}}.form-select:focus{border-color:#86b7fe;box-shadow:0 0 0 .25rem rgba(13,110,253,.25);outline:0}.form-select[multiple],.form-select[size]:not([size="1"]){background-image:none;padding-right:.75rem}.form-select:disabled{background-color:#e9ecef;background-color:var(--bs-secondary-bg)}.form-select:-moz-focusring{color:transparent;text-shadow:0 0 0 #212529;text-shadow:0 0 0 var(--bs-body-color)}.form-select-sm{border-radius:.25rem;border-radius:var(--bs-border-radius-sm);font-size:.875rem;padding-bottom:.25rem;padding-left:.5rem;padding-top:.25rem}.form-select-lg{border-radius:.5rem;border-radius:var(--bs-border-radius-lg);font-size:1.25rem;padding-bottom:.5rem;padding-left:1rem;padding-top:.5rem}[data-bs-theme=dark] .form-select{--bs-form-select-bg-img:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3E%3Cpath fill='none' stroke='%23dee2e6' stroke-linecap='round' stroke-linejoin='round' stroke-width='2' d='m2 5 6 6 6-6'/%3E%3C/svg%3E")}.form-check{display:block;margin-bottom:.125rem;min-height:1.5rem;padding-left:1.5em}.form-check .form-check-input{float:left;margin-left:-1.5em}.form-check-reverse{padding-left:0;padding-right:1.5em;text-align:right}.form-check-reverse .form-check-input{float:right;margin-left:0;margin-right:-1.5em}.form-check-input{--bs-form-check-bg:var(--bs-body-bg);-webkit-appearance:none;appearance:none;background-color:var(--bs-form-check-bg);background-image:var(--bs-form-check-bg-image);background-position:50%;background-repeat:no-repeat;background-size:contain;border:1px solid #dee2e6;border:var(--bs-border-width) solid var(--bs-border-color);flex-shrink:0;height:1em;margin-top:.25em;-webkit-print-color-adjust:exact;print-color-adjust:exact;vertical-align:top;width:1em}.form-check-input[type=checkbox]{border-radius:.25em}.form-check-input[type=radio]{border-radius:50%}.form-check-input:active{-webkit-filter:brightness(90%);filter:brightness(90%)}.form-check-input:focus{border-color:#86b7fe;box-shadow:0 0 0 .25rem rgba(13,110,253,.25);outline:0}.form-check-input:checked{background-color:#0d6efd;border-color:#0d6efd}.form-check-input:checked[type=checkbox]{--bs-form-check-bg-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 20 20'%3E%3Cpath fill='none' stroke='%23fff' stroke-linecap='round' stroke-linejoin='round' stroke-width='3' d='m6 10 3 3 6-6'/%3E%3C/svg%3E")}.form-check-input:checked[type=radio]{--bs-form-check-bg-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='-4 -4 8 8'%3E%3Ccircle r='2' fill='%23fff'/%3E%3C/svg%3E")}.form-check-input[type=checkbox]:indeterminate{--bs-form-check-bg-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 20 20'%3E%3Cpath fill='none' stroke='%23fff' stroke-linecap='round' stroke-linejoin='round' stroke-width='3' d='M6 10h8'/%3E%3C/svg%3E");background-color:#0d6efd;border-color:#0d6efd}.form-check-input:disabled{-webkit-filter:none;filter:none;opacity:.5;pointer-events:none}.form-check-input:disabled~.form-check-label,.form-check-input[disabled]~.form-check-label{cursor:default;opacity:.5}.form-switch{padding-left:2.5em}.form-switch .form-check-input{--bs-form-switch-bg:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='-4 -4 8 8'%3E%3Ccircle r='3' fill='rgba(0, 0, 0, 0.25)'/%3E%3C/svg%3E");background-image:var(--bs-form-switch-bg);background-position:0;border-radius:2em;margin-left:-2.5em;transition:background-position .15s ease-in-out;width:2em}@media (prefers-reduced-motion:reduce){.form-switch .form-check-input{transition:none}}.form-switch .form-check-input:focus{--bs-form-switch-bg:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='-4 -4 8 8'%3E%3Ccircle r='3' fill='%2386b7fe'/%3E%3C/svg%3E")}.form-switch .form-check-input:checked{--bs-form-switch-bg:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='-4 -4 8 8'%3E%3Ccircle r='3' fill='%23fff'/%3E%3C/svg%3E");background-position:100%}.form-switch.form-check-reverse{padding-left:0;padding-right:2.5em}.form-switch.form-check-reverse .form-check-input{margin-left:0;margin-right:-2.5em}.form-check-inline{display:inline-block;margin-right:1rem}.btn-check{clip:rect(0,0,0,0);pointer-events:none;position:absolute}.btn-check:disabled+.btn,.btn-check[disabled]+.btn{-webkit-filter:none;filter:none;opacity:.65;pointer-events:none}[data-bs-theme=dark] .form-switch .form-check-input:not(:checked):not(:focus){--bs-form-switch-bg:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='-4 -4 8 8'%3E%3Ccircle r='3' fill='rgba(255, 255, 255, 0.25)'/%3E%3C/svg%3E")}.form-range{-webkit-appearance:none;appearance:none;background-color:initial;height:1.5rem;padding:0;width:100%}.form-range:focus{outline:0}.form-range:focus::-webkit-slider-thumb{box-shadow:0 0 0 1px #fff,0 0 0 .25rem rgba(13,110,253,.25)}.form-range:focus::-moz-range-thumb{box-shadow:0 0 0 1px #fff,0 0 0 .25rem rgba(13,110,253,.25)}.form-range::-moz-focus-outer{border:0}.form-range::-webkit-slider-thumb{-webkit-appearance:none;appearance:none;background-color:#0d6efd;border:0;border-radius:1rem;height:1rem;margin-top:-.25rem;-webkit-transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;width:1rem}@media (prefers-reduced-motion:reduce){.form-range::-webkit-slider-thumb{-webkit-transition:none;transition:none}}.form-range::-webkit-slider-thumb:active{background-color:#b6d4fe}.form-range::-webkit-slider-runnable-track{background-color:#e9ecef;background-color:var(--bs-secondary-bg);border-color:transparent;border-radius:1rem;color:transparent;cursor:pointer;height:.5rem;width:100%}.form-range::-moz-range-thumb{appearance:none;background-color:#0d6efd;border:0;border-radius:1rem;height:1rem;-moz-transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;width:1rem}@media (prefers-reduced-motion:reduce){.form-range::-moz-range-thumb{-moz-transition:none;transition:none}}.form-range::-moz-range-thumb:active{background-color:#b6d4fe}.form-range::-moz-range-track{background-color:#e9ecef;background-color:var(--bs-secondary-bg);border-color:transparent;border-radius:1rem;color:transparent;cursor:pointer;height:.5rem;width:100%}.form-range:disabled{pointer-events:none}.form-range:disabled::-webkit-slider-thumb{background-color:rgba(33,37,41,.75);background-color:var(--bs-secondary-color)}.form-range:disabled::-moz-range-thumb{background-color:rgba(33,37,41,.75);background-color:var(--bs-secondary-color)}.form-floating{position:relative}.form-floating>.form-control,.form-floating>.form-control-plaintext,.form-floating>.form-select{height:calc(3.5rem + 2px);height:calc(3.5rem + var(--bs-border-width)*2);line-height:1.25;min-height:calc(3.5rem + 2px);min-height:calc(3.5rem + var(--bs-border-width)*2)}.form-floating>label{border:1px solid transparent;border:var(--bs-border-width) solid transparent;height:100%;left:0;overflow:hidden;padding:1rem .75rem;pointer-events:none;position:absolute;text-align:start;text-overflow:ellipsis;top:0;-webkit-transform-origin:0 0;transform-origin:0 0;transition:opacity .1s ease-in-out,-webkit-transform .1s ease-in-out;transition:opacity .1s ease-in-out,transform .1s ease-in-out;transition:opacity .1s ease-in-out,transform .1s ease-in-out,-webkit-transform .1s ease-in-out;white-space:nowrap;z-index:2}@media (prefers-reduced-motion:reduce){.form-floating>label{transition:none}}.form-floating>.form-control,.form-floating>.form-control-plaintext{padding:1rem .75rem}.form-floating>.form-control-plaintext::-webkit-input-placeholder,.form-floating>.form-control::-webkit-input-placeholder{color:transparent}.form-floating>.form-control-plaintext::placeholder,.form-floating>.form-control::placeholder{color:transparent}.form-floating>.form-control-plaintext:focus,.form-floating>.form-control-plaintext:not(:placeholder-shown),.form-floating>.form-control:focus,.form-floating>.form-control:not(:placeholder-shown){padding-bottom:.625rem;padding-top:1.625rem}.form-floating>.form-control-plaintext:-webkit-autofill,.form-floating>.form-control:-webkit-autofill{padding-bottom:.625rem;padding-top:1.625rem}.form-floating>.form-select{padding-bottom:.625rem;padding-top:1.625rem}.form-floating>.form-control-plaintext~label,.form-floating>.form-control:focus~label,.form-floating>.form-control:not(:placeholder-shown)~label,.form-floating>.form-select~label{color:rgba(33,37,41,.65);color:rgba(var(--bs-body-color-rgb),.65);-webkit-transform:scale(.85) translateY(-.5rem) translateX(.15rem);transform:scale(.85) translateY(-.5rem) translateX(.15rem)}.form-floating>.form-control-plaintext~label:after,.form-floating>.form-control:focus~label:after,.form-floating>.form-control:not(:placeholder-shown)~label:after,.form-floating>.form-select~label:after{background-color:#fff;background-color:var(--bs-body-bg);border-radius:.375rem;border-radius:var(--bs-border-radius);content:"";height:1.5em;inset:1rem .375rem;position:absolute;z-index:-1}.form-floating>.form-control:-webkit-autofill~label{color:rgba(33,37,41,.65);color:rgba(var(--bs-body-color-rgb),.65);-webkit-transform:scale(.85) translateY(-.5rem) translateX(.15rem);transform:scale(.85) translateY(-.5rem) translateX(.15rem)}.form-floating>.form-control-plaintext~label{border-width:1px 0;border-width:var(--bs-border-width) 0}.form-floating>.form-control:disabled~label,.form-floating>:disabled~label{color:#6c757d}.form-floating>.form-control:disabled~label:after,.form-floating>:disabled~label:after{background-color:#e9ecef;background-color:var(--bs-secondary-bg)}.input-group{align-items:stretch;display:flex;flex-wrap:wrap;position:relative;width:100%}.input-group>.form-control,.input-group>.form-floating,.input-group>.form-select{flex:1 1 auto;min-width:0;position:relative;width:1%}.input-group>.form-control:focus,.input-group>.form-floating:focus-within,.input-group>.form-select:focus{z-index:5}.input-group .btn{position:relative;z-index:2}.input-group .btn:focus{z-index:5}.input-group-text{align-items:center;background-color:#f8f9fa;background-color:var(--bs-tertiary-bg);border:1px solid #dee2e6;border:var(--bs-border-width) solid var(--bs-border-color);border-radius:.375rem;border-radius:var(--bs-border-radius);color:#212529;color:var(--bs-body-color);display:flex;font-size:1rem;font-weight:400;line-height:1.5;padding:.375rem .75rem;text-align:center;white-space:nowrap}.input-group-lg>.btn,.input-group-lg>.form-control,.input-group-lg>.form-select,.input-group-lg>.input-group-text{border-radius:.5rem;border-radius:var(--bs-border-radius-lg);font-size:1.25rem;padding:.5rem 1rem}.input-group-sm>.btn,.input-group-sm>.form-control,.input-group-sm>.form-select,.input-group-sm>.input-group-text{border-radius:.25rem;border-radius:var(--bs-border-radius-sm);font-size:.875rem;padding:.25rem .5rem}.input-group-lg>.form-select,.input-group-sm>.form-select{padding-right:3rem}.input-group.has-validation>.dropdown-toggle:nth-last-child(n+4),.input-group.has-validation>.form-floating:nth-last-child(n+3)>.form-control,.input-group.has-validation>.form-floating:nth-last-child(n+3)>.form-select,.input-group.has-validation>:nth-last-child(n+3):not(.dropdown-toggle):not(.dropdown-menu):not(.form-floating),.input-group:not(.has-validation)>.dropdown-toggle:nth-last-child(n+3),.input-group:not(.has-validation)>.form-floating:not(:last-child)>.form-control,.input-group:not(.has-validation)>.form-floating:not(:last-child)>.form-select,.input-group:not(.has-validation)>:not(:last-child):not(.dropdown-toggle):not(.dropdown-menu):not(.form-floating){border-bottom-right-radius:0;border-top-right-radius:0}.input-group>:not(:first-child):not(.dropdown-menu):not(.valid-tooltip):not(.valid-feedback):not(.invalid-tooltip):not(.invalid-feedback){border-bottom-left-radius:0;border-top-left-radius:0;margin-left:-1px;margin-left:calc(var(--bs-border-width)*-1)}.input-group>.form-floating:not(:first-child)>.form-control,.input-group>.form-floating:not(:first-child)>.form-select{border-bottom-left-radius:0;border-top-left-radius:0}.valid-feedback{color:#198754;color:var(--bs-form-valid-color);display:none;font-size:.875em;margin-top:.25rem;width:100%}.valid-tooltip{background-color:#198754;background-color:var(--bs-success);border-radius:.375rem;border-radius:var(--bs-border-radius);color:#fff;display:none;font-size:.875rem;margin-top:.1rem;max-width:100%;padding:.25rem .5rem;position:absolute;top:100%;z-index:5}.is-valid~.valid-feedback,.is-valid~.valid-tooltip,.was-validated :valid~.valid-feedback,.was-validated :valid~.valid-tooltip{display:block}.form-control.is-valid,.was-validated .form-control:valid{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 8 8'%3E%3Cpath fill='%23198754' d='M2.3 6.73.6 4.53c-.4-1.04.46-1.4 1.1-.8l1.1 1.4 3.4-3.8c.6-.63 1.6-.27 1.2.7l-4 4.6c-.43.5-.8.4-1.1.1z'/%3E%3C/svg%3E");background-position:right calc(.375em + .1875rem) center;background-repeat:no-repeat;background-size:calc(.75em + .375rem) calc(.75em + .375rem);border-color:#198754;border-color:var(--bs-form-valid-border-color);padding-right:calc(1.5em + .75rem)}.form-control.is-valid:focus,.was-validated .form-control:valid:focus{border-color:#198754;border-color:var(--bs-form-valid-border-color);box-shadow:0 0 0 .25rem rgba(25,135,84,.25);box-shadow:0 0 0 .25rem rgba(var(--bs-success-rgb),.25)}.was-validated textarea.form-control:valid,textarea.form-control.is-valid{background-position:top calc(.375em + .1875rem) right calc(.375em + .1875rem);padding-right:calc(1.5em + .75rem)}.form-select.is-valid,.was-validated .form-select:valid{border-color:#198754;border-color:var(--bs-form-valid-border-color)}.form-select.is-valid:not([multiple]):not([size]),.form-select.is-valid:not([multiple])[size="1"],.was-validated .form-select:valid:not([multiple]):not([size]),.was-validated .form-select:valid:not([multiple])[size="1"]{--bs-form-select-bg-icon:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 8 8'%3E%3Cpath fill='%23198754' d='M2.3 6.73.6 4.53c-.4-1.04.46-1.4 1.1-.8l1.1 1.4 3.4-3.8c.6-.63 1.6-.27 1.2.7l-4 4.6c-.43.5-.8.4-1.1.1z'/%3E%3C/svg%3E");background-position:right .75rem center,center right 2.25rem;background-size:16px 12px,calc(.75em + .375rem) calc(.75em + .375rem);padding-right:4.125rem}.form-select.is-valid:focus,.was-validated .form-select:valid:focus{border-color:#198754;border-color:var(--bs-form-valid-border-color);box-shadow:0 0 0 .25rem rgba(25,135,84,.25);box-shadow:0 0 0 .25rem rgba(var(--bs-success-rgb),.25)}.form-control-color.is-valid,.was-validated .form-control-color:valid{width:calc(3.75rem + 1.5em)}.form-check-input.is-valid,.was-validated .form-check-input:valid{border-color:#198754;border-color:var(--bs-form-valid-border-color)}.form-check-input.is-valid:checked,.was-validated .form-check-input:valid:checked{background-color:#198754;background-color:var(--bs-form-valid-color)}.form-check-input.is-valid:focus,.was-validated .form-check-input:valid:focus{box-shadow:0 0 0 .25rem rgba(25,135,84,.25);box-shadow:0 0 0 .25rem rgba(var(--bs-success-rgb),.25)}.form-check-input.is-valid~.form-check-label,.was-validated .form-check-input:valid~.form-check-label{color:#198754;color:var(--bs-form-valid-color)}.form-check-inline .form-check-input~.valid-feedback{margin-left:.5em}.input-group>.form-control:not(:focus).is-valid,.input-group>.form-floating:not(:focus-within).is-valid,.input-group>.form-select:not(:focus).is-valid,.was-validated .input-group>.form-control:not(:focus):valid,.was-validated .input-group>.form-floating:not(:focus-within):valid,.was-validated .input-group>.form-select:not(:focus):valid{z-index:3}.invalid-feedback{color:#dc3545;color:var(--bs-form-invalid-color);display:none;font-size:.875em;margin-top:.25rem;width:100%}.invalid-tooltip{background-color:#dc3545;background-color:var(--bs-danger);border-radius:.375rem;border-radius:var(--bs-border-radius);color:#fff;display:none;font-size:.875rem;margin-top:.1rem;max-width:100%;padding:.25rem .5rem;position:absolute;top:100%;z-index:5}.is-invalid~.invalid-feedback,.is-invalid~.invalid-tooltip,.was-validated :invalid~.invalid-feedback,.was-validated :invalid~.invalid-tooltip{display:block}.form-control.is-invalid,.was-validated .form-control:invalid{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' fill='none' stroke='%23dc3545'%3E%3Ccircle cx='6' cy='6' r='4.5'/%3E%3Cpath stroke-linejoin='round' d='M5.8 3.6h.4L6 6.5z'/%3E%3Ccircle cx='6' cy='8.2' r='.6' fill='%23dc3545' stroke='none'/%3E%3C/svg%3E");background-position:right calc(.375em + .1875rem) center;background-repeat:no-repeat;background-size:calc(.75em + .375rem) calc(.75em + .375rem);border-color:#dc3545;border-color:var(--bs-form-invalid-border-color);padding-right:calc(1.5em + .75rem)}.form-control.is-invalid:focus,.was-validated .form-control:invalid:focus{border-color:#dc3545;border-color:var(--bs-form-invalid-border-color);box-shadow:0 0 0 .25rem rgba(220,53,69,.25);box-shadow:0 0 0 .25rem rgba(var(--bs-danger-rgb),.25)}.was-validated textarea.form-control:invalid,textarea.form-control.is-invalid{background-position:top calc(.375em + .1875rem) right calc(.375em + .1875rem);padding-right:calc(1.5em + .75rem)}.form-select.is-invalid,.was-validated .form-select:invalid{border-color:#dc3545;border-color:var(--bs-form-invalid-border-color)}.form-select.is-invalid:not([multiple]):not([size]),.form-select.is-invalid:not([multiple])[size="1"],.was-validated .form-select:invalid:not([multiple]):not([size]),.was-validated .form-select:invalid:not([multiple])[size="1"]{--bs-form-select-bg-icon:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' fill='none' stroke='%23dc3545'%3E%3Ccircle cx='6' cy='6' r='4.5'/%3E%3Cpath stroke-linejoin='round' d='M5.8 3.6h.4L6 6.5z'/%3E%3Ccircle cx='6' cy='8.2' r='.6' fill='%23dc3545' stroke='none'/%3E%3C/svg%3E");background-position:right .75rem center,center right 2.25rem;background-size:16px 12px,calc(.75em + .375rem) calc(.75em + .375rem);padding-right:4.125rem}.form-select.is-invalid:focus,.was-validated .form-select:invalid:focus{border-color:#dc3545;border-color:var(--bs-form-invalid-border-color);box-shadow:0 0 0 .25rem rgba(220,53,69,.25);box-shadow:0 0 0 .25rem rgba(var(--bs-danger-rgb),.25)}.form-control-color.is-invalid,.was-validated .form-control-color:invalid{width:calc(3.75rem + 1.5em)}.form-check-input.is-invalid,.was-validated .form-check-input:invalid{border-color:#dc3545;border-color:var(--bs-form-invalid-border-color)}.form-check-input.is-invalid:checked,.was-validated .form-check-input:invalid:checked{background-color:#dc3545;background-color:var(--bs-form-invalid-color)}.form-check-input.is-invalid:focus,.was-validated .form-check-input:invalid:focus{box-shadow:0 0 0 .25rem rgba(220,53,69,.25);box-shadow:0 0 0 .25rem rgba(var(--bs-danger-rgb),.25)}.form-check-input.is-invalid~.form-check-label,.was-validated .form-check-input:invalid~.form-check-label{color:#dc3545;color:var(--bs-form-invalid-color)}.form-check-inline .form-check-input~.invalid-feedback{margin-left:.5em}.input-group>.form-control:not(:focus).is-invalid,.input-group>.form-floating:not(:focus-within).is-invalid,.input-group>.form-select:not(:focus).is-invalid,.was-validated .input-group>.form-control:not(:focus):invalid,.was-validated .input-group>.form-floating:not(:focus-within):invalid,.was-validated .input-group>.form-select:not(:focus):invalid{z-index:4}.btn{--bs-btn-padding-x:0.75rem;--bs-btn-padding-y:0.375rem;--bs-btn-font-family: ;--bs-btn-font-size:1rem;--bs-btn-font-weight:400;--bs-btn-line-height:1.5;--bs-btn-color:var(--bs-body-color);--bs-btn-bg:transparent;--bs-btn-border-width:var(--bs-border-width);--bs-btn-border-color:transparent;--bs-btn-border-radius:var(--bs-border-radius);--bs-btn-hover-border-color:transparent;--bs-btn-box-shadow:inset 0 1px 0 hsla(0,0%,100%,.15),0 1px 1px rgba(0,0,0,.075);--bs-btn-disabled-opacity:0.65;--bs-btn-focus-box-shadow:0 0 0 0.25rem rgba(var(--bs-btn-focus-shadow-rgb),.5);background-color:var(--bs-btn-bg);border:var(--bs-btn-border-width) solid var(--bs-btn-border-color);border-radius:var(--bs-btn-border-radius);color:var(--bs-btn-color);cursor:pointer;display:inline-block;font-family:var(--bs-btn-font-family);font-size:var(--bs-btn-font-size);font-weight:var(--bs-btn-font-weight);line-height:var(--bs-btn-line-height);padding:var(--bs-btn-padding-y) var(--bs-btn-padding-x);text-align:center;text-decoration:none;transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;-webkit-user-select:none;user-select:none;vertical-align:middle}@media (prefers-reduced-motion:reduce){.btn{transition:none}}.btn:hover{background-color:var(--bs-btn-hover-bg);border-color:var(--bs-btn-hover-border-color);color:var(--bs-btn-hover-color)}.btn-check+.btn:hover{background-color:var(--bs-btn-bg);border-color:var(--bs-btn-border-color);color:var(--bs-btn-color)}.btn:focus-visible{background-color:var(--bs-btn-hover-bg);border-color:var(--bs-btn-hover-border-color);box-shadow:var(--bs-btn-focus-box-shadow);color:var(--bs-btn-hover-color);outline:0}.btn-check:focus-visible+.btn{border-color:var(--bs-btn-hover-border-color);box-shadow:var(--bs-btn-focus-box-shadow);outline:0}.btn-check:checked+.btn,.btn.active,.btn.show,.btn:first-child:active,:not(.btn-check)+.btn:active{background-color:var(--bs-btn-active-bg);border-color:var(--bs-btn-active-border-color);color:var(--bs-btn-active-color)}.btn-check:checked+.btn:focus-visible,.btn.active:focus-visible,.btn.show:focus-visible,.btn:first-child:active:focus-visible,:not(.btn-check)+.btn:active:focus-visible{box-shadow:var(--bs-btn-focus-box-shadow)}.btn.disabled,.btn:disabled,fieldset:disabled .btn{background-color:var(--bs-btn-disabled-bg);border-color:var(--bs-btn-disabled-border-color);color:var(--bs-btn-disabled-color);opacity:var(--bs-btn-disabled-opacity);pointer-events:none}.btn-primary{--bs-btn-color:#fff;--bs-btn-bg:#0d6efd;--bs-btn-border-color:#0d6efd;--bs-btn-hover-color:#fff;--bs-btn-hover-bg:#0b5ed7;--bs-btn-hover-border-color:#0a58ca;--bs-btn-focus-shadow-rgb:49,132,253;--bs-btn-active-color:#fff;--bs-btn-active-bg:#0a58ca;--bs-btn-active-border-color:#0a53be;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#fff;--bs-btn-disabled-bg:#0d6efd;--bs-btn-disabled-border-color:#0d6efd}.btn-secondary{--bs-btn-color:#fff;--bs-btn-bg:#6c757d;--bs-btn-border-color:#6c757d;--bs-btn-hover-color:#fff;--bs-btn-hover-bg:#5c636a;--bs-btn-hover-border-color:#565e64;--bs-btn-focus-shadow-rgb:130,138,145;--bs-btn-active-color:#fff;--bs-btn-active-bg:#565e64;--bs-btn-active-border-color:#51585e;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#fff;--bs-btn-disabled-bg:#6c757d;--bs-btn-disabled-border-color:#6c757d}.btn-success{--bs-btn-color:#fff;--bs-btn-bg:#198754;--bs-btn-border-color:#198754;--bs-btn-hover-color:#fff;--bs-btn-hover-bg:#157347;--bs-btn-hover-border-color:#146c43;--bs-btn-focus-shadow-rgb:60,153,110;--bs-btn-active-color:#fff;--bs-btn-active-bg:#146c43;--bs-btn-active-border-color:#13653f;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#fff;--bs-btn-disabled-bg:#198754;--bs-btn-disabled-border-color:#198754}.btn-info{--bs-btn-color:#000;--bs-btn-bg:#0dcaf0;--bs-btn-border-color:#0dcaf0;--bs-btn-hover-color:#000;--bs-btn-hover-bg:#31d2f2;--bs-btn-hover-border-color:#25cff2;--bs-btn-focus-shadow-rgb:11,172,204;--bs-btn-active-color:#000;--bs-btn-active-bg:#3dd5f3;--bs-btn-active-border-color:#25cff2;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#000;--bs-btn-disabled-bg:#0dcaf0;--bs-btn-disabled-border-color:#0dcaf0}.btn-warning{--bs-btn-color:#000;--bs-btn-bg:#ffc107;--bs-btn-border-color:#ffc107;--bs-btn-hover-color:#000;--bs-btn-hover-bg:#ffca2c;--bs-btn-hover-border-color:#ffc720;--bs-btn-focus-shadow-rgb:217,164,6;--bs-btn-active-color:#000;--bs-btn-active-bg:#ffcd39;--bs-btn-active-border-color:#ffc720;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#000;--bs-btn-disabled-bg:#ffc107;--bs-btn-disabled-border-color:#ffc107}.btn-danger{--bs-btn-color:#fff;--bs-btn-bg:#dc3545;--bs-btn-border-color:#dc3545;--bs-btn-hover-color:#fff;--bs-btn-hover-bg:#bb2d3b;--bs-btn-hover-border-color:#b02a37;--bs-btn-focus-shadow-rgb:225,83,97;--bs-btn-active-color:#fff;--bs-btn-active-bg:#b02a37;--bs-btn-active-border-color:#a52834;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#fff;--bs-btn-disabled-bg:#dc3545;--bs-btn-disabled-border-color:#dc3545}.btn-light{--bs-btn-color:#000;--bs-btn-bg:#f8f9fa;--bs-btn-border-color:#f8f9fa;--bs-btn-hover-color:#000;--bs-btn-hover-bg:#d3d4d5;--bs-btn-hover-border-color:#c6c7c8;--bs-btn-focus-shadow-rgb:211,212,213;--bs-btn-active-color:#000;--bs-btn-active-bg:#c6c7c8;--bs-btn-active-border-color:#babbbc;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#000;--bs-btn-disabled-bg:#f8f9fa;--bs-btn-disabled-border-color:#f8f9fa}.btn-dark{--bs-btn-color:#fff;--bs-btn-bg:#212529;--bs-btn-border-color:#212529;--bs-btn-hover-color:#fff;--bs-btn-hover-bg:#424649;--bs-btn-hover-border-color:#373b3e;--bs-btn-focus-shadow-rgb:66,70,73;--bs-btn-active-color:#fff;--bs-btn-active-bg:#4d5154;--bs-btn-active-border-color:#373b3e;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#fff;--bs-btn-disabled-bg:#212529;--bs-btn-disabled-border-color:#212529}.btn-outline-primary{--bs-btn-color:#0d6efd;--bs-btn-border-color:#0d6efd;--bs-btn-hover-color:#fff;--bs-btn-hover-bg:#0d6efd;--bs-btn-hover-border-color:#0d6efd;--bs-btn-focus-shadow-rgb:13,110,253;--bs-btn-active-color:#fff;--bs-btn-active-bg:#0d6efd;--bs-btn-active-border-color:#0d6efd;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#0d6efd;--bs-btn-disabled-bg:transparent;--bs-btn-disabled-border-color:#0d6efd;--bs-gradient:none}.btn-outline-secondary{--bs-btn-color:#6c757d;--bs-btn-border-color:#6c757d;--bs-btn-hover-color:#fff;--bs-btn-hover-bg:#6c757d;--bs-btn-hover-border-color:#6c757d;--bs-btn-focus-shadow-rgb:108,117,125;--bs-btn-active-color:#fff;--bs-btn-active-bg:#6c757d;--bs-btn-active-border-color:#6c757d;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#6c757d;--bs-btn-disabled-bg:transparent;--bs-btn-disabled-border-color:#6c757d;--bs-gradient:none}.btn-outline-success{--bs-btn-color:#198754;--bs-btn-border-color:#198754;--bs-btn-hover-color:#fff;--bs-btn-hover-bg:#198754;--bs-btn-hover-border-color:#198754;--bs-btn-focus-shadow-rgb:25,135,84;--bs-btn-active-color:#fff;--bs-btn-active-bg:#198754;--bs-btn-active-border-color:#198754;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#198754;--bs-btn-disabled-bg:transparent;--bs-btn-disabled-border-color:#198754;--bs-gradient:none}.btn-outline-info{--bs-btn-color:#0dcaf0;--bs-btn-border-color:#0dcaf0;--bs-btn-hover-color:#000;--bs-btn-hover-bg:#0dcaf0;--bs-btn-hover-border-color:#0dcaf0;--bs-btn-focus-shadow-rgb:13,202,240;--bs-btn-active-color:#000;--bs-btn-active-bg:#0dcaf0;--bs-btn-active-border-color:#0dcaf0;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#0dcaf0;--bs-btn-disabled-bg:transparent;--bs-btn-disabled-border-color:#0dcaf0;--bs-gradient:none}.btn-outline-warning{--bs-btn-color:#ffc107;--bs-btn-border-color:#ffc107;--bs-btn-hover-color:#000;--bs-btn-hover-bg:#ffc107;--bs-btn-hover-border-color:#ffc107;--bs-btn-focus-shadow-rgb:255,193,7;--bs-btn-active-color:#000;--bs-btn-active-bg:#ffc107;--bs-btn-active-border-color:#ffc107;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#ffc107;--bs-btn-disabled-bg:transparent;--bs-btn-disabled-border-color:#ffc107;--bs-gradient:none}.btn-outline-danger{--bs-btn-color:#dc3545;--bs-btn-border-color:#dc3545;--bs-btn-hover-color:#fff;--bs-btn-hover-bg:#dc3545;--bs-btn-hover-border-color:#dc3545;--bs-btn-focus-shadow-rgb:220,53,69;--bs-btn-active-color:#fff;--bs-btn-active-bg:#dc3545;--bs-btn-active-border-color:#dc3545;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#dc3545;--bs-btn-disabled-bg:transparent;--bs-btn-disabled-border-color:#dc3545;--bs-gradient:none}.btn-outline-light{--bs-btn-color:#f8f9fa;--bs-btn-border-color:#f8f9fa;--bs-btn-hover-color:#000;--bs-btn-hover-bg:#f8f9fa;--bs-btn-hover-border-color:#f8f9fa;--bs-btn-focus-shadow-rgb:248,249,250;--bs-btn-active-color:#000;--bs-btn-active-bg:#f8f9fa;--bs-btn-active-border-color:#f8f9fa;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#f8f9fa;--bs-btn-disabled-bg:transparent;--bs-btn-disabled-border-color:#f8f9fa;--bs-gradient:none}.btn-outline-dark{--bs-btn-color:#212529;--bs-btn-border-color:#212529;--bs-btn-hover-color:#fff;--bs-btn-hover-bg:#212529;--bs-btn-hover-border-color:#212529;--bs-btn-focus-shadow-rgb:33,37,41;--bs-btn-active-color:#fff;--bs-btn-active-bg:#212529;--bs-btn-active-border-color:#212529;--bs-btn-active-shadow:inset 0 3px 5px rgba(0,0,0,.125);--bs-btn-disabled-color:#212529;--bs-btn-disabled-bg:transparent;--bs-btn-disabled-border-color:#212529;--bs-gradient:none}.btn-link{--bs-btn-font-weight:400;--bs-btn-color:var(--bs-link-color);--bs-btn-bg:transparent;--bs-btn-border-color:transparent;--bs-btn-hover-color:var(--bs-link-hover-color);--bs-btn-hover-border-color:transparent;--bs-btn-active-color:var(--bs-link-hover-color);--bs-btn-active-border-color:transparent;--bs-btn-disabled-color:#6c757d;--bs-btn-disabled-border-color:transparent;--bs-btn-box-shadow:0 0 0 #000;--bs-btn-focus-shadow-rgb:49,132,253;text-decoration:underline}.btn-link:focus-visible{color:var(--bs-btn-color)}.btn-link:hover{color:var(--bs-btn-hover-color)}.btn-group-lg>.btn,.btn-lg{--bs-btn-padding-y:0.5rem;--bs-btn-padding-x:1rem;--bs-btn-font-size:1.25rem;--bs-btn-border-radius:var(--bs-border-radius-lg)}.btn-group-sm>.btn,.btn-sm{--bs-btn-padding-y:0.25rem;--bs-btn-padding-x:0.5rem;--bs-btn-font-size:0.875rem;--bs-btn-border-radius:var(--bs-border-radius-sm)}.fade{transition:opacity .15s linear}@media (prefers-reduced-motion:reduce){.fade{transition:none}}.fade:not(.show){opacity:0}.collapse:not(.show){display:none}.collapsing{height:0;overflow:hidden;transition:height .35s ease}@media (prefers-reduced-motion:reduce){.collapsing{transition:none}}.collapsing.collapse-horizontal{height:auto;transition:width .35s ease;width:0}@media (prefers-reduced-motion:reduce){.collapsing.collapse-horizontal{transition:none}}.dropdown,.dropdown-center,.dropend,.dropstart,.dropup,.dropup-center{position:relative}.dropdown-toggle{white-space:nowrap}.dropdown-toggle:after{border-bottom:0;border-left:.3em solid transparent;border-right:.3em solid transparent;border-top:.3em solid;content:"";display:inline-block;margin-left:.255em;vertical-align:.255em}.dropdown-toggle:empty:after{margin-left:0}.dropdown-menu{--bs-dropdown-zindex:1000;--bs-dropdown-min-width:10rem;--bs-dropdown-padding-x:0;--bs-dropdown-padding-y:0.5rem;--bs-dropdown-spacer:0.125rem;--bs-dropdown-font-size:1rem;--bs-dropdown-color:var(--bs-body-color);--bs-dropdown-bg:var(--bs-body-bg);--bs-dropdown-border-color:var(--bs-border-color-translucent);--bs-dropdown-border-radius:var(--bs-border-radius);--bs-dropdown-border-width:var(--bs-border-width);--bs-dropdown-inner-border-radius:calc(var(--bs-border-radius) - var(--bs-border-width));--bs-dropdown-divider-bg:var(--bs-border-color-translucent);--bs-dropdown-divider-margin-y:0.5rem;--bs-dropdown-box-shadow:var(--bs-box-shadow);--bs-dropdown-link-color:var(--bs-body-color);--bs-dropdown-link-hover-color:var(--bs-body-color);--bs-dropdown-link-hover-bg:var(--bs-tertiary-bg);--bs-dropdown-link-active-color:#fff;--bs-dropdown-link-active-bg:#0d6efd;--bs-dropdown-link-disabled-color:var(--bs-tertiary-color);--bs-dropdown-item-padding-x:1rem;--bs-dropdown-item-padding-y:0.25rem;--bs-dropdown-header-color:#6c757d;--bs-dropdown-header-padding-x:1rem;--bs-dropdown-header-padding-y:0.5rem;background-clip:padding-box;background-color:var(--bs-dropdown-bg);border:var(--bs-dropdown-border-width) solid var(--bs-dropdown-border-color);border-radius:var(--bs-dropdown-border-radius);color:var(--bs-dropdown-color);display:none;font-size:var(--bs-dropdown-font-size);list-style:none;margin:0;min-width:var(--bs-dropdown-min-width);padding:var(--bs-dropdown-padding-y) var(--bs-dropdown-padding-x);position:absolute;text-align:left;z-index:var(--bs-dropdown-zindex)}.dropdown-menu[data-bs-popper]{left:0;margin-top:var(--bs-dropdown-spacer);top:100%}.dropdown-menu-start{--bs-position:start}.dropdown-menu-start[data-bs-popper]{left:0;right:auto}.dropdown-menu-end{--bs-position:end}.dropdown-menu-end[data-bs-popper]{left:auto;right:0}@media (min-width:576px){.dropdown-menu-sm-start{--bs-position:start}.dropdown-menu-sm-start[data-bs-popper]{left:0;right:auto}.dropdown-menu-sm-end{--bs-position:end}.dropdown-menu-sm-end[data-bs-popper]{left:auto;right:0}}@media (min-width:768px){.dropdown-menu-md-start{--bs-position:start}.dropdown-menu-md-start[data-bs-popper]{left:0;right:auto}.dropdown-menu-md-end{--bs-position:end}.dropdown-menu-md-end[data-bs-popper]{left:auto;right:0}}@media (min-width:992px){.dropdown-menu-lg-start{--bs-position:start}.dropdown-menu-lg-start[data-bs-popper]{left:0;right:auto}.dropdown-menu-lg-end{--bs-position:end}.dropdown-menu-lg-end[data-bs-popper]{left:auto;right:0}}@media (min-width:1200px){.dropdown-menu-xl-start{--bs-position:start}.dropdown-menu-xl-start[data-bs-popper]{left:0;right:auto}.dropdown-menu-xl-end{--bs-position:end}.dropdown-menu-xl-end[data-bs-popper]{left:auto;right:0}}@media (min-width:1400px){.dropdown-menu-xxl-start{--bs-position:start}.dropdown-menu-xxl-start[data-bs-popper]{left:0;right:auto}.dropdown-menu-xxl-end{--bs-position:end}.dropdown-menu-xxl-end[data-bs-popper]{left:auto;right:0}}.dropup .dropdown-menu[data-bs-popper]{bottom:100%;margin-bottom:var(--bs-dropdown-spacer);margin-top:0;top:auto}.dropup .dropdown-toggle:after{border-bottom:.3em solid;border-left:.3em solid transparent;border-right:.3em solid transparent;border-top:0;content:"";display:inline-block;margin-left:.255em;vertical-align:.255em}.dropup .dropdown-toggle:empty:after{margin-left:0}.dropend .dropdown-menu[data-bs-popper]{left:100%;margin-left:var(--bs-dropdown-spacer);margin-top:0;right:auto;top:0}.dropend .dropdown-toggle:after{border-bottom:.3em solid transparent;border-left:.3em solid;border-right:0;border-top:.3em solid transparent;content:"";display:inline-block;margin-left:.255em;vertical-align:.255em}.dropend .dropdown-toggle:empty:after{margin-left:0}.dropend .dropdown-toggle:after{vertical-align:0}.dropstart .dropdown-menu[data-bs-popper]{left:auto;margin-right:var(--bs-dropdown-spacer);margin-top:0;right:100%;top:0}.dropstart .dropdown-toggle:after{content:"";display:inline-block;display:none;margin-left:.255em;vertical-align:.255em}.dropstart .dropdown-toggle:before{border-bottom:.3em solid transparent;border-right:.3em solid;border-top:.3em solid transparent;content:"";display:inline-block;margin-right:.255em;vertical-align:.255em}.dropstart .dropdown-toggle:empty:after{margin-left:0}.dropstart .dropdown-toggle:before{vertical-align:0}.dropdown-divider{border-top:1px solid var(--bs-dropdown-divider-bg);height:0;margin:var(--bs-dropdown-divider-margin-y) 0;opacity:1;overflow:hidden}.dropdown-item{background-color:initial;border:0;border-radius:0;border-radius:var(--bs-dropdown-item-border-radius,0);clear:both;color:var(--bs-dropdown-link-color);display:block;font-weight:400;padding:var(--bs-dropdown-item-padding-y) var(--bs-dropdown-item-padding-x);text-align:inherit;text-decoration:none;white-space:nowrap;width:100%}.dropdown-item:focus,.dropdown-item:hover{background-color:var(--bs-dropdown-link-hover-bg);color:var(--bs-dropdown-link-hover-color)}.dropdown-item.active,.dropdown-item:active{background-color:var(--bs-dropdown-link-active-bg);color:var(--bs-dropdown-link-active-color);text-decoration:none}.dropdown-item.disabled,.dropdown-item:disabled{background-color:initial;color:var(--bs-dropdown-link-disabled-color);pointer-events:none}.dropdown-menu.show{display:block}.dropdown-header{color:var(--bs-dropdown-header-color);display:block;font-size:.875rem;margin-bottom:0;padding:var(--bs-dropdown-header-padding-y) var(--bs-dropdown-header-padding-x);white-space:nowrap}.dropdown-item-text{color:var(--bs-dropdown-link-color);display:block;padding:var(--bs-dropdown-item-padding-y) var(--bs-dropdown-item-padding-x)}.dropdown-menu-dark{--bs-dropdown-color:#dee2e6;--bs-dropdown-bg:#343a40;--bs-dropdown-border-color:var(--bs-border-color-translucent);--bs-dropdown-box-shadow: ;--bs-dropdown-link-color:#dee2e6;--bs-dropdown-link-hover-color:#fff;--bs-dropdown-divider-bg:var(--bs-border-color-translucent);--bs-dropdown-link-hover-bg:hsla(0,0%,100%,.15);--bs-dropdown-link-active-color:#fff;--bs-dropdown-link-active-bg:#0d6efd;--bs-dropdown-link-disabled-color:#adb5bd;--bs-dropdown-header-color:#adb5bd}.btn-group,.btn-group-vertical{display:inline-flex;position:relative;vertical-align:middle}.btn-group-vertical>.btn,.btn-group>.btn{flex:1 1 auto;position:relative}.btn-group-vertical>.btn-check:checked+.btn,.btn-group-vertical>.btn-check:focus+.btn,.btn-group-vertical>.btn.active,.btn-group-vertical>.btn:active,.btn-group-vertical>.btn:focus,.btn-group-vertical>.btn:hover,.btn-group>.btn-check:checked+.btn,.btn-group>.btn-check:focus+.btn,.btn-group>.btn.active,.btn-group>.btn:active,.btn-group>.btn:focus,.btn-group>.btn:hover{z-index:1}.btn-toolbar{display:flex;flex-wrap:wrap;justify-content:flex-start}.btn-toolbar .input-group{width:auto}.btn-group{border-radius:.375rem;border-radius:var(--bs-border-radius)}.btn-group>.btn-group:not(:first-child),.btn-group>:not(.btn-check:first-child)+.btn{margin-left:-1px;margin-left:calc(var(--bs-border-width)*-1)}.btn-group>.btn-group:not(:last-child)>.btn,.btn-group>.btn.dropdown-toggle-split:first-child,.btn-group>.btn:not(:last-child):not(.dropdown-toggle){border-bottom-right-radius:0;border-top-right-radius:0}.btn-group>.btn-group:not(:first-child)>.btn,.btn-group>.btn:nth-child(n+3),.btn-group>:not(.btn-check)+.btn{border-bottom-left-radius:0;border-top-left-radius:0}.dropdown-toggle-split{padding-left:.5625rem;padding-right:.5625rem}.dropdown-toggle-split:after,.dropend .dropdown-toggle-split:after,.dropup .dropdown-toggle-split:after{margin-left:0}.dropstart .dropdown-toggle-split:before{margin-right:0}.btn-group-sm>.btn+.dropdown-toggle-split,.btn-sm+.dropdown-toggle-split{padding-left:.375rem;padding-right:.375rem}.btn-group-lg>.btn+.dropdown-toggle-split,.btn-lg+.dropdown-toggle-split{padding-left:.75rem;padding-right:.75rem}.btn-group-vertical{align-items:flex-start;flex-direction:column;justify-content:center}.btn-group-vertical>.btn,.btn-group-vertical>.btn-group{width:100%}.btn-group-vertical>.btn-group:not(:first-child),.btn-group-vertical>.btn:not(:first-child){margin-top:-1px;margin-top:calc(var(--bs-border-width)*-1)}.btn-group-vertical>.btn-group:not(:last-child)>.btn,.btn-group-vertical>.btn:not(:last-child):not(.dropdown-toggle){border-bottom-left-radius:0;border-bottom-right-radius:0}.btn-group-vertical>.btn-group:not(:first-child)>.btn,.btn-group-vertical>.btn~.btn{border-top-left-radius:0;border-top-right-radius:0}.nav{--bs-nav-link-padding-x:1rem;--bs-nav-link-padding-y:0.5rem;--bs-nav-link-font-weight: ;--bs-nav-link-color:var(--bs-link-color);--bs-nav-link-hover-color:var(--bs-link-hover-color);--bs-nav-link-disabled-color:var(--bs-secondary-color);display:flex;flex-wrap:wrap;list-style:none;margin-bottom:0;padding-left:0}.nav-link{background:none;border:0;color:var(--bs-nav-link-color);display:block;font-size:var(--bs-nav-link-font-size);font-weight:var(--bs-nav-link-font-weight);padding:var(--bs-nav-link-padding-y) var(--bs-nav-link-padding-x);text-decoration:none;transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out}@media (prefers-reduced-motion:reduce){.nav-link{transition:none}}.nav-link:focus,.nav-link:hover{color:var(--bs-nav-link-hover-color)}.nav-link:focus-visible{box-shadow:0 0 0 .25rem rgba(13,110,253,.25);outline:0}.nav-link.disabled,.nav-link:disabled{color:var(--bs-nav-link-disabled-color);cursor:default;pointer-events:none}.nav-tabs{--bs-nav-tabs-border-width:var(--bs-border-width);--bs-nav-tabs-border-color:var(--bs-border-color);--bs-nav-tabs-border-radius:var(--bs-border-radius);--bs-nav-tabs-link-hover-border-color:var(--bs-secondary-bg) var(--bs-secondary-bg) var(--bs-border-color);--bs-nav-tabs-link-active-color:var(--bs-emphasis-color);--bs-nav-tabs-link-active-bg:var(--bs-body-bg);--bs-nav-tabs-link-active-border-color:var(--bs-border-color) var(--bs-border-color) var(--bs-body-bg);border-bottom:var(--bs-nav-tabs-border-width) solid var(--bs-nav-tabs-border-color)}.nav-tabs .nav-link{border:var(--bs-nav-tabs-border-width) solid transparent;border-top-left-radius:var(--bs-nav-tabs-border-radius);border-top-right-radius:var(--bs-nav-tabs-border-radius);margin-bottom:calc(var(--bs-nav-tabs-border-width)*-1)}.nav-tabs .nav-link:focus,.nav-tabs .nav-link:hover{border-color:var(--bs-nav-tabs-link-hover-border-color);isolation:isolate}.nav-tabs .nav-item.show .nav-link,.nav-tabs .nav-link.active{background-color:var(--bs-nav-tabs-link-active-bg);border-color:var(--bs-nav-tabs-link-active-border-color);color:var(--bs-nav-tabs-link-active-color)}.nav-tabs .dropdown-menu{border-top-left-radius:0;border-top-right-radius:0;margin-top:calc(var(--bs-nav-tabs-border-width)*-1)}.nav-pills{--bs-nav-pills-border-radius:var(--bs-border-radius);--bs-nav-pills-link-active-color:#fff;--bs-nav-pills-link-active-bg:#0d6efd}.nav-pills .nav-link{border-radius:var(--bs-nav-pills-border-radius)}.nav-pills .nav-link.active,.nav-pills .show>.nav-link{background-color:var(--bs-nav-pills-link-active-bg);color:var(--bs-nav-pills-link-active-color)}.nav-underline{--bs-nav-underline-gap:1rem;--bs-nav-underline-border-width:0.125rem;--bs-nav-underline-link-active-color:var(--bs-emphasis-color);gap:var(--bs-nav-underline-gap)}.nav-underline .nav-link{border-bottom:var(--bs-nav-underline-border-width) solid transparent;padding-left:0;padding-right:0}.nav-underline .nav-link:focus,.nav-underline .nav-link:hover{border-bottom-color:initial}.nav-underline .nav-link.active,.nav-underline .show>.nav-link{border-bottom-color:initial;color:var(--bs-nav-underline-link-active-color);font-weight:700}.nav-fill .nav-item,.nav-fill>.nav-link{flex:1 1 auto;text-align:center}.nav-justified .nav-item,.nav-justified>.nav-link{flex-basis:0;flex-grow:1;text-align:center}.nav-fill .nav-item .nav-link,.nav-justified .nav-item .nav-link{width:100%}.tab-content>.tab-pane{display:none}.tab-content>.active{display:block}.navbar{--bs-navbar-padding-x:0;--bs-navbar-padding-y:0.5rem;--bs-navbar-color:rgba(var(--bs-emphasis-color-rgb),0.65);--bs-navbar-hover-color:rgba(var(--bs-emphasis-color-rgb),0.8);--bs-navbar-disabled-color:rgba(var(--bs-emphasis-color-rgb),0.3);--bs-navbar-active-color:rgba(var(--bs-emphasis-color-rgb),1);--bs-navbar-brand-padding-y:0.3125rem;--bs-navbar-brand-margin-end:1rem;--bs-navbar-brand-font-size:1.25rem;--bs-navbar-brand-color:rgba(var(--bs-emphasis-color-rgb),1);--bs-navbar-brand-hover-color:rgba(var(--bs-emphasis-color-rgb),1);--bs-navbar-nav-link-padding-x:0.5rem;--bs-navbar-toggler-padding-y:0.25rem;--bs-navbar-toggler-padding-x:0.75rem;--bs-navbar-toggler-font-size:1.25rem;--bs-navbar-toggler-icon-bg:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 30 30'%3E%3Cpath stroke='rgba(33, 37, 41, 0.75)' stroke-linecap='round' stroke-miterlimit='10' stroke-width='2' d='M4 7h22M4 15h22M4 23h22'/%3E%3C/svg%3E");--bs-navbar-toggler-border-color:rgba(var(--bs-emphasis-color-rgb),0.15);--bs-navbar-toggler-border-radius:var(--bs-border-radius);--bs-navbar-toggler-focus-width:0.25rem;--bs-navbar-toggler-transition:box-shadow 0.15s ease-in-out;align-items:center;display:flex;flex-wrap:wrap;justify-content:space-between;padding:var(--bs-navbar-padding-y) var(--bs-navbar-padding-x);position:relative}.navbar>.container,.navbar>.container-fluid,.navbar>.container-lg,.navbar>.container-md,.navbar>.container-sm,.navbar>.container-xl,.navbar>.container-xxl{align-items:center;display:flex;flex-wrap:inherit;justify-content:space-between}.navbar-brand{color:var(--bs-navbar-brand-color);font-size:var(--bs-navbar-brand-font-size);margin-right:var(--bs-navbar-brand-margin-end);padding-bottom:var(--bs-navbar-brand-padding-y);padding-top:var(--bs-navbar-brand-padding-y);text-decoration:none;white-space:nowrap}.navbar-brand:focus,.navbar-brand:hover{color:var(--bs-navbar-brand-hover-color)}.navbar-nav{--bs-nav-link-padding-x:0;--bs-nav-link-padding-y:0.5rem;--bs-nav-link-font-weight: ;--bs-nav-link-color:var(--bs-navbar-color);--bs-nav-link-hover-color:var(--bs-navbar-hover-color);--bs-nav-link-disabled-color:var(--bs-navbar-disabled-color);display:flex;flex-direction:column;list-style:none;margin-bottom:0;padding-left:0}.navbar-nav .nav-link.active,.navbar-nav .nav-link.show{color:var(--bs-navbar-active-color)}.navbar-nav .dropdown-menu{position:static}.navbar-text{color:var(--bs-navbar-color);padding-bottom:.5rem;padding-top:.5rem}.navbar-text a,.navbar-text a:focus,.navbar-text a:hover{color:var(--bs-navbar-active-color)}.navbar-collapse{align-items:center;flex-basis:100%;flex-grow:1}.navbar-toggler{background-color:initial;border:var(--bs-border-width) solid var(--bs-navbar-toggler-border-color);border-radius:var(--bs-navbar-toggler-border-radius);color:var(--bs-navbar-color);font-size:var(--bs-navbar-toggler-font-size);line-height:1;padding:var(--bs-navbar-toggler-padding-y) var(--bs-navbar-toggler-padding-x);transition:var(--bs-navbar-toggler-transition)}@media (prefers-reduced-motion:reduce){.navbar-toggler{transition:none}}.navbar-toggler:hover{text-decoration:none}.navbar-toggler:focus{box-shadow:0 0 0 var(--bs-navbar-toggler-focus-width);outline:0;text-decoration:none}.navbar-toggler-icon{background-image:var(--bs-navbar-toggler-icon-bg);background-position:50%;background-repeat:no-repeat;background-size:100%;display:inline-block;height:1.5em;vertical-align:middle;width:1.5em}.navbar-nav-scroll{max-height:75vh;max-height:var(--bs-scroll-height,75vh);overflow-y:auto}@media (min-width:576px){.navbar-expand-sm{flex-wrap:nowrap;justify-content:flex-start}.navbar-expand-sm .navbar-nav{flex-direction:row}.navbar-expand-sm .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-sm .navbar-nav .nav-link{padding-left:var(--bs-navbar-nav-link-padding-x);padding-right:var(--bs-navbar-nav-link-padding-x)}.navbar-expand-sm .navbar-nav-scroll{overflow:visible}.navbar-expand-sm .navbar-collapse{display:flex!important;flex-basis:auto}.navbar-expand-sm .navbar-toggler{display:none}.navbar-expand-sm .offcanvas{background-color:initial!important;border:0!important;flex-grow:1;height:auto!important;position:static;-webkit-transform:none!important;transform:none!important;transition:none;visibility:visible!important;width:auto!important;z-index:auto}.navbar-expand-sm .offcanvas .offcanvas-header{display:none}.navbar-expand-sm .offcanvas .offcanvas-body{display:flex;flex-grow:0;overflow-y:visible;padding:0}}@media (min-width:768px){.navbar-expand-md{flex-wrap:nowrap;justify-content:flex-start}.navbar-expand-md .navbar-nav{flex-direction:row}.navbar-expand-md .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-md .navbar-nav .nav-link{padding-left:var(--bs-navbar-nav-link-padding-x);padding-right:var(--bs-navbar-nav-link-padding-x)}.navbar-expand-md .navbar-nav-scroll{overflow:visible}.navbar-expand-md .navbar-collapse{display:flex!important;flex-basis:auto}.navbar-expand-md .navbar-toggler{display:none}.navbar-expand-md .offcanvas{background-color:initial!important;border:0!important;flex-grow:1;height:auto!important;position:static;-webkit-transform:none!important;transform:none!important;transition:none;visibility:visible!important;width:auto!important;z-index:auto}.navbar-expand-md .offcanvas .offcanvas-header{display:none}.navbar-expand-md .offcanvas .offcanvas-body{display:flex;flex-grow:0;overflow-y:visible;padding:0}}@media (min-width:992px){.navbar-expand-lg{flex-wrap:nowrap;justify-content:flex-start}.navbar-expand-lg .navbar-nav{flex-direction:row}.navbar-expand-lg .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-lg .navbar-nav .nav-link{padding-left:var(--bs-navbar-nav-link-padding-x);padding-right:var(--bs-navbar-nav-link-padding-x)}.navbar-expand-lg .navbar-nav-scroll{overflow:visible}.navbar-expand-lg .navbar-collapse{display:flex!important;flex-basis:auto}.navbar-expand-lg .navbar-toggler{display:none}.navbar-expand-lg .offcanvas{background-color:initial!important;border:0!important;flex-grow:1;height:auto!important;position:static;-webkit-transform:none!important;transform:none!important;transition:none;visibility:visible!important;width:auto!important;z-index:auto}.navbar-expand-lg .offcanvas .offcanvas-header{display:none}.navbar-expand-lg .offcanvas .offcanvas-body{display:flex;flex-grow:0;overflow-y:visible;padding:0}}@media (min-width:1200px){.navbar-expand-xl{flex-wrap:nowrap;justify-content:flex-start}.navbar-expand-xl .navbar-nav{flex-direction:row}.navbar-expand-xl .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-xl .navbar-nav .nav-link{padding-left:var(--bs-navbar-nav-link-padding-x);padding-right:var(--bs-navbar-nav-link-padding-x)}.navbar-expand-xl .navbar-nav-scroll{overflow:visible}.navbar-expand-xl .navbar-collapse{display:flex!important;flex-basis:auto}.navbar-expand-xl .navbar-toggler{display:none}.navbar-expand-xl .offcanvas{background-color:initial!important;border:0!important;flex-grow:1;height:auto!important;position:static;-webkit-transform:none!important;transform:none!important;transition:none;visibility:visible!important;width:auto!important;z-index:auto}.navbar-expand-xl .offcanvas .offcanvas-header{display:none}.navbar-expand-xl .offcanvas .offcanvas-body{display:flex;flex-grow:0;overflow-y:visible;padding:0}}@media (min-width:1400px){.navbar-expand-xxl{flex-wrap:nowrap;justify-content:flex-start}.navbar-expand-xxl .navbar-nav{flex-direction:row}.navbar-expand-xxl .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-xxl .navbar-nav .nav-link{padding-left:var(--bs-navbar-nav-link-padding-x);padding-right:var(--bs-navbar-nav-link-padding-x)}.navbar-expand-xxl .navbar-nav-scroll{overflow:visible}.navbar-expand-xxl .navbar-collapse{display:flex!important;flex-basis:auto}.navbar-expand-xxl .navbar-toggler{display:none}.navbar-expand-xxl .offcanvas{background-color:initial!important;border:0!important;flex-grow:1;height:auto!important;position:static;-webkit-transform:none!important;transform:none!important;transition:none;visibility:visible!important;width:auto!important;z-index:auto}.navbar-expand-xxl .offcanvas .offcanvas-header{display:none}.navbar-expand-xxl .offcanvas .offcanvas-body{display:flex;flex-grow:0;overflow-y:visible;padding:0}}.navbar-expand{flex-wrap:nowrap;justify-content:flex-start}.navbar-expand .navbar-nav{flex-direction:row}.navbar-expand .navbar-nav .dropdown-menu{position:absolute}.navbar-expand .navbar-nav .nav-link{padding-left:var(--bs-navbar-nav-link-padding-x);padding-right:var(--bs-navbar-nav-link-padding-x)}.navbar-expand .navbar-nav-scroll{overflow:visible}.navbar-expand .navbar-collapse{display:flex!important;flex-basis:auto}.navbar-expand .navbar-toggler{display:none}.navbar-expand .offcanvas{background-color:initial!important;border:0!important;flex-grow:1;height:auto!important;position:static;-webkit-transform:none!important;transform:none!important;transition:none;visibility:visible!important;width:auto!important;z-index:auto}.navbar-expand .offcanvas .offcanvas-header{display:none}.navbar-expand .offcanvas .offcanvas-body{display:flex;flex-grow:0;overflow-y:visible;padding:0}.navbar-dark,.navbar[data-bs-theme=dark]{--bs-navbar-color:hsla(0,0%,100%,.55);--bs-navbar-hover-color:hsla(0,0%,100%,.75);--bs-navbar-disabled-color:hsla(0,0%,100%,.25);--bs-navbar-active-color:#fff;--bs-navbar-brand-color:#fff;--bs-navbar-brand-hover-color:#fff;--bs-navbar-toggler-border-color:hsla(0,0%,100%,.1)}.navbar-dark,.navbar[data-bs-theme=dark],[data-bs-theme=dark] .navbar-toggler-icon{--bs-navbar-toggler-icon-bg:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 30 30'%3E%3Cpath stroke='rgba(255, 255, 255, 0.55)' stroke-linecap='round' stroke-miterlimit='10' stroke-width='2' d='M4 7h22M4 15h22M4 23h22'/%3E%3C/svg%3E")}.card{--bs-card-spacer-y:1rem;--bs-card-spacer-x:1rem;--bs-card-title-spacer-y:0.5rem;--bs-card-title-color: ;--bs-card-subtitle-color: ;--bs-card-border-width:var(--bs-border-width);--bs-card-border-color:var(--bs-border-color-translucent);--bs-card-border-radius:var(--bs-border-radius);--bs-card-box-shadow: ;--bs-card-inner-border-radius:calc(var(--bs-border-radius) - var(--bs-border-width));--bs-card-cap-padding-y:0.5rem;--bs-card-cap-padding-x:1rem;--bs-card-cap-bg:rgba(var(--bs-body-color-rgb),0.03);--bs-card-cap-color: ;--bs-card-height: ;--bs-card-color: ;--bs-card-bg:var(--bs-body-bg);--bs-card-img-overlay-padding:1rem;--bs-card-group-margin:0.75rem;word-wrap:break-word;background-clip:initial;background-color:var(--bs-card-bg);border:var(--bs-card-border-width) solid var(--bs-card-border-color);border-radius:var(--bs-card-border-radius);color:#212529;color:var(--bs-body-color);display:flex;flex-direction:column;height:var(--bs-card-height);min-width:0;position:relative}.card>hr{margin-left:0;margin-right:0}.card>.list-group{border-bottom:inherit;border-top:inherit}.card>.list-group:first-child{border-top-left-radius:var(--bs-card-inner-border-radius);border-top-right-radius:var(--bs-card-inner-border-radius);border-top-width:0}.card>.list-group:last-child{border-bottom-left-radius:var(--bs-card-inner-border-radius);border-bottom-right-radius:var(--bs-card-inner-border-radius);border-bottom-width:0}.card>.card-header+.list-group,.card>.list-group+.card-footer{border-top:0}.card-body{color:var(--bs-card-color);flex:1 1 auto;padding:var(--bs-card-spacer-y) var(--bs-card-spacer-x)}.card-title{color:var(--bs-card-title-color);margin-bottom:var(--bs-card-title-spacer-y)}.card-subtitle{color:var(--bs-card-subtitle-color);margin-top:calc(var(--bs-card-title-spacer-y)*-.5)}.card-subtitle,.card-text:last-child{margin-bottom:0}.card-link+.card-link{margin-left:var(--bs-card-spacer-x)}.card-header{background-color:var(--bs-card-cap-bg);border-bottom:var(--bs-card-border-width) solid var(--bs-card-border-color);color:var(--bs-card-cap-color);margin-bottom:0;padding:var(--bs-card-cap-padding-y) var(--bs-card-cap-padding-x)}.card-header:first-child{border-radius:var(--bs-card-inner-border-radius) var(--bs-card-inner-border-radius) 0 0}.card-footer{background-color:var(--bs-card-cap-bg);border-top:var(--bs-card-border-width) solid var(--bs-card-border-color);color:var(--bs-card-cap-color);padding:var(--bs-card-cap-padding-y) var(--bs-card-cap-padding-x)}.card-footer:last-child{border-radius:0 0 var(--bs-card-inner-border-radius) var(--bs-card-inner-border-radius)}.card-header-tabs{border-bottom:0;margin-bottom:calc(var(--bs-card-cap-padding-y)*-1);margin-left:calc(var(--bs-card-cap-padding-x)*-.5);margin-right:calc(var(--bs-card-cap-padding-x)*-.5)}.card-header-tabs .nav-link.active{background-color:var(--bs-card-bg);border-bottom-color:var(--bs-card-bg)}.card-header-pills{margin-left:calc(var(--bs-card-cap-padding-x)*-.5);margin-right:calc(var(--bs-card-cap-padding-x)*-.5)}.card-img-overlay{border-radius:var(--bs-card-inner-border-radius);bottom:0;left:0;padding:var(--bs-card-img-overlay-padding);position:absolute;right:0;top:0}.card-img,.card-img-bottom,.card-img-top{width:100%}.card-img,.card-img-top{border-top-left-radius:var(--bs-card-inner-border-radius);border-top-right-radius:var(--bs-card-inner-border-radius)}.card-img,.card-img-bottom{border-bottom-left-radius:var(--bs-card-inner-border-radius);border-bottom-right-radius:var(--bs-card-inner-border-radius)}.card-group>.card{margin-bottom:var(--bs-card-group-margin)}@media (min-width:576px){.card-group{display:flex;flex-flow:row wrap}.card-group>.card{flex:1 0;margin-bottom:0}.card-group>.card+.card{border-left:0;margin-left:0}.card-group>.card:not(:last-child){border-bottom-right-radius:0;border-top-right-radius:0}.card-group>.card:not(:last-child) .card-header,.card-group>.card:not(:last-child) .card-img-top{border-top-right-radius:0}.card-group>.card:not(:last-child) .card-footer,.card-group>.card:not(:last-child) .card-img-bottom{border-bottom-right-radius:0}.card-group>.card:not(:first-child){border-bottom-left-radius:0;border-top-left-radius:0}.card-group>.card:not(:first-child) .card-header,.card-group>.card:not(:first-child) .card-img-top{border-top-left-radius:0}.card-group>.card:not(:first-child) .card-footer,.card-group>.card:not(:first-child) .card-img-bottom{border-bottom-left-radius:0}}.accordion{--bs-accordion-color:var(--bs-body-color);--bs-accordion-bg:var(--bs-body-bg);--bs-accordion-transition:color 0.15s ease-in-out,background-color 0.15s ease-in-out,border-color 0.15s ease-in-out,box-shadow 0.15s ease-in-out,border-radius 0.15s ease;--bs-accordion-border-color:var(--bs-border-color);--bs-accordion-border-width:var(--bs-border-width);--bs-accordion-border-radius:var(--bs-border-radius);--bs-accordion-inner-border-radius:calc(var(--bs-border-radius) - var(--bs-border-width));--bs-accordion-btn-padding-x:1.25rem;--bs-accordion-btn-padding-y:1rem;--bs-accordion-btn-color:var(--bs-body-color);--bs-accordion-btn-bg:var(--bs-accordion-bg);--bs-accordion-btn-icon:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='%23212529'%3E%3Cpath fill-rule='evenodd' d='M1.646 4.646a.5.5 0 0 1 .708 0L8 10.293l5.646-5.647a.5.5 0 0 1 .708.708l-6 6a.5.5 0 0 1-.708 0l-6-6a.5.5 0 0 1 0-.708z'/%3E%3C/svg%3E");--bs-accordion-btn-icon-width:1.25rem;--bs-accordion-btn-icon-transform:rotate(-180deg);--bs-accordion-btn-icon-transition:transform 0.2s ease-in-out;--bs-accordion-btn-active-icon:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='%23052c65'%3E%3Cpath fill-rule='evenodd' d='M1.646 4.646a.5.5 0 0 1 .708 0L8 10.293l5.646-5.647a.5.5 0 0 1 .708.708l-6 6a.5.5 0 0 1-.708 0l-6-6a.5.5 0 0 1 0-.708z'/%3E%3C/svg%3E");--bs-accordion-btn-focus-border-color:#86b7fe;--bs-accordion-btn-focus-box-shadow:0 0 0 0.25rem rgba(13,110,253,.25);--bs-accordion-body-padding-x:1.25rem;--bs-accordion-body-padding-y:1rem;--bs-accordion-active-color:var(--bs-primary-text-emphasis);--bs-accordion-active-bg:var(--bs-primary-bg-subtle)}.accordion-button{align-items:center;background-color:var(--bs-accordion-btn-bg);border:0;border-radius:0;color:var(--bs-accordion-btn-color);display:flex;font-size:1rem;overflow-anchor:none;padding:var(--bs-accordion-btn-padding-y) var(--bs-accordion-btn-padding-x);position:relative;text-align:left;transition:var(--bs-accordion-transition);width:100%}@media (prefers-reduced-motion:reduce){.accordion-button{transition:none}}.accordion-button:not(.collapsed){background-color:var(--bs-accordion-active-bg);box-shadow:inset 0 calc(var(--bs-accordion-border-width)*-1) 0 var(--bs-accordion-border-color);color:var(--bs-accordion-active-color)}.accordion-button:not(.collapsed):after{background-image:var(--bs-accordion-btn-active-icon);-webkit-transform:var(--bs-accordion-btn-icon-transform);transform:var(--bs-accordion-btn-icon-transform)}.accordion-button:after{background-image:var(--bs-accordion-btn-icon);background-repeat:no-repeat;background-size:var(--bs-accordion-btn-icon-width);content:"";flex-shrink:0;height:var(--bs-accordion-btn-icon-width);margin-left:auto;transition:var(--bs-accordion-btn-icon-transition);width:var(--bs-accordion-btn-icon-width)}@media (prefers-reduced-motion:reduce){.accordion-button:after{transition:none}}.accordion-button:hover{z-index:2}.accordion-button:focus{border-color:var(--bs-accordion-btn-focus-border-color);box-shadow:var(--bs-accordion-btn-focus-box-shadow);outline:0;z-index:3}.accordion-header{margin-bottom:0}.accordion-item{background-color:var(--bs-accordion-bg);border:var(--bs-accordion-border-width) solid var(--bs-accordion-border-color);color:var(--bs-accordion-color)}.accordion-item:first-of-type{border-top-left-radius:var(--bs-accordion-border-radius);border-top-right-radius:var(--bs-accordion-border-radius)}.accordion-item:first-of-type .accordion-button{border-top-left-radius:var(--bs-accordion-inner-border-radius);border-top-right-radius:var(--bs-accordion-inner-border-radius)}.accordion-item:not(:first-of-type){border-top:0}.accordion-item:last-of-type{border-bottom-left-radius:var(--bs-accordion-border-radius);border-bottom-right-radius:var(--bs-accordion-border-radius)}.accordion-item:last-of-type .accordion-button.collapsed{border-bottom-left-radius:var(--bs-accordion-inner-border-radius);border-bottom-right-radius:var(--bs-accordion-inner-border-radius)}.accordion-item:last-of-type .accordion-collapse{border-bottom-left-radius:var(--bs-accordion-border-radius);border-bottom-right-radius:var(--bs-accordion-border-radius)}.accordion-body{padding:var(--bs-accordion-body-padding-y) var(--bs-accordion-body-padding-x)}.accordion-flush .accordion-collapse{border-width:0}.accordion-flush .accordion-item{border-left:0;border-radius:0;border-right:0}.accordion-flush .accordion-item:first-child{border-top:0}.accordion-flush .accordion-item:last-child{border-bottom:0}.accordion-flush .accordion-item .accordion-button,.accordion-flush .accordion-item .accordion-button.collapsed{border-radius:0}[data-bs-theme=dark] .accordion-button:after{--bs-accordion-btn-icon:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='%236ea8fe'%3E%3Cpath fill-rule='evenodd' d='M1.646 4.646a.5.5 0 0 1 .708 0L8 10.293l5.646-5.647a.5.5 0 0 1 .708.708l-6 6a.5.5 0 0 1-.708 0l-6-6a.5.5 0 0 1 0-.708z'/%3E%3C/svg%3E");--bs-accordion-btn-active-icon:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='%236ea8fe'%3E%3Cpath fill-rule='evenodd' d='M1.646 4.646a.5.5 0 0 1 .708 0L8 10.293l5.646-5.647a.5.5 0 0 1 .708.708l-6 6a.5.5 0 0 1-.708 0l-6-6a.5.5 0 0 1 0-.708z'/%3E%3C/svg%3E")}.breadcrumb{--bs-breadcrumb-padding-x:0;--bs-breadcrumb-padding-y:0;--bs-breadcrumb-margin-bottom:1rem;--bs-breadcrumb-bg: ;--bs-breadcrumb-border-radius: ;--bs-breadcrumb-divider-color:var(--bs-secondary-color);--bs-breadcrumb-item-padding-x:0.5rem;--bs-breadcrumb-item-active-color:var(--bs-secondary-color);background-color:var(--bs-breadcrumb-bg);border-radius:var(--bs-breadcrumb-border-radius);display:flex;flex-wrap:wrap;font-size:var(--bs-breadcrumb-font-size);list-style:none;margin-bottom:var(--bs-breadcrumb-margin-bottom);padding:var(--bs-breadcrumb-padding-y) var(--bs-breadcrumb-padding-x)}.breadcrumb-item+.breadcrumb-item{padding-left:var(--bs-breadcrumb-item-padding-x)}.breadcrumb-item+.breadcrumb-item:before{color:var(--bs-breadcrumb-divider-color);content:"/";content:var(--bs-breadcrumb-divider,"/");float:left;padding-right:var(--bs-breadcrumb-item-padding-x)}.breadcrumb-item.active{color:var(--bs-breadcrumb-item-active-color)}.pagination{--bs-pagination-padding-x:0.75rem;--bs-pagination-padding-y:0.375rem;--bs-pagination-font-size:1rem;--bs-pagination-color:var(--bs-link-color);--bs-pagination-bg:var(--bs-body-bg);--bs-pagination-border-width:var(--bs-border-width);--bs-pagination-border-color:var(--bs-border-color);--bs-pagination-border-radius:var(--bs-border-radius);--bs-pagination-hover-color:var(--bs-link-hover-color);--bs-pagination-hover-bg:var(--bs-tertiary-bg);--bs-pagination-hover-border-color:var(--bs-border-color);--bs-pagination-focus-color:var(--bs-link-hover-color);--bs-pagination-focus-bg:var(--bs-secondary-bg);--bs-pagination-focus-box-shadow:0 0 0 0.25rem rgba(13,110,253,.25);--bs-pagination-active-color:#fff;--bs-pagination-active-bg:#0d6efd;--bs-pagination-active-border-color:#0d6efd;--bs-pagination-disabled-color:var(--bs-secondary-color);--bs-pagination-disabled-bg:var(--bs-secondary-bg);--bs-pagination-disabled-border-color:var(--bs-border-color);display:flex;list-style:none;padding-left:0}.page-link{background-color:var(--bs-pagination-bg);border:var(--bs-pagination-border-width) solid var(--bs-pagination-border-color);color:var(--bs-pagination-color);display:block;font-size:var(--bs-pagination-font-size);padding:var(--bs-pagination-padding-y) var(--bs-pagination-padding-x);position:relative;text-decoration:none;transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out}@media (prefers-reduced-motion:reduce){.page-link{transition:none}}.page-link:hover{background-color:var(--bs-pagination-hover-bg);border-color:var(--bs-pagination-hover-border-color);color:var(--bs-pagination-hover-color);z-index:2}.page-link:focus{background-color:var(--bs-pagination-focus-bg);box-shadow:var(--bs-pagination-focus-box-shadow);color:var(--bs-pagination-focus-color);outline:0;z-index:3}.active>.page-link,.page-link.active{background-color:var(--bs-pagination-active-bg);border-color:var(--bs-pagination-active-border-color);color:var(--bs-pagination-active-color);z-index:3}.disabled>.page-link,.page-link.disabled{background-color:var(--bs-pagination-disabled-bg);border-color:var(--bs-pagination-disabled-border-color);color:var(--bs-pagination-disabled-color);pointer-events:none}.page-item:not(:first-child) .page-link{margin-left:-1px;margin-left:calc(var(--bs-border-width)*-1)}.page-item:first-child .page-link{border-bottom-left-radius:var(--bs-pagination-border-radius);border-top-left-radius:var(--bs-pagination-border-radius)}.page-item:last-child .page-link{border-bottom-right-radius:var(--bs-pagination-border-radius);border-top-right-radius:var(--bs-pagination-border-radius)}.pagination-lg{--bs-pagination-padding-x:1.5rem;--bs-pagination-padding-y:0.75rem;--bs-pagination-font-size:1.25rem;--bs-pagination-border-radius:var(--bs-border-radius-lg)}.pagination-sm{--bs-pagination-padding-x:0.5rem;--bs-pagination-padding-y:0.25rem;--bs-pagination-font-size:0.875rem;--bs-pagination-border-radius:var(--bs-border-radius-sm)}.badge{--bs-badge-padding-x:0.65em;--bs-badge-padding-y:0.35em;--bs-badge-font-size:0.75em;--bs-badge-font-weight:700;--bs-badge-color:#fff;--bs-badge-border-radius:var(--bs-border-radius);border-radius:var(--bs-badge-border-radius);color:var(--bs-badge-color);display:inline-block;font-size:var(--bs-badge-font-size);font-weight:var(--bs-badge-font-weight);line-height:1;padding:var(--bs-badge-padding-y) var(--bs-badge-padding-x);text-align:center;vertical-align:initial;white-space:nowrap}.badge:empty{display:none}.btn .badge{position:relative;top:-1px}.alert{--bs-alert-bg:transparent;--bs-alert-padding-x:1rem;--bs-alert-padding-y:1rem;--bs-alert-margin-bottom:1rem;--bs-alert-color:inherit;--bs-alert-border-color:transparent;--bs-alert-border:var(--bs-border-width) solid var(--bs-alert-border-color);--bs-alert-border-radius:var(--bs-border-radius);--bs-alert-link-color:inherit;background-color:var(--bs-alert-bg);border:var(--bs-alert-border);border-radius:var(--bs-alert-border-radius);color:var(--bs-alert-color);margin-bottom:var(--bs-alert-margin-bottom);padding:var(--bs-alert-padding-y) var(--bs-alert-padding-x);position:relative}.alert-heading{color:inherit}.alert-link{color:var(--bs-alert-link-color);font-weight:700}.alert-dismissible{padding-right:3rem}.alert-dismissible .btn-close{padding:1.25rem 1rem;position:absolute;right:0;top:0;z-index:2}.alert-primary{--bs-alert-color:var(--bs-primary-text-emphasis);--bs-alert-bg:var(--bs-primary-bg-subtle);--bs-alert-border-color:var(--bs-primary-border-subtle);--bs-alert-link-color:var(--bs-primary-text-emphasis)}.alert-secondary{--bs-alert-color:var(--bs-secondary-text-emphasis);--bs-alert-bg:var(--bs-secondary-bg-subtle);--bs-alert-border-color:var(--bs-secondary-border-subtle);--bs-alert-link-color:var(--bs-secondary-text-emphasis)}.alert-success{--bs-alert-color:var(--bs-success-text-emphasis);--bs-alert-bg:var(--bs-success-bg-subtle);--bs-alert-border-color:var(--bs-success-border-subtle);--bs-alert-link-color:var(--bs-success-text-emphasis)}.alert-info{--bs-alert-color:var(--bs-info-text-emphasis);--bs-alert-bg:var(--bs-info-bg-subtle);--bs-alert-border-color:var(--bs-info-border-subtle);--bs-alert-link-color:var(--bs-info-text-emphasis)}.alert-warning{--bs-alert-color:var(--bs-warning-text-emphasis);--bs-alert-bg:var(--bs-warning-bg-subtle);--bs-alert-border-color:var(--bs-warning-border-subtle);--bs-alert-link-color:var(--bs-warning-text-emphasis)}.alert-danger{--bs-alert-color:var(--bs-danger-text-emphasis);--bs-alert-bg:var(--bs-danger-bg-subtle);--bs-alert-border-color:var(--bs-danger-border-subtle);--bs-alert-link-color:var(--bs-danger-text-emphasis)}.alert-light{--bs-alert-color:var(--bs-light-text-emphasis);--bs-alert-bg:var(--bs-light-bg-subtle);--bs-alert-border-color:var(--bs-light-border-subtle);--bs-alert-link-color:var(--bs-light-text-emphasis)}.alert-dark{--bs-alert-color:var(--bs-dark-text-emphasis);--bs-alert-bg:var(--bs-dark-bg-subtle);--bs-alert-border-color:var(--bs-dark-border-subtle);--bs-alert-link-color:var(--bs-dark-text-emphasis)}@-webkit-keyframes progress-bar-stripes{0%{background-position-x:1rem}}@keyframes progress-bar-stripes{0%{background-position-x:1rem}}.progress,.progress-stacked{--bs-progress-height:1rem;--bs-progress-font-size:0.75rem;--bs-progress-bg:var(--bs-secondary-bg);--bs-progress-border-radius:var(--bs-border-radius);--bs-progress-box-shadow:var(--bs-box-shadow-inset);--bs-progress-bar-color:#fff;--bs-progress-bar-bg:#0d6efd;--bs-progress-bar-transition:width 0.6s ease;background-color:var(--bs-progress-bg);border-radius:var(--bs-progress-border-radius);display:flex;font-size:var(--bs-progress-font-size);height:var(--bs-progress-height);overflow:hidden}.progress-bar{background-color:var(--bs-progress-bar-bg);color:var(--bs-progress-bar-color);display:flex;flex-direction:column;justify-content:center;overflow:hidden;text-align:center;transition:var(--bs-progress-bar-transition);white-space:nowrap}@media (prefers-reduced-motion:reduce){.progress-bar{transition:none}}.progress-bar-striped{background-image:linear-gradient(45deg,hsla(0,0%,100%,.15) 25%,transparent 0,transparent 50%,hsla(0,0%,100%,.15) 0,hsla(0,0%,100%,.15) 75%,transparent 0,transparent);background-size:var(--bs-progress-height) var(--bs-progress-height)}.progress-stacked>.progress{overflow:visible}.progress-stacked>.progress>.progress-bar{width:100%}.progress-bar-animated{-webkit-animation:progress-bar-stripes 1s linear infinite;animation:progress-bar-stripes 1s linear infinite}@media (prefers-reduced-motion:reduce){.progress-bar-animated{-webkit-animation:none;animation:none}}.list-group{--bs-list-group-color:var(--bs-body-color);--bs-list-group-bg:var(--bs-body-bg);--bs-list-group-border-color:var(--bs-border-color);--bs-list-group-border-width:var(--bs-border-width);--bs-list-group-border-radius:var(--bs-border-radius);--bs-list-group-item-padding-x:1rem;--bs-list-group-item-padding-y:0.5rem;--bs-list-group-action-color:var(--bs-secondary-color);--bs-list-group-action-hover-color:var(--bs-emphasis-color);--bs-list-group-action-hover-bg:var(--bs-tertiary-bg);--bs-list-group-action-active-color:var(--bs-body-color);--bs-list-group-action-active-bg:var(--bs-secondary-bg);--bs-list-group-disabled-color:var(--bs-secondary-color);--bs-list-group-disabled-bg:var(--bs-body-bg);--bs-list-group-active-color:#fff;--bs-list-group-active-bg:#0d6efd;--bs-list-group-active-border-color:#0d6efd;border-radius:var(--bs-list-group-border-radius);display:flex;flex-direction:column;margin-bottom:0;padding-left:0}.list-group-numbered{counter-reset:section;list-style-type:none}.list-group-numbered>.list-group-item:before{content:counters(section,".") ". ";counter-increment:section}.list-group-item-action{color:var(--bs-list-group-action-color);text-align:inherit;width:100%}.list-group-item-action:focus,.list-group-item-action:hover{background-color:var(--bs-list-group-action-hover-bg);color:var(--bs-list-group-action-hover-color);text-decoration:none;z-index:1}.list-group-item-action:active{background-color:var(--bs-list-group-action-active-bg);color:var(--bs-list-group-action-active-color)}.list-group-item{background-color:var(--bs-list-group-bg);border:var(--bs-list-group-border-width) solid var(--bs-list-group-border-color);color:var(--bs-list-group-color);display:block;padding:var(--bs-list-group-item-padding-y) var(--bs-list-group-item-padding-x);position:relative;text-decoration:none}.list-group-item:first-child{border-top-left-radius:inherit;border-top-right-radius:inherit}.list-group-item:last-child{border-bottom-left-radius:inherit;border-bottom-right-radius:inherit}.list-group-item.disabled,.list-group-item:disabled{background-color:var(--bs-list-group-disabled-bg);color:var(--bs-list-group-disabled-color);pointer-events:none}.list-group-item.active{background-color:var(--bs-list-group-active-bg);border-color:var(--bs-list-group-active-border-color);color:var(--bs-list-group-active-color);z-index:2}.list-group-item+.list-group-item{border-top-width:0}.list-group-item+.list-group-item.active{border-top-width:var(--bs-list-group-border-width);margin-top:calc(var(--bs-list-group-border-width)*-1)}.list-group-horizontal{flex-direction:row}.list-group-horizontal>.list-group-item:first-child:not(:last-child){border-bottom-left-radius:var(--bs-list-group-border-radius);border-top-right-radius:0}.list-group-horizontal>.list-group-item:last-child:not(:first-child){border-bottom-left-radius:0;border-top-right-radius:var(--bs-list-group-border-radius)}.list-group-horizontal>.list-group-item.active{margin-top:0}.list-group-horizontal>.list-group-item+.list-group-item{border-left-width:0;border-top-width:var(--bs-list-group-border-width)}.list-group-horizontal>.list-group-item+.list-group-item.active{border-left-width:var(--bs-list-group-border-width);margin-left:calc(var(--bs-list-group-border-width)*-1)}@media (min-width:576px){.list-group-horizontal-sm{flex-direction:row}.list-group-horizontal-sm>.list-group-item:first-child:not(:last-child){border-bottom-left-radius:var(--bs-list-group-border-radius);border-top-right-radius:0}.list-group-horizontal-sm>.list-group-item:last-child:not(:first-child){border-bottom-left-radius:0;border-top-right-radius:var(--bs-list-group-border-radius)}.list-group-horizontal-sm>.list-group-item.active{margin-top:0}.list-group-horizontal-sm>.list-group-item+.list-group-item{border-left-width:0;border-top-width:var(--bs-list-group-border-width)}.list-group-horizontal-sm>.list-group-item+.list-group-item.active{border-left-width:var(--bs-list-group-border-width);margin-left:calc(var(--bs-list-group-border-width)*-1)}}@media (min-width:768px){.list-group-horizontal-md{flex-direction:row}.list-group-horizontal-md>.list-group-item:first-child:not(:last-child){border-bottom-left-radius:var(--bs-list-group-border-radius);border-top-right-radius:0}.list-group-horizontal-md>.list-group-item:last-child:not(:first-child){border-bottom-left-radius:0;border-top-right-radius:var(--bs-list-group-border-radius)}.list-group-horizontal-md>.list-group-item.active{margin-top:0}.list-group-horizontal-md>.list-group-item+.list-group-item{border-left-width:0;border-top-width:var(--bs-list-group-border-width)}.list-group-horizontal-md>.list-group-item+.list-group-item.active{border-left-width:var(--bs-list-group-border-width);margin-left:calc(var(--bs-list-group-border-width)*-1)}}@media (min-width:992px){.list-group-horizontal-lg{flex-direction:row}.list-group-horizontal-lg>.list-group-item:first-child:not(:last-child){border-bottom-left-radius:var(--bs-list-group-border-radius);border-top-right-radius:0}.list-group-horizontal-lg>.list-group-item:last-child:not(:first-child){border-bottom-left-radius:0;border-top-right-radius:var(--bs-list-group-border-radius)}.list-group-horizontal-lg>.list-group-item.active{margin-top:0}.list-group-horizontal-lg>.list-group-item+.list-group-item{border-left-width:0;border-top-width:var(--bs-list-group-border-width)}.list-group-horizontal-lg>.list-group-item+.list-group-item.active{border-left-width:var(--bs-list-group-border-width);margin-left:calc(var(--bs-list-group-border-width)*-1)}}@media (min-width:1200px){.list-group-horizontal-xl{flex-direction:row}.list-group-horizontal-xl>.list-group-item:first-child:not(:last-child){border-bottom-left-radius:var(--bs-list-group-border-radius);border-top-right-radius:0}.list-group-horizontal-xl>.list-group-item:last-child:not(:first-child){border-bottom-left-radius:0;border-top-right-radius:var(--bs-list-group-border-radius)}.list-group-horizontal-xl>.list-group-item.active{margin-top:0}.list-group-horizontal-xl>.list-group-item+.list-group-item{border-left-width:0;border-top-width:var(--bs-list-group-border-width)}.list-group-horizontal-xl>.list-group-item+.list-group-item.active{border-left-width:var(--bs-list-group-border-width);margin-left:calc(var(--bs-list-group-border-width)*-1)}}@media (min-width:1400px){.list-group-horizontal-xxl{flex-direction:row}.list-group-horizontal-xxl>.list-group-item:first-child:not(:last-child){border-bottom-left-radius:var(--bs-list-group-border-radius);border-top-right-radius:0}.list-group-horizontal-xxl>.list-group-item:last-child:not(:first-child){border-bottom-left-radius:0;border-top-right-radius:var(--bs-list-group-border-radius)}.list-group-horizontal-xxl>.list-group-item.active{margin-top:0}.list-group-horizontal-xxl>.list-group-item+.list-group-item{border-left-width:0;border-top-width:var(--bs-list-group-border-width)}.list-group-horizontal-xxl>.list-group-item+.list-group-item.active{border-left-width:var(--bs-list-group-border-width);margin-left:calc(var(--bs-list-group-border-width)*-1)}}.list-group-flush{border-radius:0}.list-group-flush>.list-group-item{border-width:0 0 var(--bs-list-group-border-width)}.list-group-flush>.list-group-item:last-child{border-bottom-width:0}.list-group-item-primary{--bs-list-group-color:var(--bs-primary-text-emphasis);--bs-list-group-bg:var(--bs-primary-bg-subtle);--bs-list-group-border-color:var(--bs-primary-border-subtle);--bs-list-group-action-hover-color:var(--bs-emphasis-color);--bs-list-group-action-hover-bg:var(--bs-primary-border-subtle);--bs-list-group-action-active-color:var(--bs-emphasis-color);--bs-list-group-action-active-bg:var(--bs-primary-border-subtle);--bs-list-group-active-color:var(--bs-primary-bg-subtle);--bs-list-group-active-bg:var(--bs-primary-text-emphasis);--bs-list-group-active-border-color:var(--bs-primary-text-emphasis)}.list-group-item-secondary{--bs-list-group-color:var(--bs-secondary-text-emphasis);--bs-list-group-bg:var(--bs-secondary-bg-subtle);--bs-list-group-border-color:var(--bs-secondary-border-subtle);--bs-list-group-action-hover-color:var(--bs-emphasis-color);--bs-list-group-action-hover-bg:var(--bs-secondary-border-subtle);--bs-list-group-action-active-color:var(--bs-emphasis-color);--bs-list-group-action-active-bg:var(--bs-secondary-border-subtle);--bs-list-group-active-color:var(--bs-secondary-bg-subtle);--bs-list-group-active-bg:var(--bs-secondary-text-emphasis);--bs-list-group-active-border-color:var(--bs-secondary-text-emphasis)}.list-group-item-success{--bs-list-group-color:var(--bs-success-text-emphasis);--bs-list-group-bg:var(--bs-success-bg-subtle);--bs-list-group-border-color:var(--bs-success-border-subtle);--bs-list-group-action-hover-color:var(--bs-emphasis-color);--bs-list-group-action-hover-bg:var(--bs-success-border-subtle);--bs-list-group-action-active-color:var(--bs-emphasis-color);--bs-list-group-action-active-bg:var(--bs-success-border-subtle);--bs-list-group-active-color:var(--bs-success-bg-subtle);--bs-list-group-active-bg:var(--bs-success-text-emphasis);--bs-list-group-active-border-color:var(--bs-success-text-emphasis)}.list-group-item-info{--bs-list-group-color:var(--bs-info-text-emphasis);--bs-list-group-bg:var(--bs-info-bg-subtle);--bs-list-group-border-color:var(--bs-info-border-subtle);--bs-list-group-action-hover-color:var(--bs-emphasis-color);--bs-list-group-action-hover-bg:var(--bs-info-border-subtle);--bs-list-group-action-active-color:var(--bs-emphasis-color);--bs-list-group-action-active-bg:var(--bs-info-border-subtle);--bs-list-group-active-color:var(--bs-info-bg-subtle);--bs-list-group-active-bg:var(--bs-info-text-emphasis);--bs-list-group-active-border-color:var(--bs-info-text-emphasis)}.list-group-item-warning{--bs-list-group-color:var(--bs-warning-text-emphasis);--bs-list-group-bg:var(--bs-warning-bg-subtle);--bs-list-group-border-color:var(--bs-warning-border-subtle);--bs-list-group-action-hover-color:var(--bs-emphasis-color);--bs-list-group-action-hover-bg:var(--bs-warning-border-subtle);--bs-list-group-action-active-color:var(--bs-emphasis-color);--bs-list-group-action-active-bg:var(--bs-warning-border-subtle);--bs-list-group-active-color:var(--bs-warning-bg-subtle);--bs-list-group-active-bg:var(--bs-warning-text-emphasis);--bs-list-group-active-border-color:var(--bs-warning-text-emphasis)}.list-group-item-danger{--bs-list-group-color:var(--bs-danger-text-emphasis);--bs-list-group-bg:var(--bs-danger-bg-subtle);--bs-list-group-border-color:var(--bs-danger-border-subtle);--bs-list-group-action-hover-color:var(--bs-emphasis-color);--bs-list-group-action-hover-bg:var(--bs-danger-border-subtle);--bs-list-group-action-active-color:var(--bs-emphasis-color);--bs-list-group-action-active-bg:var(--bs-danger-border-subtle);--bs-list-group-active-color:var(--bs-danger-bg-subtle);--bs-list-group-active-bg:var(--bs-danger-text-emphasis);--bs-list-group-active-border-color:var(--bs-danger-text-emphasis)}.list-group-item-light{--bs-list-group-color:var(--bs-light-text-emphasis);--bs-list-group-bg:var(--bs-light-bg-subtle);--bs-list-group-border-color:var(--bs-light-border-subtle);--bs-list-group-action-hover-color:var(--bs-emphasis-color);--bs-list-group-action-hover-bg:var(--bs-light-border-subtle);--bs-list-group-action-active-color:var(--bs-emphasis-color);--bs-list-group-action-active-bg:var(--bs-light-border-subtle);--bs-list-group-active-color:var(--bs-light-bg-subtle);--bs-list-group-active-bg:var(--bs-light-text-emphasis);--bs-list-group-active-border-color:var(--bs-light-text-emphasis)}.list-group-item-dark{--bs-list-group-color:var(--bs-dark-text-emphasis);--bs-list-group-bg:var(--bs-dark-bg-subtle);--bs-list-group-border-color:var(--bs-dark-border-subtle);--bs-list-group-action-hover-color:var(--bs-emphasis-color);--bs-list-group-action-hover-bg:var(--bs-dark-border-subtle);--bs-list-group-action-active-color:var(--bs-emphasis-color);--bs-list-group-action-active-bg:var(--bs-dark-border-subtle);--bs-list-group-active-color:var(--bs-dark-bg-subtle);--bs-list-group-active-bg:var(--bs-dark-text-emphasis);--bs-list-group-active-border-color:var(--bs-dark-text-emphasis)}.btn-close{--bs-btn-close-color:#000;--bs-btn-close-bg:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3E%3Cpath d='M.293.293a1 1 0 0 1 1.414 0L8 6.586 14.293.293a1 1 0 1 1 1.414 1.414L9.414 8l6.293 6.293a1 1 0 0 1-1.414 1.414L8 9.414l-6.293 6.293a1 1 0 0 1-1.414-1.414L6.586 8 .293 1.707a1 1 0 0 1 0-1.414z'/%3E%3C/svg%3E");--bs-btn-close-opacity:0.5;--bs-btn-close-hover-opacity:0.75;--bs-btn-close-focus-shadow:0 0 0 0.25rem rgba(13,110,253,.25);--bs-btn-close-focus-opacity:1;--bs-btn-close-disabled-opacity:0.25;--bs-btn-close-white-filter:invert(1) grayscale(100%) brightness(200%);background:transparent var(--bs-btn-close-bg) center/1em auto no-repeat;border:0;border-radius:.375rem;box-sizing:initial;height:1em;opacity:var(--bs-btn-close-opacity);padding:.25em;width:1em}.btn-close,.btn-close:hover{color:var(--bs-btn-close-color)}.btn-close:hover{opacity:var(--bs-btn-close-hover-opacity);text-decoration:none}.btn-close:focus{box-shadow:var(--bs-btn-close-focus-shadow);opacity:var(--bs-btn-close-focus-opacity);outline:0}.btn-close.disabled,.btn-close:disabled{opacity:var(--bs-btn-close-disabled-opacity);pointer-events:none;-webkit-user-select:none;user-select:none}.btn-close-white,[data-bs-theme=dark] .btn-close{-webkit-filter:var(--bs-btn-close-white-filter);filter:var(--bs-btn-close-white-filter)}.toast{--bs-toast-zindex:1090;--bs-toast-padding-x:0.75rem;--bs-toast-padding-y:0.5rem;--bs-toast-spacing:1.5rem;--bs-toast-max-width:350px;--bs-toast-font-size:0.875rem;--bs-toast-color: ;--bs-toast-bg:rgba(var(--bs-body-bg-rgb),0.85);--bs-toast-border-width:var(--bs-border-width);--bs-toast-border-color:var(--bs-border-color-translucent);--bs-toast-border-radius:var(--bs-border-radius);--bs-toast-box-shadow:var(--bs-box-shadow);--bs-toast-header-color:var(--bs-secondary-color);--bs-toast-header-bg:rgba(var(--bs-body-bg-rgb),0.85);--bs-toast-header-border-color:var(--bs-border-color-translucent);background-clip:padding-box;background-color:var(--bs-toast-bg);border:var(--bs-toast-border-width) solid var(--bs-toast-border-color);border-radius:var(--bs-toast-border-radius);box-shadow:var(--bs-toast-box-shadow);color:var(--bs-toast-color);font-size:var(--bs-toast-font-size);max-width:100%;pointer-events:auto;width:var(--bs-toast-max-width)}.toast.showing{opacity:0}.toast:not(.show){display:none}.toast-container{--bs-toast-zindex:1090;max-width:100%;pointer-events:none;position:absolute;width:-webkit-max-content;width:max-content;z-index:var(--bs-toast-zindex)}.toast-container>:not(:last-child){margin-bottom:var(--bs-toast-spacing)}.toast-header{align-items:center;background-clip:padding-box;background-color:var(--bs-toast-header-bg);border-bottom:var(--bs-toast-border-width) solid var(--bs-toast-header-border-color);border-top-left-radius:calc(var(--bs-toast-border-radius) - var(--bs-toast-border-width));border-top-right-radius:calc(var(--bs-toast-border-radius) - var(--bs-toast-border-width));color:var(--bs-toast-header-color);display:flex;padding:var(--bs-toast-padding-y) var(--bs-toast-padding-x)}.toast-header .btn-close{margin-left:var(--bs-toast-padding-x);margin-right:calc(var(--bs-toast-padding-x)*-.5)}.toast-body{word-wrap:break-word;padding:var(--bs-toast-padding-x)}.modal{--bs-modal-zindex:1055;--bs-modal-width:500px;--bs-modal-padding:1rem;--bs-modal-margin:0.5rem;--bs-modal-color: ;--bs-modal-bg:var(--bs-body-bg);--bs-modal-border-color:var(--bs-border-color-translucent);--bs-modal-border-width:var(--bs-border-width);--bs-modal-border-radius:var(--bs-border-radius-lg);--bs-modal-box-shadow:var(--bs-box-shadow-sm);--bs-modal-inner-border-radius:calc(var(--bs-border-radius-lg) - var(--bs-border-width));--bs-modal-header-padding-x:1rem;--bs-modal-header-padding-y:1rem;--bs-modal-header-padding:1rem 1rem;--bs-modal-header-border-color:var(--bs-border-color);--bs-modal-header-border-width:var(--bs-border-width);--bs-modal-title-line-height:1.5;--bs-modal-footer-gap:0.5rem;--bs-modal-footer-bg: ;--bs-modal-footer-border-color:var(--bs-border-color);--bs-modal-footer-border-width:var(--bs-border-width);display:none;height:100%;left:0;outline:0;overflow-x:hidden;overflow-y:auto;position:fixed;top:0;width:100%;z-index:var(--bs-modal-zindex)}.modal-dialog{margin:var(--bs-modal-margin);pointer-events:none;position:relative;width:auto}.modal.fade .modal-dialog{-webkit-transform:translateY(-50px);transform:translateY(-50px);transition:-webkit-transform .3s ease-out;transition:transform .3s ease-out;transition:transform .3s ease-out,-webkit-transform .3s ease-out}@media (prefers-reduced-motion:reduce){.modal.fade .modal-dialog{transition:none}}.modal.show .modal-dialog{-webkit-transform:none;transform:none}.modal.modal-static .modal-dialog{-webkit-transform:scale(1.02);transform:scale(1.02)}.modal-dialog-scrollable{height:calc(100% - var(--bs-modal-margin)*2)}.modal-dialog-scrollable .modal-content{max-height:100%;overflow:hidden}.modal-dialog-scrollable .modal-body{overflow-y:auto}.modal-dialog-centered{align-items:center;display:flex;min-height:calc(100% - var(--bs-modal-margin)*2)}.modal-content{background-clip:padding-box;background-color:var(--bs-modal-bg);border:var(--bs-modal-border-width) solid var(--bs-modal-border-color);border-radius:var(--bs-modal-border-radius);color:var(--bs-modal-color);display:flex;flex-direction:column;outline:0;pointer-events:auto;position:relative;width:100%}.modal-backdrop{--bs-backdrop-zindex:1050;--bs-backdrop-bg:#000;--bs-backdrop-opacity:0.5;background-color:var(--bs-backdrop-bg);height:100vh;left:0;position:fixed;top:0;width:100vw;z-index:var(--bs-backdrop-zindex)}.modal-backdrop.fade{opacity:0}.modal-backdrop.show{opacity:var(--bs-backdrop-opacity)}.modal-header{align-items:center;border-bottom:var(--bs-modal-header-border-width) solid var(--bs-modal-header-border-color);border-top-left-radius:var(--bs-modal-inner-border-radius);border-top-right-radius:var(--bs-modal-inner-border-radius);display:flex;flex-shrink:0;justify-content:space-between;padding:var(--bs-modal-header-padding)}.modal-header .btn-close{margin:calc(var(--bs-modal-header-padding-y)*-.5) calc(var(--bs-modal-header-padding-x)*-.5) calc(var(--bs-modal-header-padding-y)*-.5) auto;padding:calc(var(--bs-modal-header-padding-y)*.5) calc(var(--bs-modal-header-padding-x)*.5)}.modal-title{line-height:var(--bs-modal-title-line-height);margin-bottom:0}.modal-body{flex:1 1 auto;padding:var(--bs-modal-padding);position:relative}.modal-footer{align-items:center;background-color:var(--bs-modal-footer-bg);border-bottom-left-radius:var(--bs-modal-inner-border-radius);border-bottom-right-radius:var(--bs-modal-inner-border-radius);border-top:var(--bs-modal-footer-border-width) solid var(--bs-modal-footer-border-color);display:flex;flex-shrink:0;flex-wrap:wrap;justify-content:flex-end;padding:calc(var(--bs-modal-padding) - var(--bs-modal-footer-gap)*.5)}.modal-footer>*{margin:calc(var(--bs-modal-footer-gap)*.5)}@media (min-width:576px){.modal{--bs-modal-margin:1.75rem;--bs-modal-box-shadow:var(--bs-box-shadow)}.modal-dialog{margin-left:auto;margin-right:auto;max-width:var(--bs-modal-width)}.modal-sm{--bs-modal-width:300px}}@media (min-width:992px){.modal-lg,.modal-xl{--bs-modal-width:800px}}@media (min-width:1200px){.modal-xl{--bs-modal-width:1140px}}.modal-fullscreen{height:100%;margin:0;max-width:none;width:100vw}.modal-fullscreen .modal-content{border:0;border-radius:0;height:100%}.modal-fullscreen .modal-footer,.modal-fullscreen .modal-header{border-radius:0}.modal-fullscreen .modal-body{overflow-y:auto}@media (max-width:575.98px){.modal-fullscreen-sm-down{height:100%;margin:0;max-width:none;width:100vw}.modal-fullscreen-sm-down .modal-content{border:0;border-radius:0;height:100%}.modal-fullscreen-sm-down .modal-footer,.modal-fullscreen-sm-down .modal-header{border-radius:0}.modal-fullscreen-sm-down .modal-body{overflow-y:auto}}@media (max-width:767.98px){.modal-fullscreen-md-down{height:100%;margin:0;max-width:none;width:100vw}.modal-fullscreen-md-down .modal-content{border:0;border-radius:0;height:100%}.modal-fullscreen-md-down .modal-footer,.modal-fullscreen-md-down .modal-header{border-radius:0}.modal-fullscreen-md-down .modal-body{overflow-y:auto}}@media (max-width:991.98px){.modal-fullscreen-lg-down{height:100%;margin:0;max-width:none;width:100vw}.modal-fullscreen-lg-down .modal-content{border:0;border-radius:0;height:100%}.modal-fullscreen-lg-down .modal-footer,.modal-fullscreen-lg-down .modal-header{border-radius:0}.modal-fullscreen-lg-down .modal-body{overflow-y:auto}}@media (max-width:1199.98px){.modal-fullscreen-xl-down{height:100%;margin:0;max-width:none;width:100vw}.modal-fullscreen-xl-down .modal-content{border:0;border-radius:0;height:100%}.modal-fullscreen-xl-down .modal-footer,.modal-fullscreen-xl-down .modal-header{border-radius:0}.modal-fullscreen-xl-down .modal-body{overflow-y:auto}}@media (max-width:1399.98px){.modal-fullscreen-xxl-down{height:100%;margin:0;max-width:none;width:100vw}.modal-fullscreen-xxl-down .modal-content{border:0;border-radius:0;height:100%}.modal-fullscreen-xxl-down .modal-footer,.modal-fullscreen-xxl-down .modal-header{border-radius:0}.modal-fullscreen-xxl-down .modal-body{overflow-y:auto}}.tooltip{--bs-tooltip-zindex:1080;--bs-tooltip-max-width:200px;--bs-tooltip-padding-x:0.5rem;--bs-tooltip-padding-y:0.25rem;--bs-tooltip-margin: ;--bs-tooltip-font-size:0.875rem;--bs-tooltip-color:var(--bs-body-bg);--bs-tooltip-bg:var(--bs-emphasis-color);--bs-tooltip-border-radius:var(--bs-border-radius);--bs-tooltip-opacity:0.9;--bs-tooltip-arrow-width:0.8rem;--bs-tooltip-arrow-height:0.4rem;word-wrap:break-word;display:block;font-family:system-ui,-apple-system,Segoe UI,Roboto,Helvetica Neue,Noto Sans,Liberation Sans,Arial,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol,Noto Color Emoji;font-family:var(--bs-font-sans-serif);font-size:var(--bs-tooltip-font-size);font-style:normal;font-weight:400;letter-spacing:normal;line-break:auto;line-height:1.5;margin:var(--bs-tooltip-margin);opacity:0;text-align:left;text-align:start;text-decoration:none;text-shadow:none;text-transform:none;white-space:normal;word-break:normal;word-spacing:normal;z-index:var(--bs-tooltip-zindex)}.tooltip.show{opacity:var(--bs-tooltip-opacity)}.tooltip .tooltip-arrow{display:block;height:var(--bs-tooltip-arrow-height);width:var(--bs-tooltip-arrow-width)}.tooltip .tooltip-arrow:before{border-color:transparent;border-style:solid;content:"";position:absolute}.bs-tooltip-auto[data-popper-placement^=top] .tooltip-arrow,.bs-tooltip-top .tooltip-arrow{bottom:calc(var(--bs-tooltip-arrow-height)*-1)}.bs-tooltip-auto[data-popper-placement^=top] .tooltip-arrow:before,.bs-tooltip-top .tooltip-arrow:before{border-top-color:var(--bs-tooltip-bg);border-width:var(--bs-tooltip-arrow-height) calc(var(--bs-tooltip-arrow-width)*.5) 0;top:-1px}.bs-tooltip-auto[data-popper-placement^=right] .tooltip-arrow,.bs-tooltip-end .tooltip-arrow{height:var(--bs-tooltip-arrow-width);left:calc(var(--bs-tooltip-arrow-height)*-1);width:var(--bs-tooltip-arrow-height)}.bs-tooltip-auto[data-popper-placement^=right] .tooltip-arrow:before,.bs-tooltip-end .tooltip-arrow:before{border-right-color:var(--bs-tooltip-bg);border-width:calc(var(--bs-tooltip-arrow-width)*.5) var(--bs-tooltip-arrow-height) calc(var(--bs-tooltip-arrow-width)*.5) 0;right:-1px}.bs-tooltip-auto[data-popper-placement^=bottom] .tooltip-arrow,.bs-tooltip-bottom .tooltip-arrow{top:calc(var(--bs-tooltip-arrow-height)*-1)}.bs-tooltip-auto[data-popper-placement^=bottom] .tooltip-arrow:before,.bs-tooltip-bottom .tooltip-arrow:before{border-bottom-color:var(--bs-tooltip-bg);border-width:0 calc(var(--bs-tooltip-arrow-width)*.5) var(--bs-tooltip-arrow-height);bottom:-1px}.bs-tooltip-auto[data-popper-placement^=left] .tooltip-arrow,.bs-tooltip-start .tooltip-arrow{height:var(--bs-tooltip-arrow-width);right:calc(var(--bs-tooltip-arrow-height)*-1);width:var(--bs-tooltip-arrow-height)}.bs-tooltip-auto[data-popper-placement^=left] .tooltip-arrow:before,.bs-tooltip-start .tooltip-arrow:before{border-left-color:var(--bs-tooltip-bg);border-width:calc(var(--bs-tooltip-arrow-width)*.5) 0 calc(var(--bs-tooltip-arrow-width)*.5) var(--bs-tooltip-arrow-height);left:-1px}.tooltip-inner{background-color:var(--bs-tooltip-bg);border-radius:var(--bs-tooltip-border-radius);color:var(--bs-tooltip-color);max-width:var(--bs-tooltip-max-width);padding:var(--bs-tooltip-padding-y) var(--bs-tooltip-padding-x);text-align:center}.popover{--bs-popover-zindex:1070;--bs-popover-max-width:276px;--bs-popover-font-size:0.875rem;--bs-popover-bg:var(--bs-body-bg);--bs-popover-border-width:var(--bs-border-width);--bs-popover-border-color:var(--bs-border-color-translucent);--bs-popover-border-radius:var(--bs-border-radius-lg);--bs-popover-inner-border-radius:calc(var(--bs-border-radius-lg) - var(--bs-border-width));--bs-popover-box-shadow:var(--bs-box-shadow);--bs-popover-header-padding-x:1rem;--bs-popover-header-padding-y:0.5rem;--bs-popover-header-font-size:1rem;--bs-popover-header-color:inherit;--bs-popover-header-bg:var(--bs-secondary-bg);--bs-popover-body-padding-x:1rem;--bs-popover-body-padding-y:1rem;--bs-popover-body-color:var(--bs-body-color);--bs-popover-arrow-width:1rem;--bs-popover-arrow-height:0.5rem;--bs-popover-arrow-border:var(--bs-popover-border-color);word-wrap:break-word;background-clip:padding-box;background-color:var(--bs-popover-bg);border:var(--bs-popover-border-width) solid var(--bs-popover-border-color);border-radius:var(--bs-popover-border-radius);display:block;font-family:system-ui,-apple-system,Segoe UI,Roboto,Helvetica Neue,Noto Sans,Liberation Sans,Arial,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol,Noto Color Emoji;font-family:var(--bs-font-sans-serif);font-size:var(--bs-popover-font-size);font-style:normal;font-weight:400;letter-spacing:normal;line-break:auto;line-height:1.5;max-width:var(--bs-popover-max-width);text-align:left;text-align:start;text-decoration:none;text-shadow:none;text-transform:none;white-space:normal;word-break:normal;word-spacing:normal;z-index:var(--bs-popover-zindex)}.popover .popover-arrow{display:block;height:var(--bs-popover-arrow-height);width:var(--bs-popover-arrow-width)}.popover .popover-arrow:after,.popover .popover-arrow:before{border:0 solid transparent;content:"";display:block;position:absolute}.bs-popover-auto[data-popper-placement^=top]>.popover-arrow,.bs-popover-top>.popover-arrow{bottom:calc((var(--bs-popover-arrow-height))*-1 - var(--bs-popover-border-width))}.bs-popover-auto[data-popper-placement^=top]>.popover-arrow:after,.bs-popover-auto[data-popper-placement^=top]>.popover-arrow:before,.bs-popover-top>.popover-arrow:after,.bs-popover-top>.popover-arrow:before{border-width:var(--bs-popover-arrow-height) calc(var(--bs-popover-arrow-width)*.5) 0}.bs-popover-auto[data-popper-placement^=top]>.popover-arrow:before,.bs-popover-top>.popover-arrow:before{border-top-color:var(--bs-popover-arrow-border);bottom:0}.bs-popover-auto[data-popper-placement^=top]>.popover-arrow:after,.bs-popover-top>.popover-arrow:after{border-top-color:var(--bs-popover-bg);bottom:var(--bs-popover-border-width)}.bs-popover-auto[data-popper-placement^=right]>.popover-arrow,.bs-popover-end>.popover-arrow{height:var(--bs-popover-arrow-width);left:calc((var(--bs-popover-arrow-height))*-1 - var(--bs-popover-border-width));width:var(--bs-popover-arrow-height)}.bs-popover-auto[data-popper-placement^=right]>.popover-arrow:after,.bs-popover-auto[data-popper-placement^=right]>.popover-arrow:before,.bs-popover-end>.popover-arrow:after,.bs-popover-end>.popover-arrow:before{border-width:calc(var(--bs-popover-arrow-width)*.5) var(--bs-popover-arrow-height) calc(var(--bs-popover-arrow-width)*.5) 0}.bs-popover-auto[data-popper-placement^=right]>.popover-arrow:before,.bs-popover-end>.popover-arrow:before{border-right-color:var(--bs-popover-arrow-border);left:0}.bs-popover-auto[data-popper-placement^=right]>.popover-arrow:after,.bs-popover-end>.popover-arrow:after{border-right-color:var(--bs-popover-bg);left:var(--bs-popover-border-width)}.bs-popover-auto[data-popper-placement^=bottom]>.popover-arrow,.bs-popover-bottom>.popover-arrow{top:calc((var(--bs-popover-arrow-height))*-1 - var(--bs-popover-border-width))}.bs-popover-auto[data-popper-placement^=bottom]>.popover-arrow:after,.bs-popover-auto[data-popper-placement^=bottom]>.popover-arrow:before,.bs-popover-bottom>.popover-arrow:after,.bs-popover-bottom>.popover-arrow:before{border-width:0 calc(var(--bs-popover-arrow-width)*.5) var(--bs-popover-arrow-height)}.bs-popover-auto[data-popper-placement^=bottom]>.popover-arrow:before,.bs-popover-bottom>.popover-arrow:before{border-bottom-color:var(--bs-popover-arrow-border);top:0}.bs-popover-auto[data-popper-placement^=bottom]>.popover-arrow:after,.bs-popover-bottom>.popover-arrow:after{border-bottom-color:var(--bs-popover-bg);top:var(--bs-popover-border-width)}.bs-popover-auto[data-popper-placement^=bottom] .popover-header:before,.bs-popover-bottom .popover-header:before{border-bottom:var(--bs-popover-border-width) solid var(--bs-popover-header-bg);content:"";display:block;left:50%;margin-left:calc(var(--bs-popover-arrow-width)*-.5);position:absolute;top:0;width:var(--bs-popover-arrow-width)}.bs-popover-auto[data-popper-placement^=left]>.popover-arrow,.bs-popover-start>.popover-arrow{height:var(--bs-popover-arrow-width);right:calc((var(--bs-popover-arrow-height))*-1 - var(--bs-popover-border-width));width:var(--bs-popover-arrow-height)}.bs-popover-auto[data-popper-placement^=left]>.popover-arrow:after,.bs-popover-auto[data-popper-placement^=left]>.popover-arrow:before,.bs-popover-start>.popover-arrow:after,.bs-popover-start>.popover-arrow:before{border-width:calc(var(--bs-popover-arrow-width)*.5) 0 calc(var(--bs-popover-arrow-width)*.5) var(--bs-popover-arrow-height)}.bs-popover-auto[data-popper-placement^=left]>.popover-arrow:before,.bs-popover-start>.popover-arrow:before{border-left-color:var(--bs-popover-arrow-border);right:0}.bs-popover-auto[data-popper-placement^=left]>.popover-arrow:after,.bs-popover-start>.popover-arrow:after{border-left-color:var(--bs-popover-bg);right:var(--bs-popover-border-width)}.popover-header{background-color:var(--bs-popover-header-bg);border-bottom:var(--bs-popover-border-width) solid var(--bs-popover-border-color);border-top-left-radius:var(--bs-popover-inner-border-radius);border-top-right-radius:var(--bs-popover-inner-border-radius);color:var(--bs-popover-header-color);font-size:var(--bs-popover-header-font-size);margin-bottom:0;padding:var(--bs-popover-header-padding-y) var(--bs-popover-header-padding-x)}.popover-header:empty{display:none}.popover-body{color:var(--bs-popover-body-color);padding:var(--bs-popover-body-padding-y) var(--bs-popover-body-padding-x)}.carousel{position:relative}.carousel.pointer-event{touch-action:pan-y}.carousel-inner{overflow:hidden;position:relative;width:100%}.carousel-inner:after{clear:both;content:"";display:block}.carousel-item{-webkit-backface-visibility:hidden;backface-visibility:hidden;display:none;float:left;margin-right:-100%;position:relative;transition:-webkit-transform .6s ease-in-out;transition:transform .6s ease-in-out;transition:transform .6s ease-in-out,-webkit-transform .6s ease-in-out;width:100%}@media (prefers-reduced-motion:reduce){.carousel-item{transition:none}}.carousel-item-next,.carousel-item-prev,.carousel-item.active{display:block}.active.carousel-item-end,.carousel-item-next:not(.carousel-item-start){-webkit-transform:translateX(100%);transform:translateX(100%)}.active.carousel-item-start,.carousel-item-prev:not(.carousel-item-end){-webkit-transform:translateX(-100%);transform:translateX(-100%)}.carousel-fade .carousel-item{opacity:0;-webkit-transform:none;transform:none;transition-property:opacity}.carousel-fade .carousel-item-next.carousel-item-start,.carousel-fade .carousel-item-prev.carousel-item-end,.carousel-fade .carousel-item.active{opacity:1;z-index:1}.carousel-fade .active.carousel-item-end,.carousel-fade .active.carousel-item-start{opacity:0;transition:opacity 0s .6s;z-index:0}@media (prefers-reduced-motion:reduce){.carousel-fade .active.carousel-item-end,.carousel-fade .active.carousel-item-start{transition:none}}.carousel-control-next,.carousel-control-prev{align-items:center;background:none;border:0;bottom:0;color:#fff;display:flex;justify-content:center;opacity:.5;padding:0;position:absolute;text-align:center;top:0;transition:opacity .15s ease;width:15%;z-index:1}@media (prefers-reduced-motion:reduce){.carousel-control-next,.carousel-control-prev{transition:none}}.carousel-control-next:focus,.carousel-control-next:hover,.carousel-control-prev:focus,.carousel-control-prev:hover{color:#fff;opacity:.9;outline:0;text-decoration:none}.carousel-control-prev{left:0}.carousel-control-next{right:0}.carousel-control-next-icon,.carousel-control-prev-icon{background-position:50%;background-repeat:no-repeat;background-size:100% 100%;display:inline-block;height:2rem;width:2rem}.carousel-control-prev-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='%23fff'%3E%3Cpath d='M11.354 1.646a.5.5 0 0 1 0 .708L5.707 8l5.647 5.646a.5.5 0 0 1-.708.708l-6-6a.5.5 0 0 1 0-.708l6-6a.5.5 0 0 1 .708 0z'/%3E%3C/svg%3E")}.carousel-control-next-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='%23fff'%3E%3Cpath d='M4.646 1.646a.5.5 0 0 1 .708 0l6 6a.5.5 0 0 1 0 .708l-6 6a.5.5 0 0 1-.708-.708L10.293 8 4.646 2.354a.5.5 0 0 1 0-.708z'/%3E%3C/svg%3E")}.carousel-indicators{bottom:0;display:flex;justify-content:center;left:0;margin-bottom:1rem;margin-left:15%;margin-right:15%;padding:0;position:absolute;right:0;z-index:2}.carousel-indicators [data-bs-target]{background-clip:padding-box;background-color:#fff;border:0;border-bottom:10px solid transparent;border-top:10px solid transparent;box-sizing:initial;cursor:pointer;flex:0 1 auto;height:3px;margin-left:3px;margin-right:3px;opacity:.5;padding:0;text-indent:-999px;transition:opacity .6s ease;width:30px}@media (prefers-reduced-motion:reduce){.carousel-indicators [data-bs-target]{transition:none}}.carousel-indicators .active{opacity:1}.carousel-caption{bottom:1.25rem;color:#fff;left:15%;padding-bottom:1.25rem;padding-top:1.25rem;position:absolute;right:15%;text-align:center}.carousel-dark .carousel-control-next-icon,.carousel-dark .carousel-control-prev-icon{-webkit-filter:invert(1) grayscale(100);filter:invert(1) grayscale(100)}.carousel-dark .carousel-indicators [data-bs-target]{background-color:#000}.carousel-dark .carousel-caption{color:#000}[data-bs-theme=dark] .carousel .carousel-control-next-icon,[data-bs-theme=dark] .carousel .carousel-control-prev-icon,[data-bs-theme=dark].carousel .carousel-control-next-icon,[data-bs-theme=dark].carousel .carousel-control-prev-icon{-webkit-filter:invert(1) grayscale(100);filter:invert(1) grayscale(100)}[data-bs-theme=dark] .carousel .carousel-indicators [data-bs-target],[data-bs-theme=dark].carousel .carousel-indicators [data-bs-target]{background-color:#000}[data-bs-theme=dark] .carousel .carousel-caption,[data-bs-theme=dark].carousel .carousel-caption{color:#000}.spinner-border,.spinner-grow{-webkit-animation:var(--bs-spinner-animation-speed) linear infinite var(--bs-spinner-animation-name);animation:var(--bs-spinner-animation-speed) linear infinite var(--bs-spinner-animation-name);border-radius:50%;display:inline-block;height:var(--bs-spinner-height);vertical-align:var(--bs-spinner-vertical-align);width:var(--bs-spinner-width)}@-webkit-keyframes spinner-border{to{-webkit-transform:rotate(1turn);transform:rotate(1turn)}}@keyframes spinner-border{to{-webkit-transform:rotate(1turn);transform:rotate(1turn)}}.spinner-border{--bs-spinner-width:2rem;--bs-spinner-height:2rem;--bs-spinner-vertical-align:-0.125em;--bs-spinner-border-width:0.25em;--bs-spinner-animation-speed:0.75s;--bs-spinner-animation-name:spinner-border;border-right-color:currentcolor;border:var(--bs-spinner-border-width) solid;border-right:var(--bs-spinner-border-width) solid transparent}.spinner-border-sm{--bs-spinner-width:1rem;--bs-spinner-height:1rem;--bs-spinner-border-width:0.2em}@-webkit-keyframes spinner-grow{0%{-webkit-transform:scale(0);transform:scale(0)}50%{opacity:1;-webkit-transform:none;transform:none}}@keyframes spinner-grow{0%{-webkit-transform:scale(0);transform:scale(0)}50%{opacity:1;-webkit-transform:none;transform:none}}.spinner-grow{--bs-spinner-width:2rem;--bs-spinner-height:2rem;--bs-spinner-vertical-align:-0.125em;--bs-spinner-animation-speed:0.75s;--bs-spinner-animation-name:spinner-grow;background-color:currentcolor;opacity:0}.spinner-grow-sm{--bs-spinner-width:1rem;--bs-spinner-height:1rem}@media (prefers-reduced-motion:reduce){.spinner-border,.spinner-grow{--bs-spinner-animation-speed:1.5s}}.offcanvas,.offcanvas-lg,.offcanvas-md,.offcanvas-sm,.offcanvas-xl,.offcanvas-xxl{--bs-offcanvas-zindex:1045;--bs-offcanvas-width:400px;--bs-offcanvas-height:30vh;--bs-offcanvas-padding-x:1rem;--bs-offcanvas-padding-y:1rem;--bs-offcanvas-color:var(--bs-body-color);--bs-offcanvas-bg:var(--bs-body-bg);--bs-offcanvas-border-width:var(--bs-border-width);--bs-offcanvas-border-color:var(--bs-border-color-translucent);--bs-offcanvas-box-shadow:var(--bs-box-shadow-sm);--bs-offcanvas-transition:transform 0.3s ease-in-out;--bs-offcanvas-title-line-height:1.5}@media (max-width:575.98px){.offcanvas-sm{background-clip:padding-box;background-color:var(--bs-offcanvas-bg);bottom:0;color:var(--bs-offcanvas-color);display:flex;flex-direction:column;max-width:100%;outline:0;position:fixed;transition:var(--bs-offcanvas-transition);visibility:hidden;z-index:var(--bs-offcanvas-zindex)}}@media (max-width:575.98px) and (prefers-reduced-motion:reduce){.offcanvas-sm{transition:none}}@media (max-width:575.98px){.offcanvas-sm.offcanvas-start{border-right:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);left:0;top:0;-webkit-transform:translateX(-100%);transform:translateX(-100%);width:var(--bs-offcanvas-width)}.offcanvas-sm.offcanvas-end{border-left:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);right:0;top:0;-webkit-transform:translateX(100%);transform:translateX(100%);width:var(--bs-offcanvas-width)}.offcanvas-sm.offcanvas-top{border-bottom:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);top:0;-webkit-transform:translateY(-100%);transform:translateY(-100%)}.offcanvas-sm.offcanvas-bottom,.offcanvas-sm.offcanvas-top{height:var(--bs-offcanvas-height);left:0;max-height:100%;right:0}.offcanvas-sm.offcanvas-bottom{border-top:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);-webkit-transform:translateY(100%);transform:translateY(100%)}.offcanvas-sm.show:not(.hiding),.offcanvas-sm.showing{-webkit-transform:none;transform:none}.offcanvas-sm.hiding,.offcanvas-sm.show,.offcanvas-sm.showing{visibility:visible}}@media (min-width:576px){.offcanvas-sm{--bs-offcanvas-height:auto;--bs-offcanvas-border-width:0;background-color:initial!important}.offcanvas-sm .offcanvas-header{display:none}.offcanvas-sm .offcanvas-body{background-color:initial!important;display:flex;flex-grow:0;overflow-y:visible;padding:0}}@media (max-width:767.98px){.offcanvas-md{background-clip:padding-box;background-color:var(--bs-offcanvas-bg);bottom:0;color:var(--bs-offcanvas-color);display:flex;flex-direction:column;max-width:100%;outline:0;position:fixed;transition:var(--bs-offcanvas-transition);visibility:hidden;z-index:var(--bs-offcanvas-zindex)}}@media (max-width:767.98px) and (prefers-reduced-motion:reduce){.offcanvas-md{transition:none}}@media (max-width:767.98px){.offcanvas-md.offcanvas-start{border-right:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);left:0;top:0;-webkit-transform:translateX(-100%);transform:translateX(-100%);width:var(--bs-offcanvas-width)}.offcanvas-md.offcanvas-end{border-left:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);right:0;top:0;-webkit-transform:translateX(100%);transform:translateX(100%);width:var(--bs-offcanvas-width)}.offcanvas-md.offcanvas-top{border-bottom:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);top:0;-webkit-transform:translateY(-100%);transform:translateY(-100%)}.offcanvas-md.offcanvas-bottom,.offcanvas-md.offcanvas-top{height:var(--bs-offcanvas-height);left:0;max-height:100%;right:0}.offcanvas-md.offcanvas-bottom{border-top:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);-webkit-transform:translateY(100%);transform:translateY(100%)}.offcanvas-md.show:not(.hiding),.offcanvas-md.showing{-webkit-transform:none;transform:none}.offcanvas-md.hiding,.offcanvas-md.show,.offcanvas-md.showing{visibility:visible}}@media (min-width:768px){.offcanvas-md{--bs-offcanvas-height:auto;--bs-offcanvas-border-width:0;background-color:initial!important}.offcanvas-md .offcanvas-header{display:none}.offcanvas-md .offcanvas-body{background-color:initial!important;display:flex;flex-grow:0;overflow-y:visible;padding:0}}@media (max-width:991.98px){.offcanvas-lg{background-clip:padding-box;background-color:var(--bs-offcanvas-bg);bottom:0;color:var(--bs-offcanvas-color);display:flex;flex-direction:column;max-width:100%;outline:0;position:fixed;transition:var(--bs-offcanvas-transition);visibility:hidden;z-index:var(--bs-offcanvas-zindex)}}@media (max-width:991.98px) and (prefers-reduced-motion:reduce){.offcanvas-lg{transition:none}}@media (max-width:991.98px){.offcanvas-lg.offcanvas-start{border-right:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);left:0;top:0;-webkit-transform:translateX(-100%);transform:translateX(-100%);width:var(--bs-offcanvas-width)}.offcanvas-lg.offcanvas-end{border-left:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);right:0;top:0;-webkit-transform:translateX(100%);transform:translateX(100%);width:var(--bs-offcanvas-width)}.offcanvas-lg.offcanvas-top{border-bottom:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);top:0;-webkit-transform:translateY(-100%);transform:translateY(-100%)}.offcanvas-lg.offcanvas-bottom,.offcanvas-lg.offcanvas-top{height:var(--bs-offcanvas-height);left:0;max-height:100%;right:0}.offcanvas-lg.offcanvas-bottom{border-top:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);-webkit-transform:translateY(100%);transform:translateY(100%)}.offcanvas-lg.show:not(.hiding),.offcanvas-lg.showing{-webkit-transform:none;transform:none}.offcanvas-lg.hiding,.offcanvas-lg.show,.offcanvas-lg.showing{visibility:visible}}@media (min-width:992px){.offcanvas-lg{--bs-offcanvas-height:auto;--bs-offcanvas-border-width:0;background-color:initial!important}.offcanvas-lg .offcanvas-header{display:none}.offcanvas-lg .offcanvas-body{background-color:initial!important;display:flex;flex-grow:0;overflow-y:visible;padding:0}}@media (max-width:1199.98px){.offcanvas-xl{background-clip:padding-box;background-color:var(--bs-offcanvas-bg);bottom:0;color:var(--bs-offcanvas-color);display:flex;flex-direction:column;max-width:100%;outline:0;position:fixed;transition:var(--bs-offcanvas-transition);visibility:hidden;z-index:var(--bs-offcanvas-zindex)}}@media (max-width:1199.98px) and (prefers-reduced-motion:reduce){.offcanvas-xl{transition:none}}@media (max-width:1199.98px){.offcanvas-xl.offcanvas-start{border-right:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);left:0;top:0;-webkit-transform:translateX(-100%);transform:translateX(-100%);width:var(--bs-offcanvas-width)}.offcanvas-xl.offcanvas-end{border-left:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);right:0;top:0;-webkit-transform:translateX(100%);transform:translateX(100%);width:var(--bs-offcanvas-width)}.offcanvas-xl.offcanvas-top{border-bottom:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);top:0;-webkit-transform:translateY(-100%);transform:translateY(-100%)}.offcanvas-xl.offcanvas-bottom,.offcanvas-xl.offcanvas-top{height:var(--bs-offcanvas-height);left:0;max-height:100%;right:0}.offcanvas-xl.offcanvas-bottom{border-top:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);-webkit-transform:translateY(100%);transform:translateY(100%)}.offcanvas-xl.show:not(.hiding),.offcanvas-xl.showing{-webkit-transform:none;transform:none}.offcanvas-xl.hiding,.offcanvas-xl.show,.offcanvas-xl.showing{visibility:visible}}@media (min-width:1200px){.offcanvas-xl{--bs-offcanvas-height:auto;--bs-offcanvas-border-width:0;background-color:initial!important}.offcanvas-xl .offcanvas-header{display:none}.offcanvas-xl .offcanvas-body{background-color:initial!important;display:flex;flex-grow:0;overflow-y:visible;padding:0}}@media (max-width:1399.98px){.offcanvas-xxl{background-clip:padding-box;background-color:var(--bs-offcanvas-bg);bottom:0;color:var(--bs-offcanvas-color);display:flex;flex-direction:column;max-width:100%;outline:0;position:fixed;transition:var(--bs-offcanvas-transition);visibility:hidden;z-index:var(--bs-offcanvas-zindex)}}@media (max-width:1399.98px) and (prefers-reduced-motion:reduce){.offcanvas-xxl{transition:none}}@media (max-width:1399.98px){.offcanvas-xxl.offcanvas-start{border-right:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);left:0;top:0;-webkit-transform:translateX(-100%);transform:translateX(-100%);width:var(--bs-offcanvas-width)}.offcanvas-xxl.offcanvas-end{border-left:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);right:0;top:0;-webkit-transform:translateX(100%);transform:translateX(100%);width:var(--bs-offcanvas-width)}.offcanvas-xxl.offcanvas-top{border-bottom:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);top:0;-webkit-transform:translateY(-100%);transform:translateY(-100%)}.offcanvas-xxl.offcanvas-bottom,.offcanvas-xxl.offcanvas-top{height:var(--bs-offcanvas-height);left:0;max-height:100%;right:0}.offcanvas-xxl.offcanvas-bottom{border-top:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);-webkit-transform:translateY(100%);transform:translateY(100%)}.offcanvas-xxl.show:not(.hiding),.offcanvas-xxl.showing{-webkit-transform:none;transform:none}.offcanvas-xxl.hiding,.offcanvas-xxl.show,.offcanvas-xxl.showing{visibility:visible}}@media (min-width:1400px){.offcanvas-xxl{--bs-offcanvas-height:auto;--bs-offcanvas-border-width:0;background-color:initial!important}.offcanvas-xxl .offcanvas-header{display:none}.offcanvas-xxl .offcanvas-body{background-color:initial!important;display:flex;flex-grow:0;overflow-y:visible;padding:0}}.offcanvas{background-clip:padding-box;background-color:var(--bs-offcanvas-bg);bottom:0;color:var(--bs-offcanvas-color);display:flex;flex-direction:column;max-width:100%;outline:0;position:fixed;transition:var(--bs-offcanvas-transition);visibility:hidden;z-index:var(--bs-offcanvas-zindex)}@media (prefers-reduced-motion:reduce){.offcanvas{transition:none}}.offcanvas.offcanvas-start{border-right:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);left:0;top:0;-webkit-transform:translateX(-100%);transform:translateX(-100%);width:var(--bs-offcanvas-width)}.offcanvas.offcanvas-end{border-left:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);right:0;top:0;-webkit-transform:translateX(100%);transform:translateX(100%);width:var(--bs-offcanvas-width)}.offcanvas.offcanvas-top{border-bottom:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);top:0;-webkit-transform:translateY(-100%);transform:translateY(-100%)}.offcanvas.offcanvas-bottom,.offcanvas.offcanvas-top{height:var(--bs-offcanvas-height);left:0;max-height:100%;right:0}.offcanvas.offcanvas-bottom{border-top:var(--bs-offcanvas-border-width) solid var(--bs-offcanvas-border-color);-webkit-transform:translateY(100%);transform:translateY(100%)}.offcanvas.show:not(.hiding),.offcanvas.showing{-webkit-transform:none;transform:none}.offcanvas.hiding,.offcanvas.show,.offcanvas.showing{visibility:visible}.offcanvas-backdrop{background-color:#000;height:100vh;left:0;position:fixed;top:0;width:100vw;z-index:1040}.offcanvas-backdrop.fade{opacity:0}.offcanvas-backdrop.show{opacity:.5}.offcanvas-header{align-items:center;display:flex;justify-content:space-between;padding:var(--bs-offcanvas-padding-y) var(--bs-offcanvas-padding-x)}.offcanvas-header .btn-close{margin-bottom:calc(var(--bs-offcanvas-padding-y)*-.5);margin-right:calc(var(--bs-offcanvas-padding-x)*-.5);margin-top:calc(var(--bs-offcanvas-padding-y)*-.5);padding:calc(var(--bs-offcanvas-padding-y)*.5) calc(var(--bs-offcanvas-padding-x)*.5)}.offcanvas-title{line-height:var(--bs-offcanvas-title-line-height);margin-bottom:0}.offcanvas-body{flex-grow:1;overflow-y:auto;padding:var(--bs-offcanvas-padding-y) var(--bs-offcanvas-padding-x)}.placeholder{background-color:currentcolor;cursor:wait;display:inline-block;min-height:1em;opacity:.5;vertical-align:middle}.placeholder.btn:before{content:"";display:inline-block}.placeholder-xs{min-height:.6em}.placeholder-sm{min-height:.8em}.placeholder-lg{min-height:1.2em}.placeholder-glow .placeholder{-webkit-animation:placeholder-glow 2s ease-in-out infinite;animation:placeholder-glow 2s ease-in-out infinite}@-webkit-keyframes placeholder-glow{50%{opacity:.2}}@keyframes placeholder-glow{50%{opacity:.2}}.placeholder-wave{-webkit-animation:placeholder-wave 2s linear infinite;animation:placeholder-wave 2s linear infinite;-webkit-mask-image:linear-gradient(130deg,#000 55%,rgba(0,0,0,.8) 75%,#000 95%);mask-image:linear-gradient(130deg,#000 55%,rgba(0,0,0,.8) 75%,#000 95%);-webkit-mask-size:200% 100%;mask-size:200% 100%}@-webkit-keyframes placeholder-wave{to{-webkit-mask-position:-200% 0;mask-position:-200% 0}}@keyframes placeholder-wave{to{-webkit-mask-position:-200% 0;mask-position:-200% 0}}.clearfix:after{clear:both;content:"";display:block}.text-bg-primary{background-color:#0d6efd!important;background-color:RGBA(var(--bs-primary-rgb),var(--bs-bg-opacity,1))!important;color:#fff!important}.text-bg-secondary{background-color:#6c757d!important;background-color:RGBA(var(--bs-secondary-rgb),var(--bs-bg-opacity,1))!important;color:#fff!important}.text-bg-success{background-color:#198754!important;background-color:RGBA(var(--bs-success-rgb),var(--bs-bg-opacity,1))!important;color:#fff!important}.text-bg-info{background-color:#0dcaf0!important;background-color:RGBA(var(--bs-info-rgb),var(--bs-bg-opacity,1))!important;color:#000!important}.text-bg-warning{background-color:#ffc107!important;background-color:RGBA(var(--bs-warning-rgb),var(--bs-bg-opacity,1))!important;color:#000!important}.text-bg-danger{background-color:#dc3545!important;background-color:RGBA(var(--bs-danger-rgb),var(--bs-bg-opacity,1))!important;color:#fff!important}.text-bg-light{background-color:#f8f9fa!important;background-color:RGBA(var(--bs-light-rgb),var(--bs-bg-opacity,1))!important;color:#000!important}.text-bg-dark{background-color:#212529!important;background-color:RGBA(var(--bs-dark-rgb),var(--bs-bg-opacity,1))!important;color:#fff!important}.link-primary{color:#0d6efd!important;color:RGBA(var(--bs-primary-rgb),var(--bs-link-opacity,1))!important;text-decoration-color:#0d6efd!important;text-decoration-color:RGBA(var(--bs-primary-rgb),var(--bs-link-underline-opacity,1))!important}.link-primary:focus,.link-primary:hover{color:#0a58ca!important;color:RGBA(10,88,202,var(--bs-link-opacity,1))!important;text-decoration-color:#0a58ca!important;text-decoration-color:RGBA(10,88,202,var(--bs-link-underline-opacity,1))!important}.link-secondary{color:#6c757d!important;color:RGBA(var(--bs-secondary-rgb),var(--bs-link-opacity,1))!important;text-decoration-color:#6c757d!important;text-decoration-color:RGBA(var(--bs-secondary-rgb),var(--bs-link-underline-opacity,1))!important}.link-secondary:focus,.link-secondary:hover{color:#565e64!important;color:RGBA(86,94,100,var(--bs-link-opacity,1))!important;text-decoration-color:#565e64!important;text-decoration-color:RGBA(86,94,100,var(--bs-link-underline-opacity,1))!important}.link-success{color:#198754!important;color:RGBA(var(--bs-success-rgb),var(--bs-link-opacity,1))!important;text-decoration-color:#198754!important;text-decoration-color:RGBA(var(--bs-success-rgb),var(--bs-link-underline-opacity,1))!important}.link-success:focus,.link-success:hover{color:#146c43!important;color:RGBA(20,108,67,var(--bs-link-opacity,1))!important;text-decoration-color:#146c43!important;text-decoration-color:RGBA(20,108,67,var(--bs-link-underline-opacity,1))!important}.link-info{color:#0dcaf0!important;color:RGBA(var(--bs-info-rgb),var(--bs-link-opacity,1))!important;text-decoration-color:#0dcaf0!important;text-decoration-color:RGBA(var(--bs-info-rgb),var(--bs-link-underline-opacity,1))!important}.link-info:focus,.link-info:hover{color:#3dd5f3!important;color:RGBA(61,213,243,var(--bs-link-opacity,1))!important;text-decoration-color:#3dd5f3!important;text-decoration-color:RGBA(61,213,243,var(--bs-link-underline-opacity,1))!important}.link-warning{color:#ffc107!important;color:RGBA(var(--bs-warning-rgb),var(--bs-link-opacity,1))!important;text-decoration-color:#ffc107!important;text-decoration-color:RGBA(var(--bs-warning-rgb),var(--bs-link-underline-opacity,1))!important}.link-warning:focus,.link-warning:hover{color:#ffcd39!important;color:RGBA(255,205,57,var(--bs-link-opacity,1))!important;text-decoration-color:#ffcd39!important;text-decoration-color:RGBA(255,205,57,var(--bs-link-underline-opacity,1))!important}.link-danger{color:#dc3545!important;color:RGBA(var(--bs-danger-rgb),var(--bs-link-opacity,1))!important;text-decoration-color:#dc3545!important;text-decoration-color:RGBA(var(--bs-danger-rgb),var(--bs-link-underline-opacity,1))!important}.link-danger:focus,.link-danger:hover{color:#b02a37!important;color:RGBA(176,42,55,var(--bs-link-opacity,1))!important;text-decoration-color:#b02a37!important;text-decoration-color:RGBA(176,42,55,var(--bs-link-underline-opacity,1))!important}.link-light{color:#f8f9fa!important;color:RGBA(var(--bs-light-rgb),var(--bs-link-opacity,1))!important;text-decoration-color:#f8f9fa!important;text-decoration-color:RGBA(var(--bs-light-rgb),var(--bs-link-underline-opacity,1))!important}.link-light:focus,.link-light:hover{color:#f9fafb!important;color:RGBA(249,250,251,var(--bs-link-opacity,1))!important;text-decoration-color:#f9fafb!important;text-decoration-color:RGBA(249,250,251,var(--bs-link-underline-opacity,1))!important}.link-dark{color:#212529!important;color:RGBA(var(--bs-dark-rgb),var(--bs-link-opacity,1))!important;text-decoration-color:#212529!important;text-decoration-color:RGBA(var(--bs-dark-rgb),var(--bs-link-underline-opacity,1))!important}.link-dark:focus,.link-dark:hover{color:#1a1e21!important;color:RGBA(26,30,33,var(--bs-link-opacity,1))!important;text-decoration-color:#1a1e21!important;text-decoration-color:RGBA(26,30,33,var(--bs-link-underline-opacity,1))!important}.link-body-emphasis{color:#000!important;color:RGBA(var(--bs-emphasis-color-rgb),var(--bs-link-opacity,1))!important;text-decoration-color:#000!important;text-decoration-color:RGBA(var(--bs-emphasis-color-rgb),var(--bs-link-underline-opacity,1))!important}.link-body-emphasis:focus,.link-body-emphasis:hover{color:rgba(0,0,0,.75)!important;color:RGBA(var(--bs-emphasis-color-rgb),var(--bs-link-opacity,.75))!important;text-decoration-color:rgba(0,0,0,.75)!important;text-decoration-color:RGBA(var(--bs-emphasis-color-rgb),var(--bs-link-underline-opacity,.75))!important}.focus-ring:focus{box-shadow:0 0 0 .25rem rgba(13,110,253,.25);box-shadow:var(--bs-focus-ring-x,0) var(--bs-focus-ring-y,0) var(--bs-focus-ring-blur,0) var(--bs-focus-ring-width) var(--bs-focus-ring-color);outline:0}.icon-link{align-items:center;-webkit-backface-visibility:hidden;backface-visibility:hidden;display:inline-flex;gap:.375rem;text-decoration-color:rgba(13,110,253,.5);text-decoration-color:rgba(var(--bs-link-color-rgb),var(--bs-link-opacity,.5));text-underline-offset:.25em}.icon-link>.bi{fill:currentcolor;flex-shrink:0;height:1em;transition:transform .2s ease-in-out;width:1em}@media (prefers-reduced-motion:reduce){.icon-link>.bi{transition:none}}.icon-link-hover:focus-visible>.bi,.icon-link-hover:hover>.bi{-webkit-transform:translate3d(.25em,0,0);transform:translate3d(.25em,0,0);-webkit-transform:var(--bs-icon-link-transform,translate3d(.25em,0,0));transform:var(--bs-icon-link-transform,translate3d(.25em,0,0))}.ratio{position:relative;width:100%}.ratio:before{content:"";display:block;padding-top:var(--bs-aspect-ratio)}.ratio>*{height:100%;left:0;position:absolute;top:0;width:100%}.ratio-1x1{--bs-aspect-ratio:100%}.ratio-4x3{--bs-aspect-ratio:75%}.ratio-16x9{--bs-aspect-ratio:56.25%}.ratio-21x9{--bs-aspect-ratio:42.8571428571%}.fixed-top{top:0}.fixed-bottom,.fixed-top{left:0;position:fixed;right:0;z-index:1030}.fixed-bottom{bottom:0}.sticky-top{top:0}.sticky-bottom,.sticky-top{position:-webkit-sticky;position:sticky;z-index:1020}.sticky-bottom{bottom:0}@media (min-width:576px){.sticky-sm-top{top:0}.sticky-sm-bottom,.sticky-sm-top{position:-webkit-sticky;position:sticky;z-index:1020}.sticky-sm-bottom{bottom:0}}@media (min-width:768px){.sticky-md-top{top:0}.sticky-md-bottom,.sticky-md-top{position:-webkit-sticky;position:sticky;z-index:1020}.sticky-md-bottom{bottom:0}}@media (min-width:992px){.sticky-lg-top{top:0}.sticky-lg-bottom,.sticky-lg-top{position:-webkit-sticky;position:sticky;z-index:1020}.sticky-lg-bottom{bottom:0}}@media (min-width:1200px){.sticky-xl-top{top:0}.sticky-xl-bottom,.sticky-xl-top{position:-webkit-sticky;position:sticky;z-index:1020}.sticky-xl-bottom{bottom:0}}@media (min-width:1400px){.sticky-xxl-top{top:0}.sticky-xxl-bottom,.sticky-xxl-top{position:-webkit-sticky;position:sticky;z-index:1020}.sticky-xxl-bottom{bottom:0}}.hstack{align-items:center;flex-direction:row}.hstack,.vstack{align-self:stretch;display:flex}.vstack{flex:1 1 auto;flex-direction:column}.visually-hidden,.visually-hidden-focusable:not(:focus):not(:focus-within){clip:rect(0,0,0,0)!important;border:0!important;height:1px!important;margin:-1px!important;overflow:hidden!important;padding:0!important;white-space:nowrap!important;width:1px!important}.visually-hidden-focusable:not(:focus):not(:focus-within):not(caption),.visually-hidden:not(caption){position:absolute!important}.stretched-link:after{bottom:0;content:"";left:0;position:absolute;right:0;top:0;z-index:1}.text-truncate{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.vr{align-self:stretch;background-color:currentcolor;display:inline-block;min-height:1em;opacity:.25;width:1px;width:var(--bs-border-width)}.align-baseline{vertical-align:initial!important}.align-top{vertical-align:top!important}.align-middle{vertical-align:middle!important}.align-bottom{vertical-align:bottom!important}.align-text-bottom{vertical-align:text-bottom!important}.align-text-top{vertical-align:text-top!important}.float-start{float:left!important}.float-end{float:right!important}.float-none{float:none!important}.object-fit-contain{object-fit:contain!important}.object-fit-cover{object-fit:cover!important}.object-fit-fill{object-fit:fill!important}.object-fit-scale{object-fit:scale-down!important}.object-fit-none{object-fit:none!important}.opacity-0{opacity:0!important}.opacity-25{opacity:.25!important}.opacity-50{opacity:.5!important}.opacity-75{opacity:.75!important}.opacity-100{opacity:1!important}.overflow-auto{overflow:auto!important}.overflow-hidden{overflow:hidden!important}.overflow-visible{overflow:visible!important}.overflow-scroll{overflow:scroll!important}.overflow-x-auto{overflow-x:auto!important}.overflow-x-hidden{overflow-x:hidden!important}.overflow-x-visible{overflow-x:visible!important}.overflow-x-scroll{overflow-x:scroll!important}.overflow-y-auto{overflow-y:auto!important}.overflow-y-hidden{overflow-y:hidden!important}.overflow-y-visible{overflow-y:visible!important}.overflow-y-scroll{overflow-y:scroll!important}.d-inline{display:inline!important}.d-inline-block{display:inline-block!important}.d-block{display:block!important}.d-grid{display:grid!important}.d-inline-grid{display:inline-grid!important}.d-table{display:table!important}.d-table-row{display:table-row!important}.d-table-cell{display:table-cell!important}.d-flex{display:flex!important}.d-inline-flex{display:inline-flex!important}.d-none{display:none!important}.shadow{box-shadow:0 .5rem 1rem rgba(0,0,0,.15)!important;box-shadow:var(--bs-box-shadow)!important}.shadow-sm{box-shadow:0 .125rem .25rem rgba(0,0,0,.075)!important;box-shadow:var(--bs-box-shadow-sm)!important}.shadow-lg{box-shadow:0 1rem 3rem rgba(0,0,0,.175)!important;box-shadow:var(--bs-box-shadow-lg)!important}.shadow-none{box-shadow:none!important}.focus-ring-primary{--bs-focus-ring-color:rgba(var(--bs-primary-rgb),var(--bs-focus-ring-opacity))}.focus-ring-secondary{--bs-focus-ring-color:rgba(var(--bs-secondary-rgb),var(--bs-focus-ring-opacity))}.focus-ring-success{--bs-focus-ring-color:rgba(var(--bs-success-rgb),var(--bs-focus-ring-opacity))}.focus-ring-info{--bs-focus-ring-color:rgba(var(--bs-info-rgb),var(--bs-focus-ring-opacity))}.focus-ring-warning{--bs-focus-ring-color:rgba(var(--bs-warning-rgb),var(--bs-focus-ring-opacity))}.focus-ring-danger{--bs-focus-ring-color:rgba(var(--bs-danger-rgb),var(--bs-focus-ring-opacity))}.focus-ring-light{--bs-focus-ring-color:rgba(var(--bs-light-rgb),var(--bs-focus-ring-opacity))}.focus-ring-dark{--bs-focus-ring-color:rgba(var(--bs-dark-rgb),var(--bs-focus-ring-opacity))}.position-static{position:static!important}.position-relative{position:relative!important}.position-absolute{position:absolute!important}.position-fixed{position:fixed!important}.position-sticky{position:-webkit-sticky!important;position:sticky!important}.top-0{top:0!important}.top-50{top:50%!important}.top-100{top:100%!important}.bottom-0{bottom:0!important}.bottom-50{bottom:50%!important}.bottom-100{bottom:100%!important}.start-0{left:0!important}.start-50{left:50%!important}.start-100{left:100%!important}.end-0{right:0!important}.end-50{right:50%!important}.end-100{right:100%!important}.translate-middle{-webkit-transform:translate(-50%,-50%)!important;transform:translate(-50%,-50%)!important}.translate-middle-x{-webkit-transform:translateX(-50%)!important;transform:translateX(-50%)!important}.translate-middle-y{-webkit-transform:translateY(-50%)!important;transform:translateY(-50%)!important}.border{border:1px solid #dee2e6!important;border:var(--bs-border-width) var(--bs-border-style) var(--bs-border-color)!important}.border-0{border:0!important}.border-top{border-top:1px solid #dee2e6!important;border-top:var(--bs-border-width) var(--bs-border-style) var(--bs-border-color)!important}.border-top-0{border-top:0!important}.border-end{border-right:1px solid #dee2e6!important;border-right:var(--bs-border-width) var(--bs-border-style) var(--bs-border-color)!important}.border-end-0{border-right:0!important}.border-bottom{border-bottom:1px solid #dee2e6!important;border-bottom:var(--bs-border-width) var(--bs-border-style) var(--bs-border-color)!important}.border-bottom-0{border-bottom:0!important}.border-start{border-left:1px solid #dee2e6!important;border-left:var(--bs-border-width) var(--bs-border-style) var(--bs-border-color)!important}.border-start-0{border-left:0!important}.border-primary{--bs-border-opacity:1;border-color:rgba(var(--bs-primary-rgb),var(--bs-border-opacity))!important}.border-secondary{--bs-border-opacity:1;border-color:rgba(var(--bs-secondary-rgb),var(--bs-border-opacity))!important}.border-success{--bs-border-opacity:1;border-color:rgba(var(--bs-success-rgb),var(--bs-border-opacity))!important}.border-info{--bs-border-opacity:1;border-color:rgba(var(--bs-info-rgb),var(--bs-border-opacity))!important}.border-warning{--bs-border-opacity:1;border-color:rgba(var(--bs-warning-rgb),var(--bs-border-opacity))!important}.border-danger{--bs-border-opacity:1;border-color:rgba(var(--bs-danger-rgb),var(--bs-border-opacity))!important}.border-light{--bs-border-opacity:1;border-color:rgba(var(--bs-light-rgb),var(--bs-border-opacity))!important}.border-dark{--bs-border-opacity:1;border-color:rgba(var(--bs-dark-rgb),var(--bs-border-opacity))!important}.border-black{--bs-border-opacity:1;border-color:rgba(var(--bs-black-rgb),var(--bs-border-opacity))!important}.border-white{--bs-border-opacity:1;border-color:rgba(var(--bs-white-rgb),var(--bs-border-opacity))!important}.border-primary-subtle{border-color:#9ec5fe!important;border-color:var(--bs-primary-border-subtle)!important}.border-secondary-subtle{border-color:#c4c8cb!important;border-color:var(--bs-secondary-border-subtle)!important}.border-success-subtle{border-color:#a3cfbb!important;border-color:var(--bs-success-border-subtle)!important}.border-info-subtle{border-color:#9eeaf9!important;border-color:var(--bs-info-border-subtle)!important}.border-warning-subtle{border-color:#ffe69c!important;border-color:var(--bs-warning-border-subtle)!important}.border-danger-subtle{border-color:#f1aeb5!important;border-color:var(--bs-danger-border-subtle)!important}.border-light-subtle{border-color:#e9ecef!important;border-color:var(--bs-light-border-subtle)!important}.border-dark-subtle{border-color:#adb5bd!important;border-color:var(--bs-dark-border-subtle)!important}.border-1{border-width:1px!important}.border-2{border-width:2px!important}.border-3{border-width:3px!important}.border-4{border-width:4px!important}.border-5{border-width:5px!important}.border-opacity-10{--bs-border-opacity:0.1}.border-opacity-25{--bs-border-opacity:0.25}.border-opacity-50{--bs-border-opacity:0.5}.border-opacity-75{--bs-border-opacity:0.75}.border-opacity-100{--bs-border-opacity:1}.w-25{width:25%!important}.w-50{width:50%!important}.w-75{width:75%!important}.w-100{width:100%!important}.w-auto{width:auto!important}.mw-100{max-width:100%!important}.vw-100{width:100vw!important}.min-vw-100{min-width:100vw!important}.h-25{height:25%!important}.h-50{height:50%!important}.h-75{height:75%!important}.h-100{height:100%!important}.h-auto{height:auto!important}.mh-100{max-height:100%!important}.vh-100{height:100vh!important}.min-vh-100{min-height:100vh!important}.flex-fill{flex:1 1 auto!important}.flex-row{flex-direction:row!important}.flex-column{flex-direction:column!important}.flex-row-reverse{flex-direction:row-reverse!important}.flex-column-reverse{flex-direction:column-reverse!important}.flex-grow-0{flex-grow:0!important}.flex-grow-1{flex-grow:1!important}.flex-shrink-0{flex-shrink:0!important}.flex-shrink-1{flex-shrink:1!important}.flex-wrap{flex-wrap:wrap!important}.flex-nowrap{flex-wrap:nowrap!important}.flex-wrap-reverse{flex-wrap:wrap-reverse!important}.justify-content-start{justify-content:flex-start!important}.justify-content-end{justify-content:flex-end!important}.justify-content-center{justify-content:center!important}.justify-content-between{justify-content:space-between!important}.justify-content-around{justify-content:space-around!important}.justify-content-evenly{justify-content:space-evenly!important}.align-items-start{align-items:flex-start!important}.align-items-end{align-items:flex-end!important}.align-items-center{align-items:center!important}.align-items-baseline{align-items:baseline!important}.align-items-stretch{align-items:stretch!important}.align-content-start{align-content:flex-start!important}.align-content-end{align-content:flex-end!important}.align-content-center{align-content:center!important}.align-content-between{align-content:space-between!important}.align-content-around{align-content:space-around!important}.align-content-stretch{align-content:stretch!important}.align-self-auto{align-self:auto!important}.align-self-start{align-self:flex-start!important}.align-self-end{align-self:flex-end!important}.align-self-center{align-self:center!important}.align-self-baseline{align-self:baseline!important}.align-self-stretch{align-self:stretch!important}.order-first{order:-1!important}.order-0{order:0!important}.order-1{order:1!important}.order-2{order:2!important}.order-3{order:3!important}.order-4{order:4!important}.order-5{order:5!important}.order-last{order:6!important}.m-0{margin:0!important}.m-1{margin:.25rem!important}.m-2{margin:.5rem!important}.m-3{margin:1rem!important}.m-4{margin:1.5rem!important}.m-5{margin:3rem!important}.m-auto{margin:auto!important}.mx-0{margin-left:0!important;margin-right:0!important}.mx-1{margin-left:.25rem!important;margin-right:.25rem!important}.mx-2{margin-left:.5rem!important;margin-right:.5rem!important}.mx-3{margin-left:1rem!important;margin-right:1rem!important}.mx-4{margin-left:1.5rem!important;margin-right:1.5rem!important}.mx-5{margin-left:3rem!important;margin-right:3rem!important}.mx-auto{margin-left:auto!important;margin-right:auto!important}.my-0{margin-bottom:0!important;margin-top:0!important}.my-1{margin-bottom:.25rem!important;margin-top:.25rem!important}.my-2{margin-bottom:.5rem!important;margin-top:.5rem!important}.my-3{margin-bottom:1rem!important;margin-top:1rem!important}.my-4{margin-bottom:1.5rem!important;margin-top:1.5rem!important}.my-5{margin-bottom:3rem!important;margin-top:3rem!important}.my-auto{margin-bottom:auto!important;margin-top:auto!important}.mt-0{margin-top:0!important}.mt-1{margin-top:.25rem!important}.mt-2{margin-top:.5rem!important}.mt-3{margin-top:1rem!important}.mt-4{margin-top:1.5rem!important}.mt-5{margin-top:3rem!important}.mt-auto{margin-top:auto!important}.me-0{margin-right:0!important}.me-1{margin-right:.25rem!important}.me-2{margin-right:.5rem!important}.me-3{margin-right:1rem!important}.me-4{margin-right:1.5rem!important}.me-5{margin-right:3rem!important}.me-auto{margin-right:auto!important}.mb-0{margin-bottom:0!important}.mb-1{margin-bottom:.25rem!important}.mb-2{margin-bottom:.5rem!important}.mb-3{margin-bottom:1rem!important}.mb-4{margin-bottom:1.5rem!important}.mb-5{margin-bottom:3rem!important}.mb-auto{margin-bottom:auto!important}.ms-0{margin-left:0!important}.ms-1{margin-left:.25rem!important}.ms-2{margin-left:.5rem!important}.ms-3{margin-left:1rem!important}.ms-4{margin-left:1.5rem!important}.ms-5{margin-left:3rem!important}.ms-auto{margin-left:auto!important}.p-0{padding:0!important}.p-1{padding:.25rem!important}.p-2{padding:.5rem!important}.p-3{padding:1rem!important}.p-4{padding:1.5rem!important}.p-5{padding:3rem!important}.px-0{padding-left:0!important;padding-right:0!important}.px-1{padding-left:.25rem!important;padding-right:.25rem!important}.px-2{padding-left:.5rem!important;padding-right:.5rem!important}.px-3{padding-left:1rem!important;padding-right:1rem!important}.px-4{padding-left:1.5rem!important;padding-right:1.5rem!important}.px-5{padding-left:3rem!important;padding-right:3rem!important}.py-0{padding-bottom:0!important;padding-top:0!important}.py-1{padding-bottom:.25rem!important;padding-top:.25rem!important}.py-2{padding-bottom:.5rem!important;padding-top:.5rem!important}.py-3{padding-bottom:1rem!important;padding-top:1rem!important}.py-4{padding-bottom:1.5rem!important;padding-top:1.5rem!important}.py-5{padding-bottom:3rem!important;padding-top:3rem!important}.pt-0{padding-top:0!important}.pt-1{padding-top:.25rem!important}.pt-2{padding-top:.5rem!important}.pt-3{padding-top:1rem!important}.pt-4{padding-top:1.5rem!important}.pt-5{padding-top:3rem!important}.pe-0{padding-right:0!important}.pe-1{padding-right:.25rem!important}.pe-2{padding-right:.5rem!important}.pe-3{padding-right:1rem!important}.pe-4{padding-right:1.5rem!important}.pe-5{padding-right:3rem!important}.pb-0{padding-bottom:0!important}.pb-1{padding-bottom:.25rem!important}.pb-2{padding-bottom:.5rem!important}.pb-3{padding-bottom:1rem!important}.pb-4{padding-bottom:1.5rem!important}.pb-5{padding-bottom:3rem!important}.ps-0{padding-left:0!important}.ps-1{padding-left:.25rem!important}.ps-2{padding-left:.5rem!important}.ps-3{padding-left:1rem!important}.ps-4{padding-left:1.5rem!important}.ps-5{padding-left:3rem!important}.gap-0{gap:0!important}.gap-1{gap:.25rem!important}.gap-2{gap:.5rem!important}.gap-3{gap:1rem!important}.gap-4{gap:1.5rem!important}.gap-5{gap:3rem!important}.row-gap-0{row-gap:0!important}.row-gap-1{row-gap:.25rem!important}.row-gap-2{row-gap:.5rem!important}.row-gap-3{row-gap:1rem!important}.row-gap-4{row-gap:1.5rem!important}.row-gap-5{row-gap:3rem!important}.column-gap-0{-webkit-column-gap:0!important;column-gap:0!important}.column-gap-1{-webkit-column-gap:.25rem!important;column-gap:.25rem!important}.column-gap-2{-webkit-column-gap:.5rem!important;column-gap:.5rem!important}.column-gap-3{-webkit-column-gap:1rem!important;column-gap:1rem!important}.column-gap-4{-webkit-column-gap:1.5rem!important;column-gap:1.5rem!important}.column-gap-5{-webkit-column-gap:3rem!important;column-gap:3rem!important}.font-monospace{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,monospace!important;font-family:var(--bs-font-monospace)!important}.fs-1{font-size:calc(1.375rem + 1.5vw)!important}.fs-2{font-size:calc(1.325rem + .9vw)!important}.fs-3{font-size:calc(1.3rem + .6vw)!important}.fs-4{font-size:calc(1.275rem + .3vw)!important}.fs-5{font-size:1.25rem!important}.fs-6{font-size:1rem!important}.fst-italic{font-style:italic!important}.fst-normal{font-style:normal!important}.fw-lighter{font-weight:lighter!important}.fw-light{font-weight:300!important}.fw-normal{font-weight:400!important}.fw-medium{font-weight:500!important}.fw-semibold{font-weight:600!important}.fw-bold{font-weight:700!important}.fw-bolder{font-weight:bolder!important}.lh-1{line-height:1!important}.lh-sm{line-height:1.25!important}.lh-base{line-height:1.5!important}.lh-lg{line-height:2!important}.text-start{text-align:left!important}.text-end{text-align:right!important}.text-center{text-align:center!important}.text-decoration-none{text-decoration:none!important}.text-decoration-underline{text-decoration:underline!important}.text-decoration-line-through{text-decoration:line-through!important}.text-lowercase{text-transform:lowercase!important}.text-uppercase{text-transform:uppercase!important}.text-capitalize{text-transform:capitalize!important}.text-wrap{white-space:normal!important}.text-nowrap{white-space:nowrap!important}.text-break{word-wrap:break-word!important;word-break:break-word!important}.text-primary{--bs-text-opacity:1;color:rgba(13,110,253,var(--bs-text-opacity))!important;color:rgba(var(--bs-primary-rgb),var(--bs-text-opacity))!important}.text-secondary{--bs-text-opacity:1;color:rgba(108,117,125,var(--bs-text-opacity))!important;color:rgba(var(--bs-secondary-rgb),var(--bs-text-opacity))!important}.text-success{--bs-text-opacity:1;color:rgba(25,135,84,var(--bs-text-opacity))!important;color:rgba(var(--bs-success-rgb),var(--bs-text-opacity))!important}.text-info{--bs-text-opacity:1;color:rgba(13,202,240,var(--bs-text-opacity))!important;color:rgba(var(--bs-info-rgb),var(--bs-text-opacity))!important}.text-warning{--bs-text-opacity:1;color:rgba(255,193,7,var(--bs-text-opacity))!important;color:rgba(var(--bs-warning-rgb),var(--bs-text-opacity))!important}.text-danger{--bs-text-opacity:1;color:rgba(220,53,69,var(--bs-text-opacity))!important;color:rgba(var(--bs-danger-rgb),var(--bs-text-opacity))!important}.text-light{--bs-text-opacity:1;color:rgba(248,249,250,var(--bs-text-opacity))!important;color:rgba(var(--bs-light-rgb),var(--bs-text-opacity))!important}.text-dark{--bs-text-opacity:1;color:rgba(33,37,41,var(--bs-text-opacity))!important;color:rgba(var(--bs-dark-rgb),var(--bs-text-opacity))!important}.text-black{--bs-text-opacity:1;color:rgba(0,0,0,var(--bs-text-opacity))!important;color:rgba(var(--bs-black-rgb),var(--bs-text-opacity))!important}.text-white{--bs-text-opacity:1;color:rgba(255,255,255,var(--bs-text-opacity))!important;color:rgba(var(--bs-white-rgb),var(--bs-text-opacity))!important}.text-body{--bs-text-opacity:1;color:rgba(33,37,41,var(--bs-text-opacity))!important;color:rgba(var(--bs-body-color-rgb),var(--bs-text-opacity))!important}.text-muted{--bs-text-opacity:1;color:rgba(33,37,41,.75)!important;color:var(--bs-secondary-color)!important}.text-black-50{--bs-text-opacity:1;color:rgba(0,0,0,.5)!important}.text-white-50{--bs-text-opacity:1;color:hsla(0,0%,100%,.5)!important}.text-body-secondary{--bs-text-opacity:1;color:rgba(33,37,41,.75)!important;color:var(--bs-secondary-color)!important}.text-body-tertiary{--bs-text-opacity:1;color:rgba(33,37,41,.5)!important;color:var(--bs-tertiary-color)!important}.text-body-emphasis{--bs-text-opacity:1;color:#000!important;color:var(--bs-emphasis-color)!important}.text-reset{--bs-text-opacity:1;color:inherit!important}.text-opacity-25{--bs-text-opacity:0.25}.text-opacity-50{--bs-text-opacity:0.5}.text-opacity-75{--bs-text-opacity:0.75}.text-opacity-100{--bs-text-opacity:1}.text-primary-emphasis{color:#052c65!important;color:var(--bs-primary-text-emphasis)!important}.text-secondary-emphasis{color:#2b2f32!important;color:var(--bs-secondary-text-emphasis)!important}.text-success-emphasis{color:#0a3622!important;color:var(--bs-success-text-emphasis)!important}.text-info-emphasis{color:#055160!important;color:var(--bs-info-text-emphasis)!important}.text-warning-emphasis{color:#664d03!important;color:var(--bs-warning-text-emphasis)!important}.text-danger-emphasis{color:#58151c!important;color:var(--bs-danger-text-emphasis)!important}.text-light-emphasis{color:#495057!important;color:var(--bs-light-text-emphasis)!important}.text-dark-emphasis{color:#495057!important;color:var(--bs-dark-text-emphasis)!important}.link-opacity-10,.link-opacity-10-hover:hover{--bs-link-opacity:0.1}.link-opacity-25,.link-opacity-25-hover:hover{--bs-link-opacity:0.25}.link-opacity-50,.link-opacity-50-hover:hover{--bs-link-opacity:0.5}.link-opacity-75,.link-opacity-75-hover:hover{--bs-link-opacity:0.75}.link-opacity-100,.link-opacity-100-hover:hover{--bs-link-opacity:1}.link-offset-1,.link-offset-1-hover:hover{text-underline-offset:.125em!important}.link-offset-2,.link-offset-2-hover:hover{text-underline-offset:.25em!important}.link-offset-3,.link-offset-3-hover:hover{text-underline-offset:.375em!important}.link-underline-primary{--bs-link-underline-opacity:1;text-decoration-color:rgba(13,110,253,var(--bs-link-underline-opacity))!important;text-decoration-color:rgba(var(--bs-primary-rgb),var(--bs-link-underline-opacity))!important}.link-underline-secondary{--bs-link-underline-opacity:1;text-decoration-color:rgba(108,117,125,var(--bs-link-underline-opacity))!important;text-decoration-color:rgba(var(--bs-secondary-rgb),var(--bs-link-underline-opacity))!important}.link-underline-success{--bs-link-underline-opacity:1;text-decoration-color:rgba(25,135,84,var(--bs-link-underline-opacity))!important;text-decoration-color:rgba(var(--bs-success-rgb),var(--bs-link-underline-opacity))!important}.link-underline-info{--bs-link-underline-opacity:1;text-decoration-color:rgba(13,202,240,var(--bs-link-underline-opacity))!important;text-decoration-color:rgba(var(--bs-info-rgb),var(--bs-link-underline-opacity))!important}.link-underline-warning{--bs-link-underline-opacity:1;text-decoration-color:rgba(255,193,7,var(--bs-link-underline-opacity))!important;text-decoration-color:rgba(var(--bs-warning-rgb),var(--bs-link-underline-opacity))!important}.link-underline-danger{--bs-link-underline-opacity:1;text-decoration-color:rgba(220,53,69,var(--bs-link-underline-opacity))!important;text-decoration-color:rgba(var(--bs-danger-rgb),var(--bs-link-underline-opacity))!important}.link-underline-light{--bs-link-underline-opacity:1;text-decoration-color:rgba(248,249,250,var(--bs-link-underline-opacity))!important;text-decoration-color:rgba(var(--bs-light-rgb),var(--bs-link-underline-opacity))!important}.link-underline-dark{--bs-link-underline-opacity:1;text-decoration-color:rgba(33,37,41,var(--bs-link-underline-opacity))!important;text-decoration-color:rgba(var(--bs-dark-rgb),var(--bs-link-underline-opacity))!important}.link-underline{--bs-link-underline-opacity:1;text-decoration-color:#0d6efd!important;text-decoration-color:rgba(var(--bs-link-color-rgb),var(--bs-link-underline-opacity,1))!important}.link-underline-opacity-0,.link-underline-opacity-0-hover:hover{--bs-link-underline-opacity:0}.link-underline-opacity-10,.link-underline-opacity-10-hover:hover{--bs-link-underline-opacity:0.1}.link-underline-opacity-25,.link-underline-opacity-25-hover:hover{--bs-link-underline-opacity:0.25}.link-underline-opacity-50,.link-underline-opacity-50-hover:hover{--bs-link-underline-opacity:0.5}.link-underline-opacity-75,.link-underline-opacity-75-hover:hover{--bs-link-underline-opacity:0.75}.link-underline-opacity-100,.link-underline-opacity-100-hover:hover{--bs-link-underline-opacity:1}.bg-primary{--bs-bg-opacity:1;background-color:rgba(13,110,253,var(--bs-bg-opacity))!important;background-color:rgba(var(--bs-primary-rgb),var(--bs-bg-opacity))!important}.bg-secondary{--bs-bg-opacity:1;background-color:rgba(108,117,125,var(--bs-bg-opacity))!important;background-color:rgba(var(--bs-secondary-rgb),var(--bs-bg-opacity))!important}.bg-success{--bs-bg-opacity:1;background-color:rgba(25,135,84,var(--bs-bg-opacity))!important;background-color:rgba(var(--bs-success-rgb),var(--bs-bg-opacity))!important}.bg-info{--bs-bg-opacity:1;background-color:rgba(13,202,240,var(--bs-bg-opacity))!important;background-color:rgba(var(--bs-info-rgb),var(--bs-bg-opacity))!important}.bg-warning{--bs-bg-opacity:1;background-color:rgba(255,193,7,var(--bs-bg-opacity))!important;background-color:rgba(var(--bs-warning-rgb),var(--bs-bg-opacity))!important}.bg-danger{--bs-bg-opacity:1;background-color:rgba(220,53,69,var(--bs-bg-opacity))!important;background-color:rgba(var(--bs-danger-rgb),var(--bs-bg-opacity))!important}.bg-light{--bs-bg-opacity:1;background-color:rgba(248,249,250,var(--bs-bg-opacity))!important;background-color:rgba(var(--bs-light-rgb),var(--bs-bg-opacity))!important}.bg-dark{--bs-bg-opacity:1;background-color:rgba(33,37,41,var(--bs-bg-opacity))!important;background-color:rgba(var(--bs-dark-rgb),var(--bs-bg-opacity))!important}.bg-black{--bs-bg-opacity:1;background-color:rgba(0,0,0,var(--bs-bg-opacity))!important;background-color:rgba(var(--bs-black-rgb),var(--bs-bg-opacity))!important}.bg-white{--bs-bg-opacity:1;background-color:rgba(255,255,255,var(--bs-bg-opacity))!important;background-color:rgba(var(--bs-white-rgb),var(--bs-bg-opacity))!important}.bg-body{--bs-bg-opacity:1;background-color:rgba(255,255,255,var(--bs-bg-opacity))!important;background-color:rgba(var(--bs-body-bg-rgb),var(--bs-bg-opacity))!important}.bg-transparent{--bs-bg-opacity:1;background-color:initial!important}.bg-body-secondary{--bs-bg-opacity:1;background-color:rgba(233,236,239,var(--bs-bg-opacity))!important;background-color:rgba(var(--bs-secondary-bg-rgb),var(--bs-bg-opacity))!important}.bg-body-tertiary{--bs-bg-opacity:1;background-color:rgba(248,249,250,var(--bs-bg-opacity))!important;background-color:rgba(var(--bs-tertiary-bg-rgb),var(--bs-bg-opacity))!important}.bg-opacity-10{--bs-bg-opacity:0.1}.bg-opacity-25{--bs-bg-opacity:0.25}.bg-opacity-50{--bs-bg-opacity:0.5}.bg-opacity-75{--bs-bg-opacity:0.75}.bg-opacity-100{--bs-bg-opacity:1}.bg-primary-subtle{background-color:#cfe2ff!important;background-color:var(--bs-primary-bg-subtle)!important}.bg-secondary-subtle{background-color:#e2e3e5!important;background-color:var(--bs-secondary-bg-subtle)!important}.bg-success-subtle{background-color:#d1e7dd!important;background-color:var(--bs-success-bg-subtle)!important}.bg-info-subtle{background-color:#cff4fc!important;background-color:var(--bs-info-bg-subtle)!important}.bg-warning-subtle{background-color:#fff3cd!important;background-color:var(--bs-warning-bg-subtle)!important}.bg-danger-subtle{background-color:#f8d7da!important;background-color:var(--bs-danger-bg-subtle)!important}.bg-light-subtle{background-color:#fcfcfd!important;background-color:var(--bs-light-bg-subtle)!important}.bg-dark-subtle{background-color:#ced4da!important;background-color:var(--bs-dark-bg-subtle)!important}.bg-gradient{background-image:linear-gradient(180deg,hsla(0,0%,100%,.15),hsla(0,0%,100%,0))!important;background-image:var(--bs-gradient)!important}.user-select-all{-webkit-user-select:all!important;user-select:all!important}.user-select-auto{-webkit-user-select:auto!important;user-select:auto!important}.user-select-none{-webkit-user-select:none!important;user-select:none!important}.pe-none{pointer-events:none!important}.pe-auto{pointer-events:auto!important}.rounded{border-radius:.375rem!important;border-radius:var(--bs-border-radius)!important}.rounded-0{border-radius:0!important}.rounded-1{border-radius:.25rem!important;border-radius:var(--bs-border-radius-sm)!important}.rounded-2{border-radius:.375rem!important;border-radius:var(--bs-border-radius)!important}.rounded-3{border-radius:.5rem!important;border-radius:var(--bs-border-radius-lg)!important}.rounded-4{border-radius:1rem!important;border-radius:var(--bs-border-radius-xl)!important}.rounded-5{border-radius:2rem!important;border-radius:var(--bs-border-radius-xxl)!important}.rounded-circle{border-radius:50%!important}.rounded-pill{border-radius:50rem!important;border-radius:var(--bs-border-radius-pill)!important}.rounded-top{border-top-left-radius:.375rem!important;border-top-left-radius:var(--bs-border-radius)!important;border-top-right-radius:.375rem!important;border-top-right-radius:var(--bs-border-radius)!important}.rounded-top-0{border-top-left-radius:0!important;border-top-right-radius:0!important}.rounded-top-1{border-top-left-radius:.25rem!important;border-top-left-radius:var(--bs-border-radius-sm)!important;border-top-right-radius:.25rem!important;border-top-right-radius:var(--bs-border-radius-sm)!important}.rounded-top-2{border-top-left-radius:.375rem!important;border-top-left-radius:var(--bs-border-radius)!important;border-top-right-radius:.375rem!important;border-top-right-radius:var(--bs-border-radius)!important}.rounded-top-3{border-top-left-radius:.5rem!important;border-top-left-radius:var(--bs-border-radius-lg)!important;border-top-right-radius:.5rem!important;border-top-right-radius:var(--bs-border-radius-lg)!important}.rounded-top-4{border-top-left-radius:1rem!important;border-top-left-radius:var(--bs-border-radius-xl)!important;border-top-right-radius:1rem!important;border-top-right-radius:var(--bs-border-radius-xl)!important}.rounded-top-5{border-top-left-radius:2rem!important;border-top-left-radius:var(--bs-border-radius-xxl)!important;border-top-right-radius:2rem!important;border-top-right-radius:var(--bs-border-radius-xxl)!important}.rounded-top-circle{border-top-left-radius:50%!important;border-top-right-radius:50%!important}.rounded-top-pill{border-top-left-radius:50rem!important;border-top-left-radius:var(--bs-border-radius-pill)!important;border-top-right-radius:50rem!important;border-top-right-radius:var(--bs-border-radius-pill)!important}.rounded-end{border-bottom-right-radius:.375rem!important;border-bottom-right-radius:var(--bs-border-radius)!important;border-top-right-radius:.375rem!important;border-top-right-radius:var(--bs-border-radius)!important}.rounded-end-0{border-bottom-right-radius:0!important;border-top-right-radius:0!important}.rounded-end-1{border-bottom-right-radius:.25rem!important;border-bottom-right-radius:var(--bs-border-radius-sm)!important;border-top-right-radius:.25rem!important;border-top-right-radius:var(--bs-border-radius-sm)!important}.rounded-end-2{border-bottom-right-radius:.375rem!important;border-bottom-right-radius:var(--bs-border-radius)!important;border-top-right-radius:.375rem!important;border-top-right-radius:var(--bs-border-radius)!important}.rounded-end-3{border-bottom-right-radius:.5rem!important;border-bottom-right-radius:var(--bs-border-radius-lg)!important;border-top-right-radius:.5rem!important;border-top-right-radius:var(--bs-border-radius-lg)!important}.rounded-end-4{border-bottom-right-radius:1rem!important;border-bottom-right-radius:var(--bs-border-radius-xl)!important;border-top-right-radius:1rem!important;border-top-right-radius:var(--bs-border-radius-xl)!important}.rounded-end-5{border-bottom-right-radius:2rem!important;border-bottom-right-radius:var(--bs-border-radius-xxl)!important;border-top-right-radius:2rem!important;border-top-right-radius:var(--bs-border-radius-xxl)!important}.rounded-end-circle{border-bottom-right-radius:50%!important;border-top-right-radius:50%!important}.rounded-end-pill{border-bottom-right-radius:50rem!important;border-bottom-right-radius:var(--bs-border-radius-pill)!important;border-top-right-radius:50rem!important;border-top-right-radius:var(--bs-border-radius-pill)!important}.rounded-bottom{border-bottom-left-radius:.375rem!important;border-bottom-left-radius:var(--bs-border-radius)!important;border-bottom-right-radius:.375rem!important;border-bottom-right-radius:var(--bs-border-radius)!important}.rounded-bottom-0{border-bottom-left-radius:0!important;border-bottom-right-radius:0!important}.rounded-bottom-1{border-bottom-left-radius:.25rem!important;border-bottom-left-radius:var(--bs-border-radius-sm)!important;border-bottom-right-radius:.25rem!important;border-bottom-right-radius:var(--bs-border-radius-sm)!important}.rounded-bottom-2{border-bottom-left-radius:.375rem!important;border-bottom-left-radius:var(--bs-border-radius)!important;border-bottom-right-radius:.375rem!important;border-bottom-right-radius:var(--bs-border-radius)!important}.rounded-bottom-3{border-bottom-left-radius:.5rem!important;border-bottom-left-radius:var(--bs-border-radius-lg)!important;border-bottom-right-radius:.5rem!important;border-bottom-right-radius:var(--bs-border-radius-lg)!important}.rounded-bottom-4{border-bottom-left-radius:1rem!important;border-bottom-left-radius:var(--bs-border-radius-xl)!important;border-bottom-right-radius:1rem!important;border-bottom-right-radius:var(--bs-border-radius-xl)!important}.rounded-bottom-5{border-bottom-left-radius:2rem!important;border-bottom-left-radius:var(--bs-border-radius-xxl)!important;border-bottom-right-radius:2rem!important;border-bottom-right-radius:var(--bs-border-radius-xxl)!important}.rounded-bottom-circle{border-bottom-left-radius:50%!important;border-bottom-right-radius:50%!important}.rounded-bottom-pill{border-bottom-left-radius:50rem!important;border-bottom-left-radius:var(--bs-border-radius-pill)!important;border-bottom-right-radius:50rem!important;border-bottom-right-radius:var(--bs-border-radius-pill)!important}.rounded-start{border-bottom-left-radius:.375rem!important;border-bottom-left-radius:var(--bs-border-radius)!important;border-top-left-radius:.375rem!important;border-top-left-radius:var(--bs-border-radius)!important}.rounded-start-0{border-bottom-left-radius:0!important;border-top-left-radius:0!important}.rounded-start-1{border-bottom-left-radius:.25rem!important;border-bottom-left-radius:var(--bs-border-radius-sm)!important;border-top-left-radius:.25rem!important;border-top-left-radius:var(--bs-border-radius-sm)!important}.rounded-start-2{border-bottom-left-radius:.375rem!important;border-bottom-left-radius:var(--bs-border-radius)!important;border-top-left-radius:.375rem!important;border-top-left-radius:var(--bs-border-radius)!important}.rounded-start-3{border-bottom-left-radius:.5rem!important;border-bottom-left-radius:var(--bs-border-radius-lg)!important;border-top-left-radius:.5rem!important;border-top-left-radius:var(--bs-border-radius-lg)!important}.rounded-start-4{border-bottom-left-radius:1rem!important;border-bottom-left-radius:var(--bs-border-radius-xl)!important;border-top-left-radius:1rem!important;border-top-left-radius:var(--bs-border-radius-xl)!important}.rounded-start-5{border-bottom-left-radius:2rem!important;border-bottom-left-radius:var(--bs-border-radius-xxl)!important;border-top-left-radius:2rem!important;border-top-left-radius:var(--bs-border-radius-xxl)!important}.rounded-start-circle{border-bottom-left-radius:50%!important;border-top-left-radius:50%!important}.rounded-start-pill{border-bottom-left-radius:50rem!important;border-bottom-left-radius:var(--bs-border-radius-pill)!important;border-top-left-radius:50rem!important;border-top-left-radius:var(--bs-border-radius-pill)!important}.visible{visibility:visible!important}.invisible{visibility:hidden!important}.z-n1{z-index:-1!important}.z-0{z-index:0!important}.z-1{z-index:1!important}.z-2{z-index:2!important}.z-3{z-index:3!important}@media (min-width:576px){.float-sm-start{float:left!important}.float-sm-end{float:right!important}.float-sm-none{float:none!important}.object-fit-sm-contain{object-fit:contain!important}.object-fit-sm-cover{object-fit:cover!important}.object-fit-sm-fill{object-fit:fill!important}.object-fit-sm-scale{object-fit:scale-down!important}.object-fit-sm-none{object-fit:none!important}.d-sm-inline{display:inline!important}.d-sm-inline-block{display:inline-block!important}.d-sm-block{display:block!important}.d-sm-grid{display:grid!important}.d-sm-inline-grid{display:inline-grid!important}.d-sm-table{display:table!important}.d-sm-table-row{display:table-row!important}.d-sm-table-cell{display:table-cell!important}.d-sm-flex{display:flex!important}.d-sm-inline-flex{display:inline-flex!important}.d-sm-none{display:none!important}.flex-sm-fill{flex:1 1 auto!important}.flex-sm-row{flex-direction:row!important}.flex-sm-column{flex-direction:column!important}.flex-sm-row-reverse{flex-direction:row-reverse!important}.flex-sm-column-reverse{flex-direction:column-reverse!important}.flex-sm-grow-0{flex-grow:0!important}.flex-sm-grow-1{flex-grow:1!important}.flex-sm-shrink-0{flex-shrink:0!important}.flex-sm-shrink-1{flex-shrink:1!important}.flex-sm-wrap{flex-wrap:wrap!important}.flex-sm-nowrap{flex-wrap:nowrap!important}.flex-sm-wrap-reverse{flex-wrap:wrap-reverse!important}.justify-content-sm-start{justify-content:flex-start!important}.justify-content-sm-end{justify-content:flex-end!important}.justify-content-sm-center{justify-content:center!important}.justify-content-sm-between{justify-content:space-between!important}.justify-content-sm-around{justify-content:space-around!important}.justify-content-sm-evenly{justify-content:space-evenly!important}.align-items-sm-start{align-items:flex-start!important}.align-items-sm-end{align-items:flex-end!important}.align-items-sm-center{align-items:center!important}.align-items-sm-baseline{align-items:baseline!important}.align-items-sm-stretch{align-items:stretch!important}.align-content-sm-start{align-content:flex-start!important}.align-content-sm-end{align-content:flex-end!important}.align-content-sm-center{align-content:center!important}.align-content-sm-between{align-content:space-between!important}.align-content-sm-around{align-content:space-around!important}.align-content-sm-stretch{align-content:stretch!important}.align-self-sm-auto{align-self:auto!important}.align-self-sm-start{align-self:flex-start!important}.align-self-sm-end{align-self:flex-end!important}.align-self-sm-center{align-self:center!important}.align-self-sm-baseline{align-self:baseline!important}.align-self-sm-stretch{align-self:stretch!important}.order-sm-first{order:-1!important}.order-sm-0{order:0!important}.order-sm-1{order:1!important}.order-sm-2{order:2!important}.order-sm-3{order:3!important}.order-sm-4{order:4!important}.order-sm-5{order:5!important}.order-sm-last{order:6!important}.m-sm-0{margin:0!important}.m-sm-1{margin:.25rem!important}.m-sm-2{margin:.5rem!important}.m-sm-3{margin:1rem!important}.m-sm-4{margin:1.5rem!important}.m-sm-5{margin:3rem!important}.m-sm-auto{margin:auto!important}.mx-sm-0{margin-left:0!important;margin-right:0!important}.mx-sm-1{margin-left:.25rem!important;margin-right:.25rem!important}.mx-sm-2{margin-left:.5rem!important;margin-right:.5rem!important}.mx-sm-3{margin-left:1rem!important;margin-right:1rem!important}.mx-sm-4{margin-left:1.5rem!important;margin-right:1.5rem!important}.mx-sm-5{margin-left:3rem!important;margin-right:3rem!important}.mx-sm-auto{margin-left:auto!important;margin-right:auto!important}.my-sm-0{margin-bottom:0!important;margin-top:0!important}.my-sm-1{margin-bottom:.25rem!important;margin-top:.25rem!important}.my-sm-2{margin-bottom:.5rem!important;margin-top:.5rem!important}.my-sm-3{margin-bottom:1rem!important;margin-top:1rem!important}.my-sm-4{margin-bottom:1.5rem!important;margin-top:1.5rem!important}.my-sm-5{margin-bottom:3rem!important;margin-top:3rem!important}.my-sm-auto{margin-bottom:auto!important;margin-top:auto!important}.mt-sm-0{margin-top:0!important}.mt-sm-1{margin-top:.25rem!important}.mt-sm-2{margin-top:.5rem!important}.mt-sm-3{margin-top:1rem!important}.mt-sm-4{margin-top:1.5rem!important}.mt-sm-5{margin-top:3rem!important}.mt-sm-auto{margin-top:auto!important}.me-sm-0{margin-right:0!important}.me-sm-1{margin-right:.25rem!important}.me-sm-2{margin-right:.5rem!important}.me-sm-3{margin-right:1rem!important}.me-sm-4{margin-right:1.5rem!important}.me-sm-5{margin-right:3rem!important}.me-sm-auto{margin-right:auto!important}.mb-sm-0{margin-bottom:0!important}.mb-sm-1{margin-bottom:.25rem!important}.mb-sm-2{margin-bottom:.5rem!important}.mb-sm-3{margin-bottom:1rem!important}.mb-sm-4{margin-bottom:1.5rem!important}.mb-sm-5{margin-bottom:3rem!important}.mb-sm-auto{margin-bottom:auto!important}.ms-sm-0{margin-left:0!important}.ms-sm-1{margin-left:.25rem!important}.ms-sm-2{margin-left:.5rem!important}.ms-sm-3{margin-left:1rem!important}.ms-sm-4{margin-left:1.5rem!important}.ms-sm-5{margin-left:3rem!important}.ms-sm-auto{margin-left:auto!important}.p-sm-0{padding:0!important}.p-sm-1{padding:.25rem!important}.p-sm-2{padding:.5rem!important}.p-sm-3{padding:1rem!important}.p-sm-4{padding:1.5rem!important}.p-sm-5{padding:3rem!important}.px-sm-0{padding-left:0!important;padding-right:0!important}.px-sm-1{padding-left:.25rem!important;padding-right:.25rem!important}.px-sm-2{padding-left:.5rem!important;padding-right:.5rem!important}.px-sm-3{padding-left:1rem!important;padding-right:1rem!important}.px-sm-4{padding-left:1.5rem!important;padding-right:1.5rem!important}.px-sm-5{padding-left:3rem!important;padding-right:3rem!important}.py-sm-0{padding-bottom:0!important;padding-top:0!important}.py-sm-1{padding-bottom:.25rem!important;padding-top:.25rem!important}.py-sm-2{padding-bottom:.5rem!important;padding-top:.5rem!important}.py-sm-3{padding-bottom:1rem!important;padding-top:1rem!important}.py-sm-4{padding-bottom:1.5rem!important;padding-top:1.5rem!important}.py-sm-5{padding-bottom:3rem!important;padding-top:3rem!important}.pt-sm-0{padding-top:0!important}.pt-sm-1{padding-top:.25rem!important}.pt-sm-2{padding-top:.5rem!important}.pt-sm-3{padding-top:1rem!important}.pt-sm-4{padding-top:1.5rem!important}.pt-sm-5{padding-top:3rem!important}.pe-sm-0{padding-right:0!important}.pe-sm-1{padding-right:.25rem!important}.pe-sm-2{padding-right:.5rem!important}.pe-sm-3{padding-right:1rem!important}.pe-sm-4{padding-right:1.5rem!important}.pe-sm-5{padding-right:3rem!important}.pb-sm-0{padding-bottom:0!important}.pb-sm-1{padding-bottom:.25rem!important}.pb-sm-2{padding-bottom:.5rem!important}.pb-sm-3{padding-bottom:1rem!important}.pb-sm-4{padding-bottom:1.5rem!important}.pb-sm-5{padding-bottom:3rem!important}.ps-sm-0{padding-left:0!important}.ps-sm-1{padding-left:.25rem!important}.ps-sm-2{padding-left:.5rem!important}.ps-sm-3{padding-left:1rem!important}.ps-sm-4{padding-left:1.5rem!important}.ps-sm-5{padding-left:3rem!important}.gap-sm-0{gap:0!important}.gap-sm-1{gap:.25rem!important}.gap-sm-2{gap:.5rem!important}.gap-sm-3{gap:1rem!important}.gap-sm-4{gap:1.5rem!important}.gap-sm-5{gap:3rem!important}.row-gap-sm-0{row-gap:0!important}.row-gap-sm-1{row-gap:.25rem!important}.row-gap-sm-2{row-gap:.5rem!important}.row-gap-sm-3{row-gap:1rem!important}.row-gap-sm-4{row-gap:1.5rem!important}.row-gap-sm-5{row-gap:3rem!important}.column-gap-sm-0{-webkit-column-gap:0!important;column-gap:0!important}.column-gap-sm-1{-webkit-column-gap:.25rem!important;column-gap:.25rem!important}.column-gap-sm-2{-webkit-column-gap:.5rem!important;column-gap:.5rem!important}.column-gap-sm-3{-webkit-column-gap:1rem!important;column-gap:1rem!important}.column-gap-sm-4{-webkit-column-gap:1.5rem!important;column-gap:1.5rem!important}.column-gap-sm-5{-webkit-column-gap:3rem!important;column-gap:3rem!important}.text-sm-start{text-align:left!important}.text-sm-end{text-align:right!important}.text-sm-center{text-align:center!important}}@media (min-width:768px){.float-md-start{float:left!important}.float-md-end{float:right!important}.float-md-none{float:none!important}.object-fit-md-contain{object-fit:contain!important}.object-fit-md-cover{object-fit:cover!important}.object-fit-md-fill{object-fit:fill!important}.object-fit-md-scale{object-fit:scale-down!important}.object-fit-md-none{object-fit:none!important}.d-md-inline{display:inline!important}.d-md-inline-block{display:inline-block!important}.d-md-block{display:block!important}.d-md-grid{display:grid!important}.d-md-inline-grid{display:inline-grid!important}.d-md-table{display:table!important}.d-md-table-row{display:table-row!important}.d-md-table-cell{display:table-cell!important}.d-md-flex{display:flex!important}.d-md-inline-flex{display:inline-flex!important}.d-md-none{display:none!important}.flex-md-fill{flex:1 1 auto!important}.flex-md-row{flex-direction:row!important}.flex-md-column{flex-direction:column!important}.flex-md-row-reverse{flex-direction:row-reverse!important}.flex-md-column-reverse{flex-direction:column-reverse!important}.flex-md-grow-0{flex-grow:0!important}.flex-md-grow-1{flex-grow:1!important}.flex-md-shrink-0{flex-shrink:0!important}.flex-md-shrink-1{flex-shrink:1!important}.flex-md-wrap{flex-wrap:wrap!important}.flex-md-nowrap{flex-wrap:nowrap!important}.flex-md-wrap-reverse{flex-wrap:wrap-reverse!important}.justify-content-md-start{justify-content:flex-start!important}.justify-content-md-end{justify-content:flex-end!important}.justify-content-md-center{justify-content:center!important}.justify-content-md-between{justify-content:space-between!important}.justify-content-md-around{justify-content:space-around!important}.justify-content-md-evenly{justify-content:space-evenly!important}.align-items-md-start{align-items:flex-start!important}.align-items-md-end{align-items:flex-end!important}.align-items-md-center{align-items:center!important}.align-items-md-baseline{align-items:baseline!important}.align-items-md-stretch{align-items:stretch!important}.align-content-md-start{align-content:flex-start!important}.align-content-md-end{align-content:flex-end!important}.align-content-md-center{align-content:center!important}.align-content-md-between{align-content:space-between!important}.align-content-md-around{align-content:space-around!important}.align-content-md-stretch{align-content:stretch!important}.align-self-md-auto{align-self:auto!important}.align-self-md-start{align-self:flex-start!important}.align-self-md-end{align-self:flex-end!important}.align-self-md-center{align-self:center!important}.align-self-md-baseline{align-self:baseline!important}.align-self-md-stretch{align-self:stretch!important}.order-md-first{order:-1!important}.order-md-0{order:0!important}.order-md-1{order:1!important}.order-md-2{order:2!important}.order-md-3{order:3!important}.order-md-4{order:4!important}.order-md-5{order:5!important}.order-md-last{order:6!important}.m-md-0{margin:0!important}.m-md-1{margin:.25rem!important}.m-md-2{margin:.5rem!important}.m-md-3{margin:1rem!important}.m-md-4{margin:1.5rem!important}.m-md-5{margin:3rem!important}.m-md-auto{margin:auto!important}.mx-md-0{margin-left:0!important;margin-right:0!important}.mx-md-1{margin-left:.25rem!important;margin-right:.25rem!important}.mx-md-2{margin-left:.5rem!important;margin-right:.5rem!important}.mx-md-3{margin-left:1rem!important;margin-right:1rem!important}.mx-md-4{margin-left:1.5rem!important;margin-right:1.5rem!important}.mx-md-5{margin-left:3rem!important;margin-right:3rem!important}.mx-md-auto{margin-left:auto!important;margin-right:auto!important}.my-md-0{margin-bottom:0!important;margin-top:0!important}.my-md-1{margin-bottom:.25rem!important;margin-top:.25rem!important}.my-md-2{margin-bottom:.5rem!important;margin-top:.5rem!important}.my-md-3{margin-bottom:1rem!important;margin-top:1rem!important}.my-md-4{margin-bottom:1.5rem!important;margin-top:1.5rem!important}.my-md-5{margin-bottom:3rem!important;margin-top:3rem!important}.my-md-auto{margin-bottom:auto!important;margin-top:auto!important}.mt-md-0{margin-top:0!important}.mt-md-1{margin-top:.25rem!important}.mt-md-2{margin-top:.5rem!important}.mt-md-3{margin-top:1rem!important}.mt-md-4{margin-top:1.5rem!important}.mt-md-5{margin-top:3rem!important}.mt-md-auto{margin-top:auto!important}.me-md-0{margin-right:0!important}.me-md-1{margin-right:.25rem!important}.me-md-2{margin-right:.5rem!important}.me-md-3{margin-right:1rem!important}.me-md-4{margin-right:1.5rem!important}.me-md-5{margin-right:3rem!important}.me-md-auto{margin-right:auto!important}.mb-md-0{margin-bottom:0!important}.mb-md-1{margin-bottom:.25rem!important}.mb-md-2{margin-bottom:.5rem!important}.mb-md-3{margin-bottom:1rem!important}.mb-md-4{margin-bottom:1.5rem!important}.mb-md-5{margin-bottom:3rem!important}.mb-md-auto{margin-bottom:auto!important}.ms-md-0{margin-left:0!important}.ms-md-1{margin-left:.25rem!important}.ms-md-2{margin-left:.5rem!important}.ms-md-3{margin-left:1rem!important}.ms-md-4{margin-left:1.5rem!important}.ms-md-5{margin-left:3rem!important}.ms-md-auto{margin-left:auto!important}.p-md-0{padding:0!important}.p-md-1{padding:.25rem!important}.p-md-2{padding:.5rem!important}.p-md-3{padding:1rem!important}.p-md-4{padding:1.5rem!important}.p-md-5{padding:3rem!important}.px-md-0{padding-left:0!important;padding-right:0!important}.px-md-1{padding-left:.25rem!important;padding-right:.25rem!important}.px-md-2{padding-left:.5rem!important;padding-right:.5rem!important}.px-md-3{padding-left:1rem!important;padding-right:1rem!important}.px-md-4{padding-left:1.5rem!important;padding-right:1.5rem!important}.px-md-5{padding-left:3rem!important;padding-right:3rem!important}.py-md-0{padding-bottom:0!important;padding-top:0!important}.py-md-1{padding-bottom:.25rem!important;padding-top:.25rem!important}.py-md-2{padding-bottom:.5rem!important;padding-top:.5rem!important}.py-md-3{padding-bottom:1rem!important;padding-top:1rem!important}.py-md-4{padding-bottom:1.5rem!important;padding-top:1.5rem!important}.py-md-5{padding-bottom:3rem!important;padding-top:3rem!important}.pt-md-0{padding-top:0!important}.pt-md-1{padding-top:.25rem!important}.pt-md-2{padding-top:.5rem!important}.pt-md-3{padding-top:1rem!important}.pt-md-4{padding-top:1.5rem!important}.pt-md-5{padding-top:3rem!important}.pe-md-0{padding-right:0!important}.pe-md-1{padding-right:.25rem!important}.pe-md-2{padding-right:.5rem!important}.pe-md-3{padding-right:1rem!important}.pe-md-4{padding-right:1.5rem!important}.pe-md-5{padding-right:3rem!important}.pb-md-0{padding-bottom:0!important}.pb-md-1{padding-bottom:.25rem!important}.pb-md-2{padding-bottom:.5rem!important}.pb-md-3{padding-bottom:1rem!important}.pb-md-4{padding-bottom:1.5rem!important}.pb-md-5{padding-bottom:3rem!important}.ps-md-0{padding-left:0!important}.ps-md-1{padding-left:.25rem!important}.ps-md-2{padding-left:.5rem!important}.ps-md-3{padding-left:1rem!important}.ps-md-4{padding-left:1.5rem!important}.ps-md-5{padding-left:3rem!important}.gap-md-0{gap:0!important}.gap-md-1{gap:.25rem!important}.gap-md-2{gap:.5rem!important}.gap-md-3{gap:1rem!important}.gap-md-4{gap:1.5rem!important}.gap-md-5{gap:3rem!important}.row-gap-md-0{row-gap:0!important}.row-gap-md-1{row-gap:.25rem!important}.row-gap-md-2{row-gap:.5rem!important}.row-gap-md-3{row-gap:1rem!important}.row-gap-md-4{row-gap:1.5rem!important}.row-gap-md-5{row-gap:3rem!important}.column-gap-md-0{-webkit-column-gap:0!important;column-gap:0!important}.column-gap-md-1{-webkit-column-gap:.25rem!important;column-gap:.25rem!important}.column-gap-md-2{-webkit-column-gap:.5rem!important;column-gap:.5rem!important}.column-gap-md-3{-webkit-column-gap:1rem!important;column-gap:1rem!important}.column-gap-md-4{-webkit-column-gap:1.5rem!important;column-gap:1.5rem!important}.column-gap-md-5{-webkit-column-gap:3rem!important;column-gap:3rem!important}.text-md-start{text-align:left!important}.text-md-end{text-align:right!important}.text-md-center{text-align:center!important}}@media (min-width:992px){.float-lg-start{float:left!important}.float-lg-end{float:right!important}.float-lg-none{float:none!important}.object-fit-lg-contain{object-fit:contain!important}.object-fit-lg-cover{object-fit:cover!important}.object-fit-lg-fill{object-fit:fill!important}.object-fit-lg-scale{object-fit:scale-down!important}.object-fit-lg-none{object-fit:none!important}.d-lg-inline{display:inline!important}.d-lg-inline-block{display:inline-block!important}.d-lg-block{display:block!important}.d-lg-grid{display:grid!important}.d-lg-inline-grid{display:inline-grid!important}.d-lg-table{display:table!important}.d-lg-table-row{display:table-row!important}.d-lg-table-cell{display:table-cell!important}.d-lg-flex{display:flex!important}.d-lg-inline-flex{display:inline-flex!important}.d-lg-none{display:none!important}.flex-lg-fill{flex:1 1 auto!important}.flex-lg-row{flex-direction:row!important}.flex-lg-column{flex-direction:column!important}.flex-lg-row-reverse{flex-direction:row-reverse!important}.flex-lg-column-reverse{flex-direction:column-reverse!important}.flex-lg-grow-0{flex-grow:0!important}.flex-lg-grow-1{flex-grow:1!important}.flex-lg-shrink-0{flex-shrink:0!important}.flex-lg-shrink-1{flex-shrink:1!important}.flex-lg-wrap{flex-wrap:wrap!important}.flex-lg-nowrap{flex-wrap:nowrap!important}.flex-lg-wrap-reverse{flex-wrap:wrap-reverse!important}.justify-content-lg-start{justify-content:flex-start!important}.justify-content-lg-end{justify-content:flex-end!important}.justify-content-lg-center{justify-content:center!important}.justify-content-lg-between{justify-content:space-between!important}.justify-content-lg-around{justify-content:space-around!important}.justify-content-lg-evenly{justify-content:space-evenly!important}.align-items-lg-start{align-items:flex-start!important}.align-items-lg-end{align-items:flex-end!important}.align-items-lg-center{align-items:center!important}.align-items-lg-baseline{align-items:baseline!important}.align-items-lg-stretch{align-items:stretch!important}.align-content-lg-start{align-content:flex-start!important}.align-content-lg-end{align-content:flex-end!important}.align-content-lg-center{align-content:center!important}.align-content-lg-between{align-content:space-between!important}.align-content-lg-around{align-content:space-around!important}.align-content-lg-stretch{align-content:stretch!important}.align-self-lg-auto{align-self:auto!important}.align-self-lg-start{align-self:flex-start!important}.align-self-lg-end{align-self:flex-end!important}.align-self-lg-center{align-self:center!important}.align-self-lg-baseline{align-self:baseline!important}.align-self-lg-stretch{align-self:stretch!important}.order-lg-first{order:-1!important}.order-lg-0{order:0!important}.order-lg-1{order:1!important}.order-lg-2{order:2!important}.order-lg-3{order:3!important}.order-lg-4{order:4!important}.order-lg-5{order:5!important}.order-lg-last{order:6!important}.m-lg-0{margin:0!important}.m-lg-1{margin:.25rem!important}.m-lg-2{margin:.5rem!important}.m-lg-3{margin:1rem!important}.m-lg-4{margin:1.5rem!important}.m-lg-5{margin:3rem!important}.m-lg-auto{margin:auto!important}.mx-lg-0{margin-left:0!important;margin-right:0!important}.mx-lg-1{margin-left:.25rem!important;margin-right:.25rem!important}.mx-lg-2{margin-left:.5rem!important;margin-right:.5rem!important}.mx-lg-3{margin-left:1rem!important;margin-right:1rem!important}.mx-lg-4{margin-left:1.5rem!important;margin-right:1.5rem!important}.mx-lg-5{margin-left:3rem!important;margin-right:3rem!important}.mx-lg-auto{margin-left:auto!important;margin-right:auto!important}.my-lg-0{margin-bottom:0!important;margin-top:0!important}.my-lg-1{margin-bottom:.25rem!important;margin-top:.25rem!important}.my-lg-2{margin-bottom:.5rem!important;margin-top:.5rem!important}.my-lg-3{margin-bottom:1rem!important;margin-top:1rem!important}.my-lg-4{margin-bottom:1.5rem!important;margin-top:1.5rem!important}.my-lg-5{margin-bottom:3rem!important;margin-top:3rem!important}.my-lg-auto{margin-bottom:auto!important;margin-top:auto!important}.mt-lg-0{margin-top:0!important}.mt-lg-1{margin-top:.25rem!important}.mt-lg-2{margin-top:.5rem!important}.mt-lg-3{margin-top:1rem!important}.mt-lg-4{margin-top:1.5rem!important}.mt-lg-5{margin-top:3rem!important}.mt-lg-auto{margin-top:auto!important}.me-lg-0{margin-right:0!important}.me-lg-1{margin-right:.25rem!important}.me-lg-2{margin-right:.5rem!important}.me-lg-3{margin-right:1rem!important}.me-lg-4{margin-right:1.5rem!important}.me-lg-5{margin-right:3rem!important}.me-lg-auto{margin-right:auto!important}.mb-lg-0{margin-bottom:0!important}.mb-lg-1{margin-bottom:.25rem!important}.mb-lg-2{margin-bottom:.5rem!important}.mb-lg-3{margin-bottom:1rem!important}.mb-lg-4{margin-bottom:1.5rem!important}.mb-lg-5{margin-bottom:3rem!important}.mb-lg-auto{margin-bottom:auto!important}.ms-lg-0{margin-left:0!important}.ms-lg-1{margin-left:.25rem!important}.ms-lg-2{margin-left:.5rem!important}.ms-lg-3{margin-left:1rem!important}.ms-lg-4{margin-left:1.5rem!important}.ms-lg-5{margin-left:3rem!important}.ms-lg-auto{margin-left:auto!important}.p-lg-0{padding:0!important}.p-lg-1{padding:.25rem!important}.p-lg-2{padding:.5rem!important}.p-lg-3{padding:1rem!important}.p-lg-4{padding:1.5rem!important}.p-lg-5{padding:3rem!important}.px-lg-0{padding-left:0!important;padding-right:0!important}.px-lg-1{padding-left:.25rem!important;padding-right:.25rem!important}.px-lg-2{padding-left:.5rem!important;padding-right:.5rem!important}.px-lg-3{padding-left:1rem!important;padding-right:1rem!important}.px-lg-4{padding-left:1.5rem!important;padding-right:1.5rem!important}.px-lg-5{padding-left:3rem!important;padding-right:3rem!important}.py-lg-0{padding-bottom:0!important;padding-top:0!important}.py-lg-1{padding-bottom:.25rem!important;padding-top:.25rem!important}.py-lg-2{padding-bottom:.5rem!important;padding-top:.5rem!important}.py-lg-3{padding-bottom:1rem!important;padding-top:1rem!important}.py-lg-4{padding-bottom:1.5rem!important;padding-top:1.5rem!important}.py-lg-5{padding-bottom:3rem!important;padding-top:3rem!important}.pt-lg-0{padding-top:0!important}.pt-lg-1{padding-top:.25rem!important}.pt-lg-2{padding-top:.5rem!important}.pt-lg-3{padding-top:1rem!important}.pt-lg-4{padding-top:1.5rem!important}.pt-lg-5{padding-top:3rem!important}.pe-lg-0{padding-right:0!important}.pe-lg-1{padding-right:.25rem!important}.pe-lg-2{padding-right:.5rem!important}.pe-lg-3{padding-right:1rem!important}.pe-lg-4{padding-right:1.5rem!important}.pe-lg-5{padding-right:3rem!important}.pb-lg-0{padding-bottom:0!important}.pb-lg-1{padding-bottom:.25rem!important}.pb-lg-2{padding-bottom:.5rem!important}.pb-lg-3{padding-bottom:1rem!important}.pb-lg-4{padding-bottom:1.5rem!important}.pb-lg-5{padding-bottom:3rem!important}.ps-lg-0{padding-left:0!important}.ps-lg-1{padding-left:.25rem!important}.ps-lg-2{padding-left:.5rem!important}.ps-lg-3{padding-left:1rem!important}.ps-lg-4{padding-left:1.5rem!important}.ps-lg-5{padding-left:3rem!important}.gap-lg-0{gap:0!important}.gap-lg-1{gap:.25rem!important}.gap-lg-2{gap:.5rem!important}.gap-lg-3{gap:1rem!important}.gap-lg-4{gap:1.5rem!important}.gap-lg-5{gap:3rem!important}.row-gap-lg-0{row-gap:0!important}.row-gap-lg-1{row-gap:.25rem!important}.row-gap-lg-2{row-gap:.5rem!important}.row-gap-lg-3{row-gap:1rem!important}.row-gap-lg-4{row-gap:1.5rem!important}.row-gap-lg-5{row-gap:3rem!important}.column-gap-lg-0{-webkit-column-gap:0!important;column-gap:0!important}.column-gap-lg-1{-webkit-column-gap:.25rem!important;column-gap:.25rem!important}.column-gap-lg-2{-webkit-column-gap:.5rem!important;column-gap:.5rem!important}.column-gap-lg-3{-webkit-column-gap:1rem!important;column-gap:1rem!important}.column-gap-lg-4{-webkit-column-gap:1.5rem!important;column-gap:1.5rem!important}.column-gap-lg-5{-webkit-column-gap:3rem!important;column-gap:3rem!important}.text-lg-start{text-align:left!important}.text-lg-end{text-align:right!important}.text-lg-center{text-align:center!important}}@media (min-width:1200px){.float-xl-start{float:left!important}.float-xl-end{float:right!important}.float-xl-none{float:none!important}.object-fit-xl-contain{object-fit:contain!important}.object-fit-xl-cover{object-fit:cover!important}.object-fit-xl-fill{object-fit:fill!important}.object-fit-xl-scale{object-fit:scale-down!important}.object-fit-xl-none{object-fit:none!important}.d-xl-inline{display:inline!important}.d-xl-inline-block{display:inline-block!important}.d-xl-block{display:block!important}.d-xl-grid{display:grid!important}.d-xl-inline-grid{display:inline-grid!important}.d-xl-table{display:table!important}.d-xl-table-row{display:table-row!important}.d-xl-table-cell{display:table-cell!important}.d-xl-flex{display:flex!important}.d-xl-inline-flex{display:inline-flex!important}.d-xl-none{display:none!important}.flex-xl-fill{flex:1 1 auto!important}.flex-xl-row{flex-direction:row!important}.flex-xl-column{flex-direction:column!important}.flex-xl-row-reverse{flex-direction:row-reverse!important}.flex-xl-column-reverse{flex-direction:column-reverse!important}.flex-xl-grow-0{flex-grow:0!important}.flex-xl-grow-1{flex-grow:1!important}.flex-xl-shrink-0{flex-shrink:0!important}.flex-xl-shrink-1{flex-shrink:1!important}.flex-xl-wrap{flex-wrap:wrap!important}.flex-xl-nowrap{flex-wrap:nowrap!important}.flex-xl-wrap-reverse{flex-wrap:wrap-reverse!important}.justify-content-xl-start{justify-content:flex-start!important}.justify-content-xl-end{justify-content:flex-end!important}.justify-content-xl-center{justify-content:center!important}.justify-content-xl-between{justify-content:space-between!important}.justify-content-xl-around{justify-content:space-around!important}.justify-content-xl-evenly{justify-content:space-evenly!important}.align-items-xl-start{align-items:flex-start!important}.align-items-xl-end{align-items:flex-end!important}.align-items-xl-center{align-items:center!important}.align-items-xl-baseline{align-items:baseline!important}.align-items-xl-stretch{align-items:stretch!important}.align-content-xl-start{align-content:flex-start!important}.align-content-xl-end{align-content:flex-end!important}.align-content-xl-center{align-content:center!important}.align-content-xl-between{align-content:space-between!important}.align-content-xl-around{align-content:space-around!important}.align-content-xl-stretch{align-content:stretch!important}.align-self-xl-auto{align-self:auto!important}.align-self-xl-start{align-self:flex-start!important}.align-self-xl-end{align-self:flex-end!important}.align-self-xl-center{align-self:center!important}.align-self-xl-baseline{align-self:baseline!important}.align-self-xl-stretch{align-self:stretch!important}.order-xl-first{order:-1!important}.order-xl-0{order:0!important}.order-xl-1{order:1!important}.order-xl-2{order:2!important}.order-xl-3{order:3!important}.order-xl-4{order:4!important}.order-xl-5{order:5!important}.order-xl-last{order:6!important}.m-xl-0{margin:0!important}.m-xl-1{margin:.25rem!important}.m-xl-2{margin:.5rem!important}.m-xl-3{margin:1rem!important}.m-xl-4{margin:1.5rem!important}.m-xl-5{margin:3rem!important}.m-xl-auto{margin:auto!important}.mx-xl-0{margin-left:0!important;margin-right:0!important}.mx-xl-1{margin-left:.25rem!important;margin-right:.25rem!important}.mx-xl-2{margin-left:.5rem!important;margin-right:.5rem!important}.mx-xl-3{margin-left:1rem!important;margin-right:1rem!important}.mx-xl-4{margin-left:1.5rem!important;margin-right:1.5rem!important}.mx-xl-5{margin-left:3rem!important;margin-right:3rem!important}.mx-xl-auto{margin-left:auto!important;margin-right:auto!important}.my-xl-0{margin-bottom:0!important;margin-top:0!important}.my-xl-1{margin-bottom:.25rem!important;margin-top:.25rem!important}.my-xl-2{margin-bottom:.5rem!important;margin-top:.5rem!important}.my-xl-3{margin-bottom:1rem!important;margin-top:1rem!important}.my-xl-4{margin-bottom:1.5rem!important;margin-top:1.5rem!important}.my-xl-5{margin-bottom:3rem!important;margin-top:3rem!important}.my-xl-auto{margin-bottom:auto!important;margin-top:auto!important}.mt-xl-0{margin-top:0!important}.mt-xl-1{margin-top:.25rem!important}.mt-xl-2{margin-top:.5rem!important}.mt-xl-3{margin-top:1rem!important}.mt-xl-4{margin-top:1.5rem!important}.mt-xl-5{margin-top:3rem!important}.mt-xl-auto{margin-top:auto!important}.me-xl-0{margin-right:0!important}.me-xl-1{margin-right:.25rem!important}.me-xl-2{margin-right:.5rem!important}.me-xl-3{margin-right:1rem!important}.me-xl-4{margin-right:1.5rem!important}.me-xl-5{margin-right:3rem!important}.me-xl-auto{margin-right:auto!important}.mb-xl-0{margin-bottom:0!important}.mb-xl-1{margin-bottom:.25rem!important}.mb-xl-2{margin-bottom:.5rem!important}.mb-xl-3{margin-bottom:1rem!important}.mb-xl-4{margin-bottom:1.5rem!important}.mb-xl-5{margin-bottom:3rem!important}.mb-xl-auto{margin-bottom:auto!important}.ms-xl-0{margin-left:0!important}.ms-xl-1{margin-left:.25rem!important}.ms-xl-2{margin-left:.5rem!important}.ms-xl-3{margin-left:1rem!important}.ms-xl-4{margin-left:1.5rem!important}.ms-xl-5{margin-left:3rem!important}.ms-xl-auto{margin-left:auto!important}.p-xl-0{padding:0!important}.p-xl-1{padding:.25rem!important}.p-xl-2{padding:.5rem!important}.p-xl-3{padding:1rem!important}.p-xl-4{padding:1.5rem!important}.p-xl-5{padding:3rem!important}.px-xl-0{padding-left:0!important;padding-right:0!important}.px-xl-1{padding-left:.25rem!important;padding-right:.25rem!important}.px-xl-2{padding-left:.5rem!important;padding-right:.5rem!important}.px-xl-3{padding-left:1rem!important;padding-right:1rem!important}.px-xl-4{padding-left:1.5rem!important;padding-right:1.5rem!important}.px-xl-5{padding-left:3rem!important;padding-right:3rem!important}.py-xl-0{padding-bottom:0!important;padding-top:0!important}.py-xl-1{padding-bottom:.25rem!important;padding-top:.25rem!important}.py-xl-2{padding-bottom:.5rem!important;padding-top:.5rem!important}.py-xl-3{padding-bottom:1rem!important;padding-top:1rem!important}.py-xl-4{padding-bottom:1.5rem!important;padding-top:1.5rem!important}.py-xl-5{padding-bottom:3rem!important;padding-top:3rem!important}.pt-xl-0{padding-top:0!important}.pt-xl-1{padding-top:.25rem!important}.pt-xl-2{padding-top:.5rem!important}.pt-xl-3{padding-top:1rem!important}.pt-xl-4{padding-top:1.5rem!important}.pt-xl-5{padding-top:3rem!important}.pe-xl-0{padding-right:0!important}.pe-xl-1{padding-right:.25rem!important}.pe-xl-2{padding-right:.5rem!important}.pe-xl-3{padding-right:1rem!important}.pe-xl-4{padding-right:1.5rem!important}.pe-xl-5{padding-right:3rem!important}.pb-xl-0{padding-bottom:0!important}.pb-xl-1{padding-bottom:.25rem!important}.pb-xl-2{padding-bottom:.5rem!important}.pb-xl-3{padding-bottom:1rem!important}.pb-xl-4{padding-bottom:1.5rem!important}.pb-xl-5{padding-bottom:3rem!important}.ps-xl-0{padding-left:0!important}.ps-xl-1{padding-left:.25rem!important}.ps-xl-2{padding-left:.5rem!important}.ps-xl-3{padding-left:1rem!important}.ps-xl-4{padding-left:1.5rem!important}.ps-xl-5{padding-left:3rem!important}.gap-xl-0{gap:0!important}.gap-xl-1{gap:.25rem!important}.gap-xl-2{gap:.5rem!important}.gap-xl-3{gap:1rem!important}.gap-xl-4{gap:1.5rem!important}.gap-xl-5{gap:3rem!important}.row-gap-xl-0{row-gap:0!important}.row-gap-xl-1{row-gap:.25rem!important}.row-gap-xl-2{row-gap:.5rem!important}.row-gap-xl-3{row-gap:1rem!important}.row-gap-xl-4{row-gap:1.5rem!important}.row-gap-xl-5{row-gap:3rem!important}.column-gap-xl-0{-webkit-column-gap:0!important;column-gap:0!important}.column-gap-xl-1{-webkit-column-gap:.25rem!important;column-gap:.25rem!important}.column-gap-xl-2{-webkit-column-gap:.5rem!important;column-gap:.5rem!important}.column-gap-xl-3{-webkit-column-gap:1rem!important;column-gap:1rem!important}.column-gap-xl-4{-webkit-column-gap:1.5rem!important;column-gap:1.5rem!important}.column-gap-xl-5{-webkit-column-gap:3rem!important;column-gap:3rem!important}.text-xl-start{text-align:left!important}.text-xl-end{text-align:right!important}.text-xl-center{text-align:center!important}}@media (min-width:1400px){.float-xxl-start{float:left!important}.float-xxl-end{float:right!important}.float-xxl-none{float:none!important}.object-fit-xxl-contain{object-fit:contain!important}.object-fit-xxl-cover{object-fit:cover!important}.object-fit-xxl-fill{object-fit:fill!important}.object-fit-xxl-scale{object-fit:scale-down!important}.object-fit-xxl-none{object-fit:none!important}.d-xxl-inline{display:inline!important}.d-xxl-inline-block{display:inline-block!important}.d-xxl-block{display:block!important}.d-xxl-grid{display:grid!important}.d-xxl-inline-grid{display:inline-grid!important}.d-xxl-table{display:table!important}.d-xxl-table-row{display:table-row!important}.d-xxl-table-cell{display:table-cell!important}.d-xxl-flex{display:flex!important}.d-xxl-inline-flex{display:inline-flex!important}.d-xxl-none{display:none!important}.flex-xxl-fill{flex:1 1 auto!important}.flex-xxl-row{flex-direction:row!important}.flex-xxl-column{flex-direction:column!important}.flex-xxl-row-reverse{flex-direction:row-reverse!important}.flex-xxl-column-reverse{flex-direction:column-reverse!important}.flex-xxl-grow-0{flex-grow:0!important}.flex-xxl-grow-1{flex-grow:1!important}.flex-xxl-shrink-0{flex-shrink:0!important}.flex-xxl-shrink-1{flex-shrink:1!important}.flex-xxl-wrap{flex-wrap:wrap!important}.flex-xxl-nowrap{flex-wrap:nowrap!important}.flex-xxl-wrap-reverse{flex-wrap:wrap-reverse!important}.justify-content-xxl-start{justify-content:flex-start!important}.justify-content-xxl-end{justify-content:flex-end!important}.justify-content-xxl-center{justify-content:center!important}.justify-content-xxl-between{justify-content:space-between!important}.justify-content-xxl-around{justify-content:space-around!important}.justify-content-xxl-evenly{justify-content:space-evenly!important}.align-items-xxl-start{align-items:flex-start!important}.align-items-xxl-end{align-items:flex-end!important}.align-items-xxl-center{align-items:center!important}.align-items-xxl-baseline{align-items:baseline!important}.align-items-xxl-stretch{align-items:stretch!important}.align-content-xxl-start{align-content:flex-start!important}.align-content-xxl-end{align-content:flex-end!important}.align-content-xxl-center{align-content:center!important}.align-content-xxl-between{align-content:space-between!important}.align-content-xxl-around{align-content:space-around!important}.align-content-xxl-stretch{align-content:stretch!important}.align-self-xxl-auto{align-self:auto!important}.align-self-xxl-start{align-self:flex-start!important}.align-self-xxl-end{align-self:flex-end!important}.align-self-xxl-center{align-self:center!important}.align-self-xxl-baseline{align-self:baseline!important}.align-self-xxl-stretch{align-self:stretch!important}.order-xxl-first{order:-1!important}.order-xxl-0{order:0!important}.order-xxl-1{order:1!important}.order-xxl-2{order:2!important}.order-xxl-3{order:3!important}.order-xxl-4{order:4!important}.order-xxl-5{order:5!important}.order-xxl-last{order:6!important}.m-xxl-0{margin:0!important}.m-xxl-1{margin:.25rem!important}.m-xxl-2{margin:.5rem!important}.m-xxl-3{margin:1rem!important}.m-xxl-4{margin:1.5rem!important}.m-xxl-5{margin:3rem!important}.m-xxl-auto{margin:auto!important}.mx-xxl-0{margin-left:0!important;margin-right:0!important}.mx-xxl-1{margin-left:.25rem!important;margin-right:.25rem!important}.mx-xxl-2{margin-left:.5rem!important;margin-right:.5rem!important}.mx-xxl-3{margin-left:1rem!important;margin-right:1rem!important}.mx-xxl-4{margin-left:1.5rem!important;margin-right:1.5rem!important}.mx-xxl-5{margin-left:3rem!important;margin-right:3rem!important}.mx-xxl-auto{margin-left:auto!important;margin-right:auto!important}.my-xxl-0{margin-bottom:0!important;margin-top:0!important}.my-xxl-1{margin-bottom:.25rem!important;margin-top:.25rem!important}.my-xxl-2{margin-bottom:.5rem!important;margin-top:.5rem!important}.my-xxl-3{margin-bottom:1rem!important;margin-top:1rem!important}.my-xxl-4{margin-bottom:1.5rem!important;margin-top:1.5rem!important}.my-xxl-5{margin-bottom:3rem!important;margin-top:3rem!important}.my-xxl-auto{margin-bottom:auto!important;margin-top:auto!important}.mt-xxl-0{margin-top:0!important}.mt-xxl-1{margin-top:.25rem!important}.mt-xxl-2{margin-top:.5rem!important}.mt-xxl-3{margin-top:1rem!important}.mt-xxl-4{margin-top:1.5rem!important}.mt-xxl-5{margin-top:3rem!important}.mt-xxl-auto{margin-top:auto!important}.me-xxl-0{margin-right:0!important}.me-xxl-1{margin-right:.25rem!important}.me-xxl-2{margin-right:.5rem!important}.me-xxl-3{margin-right:1rem!important}.me-xxl-4{margin-right:1.5rem!important}.me-xxl-5{margin-right:3rem!important}.me-xxl-auto{margin-right:auto!important}.mb-xxl-0{margin-bottom:0!important}.mb-xxl-1{margin-bottom:.25rem!important}.mb-xxl-2{margin-bottom:.5rem!important}.mb-xxl-3{margin-bottom:1rem!important}.mb-xxl-4{margin-bottom:1.5rem!important}.mb-xxl-5{margin-bottom:3rem!important}.mb-xxl-auto{margin-bottom:auto!important}.ms-xxl-0{margin-left:0!important}.ms-xxl-1{margin-left:.25rem!important}.ms-xxl-2{margin-left:.5rem!important}.ms-xxl-3{margin-left:1rem!important}.ms-xxl-4{margin-left:1.5rem!important}.ms-xxl-5{margin-left:3rem!important}.ms-xxl-auto{margin-left:auto!important}.p-xxl-0{padding:0!important}.p-xxl-1{padding:.25rem!important}.p-xxl-2{padding:.5rem!important}.p-xxl-3{padding:1rem!important}.p-xxl-4{padding:1.5rem!important}.p-xxl-5{padding:3rem!important}.px-xxl-0{padding-left:0!important;padding-right:0!important}.px-xxl-1{padding-left:.25rem!important;padding-right:.25rem!important}.px-xxl-2{padding-left:.5rem!important;padding-right:.5rem!important}.px-xxl-3{padding-left:1rem!important;padding-right:1rem!important}.px-xxl-4{padding-left:1.5rem!important;padding-right:1.5rem!important}.px-xxl-5{padding-left:3rem!important;padding-right:3rem!important}.py-xxl-0{padding-bottom:0!important;padding-top:0!important}.py-xxl-1{padding-bottom:.25rem!important;padding-top:.25rem!important}.py-xxl-2{padding-bottom:.5rem!important;padding-top:.5rem!important}.py-xxl-3{padding-bottom:1rem!important;padding-top:1rem!important}.py-xxl-4{padding-bottom:1.5rem!important;padding-top:1.5rem!important}.py-xxl-5{padding-bottom:3rem!important;padding-top:3rem!important}.pt-xxl-0{padding-top:0!important}.pt-xxl-1{padding-top:.25rem!important}.pt-xxl-2{padding-top:.5rem!important}.pt-xxl-3{padding-top:1rem!important}.pt-xxl-4{padding-top:1.5rem!important}.pt-xxl-5{padding-top:3rem!important}.pe-xxl-0{padding-right:0!important}.pe-xxl-1{padding-right:.25rem!important}.pe-xxl-2{padding-right:.5rem!important}.pe-xxl-3{padding-right:1rem!important}.pe-xxl-4{padding-right:1.5rem!important}.pe-xxl-5{padding-right:3rem!important}.pb-xxl-0{padding-bottom:0!important}.pb-xxl-1{padding-bottom:.25rem!important}.pb-xxl-2{padding-bottom:.5rem!important}.pb-xxl-3{padding-bottom:1rem!important}.pb-xxl-4{padding-bottom:1.5rem!important}.pb-xxl-5{padding-bottom:3rem!important}.ps-xxl-0{padding-left:0!important}.ps-xxl-1{padding-left:.25rem!important}.ps-xxl-2{padding-left:.5rem!important}.ps-xxl-3{padding-left:1rem!important}.ps-xxl-4{padding-left:1.5rem!important}.ps-xxl-5{padding-left:3rem!important}.gap-xxl-0{gap:0!important}.gap-xxl-1{gap:.25rem!important}.gap-xxl-2{gap:.5rem!important}.gap-xxl-3{gap:1rem!important}.gap-xxl-4{gap:1.5rem!important}.gap-xxl-5{gap:3rem!important}.row-gap-xxl-0{row-gap:0!important}.row-gap-xxl-1{row-gap:.25rem!important}.row-gap-xxl-2{row-gap:.5rem!important}.row-gap-xxl-3{row-gap:1rem!important}.row-gap-xxl-4{row-gap:1.5rem!important}.row-gap-xxl-5{row-gap:3rem!important}.column-gap-xxl-0{-webkit-column-gap:0!important;column-gap:0!important}.column-gap-xxl-1{-webkit-column-gap:.25rem!important;column-gap:.25rem!important}.column-gap-xxl-2{-webkit-column-gap:.5rem!important;column-gap:.5rem!important}.column-gap-xxl-3{-webkit-column-gap:1rem!important;column-gap:1rem!important}.column-gap-xxl-4{-webkit-column-gap:1.5rem!important;column-gap:1.5rem!important}.column-gap-xxl-5{-webkit-column-gap:3rem!important;column-gap:3rem!important}.text-xxl-start{text-align:left!important}.text-xxl-end{text-align:right!important}.text-xxl-center{text-align:center!important}}@media (min-width:1200px){.fs-1{font-size:2.5rem!important}.fs-2{font-size:2rem!important}.fs-3{font-size:1.75rem!important}.fs-4{font-size:1.5rem!important}}@media print{.d-print-inline{display:inline!important}.d-print-inline-block{display:inline-block!important}.d-print-block{display:block!important}.d-print-grid{display:grid!important}.d-print-inline-grid{display:inline-grid!important}.d-print-table{display:table!important}.d-print-table-row{display:table-row!important}.d-print-table-cell{display:table-cell!important}.d-print-flex{display:flex!important}.d-print-inline-flex{display:inline-flex!important}.d-print-none{display:none!important}}@font-face{font-display:swap;font-family:Lato;font-style:normal;font-weight:400;src:url(/apps/sme-visualisations/static/media/Lato-Regular.2b7b7f6c8554ad96436b.ttf) format("truetype")}@font-face{font-display:swap;font-family:Lato;font-style:normal;font-weight:700 900;src:url(/apps/sme-visualisations/static/media/Lato-Black.0f56360fd2c505dd13fa.ttf) format("truetype")}:root{--silicon-ink:#263d45;--silicon-cyan:#006d7a;--silicon-paper:#f4f8f8;--silicon-line:#c5d5d8;--silicon-yellow:#ffc700;--silicon-red:#ba302c}body{-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;background-color:#f4f8f8;background-color:var(--silicon-paper);background-image:radial-gradient(#c5d5d866 .7px,transparent 0);background-size:16px 16px;color:#263d45;color:var(--silicon-ink);font-family:Lato,sans-serif;margin:0}code{color:#006d7a;color:var(--silicon-cyan);font-family:ui-monospace,Menlo,Consolas,monospace}h1,h2{text-wrap:balance;font-weight:900}h1{font-size:clamp(1.65rem,3vw,2.75rem);letter-spacing:-.025em}h2{font-size:clamp(1.05rem,1.8vw,1.5rem)}a{color:#006d7a;color:var(--silicon-cyan)}:focus-visible{outline:3px solid #006d7a;outline:3px solid var(--silicon-cyan);outline-offset:4px}#root>.container-fluid{padding:clamp(1rem,3vw,3rem)}#root>.container-fluid>header{border-bottom:1px solid #c5d5d8;border-bottom:1px solid var(--silicon-line);margin-bottom:2rem;padding:1rem 0 1.75rem;row-gap:1.5rem}#description{margin:.75rem auto 0;max-width:65ch}.btn{border-radius:2px;box-shadow:0 3px 5px #263d4514;font-weight:700;min-height:42px;transition:background-color .14s ease-out,box-shadow .14s ease-out}.btn-primary{background-color:#006d7a;background-color:var(--silicon-cyan);border-color:#006d7a;border-color:var(--silicon-cyan);color:#fff}.btn-primary.active,.btn-primary:active,.btn-primary:focus,.btn-primary:hover{background-color:#004e59;border-color:#004e59;color:#fff}.btn-primary:disabled{background-color:#006d7a;background-color:var(--silicon-cyan);border-color:#006d7a;border-color:var(--silicon-cyan)}.btn:focus-visible{box-shadow:none;outline:3px solid #006d7a;outline:3px solid var(--silicon-cyan);outline-offset:3px}.btn:disabled{box-shadow:none}.text-danger{color:#ba302c!important;color:var(--silicon-red)!important}.silicon-grid{-webkit-font-feature-settings:"tnum";font-feature-settings:"tnum";font-variant-numeric:tabular-nums;overflow:visible;width:100%}.silicon-grid-cell{shape-rendering:crispEdges}.silicon-grid-depth{fill:#6a858d;pointer-events:none}#root>.silicon-directory{max-width:1240px;padding:clamp(1.5rem,5vw,5rem) clamp(1.25rem,5vw,4rem)}.directory-heading{align-items:center;display:flex;gap:2rem;justify-content:space-between;margin-bottom:clamp(2rem,5vw,4rem)}.directory-heading h1{color:#006d7a;color:var(--silicon-cyan);font-size:clamp(2.75rem,6vw,5rem);line-height:1.05;margin:0;max-width:11ch}.directory-die{flex:0 0 auto;image-rendering:pixelated;width:clamp(112px,20vw,210px)}.directory-board{background:#dce9eb;-webkit-clip-path:polygon(0 0,calc(100% - 16px) 0,100% 16px,100% 100%,16px 100%,0 calc(100% - 16px));clip-path:polygon(0 0,calc(100% - 16px) 0,100% 16px,100% 100%,16px 100%,0 calc(100% - 16px));padding:clamp(1rem,2.8vw,2rem)}.die-directory{grid-gap:1.25rem;display:grid;gap:1.25rem;grid-template-columns:repeat(3,minmax(0,1fr))}.die-directory .nav-item{min-width:0}.die-directory .nav-link{align-items:flex-end;background:#263d45;background:var(--silicon-ink);box-shadow:3px 5px 7px #263d4526;color:#fff;display:flex;font-size:1.05rem;font-weight:700;height:100%;line-height:1.4;min-height:145px;padding:2.25rem 1.25rem 1.25rem;position:relative;transition:background-color .16s ease-out,-webkit-transform .16s ease-out;transition:background-color .16s ease-out,transform .16s ease-out;transition:background-color .16s ease-out,transform .16s ease-out,-webkit-transform .16s ease-out}.die-directory .nav-link:before{background:#a8dde0;box-shadow:12px 0 #a8dde0,24px 0 #a8dde0;content:"";height:8px;left:20px;pointer-events:none;position:absolute;top:16px;width:8px}.die-directory .nav-link:focus-visible:before,.die-directory .nav-link:hover:before{background:#ffc700;background:var(--silicon-yellow)}.die-directory .nav-link:hover{background:#005966;-webkit-transform:translateY(-2px);transform:translateY(-2px)}.die-directory .nav-link:focus-visible{outline-color:#006d7a;outline-color:var(--silicon-cyan);outline-offset:4px}@media (max-width:700px){#root>.container-fluid>header>.col{flex:1 0 100%}.directory-heading{gap:1rem}.directory-heading h1{font-size:clamp(2rem,7.5vw,3.25rem)}.directory-die{width:88px}.die-directory{gap:1rem;grid-template-columns:repeat(2,minmax(0,1fr))}.die-directory .nav-link{font-size:.95rem;min-height:144px;padding:2.25rem .85rem 1rem}}@media (max-width:360px){.directory-die{width:72px}.directory-heading h1{font-size:1.8rem}}@media (prefers-reduced-motion:reduce){.btn,.die-directory .nav-link{transition:none}.die-directory .nav-link:hover{-webkit-transform:none;transform:none}}#root>.container,#root>.container-fluid{min-height:0}.silicon-grid{display:block;height:auto;margin-left:auto;margin-right:auto;max-width:100%}.sme-gemm-responsive-titles h2{font-size:clamp(.75rem,min(1.5vw,2.2dvh),1.5rem);line-height:1.15}.sme-gemm-responsive-titles .row .row h2{font-size:clamp(.65rem,min(1.25vw,1.9dvh),1.25rem)}#root>.container-fluid.sme-gemm-responsive-titles{padding:clamp(6px,min(1.5vw,1.5dvh),3rem)}#root>.container-fluid.sme-gemm-responsive-titles>header{margin-bottom:clamp(.25rem,min(1.5vw,1.5dvh),2rem);padding-bottom:clamp(.2rem,min(1vw,1dvh),1.75rem);padding-top:clamp(.2rem,min(1vw,1dvh),1rem);row-gap:clamp(.25rem,min(1vw,1dvh),1.5rem)}.sme-gemm-responsive-titles>header h1{font-size:clamp(.85rem,min(2.7vw,3.2dvh),2.75rem);line-height:1.1}.sme-gemm-responsive-titles>.row.mt-4{margin-top:clamp(.25rem,min(1.4vw,1.4dvh),1.5rem)!important}#root>.container-fluid.sme-gemm-responsive-titles>header #description{font-size:clamp(.7rem,min(1.15vw,1.6dvh),1rem);line-height:1.25}#root>.container-fluid.sme-gemm-responsive-titles>header .btn-group .btn{font-size:clamp(.7rem,min(1vw,1.5dvh),1rem);line-height:1.2;min-height:clamp(26px,min(3vw,4dvh),42px);padding:clamp(3px,min(.5vw,.6dvh),8px) clamp(5px,min(.7vw,.8dvh),12px)}#root>.container-fluid.sme-gemm-responsive-titles>header .btn-group .btn svg{height:clamp(12px,min(1.2vw,1.8dvh),20px);width:clamp(12px,min(1.2vw,1.8dvh),20px)}#root>.container-fluid.sme-gemm-responsive-titles>header .col{min-width:0}#root>.container-fluid.sme-gemm-responsive-titles>header .btn-group{max-width:100%} +/*# sourceMappingURL=main.790bcbb3.css.map*/ \ No newline at end of file diff --git a/static/apps/sme-visualisations/static/js/main.b8decb63.js b/static/apps/sme-visualisations/static/js/main.b8decb63.js deleted file mode 100644 index db3361f860..0000000000 --- a/static/apps/sme-visualisations/static/js/main.b8decb63.js +++ /dev/null @@ -1,3 +0,0 @@ -/*! For license information please see https://learn.arm.com/apps/sme-visualisations/static/js/main.b8decb63.js.LICENSE.txt */ -!function(){var e={694:function(e,t){var n;!function(){"use strict";var r={}.hasOwnProperty;function a(){for(var e=[],t=0;t>",u=i||r;if(null==n[r])return t?new Error("Required "+o+" `"+u+"` was not specified in `"+l+"`."):null;for(var s=arguments.length,c=Array(s>6?s-6:0),f=6;f