#!/usr/bin/env bash
#shellcheck disable=SC1001,1083,2016,2046,2086,2155,2206,2207,2068,2071,2076,2162
export LC_ALL=C

# Here the quick 'n dirty guide to adding a new OS to quickget
#
#    1. Update os_support() - add new OS, all lowercase
#    2. Update pretty_name() - add a pretty name for new OS *only if the catch all is not suitable*
#    3. Update os_homepage() - add a homepage for new OS
#    4. Create a releases_newos() generator (required) outputs the current supported release versions
#    5. Create a editions_newos() generator (optional) outputs the editions if new OS has multiple flavours/editions
#    6. Update make_vm_config() - add any *required* new OS tweaks
#    7. Create a get_newos() function - that does something like this:
#
#function get_newos() {
#    local EDITION="${1:-}"
#    local HASH=""
#    local ISO="newos-${RELEASE}-${EDITION}-amd64.iso"
#    local URL="https://www.newos.org/download/${RELEASE}/${EDITION}"
#
#    HASH=$(wget -q -O- "${URL}/SHA512SUMS" | grep "${ISO}" | cut_1)
#    echo "${URL}/${ISO} ${HASH}"
#}

function cleanup() {
    if [ -n "$(jobs -p)" ]; then
        kill "$(jobs -p)"
    fi
}

function os_info() {
    local SIMPLE_NAME=""
    local INFO=""
    SIMPLE_NAME="${1}"
    case ${SIMPLE_NAME} in
      alma)             INFO="Alma Linux|Fedora,RedHat||https://almalinux.org/|Community owned and governed, forever-free enterprise Linux distribution, focused on long-term stability, providing a robust production-grade platform. AlmaLinux OS is binary compatible with RHEL®.";;
      alpine)           INFO="Alpine Linux|Independent||https://alpinelinux.org/|Security-oriented, lightweight Linux distribution based on musl libc and busybox.";;
      android)          INFO="Android x86|Independent||https://www.android-x86.org/|Port Android Open Source Project to x86 platform.";;
      antix)            INFO="Antix|Debian||https://antixlinux.com/|Fast, lightweight and easy to install systemd-free linux live CD distribution based on Debian Stable for Intel-AMD x86 compatible systems.";;
      artix)            INFO="Artix Linux|Arch||https://artixlinux.org/|The Art of Linux. Simple. Fast. Systemd-free.";;
      archlinux)        INFO="Arch Linux|Independent||https://archlinux.org/|Lightweight and flexible Linux® distribution that tries to Keep It Simple.";;
      archcraft)        INFO="Archcraft|Arch||https://archcraft.io/|Yet another minimal Linux distribution, based on Arch Linux.";;
      arcolinux)        INFO="Arco Linux|Arch||https://arcolinux.com/|Is all about becoming an expert in linux.";;
      athenaos)         INFO="Athena OS|Arch||https://athenaos.org/|Offer a different experience than the most used pentesting distributions by providing only tools that fit with the user needs and improving the access to hacking resources and learning materials.";;
      batocera)         INFO="Batocera|Independent||https://batocera.org/|Retro-gaming distribution with the aim of turning any computer/nano computer into a gaming console during a game or permanently.";;
      bazzite)          INFO="bazzite|Fedora,SteamOS||https://github.com/ublue-os/bazzite/|Container native gaming and a ready-to-game SteamOS like.";;
      blendos)          INFO="BlendOS|Arch||https://blendos.co/|A seamless blend of all Linux distributions. Allows you to have an immutable, atomic and declarative Arch Linux system, with application support from several Linux distributions & Android.";;
      bodhi)            INFO="Bodhi|Debian,Ubuntu||https://www.bodhilinux.com/|Lightweight distribution featuring the fast & fully customizable Moksha Desktop.";;
      bunsenlabs)       INFO="Bunsenlab|Debian||https://www.bunsenlabs.org/|Light-weight and easily customizable Openbox desktop. The project is a community continuation of CrunchBang Linux.";;
      cachyos)          INFO="CachyOS|Arch||https://cachyos.org/|Designed to deliver lightning-fast speeds and stability, ensuring a smooth and enjoyable computing experience every time you use it.";;
      centos-stream)    INFO="CentOS Stream|Fedora,RedHat||https://www.centos.org/centos-stream/|Continuously delivered distro that tracks just ahead of Red Hat Enterprise Linux (RHEL) development, positioned as a midstream between Fedora Linux and RHEL.";;
      chimeralinux)     INFO="Chimera Linux|Independent|anon:chimera root:chimera|https://chimera-linux.org/|Modern, general-purpose non-GNU Linux distribution.";;
      crunchbang++)     INFO="#!++|Debian||https://www.crunchbangplusplus.org/|The classic minimal crunchbang feel, now with debian 12 bookworm.";;
      debian)           INFO="Debian|Independent||https://www.debian.org/|Complete Free Operating System with perfect level of ease of use and stability.";;
      deepin)           INFO="Deepin|Debian||https://www.deepin.org/|Beautiful UI design, intimate human-computer interaction, and friendly community environment make you feel at home.";;
      devuan)           INFO="Devuan|Debian||https://www.devuan.org/|Fork of Debian without systemd that allows users to reclaim control over their system by avoiding unnecessary entanglements and ensuring Init Freedom.";;
      dragonflybsd)     INFO="DragonFlyBSD|FreeBSD||https://www.dragonflybsd.org/|Provides an opportunity for the BSD base to grow in an entirely different direction from the one taken in the FreeBSD, NetBSD, and OpenBSD series.";;
      easyos)           INFO="EasyOS|Independent||https://easyos.org/|Experimental distribution designed from scratch to support containers.";;
      edubuntu)         INFO="Edubuntu|Ubuntu||https://www.edubuntu.org/|Stable, secure and privacy concious option for schools.";;
      elementary)       INFO="elementary OS|Debian,Ubuntu||https://elementary.io/|Thoughtful, capable, and ethical replacement for Windows and macOS.";;
      endeavouros)      INFO="EndeavourOS|Arch||https://endeavouros.com/|Provides an Arch experience without the hassle of installing it manually for both x86_64 and ARM systems.";;
      endless)          INFO="Endless OS|Debian||https://www.endlessos.org/os|Completely Free, User-Friendly Operating System Packed with Educational Tools, Games, and More.";;
      fedora)           INFO="Fedora|Independent||https://www.fedoraproject.org/|Innovative platform for hardware, clouds, and containers, built with love by you.";;
      freebsd)          INFO="FreeBSD|Independent||https://www.freebsd.org/|Operating system used to power modern servers, desktops, and embedded platforms.";;
      freedos)          INFO="FreeDOS|Independent||https://freedos.org/|DOS-compatible operating system that you can use to play classic DOS games, run legacy business software, or develop embedded systems.";;
      garuda)           INFO="Garuda Linux|Arch||https://garudalinux.org/|Feature rich and easy to use Linux distribution.";;
      gentoo)           INFO="Gentoo|Independent||https://www.gentoo.org/|Highly flexible, source-based Linux distribution.";;
      ghostbsd)         INFO="GhostBSD|FreeBSD||https://www.ghostbsd.org/|Simple, elegant desktop BSD Operating System.";;
      haiku)            INFO="Haiku|Independent||https://www.haiku-os.org/|Specifically targets personal computing. Inspired by the BeOS, Haiku is fast, simple to use, easy to learn and yet very powerful.";;
      holoiso)          INFO="SteamOS HoloISO|Arch,SteamOS||https://github.com/HoloISO/holoiso|Bring the Steam Decks SteamOS Holo redistribution and provide a close-to-official SteamOS experience.";;
      kali)             INFO="Kali|Debian||https://www.kali.org/|The most advanced Penetration Testing Distribution.";;
      kdeneon)          INFO="KDE Neon|Debian,Ubuntu||https://neon.kde.org/|Latest and greatest of KDE community software packaged on a rock-solid base.";;
      kolibrios)        INFO="KolibriOS|Independent||http://kolibrios.org/en/|Tiny yet incredibly powerful and fast operating system.";;
      kubuntu)          INFO="Kubuntu|Ubuntu||https://kubuntu.org/|Free, complete, and open-source alternative to Microsoft Windows and Mac OS X which contains everything you need to work, play, or share.";;
      linuxlite)        INFO="Linux Lite|Debian,Ubuntu||https://www.linuxliteos.com/|Your first simple, fast and free stop in the world of Linux.";;
      linuxmint)        INFO="Linux Mint|Debian,Ubuntu||https://linuxmint.com/|Designed to work out of the box and comes fully equipped with the apps most people need.";;
      lmde)             INFO="Linux Mint Debian Edition|Debian||https://www.linuxmint.com/download_lmde.php|Aims to be as similar as possible to Linux Mint, but without using Ubuntu. The package base is provided by Debian instead.";;
      lubuntu)          INFO="Lubuntu|Ubuntu||https://lubuntu.me/|Complete Operating System that ships the essential apps and services for daily use: office applications, PDF reader,  image editor, music and video players, etc. Using lightwave lxde/lxqt.";;
      mageia)           INFO="Mageia|Independent||https://www.mageia.org/|Stable, secure operating system for desktop & server.";;
      manjaro)          INFO="Manjaro|Arch||https://manjaro.org/|Versatile, free, and open-source Linux operating system designed with a strong focus on safeguarding user privacy and offering extensive control over hardware.";;
      mxlinux)          INFO="MX Linux|Debian,Antix||https://mxlinux.org/|Designed to combine elegant and efficient desktops with high stability and solid performance.";;
      netboot)          INFO="netboot.xyz|iPXE||https://netboot.xyz/|Your favorite operating systems in one place.";;
      netbsd)           INFO="NetBSD|Independent||https://www.netbsd.org/|Free, fast, secure, and highly portable Unix-like Open Source operating system. It is available for a wide range of platforms, from large-scale servers and powerful desktop systems to handheld and embedded devices.";;
      nixos)            INFO="NixOS|Independent||https://nixos.org/|Linux distribution based on Nix package manager, tool that takes a unique approach to package management and system configuration.";;
      macos)            INFO="macOS|proprietary||https://www.apple.com/macos/|Work and play on your Mac are even more powerful. Elevate your presence on video calls. Access information in all-new ways. Boost gaming performance. And discover even more ways to personalize your Mac.";;
      openbsd)          INFO="OpenBSD|Independent||https://www.openbsd.org/|FREE, multi-platform 4.4BSD-based UNIX-like operating system. Our efforts emphasize portability, standardization, correctness, proactive security and integrated cryptography.";;
      openindiana)      INFO="OpenIndiana|Solaris,OpenSolaris||https://www.openindiana.org/|Community supported illumos-based operating system.";;
      opensuse)         INFO="openSUSE|Independent||https://www.opensuse.org/|The makers choice for sysadmins, developers and desktop users.";;
      oraclelinux)      INFO="Oracle Linux|RedHat||https://www.oracle.com/linux/|Linux with everything required to deploy, optimize, and manage applications on-premises, in the cloud, and at the edge.";;
      parrotsec)        INFO="Parrot Security|Debian|parrot:parrot|https://www.parrotsec.org/|Provides a huge arsenal of tools, utilities and libraries that IT and security professionals can use to test and assess the security of their assets in a reliable, compliant and reproducible way.";;
      peppermint)       INFO="PeppermintOS|Debian,Devuan||https://peppermintos.com/|Provides a user with the opportunity to build the system that best fits their needs. While at the same time providing a functioning OS with minimum hassle out of the box.";;
      popos)            INFO="Pop!_OS|Ubuntu||https://pop.system76.com/|Operating system for STEM and creative professionals who use their computer as a tool to discover and create.";;
      porteus)          INFO="Porteus|Slackware||http://www.porteus.org/|Complete linux operating system that is optimized to run from CD, USB flash drive, hard drive, or other bootable storage media.";;
      primtux)          INFO="PrimTux|Ubuntu||https://primtux.fr/|Upgrade for obsolete equipment and benefiting the school or educational environment in the spirit of education.";;
      reactos)          INFO="ReactOS|Independent||https://reactos.org/|Imagine running your favorite Windows applications and drivers in an open-source environment you can trust.";;
      rebornos)         INFO="RebornOS|Arch||https://rebornos.org/|Aiming to make Arch Linux as user friendly as possible by providing interface solutions to things you normally have to do in a terminal.";;
      rockylinux)       INFO="Rocky Linux|RedHat||https://rockylinux.org/|Open-source enterprise operating system designed to be 100% bug-for-bug compatible with Red Hat Enterprise Linux®.";;
      siduction)        INFO="Siduction|Debian||https://siduction.org/|Operating system based on the Linux kernel and the GNU project. In addition, there are applications and libraries from Debian.";;
      slackware)        INFO="Slackware|Independent||http://www.slackware.com/|Advanced Linux operating system, designed with the twin goals of ease of use and stability as top priorities.";;
      slax)             INFO="Slax|Debian Slackware||https://www.slax.org/|Compact, fast, and modern Linux operating system that combines sleek design with modular approach. With the ability to run directly from a USB flash drive without the need for installation, Slax is truly portable and fits easily in your pocket.";;
      slint)            INFO="Slint|Slackware||https://slint.fr/|Slint is an easy-to-use, versatile, blind-friendly Linux distribution for 64-bit computers. Slint is based on Slackware and borrows tools from Salix. Maintainer: Didier Spaier.";;
      slitaz)           INFO="SliTaz|Independent||https://www.slitaz.org/en/|Simple, fast and low resource Linux OS for servers & desktops.";;
      solus)            INFO="Solus|Independent||https://getsol.us/|Designed for home computing. Every tweak enables us to deliver a cohesive computing experience.";;
      sparkylinux)      INFO="SparkyLinux|Debian||https://sparkylinux.org/|Fast, lightweight and fully customizable operating system which offers several versions for different use cases.";;
      spirallinux)      INFO="Spiral Linux|Debian||https://spirallinux.github.io/|Selection of Linux spins built from Debian GNU/Linux, with a focus on simplicity and out-of-the-box usability across all the major desktop environments.";;
      tails)            INFO="Tails|Debian||https://tails.net/|Portable operating system that protects against surveillance and censorship.";;
      tinycore)         INFO="Tiny Core Linux|Independent||http://www.tinycorelinux.net/|Highly modular based system with community build extensions.";;
      trisquel)         INFO="Trisquel|Debian,Ubuntu||https://trisquel.info/|Fully free operating system for home users, small enterprises and educational centers.";;
      truenas-core)     INFO="TrueNAS Core|FreeBSD||https://www.truenas.com/truenas-core/|World’s most popular storage OS because it gives you the power to build your own professional-grade storage system to use in a variety of data-intensive applications without any software costs.";;
      truenas-scale)    INFO="TrueNAS Scale|Debian||https://www.truenas.com/truenas-scale/|Open Source Hyperconverged Infrastructure (HCI) solution. In addition to powerful scale-out storage capabilities, SCALE adds Linux Containers and VMs (KVM) so apps run closer to data.";;
      ubuntu)           INFO="Ubuntu|Debian||https://ubuntu.com/|Complete desktop Linux operating system, freely available with both community and professional support.";;
      ubuntu-budgie)    INFO="Ubuntu Budgie|Ubuntu||https://ubuntubudgie.org/|Community developed distribution, integrating the Budgie Desktop Environment with Ubuntu at its core.";;
      ubuntucinnamon)   INFO="Ubuntu Cinnamon|Ubuntu||https://ubuntucinnamon.org/|Community-driven, featuring Linux Mint’s Cinnamon Desktop with Ubuntu at the core, packed fast and full of features, here is the most traditionally modern desktop you will ever love.";;
      ubuntukylin)      INFO="Ubuntu Kylin|Ubuntu||https://ubuntukylin.com/|Universal desktop operating system for personal computers, laptops, and embedded devices. It is dedicated to bringing a smarter user experience to users all over the world.";;
      ubuntu-mate)      INFO="Ubuntu MATE|Ubuntu||https://ubuntu-mate.org/|Stable, easy-to-use operating system with a configurable desktop environment. It is ideal for those who want the most out of their computers and prefer a traditional desktop metaphor. Using Mate desktop.";;
      ubuntu-server)    INFO="Ubuntu Server|Ubuntu||https://ubuntu.com/server|Brings economic and technical scalability to your datacentre, public or private. Whether you want to deploy an OpenStack cloud, a Kubernetes cluster or a 50,000-node render farm, Ubuntu Server delivers the best value scale-out performance available.";;
      ubuntustudio)     INFO="Ubuntu Studio|Ubuntu||https://ubuntustudio.org/|Comes preinstalled with a selection of the most common free multimedia applications available, and is configured for best performance for various purposes: Audio, Graphics, Video, Photography and Publishing.";;
      ubuntu-unity)     INFO="Ubuntu Unity|Ubuntu||https://ubuntuunity.org/|Flavor of Ubuntu featuring the Unity7 desktop environment (the default desktop environment used by Ubuntu from 2010-2017).";;
      vanillaos)        INFO="Vanilla OS|Debian,Ubuntu||https://vanillaos.org/|Designed to be a reliable and productive operating system for your daily work.";;
      void)             INFO="Void Linux|Independent|anon:voidlinux|https://voidlinux.org/|General purpose operating system. Its package system allows you to quickly install, update and remove software; software is provided in binary packages or can be built directly from sources.";;
      vxlinux)          INFO="VX Linux|Void||https://vxlinux.org/|Pre-configured, secure systemd-free Plasma desktop with focus on convenience, performance and simplicity. Based on the excellent Void Linux.";;
      whonix)           INFO="Whonix|Debian||https://www.whonix.org/|Superior Internet Privacy with Whonix™ As handy as an app - delivering maximum anonymity and security.";;
      windows)          INFO="Windows|proprietary||https://www.microsoft.com/en-us/windows/|Whether you’re gaming, studying, running a business, or running a household, Windows helps you get it done.";;
      windows-server)   INFO="Windows Server|proprietary||https://www.microsoft.com/en-us/windows-server/|Platform for building an infrastructure of connected applications, networks, and web services.";;
      xerolinux)        INFO="XeroLinux|Arch||https://xerolinux.xyz/|Arch-Based Distro, that provides you with an easy way to install Arch and a well optimized, beautifully Customized Plasma Desktop, that you can later shape to suite your needs!";;
      xubuntu)          INFO="Xubuntu|Ubuntu||https://xubuntu.org/|Elegant and easy to use operating system. Xubuntu comes with Xfce, which is a stable, light and configurable desktop environment.";;
      zorin)            INFO="Zorin OS|Ubuntu||https://zorin.com/os/|Alternative to Windows and macOS designed to make your computer faster, more powerful, secure, and privacy-respecting.";;
    esac
    echo "${INFO}"
}

function pretty_name() {
    local SIMPLE_NAME=""
    local PRETTY_NAME=""
    SIMPLE_NAME="${1}"
    PRETTY_NAME=$(os_info ${SIMPLE_NAME} | cut -d'|' -f1)
    echo "${PRETTY_NAME}"
}

function os_basedof() {
    local SIMPLE_NAME=""
    local BASED=""
    SIMPLE_NAME="${1}"
    BASED=$(os_info ${SIMPLE_NAME} | cut -d'|' -f2)
    echo "${BASED}"
}

function os_credentials() {
    local SIMPLE_NAME=""
    local CREDE=""
    SIMPLE_NAME="${1}"
    CREDE=$(os_info ${SIMPLE_NAME} | cut -d'|' -f3)
    echo "${CREDE}"
}

function os_homepage(){
    local SIMPLE_NAME=""
    local HOMEP=""
    SIMPLE_NAME="${1}"
    HOMEP=$(os_info ${SIMPLE_NAME} | cut -d'|' -f4)
    echo "$HOMEP"
}

function os_about() {
    local SIMPLE_NAME=""
    local ABOUT=""
    SIMPLE_NAME="${1}"
    ABOUT=$(os_info ${SIMPLE_NAME} | cut -d'|' -f5)
    echo "${ABOUT}"
}

function validate_release() {
    local DISPLAY_NAME=""
    local RELEASE_GENERATOR=""
    local RELEASES=""

    DISPLAY_NAME="$(pretty_name "${OS}")"
    case ${OS} in
      *ubuntu-server*) RELEASE_GENERATOR="releases_ubuntu-server";;
      *ubuntu*) RELEASE_GENERATOR="releases_ubuntu";;
      *) RELEASE_GENERATOR="${1}";;
    esac

    RELEASES=$(${RELEASE_GENERATOR})
    if [[ ! " ${RELEASES[*]} " =~ " ${RELEASE} " ]]; then
        echo -e "ERROR! ${DISPLAY_NAME} ${RELEASE} is not a supported release."
        echo " - Releases: ${RELEASES}"
        exit 1
    fi
}

function list_json() {
    # Reference: https://stackoverflow.com/a/67359273
    list_csv | jq -R 'split(",") as $h|reduce inputs as $in ([]; . += [$in|split(",")|. as $a|reduce range(0,length) as $i ({};.[$h[$i]]=$a[$i])])'
    exit 0
}

function list_csv() {
  local DISPLAY_NAME
  local DL=""
  local DOWNLOADER
  local FUNC
  local OPTION
  local OS
  local PNG
  local RELEASE
  local SVG
  local HAS_ZSYNC=0

  # Check if zsync is available
  if command -v zsync &>/dev/null; then
    HAS_ZSYNC=1
  fi

  if command -v aria2c &>/dev/null; then
    DL="aria2c"
  elif command -v wget &>/dev/null; then
    DL="wget"
  fi

  echo "Display Name,OS,Release,Option,Downloader,PNG,SVG"
  for OS in $(os_support); do
    DISPLAY_NAME="$(pretty_name "${OS}")"

    case ${OS} in
      *ubuntu-server*) FUNC="ubuntu-server";;
      *ubuntu*) FUNC="ubuntu";;
      *) FUNC="${OS}";;
    esac

    PNG="https://quickemu-project.github.io/quickemu-icons/png/${FUNC}/${FUNC}-quickemu-white-pinkbg.png"
    SVG="https://quickemu-project.github.io/quickemu-icons/svg/${FUNC}/${FUNC}-quickemu-white-pinkbg.svg"

    for RELEASE in $("releases_${FUNC}" | sed -Ee 's/eol-\S+//g' ); do # hide eol releases
      if [[ "${OS}" == *"ubuntu"* ]] && [ "${RELEASE}" == "devel" ] && [ ${HAS_ZSYNC} -eq 1 ]; then
        DOWNLOADER="zsync"
      else
        DOWNLOADER="${DL}"
      fi

      # If the OS has an editions_() function, use it.
      if [[ $(type -t "editions_${OS}") == function ]]; then
        for OPTION in $(editions_"${OS}"); do
          echo "${DISPLAY_NAME},${OS},${RELEASE},${OPTION},${DOWNLOADER},${PNG},${SVG}"
        done
      elif [[ "${OS}" == "windows"* ]]; then
        "languages_${OS}"
        for OPTION in "${LANGS[@]}"; do
          echo "${DISPLAY_NAME},${OS},${RELEASE},${OPTION},${DOWNLOADER},${PNG},${SVG}"
        done
      else
        echo "${DISPLAY_NAME},${OS},${RELEASE},,${DOWNLOADER},${PNG},${SVG}"
      fi
    done
  done
  exit 0
}

list_supported() {
    # output OS RELEASE EDITION (usefull for straight testing...)
    local DL=""
    local FUNC
    local OPTION
    local OS

    for OS in $(os_support); do
        case ${OS} in
          *ubuntu-server*) FUNC="ubuntu-server";;
          *ubuntu*) FUNC="ubuntu";;
          *) FUNC="${OS}";;
        esac
        for RELEASE in $("releases_${FUNC}" | sed -Ee 's/eol-\S+//g' ); do # hide eol releases
            # If the OS has an editions_() function, use it.
            if [[ $(type -t "editions_${OS}") == function ]]; then
                for OPTION in $(editions_"${OS}"); do
                    echo "${OS} ${RELEASE} ${OPTION}"
                done
            elif [[ "${OS}" == "windows"* ]]; then
                "languages_${OS}"
                for OPTION in "${LANGS[@]}"; do
                    echo "${OS} ${RELEASE} ${OPTION}"
                done
            else
                echo "${OS} ${RELEASE}"
            fi
        done
    done
    exit 0
}

list_isos() {
    local URL
    local FUNC
    local OPTION
    local OS

    echo "OS|Release|Edition|URL"
    for OS in $(os_support); do
        case ${OS} in
          *ubuntu-server*) FUNC="ubuntu-server";;
          *ubuntu*) FUNC="ubuntu";;
          *) FUNC="${OS}";;
        esac
        for RELEASE in $("releases_${FUNC}" | sed -Ee 's/eol-\S+//g' ); do # hide eol releases
             # If the OS has an editions_() function, use it.
            if [[ $(type -t "editions_${OS}") == function ]]; then
                for OPTION in $(editions_"${OS}"); do
                    URL=$(./quickget -u ${OS} ${RELEASE} ${OPTION})
                    if [ -z "${URL}" ]; then
                        echo "${OS}|${RELEASE}|${OPTION}|${URL}"
                    else
                        echo "${OS}|${RELEASE}|${OPTION}|${URL}"
                    fi
                done
            elif [[ "${OS}" == "windows"* ]]; then
                "languages_${OS}"
                for OPTION in "${LANGS[@]}"; do
                    #URL=$(./quickget -u ${OS} ${RELEASE} ${OPTION})
                    if [ -n "${URL}" ]; then
                        echo "${OS}|${RELEASE}|${OPTION}|"
                    else
                        echo "${OS}|${RELEASE}|${OPTION}|Strange!"
                    fi
                done
            elif [[ "${OS}" == "macos" ]]; then
                echo "${OS}|${RELEASE}|${OPTION}|"
            else
                URL=$(./quickget -u ${OS} ${RELEASE})
                if [ -z "${URL}" ]; then
                    echo "${OS}|${RELEASE}|${OPTION}|${URL}"
                else
                    echo "${OS}|${RELEASE}|${OPTION}|${URL}"
                fi
            fi
        done
    done
    exit 0
}

test_isos() {
    local DL=""
    local URL
    local ISO
    local FUNC
    local OPTION
    local OS
    local RELEASE
    local HAS_ZSYNC=0
    local GOOD

    # Check if zsync is available
    if command -v zsync &>/dev/null; then
        HAS_ZSYNC=1
    fi
    if command -v aria2c &>/dev/null; then
        DL="aria2c"
    elif command -v wget &>/dev/null; then
        DL="wget"
    fi
    echo "Status - OS|Release|Edition|URL"
    for OS in $(os_support); do
        case ${OS} in
          *ubuntu-server*) FUNC="ubuntu-server";;
          *ubuntu*) FUNC="ubuntu";;
          *) FUNC="${OS}";;
        esac
        for RELEASE in $("releases_${FUNC}" | sed -Ee 's/eol-\S+//g' ); do # hide eol releases
            if [[ "${OS}" == *"ubuntu"* ]] && [ "${RELEASE}" == "devel" ] && [ ${HAS_ZSYNC} -eq 1 ]; then
                DOWNLOADER="zsync"
            else
                DOWNLOADER="${DL}"
            fi
            # If the OS has an editions_() function, use it.
            if [[ $(type -t "editions_${OS}") == function ]]; then
                for OPTION in $(editions_"${OS}"); do
                    #URL=$(timeout 10 ./quickget -u ${OS} ${RELEASE} ${OPTION})
                    URL=$(timeout 10 ./quickget -u ${OS} ${RELEASE} ${OPTION})
                    GOOD=$(wget -q --spider ${URL} && echo 'OK' || echo 'ERROR!')
                    if [[ "${GOOD}" == "OK" ]]; then
                        echo "OK - ${OS}|${RELEASE}|${OPTION}|${URL}"
                    else
                        echo "ERROR - ${OS}|${RELEASE}|${OPTION}|${URL}"
                    fi
                done
            elif [[ "${OS}" == "windows"* ]]; then
                "languages_${OS}"
                for OPTION in "${LANGS[@]}"; do
                    #URL=$(timeout 10 ./quickget -u ${OS} ${RELEASE} ${OPTION})
                    if [ -z "${URL}" ]; then
                        echo "N - ${OS}|${RELEASE}|${OPTION}|"
                    else
                        echo "N - ${OS}|${RELEASE}|${OPTION}|"
                    fi
                done
            else
                URL=$(./quickget -u ${OS} ${RELEASE} ${OPTION})
                GOOD=$(timeout 10 wget -q --spider  ${URL} && echo 'OK' || echo 'ERROR!')
                if [[ "${GOOD}" == "OK" ]]; then
                    echo "OK - ${OS}|${RELEASE}|${OPTION}|${URL}"
                else
                    echo "ERROR - ${OS}|${RELEASE}|${OPTION}|${URL}"
                fi
            fi
        done
    done
    exit 0
}

function os_support() {
    echo alma \
    alpine \
    android \
    antix \
    archlinux \
    archcraft \
    arcolinux \
    artix \
    athenaos \
    batocera \
    bazzite \
    blendos \
    bodhi \
    bunsenlabs \
    cachyos \
    centos-stream \
    chimeralinux \
    crunchbang++ \
    debian \
    deepin \
    devuan \
    dragonflybsd \
    easyos \
    edubuntu \
    elementary \
    endeavouros \
    endless \
    fedora \
    freebsd \
    freedos \
    garuda \
    gentoo \
    ghostbsd \
    haiku \
    holoiso \
    kali \
    kdeneon \
    kolibrios \
    kubuntu \
    linuxlite \
    linuxmint \
    lmde \
    mageia \
    manjaro \
    mxlinux \
    netboot \
    netbsd \
    nitrux \
    nixos \
    lubuntu \
    macos \
    openbsd \
    openindiana \
    opensuse \
    oraclelinux \
    peppermint \
    parrotsec \
    popos \
    porteus \
    primtux \
    pureos \
    reactos \
    rebornos \
    rockylinux \
    siduction \
    slackware \
    slax \
    slint \
    slitaz \
    solus \
    sparkylinux \
    spirallinux \
    tails \
    tinycore \
    trisquel \
    truenas-core \
    truenas-scale \
    ubuntu \
    ubuntu-budgie \
    ubuntucinnamon \
    ubuntukylin \
    ubuntu-mate \
    ubuntu-server \
    ubuntustudio \
    ubuntu-unity \
    vanillaos \
    void \
    vxlinux \
    windows \
    windows-server \
    xerolinux \
    xubuntu \
    zorin
}

# Get string before first whitespace (HASH)
function cut_1() {
    cut -d' ' -f1
}

function releases_alma() {
    echo 9 8
}

function editions_alma() {
    echo boot minimal dvd
}

function releases_alpine() {
    echo latest 3.18 3.17 3.16 3.15 3.14 3.13 3.12
}

function releases_android() {
    echo 9.0 8.1 7.1
}

function editions_android() {
    echo x86_64 x86
}

function releases_antix() {
    echo 23 22 21
}

function editions_antix() {
    echo net-sysv core-sysv base-sysv full-sysv net-runit core-runit base-runit full-runit
}

function releases_archcraft() {
    echo latest
}

function releases_archlinux() {
    echo latest
}

function releases_arcolinux() {
    local RLIST
    RLIST=$(curl -s https://ant.seedhost.eu/arcolinux/iso/ | grep -o -E ">v[[:digit:]]{2}.[[:digit:]]{2}.[[:digit:]]{2}" | sed -e "s/>//" | tr '\r\n' ' ')
    echo ${RLIST}
}

function editions_arcolinux() {
    echo large small
}

function releases_artix() {
    echo stable
}

function editions_artix() {
    echo base-dinit \
    base-openrc \
    base-runit \
    base-s6 \
    cinnamon-dinit \
    cinnamon-openrc \
    cinnamon-runit \
    cinnamon-s6 \
    lxde-dinit \
    lxde-openrc \
    lxde-runit \
    lxde-s6 \
    lxqt-dinit \
    lxqt-openrc \
    lxqt-runit \
    lxqt-s6 \
    mate-dinit \
    mate-openrc \
    mate-runit \
    mate-s6 \
    plasma-dinit \
    plasma-openrc \
    plasma-runit \
    plasma-s6 \
    xfce-dinit \
    xfce-openrc \
    xfce-runit \
    xfce-s6 \
    community-gtk-openrc \
    community-qt-openrc
}

function releases_athenaos() {
    wget -q -O- 'https://sourceforge.net/projects/athena-iso/rss?path=/' | grep '.iso/download"' | cut -d'=' -f5 | cut -d'"' -f2 | cut -d'/' -f7 | cut -d'v' -f2 | sed ':a;N;$!ba;s/\n/ /g'
}

function releases_batocera() {
    echo latest
}

function releases_bazzite() {
    wget -q -O- "https://api.github.com/repos/ublue-os/bazzite/releases" | grep 'download_url' | grep 'sum' | cut -d '/' -f8 | cut -d'v' -f2 | tr '\r\n' ' '
}

function releases_blendos() {
    local RLIST=""

    # Pull the rss feed
    wget -q https://sourceforge.net/projects/blendos/rss?path=/ISOs/ -O- | grep -E -o 'https://.*blendOS\.iso.*</media:hash' >/tmp/blendos-isos.rss
    RLIST=$(grep -E -o 'https://.*blendOS\.iso.*</media:hash' /tmp/blendos-isos.rss | cut -d/ -f 8-9 | sort -r -t/  --key=2 |grep -e '16878' -e '168[8-9]')
    echo "${RLIST}"
}

function releases_bodhi() {
    echo 7.0.0
}

function editions_bodhi() {
    echo standard hwe s76
}

function releases_bunsenlabs() {
    echo latest
}

function releases_cachyos() {
    echo 230813
}

function editions_cachyos() {
    echo kde gnome
}

function releases_centos-stream() {
    echo 9 8
}

function editions_centos-stream() {
    echo boot dvd1
}

function releases_chimeralinux() {
    echo latest
}

function editions_chimeralinux() {
    echo base gnome
}

function releases_crunchbang++() {
    echo 12 11 10 9 8
}

function releases_debian() {
    DEBCURRENT=$(wget -q https://cdimage.debian.org/debian-cd/ -O- |grep '\.[0-9]/'|cut -d\> -f9|cut -d\/ -f1)
    local DEBOLD=$(wget -q https://cdimage.debian.org/cdimage/archive/ -O- |grep -e '>[1-9][0-9]\.'|grep -v 'live' | cut -d\> -f9|cut -d\/ -f1 )

    echo ${DEBCURRENT} # ${DEBOLD}
}

function editions_debian() {
    echo standard cinnamon gnome kde lxde lxqt mate xfce netinst
}

function releases_deepin() {
    echo 20.7 20.6 20.5 20.4 20.3 20.2.4 20.2.3 20.2.2 20.2.1 20.2 20.1 20
}

function releases_devuan() {
    echo beowulf chimaera daedalus
}

function releases_dragonflybsd() {
    # If you remove "".bz2" from the end of the searched URL, you will get only the current release - currently 6.4.0
    # We could add a variable so this behaviour is optional/switchable (maybe from option or env)
    DBSD_RELEASES=$(curl -sL  http://mirror-master.dragonflybsd.org/iso-images/| grep -E -o '"dfly-x86_64-.*_REL.iso.bz2"' | grep -o -E '[[:digit:]]+\.[[:digit:]]+\.[[:digit:]]+' )
    echo $DBSD_RELEASES
}

function releases_easyos() {
    #local RLIST
    #RLIST=$(curl -s https://distro.ibiblio.org/easyos/amd64/releases/kirkstone/2023/ | grep 'href="' | tail +2 | cut -d'/' -f1 | cut -d'"' -f6)
    #RLIST=$(wget -q -O- 'https://distro.ibiblio.org/easyos/amd64/releases/kirkstone/2023/' | grep 'href="' | tail +2 | cut -d'/' -f1 | cut -d'"' -f6)
    #echo ${RLIST}
    # Not dynamic for now
    echo 5.6.4 5.6.3 5.6.2 5.6.1 5.5.5 5.5.4
}

function releases_elementary() {
    echo 7.1 7.0
}

function releases_endeavouros() {
    echo galileo-11-2023 \
     cassini_nova-03-2023_r3 \
     cassini_22_12 \
     cassini_neo_22_12 \
     artemis_nova_22_9 \
     artemis_neo_22_8 \
     artemis_neo_22_7 \
     artemis-22_6 \
     apollo_22_1 \
     atlantis_neo-21_5 \
     atlantis-21_4
}

function releases_endless() {
    echo 5.0.0
}

function editions_endless() {
    echo base en fr pt_BR es
}

function releases_fedora() {
    echo 39 38
}

function editions_fedora() {
    echo Workstation \
    Budgie \
    Cinnamon \
    i3 \
    KDE \
    LXDE \
    LXQt \
    Mate \
    Xfce \
    Silverblue \
    Sericea \
    Kinoite \
    Sway \
    Server \
    Onyx
}

function releases_freebsd(){
    local FBSD_RELEASES=$(curl -sL https://download.freebsd.org/ftp/releases/amd64/amd64/ISO-IMAGES/|grep -e 'class="link"' |grep -v '\.\.'|cut -d\" -f4|tr -d '/')
    echo ${FBSD_RELEASES}
}

function editions_freebsd(){
    echo disc1 dvd1
}

function releases_freedos() {
    echo 1.3 1.2
}

function releases_garuda() {
    echo latest
}

function editions_garuda() {
    echo cinnamon dr460nized dr460nized-gaming gnome i3 kde-git kde-lite lxqt-kwin mate qtile sway wayfire xfce
}

function releases_gentoo() {
    echo latest
}

function editions_gentoo() {
    echo minimal livegui
}

function releases_ghostbsd() {
    echo 22.01.12 21.11.24 21.10.16
}

function editions_ghostbsd() {
    echo mate xfce
}

function releases_haiku() {
    echo r1beta4 r1beta3
}

function editions_haiku() {
    echo x86_64 x86_gcc2h
}

function releases_holoiso() {
    wget -q https://github.com/HoloISO/holoiso/releases/latest -O- | grep -o -e 'releases/tag/[[:digit:]]\+\.[[:digit:]]\+\.[[:digit:]]' | head -1 | cut -d/ -f3
}

function releases_kali() {
    echo current kali-weekly
}

function releases_kdeneon() {
    echo user testing unstable developer
}

function releases_kolibrios() {
    echo latest
}

function releases_linuxlite() {
    echo 6.6 6.4 6.2 6.0
}

function releases_linuxmint(){
    echo 21.2 21.1 21 20.3 20.2
}

function editions_linuxmint(){
    echo cinnamon mate xfce
}

function editions_lmde(){
    echo cinnamon
}

function releases_lmde(){
    echo 5
}

function releases_macos() {
    echo high-sierra mojave catalina big-sur monterey ventura sonoma
}

function releases_mageia(){
    echo 8
}

function editions_mageia(){
    echo Plasma GNOME Xfce
}

function editions_manjaro(){
    echo full minimal
}

function releases_manjaro() {
    echo xfce \
    gnome \
    plasma \
    budgie \
    cinnamon \
    i3 \
    mate \
    sway
}

function releases_mxlinux(){
    echo 21.3
}

function editions_mxlinux(){
    echo Xfce KDE Fluxbox
}

function releases_netboot() {
    echo latest
}

function releases_netbsd() {
    local NBSD_RELEASES=$(curl -sL  http://cdn.netbsd.org/pub/NetBSD/iso/ | grep -o -E '"[[:digit:]]+\.[[:digit:]]+/"' |tr -d '"/' |sort -nr )
    echo ${NBSD_RELEASES}
}

function releases_nitrux() {
    echo latest
}

function releases_nixos(){
    echo 23.11 23.05 22.11 22.05 21.11 21.05
}

function editions_nixos(){
    echo minimal plasma5 gnome
}

function releases_openbsd(){
    local OBSD_RELEASES=$(curl -sL https://mirror.leaseweb.com/pub/OpenBSD/|grep -e '6\.[8-9]/' -e '[7-9]\.'|cut -d\" -f4|tr -d '/')
    echo ${OBSD_RELEASES}
}

function releases_openindiana(){
    echo 20230421
}

function editions_openindiana(){
    echo gui text minimal
}

function releases_opensuse(){
    echo 15.4 15.3 15.2 15.1 15.0 microos tumbleweed
}

function releases_oraclelinux() {
    echo 9.0 8.6 8.5 8.4 7.9 7.8 7.7
}

function releases_parrotsec() {
    echo 6.0 5.3 4.11.3
}

function editions_parrotsec() {
    echo architect home htb security
}

function releases_peppermint() {
    echo latest
}

function editions_peppermint() {
    echo devuan-xfce devuan-gnome debian-xfce debian-gnome
}

function releases_popos() {
    echo 22.04 21.10 20.04
}

function editions_popos() {
    echo intel nvidia
}

function releases_porteus() {
    echo 5.01 5.0
}

function editions_porteus() {
    echo cinnamon gnome kde lxde lxqt mate openbox xfce
}

function releases_primtux() {
    echo 7
}

function editions_primtux() {
    echo 2022-10
}

function releases_pureos() {
    echo 9.0 10.3
}

function editions_pureos() {
    echo gnome plasma
}

function releases_reactos() {
    echo latest
}

function releases_rebornos() {
    echo latest
}

function releases_rockylinux() {
    echo 9.1 9.0 8.7 8.6 8.5 8.4 8.3
}

function editions_rockylinux() {
    echo minimal dvd boot
}

function releases_siduction() {
    echo latest
}

function editions_siduction() {
    echo kde lxqt nox xfce xorg
}

function releases_slackware() {
    echo 15.0 14.2
}

function releases_slax() {
    echo latest
}

function editions_slax() {
    echo debian slackware
}

function releases_slint() {
    echo 15.0 14.2.1
}

function releases_slitaz() {
    echo preferred core core64 loram core-5in1 preinit
}

function releases_solus() {
    echo 4.3
}

function editions_solus() {
    echo Budgie GNOME MATE Plasma
}

function releases_sparkylinux() {
    local SPARKY_RELEASES=$(wget -qO- "https://sourceforge.net/projects/sparkylinux/rss?path=/" | grep 'link' | grep '.iso' | cut -d'-' -f2 | uniq | tr '\r\n' ' ')
    echo "${SPARKY_RELEASES}"
}

function editions_sparkylinux() {
    echo lxqt mate xfce kde minimalgui minimalcli gameover multimedia rescue
}

function releases_spirallinux() {
    echo latest
}

function editions_spirallinux() {
    echo Plasma XFCE Mate LXQt Gnome Budgie Cinnamon Builder
}

function releases_tails() {
    echo stable
}

function releases_tinycore() {
    echo 14.0
}

function editions_tinycore() {
    echo Core TinyCore CorePlus CorePure64 TinyCorePure64
}

function releases_trisquel() {
    echo 11.0 10.0.1
}

function editions_trisquel() {
    echo mate lxde kde sugar
}

function releases_truenas() {
    if [[ $OS == truenas ]] ; then
        echo "ERROR! The supported TrueNAS OS values are truenas-core or truenas-scale"
        exit 1;
    fi
}

function releases_truenas-core() {
    echo 13.0 12.0
}

function releases_truenas-scale() {
    echo 22.12 22.02
}

function releases_ubuntu() {
    local VERSION_DATA="$(IFS=$'\n' wget -qO- https://api.launchpad.net/devel/ubuntu/series | jq -r '.entries[]')"
    local SUPPORTED_VERSIONS=($(IFS=$'\n' jq -r 'select(.status=="Supported" or .status=="Current Stable Release") | .version' <<<${VERSION_DATA} | sort))
    local EOL_VERSIONS=($(IFS=$'\n' jq -r 'select(.status=="Obsolete") | .version' <<<${VERSION_DATA} | sort))
    local LTS_SUPPORT=()
    local INTERIM_SUPPORT=()

    for i in "${SUPPORTED_VERSIONS[@]}"; do
        if [[ $(expr ${i%.*} % 2) == 0 && ${i#*.} == "04" ]]; then
            LTS_SUPPORT+=($i)
        else
            INTERIM_SUPPORT+=($i)
        fi
    done

    case "${OS}" in
      edubuntu|ubuntu-unity|ubuntucinnamon)
        echo ${INTERIM_SUPPORT[@]} daily-live
        ;;
      kubuntu|lubuntu|ubuntukylin|ubuntu-mate|ubuntustudio|xubuntu)
        ## after 14.04
        echo ${LTS_SUPPORT[@]:1} ${INTERIM_SUPPORT[@]} daily-live jammy-daily #${EOL_VERSIONS[@]/#/eol-}
        ;;
      ubuntu-budgie)
        #after 16.04
        echo ${LTS_SUPPORT[@]:2} ${INTERIM_SUPPORT[@]} daily-live jammy-daily #${EOL_VERSIONS[@]/#/eol-}
        ;;
      ubuntu)
        echo ${LTS_SUPPORT[@]} ${INTERIM_SUPPORT[@]} daily-live #${EOL_VERSIONS[@]/#/eol-}
        ;;
    esac
}

function releases_ubuntu-server() {
    local ALL_VERSIONS=($(IFS=$'\n' wget -qO- http://releases.ubuntu.com/streams/v1/com.ubuntu.releases:ubuntu-server.json | jq -r '.products[] | select(.arch=="amd64") | .version'))
    local LTS_SUPPORT=()
    local INTERIM_SUPPORT=()

    for i in "${!ALL_VERSIONS[@]}"; do
        if [[ $i == 0 || ${ALL_VERSIONS[$i]} > ${ALL_VERSIONS[$(expr $i - 1)]} ]]; then
            if [[ $(expr ${ALL_VERSIONS[${i}]%.*} % 2) == 0 && ${ALL_VERSIONS[${i}]#*.} == "04" ]]; then
                LTS_SUPPORT+=(${ALL_VERSIONS[$i]})
            else
                INTERIM_SUPPORT+=(${ALL_VERSIONS[$i]})
            fi
        else
            break
        fi
    done
    echo ${LTS_SUPPORT[@]} ${INTERIM_SUPPORT[@]} daily-live
}

function releases_vanillaos() {
    echo 22.10
}

function releases_void() {
    echo current
}

function editions_void() {
    echo glibc musl xfce-glibc xfce-musl
}

function releases_vxlinux() {
    wget -q https://github.com/VX-Linux/main/releases/latest -O- | grep -o -e 'releases/tag/[[:digit:]]\+\.[[:digit:]]\+\.[[:digit:]]' | head -1 | cut -d/ -f3
}

function releases_windows() {
    echo 11 10-ltsc 10 8
}

function languages_windows() {
    if [ "${RELEASE}" == 8 ]; then
        LANGS=("Arabic" "Brazilian Portuguese" "Bulgarian" "Chinese (Simplified)" "Chinese (Traditional)" "Chinese (Traditional Hong Kong)" \
        "Croatian" "Czech" "Danish" "Dutch" "English (United States)" "English International" "Estonian" "Finnish" "French" "German" "Greek" \
        "Hebrew" "Hungarian" "Italian" "Japanese" "Latvian" "Lithuanian" "Norwegian" "Polish" "Portuguese" "Romanian" "Russian" "Serbian Latin" \
        "Slovak" "Slovenian" "Spanish" "Swedish" "Thai" "Turkish" "Ukrainian")
    elif [ "${RELEASE}" == "10-ltsc" ]; then
        LANGS=("English (United States)" "English (Great Britain)" "Chinese (Simplified)" "Chinese (Traditional)" \
        "French" "German" "Italian" "Japanese" "Korean" "Portuguese (Brazil)" "Spanish")
    else
        LANGS=("Arabic" "Brazilian Portuguese" "Bulgarian" "Chinese (Simplified)" "Chinese (Traditional)" "Croatian" "Czech" "Danish" "Dutch" \
        "English (United States)" "English International" "Estonian" "Finnish" "French" "French Canadian" "German" "Greek" "Hebrew" "Hungarian" \
        "Italian" "Japanese" "Korean" "Latvian" "Lithuanian" "Norwegian" "Polish" "Portuguese" "Romanian" "Russian" "Serbian Latin" "Slovak" \
        "Slovenian" "Spanish" "Spanish (Mexico)" "Swedish" "Thai" "Turkish" "Ukrainian")
    fi
}

function releases_windows-server() {
    echo 2022 2019 2016 2012-r2
}

function languages_windows-server() {
    LANGS=("English (United States)" "Chinese (Simplified)" "French" "German" "Italian" "Japanese" "Russian" "Spanish")
}

function releases_xerolinux() {
    echo kde
}

function releases_zorin() {
    echo 17 16
}

function editions_zorin() {
    echo core64 lite64 education64 edulite64
}

function check_hash() {
    local iso=""
    local hash=""
    local hash_algo=""
    if [ "${download_iso}" == 1 ]; then
        iso="${1}"
    else
        iso="${VM_PATH}/${1}"
    fi
    hash="${2}"

    # Guess the hash algorithm by the hash length
    case ${#hash} in
      32) hash_algo=md5sum;;
      40) hash_algo=sha1sum;;
      64) hash_algo=sha256sum;;
      128) hash_algo=sha512sum;;
      *) echo "WARNING! Can't guess hash algorithm, not checking ${iso} hash."
        return;;
    esac

    echo -n "Checking ${iso} with ${hash_algo}... "
    if ! echo "${hash} ${iso}" | ${hash_algo} --check --status; then
        echo "ERROR!"
        echo "${iso} doesn't match ${hash}. Try running 'quickget' again."
        exit 1
    else
        echo "Good!"
    fi
}

function web_get() {
    local DIR="${2}"
    local FILE=""
    local URL="${1}"

    if [ -n "${3}" ]; then
        FILE="${3}"
    else
        FILE="${URL##*/}"
    fi

    while (( "$#" )); do
        if [[ $1 == --header ]]; then
            HEADERS+=("$1" "$2")
            shift 2
        else
            shift
        fi
    done

    # Test mode for ISO
    if [ "${show_iso_url}" == 1 ]; then
        echo "${URL}"
        exit 0
    elif [ "${test_iso_url}" == 1 ]; then
        echo -n "Testing if $(echo ${URL} | rev | cut -d'/' -f1 | rev) is available... "
        wget -q --spider "${URL}" && echo 'Sucessfull' || echo 'ERROR!'
        exit 0
    elif [ "${download_iso}" == 1 ]; then
        DIR="$(pwd)"
    fi

    if [ "${DIR}" != "$(pwd)" ] && ! mkdir -p "${DIR}" 2>/dev/null; then
        echo "ERROR! Unable to create directory ${DIR}"
        exit 1
    fi

    if [[ ${OS} != windows && ${OS} != macos && ${OS} != windows-server ]]; then
        echo Downloading $(pretty_name "${OS}") ${RELEASE} ${EDITION:+ $EDITION} from ${URL}
    fi

    if command -v aria2c &>/dev/null; then
        if ! aria2c --stderr -x16 --continue=true --summary-interval=0 --download-result=hide --console-log-level=error "${URL}" --dir "${DIR}" -o "${FILE}" "${HEADERS[@]}"; then
            echo #Necessary as aria2c in suppressed mode does not have new lines
            echo "ERROR! Failed to download ${URL} with aria2c. Try running 'quickget' again."
            exit 1
        fi

        echo #Necessary as aria2c in suppressed mode does not have new lines
    elif command -v wget2 &>/dev/null; then
        if ! wget2 --quiet --continue --tries=3 --read-timeout=10 --force-progress --progress=bar:force:noscroll "${URL}" -O "${DIR}/${FILE}" "${HEADERS[@]}"; then
            echo "ERROR! Failed to download ${URL} with wget2. Try running 'quickget' again."
            exit 1
        fi

    elif ! wget --quiet --continue --tries=3 --read-timeout=10 --show-progress --progress=bar:force:noscroll "${URL}" -O "${DIR}/${FILE}" "${HEADERS[@]}"; then
        echo "ERROR! Failed to download ${URL} with wget. Try running 'quickget' again."
        exit 1
    fi
}

function zsync_get() {
    local DIR="${2}"
    local FILE="${1##*/}"
    local OUT=""
    local URL="${1}"

    # Test mode for ISO
    if [ "${show_iso_url}" == 1 ]; then
        echo "${URL}"
        exit 0
    elif [ "${test_iso_url}" == 1 ]; then
        wget --spider "${URL}"
        exit 0
    elif command -v zsync &>/dev/null; then
        if [ -n "${3}" ]; then
            OUT="${3}"
        else
            OUT="${FILE}"
        fi

        if ! mkdir -p "${DIR}" 2>/dev/null; then
            echo "ERROR! Unable to create directory ${DIR}"
            exit 1
        fi

        echo -e Downloading $(pretty_name "${OS}") ${RELEASE} ${EDITION+ ${EDITION}} from ${URL}'\n'
        # Only force http for zsync - not earlier because we might fall through here
        if ! zsync "${URL/https/http}.zsync" -i "${DIR}/${OUT}" -o "${DIR}/${OUT}" 2>/dev/null; then
            echo "ERROR! Failed to download ${URL/https/http}.zsync"
            exit 1
        fi

        if [ -e "${DIR}/${OUT}.zs-old" ]; then
            rm "${DIR}/${OUT}.zs-old"
        fi
    else
        echo "INFO: zsync not found, falling back to wget/aria2c"
        if [ -n "${3}" ]; then
            web_get "${1}" "${2}" "${3}"
        else
            web_get "${1}" "${2}"
        fi
    fi
}

function make_vm_config() {
    local CONF_FILE=""
    local IMAGE_FILE=""
    local ISO_FILE=""
    local IMAGE_TYPE=""
    local GUEST=""
    #not needed anymore?
    #local SEC_BOOT=""

    if [ "${download_iso}" == 1 ]; then
        exit 0
    fi

    if [ "${download_iso}" == "on" ]; then
        exit 0
    fi

    IMAGE_FILE="${1}"
    ISO_FILE="${2}"
    case "${OS}" in
      batocera)
        GUEST="batocera"
        IMAGE_TYPE="img";;
      dragonflybsd)
        GUEST="dragonflybsd"
        IMAGE_TYPE="iso";;
      freebsd|ghostbsd)
        GUEST="freebsd"
        IMAGE_TYPE="iso";;
      haiku)
        GUEST="haiku"
        IMAGE_TYPE="iso";;
      freedos)
        GUEST="freedos"
        IMAGE_TYPE="iso";;
      kolibrios)
        GUEST="kolibrios"
        IMAGE_TYPE="iso";;
      macos)
        GUEST="macos"
        IMAGE_TYPE="img";;
      netbsd)
        GUEST="netbsd"
        IMAGE_TYPE="iso";;
      openbsd)
        GUEST="openbsd"
        IMAGE_TYPE="iso";;
      openindiana)
        GUEST="solaris"
        IMAGE_TYPE="iso";;
      reactos)
        GUEST="reactos"
        IMAGE_TYPE="iso";;
      truenas*)
        GUEST="truenas"
        IMAGE_TYPE="iso";;
      windows)
        GUEST="windows"
        IMAGE_TYPE="iso";;
      windows-server)
        GUEST="windows-server"
        IMAGE_TYPE="iso";;
      *)
        GUEST="linux"
        IMAGE_TYPE="iso";;
    esac

    CONF_FILE="${VM_PATH}.conf"

    if [ ! -e "${CONF_FILE}" ]; then
        echo "Making ${CONF_FILE}"
        cat << EOF > "${CONF_FILE}"
#!$(which quickemu) --vm
guest_os="${GUEST}"
disk_img="${VM_PATH}/disk.qcow2"
${IMAGE_TYPE}="${VM_PATH}/${IMAGE_FILE}"
EOF
        echo "Giving user execute permissions on ${CONF_FILE}"
        chmod u+x "${CONF_FILE}"
        if [ -n "${ISO_FILE}" ]; then
            echo "fixed_iso=\"${VM_PATH}/${ISO_FILE}\"" >> "${CONF_FILE}"
        fi

        # OS specific tweaks
        case ${OS} in
          alma|athenaos|centos-stream|endless|garuda|nixos|oraclelinux|popos|rockylinux)
            echo "disk_size=\"32G\"" >> "${CONF_FILE}";;
          openindiana)
            echo "boot=\"legacy\"" >> "${CONF_FILE}"
            echo "disk_size=\"32G\"" >> "${CONF_FILE}";;
          batocera)
            echo "disk_size=\"8G\"" >> "${CONF_FILE}";;
          dragonflybsd|haiku|openbsd|netbsd|slackware|slax|tails|tinycore)
            echo "boot=\"legacy\"" >> "${CONF_FILE}";;
          deepin)
            echo "disk_size=\"64G\"" >> "${CONF_FILE}"
            echo "ram=\"4G\"" >> "${CONF_FILE}"
            ;;
          freedos)
            echo "boot=\"legacy\"" >> "${CONF_FILE}"
            echo "disk_size=\"4G\"" >> "${CONF_FILE}"
            echo "ram=\"256M\"" >> "${CONF_FILE}"
            ;;
          kolibrios)
            echo "boot=\"legacy\"" >> "${CONF_FILE}"
            echo "disk_size=\"2G\"" >> "${CONF_FILE}"
            echo "ram=\"128M\"" >> "${CONF_FILE}"
            ;;
          slint)
            echo "disk_size=\"50G\"" >> "${CONF_FILE}"
            ;;
          slitaz)
            echo "boot=\"legacy\"" >> "${CONF_FILE}"
            echo "disk_size=\"4G\"" >> "${CONF_FILE}"
            echo "ram=\"512M\"" >> "${CONF_FILE}"
            ;;
          truenas-scale|truenas-core)
            echo "boot=\"legacy\"" >> "${CONF_FILE}"
            # the rest is non-functional
            # echo "bootdrive_size=\"5G\"" >> "${CONF_FILE}" # boot drive
            # echo "1stdrive_size=\"20G\"" >> "${CONF_FILE}" # for testing
            # echo "2nddrive_size=\"20G\"" >> "${CONF_FILE}" # again, for testing
            ;;
          ubuntu-server)
            # 22.04+ fails on LVM build if disk size is < 10G
            # 22.04.1 fails on auto-install if TPM is disabled
            echo "disk_size=\"10G\"" >> "${CONF_FILE}"
            echo "ram=\"4G\"" >> "${CONF_FILE}"
            if [[ "${RELEASE}" == *"22.04"* ]]; then
                echo "tpm=\"on\"" >> "${CONF_FILE}"
            fi
            ;;
          vanillaos)
            ## Minimum is 50G for abroot, but a 64GB is allocated to give some headroom
            echo "disk_size=\"64G\"" >> "${CONF_FILE}"
            ;;
          zorin)
            case ${EDITION} in
              education64|edulite64)
                echo "disk_size=\"32G\"" >> "${CONF_FILE}";;
            esac
            ;;
          reactos)
            echo "boot=\"legacy\"" >> "${CONF_FILE}"
            echo "disk_size=\"12G\"" >> "${CONF_FILE}"
            echo "ram=\"2048M\"" >> "${CONF_FILE}"
            ;;
          macos)
            echo "macos_release=\"${RELEASE}\"" >> "${CONF_FILE}"
            # https://github.com/quickemu-project/quickemu/issues/438
            if [ "${RELEASE}" == "monterey" ]; then
                echo "cpu_cores=2" >> "${CONF_FILE}"
            fi
            ;;
        esac

        if [ "${OS}" == "ubuntu" ] && [[ ${RELEASE} == *"daily"*  ]]; then
            # Minimum to install lobster testing is 18GB but 32GB are allocated for headroom
            echo "disk_size=\"32G\"" >> "${CONF_FILE}"
        fi

        # Enable TPM for Windows 11
        if [ "${OS}" == "windows" ] && [ "${RELEASE}" == 11 ] || [ "${OS}" == "windows-server" ] && [ "${RELEASE}" == "2022" ]; then
            echo "tpm=\"on\"" >> "${CONF_FILE}"
            echo "secureboot=\"off\"" >> "${CONF_FILE}"
        fi
    fi

    echo
    echo "To start your $(pretty_name "${OS}") virtual machine run:"
    if [ ${OS} == "slint" ]; then
        echo -e "    quickemu --vm ${CONF_FILE}\nTo start Slint with braille support run:\n    quickemu --vm --braille --display sdl ${CONF_FILE}"
    else
        echo "    quickemu --vm ${CONF_FILE}"
    fi
    echo
    exit 0
}

# QUICKGET-EXTENDED ONLY DISTROS!

function get_agarimos() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local URL=""
    #local DATE=""
    #local KERNEL=""
    case ${EDITION} in
        gnome)
            URL="https://sourceforge.net/projects/agarimos/files/Gnome"
            ISO="AgarimOS-Gnome-Catppuccin-Liv-x86_64-6.5.12_1-20231130.iso"
            ;;
        plasma)
            URL="https://sourceforge.net/projects/agarimos/files/Plasma"
            ISO="AgarimOS-Plasma-Dracula-Live-x86_64-6.5.11_1-20231120.iso"
            ;;
        xfce)
            URL="https://sourceforge.net/projects/agarimos/files/XFCE4"
            ISO="AgarimOS-XFCE4-Catppuccin-Live-x86_64-6.5.12_1-20231122.iso"
            ;;
        lxqt)
            URL="https://sourceforge.net/projects/agarimos/files/LXQT-KWIN"
            ISO="AgarimOS-LXQT-KWIN-Dracula-Live-x86_64-6.5.12_1-20231121.iso"
            ;;
    esac

    HASH=$(wget -q -O- "${URL}/${ISO}.sha256" | cut -d' ' -f1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_artixlinux() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local URL="https://iso.artixlinux.org/iso"
    DATE=$(wget -q -O- ${URL}/sha256sums | cut -d'-' -f4 | head -1)
    ISO="artix-${EDITION}-${DATE}-x86_64.iso"
    HASH=$(wget -q -O- ${URL}/sha256sums | grep "${ISO}")
    echo "${URL}/${ISO} ${HASH}"
}

function get_athenaos() {
    local HASH=""
    local URL=""
    local TMPURL=""
    local ISO="athena-2023.06.23-x86_64.iso"
    TMPURL=$(wget -q -S -O- --max-redirect=0 "https://sourceforge.net/projects/athena-iso/files/v23.06.23/${ISO}/download" 2>&1 | grep -i Location | cut -d' ' -f4)
    URL=${TMPURL%\?*}
    echo "${URL} ${HASH}"
}

function get_batocera() {
    local HASH=""
    local URL="https://mirrors.o2switch.fr/batocera/x86_64/stable/last"
    local ISO="$(curl -sl ${URL}/ | grep -e 'batocera.*img.gz'|cut -d\" -f2)"
     echo "${URL}/${ISO} ${HASH}"
}

function get_bazzite() {
    local HASH=""
    local ISO=""
    local URL="https://github.com/ublue-os/bazzite/releases/download/v${RELEASE}"

    ISO=$(wget -q -O- "https://api.github.com/repos/ublue-os/bazzite/releases" | grep 'download_url' | grep 'sum' | cut -d '"' -f4 | cut -d'.' -f1-5 | grep "${RELEASE}" | cut -d'/' -f9)
    HASH=$(wget -q -O- "${URL}/${ISO}.sha256sum" | grep 'SHA256' | cut -d' ' -f4)
     echo "${URL}/${ISO} ${HASH}"
}

function get_biglinux() {
    local HASH=""
    local ISO=""
    local URL="https://iso.biglinux.com.br/"
    ISO=$(grep -Eo 'biglinux_[0-9]{4}(-[0-9]{2}){2}_k[0-9]{2,3}.iso' <(wget -q -O- ${URL}) | sort -u | tail -n2 | head -n1)
    HASH=$(curl -s ${URL}${ISO}.md5 | grep -Eo '[[:alnum:]]{32}')
    echo "${URL}${ISO} ${HASH}"
}

function get_cereus() {
    local EDITION="${1:-}"
    local HASH=""
    local DATE=""
    local ISO=""
    local URL="https://sourceforge.net/projects/cereus-linux/files/isos/beta/latest/${EDITION}"
    DATE=$(wget -q -O- https://sourceforge.net/projects/cereus-linux/files/isos/beta/latest/base/SHA256SUM | grep 'x86_64-base' | rev | cut -d'-' -f1 | rev | cut -d'.' -f1-3)
    ISO="cereus-beta-live-x86_64-${EDITION}-${DATE}.iso"
    case ${EDITION} in
      base) HASH=$(wget -q -O- "${URL}/SHA256SUM" | grep "${ISO}" | cut -d' ' -f1);;
      *) HASH=$(wget -q -O- "${URL}/SHA256" | grep "${ISO}" | cut -d' ' -f1);;
    esac
    echo "${URL}/${ISO} ${HASH}"
}

function get_chimeralinux() {
    local EDITION="${1:-}"
    local HASH=""
    local DATE=""
    local ISO=""
    local URL="https://repo.chimera-linux.org/live/${RELEASE}"
    DATE=$(wget -q -O- "${URL}/sha256sums.txt" | head -n1 | cut -d'-' -f5)
    ISO="chimera-linux-x86_64-LIVE-${DATE}-${EDITION}.iso"
    HASH=$(wget -q -O- "${URL}/sha256sums.txt" | grep 'x86_64-LIVE' | grep "${EDITION}" | cut -d' ' -f1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_crunchbang++() {
    local HASH=""
    local ISO=""
    local URL=""
    local URLPART=""
    local URLPART2=""

    URLPART="https://github.com/CBPP/cbpp"

    case ${RELEASE} in
        8)
            URLPART2="releases/download/v1.0-amd64"
            ISO="cbpp-1.0-amd64-20150428.iso"
            ;;
        9)
            URLPART2="9-amd64/releases/download/v9.0"
            ISO="cbpp-9.0-amd64-20170621.iso"
            ;;
        10)
            URLPART2="releases/download/v10"
            ISO="cbpp-10.1-amd64-20190713.iso"
            ;;
        11)
            URLPART2="releases/download/v11.2"
            ISO="cbpp-11.2-amd64-20230514.iso"
            ;;
        12)
            URLPART2="releases/download/v12.0"
            ISO="cbpp-12.0-amd64-20230611.iso"
            ;;
    esac

    URL="${URLPART}/${URLPART2}"
    echo "${URL}/${ISO} ${HASH}"
}

function get_dietpi() {
    local HASH=""
    local ISO=""
    local URL="https://dietpi.com/downloads/images"
    case ${RELEASE} in
      bios)
        case ${EDITION} in
          bookworm)
            local ISO="DietPi_NativePC-BIOS-x86_64-Bookworm.7z"
            ;;
          bullseye)
            local ISO="DietPi_NativePC-BIOS-x86_64-Bullseye.7z"
            ;;
          bookworm-installer)
            local ISO="DietPi_NativePC-BIOS-x86_64-Bookworm_Installer.7z"
            ;;
          bullseye-installer)
            local ISO="DietPi_NativePC-BIOS-x86_64-Bullseye_Installer.7z"
            ;;
        esac
      ;;
      uefi)
        case ${EDITION} in
          bookworm-installer)
            local ISO="DietPi_NativePC-UEFI-x86_64-Bookworm_Installer.7z"
            ;;
          bullseye-installer)
            local ISO="DietPi_NativePC-UEFI-x86_64-Bullseye_Installer.7z"
            ;;
        esac
      ;;
    esac
    HASH=$(wget -q -O- "${URL}/SHASUMS.txt" | grep "${ISO}" | cut -d' ' -f1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_fvoid() {
    local HASH=""
    local URL=""
    local TMPURL=""
    TMPURL=$(wget -q -S -O- --max-redirect=0 "https://sourceforge.net/projects/f-void/files/latest/download" 2>&1 | grep -i Location | cut -d' ' -f4)
    URL=${TMPURL%\?*}
    echo "${URL} ${HASH}"
}

function get_gabeeos() {
    local HASH=""
    local URL=""
#    local TMPURL=""
#    TMPURL=$(wget -q -S -O- --max-redirect=0 "https://sourceforge.net/projects/gabeeos/files/latest/download" 2>&1 | grep -i Location | cut -d' ' -f4)
    case ${EDITION} in
      openbox)
        ISO="gabeeOSLinux-Openbox-Cherry-x86_64-6.1.25_1-20230502.iso"
        URL="https://sourceforge.net/projects/gabeeoslinux/files/Distro/Openbox/beta"
        HASH=$(wget -q -O- ${URL}/SHA256 | grep "${ISO}" | cut -d' ' -f2)
        ;;
      qtile)
        ISO="gabeeOSLinux-Qtile-x86_64-6.1.25_1-20230508.iso"
        URL="https://sourceforge.net/projects/gabeeoslinux/files/Distro/Qtile/beta"
        HASH=$(wget -q -O- ${URL}/SHA256 | grep "${ISO}" | cut -d' ' -f4)
        ;;
    esac
    echo "${URL}/${ISO} ${HASH}"
}

function get_miyo() {
    local EDITION="${1:-}"
    local HASH=""
    local URL="https://sourceforge.net/projects/miyolinux/files/${RELEASE}-Release/${EDITION}"

    case ${EDITION} in
      Kwin) ISO="miyo-kwin-x86_64-BIOS-20220526.iso";;
      Deboot-Ceres) ISO="Deboot-Ceres-x86-64-BIOS-20220415.iso";;
      JWM) ISO="miyolinux-jwm-x86_64-BIOS-20220226.iso";;
      Openbox) ISO="MiyoLinux-x86_64-BIOS-20220129.iso";;
      MATE) ISO="mate-minimal-x86_64-BIOS-20220107.iso";;
    esac

    HASH=$(wget -q -O- "${URL}/${ISO}.sha256" | cut -d' ' -f1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_pureos() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local URL=""
    case ${RELEASE} in
      9)
        URL="https://downloads.puri.sm/9/live/${EDITION}/2020-08-06"
        ISO="pureos-${RELEASE}-${EDITION}-live_20200806-amd64.hybrid.iso"
        HASH=$(wget -q -O- "${URL}/checksums.sha256sum" | grep "${ISO}" | cut -d' ' -f1)
        ;;
      10)
        URL="https://downloads.puri.sm/10/${EDITION}/2023-06-14"
        ISO="pureos-${RELEASE}-${EDITION}-live-20230614_amd64.iso"
        HASH=$(wget -q -O- "${URL}/pureos-${RELEASE}-${EDITION}-live-20230614_amd64.checksums_sha256.txt" | head -1 | cut -d' ' -f1)
    esac
    echo "${URL}/${ISO} ${HASH}"
}

function get_rebornos() {
   local ISO=$(curl -s 'https://www.rebornos.org/download/' | grep -ohE 'https://pub-cb7a4d4f7a974896b3bf40c52d1defbc.r2.dev/RebornOS-ISO/(rebornos_xfce_minimal|rebornos_iso)-[0-9]{4}.[0-9]{2}.[0-9]{2}-x86_64.iso' | tail -n1)
   local HASH=$(curl -s 'https://www.rebornos.org/download/' | grep -ozP 'Checksum MD5:.*[0-9a-fA-F]{32}' | grep -zoP '[0-9a-fA-F]{32}' | cut -d '' -f1)
   echo "${ISO} ${HASH}"
}

function get_slax() {
    local HASH=""
    local ISO=""
    local URL="https://slax.org/download-slax.php?a=64bit&b=${EDITION}"
    case ${EDITION} in
      Debian) ISO="slax-64bit-11.6.0.iso"
          HASH="b3771211c4485fec2e4f2418b06125f3e53424c5"
      ;;
      Slackware) ISO="slax-64bit-15.0.1.iso"
          HASH="4ec9dff930251fbae847a56b18d53505147faf84"
      ;;
    esac
    echo "${URL}/${ISO} ${HASH}"
}

function get_slitaz() {
    local HASH=""
    local ISO="slitaz-rolling-${RELEASE}"
    local URL="http://mirror.slitaz.org/iso/rolling"
    case ${RELEASE} in
      preferred) ISO="slitaz-rolling";;
      *)   ISO="slitaz-rolling-${RELEASE}";;
    esac
    HASH=$(wget -q -O- "${URL}/${ISO}.md5" |  cut -d' ' -f1)
    echo "${URL}/${ISO}.iso ${HASH}"
}

function get_sparkylinux() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local URL=""
    ISO="sparkylinux-${RELEASE}-x86_64-${EDITION}.iso"
    case ${EDITION} in
      minimalcli) URL="https://sourceforge.net/projects/sparkylinux/files/cli";;
      minimalgui) URL="https://sourceforge.net/projects/sparkylinux/files/base";;
      *)   URL="https://sourceforge.net/projects/sparkylinux/files/${EDITION}";;
    esac
    HASH=$(wget -q -O- ${URL}/${ISO}.allsums.txt | head -2 | grep 'iso' | cut -d' ' -f1)
    echo "${URL}/${ISO}" "${HASH}"
}

function get_tuxedoos() {
    local DATE=""
    local HASH=""
    local ISO=""
    local URL="https://os.tuxedocomputers.com"

    DATE=$(wget -q -O- "${URL}" | grep '.iso' | cut -d'-' -f4 | cut -d'.' -f1)
    ISO="TUXEDO-OS-${RELEASE}-${DATE}.iso"

    HASH=$(wget -q -O- "${URL}checksums/${ISO}.md5" | cut -d' ' -f1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_ventoy() {
    local HASH=""
    local ISO="ventoy-${RELEASE}-livecd.iso"
    local URL="https://github.com/ventoy/Ventoy/releases/download/v${RELEASE}"
    HASH="$(wget -q -O- "${URL}/sha256.txt" | grep "${ISO}" | cut -d' ' -f4)"
    echo "${URL}/${ISO} ${HASH}"
}

function get_voidpup() {
    local HASH=""
    local URL=""
    local TMPURL=""
    TMPURL=$(wget -q -S -O- --max-redirect=0 "https://sourceforge.net/projects/vpup/files/latest/download" 2>&1 | grep -i Location | cut -d' ' -f4)
    URL=${TMPURL%\?*}
    echo "${URL} ${HASH}"
}

function get_slax() {
    local HASH=""
    local ISO=""
    local URL="https://slax.org/download-slax.php?a=64bit&b=${EDITION}"
    case ${EDITION} in
      Debian) ISO="slax-64bit-11.6.0.iso"
          HASH="b3771211c4485fec2e4f2418b06125f3e53424c5"
      ;;
      Slackware) ISO="slax-64bit-15.0.1.iso"
          HASH="4ec9dff930251fbae847a56b18d53505147faf84"
      ;;
    esac
    echo "${URL}/${ISO} ${HASH}"
}

function get_slitaz() {
    local HASH=""
    local ISO="slitaz-rolling-${RELEASE}"
    local URL="http://mirror.slitaz.org/iso/rolling"
    case ${RELEASE} in
      preferred) ISO="slitaz-rolling";;
      *)   ISO="slitaz-rolling-${RELEASE}";;
    esac
    HASH=$(wget -q -O- "${URL}/${ISO}.md5" |  cut -d' ' -f1)
    echo "${URL}/${ISO}.iso ${HASH}"
}

function get_sparkylinux() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local URL=""
    ISO="sparkylinux-${RELEASE}-x86_64-${EDITION}.iso"
    case ${EDITION} in
      minimalcli) URL="https://sourceforge.net/projects/sparkylinux/files/cli";;
      minimalgui) URL="https://sourceforge.net/projects/sparkylinux/files/base";;
      *)   URL="https://sourceforge.net/projects/sparkylinux/files/${EDITION}";;
    esac
    HASH=$(wget -q -O- ${URL}/${ISO}.allsums.txt | head -2 | grep 'iso' | cut -d' ' -f1)
    echo "${URL}/${ISO}" "${HASH}"
}

function get_tuxedoos() {
    local DATE="202309111354"
    local HASH=""
    local ISO="TUXEDO-OS-${RELEASE}-${DATE}.iso"
    local URL="https://os.tuxedocomputers.com/"
    HASH=$(wget -q -O- "${URL}/checksums" | grep "${ISO}" | cut -d' ' -f1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_ventoy() {
    local HASH=""
    local ISO="ventoy-${RELEASE}-livecd.iso"
    local URL="https://github.com/ventoy/Ventoy/releases/download/v${RELEASE}"
    HASH="$(wget -q -O- "${URL}/sha256.txt" | grep "${ISO}" | cut -d' ' -f4)"
    echo "${URL}/${ISO} ${HASH}"
}

function get_voidpup() {
    local HASH=""
    local URL=""
    local TMPURL=""
    TMPURL=$(wget -q -S -O- --max-redirect=0 "https://sourceforge.net/projects/vpup/files/latest/download" 2>&1 | grep -i Location | cut -d' ' -f4)
    URL=${TMPURL%\?*}
    echo "${URL} ${HASH}"
}

function get_vxlinux() {
    local HASH=""
    local ISO="vx-${RELEASE}.iso"
    local URL="https://github.com/VX-Linux/main/releases/download/${RELEASE}"

    HASH=$(wget -q -O- "${URL}/vx-${RELEASE}.md5" | cut  -d' ' -f1)
    echo "${URL}/${ISO} ${HASH}"
}

# QUICKEMU STANDARD

function get_alma() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO="AlmaLinux-${RELEASE}-latest-x86_64-${EDITION}.iso"
    local URL="https://repo.almalinux.org/almalinux/${RELEASE}/isos/x86_64"
    HASH="$(wget -q -O- "${URL}/CHECKSUM" | grep "(${ISO}" | cut -d' ' -f4)"
    echo "${URL}/${ISO} ${HASH}"
}

function get_alpine() {
    local HASH=""
    local ISO=""
    local URL=""
    local VERSION=""

    case ${RELEASE} in
      latest) URL="https://dl-cdn.alpinelinux.org/alpine/latest-stable/releases/x86_64";;
      *) URL="https://dl-cdn.alpinelinux.org/alpine/v${RELEASE}/releases/x86_64";;
    esac
    VERSION=$(wget -qO- "${URL}/latest-releases.yaml" | awk '/"Xen"/{found=0} {if(found) print} /"Virtual"/{found=1}' | grep 'version:' | awk '{print $2}')
    ISO="alpine-virt-${VERSION}-x86_64.iso"
    HASH=$(wget -qO- "${URL}/latest-releases.yaml" | awk '/"Xen"/{found=0} {if(found) print} /"Virtual"/{found=1}' | grep 'sha256:' | awk '{print $2}')
    echo "${URL}/${ISO} ${HASH}"
}

function get_android() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local JSON_ALL=""
    local JSON_REL=""
    local URL="https://mirrors.gigenet.com/OSDN/android-x86"

    JSON_ALL=$(wget -q -O- "https://www.fosshub.com/Android-x86-old.html" | grep "var settings =" | cut -d'=' -f2-)
    JSON_REL=$(echo "${JSON_ALL}" | jq --arg ver "${OS}-${EDITION}-${RELEASE}" 'first(.pool.f[] | select((.n | startswith($ver)) and (.n | endswith(".iso"))))')
    ISO=$(echo "${JSON_REL}" | jq -r .n)
    HASH=$(echo "${JSON_REL}" | jq -r .hash.sha256)
    # Traverse the directories to find the .iso location
    for DIR in $(wget -4 -q -O- "${URL}" | grep -o -E '[0-9]{5}' | sort -ur); do
        if wget -4 -q -O- "${URL}/${DIR}" | grep "${ISO}" &>/dev/null; then
            URL="${URL}/${DIR}"
            break
        fi
    done
    echo "${URL}/${ISO} ${HASH}"
}

function get_antix() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local URL_runit=""
    local URL="https://sourceforge.net/projects/antix-linux/files/Final/antiX-${RELEASE}"

    case ${RELEASE} in
      21) URL_runit="${URL}/runit-bullseye";;
      *) URL_runit="${URL}/runit-antiX-${RELEASE}";;
    esac

    case ${EDITION} in
      net-sysv)  ISO="antiX-${RELEASE}-net_x64-net.iso";;
      core-sysv) ISO="antiX-${RELEASE}_x64-core.iso";;
      base-sysv) ISO="antiX-${RELEASE}_x64-base.iso";;
      full-sysv) ISO="antiX-${RELEASE}_x64-full.iso";;
      net-runit)  ISO="antiX-${RELEASE}-runit-net_x64-net.iso"
                  URL="${URL_runit}"
      ;;
      core-runit) ISO="antiX-${RELEASE}-runit_x64-core.iso"
                  URL="${URL_runit}"
      ;;
      base-runit) ISO="antiX-${RELEASE}-runit_x64-base.iso"
                  URL="${URL_runit}"
      ;;
      full-runit) ISO="antiX-${RELEASE}-runit_x64-full.iso"
                  URL="${URL_runit}"
      ;;
    esac

    HASH=$(wget -q -O- ${URL}/README.txt | grep "${ISO}" | cut_1 | head -1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_archcraft() {
    local HASH=""
    local URL=""
    # no longer needed?
    #local TMPURL=""

    # Check where the URL redirects using curl. Output to a nonexistent directory so it's not possible to successfully download the image
    URL=$(curl -Lfs "https://sourceforge.net/projects/archcraft/files/latest/download" -w %{url_effective} -o /this/is/a/nonexistent/directory/$RANDOM/$RANDOM)
    echo "${URL} ${HASH}"
}

function get_archlinux() {
    local HASH=""
    local ISO="archlinux-x86_64.iso"
    local URL="https://mirror.rackspace.com/archlinux/iso/latest"

    HASH=$(wget -q -O- "${URL}/sha256sums.txt" | grep "${ISO}" | cut_1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_arcolinux() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO="arcolinux${EDITION:0:1}-${RELEASE}-x86_64.iso"
    local URL="https://ant.seedhost.eu/arcolinux/iso/${RELEASE}"
    HASH=$(wget -q -O- "${URL}/${ISO}.sha1" | cut_1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_artix() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local URL="https://iso.artixlinux.org/iso"

    DATE=$(wget -q -O- ${URL}/sha256sums | cut -d'-' -f4 | head -1)
    ISO="artix-${EDITION}-${DATE}-x86_64.iso"
    HASH=$(wget -q -O- ${URL}/sha256sums | grep "${ISO}")
    echo "${URL}/${ISO} ${HASH}"
}

function get_athenaos() {
    local HASH=""
    local URL=""
    local ISO=""

    case ${RELEASE} in
      rolling)
        ISO="athena-rolling-x86_64.iso"
        URL="https://sourceforge.net/projects/athena-iso/files/rolling"
        HASH=$(wget -q -O- "${URL}/${ISO}.md5" | cut_1)
        ;;
      *)
        ISO="athena-20${RELEASE}-x86_64.iso"
        URL="https://sourceforge.net/projects/athena-iso/files/v${RELEASE}"
        HASH=$(wget -q -O- 'https://sourceforge.net/projects/athena-iso/rss?path=/' | grep '.iso/download"' | grep "${RELEASE}" | cut -d '=' -f7 | cut -d'>' -f2 | cut -d'<' -f1)
        ;;
    esac
    echo "${URL}/${ISO} ${HASH}"
}

function get_batocera() {
    local HASH=""
    local URL="https://mirrors.o2switch.fr/batocera/x86_64/stable/last"
    local ISO="$(curl -sl ${URL}/ | grep -e 'batocera.*img.gz'|cut -d\" -f2)"

    echo "${URL}/${ISO} ${HASH}"
}

function get_bazzite() {
    local HASH=""
    local ISO=""
    local URL="https://github.com/ublue-os/bazzite/releases/download/v${RELEASE}"

    ISO=$(wget -q -O- "https://api.github.com/repos/ublue-os/bazzite/releases" | grep 'download_url' | grep 'sum' | cut -d '"' -f4 | cut -d'.' -f1-5 | grep "${RELEASE}" | cut -d'/' -f9)
    HASH=$(wget -q -O- "${URL}/${ISO}.sha256sum" | grep 'SHA256' | cut -d' ' -f4)
    echo "${URL}/${ISO} ${HASH}"
}

function get_blendos() {
    local HASH=""
    local URL=""

    # BlendOS has more editions and releases but there's a tracker indirect and other issues
    # so easier to use the rss feed
    #
    # We have to provide edition/release as RELEASE or have a major refactor
    # But this works for now ... or does it ....
    URL=$(grep ${RELEASE} /tmp/blendos-isos.rss | grep -E -o 'https://.*blendOS\.iso')
    HASH=$(grep ${RELEASE} /tmp/blendos-isos.rss | grep -E -o '[[:alnum:]]{32}')
    # ## fix up variables for path naming
    EDITION=${RELEASE%%/*}
    RELEASE=${RELEASE##*/}
    # For UX maybe show the date of the release
    #echo ${RELEASE##*/} "(" $(date -d @${RELEASE##*/}) ")"
    # maybe $(date -d @${RELEASE##*/} '+%Y%m%d')
    echo "${URL} ${HASH}"
}

function get_bodhi() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local URL="https://sourceforge.net/projects/bodhilinux/files/${RELEASE}"

    case ${EDITION} in
      standard) ISO="bodhi-${RELEASE}-64.iso";;
      *) ISO="bodhi-${RELEASE}-64-${EDITION}.iso";;
    esac
    HASH=$(wget -q -O- "${URL}/${ISO}.sha256" | cut_1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_bunsenlabs() {
    local HASH=""
    local ISO="beryllium-1-amd64.hybrid.iso"
    local URL="https://ddl.bunsenlabs.org/ddl"

    HASH=$(wget -q -O- "${URL}/release.sha256.txt" | head -1 | cut_1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_cachyos() {
    local HASH=""
    local ISO="cachyos-${EDITION}-linux-${RELEASE}.iso"
    local URL="https://mirror.cachyos.org/ISO/${EDITION}/${RELEASE}"
    HASH=$(wget -q -O- "${URL}/${ISO}.sha256" | cut_1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_centos-stream() {
    local HASH=""
    local ISO=""

    case ${RELEASE} in
      8)
        ISO="CentOS-Stream-${RELEASE}-x86_64-latest-${EDITION}.iso"
        URL="https://mirrors.ocf.berkeley.edu/centos/8-stream/isos/x86_64"
        HASH=$(wget -q -O- ${URL}/CHECKSUM | grep "SHA256 (${ISO}" | cut -d' ' -f4)
        ;;
      9)
        ISO="CentOS-Stream-${RELEASE}-latest-x86_64-${EDITION}.iso"
        URL="https://mirrors.ocf.berkeley.edu/centos-stream/9-stream/BaseOS/x86_64/iso"
        HASH=$(wget -q -O- ${URL}/${ISO}.SHA256SUM | grep "SHA256 (${ISO}" | cut -d' ' -f4)
        ;;
    esac
    echo "${URL}/${ISO} ${HASH}"
}

function get_chimeralinux() {
    local EDITION="${1:-}"
    local HASH=""
    local DATE=""
    local ISO=""
    local URL="https://repo.chimera-linux.org/live/${RELEASE}"

    DATE=$(wget -q -O- "${URL}/sha256sums.txt" | head -n1 | cut -d'-' -f5)
    ISO="chimera-linux-x86_64-LIVE-${DATE}-${EDITION}.iso"
    HASH=$(wget -q -O- "${URL}/sha256sums.txt" | grep 'x86_64-LIVE' | grep "${EDITION}" | cut_1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_crunchbang++() {
    local HASH=""
    local ISO=""
    local URL=""
    local URLPART=""
    local URLPART2=""

    URLPART="https://github.com/CBPP/cbpp"
    case ${RELEASE} in
      8)
        URLPART2="releases/download/v1.0-amd64"
        ISO="cbpp-1.0-amd64-20150428.iso"
        ;;
      9)
        URLPART2="9-amd64/releases/download/v9.0"
        ISO="cbpp-9.0-amd64-20170621.iso"
        ;;
      10)
        URLPART2="releases/download/v10"
        ISO="cbpp-10.1-amd64-20190713.iso"
        ;;
      11)
        URLPART2="releases/download/v11.2"
        ISO="cbpp-11.2-amd64-20230514.iso"
        ;;
      12)
        URLPART2="releases/download/v12.0"
        ISO="cbpp-12.0-amd64-20230611.iso"
        ;;
    esac
    URL="${URLPART}/${URLPART2}"
    echo "${URL}/${ISO} ${HASH}"
}

function get_debian() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO="debian-live-${RELEASE}-amd64-${EDITION}.iso"
    local URL=""

    DEBCURRENT=$(wget -q https://cdimage.debian.org/debian-cd/ -O- |grep '\.[0-9]/'|cut -d\> -f9|cut -d\/ -f1)
    case ${RELEASE} in
      "${DEBCURRENT}") URL="https://cdimage.debian.org/debian-cd/${RELEASE}-live/amd64/iso-hybrid";;
      *) URL="https://cdimage.debian.org/cdimage/archive/${RELEASE}-live/amd64/iso-hybrid";;
    esac

    if [ "${EDITION}" == "netinst" ]; then
        URL="${URL/-live/}"
        URL="${URL/hybrid/cd}"
        ISO="${ISO/-live/}"
    fi

    HASH=$(wget -q -O- "${URL}/SHA512SUMS" | grep "${ISO}" | cut_1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_deepin() {
    local HASH=""
    local EDITION=""
    local ISO="deepin-desktop-community-${RELEASE}-amd64.iso"
    # deepin-desktop-community-20.3-amd64.iso
    local URL="https://cdimage.deepin.com/releases/"${RELEASE}

    # fix iso name
    if [[ "${RELEASE}" == *"20" ]] ; then
        EDITION="1003"
        ISO="deepin-desktop-community-${EDITION}-amd64.iso"
    elif [[ "${RELEASE}" == *"20.1" ]]; then
        EDITION="1010"
        ISO="deepin-desktop-community-${EDITION}-amd64.iso"
    fi

    HASH=$(wget -q -O- "${URL}/SHA256SUMS" | grep "${ISO}" | cut_1)
    #echo "${URL}/${ISO} ${HASH}"
    web_get "${URL}/${ISO}" "${VM_PATH}"
    check_hash "${ISO}" "${HASH}"
    make_vm_config "${ISO}"
}

function get_devuan() {
    local HASH=""
    local ISO=""
    local URL="https://files.devuan.org/devuan_${RELEASE}/desktop-live"

    case ${RELEASE} in
      beowulf) ISO="devuan_${RELEASE}_3.1.1_amd64_desktop-live.iso";;
      chimaera) ISO="devuan_${RELEASE}_4.0.2_amd64_desktop-live.iso";;
      daedalus) ISO="devuan_${RELEASE}_5.0.0_amd64_desktop-live.iso";;
    esac
    HASH=$(wget -q -O- "${URL}/SHASUMS.txt" | grep "${ISO}" | cut_1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_dragonflybsd() {
    local HASH=""
    local ISO="dfly-x86_64-${RELEASE}_REL.iso.bz2"
    local URL="http://mirror-master.dragonflybsd.org/iso-images"

    HASH=$(wget -q -O- "${URL}/md5.txt" | grep "(${ISO})" | cut -d' ' -f4)
    echo "${URL}/${ISO} ${HASH}"
}

function get_easyos() {
    local HASH=""
    local URL="https://distro.ibiblio.org/easyos/amd64/releases/kirkstone/2023/${RELEASE}"
    local ISO="easy-${RELEASE}-amd64.img"

    HASH=$(wget -q -O- "${URL}/md5.sum.txt" | cut  -d' ' -f1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_elementary() {
    local HASH=""
    case ${RELEASE} in
      7.0)
        local ISO="elementaryos-${RELEASE}-stable.20230129rc.iso"
        ;;
      7.1)
        local ISO="elementaryos-${RELEASE}-stable.20230926rc.iso"
        HASH="5c7f6b388e5787c366587985301ea05ab16e4cc0de3be2b3d6a559ce81a2f102"
        ;;
    esac
    local URL="https://ams3.dl.elementary.io/download"
    echo "${URL}/$(date +%s | base64)/${ISO} ${HASH}"
}

function get_endeavouros() {
    local HASH=""
    # Endeavour release names are Capitalized and our $RELEASE is forced to lowercase so we have to revert it
    local ISO="EndeavourOS_${RELEASE@u}.iso"
    local URL="https://github.com/endeavouros-team/ISO/releases/download/1-EndeavourOS-ISO-releases-archive"

    HASH=$(wget -q -O- "${URL}/${ISO}.sha512sum" | cut  -d' ' -f1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_endless() {
    local HASH="" # No hash - there is a signature in .asc signed by
    #https://d1anzknqnc1kmb.cloudfront.net/eos-image-keyring.gpg
    # (4096R: CB50 0F7B C923 3FAD 32B4 E720 9E0C 1250 587A 279C)
    local FILE_TS=""

    # https://support.endlessos.org/en/installation/direct-download gives the info but computes the URLS in js
    # so parsing out the useful info is not happening tonight
    # Endless edition names are "base" for the small minimal one or the Language for the large full release
    # The isos are stamped as they are finished so ....
    case ${EDITION} in
      base)
          FILE_TS="230127-211122";;
        fr)
          FILE_TS="230127-213415";;
        en)
          FILE_TS="230127-212436";;
        es)
          FILE_TS="230127-212646";;
        pt_BR)
          FILE_TS="230127-220328";;
    esac
    URL="https://images-dl.endlessm.com/release/${RELEASE}/eos-amd64-amd64/${EDITION}"
    ISO="eos-eos${RELEASE:0:3}-amd64-amd64.${FILE_TS}.${EDITION}.iso"
    echo "${URL}/${ISO}"
}

function get_fedora() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local JSON=""
    local URL=""
    local VARIANT=""

    case ${EDITION} in
      Server|Kinoite|Onyx|Silverblue|Sericea|Workstation) VARIANT="${EDITION}";;
      *) VARIANT="Spins";;
    esac
    JSON=$(wget -q -O- "https://getfedora.org/releases.json" | jq '.[] | select(.variant=="'${VARIANT}'" and .subvariant=="'"${EDITION}"'" and .arch=="x86_64" and .version=="'"${RELEASE}"'")')
    URL=$(echo "${JSON}" | jq -r '.link' | head -n1)
    HASH=$(echo "${JSON}" | jq -r '.sha256' | head -n1)
    echo "${URL} ${HASH}"
}

function get_freebsd() {
    local EDITION="${1}"
    local HASH=""
    local ISO="FreeBSD-${RELEASE}-RELEASE-amd64-${EDITION}.iso"
    local URL="https://download.freebsd.org/ftp/releases/amd64/amd64/ISO-IMAGES/${RELEASE}"

    HASH=$(wget -q -O- "${URL}/CHECKSUM.SHA256-FreeBSD-${RELEASE}-RELEASE-amd64" | grep "${ISO}" | grep -v ".xz" | cut -d' ' -f4)
    echo "${URL}/${ISO} ${HASH}"
}

function get_freedos() {
    local HASH=""
    local ISO=""
    local URL="http://www.ibiblio.org/pub/micro/pc-stuff/freedos/files/distributions/${RELEASE}/official"

    case ${RELEASE} in
      1.2)
        ISO="FD12CD.iso"
        HASH=$(wget -q -O- "${URL}/FD12.sha" | grep "${ISO}" | cut_1)
        ;;
      1.3)
        ISO="FD13-LiveCD.zip"
        HASH=$(wget -q -O- "${URL}/verify.txt" | grep -A 8 "sha256sum" | grep "${ISO}" | cut_1)
        ;;
    esac
    echo "${URL}/${ISO} ${HASH}"
}

function get_garuda() {
  local EDITION="${1:-}"
  local HASH=""
  local ISO=""
  local URL="https://iso.builds.garudalinux.org/iso/latest/garuda"

  ISO=${EDITION}/latest.iso
  HASH="$(wget -q -O- "${URL}/${ISO}.sha256" | cut_1)"
  echo "${URL}/${ISO} ${HASH}"
}

function get_gentoo() {
    local HASH=""
    local ISO=""
    local URL="https://mirror.bytemark.co.uk/gentoo/releases/amd64/autobuilds/"

    case ${EDITION} in
      minimal) ISO=$(wget -q -O- "${URL}/${RELEASE}-iso.txt" | grep install | cut -d' ' -f1)
        HASH=$( wget -q -O- "${URL}/${ISO}.DIGESTS" | grep -A 1 SHA512 | grep iso | grep -v CONTENTS | cut -d' ' -f1);;
      livegui) ISO=$(wget -q -O- "${URL}/${RELEASE}-iso.txt" | grep livegui | cut -d' ' -f1)
        HASH=$( wget -q -O- "${URL}/${ISO}.DIGESTS" | grep -A 1 SHA512 | grep iso | grep -v CONTENTS | cut -d' ' -f1);;
    esac
    echo "${URL}/${ISO} ${HASH}"
}

function get_ghostbsd() {
    local EDITION="${1:-}"
    local ISO=""
    local URL="https://download.ghostbsd.org/releases/amd64/${RELEASE}"
    local HASH=""

    case ${EDITION} in
      mate) ISO="GhostBSD-${RELEASE}.iso";;
      xfce) ISO="GhostBSD-${RELEASE}-XFCE.iso";;
    esac
    HASH=$(wget -q -O- "${URL}/${ISO}.sha256" | grep "${ISO}" | cut -d' ' -f4)
    echo "${URL}/${ISO} ${HASH}"
}

function get_haiku() {
    local EDITION="${1:-}"
    local ISO="haiku-${RELEASE}-${EDITION}-anyboot.iso"
    # local URL="https://cdn.haiku-os.org/haiku-release/${RELEASE}" # domain gone
    local URL="http://mirror.rit.edu/haiku/${RELEASE}" # NY, USA
    # local URL="https://mirrors.tnonline.net/haiku/haiku-release/${RELEASE}" # Sweden
    # local URL="https://mirror.aarnet.edu.au/pub/haiku/${RELEASE}" # Aus

    HASH=$(wget -q -O- "${URL}/${ISO}.sha256" | grep "${ISO}" | cut -d' ' -f4)
    echo "${URL}/${ISO} ${HASH}"
}

function get_holoiso() {
    #local HASH=""
    local ISO=$(wget -q -O- "https://api.github.com/repos/HoloISO/holoiso/releases" | sed 's/ /\n/g' | grep "HoloISO_${RELEASES}" | cut -d'\' -f1 | cut -d'/' -f4)
    local URL="https://cd2.holoiso.ru.eu.org"
    # Can't find hash
    #HASH=$(wget -q -O- "${URL}/${ISO}.sha256sum" | cut_1)
    echo "${URL}/${ISO} #${HASH}"
}

function get_kali() {
    local HASH=""
    local ISO=""
    local URL="https://cdimage.kali.org/${RELEASE}"

    ISO=$(wget -q -O- "${URL}/?C=M;O=D" | grep -o ">kali-linux-.*-installer-amd64.iso" | head -n 1 | cut -c 2-)
    HASH=$(wget -q -O- "${URL}/SHA256SUMS" | grep -v torrent | grep "${ISO}" | cut_1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_kdeneon() {
    local HASH=""
    local ISO=""
    local URL="https://files.kde.org/neon/images/${RELEASE}/current"

    ISO=$(wget -q -O- "${URL}/neon-${RELEASE}-current.sha256sum" | cut -d' ' -f3-)
    HASH=$(wget -q -O- "${URL}/neon-${RELEASE}-current.sha256sum" | cut_1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_kolibrios() {
    local HASH=""
    local ISO="kolibri.iso"
    local URL="https://builds.kolibrios.org/eng"
    echo "${URL}/${ISO} ${HASH}"
}

function get_linuxlite() {
    local HASH=""
    local ISO="linux-lite-${RELEASE}-64bit.iso"
    local URL="https://sourceforge.net/projects/linux-lite/files/${RELEASE}"

    HASH=$(wget -q -O- "${URL}/${ISO}.sha256" | cut_1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_linuxmint() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO="linuxmint-${RELEASE}-${EDITION}-64bit.iso"
    local URL="https://mirror.bytemark.co.uk/linuxmint/stable/${RELEASE}"

    HASH=$(wget -q -O- "${URL}/sha256sum.txt" | grep "${ISO}" | cut_1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_lmde() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO="lmde-${RELEASE}-${EDITION}-64bit.iso"
    local URL="https://mirror.bytemark.co.uk/linuxmint/debian"

    HASH=$(wget -q -O- "${URL}/sha256sum.txt" | grep "${ISO}" | cut_1)
    echo "${URL}/${ISO} ${HASH}"
}

function generate_id() {
    local macRecoveryID=""
    local TYPE="${1}"
    local valid_chars=("0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "A" "B" "C" "D" "E" "F")

    for ((i=0; i<$TYPE; i++)); do
        macRecoveryID+="${valid_chars[$((RANDOM % 16))]}"
    done
    echo "${macRecoveryID}"
}

function get_macos() {
    local BOARD_ID=""
    local CWD=""
    local CHUNKCHECK=""
    local MLB="00000000000000000"
    local OS_TYPE="default"

    case ${RELEASE} in
      lion)           #10.7
        BOARD_ID="Mac-2E6FAB96566FE58C"
        MLB="00000000000F25Y00";;
      mountainlion)   #10.8
        BOARD_ID="Mac-7DF2A3B5E5D671ED"
        MLB="00000000000F65100";;
      mavericks)      #10.9
        BOARD_ID="Mac-F60DEB81FF30ACF6"
        MLB="00000000000FNN100";;
      yosemite)       #10.10
        BOARD_ID="Mac-E43C1C25D4880AD6"
        MLB="00000000000GDVW00";;
      elcapitan)      #10.11
        BOARD_ID="Mac-FFE5EF870D7BA81A"
        MLB="00000000000GQRX00";;
      sierra)         #10.12
        BOARD_ID="Mac-77F17D7DA9285301"
        MLB="00000000000J0DX00";;
      high-sierra)    #10.13
        BOARD_ID="Mac-BE088AF8C5EB4FA2"
        MLB="00000000000J80300";;
      mojave)         #10.14
        BOARD_ID="Mac-7BA5B2DFE22DDD8C"
        MLB="00000000000KXPG00";;
      catalina)       #10.15
        BOARD_ID="Mac-00BE6ED71E35EB86";;
      big-sur)        #11
        BOARD_ID="Mac-42FD25EABCABB274";;
      monterey)       #12
        BOARD_ID="Mac-E43C1C25D4880AD6";;
      ventura)        #13
        BOARD_ID="Mac-BE088AF8C5EB4FA2";;
      sonoma)
        BOARD_ID="Mac-53FDB3D8DB8CA971";;
      *) echo "ERROR! Unknown release: ${RELEASE}"
        releases_macos
        exit 1;;
    esac

    CWD="$(dirname "${0}")"
    if [ -x "${CWD}/chunkcheck" ]; then
        CHUNKCHECK="${CWD}/chunkcheck"
    elif [ -x /usr/bin/chunkcheck ]; then
        CHUNKCHECK="/usr/bin/chunkcheck"
    else
        web_get "https://raw.githubusercontent.com/wimpysworld/quickemu/master/chunkcheck" "${HOME}/.quickemu"
        CHUNKCHECK="${HOME}/.quickemu/chunkcheck"
    fi

    if [ -z "${CHUNKCHECK}" ]; then
        read -p "ERROR! Can not find chunkcheck. Will not be able to verify image. Proceed anyway?" skipVerification
        if [ "${skipVerification,,}" != "y" ] && [ "${skipVerification,,}" != "yes" ]; then
            exit 1
        fi
        echo 'Skipping verification' && skipVerification=true
    fi

    OpenCore_qcow2="https://github.com/kholia/OSX-KVM/raw/master/OpenCore/OpenCore.qcow2"
    OVMF_CODE="https://github.com/kholia/OSX-KVM/raw/master/OVMF_CODE.fd"
    OVMF_VARS="https://github.com/kholia/OSX-KVM/raw/master/OVMF_VARS-1920x1080.fd"

    local appleSession=$(curl -v -H "Host: osrecovery.apple.com" -H "Connection: close" -A "InternetRecovery/1.0" http://osrecovery.apple.com/ 2>&1 | tr ';' '\n' | awk -F'session=|;' '{print $2}' | grep 1)
    local info=$(curl -s -X POST -H "Host: osrecovery.apple.com" -H "Connection: close" -A "InternetRecovery/1.0" -b "session=\"${appleSession}\"" -H "Content-Type: text/plain"\
    -d $'cid='$(generate_id 16)$'\nsn='${MLB}$'\nbid='${BOARD_ID}$'\nk='$(generate_id 64)$'\nfg='$(generate_id 64)$'\nos='${OS_TYPE} \
    http://osrecovery.apple.com/InstallationPayload/RecoveryImage | tr ' ' '\n')
    local downloadLink=$(echo "$info" | grep 'oscdn' | grep 'dmg')
    local downloadSession=$(echo "$info" | grep 'expires' | grep 'dmg')
    local chunkListLink=$(echo "$info" | grep 'oscdn' | grep 'chunklist')
    local chunkListSession=$(echo "$info" | grep 'expires' | grep 'chunklist')

    if [ "${show_iso_url}" == 1 ]; then
        echo -e "Recovery URL (inaccessible through normal browser):\n${downloadLink}\nChunklist (used for verifying the Recovery Image):\n${chunkListLink}\nFirmware URLs:\n${OpenCore_qcow2}\n${OVMF_CODE}\n${OVMF_VARS}"
        exit 0
    elif [ "${test_iso_url}" == 1 ]; then
        wget --spider --header "Host: oscdn.apple.com" --header "Connection: close" --header "User-Agent: InternetRecovery/1.0" --header "Cookie: AssetToken=${downloadSession}" "${downloadLink}"
        wget --spider --header "Host: oscdn.apple.com" --header "Connection: close" --header "User-Agent: InternetRecovery/1.0" --header "Cookie: AssetToken=${chunkListSession}" "${chunkListLink}"
        exit 0
    elif [ "${download_iso}" == 1 ]; then
        echo "Downloading macOS ${RELEASE} from ${downloadLink}"
        web_get "${downloadLink}" "${VM_PATH}" RecoveryImage.dmg --header "Host: oscdn.apple.com" --header "Connection: close" --header "User-Agent: InternetRecovery/1.0" --header "Cookie: AssetToken=${downloadSession}"
        curl --progress-bar "${chunkListLink}" -o RecoveryImage.chunklist --header "Host: oscdn.apple.com" --header "Connection: close" --header "User-Agent: InternetRecovery/1.0" --header "Cookie: AssetToken=${chunkListSession}"
        VM_PATH="$(pwd)"
    else
        echo "Downloading macOS firmware"
        web_get "${OpenCore_qcow2}" "${VM_PATH}"
        web_get "${OVMF_CODE}" "${VM_PATH}"
        if [ ! -e "${VM_PATH}/OVMF_VARS-1920x1080.fd" ]; then
            web_get "${OVMF_VARS}" "${VM_PATH}"
        fi

        if [ ! -e "${VM_PATH}/RecoveryImage.chunklist" ]; then
            echo "Downloading macOS ${RELEASE} from ${downloadLink}"
            web_get "${downloadLink}" "${VM_PATH}" RecoveryImage.dmg --header "Host: oscdn.apple.com" --header "Connection: close" --header "User-Agent: InternetRecovery/1.0" --header "Cookie: AssetToken=${downloadSession}"
            curl --progress-bar "${chunkListLink}" -o "${VM_PATH}/RecoveryImage.chunklist" --header "Host: oscdn.apple.com" --header "Connection: close" --header "User-Agent: InternetRecovery/1.0" --header "Cookie: AssetToken=${chunkListSession}"
        fi
    fi

    if [ $skipVerification != true ]; then
        if ! python3 "${CHUNKCHECK}" "${VM_PATH}" 2> /dev/null; then
            echo "Verification failed."
            exit 1
        fi
        echo "Verified macOS ${RELEASE} image using chunklist."
    else
        echo "Skipping verification of image."
    fi

    if [ -e "${VM_PATH}/RecoveryImage.dmg" ] && [ ! -e "${VM_PATH}/RecoveryImage.img" ]; then
        echo "Converting RecoveryImage..."
        qemu-img convert "${VM_PATH}/RecoveryImage.dmg" -O raw "${VM_PATH}/RecoveryImage.img" 2>/dev/null
    fi

    rm "${VM_PATH}/RecoveryImage.dmg" "${VM_PATH}/RecoveryImage.chunklist"
    make_vm_config RecoveryImage.img
}

function get_mageia() {
    local EDITION="${1:-}"
    local ISO=$(wget -q https://www.mageia.org/en/downloads/get/?q="Mageia-${RELEASE}-Live-${EDITION}-x86_64.iso" -O- | grep 'click here'| grep -o 'href=.*\.iso'|cut -d\" -f2)
    local HASH=$(wget -q -O- "${ISO}.sha512" | cut_1)
    echo "${ISO} ${HASH}"
}

function get_manjaro() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local MANIFEST=""
    local URL=""
    local TYPE=""

    case ${RELEASE} in
      sway) MANIFEST="$( wget -qO- https://mirror.manjaro-sway.download/manjaro-sway/release.json )";;
      gnome|xfce|plasma) TYPE="official";;
      *) TYPE="community";;
    esac

    [[ ${RELEASE} != "sway" ]] && MANIFEST="$(wget -qO- https://gitlab.manjaro.org/web/iso-info/-/raw/master/file-info.json)"
    [[ ${EDITION} == "minimal" && ${TYPE} != "sway" ]] && EDITION=".minimal" || EDITION=""
    if [[ ${RELEASE} != "sway" ]]; then
        URL="$(echo ${MANIFEST} | jq -r .${TYPE}.${RELEASE}${EDITION}.image)"
    else
        URL=$(echo ${MANIFEST} | jq -r '.[] | select(.name|test("^manjaro-sway-.*[.]iso$")) | select(.name|contains("unstable")|not) | .url')
    fi
    HASH=$(wget -qO- "${URL}.sha512" | cut_1)
    echo "${URL} ${HASH}"
}

function get_mxlinux() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local URL="https://sourceforge.net/projects/mx-linux/files/Final/${EDITION}"

    case ${EDITION} in
      Xfce) ISO="MX-${RELEASE}_x64.iso";;
      KDE) ISO="MX-${RELEASE}_KDE_x64.iso";;
      Fluxbox) ISO="MX-${RELEASE}_fluxbox_x64.iso";;
    esac
    HASH=$(wget -q -O- "${URL}/${ISO}.sha256" | cut_1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_netboot() {
    local ISO="netboot.xyz.iso"
    local HASH=""
    local URL="https://boot.netboot.xyz/ipxe"

    HASH=$(wget -q -O- "${URL}/netboot.xyz-sha256-checksums.txt" | grep "${ISO}" | cut_1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_netbsd() {
    local HASH=""
    local ISO="NetBSD-${RELEASE}-amd64.iso"
    local URL="https://cdn.netbsd.org/pub/NetBSD/NetBSD-${RELEASE}/images/"

    HASH=$(wget -q -O- "${URL}/MD5" | grep "${ISO}" | cut -d' ' -f4)
    echo "${URL}/${ISO} ${HASH}"
}

function get_nitrux() {
    local HASH=""
    local URLBASE=""
    local URL=""
    local ISONAME=""
    local ISO=""

    URLBASE="https://sourceforge.net/projects/nitruxos/files/Release"
    URL="${URLBASE}/ISO"
    ISONAME="nitrux-nx-desktop-plasma-fefc905b-amd64"
    ISO="${ISONAME}.iso"
    HASH=$(wget -q -O- "${URLBASE}/MD5/${ISONAME}.md5sum" | grep "${ISO}" | cut -d' ' -f1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_nixos() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO="latest-nixos-${EDITION}-x86_64-linux.iso"
    local URL="https://channels.nixos.org/nixos-${RELEASE}"

    HASH=$(wget -q -O- "${URL}/${ISO}.sha256" | cut_1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_openbsd() {
    local HASH=""
    local ISO="install${RELEASE//\./}.iso"
    local URL="https://mirror.leaseweb.com/pub/OpenBSD/${RELEASE}/amd64"

    HASH=$(wget -q -O- "${URL}/SHA256" | grep "${ISO}" | cut -d' ' -f4)
    echo "${URL}/${ISO} ${HASH}"
}

function get_openindiana(){
    local HASH=""
    local ISO=""
    local URL=""

    URL="https://dlc.openindiana.org/isos/hipster/${RELEASE}"
    ISO="OI-hipster-${EDITION}-${RELEASE}.iso"
    HASH=$(wget -q -O- "${URL}/${ISO}.sha256" |cut_1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_opensuse() {
    local HASH=""
    local ISO=""
    local URL=""

    if [ "${RELEASE}" == "tumbleweed" ]; then
        ISO="openSUSE-Tumbleweed-DVD-x86_64-Current.iso"
        URL="https://download.opensuse.org/tumbleweed/iso"
    elif [ "${RELEASE}" == "microos" ]; then
        ISO="openSUSE-MicroOS-DVD-x86_64-Current.iso"
        URL="https://download.opensuse.org/tumbleweed/iso"
    elif [ "$RELEASE" == 15.0 ] || [ "$RELEASE" == 15.1 ]; then
        ISO="openSUSE-Leap-${RELEASE}-DVD-x86_64.iso"
        URL="https://download.opensuse.org/distribution/leap/${RELEASE}/iso"
    else
        ISO="openSUSE-Leap-${RELEASE}-DVD-x86_64-Current.iso"
        URL="https://download.opensuse.org/distribution/leap/${RELEASE}/iso"
    fi
    HASH=$(wget -q -O- "${URL}/${ISO}.sha256" |awk '{if(NR==4) print $0}'|cut_1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_oraclelinux() {
    local HASH=""
    local ISO=""
    local VER_MAJ=${RELEASE::1}
    local VER_MIN=${RELEASE:2:1}
    local URL="https://yum.oracle.com/ISOS/OracleLinux/OL${VER_MAJ}/u${VER_MIN}/x86_64/"

    case ${VER_MAJ} in
      7) ISO="OracleLinux-R${VER_MAJ}-U${VER_MIN}-Server-x86_64-dvd.iso";;
      *) ISO="OracleLinux-R${VER_MAJ}-U${VER_MIN}-x86_64-dvd.iso";;
    esac
    HASH=$(wget -q -O- "https://linux.oracle.com/security/gpg/checksum/OracleLinux-R${VER_MAJ}-U${VER_MIN}-Server-x86_64.checksum" | grep "${ISO}" | cut_1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_parrotsec() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local URL=""

    ISO="Parrot-${EDITION}-${RELEASE}_amd64.iso"
    URL="https://download.parrot.sh/parrot/iso/${RELEASE}"
    HASH="$(wget -q -O- "${URL}"/signed-hashes.txt | grep "${ISO}" | cut_1)"
    echo "${URL}/${ISO}" "${HASH}"
}

function get_peppermint() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local URL="https://sourceforge.net/projects/peppermintos/files/isos"

    case ${EDITION} in
      devuan-xfce) ISO="PeppermintOS-devuan_64_xfce.iso"
      URL="${URL}/XFCE"
      ;;
      debian-xfce) ISO="PeppermintOS-Debian-64.iso"
      URL="${URL}/XFCE"
      ;;
      devuan-gnome) ISO="PeppermintOS-devuan_64_gfb.iso"
      URL="${URL}/Gnome_FlashBack"
      ;;
      debian-gnome) ISO="PeppermintOS-Debian_64_gfb.iso"
      URL="${URL}/Gnome_FlashBack"
      ;;
    esac
    HASH=$(wget -q -O- "${URL}/${ISO}-sha512.checksum" | grep "${ISO}" | cut_1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_popos() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local URL=""

    URL=$(wget -q -O- "https://api.pop-os.org/builds/${RELEASE}/${EDITION}" | jq -r .url)
    HASH=$(wget -q -O- "https://api.pop-os.org/builds/${RELEASE}/${EDITION}" | jq -r .sha_sum)
    echo "${URL} ${HASH}"
}

function get_porteus() {
    local EDITION="${1:-}"
    local edition=""
    local HASH=""
    local ISO=""
    local URL=""

    edition="${EDITION~~}"
    ISO="Porteus-${edition}-v${RELEASE}-x86_64.iso"
    URL="https://mirrors.dotsrc.org/porteus/x86_64/Porteus-v${RELEASE}"
    HASH=$(wget -q -O- "${URL}/sha256sums.txt" | grep "${ISO}" | cut_1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_primtux() {
    local HASH=""
    local URL=""
    local ISO=""

    ISO="PrimTux${RELEASE}-amd64-${EDITION}.iso"
    URL="https://sourceforge.net/projects/primtux/files/Distribution"
    HASH=$(wget -q -O- "${URL}/${ISO}.md5" | grep "${ISO}" | cut_1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_primtux() {
    local HASH=""
    local URL=""
    local ISO=""

    ISO="PrimTux${RELEASE}-amd64-${EDITION}.iso"
    URL="https://sourceforge.net/projects/primtux/files/Distribution"
    HASH=$(wget -q -O- "${URL}/${ISO}.md5" | grep "${ISO}" | cut -d' ' -f1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_pureos() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local URL=""

    case ${RELEASE} in
      9)
        URL="https://downloads.puri.sm/9/live/${EDITION}/2020-08-06"
        ISO="pureos-${RELEASE}-${EDITION}-live_20200806-amd64.hybrid.iso"
        HASH=$(wget -q -O- "${URL}/checksums.sha256sum" | grep "${ISO}" | cut -d' ' -f1)
        ;;
      10)
        URL="https://downloads.puri.sm/10/${EDITION}/2023-06-14"
        ISO="pureos-${RELEASE}-${EDITION}-live-20230614_amd64.iso"
        HASH=$(wget -q -O- "${URL}/pureos-${RELEASE}-${EDITION}-live-20230614_amd64.checksums_sha256.txt" | head -1 | cut -d' ' -f1)
    esac
    echo "${URL}/${ISO} ${HASH}"
}

function get_reactos() {
    local HASH=""
    local URL=""
    # no longer needed?
    #local TMPURL=""

    URL=$(curl -Lfs "https://sourceforge.net/projects/reactos/files/latest/download" -w %{url_effective} -o /this/is/a/nonexistent/directory/$RANDOM/$RANDOM)
    echo "${URL} ${HASH}"
}

function get_rebornos() {
    local ISO=""
    local HASH=""
    ISO=$(wget -q -O- "https://meta.cdn.soulharsh007.dev/RebornOS-ISO?format=json" | jq -r ".url")
    HASH=$(wget -q -O- "https://meta.cdn.soulharsh007.dev/RebornOS-ISO?format=json" | jq -r ".md5")
    echo "${ISO} ${HASH}"
}

function get_rockylinux() {
    local EDITION="${1:-}"
    if [[ "${RELEASE}" =~ ^8. ]] && [[ "${EDITION}" == "dvd" ]]
    then
        EDITION="dvd1"
    fi
    local HASH=""
    local ISO="Rocky-${RELEASE}-x86_64-${EDITION}.iso"
    local URL=""

    case ${RELEASE} in
      9.1) URL="https://download.rockylinux.org/pub/rocky/9/isos/x86_64";;
      8.7) URL="https://download.rockylinux.org/pub/rocky/8/isos/x86_64";;
      *)   URL="http://dl.rockylinux.org/vault/rocky/${RELEASE}/isos/x86_64";;
    esac
    HASH=$(wget -q -O- "${URL}/CHECKSUM" | grep "SHA256" | grep "${ISO})" | cut -d' ' -f4)
    echo "${URL}/${ISO} ${HASH}"
}

function get_siduction() {
    local HASH=""
    local DATE=""
    local ISO=""
    local URL="https://mirrors.dotsrc.org/siduction/iso/Standing_on_the_Shoulders_of_Giants/${EDITION}"

    DATE=$(wget -q -O- "${URL}"| grep .iso.md5 | cut -d'-' -f6 | cut -d'.' -f1)
    HASH=$(wget -q -O- "${URL}/${ISO}.md5" | cut_1)
    ISO="siduction-2023.1.1-Standing_on_the_Shoulders_of_Giants-${EDITION}-amd64-${DATE}.iso"
    echo "${URL}/${ISO} ${HASH}"
}

function get_slackware() {
    local HASH=""
    local ISO="slackware64-${RELEASE}-install-dvd.iso"
    local URL="https://slackware.nl/slackware/slackware-iso/slackware64-${RELEASE}-iso"

    HASH=$(wget -q -O- "${URL}/${ISO}.md5" |  cut_1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_slax() {
    local HASH=""
    local ISO=""
    local URL=""

    case ${EDITION} in
      debian)
        URL="https://ftp.fi.muni.cz/pub/linux/slax/Slax-12.x"
        ISO=$(wget -q -O- "${URL}/md5.txt" | grep '64bit-' | cut -d' ' -f3 | tail -n1)
        HASH=$(wget -q -O- "${URL}/md5.txt" | grep '64bit-' | cut_1 | tail -n1)
        ;;
      slackware)
        URL="https://ftp.fi.muni.cz/pub/linux/slax/Slax-15.x"
        ISO=$(wget -q -O- "${URL}/md5.txt" | grep '64bit-' | cut -d' ' -f3 | tail -n1)
        HASH=$(wget -q -O- "${URL}/md5.txt" | grep '64bit-' | cut_1 | tail -n1)
        ;;
    esac
    echo "${URL}/${ISO} ${HASH}"
}

function get_slint() {
    local HASH=""
    local ISO=""
    local URL=""

    case ${RELEASE} in
      14.2.1) ISO="slint64-14.2.1.4.iso";;
      15.0) ISO="slint64-15.0-5.iso";;
    esac
    URL="https://slackware.uk/slint/x86_64/slint-${RELEASE}/iso"
    HASH=$(wget -q -O- "${URL}"/${ISO}.sha256 | cut -d' ' -f4)
    echo "${URL}/${ISO}" "${HASH}"
}

function get_slitaz() {
    local HASH=""
    local ISO="slitaz-rolling-${RELEASE}"
    local URL="http://mirror.slitaz.org/iso/rolling"

    case ${RELEASE} in
      preferred) ISO="slitaz-rolling";;
      *) ISO="slitaz-rolling-${RELEASE}";;
    esac
    HASH=$(wget -q -O- "${URL}/${ISO}.md5" |  cut_1)
    echo "${URL}/${ISO}.iso ${HASH}"
}

function get_solus() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO="Solus-${RELEASE}-${EDITION}.iso"
    local URL="https://mirrors.rit.edu/solus/images/${RELEASE}"

    HASH=$(wget -q -O- "${URL}/${ISO}.sha256sum" | cut_1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_sparkylinux() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local URL=""

    ISO="sparkylinux-${RELEASE}-x86_64-${EDITION}.iso"
    case ${EDITION} in
      minimalcli) URL="https://sourceforge.net/projects/sparkylinux/files/cli";;
      minimalgui) URL="https://sourceforge.net/projects/sparkylinux/files/base";;
      *) URL="https://sourceforge.net/projects/sparkylinux/files/${EDITION}";;
    esac
    HASH=$(wget -q -O- "${URL}/${ISO}.allsums.txt" | head -2 | grep 'iso' | cut_1)
    echo "${URL}/${ISO}" "${HASH}"
}

function get_spirallinux() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO="SpiralLinux_${EDITION}_12.231005_x86-64.iso"
    local URL="https://sourceforge.net/projects/spirallinux/files/12.231005"

    HASH=$(wget -q -O- 'https://sourceforge.net/projects/spirallinux/rss?path=/' | grep "${ISO}" | grep 'md5' | cut -d'<' -f3 | cut -d'>' -f2)
    echo "${URL}/${ISO}" "${HASH}"
}

function get_tails() {
    local ISO=""
    local JSON=""
    local HASH=""
    local URL=""

    JSON="$(wget -q -O- "https://tails.boum.org/install/v2/Tails/amd64/${RELEASE}/latest.json")"
    URL=$(echo "${JSON}" | jq -r '.installations[0]."installation-paths"[]|select(.type=="iso")|."target-files"[0].url')
    HASH=$(echo "${JSON}" | jq -r '.installations[0]."installation-paths"[]|select(.type=="iso")|."target-files"[0].sha256')
    echo "${URL} ${HASH}"
}

function get_tinycore() {
    local HASH=""
    local ISO="${EDITION}-${RELEASE}.iso"
    local URL=""

    if [ "${EDITION}" == "Core" ] || [ "${EDITION}" == "TinyCore" ] || [ "${EDITION}" == "CorePlus" ]; then
        URL="http://www.tinycorelinux.net/14.x/x86/release"
    elif [ "${EDITION}" == "CorePure64" ] || [ "${EDITION}" == "TinyCorePure64" ]; then
        URL="http://www.tinycorelinux.net/14.x/x86_64/release"
    fi

    HASH=$(wget -q -O- "${URL}/${ISO}.md5.txt" | cut_1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_trisquel() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local URL="https://mirrors.ocf.berkeley.edu/trisquel-images"

    case ${EDITION} in
      mate) ISO="trisquel_${RELEASE}_amd64.iso";;
      lxde) ISO="trisquel-mini_${RELEASE}_amd64.iso";;
      kde) ISO="triskel_${RELEASE}_amd64.iso";;
      sugar) ISO="trisquel-sugar_${RELEASE}_amd64.iso";;
    esac
    HASH=$(wget -q -O- "${URL}/${ISO}.sha1" | grep "${ISO}" | cut_1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_truenas-scale() {
    local HASH=""
    local ISO=""
    local URL=""
    local DLINFO="https://www.truenas.com/download-truenas-scale/"

    URL=$(wget -q ${DLINFO} -O- | grep -o "\"https://.*${RELEASE}.*\.iso\""|cut -d\" -f2)
    HASH=$(wget -q "${URL}.sha256" -O- | cut_1 )
    echo "${URL} ${HASH}"
}

function get_truenas-core() {
    local HASH=""
    local ISO=""
    local URL=""
    local DLINFO="https://www.truenas.com/download-truenas-core/"
    URL=$(wget -q ${DLINFO} -O- | grep -o "\"https://.*${RELEASE}.*\.iso\""|cut -d\" -f2)

    HASH=$(wget -q ${URL}.sha256 -O- | cut_1)
    echo "${URL} ${HASH}"
}

function get_ubuntu-server() {
    local HASH=""
    local ISO=""
    local URL=""

    [[ $RELEASE = daily ]] && RELEASE=daily-live

    if [[ "${RELEASE}" == "daily"* ]]; then
        URL="https://cdimage.ubuntu.com/${OS}/${RELEASE}/current"
    else
        URL="https://releases.ubuntu.com/${RELEASE}"
    fi

    if wget -q --spider "${URL}/SHA256SUMS"; then
        DATA=$(wget -qO- "${URL}/SHA256SUMS" | grep 'live-server' | grep amd64 | grep iso)
        ISO=$(cut -d'*' -f2 <<<${DATA})
        HASH=$(cut_1 <<<${DATA})
    else
        DATA=$(wget -qO- "${URL}/MD5SUMS" | grep 'live-server' | grep amd64 | grep iso)
        ISO=$(cut -d' ' -f3 <<<${DATA})
        HASH=$(cut_1 <<<${DATA})
    fi

    if [ -z $ISO ] || [ -z $HASH ]; then
        echo "$(pretty_name $OS) ${RELEASE} is currently unavailable. Please select other OS/Release combination"
        exit 1
    fi

    if [[ "${RELEASE}" == "daily"* ]] || [ "${RELEASE}" == "dvd" ]; then
        zsync_get "${URL}/${ISO}" "${VM_PATH}" "${OS}-devel.iso"
        make_vm_config "${OS}-devel.iso"
    else
        web_get "${URL}/${ISO}" "${VM_PATH}"
        check_hash "${ISO}" "${HASH}"
        make_vm_config "${ISO}"
    fi
}

function get_ubuntu() {
    local ISO=""
    local HASH=""
    local URL=""
    local DATA=""

    [[ $RELEASE = daily ]] && RELEASE=daily-live

    if [[ "${RELEASE}" == "daily"* ]] && [ "${OS}" == "ubuntustudio" ]; then
        # Ubuntu Studio daily-live images are in the dvd directory
        RELEASE="dvd"
    fi

    if [[ "${RELEASE}" == "eol-"* ]]; then
        URL="https://old-releases.ubuntu.com/releases/${RELEASE/eol-/}"
    elif [[ "${RELEASE}" == "jammy-daily" ]]; then
        if [[ "${OS}" == "ubuntustudio" ]]; then
            URL="https://cdimage.ubuntu.com/${OS}/jammy/dvd/current"
        else
            URL="https://cdimage.ubuntu.com/${OS}/jammy/daily-live/current"
        fi
        VM_PATH="${OS}-jammy-live"
    elif [[ "${RELEASE}" == "daily"* ]] || [ "${RELEASE}" == "dvd" ]; then
        URL="https://cdimage.ubuntu.com/${OS}/${RELEASE}/current"
        VM_PATH="${OS}-${RELEASE}"
    elif [ "${OS}" == "ubuntu" ]; then
        URL="https://releases.ubuntu.com/${RELEASE}"
    else
        URL="https://cdimage.ubuntu.com/${OS}/releases/${RELEASE}/release"
    fi

    if wget -q --spider "${URL}/SHA256SUMS"; then
        DATA=$(wget -qO- "${URL}/SHA256SUMS" | grep 'desktop\|dvd\|install' | grep amd64 | grep iso | grep -v "+mac")
        ISO=$(cut -d'*' -f2 <<<${DATA} | sed '1q;d')
        HASH=$(cut_1 <<<${DATA} | sed '1q;d')
    else
        DATA=$(wget -qO- "${URL}/MD5SUMS" | grep 'desktop\|dvd\|install' | grep amd64 | grep iso | grep -v "+mac")
        ISO=$(cut -d'*' -f2 <<<${DATA})
        HASH=$(cut_1 <<<${DATA})
    fi

    if [ -z $ISO ] || [ -z $HASH ]; then
        echo "$(pretty_name $OS) ${RELEASE} is currently unavailable. Please select other OS/Release combination"
        exit 1
    fi

    if [[ "${RELEASE}" == "daily"* ]] || [ "${RELEASE}" == "dvd" ]; then
        zsync_get "${URL}/${ISO}" "${VM_PATH}" "${OS}-devel.iso"
        make_vm_config "${OS}-devel.iso"
    elif [[ "${RELEASE}" == "jammy-daily" ]]; then
        zsync_get "${URL}/${ISO}" "${VM_PATH}" "${OS}-jammy-live.iso"
        make_vm_config "${OS}-jammy-live.iso"
    else
        web_get "${URL}/${ISO}" "${VM_PATH}"
        check_hash "${ISO}" "${HASH}"
        make_vm_config "${ISO}"
    fi
}

function get_vanillaos() {
    # maybe use github api and dynamism for R2.0 but for 22.10 just
    # hit their CDN
    #
    # https://cdn.vanillaos.org/assets/ISO/22.10-r8/VanillaOS-22.10-all.20230226.md5.txt
    # https://cdn.vanillaos.org/assets/ISO/22.10-r8/VanillaOS-22.10-all.20230226.sha256.txt
    local HASH=$(curl -s "https://cdn.vanillaos.org/assets/ISO/22.10-r8/VanillaOS-22.10-all.20230226.sha256.txt" | cut_1)
    local URL="https://cdn.vanillaos.org/assets/ISO/22.10-r8/VanillaOS-22.10-all.20230226.iso"

    echo "${URL} ${HASH}"
}

function get_void() {
    local DATE=""
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local URL="https://repo-default.voidlinux.org/live/current"

    DATE=$(wget -q -O- "${URL}/sha256sum.txt" | head -n1 | cut -d'.' -f1 | cut -d'-' -f4)
    case ${EDITION} in
      glibc) ISO="void-live-x86_64-${DATE}-base.iso";;
      musl) ISO="void-live-x86_64-musl-${DATE}-base.iso";;
      xfce-glibc) ISO="void-live-x86_64-${DATE}-xfce.iso";;
      xfce-musl) ISO="void-live-x86_64-musl-${DATE}-xfce.iso";;
    esac
    HASH="$(wget -q -O- "${URL}/sha256sum.txt" | grep "${ISO}" | cut -d' ' -f4)"
    echo "${URL}/${ISO} ${HASH}"
}

function get_vxlinux() {
    local HASH=""
    local ISO="vx-${RELEASE}.iso"
    local URL="https://github.com/VX-Linux/main/releases/download/${RELEASE}"

    HASH=$(wget -q -O- "${URL}/vx-${RELEASE}.md5" | cut  -d' ' -f1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_xerolinux() {
    local HASH=""
    local URL=""
    local ISO="xerolinux-2022.12-x86_64.iso"
    local URL="https://sourceforge.net/projects/xerolinux/files/Releases"

    HASH=$(wget -q -O- "${URL}/${ISO}.sha256" | cut_1)
    echo "${URL}/${ISO} ${HASH}"
}

function get_zorin() {
    local EDITION="${1:-}"
    local HASH=""
    local ISO=""
    local URL=""

    URL=$(curl -Lfs "https://zrn.co/${RELEASE}${EDITION}" -w %{url_effective} -o /this/is/a/nonexistent/directory/$RANDOM/$RANDOM)
    echo "${URL} ${HASH}"
}

function unattended_windows() {
    cat << 'EOF' > "${1}"
<?xml version="1.0" encoding="utf-8"?>
<unattend xmlns="urn:schemas-microsoft-com:unattend"
  xmlns:wcm="http://schemas.microsoft.com/WMIConfig/2002/State"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <!--
       For documentation on components:
       https://docs.microsoft.com/en-us/windows-hardware/customize/desktop/unattend/
  -->
  <settings pass="offlineServicing">
    <component name="Microsoft-Windows-LUA-Settings" processorArchitecture="amd64" publicKeyToken="31bf3856ad364e35" language="neutral" versionScope="nonSxS" xmlns:wcm="http://schemas.microsoft.com/WMIConfig/2002/State" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <EnableLUA>false</EnableLUA>
    </component>
    <component name="Microsoft-Windows-Shell-Setup" processorArchitecture="amd64" publicKeyToken="31bf3856ad364e35" language="neutral" versionScope="nonSxS" xmlns:wcm="http://schemas.microsoft.com/WMIConfig/2002/State" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <ComputerName>*</ComputerName>
    </component>
  </settings>

  <settings pass="generalize">
    <component name="Microsoft-Windows-PnPSysprep" processorArchitecture="amd64" publicKeyToken="31bf3856ad364e35" language="neutral" versionScope="nonSxS">
      <PersistAllDeviceInstalls>true</PersistAllDeviceInstalls>
    </component>
    <component name="Microsoft-Windows-Security-SPP" processorArchitecture="amd64" publicKeyToken="31bf3856ad364e35" language="neutral" versionScope="nonSxS" xmlns:wcm="http://schemas.microsoft.com/WMIConfig/2002/State" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <SkipRearm>1</SkipRearm>
    </component>
  </settings>

  <settings pass="specialize">
    <component name="Microsoft-Windows-Security-SPP-UX" processorArchitecture="amd64" publicKeyToken="31bf3856ad364e35" language="neutral" versionScope="nonSxS" xmlns:wcm="http://schemas.microsoft.com/WMIConfig/2002/State" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <SkipAutoActivation>true</SkipAutoActivation>
    </component>
    <component name="Microsoft-Windows-Shell-Setup" processorArchitecture="amd64" publicKeyToken="31bf3856ad364e35" language="neutral" versionScope="nonSxS" xmlns:wcm="http://schemas.microsoft.com/WMIConfig/2002/State" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <ComputerName>*</ComputerName>
      <OEMInformation>
        <Manufacturer>Quickemu Project</Manufacturer>
        <Model>Quickemu</Model>
        <SupportHours>24/7</SupportHours>
        <SupportPhone></SupportPhone>
        <SupportProvider>Quickemu Project</SupportProvider>
        <SupportURL>https://github.com/quickemu-project/quickemu/issues</SupportURL>
      </OEMInformation>
      <OEMName>Quickemu Project</OEMName>
      <ProductKey>W269N-WFGWX-YVC9B-4J6C9-T83GX</ProductKey>
    </component>
    <component name="Microsoft-Windows-SQMApi" processorArchitecture="amd64" publicKeyToken="31bf3856ad364e35" language="neutral" versionScope="nonSxS" xmlns:wcm="http://schemas.microsoft.com/WMIConfig/2002/State" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <CEIPEnabled>0</CEIPEnabled>
    </component>
  </settings>

  <settings pass="windowsPE">
    <component name="Microsoft-Windows-Setup" processorArchitecture="amd64" publicKeyToken="31bf3856ad364e35" language="neutral" versionScope="nonSxS" xmlns:wcm="http://schemas.microsoft.com/WMIConfig/2002/State" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <Diagnostics>
        <OptIn>false</OptIn>
      </Diagnostics>
      <DiskConfiguration>
        <Disk wcm:action="add">
          <DiskID>0</DiskID>
          <WillWipeDisk>true</WillWipeDisk>
          <CreatePartitions>
            <!-- Windows RE Tools partition -->
            <CreatePartition wcm:action="add">
              <Order>1</Order>
              <Type>Primary</Type>
              <Size>256</Size>
            </CreatePartition>
            <!-- System partition (ESP) -->
            <CreatePartition wcm:action="add">
              <Order>2</Order>
              <Type>EFI</Type>
              <Size>128</Size>
            </CreatePartition>
            <!-- Microsoft reserved partition (MSR) -->
            <CreatePartition wcm:action="add">
              <Order>3</Order>
              <Type>MSR</Type>
              <Size>128</Size>
            </CreatePartition>
            <!-- Windows partition -->
            <CreatePartition wcm:action="add">
              <Order>4</Order>
              <Type>Primary</Type>
              <Extend>true</Extend>
            </CreatePartition>
          </CreatePartitions>
          <ModifyPartitions>
            <!-- Windows RE Tools partition -->
            <ModifyPartition wcm:action="add">
              <Order>1</Order>
              <PartitionID>1</PartitionID>
              <Label>WINRE</Label>
              <Format>NTFS</Format>
              <TypeID>DE94BBA4-06D1-4D40-A16A-BFD50179D6AC</TypeID>
            </ModifyPartition>
            <!-- System partition (ESP) -->
            <ModifyPartition wcm:action="add">
              <Order>2</Order>
              <PartitionID>2</PartitionID>
              <Label>System</Label>
              <Format>FAT32</Format>
            </ModifyPartition>
            <!-- MSR partition does not need to be modified -->
            <ModifyPartition wcm:action="add">
              <Order>3</Order>
              <PartitionID>3</PartitionID>
            </ModifyPartition>
            <!-- Windows partition -->
              <ModifyPartition wcm:action="add">
              <Order>4</Order>
              <PartitionID>4</PartitionID>
              <Label>Windows</Label>
              <Letter>C</Letter>
              <Format>NTFS</Format>
            </ModifyPartition>
          </ModifyPartitions>
        </Disk>
      </DiskConfiguration>
      <DynamicUpdate>
        <Enable>true</Enable>
        <WillShowUI>Never</WillShowUI>
      </DynamicUpdate>
      <ImageInstall>
        <OSImage>
          <InstallTo>
            <DiskID>0</DiskID>
            <PartitionID>4</PartitionID>
          </InstallTo>
          <InstallToAvailablePartition>false</InstallToAvailablePartition>
        </OSImage>
      </ImageInstall>
      <RunSynchronous>
        <RunSynchronousCommand wcm:action="add">
          <Order>1</Order>
          <Path>reg add HKLM\System\Setup\LabConfig /v BypassCPUCheck /t REG_DWORD /d 0x00000001 /f</Path>
        </RunSynchronousCommand>
        <RunSynchronousCommand wcm:action="add">
          <Order>2</Order>
          <Path>reg add HKLM\System\Setup\LabConfig /v BypassRAMCheck /t REG_DWORD /d 0x00000001 /f</Path>
        </RunSynchronousCommand>
        <RunSynchronousCommand wcm:action="add">
          <Order>3</Order>
          <Path>reg add HKLM\System\Setup\LabConfig /v BypassSecureBootCheck /t REG_DWORD /d 0x00000001 /f</Path>
        </RunSynchronousCommand>
        <RunSynchronousCommand wcm:action="add">
          <Order>4</Order>
          <Path>reg add HKLM\System\Setup\LabConfig /v BypassTPMCheck /t REG_DWORD /d 0x00000001 /f</Path>
        </RunSynchronousCommand>
      </RunSynchronous>
      <UpgradeData>
        <Upgrade>false</Upgrade>
        <WillShowUI>Never</WillShowUI>
      </UpgradeData>
      <UserData>
        <AcceptEula>true</AcceptEula>
        <FullName>Quickemu</FullName>
        <Organization>Quickemu Project</Organization>
        <!-- https://docs.microsoft.com/en-us/windows-server/get-started/kms-client-activation-keys -->
        <ProductKey>
          <Key>W269N-WFGWX-YVC9B-4J6C9-T83GX</Key>
          <WillShowUI>Never</WillShowUI>
        </ProductKey>
      </UserData>
    </component>

    <component name="Microsoft-Windows-PnpCustomizationsWinPE" publicKeyToken="31bf3856ad364e35" language="neutral" versionScope="nonSxS" processorArchitecture="amd64" xmlns:wcm="http://schemas.microsoft.com/WMIConfig/2002/State" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <!--
           This makes the VirtIO drivers available to Windows, assuming that
           the VirtIO driver disk is available as drive E:
           https://github.com/virtio-win/virtio-win-pkg-scripts/blob/master/README.md
      -->
      <DriverPaths>
        <PathAndCredentials wcm:action="add" wcm:keyValue="1">
          <Path>E:\qemufwcfg\w10\amd64</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="2">
          <Path>E:\vioinput\w10\amd64</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="3">
          <Path>E:\vioscsi\w10\amd64</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="4">
          <Path>E:\viostor\w10\amd64</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="5">
          <Path>E:\vioserial\w10\amd64</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="6">
          <Path>E:\qxldod\w10\amd64</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="7">
          <Path>E:\amd64\w10</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="8">
          <Path>E:\viogpudo\w10\amd64</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="9">
          <Path>E:\viorng\w10\amd64</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="10">
          <Path>E:\NetKVM\w10\amd64</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="11">
          <Path>E:\viofs\w10\amd64</Path>
        </PathAndCredentials>
        <PathAndCredentials wcm:action="add" wcm:keyValue="12">
          <Path>E:\Balloon\w10\amd64</Path>
        </PathAndCredentials>
      </DriverPaths>
    </component>
  </settings>

  <settings pass="oobeSystem">
    <component name="Microsoft-Windows-Shell-Setup" processorArchitecture="amd64" publicKeyToken="31bf3856ad364e35" language="neutral" versionScope="nonSxS" xmlns:wcm="http://schemas.microsoft.com/WMIConfig/2002/State" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
      <AutoLogon>
        <Password>
          <Value>quickemu</Value>
          <PlainText>true</PlainText>
        </Password>
        <Enabled>true</Enabled>
        <Username>Quickemu</Username>
      </AutoLogon>
      <DisableAutoDaylightTimeSet>false</DisableAutoDaylightTimeSet>
      <OOBE>
        <HideEULAPage>true</HideEULAPage>
        <HideLocalAccountScreen>true</HideLocalAccountScreen>
        <HideOEMRegistrationScreen>true</HideOEMRegistrationScreen>
        <HideOnlineAccountScreens>true</HideOnlineAccountScreens>
        <HideWirelessSetupInOOBE>true</HideWirelessSetupInOOBE>
        <NetworkLocation>Home</NetworkLocation>
        <ProtectYourPC>3</ProtectYourPC>
        <SkipUserOOBE>true</SkipUserOOBE>
        <SkipMachineOOBE>true</SkipMachineOOBE>
        <VMModeOptimizations>
          <SkipWinREInitialization>true</SkipWinREInitialization>
        </VMModeOptimizations>
      </OOBE>
      <UserAccounts>
        <LocalAccounts>
          <LocalAccount wcm:action="add">
            <Password>
              <Value>quickemu</Value>
              <PlainText>true</PlainText>
            </Password>
            <Description>Quickemu</Description>
            <DisplayName>Quickemu</DisplayName>
            <Group>Administrators</Group>
            <Name>Quickemu</Name>
          </LocalAccount>
        </LocalAccounts>
      </UserAccounts>
      <RegisteredOrganization>Quickemu Project</RegisteredOrganization>
      <RegisteredOwner>Quickemu</RegisteredOwner>
      <FirstLogonCommands>
        <SynchronousCommand wcm:action="add">
          <CommandLine>msiexec /i E:\guest-agent\qemu-ga-x86_64.msi /quiet /passive /qn</CommandLine>
          <Description>Install Virtio Guest Agent</Description>
          <Order>1</Order>
        </SynchronousCommand>
        <SynchronousCommand wcm:action="add">
          <CommandLine>msiexec /i F:\spice-webdavd-x64-latest.msi /quiet /passive /qn</CommandLine>
          <Description>Install spice-webdavd file sharing agent</Description>
          <Order>2</Order>
        </SynchronousCommand>
        <SynchronousCommand wcm:action="add">
          <CommandLine>msiexec /i F:\UsbDk_1.0.22_x64.msi /quiet /passive /qn</CommandLine>
          <Description>Install usbdk USB sharing agent</Description>
          <Order>3</Order>
        </SynchronousCommand>
        <SynchronousCommand wcm:action="add">
          <CommandLine>msiexec /i F:\spice-vdagent-x64-0.10.0.msi /quiet /passive /qn</CommandLine>
          <Description>Install spice-vdagent SPICE agent</Description>
          <Order>4</Order>
        </SynchronousCommand>
        <SynchronousCommand wcm:action="add">
          <CommandLine>Cmd /c POWERCFG -H OFF</CommandLine>
          <Description>Disable Hibernation</Description>
          <Order>5</Order>
        </SynchronousCommand>
      </FirstLogonCommands>
    </component>
  </settings>
</unattend>
EOF
}

handle_curl_error() {
    local error_code="$1"
    local fatal_error_action=2

    case "$error_code" in
        6)
            echo "Failed to resolve Microsoft servers! Is there an Internet connection? Exiting..."
            return "$fatal_error_action"
            ;;
        7)
            echo "Failed to contact Microsoft servers! Is there an Internet connection or is the server down?"
            ;;
        23)
            echo "Failed at writing Windows media to disk! Out of disk space or permission error? Exiting..."
            return "$fatal_error_action"
            ;;
        26)
            echo "Ran out of memory during download! Exiting..."
            return "$fatal_error_action"
            ;;
        36)
            echo "Failed to continue earlier download!"
            ;;
        22)
            echo "Microsoft servers returned failing HTTP status code!"
            ;;
      # POSIX defines exit statuses 1-125 as usable by us
      # https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_08_02
      $((error_code <= 125)))
        # Must be some other server error (possibly with this specific request/file)
        # This is when accounting for all possible errors in the curl manual assuming a correctly formed curl command and HTTP(S) request, using only the curl features we're using, and a sane build
            echo "Server returned an error status!"
            ;;
      126 | 127)
        echo "Curl command not found! Please install curl and try again. Exiting..."
            return "$fatal_error_action"
            ;;
      # Exit statuses are undefined by POSIX beyond this point
        *)
            case "$(kill -l "$error_code")" in
                # Signals defined to exist by POSIX:
                # https://pubs.opengroup.org/onlinepubs/009695399/basedefs/signal.h.html
                INT)
                    echo "Curl was interrupted!"
                    ;;
                # There could be other signals but these are most common
                SEGV | ABRT)
                    echo "Curl crashed! Failed exploitation attempt? Please report any core dumps to curl developers. Exiting..."
                    return "$fatal_error_action"
                    ;;
                *)
                    echo "Curl terminated due to a fatal signal!"
                    ;;
         esac
    esac
    return 1
}

function download_windows-server() {
    # Download enterprise evaluation windows versions
    local windows_version="$1"
    local enterprise_type="$2"

    local url="https://www.microsoft.com/en-us/evalcenter/download-$windows_version"

    local iso_download_page_html="$(curl --silent --location --fail --proto =https --tlsv1.2 --http1.1 -- "$url")" || {
        handle_curl_error $?
        return $?
    }

    local CULTURE=""
    local COUNTRY=""
    local PRETTY_RELEASE=""

    case "$RELEASE" in
      "10-ltsc") PRETTY_RELEASE="10 LTSC";;
      "2012-r2") PRETTY_RELEASE="2012 R2";;
      *) PRETTY_RELEASE="$RELEASE";;
    esac

    case "$LANG" in
      "English (Great Britain)")
        CULTURE="en-gb"
        COUNTRY="GB";;
      "Chinese (Simplified)")
        CULTURE="zh-cn"
        COUNTRY="CN";;
      "Chinese (Traditional)")
        CULTURE="zh-tw"
        COUNTRY="TW";;
      "French")
        CULTURE="fr-fr"
        COUNTRY="FR";;
      "German")
        CULTURE="de-de"
        COUNTRY="DE";;
      "Italian")
        CULTURE="it-it"
        COUNTRY="IT";;
      "Japanese")
        CULTURE="ja-jp"
        COUNTRY="JP";;
      "Korean")
        CULTURE="ko-kr"
        COUNTRY="KR";;
      "Portuguese (Brazil)")
        CULTURE="pt-br"
        COUNTRY="BR";;
      "Spanish")
        CULTURE="es-es"
        COUNTRY="ES";;
      "Russian")
        CULTURE="ru-ru"
        COUNTRY="RU";;
      *)
        CULTURE="en-us"
        COUNTRY="US";;
    esac

    iso_download_links="$(echo "$iso_download_page_html" | grep -o "https://go.microsoft.com/fwlink/p/?LinkID=[0-9]\+&clcid=0x[0-9a-z]\+&culture=$CULTURE&country=$COUNTRY" | head -c 1024)"

    case "$enterprise_type" in
      # Select x64 LTSC download link
      "ltsc") iso_download_link=$(echo "$iso_download_links" | head -n 4 | tail -n 1);;
      *) iso_download_link="$iso_download_links";;
    esac

    iso_download_link="$(curl --silent --location --output /dev/null --silent --write-out "%{url_effective}" --head --fail --proto =https --tlsv1.2 --http1.1 -- "$iso_download_link")"

    if [ "${COUNTRY}" != "US" ]; then
        echo Downloading $(pretty_name "${OS}") ${PRETTY_RELEASE} in "${LANG}" from "$iso_download_link"
    else
        echo Downloading $(pretty_name "${OS}") ${PRETTY_RELEASE} from "$iso_download_link"
    fi

    FILE_NAME="${iso_download_link##*/}"
    web_get "$iso_download_link" "${VM_PATH}" "${FILE_NAME}"
    OS="windows-server"
}

function download_windows() {
    # Download newer consumer Windows versions from behind gated Microsoft API
    # This function aims to precisely emulate what Fido does down to the URL requests and HTTP headers (exceptions: updated user agent and referer adapts to Windows version instead of always being "windows11") but written in POSIX sh (with coreutils) and curl instead of PowerShell (also simplified to greatly reduce attack surface)
    # However, differences such as the order of HTTP headers and TLS stacks (could be used to do TLS fingerprinting) still exist
    #
    # Command translated: ./Fido -Win 10 -Lang English -Verbose
    # "English" = "English (United States)" (as opposed to the default "English (International)")
    # For testing Fido, replace all "https://" with "http://" and remove all instances of "-MaximumRedirection 0" (to allow redirection of HTTP traffic to HTTPS) so HTTP requests can easily be inspected in Wireshark
    # Fido (command-line only) works under PowerShell for Linux if that makes it easier for you
    # UPDATE: Fido v1.4.2+ no longer works without being edited on Linux due to these issues on the Fido GitHub repo (and possibly others after these): #56 and #58
    #
    # If this function in Mido fails to work for you then please test with the Fido script before creating an issue because we basically just copy what Fido does exactly:
    # https://github.com/pbatard/Fido

    # Either 8, 10, or 11
    local windows_version="$1"

    local url="https://www.microsoft.com/en-us/software-download/windows$windows_version"
    case "$windows_version" in
      8 | 10) url="${url}ISO";;
    esac

    local user_agent="Mozilla/5.0 (X11; Linux x86_64; rv:100.0) Gecko/20100101 Firefox/100.0"
    # uuidgen: For MacOS (installed by default) and other systems (e.g. with no /proc) that don't have a kernel interface for generating random UUIDs
    local session_id="$(cat /proc/sys/kernel/random/uuid 2> /dev/null || uuidgen --random)"

    # Get product edition ID for latest release of given Windows version
    # Product edition ID: This specifies both the Windows release (e.g. 22H2) and edition ("multi-edition" is default, either Home/Pro/Edu/etc., we select "Pro" in the answer files) in one number
    # This is the *only* request we make that Fido doesn't. Fido manually maintains a list of all the Windows release/edition product edition IDs in its script (see: $WindowsVersions array). This is helpful for downloading older releases (e.g. Windows 10 1909, 21H1, etc.) but we always want to get the newest release which is why we get this value dynamically
    # Also, keeping a "$WindowsVersions" array like Fido does would be way too much of a maintenance burden
    # Remove "Accept" header that curl sends by default
    local iso_download_page_html="$(curl --silent --user-agent "$user_agent" --header "Accept:" --fail --proto =https --tlsv1.2 --http1.1 -- "$url")" || {
        handle_curl_error $?
        return $?
    }

    # Limit untrusted size for input validation
    iso_download_page_html="$(echo "$iso_download_page_html" | head -c 102400)"
    # tr: Filter for only numerics to prevent HTTP parameter injection
    # head -c was recently added to POSIX: https://austingroupbugs.net/view.php?id=407
    local product_edition_id="$(echo "$iso_download_page_html" | grep -Eo '<option value="[0-9]+">Windows' | cut -d '"' -f 2 | head -n 1 | tr -cd '0-9' | head -c 16)"
    # echo " - Product edition ID: $product_edition_id"

    # Permit Session ID
    # "org_id" is always the same value
    curl --silent --output /dev/null --user-agent "$user_agent" --header "Accept:" --fail --proto =https --tlsv1.2 --http1.1 -- "https://vlscppe.microsoft.com/tags?org_id=y6jn8c31&session_id=$session_id" || {
        # This should only happen if there's been some change to how this API works (copy whatever fix Fido implements)
        handle_curl_error $?
        return $?
    }

    # Extract everything after the last slash
    local url_segment_parameter="${url##*/}"

    # Get language -> skuID association table
    # SKU ID: This specifies the language of the ISO. We always use "English (United States)", however, the SKU for this changes with each Windows release
    # We must make this request so our next one will be allowed
    # --data "" is required otherwise no "Content-Length" header will be sent causing HTTP response "411 Length Required"
    local language_skuid_table_html="$(curl --silent --request POST --user-agent "$user_agent" --data "" --header "Accept:" --fail --proto =https --tlsv1.2 --http1.1 -- "https://www.microsoft.com/en-US/api/controls/contentinclude/html?pageId=a8f8f489-4c7f-463a-9ca6-5cff94d8d041&host=www.microsoft.com&segments=software-download,$url_segment_parameter&query=&action=getskuinformationbyproductedition&sessionId=$session_id&productEditionId=$product_edition_id&sdVersion=2")" || {
        handle_curl_error $?
        return $?
    }

    # Limit untrusted size for input validation
    language_skuid_table_html="$(echo "$language_skuid_table_html" | head -c 10240)"

    # tr: Filter for only alphanumerics or "-" to prevent HTTP parameter injection
    local sku_id="$(echo "$language_skuid_table_html" | grep "${LANG}" | sed 's/&quot;//g' | cut -d ',' -f 1  | cut -d ':' -f 2 | tr -cd '[:alnum:]-' | head -c 16)"
    # echo " - SKU ID: $sku_id"

    # Get ISO download link
    # If any request is going to be blocked by Microsoft it's always this last one (the previous requests always seem to succeed)
    # --referer: Required by Microsoft servers to allow request
    local iso_download_link_html="$(curl --silent --request POST --user-agent "$user_agent" --data "" --referer "$url" --header "Accept:" --fail --proto =https --tlsv1.2 --http1.1 -- "https://www.microsoft.com/en-US/api/controls/contentinclude/html?pageId=6e2a1789-ef16-4f27-a296-74ef7ef5d96b&host=www.microsoft.com&segments=software-download,$url_segment_parameter&query=&action=GetProductDownloadLinksBySku&sessionId=$session_id&skuId=$sku_id&language=English&sdVersion=2")" || {
        # This should only happen if there's been some change to how this API works
        handle_curl_error $?
        return $?
    }

    local failed=0

    if [ "${LANG}" == "English (United States)" ]; then
        LANG="English"
    fi

    local HASH=$(echo "$iso_download_link_html" | sed 's/<tr><td>/\n<tr><td>/g' | grep "$LANG  64-bit" | grep -o -P '(?<=</td><td>).*(?=</td></tr>)')

    # Limit untrusted size for input validation
    iso_download_link_html="$(echo "$iso_download_link_html" | head -c 4096)"

    if ! [ "$iso_download_link_html" ]; then
        # This should only happen if there's been some change to how this API works
        echo " - Microsoft servers gave us an empty response to our request for an automated download."
        failed=1
    fi

    if echo "$iso_download_link_html" | grep -q "We are unable to complete your request at this time."; then
        if [ "${show_iso_url}" == 1 ] || [ "${test_iso_url}" == 1 ]; then
            echo " - Failed to get URL: Microsoft blocked the automated download request based on your IP address."
            exit 1
        fi
        echo " - Microsoft blocked the automated download request based on your IP address."
        failed=1
    fi

    if [ ${failed} -eq 1 ]; then
        echo " - Manually download the Windows ${windows_version} ISO using a web browser from: ${url}"
        echo " - Save the downloaded ISO to: $(realpath "${VM_PATH}")"
        echo " - Update the config file to reference the downloaded ISO: ./${VM_PATH}.conf"
        echo " - Continuing with the VM creation process..."
        return 1
    fi

    # Filter for 64-bit ISO download URL
    # sed: HTML decode "&" character
    # tr: Filter for only alphanumerics or punctuation
    local iso_download_link="$(echo "$iso_download_link_html" | grep -o "https://software.download.prss.microsoft.com.*IsoX64" | cut -d '"' -f 1 | sed 's/&amp;/\&/g' | tr -cd '[:alnum:][:punct:]' | head -c 512)"

    if ! [ "$iso_download_link" ]; then
        # This should only happen if there's been some change to the download endpoint web address
        echo " - Microsoft servers gave us no download link to our request for an automated download. Please manually download this ISO in a web browser: $url"
        return 1
    fi

    if [ "${show_iso_url}" == 1 ]; then
        echo -e "   Windows ${RELEASE} Download (valid for 24 hours):\n${iso_download_link}"
        exit 0
    elif [ "${test_iso_url}" == 1 ]; then
        wget --spider "${iso_download_link}"
        exit 0
    fi

    if [ "${LANG}" != "English International" ]; then
        echo Downloading Windows ${RELEASE} in "${LANG}" from "$iso_download_link"
    else
        echo Downloading Windows ${RELEASE} from "$iso_download_link"
    fi

    # Download ISO
    FILE_NAME="$(echo "$iso_download_link" | cut -d'?' -f1 | cut -d'/' -f5)"
    web_get "$iso_download_link" "${VM_PATH}" "${FILE_NAME}"
    # Only Windows 11 hashes can be found directly from Microsoft's page.
    if [ "${windows_version}" == 11 ]; then
        check_hash "${FILE_NAME}" "${HASH}"
    fi
}

function get_windows() {
    if [ "${RELEASE}" == "10-ltsc" ]; then
        download_windows-server windows-10-enterprise ltsc
    elif [ "${OS}" == "windows-server" ]; then
        download_windows-server windows-server-${RELEASE}
    else
        download_windows "${RELEASE}"
    fi

    if [ "${download_iso}" == 1 ]; then
        exit 0
    fi

    echo "Downloading VirtIO drivers..."
    web_get "https://fedorapeople.org/groups/virt/virtio-win/direct-downloads/stable-virtio/virtio-win.iso" "${VM_PATH}"

    rm -f "${VM_PATH}/unattended.iso"
    case ${RELEASE} in
      10|11)
        echo "Making unattended.iso"
        mkdir -p "${VM_PATH}/unattended" 2>/dev/null
        web_get https://www.spice-space.org/download/windows/spice-webdavd/spice-webdavd-x64-latest.msi "${VM_PATH}/unattended"
        web_get https://www.spice-space.org/download/windows/vdagent/vdagent-win-0.10.0/spice-vdagent-x64-0.10.0.msi "${VM_PATH}/unattended"
        web_get https://www.spice-space.org/download/windows/usbdk/UsbDk_1.0.22_x64.msi "${VM_PATH}/unattended"
        unattended_windows "${VM_PATH}/unattended/autounattend.xml"
            mkisofs -quiet -l -o "${VM_PATH}/unattended.iso" "${VM_PATH}/unattended/"
            ;;
    esac

    if [ -n "${FILE_NAME}" ]; then
        make_vm_config "${FILE_NAME}" "virtio-win.iso"
    else
        make_vm_config "windows-${RELEASE}.iso" "virtio-win.iso"
    fi
}

open_url() {
    local URL="${1}";
    xdg-open "$URL" || sensible-browser "$URL" || x-www-browser "$URL" || gnome-open "$URL";
}

create_vm() {
    # shellcheck disable=SC2206
    local URL_HASH=(${1// / })
    local URL="${URL_HASH[0]}"
    local HASH="${URL_HASH[1]}"
    local ISO="${URL##*/}"

    #echo "${URL}"
    #echo "${ISO}"
    #echo "${HASH}"
    web_get "${URL}" "${VM_PATH}"

    if [ -n "${HASH}" ]; then
      check_hash "${ISO}" "${HASH}"
    fi

    if [ ${OS} == "freedos" ] && [[ $ISO =~ ".zip" ]]; then
        unzip ${VM_PATH}/${ISO} -d ${VM_PATH}
        ISO=$(find "${VM_PATH}" -type f -iname '*.iso')
    fi

    if [[ ${OS} == "batocera" ]] && [[ ${ISO} =~ ".gz" ]]; then
        gzip -d "${VM_PATH}/${ISO}"
        ISO="${ISO/.gz/}"
    fi

    #  Could be other OS iso files compressed with bzip2 or gzip
    #  but for now we'll keep this to know cases
    if [[ ${OS} == "dragonflybsd" ]] && [[ ${ISO} =~ ".bz2" ]]; then
        bzip2 -d  "${VM_PATH}/${ISO}"
        ISO="${ISO/.bz2/}"
    fi

    if [ ${OS} == "reactos" ] && [[ $ISO =~ ".zip" ]]; then
        unzip ${VM_PATH}/${ISO} -d ${VM_PATH}
        ISO=$(find "${VM_PATH}" -type f \( -iname '*.iso' ! -iname '*.zip' \))
    fi

    make_vm_config "${ISO}"
}

trap cleanup EXIT

if ((BASH_VERSINFO[0] < 4)); then
    echo "Sorry, you need bash 4.0 or newer to run this script."
    exit 1
fi

LANGS=()

os_error() {
    echo "ERROR! You must specify an operating system."
    echo "- Supported Operating Systems:"
    os_support | fold -s -w $(tput cols)
    echo -e "\nTo see all possible arguments, use:\n   quickget -h  or  quickget --help"
    exit 1
}

os_supported() {
    if [[ ! " $(os_support) " =~ " ${OS} " ]]; then
            echo -e "ERROR! ${OS} is not a supported OS.\n"
    os_support | fold -s -w $(tput cols)
    exit 1
    fi
}

function help_message() {
    printf '                             _              _
           __ _ _   _ _  ___║ ║ ____ _  ___║ ║_
          / _` ║ ║ ║ ║ ║/ __║ ║/ / _` ║/ _ \ __║
         ( (_║ ║ ║_║ ║ ║ (__║   < (_║ ║  __/ ║_      MIT
          \__, ║\__,_║_║\___║_║\ \__, ║\___║\__║   license
             ║_║  version: %s ║___/
 QEMU %s --------------------------------------------------
       > Quickly create and run optimised Windows, <
       > macOS and Linux desktop virtual machines. <
   homepage   -    Not Yet
  repository  - https://github.com/quickemu-project/quickemu
 official GUI - https://github.com/quickemu-project/quickgui
  by Wimpy https://github.com/flexiondotorg and contributors
 Discord - https://discord.gg/wimpy-s-world-712850672223125565
--------------------------------------------------------------

Basic Usage:
 quickget <os> <release> [edition]
 quickget alpine latest

Advanced Usage:
 quickget <arg> [path] <os> [re] [ed]
 quickget -d peppermint latest devuan-xfce

Posible arguments:
 --help             (-h)                : Show this help message and exit
 --os-info          (-i) <os>           : Show info about OS
 --os-homepage      (-o) <os>           : Open OS homepage in default browser
 --iso-download     (-d) <os> <re> [ed] : Just download ISO
 --list-supported  (-ls)                : List all supported OS,releases,editions
 --list-isos       (-ls)                : List all supported ISOs
 --test-isos       (-ts)                : Test if ISOs are available
 --version          (-v)                : Show version and exit

supported Operating Systems:\n' "$(quickemu --version)" "$(qemu-x86_64 -version | head -1 | cut -d' ' -f3)"
    os_support | fold -s -w $(tput cols)
    exit 0
}

function show_os_info() {
    local OS=""

    if [ -z "${1}" ]; then
        os_error
        exit 1
    fi

    OS="${1}"
    os_supported
    if command -v neofetch > /dev/null; then
        neofetch -l --ascii_distro ${OS}
    fi
    echo ${OS}
    echo -n 'Pretty name: '
    pretty_name ${OS}
    echo -n 'Based of: '
    os_basedof ${OS}

    if [ -z "$(os_credentials ${OS})" ]; then
        echo 'Credentials: Unknown'
    else
        echo -n 'Credentials: '
        os_credentials ${OS}
    fi

    echo -n 'Homepage: '
    os_homepage ${OS}
    echo -n 'Info: '
    os_about ${OS}

    if [[ ! $(type -t "editions_${OS}") == function ]]; then
        echo -n 'Releases: '
        "releases_${OS}"
    else
        echo -n 'Releases: '
        "releases_${OS}"
        echo -n 'Editions: '
        "editions_${OS}"
    fi

    exit 0
}

case "${1}" in
  '-h'|'--help')
    help_message
    ;;
  'list'|'list_csv')
    list_csv
    ;;
  'list_json')
    list_json
    ;;
  '-ls'|'--list-supported')
    list_supported  
    ;;
  '-li|--list-isos')
    list_isos
    ;;  
  '-ti|--test-isos')
    test_isos
    ;;
  '-d'|'--iso-download')
    download_iso=1
    if [ -n "$4" ]; then
        set -- "$2" "$3" "$4"
    elif [ -n "$3" ]; then
        set -- "$2" "$3"
    else
        set -- "$2"
    fi
    ;;
  '-i'|'--os-info')
    echo "$(show_os_info "${2}")" | fold -s -w $(tput cols)
    exit 0
    ;;
  '-o'|'--os-homepage')
    OS="${2}"
    if [ -z "$(os_homepage ${OS})" ]; then
        os_error
    else
        open_url "$(os_homepage ${OS})"
        exit 0
    fi
    ;;
  '-v'|'--version')
    WHERE=$(dirname "${BASH_SOURCE[0]}")
    "${WHERE}/quickemu" --version
    exit 0
    ;;
 esac

if [ -n "${1}" ]; then
    OS="${1,,}"
    case "${OS}" in
    '-i'|'--os-info'|'-o'|'--os-homepage'|'-d'|'--iso-download')
        os_error
        ;;
    esac
else
    os_error
fi

os_supported

if [ -n "${2}" ]; then
    RELEASE="${2,,}"
    VM_PATH="${OS}-${RELEASE}"

    # If the OS has an editions_() function, use it.
    if [[ $(type -t "editions_${OS}") == function ]]; then
        validate_release "releases_${OS}"
        EDITIONS=($(editions_${OS}))
        EDITION=${EDITIONS[0]}
        if [ -n "${3}" ]; then
            EDITION="${3}"
                if [[ ! " ${EDITIONS[*]} " =~ " ${EDITION} " ]]; then
        echo -e "ERROR! ${EDITION} is not a supported $(pretty_name "${OS}") edition."
        echo -n ' - Editions: '
        for EDITION in "${EDITIONS[@]}"; do
            echo -n "${EDITION} "
        done
        echo ''
        exit 1
        fi
    else
        echo -en "ERROR! You must specify an edition.\n - Editions: "
        #TODO ERROR here
        "editions_${OS}"
        exit 1
    fi

    # Handle odd missing Fedora combinations
    if [[ $OS == fedora ]] ; then
        if [[ ${RELEASE} = "33" && ${EDITION} = "i3" ]] || [[ ${RELEASE} = "34" && ${EDITION} = "Cinnamon" ]] || [[ "${RELEASE}" < "39" && ${EDITION} = "Onyx" ]]; then
            echo "ERROR! Unsupported combination"
            echo "       Fedora ${RELEASE} ${EDITION} is not available, please choose another Release or Edition"
            exit 1;
        fi
    fi

    # Handle missing Manjaro Sway minimal
    if [[ $OS == manjaro ]] ; then
        if [[ ${RELEASE} == "sway" && ${EDITION} == "minimal" ]] ; then
            echo "ERROR! Unsupported combination"
            echo "       Manjaro Sway does not have a minimal edition"
            exit 1;
        fi
    fi

    VM_PATH="${OS}-${RELEASE}-${EDITION}"
    create_vm "$("get_${OS}" "${EDITION}")"
    if [ "${OS}" == "macos" ]; then
        # macOS doesn't use create_vm()
        validate_release releases_macos
        get_macos
    elif [[ "${OS}" == *"ubuntu-server"* ]]; then
        # (Comes before regular Ubuntu, or the code tries to download the desktop) #
        # Ubuntu doesn't use create_vm()
        validate_release releases_ubuntu-server
        get_ubuntu-server
    elif [[ "${OS}" == *"ubuntu"* ]]; then
        # Ubuntu doesn't use create_vm()
        validate_release releases_ubuntu
        get_ubuntu
    elif [[ "${OS}" == *"deepin"* ]]; then
        # deepin doesn't use create_vm()
        validate_release releases_deepin
        get_deepin
    elif [[ "${OS}" == "windows"* ]]; then
        LANG="English International"
        "languages_${OS}"
        if [ -n "${3}" ]; then
            LANG="${3}"
            if [[ ! ${LANGS[*]} =~ "${LANG}" ]]; then
                echo -e "ERROR! ${LANG} is not a supported $(pretty_name "${OS}") language:\n"
                for LANG in "${LANGS[@]}"; do
                    echo -n "${LANG} "
                done
                exit 1
            fi
            VM_PATH="$(echo "${OS}-${RELEASE}-${LANG// /-}" | tr -d '()')"
        fi
        validate_release "releases_${OS}"
        get_windows
    else
        validate_release "releases_${OS}"
        create_vm "$("get_${OS}")"
    fi

elif [ $(releases_${OS} | wc -w) -eq 1 ] && [[ ! $(type -t "editions_${OS}") == function ]]; then
    RELEASE=$(releases_${OS})
    VM_PATH="${OS}"
    create_vm "$("get_${OS}")"
else
    echo "ERROR! You must specify a release."
    case ${OS} in
      *ubuntu-server*)
        echo -n " - Releases: "
        releases_ubuntu-server | sed -Ee 's/eol-\S+//g' # hide eol releases
        ;;
      *ubuntu*)
        echo -n " - Releases: "
        releases_ubuntu | sed -Ee 's/eol-\S+//g' # hide eol releases
        ;;
      *windows*)
        echo -n " - Releases: "
        "releases_${OS}"
        echo -n " - Languages: "
        "languages_${OS}" && echo "${LANGS[@]}"
        ;;
      *)
      echo -n " - Releases: "
      "releases_${OS}" | fold -s -w $(tput cols)
        ;;
    esac
    if [[ $(type -t "editions_${OS}") == function ]]; then
        echo -n " - Editions: "
        "editions_${OS}"
    fi
    exit 1
fi

# vim:tabstop=4:shiftwidth=4:expandtab