#!/usr/bin/env bash

# Amelia installer for Archlinux
# Version: 1.5.2
# Source: https://gitlab.com/prism7/archery
# shellcheck disable=SC2154

        set -euo pipefail

# TUI FUNCTIONS
vm()            { inf "${yellowl}Virtual Machine ${nc}detected\n";}
ok()            { sleep 0.2; NC "\n\n==> [${green}${prompt} OK${nc}]";}
NC()            { echo -e "${nc} $1${nc}"       ;}
y_n()           { err "Please type 'y' or 'n' to continue.."; reload;}
RED()           { echo -e "${red} $1${nc}"      ;}
skip()          { sleep 0.2; YELLOWL "\n\n    -->  Skipping..";}
BLUE()          { echo -e "${blue} $1${nc}"     ;}
CYAN()          { echo -e "${cyan} $1${nc}"     ;}
GREEN()         { echo -e "${green} $1${nc}"    ;}
REDBG()         { echo -e "${redbg} $1${nc}"    ;}
reload()        { sleep 0.2; NC "\n\n  --> [${green}Reloading${nc}]";}
choice()        { err "Please make a choice to continue.."; reload;}
yes_no()        { err "Please type 'yes' or 'no' to continue.."; reload;}
YELLOW()        { echo -e "${yellow} $1${nc}"   ;}
BLUEBG()        { echo -e "${bluebg} $1${nc}"   ;}
CYANBG()        { echo -e "${cyanbg} $1${nc}"   ;}
WHITEB()        { echo -e "${bwhite} $1${nc}"   ;}
invalid()       { err "Invalid Response"; reload;}
err_try()       { err "Errors occured. Please try again.."; reload;}
YELLOWL()       { echo -e "${yellowl} $1${nc}"  ;}
GREENBG()       { echo -e "${greenbg} $1${nc}"  ;}
MAGENTA()       { echo -e "${magenta} $1${nc}"  ;}
stage_ok()      { sleep 0.2; GREEN "\n        >>  ${nc}${stage_prompt} ${green}OK"; sleep 0.3;}
keypress()      { NC "\n\n\n                                      ${bwhite}Press any key to continue\n\n"; read -r -s -n 1;}
err_abort()     { err "Errors occured. Aborting.."; failure;}
do_umount()     { unmount; reload;}
MAGENTABG()     { echo -e "${magentabg} $1${nc}";}
umount_manual() { unmount; inf "Switching to ${yellowl}Manual Mode";}
err() {
        local msg="$1"
        local middle="${red}###  ${nc}${msg}${red}  ###${nc}"
        local clean_middle
        clean_middle="$(echo -e "$middle" | sed 's/\x1b\[[0-9;]*m//g')"
        local visible_length="${#clean_middle}"
        local dash_line
        dash_line="$(printf '%*s' "$visible_length" '' | tr ' ' '-')"
        local top_bottom="${red}${dash_line}${nc}"
        sleep 0.2
        printf "\n"
        printf "%b\n" "        $top_bottom"
        printf "%b\n" "        $middle"
        printf "%b\n" "        $top_bottom";}
msg() {
        local msg="$1"
        local middle="${green}###  ${nc}${msg}${green}  ###"
        local clean_middle
        clean_middle="$(echo -e "$middle" | sed 's/\x1b\[[0-9;]*m//g')"
        local visible_length="${#clean_middle}"
        local dash_line
        dash_line="$(printf '%*s' "$visible_length" '' | tr ' ' '-')"
        local top_bottom="${green}${dash_line}${nc}"
        sleep 0.2
        printf "\n"
        printf "%b\n" "        $top_bottom"
        printf "%b\n" "        $middle"
        printf "%b\n" "        $top_bottom"
}
inf() {
        local msg="$1"
        local string="${cyan}>>  ${nc}${msg}${nc}"
        sleep 0.2
        printf "\n\n"
        printf "%b\n" "                $string"
}
ask() {
        local msg="$1"
        local string="${yellow}>  ${msg}${yellow}:"
        printf "\n\n"
        printf "%b\n" "        $string"
}
get() {
        local msg="$1"
        local string="${blue}${msg}${blue}:${nc}"
        printf "\n\n"
        printf "%b\n" "$string"
        printf "\n"
}
ack() {
        local msg="$1"
        local string="${yellow}###  ${msg}"
        sleep 0.2
        printf "\n\n"
        printf "%b\n" "        $string"
}
reboot() {
    if [[ "${encrypt}" == "yes" ]]; then
        if [[ "${luks_encrypt}" == "ok" ]]; then
            inf "The system will now ${yellowl}reboot ${nc}for all changes to take effect\n\n"
            sleep 3
            systemctl reboot
        else
            inf "A reboot is ${yellowl}mandatory ${nc}after performing LUKS encryption\n\n"
            sleep 3
            systemctl reboot
        fi
    fi
}
title() {
        local core="$*"
        local left_sym="###"
        local right_sym="###"
        local bracket_open="[ "
        local bracket_close=" ]"
        local left_sym_len=${#left_sym}
        local right_sym_len=${#right_sym}
        local bracket_open_len=${#bracket_open}
        local bracket_close_len=${#bracket_close}
        local magenta_len=${#magenta}
        local bwhite_len=${#bwhite}
        local nc_len=${#nc}
        local decor_len=$(( left_sym_len + right_sym_len + bracket_open_len + bracket_close_len + magenta_len + nc_len + bwhite_len * 2 ))
        local total_len=126
        local core_len=${#core}
        local available=$(( total_len - decor_len - core_len ))
        local half=$(( available / 2 ))
        local core_padding=""
    if (( available % 2 != 0 )); then
        if [[ "$core" == *" "* ]]; then
            local mid_index=$(( core_len / 2 ))
            while [[ "${core:$mid_index:1}" != " " && $mid_index -gt 0 ]]; do
                (( mid_index-- ))
            done
            core="${core:0:$mid_index} ${core:$mid_index}"
        else
            core_padding=" "
        fi
    fi
        dashes_left=$(printf '%*s' "$half" '' | tr ' ' '-')
        dashes_right=$(printf '%*s' "$half" '' | tr ' ' '-')
        local core_adjusted="${magenta}${bracket_open}${bwhite}${core}${magenta}${bracket_close}${core_padding}"
        local output="${magenta}${left_sym}${nc}${dashes_left}${core_adjusted}${nc}${dashes_right}${magenta}${right_sym}"
        sleep 0.2
        NC "\n\n\n$output\n"
}
unmount() {
        inf "${yellowl}Unmount ${nc}and Retry"
        reload
        title "Unmount Filesystems"
    if umount -R /mnt > "${void}" 2>&1 ; then
        msg "Unmount OK"
    else
        err "Unmounting Failed"
        failure
    fi
}
stage_fail() {
        sleep 0.2
        RED "\n\n        >>  ${bwhite}${stage_prompt} ${nc}has ${red}FAILED${cyan}\n\n                >>  ${nc}Check ${yellowl}Amelia.log ${nc}for errors\n\n"
        failure
}
completion_err() {
        printf "\n\n"
    if [[ -e /usr/bin/pv ]]; then
        inf "Please complete ${yellowl}'${stage_prompt}' ${nc}to continue\n" | pv -qL 70
    else
        inf "Please complete ${yellowl}'${stage_prompt}' ${nc}to continue\n"
    fi
}
amd() {
        printf "\n\n"
        sleep 0.2
        REDBG   "       ------------------------------- "
        REDBG   "       ###  AMD Graphics detected  ### "
        REDBG   "       ------------------------------- "
        NC "\n\n\n          *  ${gfxcard}\n\n"
}
intel() {
        printf "\n\n"
        sleep 0.2
        BLUEBG  "       --------------------------------- "
        BLUEBG  "       ###  INTEL Graphics detected  ### "
        BLUEBG  "       --------------------------------- "
        NC "\n\n\n          *  ${gfxcard}\n\n"
}
nvidia() {
        printf "\n\n"
        sleep 0.2
        GREENBG "       ---------------------------------- "
        GREENBG "       ###  NVIDIA Graphics detected  ### "
        GREENBG "       ---------------------------------- "
        NC "\n\n\n          *  ${gfxcard}\n\n"
}
delete() {
        sleep 0.2
        printf "\n\n"
        REDBG   "       ------------------------------------------------------------ "
        REDBG   "       [!] WARNING: All data on selected disk will be destroyed [!] "
        REDBG   "       ------------------------------------------------------------ "
}
amelia() {
        sleep 0.2
        CYANBG          "************************************************************************************************* "
        CYANBG          "                                                                                                  "
        CYANBG          "                                 ###     Amelia Installer     ###                                 "
        CYANBG          "                                                                                                  "
        CYANBG          "************************************************************************************************* "
}
banner() {
        sleep 0.2
        echo
        BLUEBG          "************************************************************************************************* "
        BLUEBG          "                                                                                                  "
        BLUEBG          "                              ###     Archlinux Installation     ###                              "
        BLUEBG          "                                                                                                  "
        BLUEBG          "************************************************************************************************* "
        printf "\n\n"
}
installing() {
        sleep 0.2
        printf "\n\n\n"
        MAGENTABG       "------------------------------------------------------------------------------------------------- "
        MAGENTABG       "                                ###     Installing System     ###                                 "
        MAGENTABG       "------------------------------------------------------------------------------------------------- "
        printf "\n"
}
cnfg() {
        sleep 0.2
        printf "\n\n\n"
        MAGENTABG       "------------------------------------------------------------------------------------------------- "
        MAGENTABG       "                               ###     Configuring  System     ###                                "
        MAGENTABG       "------------------------------------------------------------------------------------------------- "
        NC "\n\n\n                                        ... Please Wait ...\n\n\n"
}
completion() {
        sleep 0.2
        printf "\n\n\n\n\n"
        GREENBG         "************************************************************************************************* "
        GREENBG         "                                                                                                  "
        GREENBG         "                              ###     Installation Completed     ###                              "
        GREENBG         "                                                                                                  "
        GREENBG         "************************************************************************************************* "
        printf "\n\n\n"
}
failure() {
        sleep 0.2
        printf "\n\n\n"
        REDBG           "************************************************************************************************* "
        REDBG           "                                                                                                  "
        REDBG           "                               ###     Installation Aborted     ###                               "
        REDBG           "                                                                                                  "
        REDBG           "************************************************************************************************* "
        printf "\n\n\n"
        umount -R /mnt > "${void}" 2>&1
    if [[ "${luks_root}" == "ok" || "${luks_swap}" == "ok" || "${luks_home}" == "ok" ]] && [[ "${installation}" != "ok" ]]; then
        reboot
    fi
        exit
}
filesystem_overview() {
        sleep 0.2
        CYAN "\n\n###${nc}---------------------------------------------${cyan}[ ${bwhite}FILESYSTEM OVERVIEW ${nc}${cyan}]${nc}---------------------------------------------${cyan}###\n\n"
        lsblk -f | GREP_COLORS='mt=01;36' grep -E --color=always 'vfat|$' | GREP_COLORS='mt=01;32' grep -E --color=always 'ext4|$' | GREP_COLORS='mt=01;35' grep -E --color=always 'btrfs|$' | GREP_COLORS='mt=01;31' grep -E --color=always 'ntfs|$' | GREP_COLORS='mt=01;33' grep -E --color=always 'swap|$'
        CYAN "\n\n###${nc}-----------------------------------------------------------------------------------------------------------------${cyan}###\n"
        sleep 0.2
}
disk_overview() {
        sleep 0.2
        CYAN "\n\n\n###${nc}------------------------------------------------${cyan}[ ${bwhite}DISK OVERVIEW ${nc}${cyan}]${nc}------------------------------------------------${cyan}###\n\n"
        fdisk -l "${instl_drive}" | grep -E --color=no 'Dev|dev' |GREP_COLORS='mt=01;36' grep -E --color=always 'EFI System|$' | GREP_COLORS='mt=01;32' grep -E --color=always 'Linux root|$' | GREP_COLORS='mt=01;35' grep -E --color=always 'Linux home|$' | GREP_COLORS='mt=01;33' grep -E --color=always 'Linux swap|$' | GREP_COLORS='mt=01;31' grep -E --color=always 'Linux extended boot|$'
        CYAN "\n\n###${nc}-----------------------------------------------------------------------------------------------------------------${cyan}###"
}
multi_info() {
        sleep 0.2
        CYAN "\n        >>  ${nc}Multiple ${color}${type} ${nc}Partitions have been detected"
        disk_overview
        NC "\n     ${color}${type} Partitions:${nc}\n\n     ${dashline}\n${multi_type}\n     ${dashline}\n"
        YELLOW "\n        ###  Only the ${nc}1st ${type} ${yellow}partition on a selected disk can be ${nc}auto-assigned ${yellow}as a valid partition${cyan}\n\n\n        >>  ${nc}Partition ${yellowl}${type_comply} ${nc}is auto-assigned as such and will be ${action}\n"
}
# SYSTEM FUNCTIONS
mode_check() {
    if [[ "${run_as}" == "root" ]]; then
        usermode=">   ${nc}Running in ${red}ROOT ${nc}mode   ${yellowl}<"
    else
        usermode=">   ${nc}Running in ${blue}DEMO ${nc}mode   ${yellowl}<"
    fi
        sleep 0.2
        YELLOWL "\n\n\n\n                                    ${usermode}\n\n\n\n\n\n"
}
check_fonts() {
    if [[ -f /usr/share/kbd/consolefonts/ter-v18b.psf.gz && -f /usr/share/kbd/consolefonts/ter-v32b.psf.gz ]]; then
        if [[ "${tty}" == *"tty"* && "${run_as}" == "root" ]]; then
            until slct_font; do : ; done
        else
            if [[ -e /usr/bin/pv ]]; then
                MAGENTABG "      'Terminus Font' detected       ==>       Log in as 'root' in a tty & re-run to enable       " | pv -qL 70
            else
                MAGENTABG "      'Terminus Font' detected       ==>       Log in as 'root' in a tty & re-run to enable       "
            fi
            echo
        fi
    fi
}
slct_font() {
        local prompt="Font Selection"
        title "${prompt}"
        ask "Select a Font"
        NC "\n\n            [1]  Terminus Font\n\n            [2]  HiDPI Terminus Font"
        get "Enter a number"
        read -r -p "==> " fontselect
    case "${fontselect}" in
        1)
            setfont ter-v18b ;;
        2)
            setfont ter-v32b ;;
        *)
            invalid
            return 1 ;;
    esac
        ok
        sleep 0.5
        clear
}
uefi_check() {
        bitness="$(cat /sys/firmware/efi/fw_platform_size)"
        local prompt="UEFI ${bitness}-bit Mode"
        title "UEFI Mode Verification"
    if [[ "${bitness}" == "64" ]]; then
        uefimode="x86_64-efi"
        efiname="BOOTX64"
        ok
    elif [[ "${bitness}" == "32" ]]; then
        uefimode="i386-efi"
        efiname="BOOTIA32"
        ok
    else
        err "Not in UEFI Mode"
        failure
    fi
}
connection_check() {
        local prompt="Internet Connection Check"
        title "${prompt}"
    if ping -c 3 www.google.com > "${void}" 2>&1; then
        ok
    else
        printf "\n\n"
        err "An internet connection could not be established"
        printf "\n\n"
        failure
    fi
}
upd_clock() {
        local prompt="System Clock Update"
        title "${prompt}"
        printf "\n\n"
        sleep 0.2
        timedatectl
        [[ "${run_as}" == "root" ]] && timedatectl set-ntp true
        ok
}
dtct_hyper() {
        hypervisor="$(systemd-detect-virt)"
    case "${hypervisor}" in
        kvm)
            vmpkgs="spice spice-vdagent spice-protocol spice-gtk qemu-guest-agent swtpm" ;;
        vmware)
            vmpkgs="open-vm-tools"
            vm_services="vmtoolsd vmware-vmblock-fuse" ;;
        oracle)
            vmpkgs="virtualbox-guest-utils"
            vm_services="vboxservice" ;;
        microsoft)
            vmpkgs="hyperv"
            vm_services="hv_kvp_daemon hv_vss_daemon" ;;
    esac
}
machine_dtct() {
        until dtct_hyper; do : ; done
        local prompt="Machine Detection"
        title "${prompt}"
        CPU="$(grep -E 'vendor_id' /proc/cpuinfo)"
        hardw_model="$(hostnamectl | grep -E "Hardware Model:" | sed 's|  Hardware Model: ||')"
        hardw_model_vend="$(hostnamectl | grep -E "Hardware Model:" | sed 's|  Hardware Model: ||' | awk "{print \$1}")"
        hardw_vendor="$(hostnamectl | grep -E "Hardware Vendor" | awk "{print \$3}")"
        machine="$(hostnamectl | grep -Em 1 "Chassis" | awk "{print \$2}")"
    if [[ "${hypervisor}" != "none" ]]; then
        vm
        vendor="Virtual Machine"
    fi
    if [[ "${CPU}" == *"GenuineIntel"* ]]; then
        microcode="intel-ucode"
        nrg_plc="x86_energy_perf_policy"
        cpu_name="Intel"
    elif [[ "${CPU}" == *"AuthenticAMD"* ]]; then
        microcode="amd-ucode"
        cpu_name="AMD"
    fi
    if [[ "${hardw_model_vend}" == "${hardw_vendor}" ]]; then
        inf "This system is a(n): ${yellowl}${hardw_model} ${bwhite}${machine}"
    else
        inf "This system is a(n): ${yellowl}${hardw_model} ${hardw_vendor} ${bwhite}${machine}"
    fi
        ack "The ${cpu_name} cpu microcode will be installed"
        ok
}
main_menu() {
        title "Main Menu"
        ask "Make a selection"
    if [[ -e /usr/bin/pv ]]; then
        inf "Select ${bwhite}[4] ${nc}for ${yellowl}Auto-Navigation ${nc}Mode" | pv -qL 70
    else
        inf "Select ${bwhite}[4] ${nc}for ${yellowl}Auto-Navigation ${nc}Mode"
    fi
        NC "\n\n            [1]  Personalization\n\n            [2]  System Configuration\n\n            [3]  Disk Management\n\n            [4]  Start Installation"
        get "Enter a number"
        read -r -p "==> " menu
    case "${menu}" in
        1)
            until persnl_submn; do : ; done ;;
        2)
            until sys_submn; do : ; done ;;
        3)
            until dsks_submn; do : ; done ;;
        4)
            instl ;;
       "")
            err "Please select a Submenu"
            reload
            return 1 ;;
        *)
            invalid
            return 1 ;;
    esac
}
persnl_submn() {
        title "Personalization"
        ask "Select a Submenu"
        NC "\n\n            [1]  Locale & Keyboard Layout Setup\n\n            [2]  User, Root User & Hostname Setup\n\n            [3]  Shell Selection\n\n            [ ]  Return to Main Menu"
        get "Enter a number"
        read -r -p "==> " persmenu
    case "${persmenu}" in
        1)
            until slct_locale; do : ; done
            until slct_kbd; do : ; done
            return 1 ;;
        2)
            until user_setup; do : ; done
            until rootuser_setup; do : ; done
            until slct_hostname; do : ; done
            return 1 ;;
        3)
            until slct_shell; do : ; done
            return 1 ;;
       "")
            until main_menu; do : ; done ;;
        *)
            invalid
            return 1 ;;
    esac
}
slct_locale() {
        local prompt="Locale Selection"
        title "${prompt}"
        ask "Select your Locale"
        ack "[Enter ${nc}'l'${yellow} to list locales, then ${nc}'enter'${yellow} to search or ${nc}'q'${yellow} to quit]"
        inf "Exclude ${yellowl}'.UTF_8' ${nc}suffix"
        get "Enter your Locale ${bwhite}(empty for 'en_US')"
        read -r -p "==> " LOCALESET
    if [[ -z "${LOCALESET}" ]]; then
        SETLOCALE="en_US.UTF-8"
        ack "en_US.UTF-8 Locale has been selected"
    elif [[ "${LOCALESET}" == "l" ]]; then
        grep -E 'UTF-8' /usr/share/i18n/SUPPORTED | less
        return 1
    elif ! grep -qF "${LOCALESET} " /usr/share/i18n/SUPPORTED; then
        invalid
        return 1
    else
        SETLOCALE="${LOCALESET}.UTF-8"
        ack "${SETLOCALE} Locale has been selected"
    fi
        ok
        lcl_slct="yes"
}
slct_kbd() {
        local prompt="Keyboard Layout Selection"
        local stage_prompt="Setting Keyboard Layout"
        title "${prompt}"
    if [[ "${tty}" == *"pts"* ]]; then
        SETKBD="us"
        inf "No 'tty' ${yellowl}(Linux console) ${nc}detected"
        ack "Default Keyboard Layout ('us') selected"
        ok
        return 0
    fi
        ask "Select your Keyboard Layout"
        ack "[Enter ${nc}'l'${yellow} to list layouts, then ${nc}'enter'${yellow} to search or ${nc}'q'${yellow} to quit]"
        get "Enter your keyboard layout ${bwhite}(empty for 'us')"
        read -r -p "==> " SETKBD
    if [[ -z "${SETKBD}" ]]; then
        SETKBD="us"
        ack "'us' Keyboard Layout has been selected"
    elif [[ "${SETKBD}" == "l" ]]; then
        localectl list-keymaps | less
        return 1
    elif ! localectl list-keymaps | grep -Fxq "${SETKBD}"; then
        invalid
        return 1
    else
        ack "${SETKBD} Keyboard Layout has been selected"
        loadkeys "${SETKBD}" > "${void}" 2> "${log}" || stage_fail
    fi
        ok
}
user_setup() {
        local prompt="User Setup"
        title "${prompt}"
        get "Enter a username"
        read -r -p "==> " USERNAME
        USERNAME="${USERNAME,,}"
    if [[ -z "${USERNAME}" ]]; then
        err "Please enter a username to continue"
        reload
        return 1
    elif [[ "${USERNAME}" =~ ^[a-z_]([a-z0-9_-]{0,31}|[a-z0-9_-]{0,30}\$)$ ]]; then
        get "Enter a password for${nc} ${cyan}${USERNAME}"
        read -r -p "==> " USERPASSWD
        if [[ -z "${USERPASSWD}" ]]; then
            err "Please enter a password to continue"
            reload
            return 1
        fi
        get "Re-enter${nc} ${cyan}${USERNAME}'s ${blue}password"
        read -r -p "==> " USERPASSWD2
        if [[ "${USERPASSWD}" != "${USERPASSWD2}" ]]; then
            err "Passwords don't match. Please try again.."
            reload
            return 1
        fi
    else
        err "Please enter a valid username to continue"
        reload
        return 1
    fi
        ok
}
rootuser_setup() {
        local prompt="Root User Setup"
        title "${prompt}"
        get "Enter a password for the${nc}${cyan} Root ${blue}user"
        read -r -p "==> " ROOTPASSWD
    if [[ -z "${ROOTPASSWD}" ]]; then
        err "Please enter a password for the Root user to continue"
        reload
        return 1
    fi
        get "Re-enter${nc} ${cyan}Root ${blue}user's password"
        read -r -p "==> " ROOTPASSWD2
    if [[ "${ROOTPASSWD}" != "${ROOTPASSWD2}" ]]; then
        err "Passwords don't match. Please try again.."
        reload
        return 1
    fi
        ok
}
slct_hostname() {
        local prompt="Hostname Setup"
        title "${prompt}"
        get "Enter a hostname"
        read -r -p "==> " HOSTNAME
    if [[ -z "${HOSTNAME}" ]]; then
        err "Please enter a hostname to continue"
        reload
        return 1
    elif [[ "${HOSTNAME}" =~ [[:upper:]] ]]; then
        err "Lowercase is preferred. Please try again.."
        reload
        return 1
    fi
        ok
}
slct_shell() {
        local prompt="Shell Selection"
        title "${prompt}"
        ask "Select a Shell"
        NC "\n\n            [1]  Bash\n\n            [2]  Zsh\n\n            [3]  Fish"
        get "Enter a number"
        read -r -p "==> " shellnmbr
    case "${shellnmbr}" in
        1)
            shell=""
            shellname="bash"
            shellname2="Bash"
            shell_pkgs="bash-completion powerline powerline-fonts" ;;
        2)
            shell="zsh"
            shellname="zsh"
            shellname2="Zsh"
            shell_pkgs="powerline powerline-fonts zsh-autocomplete zsh-autosuggestions zsh-completions zsh-syntax-highlighting" ;;
        3)
            shell="fish"
            shellname="fish"
            shellname2="Fish"
            shell_pkgs="powerline powerline-fonts which" ;;
       "")
            err "Please select a Shell"
            reload
            return 1 ;;
        *)
            invalid
            return 1 ;;
    esac
        ack "The ${shellname2} shell has been selected"
        ok
}
sys_submn() {
        title "System Configuration"
        ask "Select a Submenu"
        NC "\n\n            [1]  Kernel, Secure Boot Signing, Bootloader & ESP Mountpoint\n\n            [2]  Filesystem & Swap Setup\n\n            [3]  Graphics Setup\n\n            [4]  Desktop Setup\n\n            [5]  EFI Boot Entries Deletion\n\n            [6]  Extended Options\n\n            [ ]  Return to Main Menu"
        get "Enter a number"
        read -r -p "==> " sysmenu
    case "${sysmenu}" in
        1)
            until slct_krnl; do : ; done
            until ask_sign; do : ; done
            until slct_bootldr; do : ; done
            until slct_espmnt; do : ; done
            return 1 ;;
        2)
            until slct_fs; do : ; done
            until slct_swap; do : ; done
            return 1 ;;
        3)
            until dtct_gfx; do : ; done
            return 1 ;;
        4)
            until dsktp_setup; do : ; done
            return 1 ;;
        5)
            until boot_entr; do : ; done
            return 1 ;;
        6)
            until ext_opt_submn; do : ; done
            return 1 ;;
       "")
            until main_menu; do : ; done ;;
        *)
            invalid
            return 1 ;;
    esac
}
slct_krnl() {
        local prompt="Kernel Selection"
        title "${prompt}"
        ask "Select a Kernel"
        NC "\n\n            [1]  Linux\n\n            [2]  Linux LTS\n\n            [3]  Linux Hardened\n\n            [4]  Linux Zen"
        get "Enter a number"
        read -r -p "==> " kernelnmbr
    case "${kernelnmbr}" in
        1)
            kernel="linux"
            kernelname="Linux" ;;
        2)
            kernel="linux-lts"
            kernelname="Linux LTS" ;;
        3)
            inf "${yellowl}INFO: ${nc}System Hibernation is ${bwhite}not supported ${nc}by this kernel"
            kernel="linux-hardened"
            kernelname="Linux Hardened" ;;
        4)
            kernel="linux-zen"
            kernelname="Linux Zen" ;;
       "")
            err "Please select a Kernel"
            reload
            return 1 ;;
        *)
            invalid
            return 1 ;;
    esac
        ack "The ${kernelname} kernel has been selected"
        ok
}
ask_sign() {
        title "Secure Boot Signing"
        ask "Sign UKI(s), Kernel & binaries for use with Secure Boot ? [y/N]"
        get "Enter [y/N]"
        read -r -p "==> " sb_sign
        sb_sign="${sb_sign:-n}"
        sb_sign="${sb_sign,,}"
    if [[ "${sb_sign}" == "y" ]]; then
        local prompt="Secure Boot 'Setup' Mode Verification"
        validpkgs+=(sbctl)
        SB_Status="$(bootctl status 2> "${void}" | grep -E 'Secure Boot' | awk "{print \$4}")"
        if [[ "${SB_Status}" == "(setup)" ]]; then
            ok
        else
            err "Secure Boot Not in ${yellowl}'Setup' ${nc}Mode"
            printf "\n\n"
            failure
        fi
        ack "Secure Boot Signing has been selected"
        ask "Create an additional bootloader Rescue entry (for troubleshooting) ? [Y/n]"
        get "Enter [Y/n]"
        read -r -p "==> " setrescue
        setrescue="${setrescue:-y}"
        setrescue="${setrescue,,}"
        if [[ "${setrescue}" == "y" ]]; then
            local prompt="Rescue Entry set"
            ok
        elif [[ "${setrescue}" == "n" ]]; then
            skip
        else
            y_n
            return 1
        fi
    elif [[ "${sb_sign}" == "n" ]]; then
        skip
    else
        y_n
        return 1
    fi
        local prompt="Secure Boot Signing setup"
        ok
}
slct_bootldr() {
        local prompt="Bootloader Selection"
        title "${prompt}"
        ask "Select a Bootloader"
        NC "\n\n            [1]  Systemd-boot\n\n            [2]  Grub"
        get "Enter a number"
        read -r -p "==> " bootloader
    case "${bootloader}" in
        1)
            uki="y"
            ukify="systemd-ukify"
            ack "Systemd-boot has been selected"
            local prompt="UKI(s) Auto-generation"
            CYAN "\n\n\n        ###  ${nc}UKIs can be generated for every additional Kernel installed\n\n${cyan}        ###  ${nc}Secure Boot signing will be performed automatically for all subsequent UKIs"
            ask "Automate UKI(s) generation ? [y/N]"
            get "Enter [y/N]"
            read -r -p "==> " uki_use
            uki_use="${uki_use:-n}"
            uki_use="${uki_use,,}"
            case "${uki_use}" in
                y)
                    ack "UKI(s) Auto-generation has been selected" ;;
                n)
                    skip ;;
               "")
                    y_n
                    reload
                    return 1 ;;
                *)
                    invalid
                    return 1 ;;
            esac ;;
        2)
            uki="n"
            ask "Select a Boot Path to install to"
            NC "\n\n            [1]  Standard Path\n\n            [2]  Fallback Path -- for Removable Devices (recommended)"
            get "Enter a number"
            read -r -p "==> " path
            case "${path}" in
                1)
                    ack "Grub (Standard Boot Path) has been selected" ;;
                2)
                    ack "Grub (Fallback Boot Path) has been selected" ;;
               "")
                    err "Please select a Boot Path"
                    reload
                    return 1 ;;
                *)
                    invalid
                    return 1 ;;
            esac ;;
       "")
            err "Please select a Bootloader"
            reload
            return 1 ;;
        *)
            invalid
            return 1 ;;
    esac
        ok
}
slct_espmnt() {
        local prompt="ESP Mountpoint Selection"
        title "${prompt}"
        ask "Select a Mountpoint for the ESP"
        NC "\n\n            [1]  /mnt/efi\n\n            [2]  /mnt/boot"
        get "Enter a number"
        read -r -p "==> " espmnt
    case "${espmnt}" in
        1)
            esp_mount="/mnt/efi"
            btldr_esp_mount="/efi"
            ack "'/mnt/efi' mountpoint has been selected" ;;
        2)
            esp_mount="/mnt/boot"
            btldr_esp_mount="/boot"
            ack "'/mnt/boot' mountpoint has been selected" ;;
       "")
            err "Please select a Mountpoint"
            reload
            return 1 ;;
        *)
            invalid
            return 1 ;;
    esac
        ok
    if [[ "${sanity}" == "no" ]]; then
        until sanity_check; do : ; done
    fi
}
slct_fs() {
        local prompt="Filesystem Selection"
        title "${prompt}"
        ask "Select Filesystem to be used"
        NC "\n\n            [1]  Ext4\n\n            [2]  Btrfs"
        get "Enter a number"
        read -r -p "==> " fs
    case "${fs}" in
        1)
            fsname="Ext4"
            fs_mod="ext4"
            fstools="e2fsprogs"
            roottype="/Root"
            inf "${yellowl}INFO: ${nc}Keeping User Data on a ${bwhite}separate ${nc}/Home partition is supported"
            ask "Make use of a dedicated /Home partition ? [y/N]"
            get "Enter [y/N]"
            read -r -p "==> " sep_home
            sep_home="${sep_home:-n}"
            sep_home="${sep_home,,}"
            case "${sep_home}" in
                y)
                    ask "Make a selection"
                    NC "\n\n            [1]  Create a /Home partition\n\n            [2]  Utilize a previously used unencrypted /Home partition"
                    get "Enter a number"
                    read -r -p "==> " hometype
                    case "${hometype}" in
                        1)
                            ack "A /Home Partition will be created" ;;
                        2)
                            ack "An existing /Home Partition will be used" ;;
                        *)
                            invalid
                            return 1 ;;
                    esac ;;
                n)
                    skip ;;
                *)
                    invalid
                    return 1 ;;
            esac
            ack "${fsname} has been selected" ;;
        2)
            fsname="Btrfs"
            fs_mod="btrfs"
            fstools="btrfs-progs"
            roottype="/@"
            btrfs_bootopts="rootflags=subvol=@"
            ack "${fsname} has been selected"
            ask "Label your Btrfs snapshots directory"
            get "Enter a name"
            read -r -p "==> " snapname
            if [[ -z "${snapname}" ]]; then
                invalid
                return 1
            fi ;;
        "")
            err "Please select a Filesystem"
            reload
            return 1 ;;
        *)
            invalid
            return 1 ;;
    esac
        ok
}
slct_swap() {
        local prompt="Swap Selection"
        title "${prompt}"
        ask "Select Swap type"
        NC "\n\n            [1]  Swap Partition\n\n            [2]  Swapfile\n\n            [3]  Zram Swap"
        get "Enter a number ${bwhite}(empty to skip)"
        read -r -p "==> " swapmode
    case "${swapmode}" in
        1)
            swaptype="swappart"
            ack "Swap Partition has been selected" ;;
        2)
            if [[ "${fs}" == "1" ]]; then
                swaptype="swapfile"
            elif [[ "${fs}" == "2" ]]; then
                swaptype="swapfile_btrfs"
            fi
            ack "Swapfile has been selected"
            until set_swapsize; do : ; done ;;
        3)
            inf "Hibernating to Swap on Zram is ${yellowl}not supported"
            zram="zram-generator"
            ack "Zram Swap has been selected" ;;
       "")
            ack "No Swap will be used"
            skip ;;
        *)
            invalid
            return 1 ;;
    esac
        ok
}
set_swapsize() {
        local prompt="Swapsize"
        inf "Set Swap ${yellowl}size ${nc}(integers only eg. 1,4,8,16,34)"
        get "Enter Swap size ${bwhite}(in GB)"
        read -r -p "==> " swapsize
    if [[ -z "${swapsize}" ]]; then
        err "Please enter a value to continue"
        reload
        return 1
    elif [[ "${swapsize}" == [[:digit:]] ]]; then
        ok
    else
        err "Please use only integers as a value"
        reload
        return 1
    fi
}
dtct_gfx() {
        gfx_slct="yes"
    if [[ "${vendor}" == "Virtual Machine" ]]; then
        vm
        skip
        return 0
    fi
        title "Graphics Setup"
        gfxcount="$(lspci | grep -E -c 'VGA|Display|3D')"
        gfxcard="$(lspci | grep -E 'VGA|Display|3D' | sed 's/^.*: //g')"
        intelcount="$(lspci | grep -E 'VGA|Display|3D' | grep -E -c 'Intel Corporation')"
        intelcards="$(lspci | grep -E 'VGA|Display|3D' | grep -E 'Intel Corporation'| sed 's/.*Corporation //g' | cat --number | sed 's/.[0-9]//')"
        amdcount="$(lspci | grep -E 'VGA|Display|3D' | grep -E -c 'Advanced Micro Devices')"
        amdcards="$(lspci | grep -E 'VGA|Display|3D' | grep -E 'Advanced Micro Devices' | sed 's/.*\[AMD\/ATI\] //g' | cat --number | sed 's/.[0-9]//')"
        nvidiacount="$(lspci | grep -E 'VGA|Display|3D' | grep -E -c 'NVIDIA Corporation')"
        nvidiacards="$(lspci | grep -E 'VGA|Display|3D' | grep -E 'NVIDIA Corporation'| sed 's/.*Corporation //g' | cat --number | sed 's/.[0-9]//')"
    if [[ "${gfxcount}" == "1" ]]; then
        dtct_single_gfx
    else
        dtct_multi_gfx
    fi
}
dtct_single_gfx() {
    if [[ "${intelcount}" -eq "1" ]]; then
        vendor="Intel"
        sourcetype="Open-source"
        intel
    elif [[ "${amdcount}" -eq "1" ]]; then
        vendor="AMD"
        sourcetype="Open-source"
        amd
    elif [[ "${nvidiacount}" -eq "1" ]]; then
        vendor="Nvidia"
        nvidia
        sleep 0.2
        CYAN "
        ###  ${yellowl}Turing ${bwhite}(NV160/TUxxx) ${nc}Graphics or newer are officialy supported ${cyan}\n\n        ###  ${yellowl}Maxwell ${bwhite}(NV110/GMxxx) ${nc}through ${yellowl}Volta ${bwhite}(NV140/GVxxx) ${nc}Graphics are unofficialy supported ${yellowl}[AUR] ${nc}${cyan}\n\n\n        ###  ${nc}Selecting ${yellowl}(n)o ${nc}defaults to the ${bwhite}open-source ${yellowl}'nouveau' ${nc}driver"
        ask "Install proprietary Nvidia drivers ? [Y/n]"
        get "Enter [Y/n]"
        read -r -p "==> " nvidiaprop
        nvidiaprop="${nvidiaprop:-y}"
        nvidiaprop="${nvidiaprop,,}"
        if [[ "${nvidiaprop}" == "y"  ]]; then
            sourcetype="Proprietary"
        elif [[ "${nvidiaprop}" == "n"  ]]; then
            sourcetype="Open-source"
            skip
        elif [[ ! "${nvidiaprop}" =~ ^(y|n)$ ]]; then
            invalid
            return 1
        fi
    fi
       gfx_conf
}
dtct_multi_gfx() {
        sleep 0.2
        YELLOW "\n\n        ###  Multi Graphics Setup detected, consisting of:"
        NC "\n        ____________________________________________________________________"
    if [[ "${intelcount}" -ge "1" ]]; then
        echo
        BLUEBG  "       ------------------------------- "
        BLUEBG  "       [${intelcount}]  Intel   Graphics device(s) "
        BLUEBG  "       ------------------------------- "
        NC "\n${intelcards}\n\n        ____________________________________________________________________"
    fi
    if [[ "${amdcount}" -ge "1" ]]; then
        echo
        REDBG   "       ------------------------------- "
        REDBG   "       [${amdcount}]  AMD     Graphics device(s) "
        REDBG   "       ------------------------------- "
        NC "\n${amdcards}\n\n        ____________________________________________________________________"
    fi
    if [[ "${nvidiacount}" -ge "1" ]]; then
        echo
        GREENBG "       ------------------------------- "
        GREENBG "       [${nvidiacount}]  Nvidia  Graphics device(s) "
        GREENBG "       ------------------------------- "
        NC "\n${nvidiacards}\n\n\n        ${cyan}###  ${yellowl}Turing ${bwhite}(NV160/TUxxx) ${nc}Graphics or newer are officialy supported ${cyan}\n\n        ###  ${yellowl}Maxwell ${bwhite}(NV110/GMxxx) ${nc}through ${yellowl}Volta ${bwhite}(NV140/GVxxx) ${nc}Graphics are unofficialy supported ${yellowl}[AUR] ${nc}${cyan}\n\n\n        ###  ${nc}Selecting ${yellowl}(n)o ${nc}defaults to the ${bwhite}open-source ${yellowl}'nouveau' ${nc}driver\n        ________________________________________________________________"
        ask "Install proprietary Nvidia drivers ? [Y/n]"
        get "Enter [Y/n]"
        read -r -p "==> " nvidiaprop
        nvidiaprop="${nvidiaprop:-y}"
        nvidiaprop="${nvidiaprop,,}"
        if [[ "${nvidiaprop}" == "n"  ]]; then
            skip
        elif [[ ! "${nvidiaprop}" =~ ^(y|n)$ ]]; then
            invalid
            return 1
        fi
    fi
        multivendors=()
        multisourcetype=()
    if [[ "${intelcount}" -ge "1" ]]; then
        multivendors+=(Intel)
        multisourcetype+=(Open-source)
    fi
    if [[ "${amdcount}" -ge "1" ]]; then
        multivendors+=(AMD)
        multisourcetype+=(Open-source)
    fi
    if [[ "${nvidiacount}" -ge "1" ]]; then
        multivendors+=(Nvidia)
        if [[ "${nvidiaprop}" == "y" ]]; then
            multisourcetype+=(Proprietary)
        else
            multisourcetype+=(Open-source)
        fi
    fi
        vendors="${multivendors[*]}"
        sourcetype="${multisourcetype[*]}"
    if [[ "${sourcetype}" =~ "Open-source" && "${sourcetype}" =~ "Proprietary" ]]; then
        sourcetype="Open-source & Proprietary"
    elif [[ "${sourcetype}" =~ "Open-source" ]]; then
        sourcetype="Open-source"
    elif [[ "${sourcetype}" =~ "Proprietary" ]]; then
        sourcetype="Proprietary"
    fi
        gfx_conf
}
gfx_conf() {
        inf "${yellowl}${sourcetype} ${nc}drivers will be used"
    if [[ "${vendor}" == "AMD" || "${vendors}" =~ "AMD"  ]]; then
        ask "Enable 'amdgpu' driver support for"
        NC "\n\n            [1]  'Southern Islands' Graphics\n\n            [2]  'Sea Islands' Graphics"
        get "Enter a number ${bwhite}(empty to skip)"
        read -r -p "==> " islands
        case "${islands}" in
            1)
                local prompt="Southern Islands"
                ok ;;
            2)
                local prompt="Sea Islands"
                ok ;;
           "")
                skip ;;
            *)
                invalid
                return 1 ;;
        esac
    fi
    if [[ "${nvidiaprop}" == "y"  ]]; then
        sleep 0.2
        ask "Select Nvidia driver"
        NC "\n\n            [1]  Nvidia-open                 ${yellowl}Turing ${bwhite}(NV160/TUxxx) ${nc}Graphics or newer\n\n            [2]  Nvidia-580xx-dkms [AUR]     ${yellowl}Maxwell ${bwhite}(NV110/GMxxx) ${nc}through ${yellowl}Volta ${bwhite}(NV140/GVxxx) ${nc}Graphics"
        get "Enter a number"
        read -r -p "==> " family
        case "${family}" in
            1)
                local prompt="Turing+"
                ok ;;
            2)
                local prompt="Maxwell -> Volta"
                ok
                local prompt="GSP Firmware Disabled"
                ask "Disable 'GSP' firmware ? [y/n]"
                get "Enter [y/n]"
                read -r -p "==> " nogsp
                if [[ "${nogsp}" == "n" ]]; then
                   skip
                elif [[ "${nogsp}" == "y" ]]; then
                   ok
                else
                   y_n
                   return 1
                fi ;;
           "")
                choice
                return 1 ;;
            *)
                invalid
                return 1 ;;
        esac
        local prompt="Low Latency Display Interrupts enabled"
        ask "Enable Low Latency Display Interrupts (experimental) ? [Y/n]"
        get "Enter [Y/n]"
        read -r -p "==> " lowlat
        lowlat="${lowlat:-y}"
        lowlat="${lowlat,,}"
        if [[ "${lowlat}" == "n" ]]; then
           skip
        elif [[ "${lowlat}" == "y" ]]; then
           ok
        else
           y_n
           return 1
        fi
    fi
        ack "Graphics will be automatically configured"
        local prompt="Graphics Setup"
        ok
        keypress
}
gfxpkgs_set() {
        gfxpkgs=()
    if [[ "${vendor}" == "Intel" || "${vendors}" =~ "Intel" ]]; then
        perf_stream="dev.i915.perf_stream_paranoid = 0"
        gfxpkgs+=(igsc intel-compute-runtime intel-media-driver intel-media-sdk libva-intel-driver libva-utils libvpl opencl-headers vpl-gpu-rt vkd3d vulkan-intel vulkan-mesa-layers)
    fi
    if [[ "${vendor}" == "AMD" || "${vendors}" =~ "AMD" ]]; then
        gfxpkgs+=(libva-mesa-driver mesa-utils opencl-headers rocm-opencl-runtime vkd3d vulkan-mesa-layers vulkan-radeon)
    fi
    if [[ "${nvidiaprop}" == "y" ]]; then
        if [[ "${swapmode}" =~ ^(1|2|3)$ ]]; then
            sleep 0.2
            NC "\n        ----------------------------------------------------------------\n        ${cyan}###  ${yellowl}INFO: ${nc}When Hibernating                                  ${cyan}###\n\n        ###  ${nc}Nvidia's ${yellowl}'Preserve-Video-Memory-After-Suspend' ${nc}feature  ${cyan}###\n\n        ###  ${nc}is incompatible with ${yellowl}'Early KMS' ${nc}use                    ${cyan}###${nc}\n        ----------------------------------------------------------------"
            keypress
        fi
        gfxpkgs=(libva-mesa-driver libva-nvidia-driver libvdpau-va-gl vkd3d)
        if [[ "${family}" == "1" ]]; then
            gfxpkgs+=(nvidia-settings nvidia-utils opencl-nvidia opencl-headers)
            if [[ "${kernelnmbr}" == "1" ]]; then
                nvname="nvidia-open"
                gfxpkgs+=(nvidia-open)
            elif [[ "${kernelnmbr}" == "2" ]]; then
                nvname="nvidia-open-lts"
                gfxpkgs+=(nvidia-open-lts)
            else
                gfxpkgs+=(nvidia-open-dkms)
            fi
        elif [[ "${family}" == "2" ]]; then
            nvidia_aur="y"
        fi
    elif [[ "${nvidiaprop}" == "n" ]]; then
        gfxpkgs+=(libva-mesa-driver vulkan-nouveau)
    fi
}
dsktp_setup() {
        title "Desktop Setup"
        ask "Make a selection"
        NC "\n\n            [1]  Desktop Selection\n\n            [2]  Arch 'base-devel' Meta-package\n\n            [3]  Web browser Selection\n\n            [4]  Printer & Scanner Support\n\n            [ ]  Return to System Configuration"
        get "Enter a number"
        read -r -p "==> " desk_setup
    case "${desk_setup}" in
        1)
            until dsktp_slct; do : ; done
            return 1 ;;
        2)
            until base_devel; do : ; done
            return 1 ;;
        3)
            until web_browser; do : ; done
            return 1 ;;
        4)
            until print_scan; do : ; done
            return 1 ;;
       "")
            until sys_submn; do : ; done ;;
        *)
            invalid
            return 1 ;;
    esac
}
term_offer() {
        inf "${desktopname} desktop lacks a ${yellowl}native ${nc}terminal emulator by design"
        ask "Install ${nc}'gnome-terminal' ${yellow}for convenience ? [Y/n]"
        get "Enter [Y/n]"
        read -r -p "==> " terminal
        terminal="${terminal:-y}"
        terminal="${terminal,,}"
    case "${terminal}" in
        y)
            local prompt="Terminal"
            ok ;;
        n)
            skip ;;
        *)
            invalid
            until term_offer; do : ; done ;;
    esac
}
alt_session_support() {
        inf "${desktopname} desktop defaults to a(n) ${yellowl}${session} ${nc}session"
        ask "Install ${nc}${alt_session} ${yellow}session support ? [N/y]"
        get "Enter [N/y]"
        read -r -p "==> " session_support
        session_support="${session_support:-n}"
        session_support="${session_support,,}"
    case "${session_support}" in
        y)
            local prompt="${alt_session} support"
            ok ;;
        n)
            skip ;;
        *)
            invalid
            until alt_session_support; do : ; done ;;
    esac
}
dsktp_slct() {
        title "Desktop Selection"
        deskpkgs=""
        custompkgs=""
        terminal=""
        local prompt="Desktop Selection"
        ask "Make a selection"
        NC "\n\n            [1]  Plasma\n\n            [2]  Plasma Lite\n\n            [3]  Gnome\n\n            [4]  Gnome Lite\n\n            [5]  Xfce\n\n            [6]  Cinnamon\n\n            [7]  Deepin\n\n            [8]  Budgie\n\n            [9]  Lxqt\n\n           [10]  Mate\n\n           [11]  Basic Arch Linux  (No GUI)\n\n           [12]  Custom Arch Linux\n\n           [13]  Cosmic\n\n           [14]  Pantheon"
        get "Enter a number"
        read -r -p "==> " desktop
    case "${desktop}" in
        1)
            desktopname="Plasma"
            ack "${desktopname} has been selected"
            session="Wayland"
            alt_session="X11"
            alt_session_support
            alt_session_pack="plasma-x11-session" ;;
        2)
            desktopname="Plasma Lite"
            ack "${desktopname} has been selected"
            session="Wayland"
            alt_session="X11"
            alt_session_support
            alt_session_pack="plasma-x11-session" ;;
        3)
            desktopname="Gnome"
            ack "${desktopname} has been selected" ;;
        4)
            desktopname="Gnome Lite"
            ack "${desktopname} has been selected" ;;
        5)
            desktopname="Xfce"
            ack "${desktopname} has been selected"
            session="X11"
            alt_session="Wayland (experimental)"
            alt_session_support
            alt_session_pack="labwc";;
        6)
            desktopname="Cinnamon"
            ack "${desktopname} has been selected"
            term_offer ;;
        7)
            desktopname="Deepin"
            ack "${desktopname} has been selected" ;;
        8)
            desktopname="Budgie"
            ack "${desktopname} has been selected"
            term_offer ;;
        9)
            desktopname="Lxqt"
            ack "${desktopname} has been selected"
            session="X11"
            alt_session="Wayland (experimental)"
            alt_session_support
            alt_session_pack="labwc lxqt-wayland-session waylock" ;;
       10)
            desktopname="Mate"
            ack "${desktopname} has been selected" ;;
       11)
            desktopname="Basic Arch Linux"
            ack "${desktopname} has been selected" ;;
       12)
            desktopname="Custom Arch Linux"
            until cust_sys; do :; done
            return 0 ;;
       13)
            desktopname="Cosmic"
            ack "${desktopname} has been selected" ;;
       14)
            desktopname="Pantheon"
            ack "${desktopname} has been selected" ;;
       "")
            choice
            keypress
            return 1 ;;
        *)
            invalid
            keypress
            return 1 ;;
    esac
        ok
    if [[ -n "${web}" && "${desktop}" =~ ^(11|12)$ ]]; then
            until web_browser; do : ; done
    fi
    if [[ "${printer}" == "y" && "${desktop}" =~ ^(11|12)$ ]]; then
            until print_scan; do : ; done
    fi
}
cust_sys() {
        local prompt="Custom Arch Linux"
        until add_pkgs; do : ; done
        until add_services; do : ; done
        ok
}
add_pkgs() {
        local prompt="Adding Packages"
        title "Add Your Packages"
        inf "${bwhite}'base'${nc}, ${bwhite}'linux-firmware' ${nc}(if on bare-metal), ${bwhite}'sudo' ${nc}& your ${bwhite}current ${nc}choices are already ${yellowl}included${nc}\n"
        get "Enter any additional packages ${bwhite}(space-seperated)"
        read -r -p "==> " custompkgs
    if [[ -z "${custompkgs}" ]]; then
        err "Please enter package(s) to continue"
        reload
        return 1
    else
        ok
    fi
}
add_services() {
        local prompt="Adding Services"
        title "Add Your Services"
        ack "Empty to skip"
        get "Enter services to be enabled ${bwhite}(space-seperated)"
        read -r -p "==> " customservices
    if [[ -z "${customservices}" ]]; then
        skip
    else
        ok
    fi
}
base_devel() {
        local prompt="'base-devel' Meta-Package"
        title "${prompt}"
        inf "${yellowl}INFO: ${nc}The ${bwhite}'base' ${nc}meta-package does not include the ${bwhite}tools ${nc}needed for building packages"
        ask "Install 'base-devel' meta-package ? [y/N]"
        get "Enter [y/N]"
        read -r -p "==> " dev
        dev="${dev:-n}"
        dev="${dev,,}"
    case "${dev}" in
        y)
            devel="base-devel"
            validpkgs+=(base-devel)
            ack "The 'base-devel' meta-package will be installed" ;;
        n)
            skip ;;
        *)
            invalid
            return 1 ;;
    esac
        ok
}
web_browser() {
        title "Web Browser Selection"
    if [[ ! "${desktop}" =~ ^(11|12)$ && -n "${desktop}" ]]; then
        local prompt="Web Browser"
        ask "Select Web Browser to install"
        NC "\n\n            [1]  Firefox\n\n            [2]  Chromium\n\n            [3]  Vivaldi\n\n            [4]  Brave Browser\n\n            [5]  Microsoft Edge\n\n            [6]  Zen Browser\n\n            [7]  Opera\n\n            [8]  Google Chrome\n\n            [9]  Helium Browser"
        get "Enter a number ${bwhite}(empty to skip)"
        read -r -p "==> " web
        case "${web}" in
            1)
                web_pkg="firefox"
                web_name="Firefox" ;;
            2)
                web_pkg="chromium"
                web_name="Chromium" ;;
            3)
                web_pkg="vivaldi"
                web_name="Vivaldi" ;;
            4)
                web_aur="brave-bin"
                web_aur_url="https://aur.archlinux.org/cgit/aur.git/snapshot/brave-bin.tar.gz"
                web_name="Brave Browser" ;;
            5)
                web_aur="microsoft-edge-stable-bin"
                web_aur_url="https://aur.archlinux.org/cgit/aur.git/snapshot/microsoft-edge-stable-bin.tar.gz"
                web_name="Microsoft Edge" ;;
            6)
                web_aur="zen-browser-bin"
                web_aur_url="https://aur.archlinux.org/cgit/aur.git/snapshot/zen-browser-bin.tar.gz"
                web_name="Zen Browser" ;;
            7)
                web_aur="opera"
                web_aur_url="https://aur.archlinux.org/cgit/aur.git/snapshot/opera.tar.gz"
                web_name="Opera" ;;
            8)
                web_aur="google-chrome"
                web_aur_url="https://aur.archlinux.org/cgit/aur.git/snapshot/google-chrome.tar.gz"
                web_name="Google Chrome" ;;
            9)
                web_aur="helium-browser-bin"
                web_aur_url="https://aur.archlinux.org/cgit/aur.git/snapshot/helium-browser-bin.tar.gz"
                web_name="Helium Browser" ;;
           "")
                web_pkg=""
                web_aur=""
                web_aur_url=""
                web_name=""
                web_slct="yes"
                skip
                ok ;;
            *)
                invalid
                return 1 ;;
        esac
        if [[ "${web}" =~ ^(4|5|6|7|8|9)$ && -z "${devel}" ]]; then
            validpkgs+=(base-devel)
        fi
    else
        echo
        err "Incompatible selection detected"
        inf "${yellowl}Basic ${nc}Arch Linux / ${yellowl}Custom ${nc}Arch Linux detected or ${yellowl}No Desktop ${nc}selected yet"
        ack "No Browser selected"
        web_pkg=""
        web_aur=""
        web_name=""
        web_slct=""
        skip
        keypress
    fi
    if [[ "${web}" =~ ^(1|2|3|4|5|6|7|8|9)$ ]]; then
        local prompt="${web_name}"
        web_slct="yes"
        ok
    fi
}
print_scan() {
        local prompt="Printer & Scanner Support"
        title "${prompt}"
    if [[ "${vendor}" != "Virtual Machine" ]]; then
        if [[ ! "${desktop}" =~ ^(11|12)$ && -n "${desktop}" ]]; then
            ask "Enable Printer & Scanner support ? [y/N]"
            get "Enter [y/N]"
            read -r -p "==> " printer
            printer="${printer:-n}"
            printer="${printer,,}"
            case "${printer}" in
                y)
                    collect_print_pkgs=(bluez-cups cups-pdf cups-browsed cups-pk-helper foomatic-db-gutenprint-ppds gutenprint ipp-usb libusb nss-mdns sane-airscan system-config-printer xdg-utils colord)
                    if [[ "${desktop}" == "2" ]]; then
                        collect_print_pkgs+=(print-manager skanlite)
                    elif [[ "${desktop}" == "4" ]]; then
                        collect_print_pkgs+=(simple-scan)
                    fi
                    print_pkgs="${collect_print_pkgs[*]}" ;;
                n)
                    print_pkgs=""
                    skip ;;
                *)
                    invalid
                    return 1 ;;
            esac
            ok
        else
            echo
            err "Incompatible selection detected"
            inf "${yellowl}Basic ${nc}Arch Linux / ${yellowl}Custom ${nc}Arch Linux detected or ${yellowl}No Desktop ${nc}selected yet"
            ack "Printer/Scanner support not enabled"
            print_pkgs=""
            skip
            ok
            keypress
        fi
    else
        print_pkgs=""
        vm
        skip
        ok
    fi
}
boot_entr() {
    if [[ "${vendor}" == "Virtual Machine" ]]; then
        efi_entr_del="yes"
        vm
        skip
        return 0
    fi
        local prompt="Boot Entries"
        title "EFI Boot Entries Deletion"
        ask "Select an EFI Boot Entry to Delete ${red}[!] (CAUTION) [!]${nc} "
        printf "\n\n\n"
        NC ""
        efibootmgr --unicode
        entrnmbr="$(efibootmgr --unicode | grep -E 'BootOrder' | awk "{print \$2}")"
        boot_entry=" "
    while [[ -n "${boot_entry}" ]]; do
        get "Enter a Boot Entry number for Deletion ${bwhite}(empty to skip)"
        CYAN "\nBoot Entries: ${yellowl}${entrnmbr}\n"
        read -r -p "==> " boot_entry
        if [[ -n "${boot_entry}" ]]; then
            if [[ "${run_as}" != "root" ]]; then
                err "Root Privileges Missing.."
                reload
                until sys_submn; do : ; done
            fi
            if efibootmgr -b "${boot_entry}" -B --unicode; then
                local prompt="Entry ${boot_entry} Deleted"
                ok
            else
                err_try
                return 1
            fi
        else
            skip
            ok
        fi
    done
        efi_entr_del="yes"
}
ext_opt_submn() {
        title "Extended Options"
        ask "Make a selection"
        NC "\n\n            [1]  Custom Kernel Parameters\n\n            [2]  System Watchdogs\n\n            [3]  General System Optimizations\n\n            [4]  Wireless Regulatory Domain\n\n            [5]  Systemd-oomd\n\n            [6]  Irqbalance\n\n            [7]  Thermald\n\n            [8]  Rng-tools\n\n            [9]  Rtkit\n\n           [10]  Tlp\n\n           [  ]  Return to System Configuration"
        get "Enter a number"
        read -r -p "==> " set_ext_opt
    case "${set_ext_opt}" in
        1)
            until cust_kern_param; do : ; done
            return 1 ;;
        2)
            until sys_watchdog; do : ; done
            return 1 ;;
        3)
            until sysoptm; do : ; done
            return 1 ;;
        4)
            until ask_wireless_regdom; do : ; done
            return 1 ;;
        5)
            until systemd_oomd; do : ; done
            return 1 ;;
        6)
            until irqbalance; do : ; done
            return 1 ;;
        7)
            until thermald; do : ; done
            return 1 ;;
        8)
            until rngd; do : ; done
            return 1 ;;
        9)
            until rtkit; do : ; done
            return 1 ;;
       10)
            until tlp; do : ; done
            return 1 ;;
       "")
            until sys_submn; do : ; done ;;
        *)
            invalid
            return 1 ;;
    esac
}
display_ext_opt() {
        local prompt="Extended Options"
        ask "Display Extended Options ? [y/N]"
        get "Enter [y/N]"
        read -r -p "==> " show_extopts
        show_extopts="${show_extopts:-n}"
        show_extopts="${show_extopts,,}"
    if [[ "${show_extopts}" == "n" ]]; then
        skip
        ok
    elif [[ "${show_extopts}" == "y" ]]; then
        return 0
    else
        invalid
        return 1
    fi
}
cust_kern_param() {
        local prompt="Custom Kernel Parameters"
        title "${prompt}"
        inf "${yellowl}Custom ${nc}Kernel parameters can be set at ${bwhite}boot ${nc}time"
        ask "Enter your own additional Kernel parameters to be added to the Kernel cmdline ? [y/N]"
        get "Enter [y/N]"
        read -r -p "==> " ask_param
        ask_param="${ask_param:-n}"
        ask_param="${ask_param,,}"
    case "${ask_param}" in
        y)
            until add_prmtrs; do : ; done ;;
        n)
            skip
            ok ;;
        *)
            invalid
            return 1 ;;
    esac
}
add_prmtrs() {
        local prompt="Custom Kernel Parameters"
        ask "Add Your Kernel parameters ${nc}(Empty to skip)"
        get "Enter your own Kernel parameters to be set at boot ${bwhite}(space-seperated)"
        read -r -p "==> " cust_bootopts
    if [[ -z "${cust_bootopts}" ]]; then
        skip
        ok
    else
        ok
    fi
}
sys_watchdog() {
        local prompt="System Watchdogs"
        title "${prompt}"
        CYAN "\n\n        ###  ${nc}A watchdog is a hardware or software component that keeps track of a system's performance${cyan}\n\n        ###  ${nc}and intervenes if it notices any strange behaviour or malfunctions"
        ask "Disable Watchdogs in the installed system ? [y/N]"
        get "Enter [y/N]"
        read -r -p "==> " kill_watchdog
        kill_watchdog="${kill_watchdog:-n}"
        kill_watchdog="${kill_watchdog,,}"
    case "${kill_watchdog}" in
        y)
            ack "Watchdogs will be disabled" ;;
        n)
            skip ;;
        *)
            invalid
            return 1 ;;
    esac
        ok
}
sysoptm() {
        local prompt="System Optimizations"
        title "${prompt}"
        CYAN "\n\n        ###  ${nc}System Optimizations are available${cyan}\n\n        ###  ${nc}Type ${yellowl}'v' ${nc}to view a summary"
        ask "Enable System Optimizations ? [v/y/N]"
        get "Enter [v/y/N]"
        read -r -p "==> " sys_optm
        sys_optm="${sys_optm:-n}"
        sys_optm="${sys_optm,,}"
    case "${sys_optm}" in
        y)
            validpkgs+=("ccache" "ntfs-3g" "pbzip2" "pigz")
            ack "System Optimizations will be set" ;;
        n)
            skip ;;
        v)
            view_optm
            return 1 ;;
        *)
            invalid
            return 1 ;;
    esac
        ok
}
ask_wireless_regdom() {
    if [[ "${vendor}" == "Virtual Machine" ]]; then
        vm
        skip
        return 0
    fi
        local prompt="Wireless Regdom Setup"
        title "Wireless Regulatory Domain Setup"
        CYAN "\n\n        ###  ${nc}The regulatory domain is used to reconfigure wireless drivers, to make sure that wireless${cyan}\n\n        ###  ${nc}hardware usage complies with local laws set by the FCC, ETSI and other organizations"
        ask "Select your Country Code (e.g. US)"
        ack "[Enter ${nc}'l'${yellow} to list country codes, then ${nc}'enter'${yellow} to search or ${nc}'q'${yellow} to quit]"
        get "Enter your Country Code ${bwhite}(empty to skip)"
        read -r -p "==> " REGDOM
        REGDOM="${REGDOM^^}"
    if [[ -z "${REGDOM}" ]]; then
        skip
    elif [[ "${REGDOM}" == "L" ]]; then
        sed 's|^#WIRELESS_REGDOM=||g' /etc/conf.d/wireless-regdom | sed 's|"||g'| less
        return 1
    elif ! grep \""${REGDOM}"\" /etc/conf.d/wireless-regdom > "${void}" 2>&1 ; then
        invalid
        return 1
    else
        wireless_reg="wireless-regdb"
        ack "${REGDOM} Country Code has been selected"
    fi
        ok
}
systemd_oomd() {
        local prompt="Systemd-oomd Setup"
        title "${prompt}"
        CYAN "\n\n        ###  ${nc}A system service that uses cgroups-v2 and pressure stall information (PSI)\n\n${cyan}        ###  ${nc}to monitor system and take corrective action before an 'OOM' occurs in the kernel space"
        ask "Enable 'systemd-oomd' ? [y/N]"
        inf "Swapping enabled is ${yellowl}highly recommended ${nc}for optimal performance"
        get "Enter [y/N]"
        read -r -p "==> " oomd
        oomd="${oomd:-n}"
        oomd="${oomd,,}"
    if [[ "${oomd}" == "y" ]]; then
        ack "'Systemd-oomd' service will be enabled"
    elif [[ "${oomd}" == "n" ]]; then
        skip
    else
        invalid
        return 1
    fi
        ok
}
irqbalance() {
        local prompt="Irqbalance Setup"
        title "${prompt}"
        CYAN "\n\n        ###  ${nc}Distributes hardware interrupts across processors on a multiprocessor system${cyan}\n\n        ###  ${nc}in order to increase performance"
        ask "Install & enable 'irqbalance' ? [y/N]"
        get "Enter [y/N]"
        read -r -p "==> " irqbalance
        irqbalance="${irqbalance:-n}"
        irqbalance="${irqbalance,,}"
    if [[ "${irqbalance}" == "y" ]]; then
        validpkgs+=(irqbalance)
        ack "'irqbalance' service will be enabled"
    elif [[ "${irqbalance}" == "n" ]]; then
        skip
    else
        invalid
        return 1
    fi
        ok
}
thermald() {
        local prompt="Thermald Setup"
        title "${prompt}"
        CYAN "\n\n        ###  ${nc}A Linux daemon used to prevent the overheating of ${yellowl}Intel ${nc}platforms\n\n${cyan}        ###  ${nc}This daemon monitors temperature and applies compensation using available cooling methods"
        ask "Install & enable 'thermald' ? [y/N]"
        get "Enter [y/N]: "
        read -r -p "==> " thermald
        thermald="${thermald:-n}"
        thermald="${thermald,,}"
    if [[ "${thermald}" == "y" ]]; then
        validpkgs+=(thermald)
        ack "'thermald' service will be enabled"
    elif [[ "${thermald}" == "n" ]]; then
        skip
    else
        invalid
        return 1
    fi
        ok
}
rngd() {
        local prompt="Rng-tools Setup"
        title "${prompt}"
        CYAN "\n\n        ###  ${nc}The rngd daemon is capable of using both environmental noise\n\n${cyan}        ###  ${nc}and hardware random number generators for extracting entropy"
        ask "Install & enable 'rngd' ? [y/N] "
        get "Enter [y/N]"
        read -r -p "==> " rngd
        rngd="${rngd:-n}"
        rngd="${rngd,,}"
    if [[ "${rngd}" == "y" ]]; then
        validpkgs+=(rng-tools)
        ack "'rngd' service will be enabled"
    elif [[ "${rngd}" == "n" ]]; then
        skip
    else
        invalid
        return 1
    fi
        ok
}
rtkit() {
        local prompt="Rtkit Setup"
        title "${prompt}"
        CYAN "\n\n        ###  ${nc}RealtimeKit is a D-Bus system service that changes the scheduling policy\n\n${cyan}        ###  ${nc}of user processes/threads to SCHED_RR, [Realtime Scheduling Mode on request]"
        ask "Install & enable 'rtkit' ? [y/N]"
        get "Enter [y/N]"
        read -r -p "
==> " rtkit
        rtkit="${rtkit:-n}"
        rtkit="${rtkit,,}"
    if [[ "${rtkit}" == "y" ]]; then
        validpkgs+=("realtime-privileges" "rtkit")
        ack "'rtkit' service will be enabled"
    elif [[ "${rtkit}" == "n" ]]; then
        skip
    else
        invalid
        return 1
    fi
        ok
}
tlp() {
        local prompt="Tlp Setup"
        title "${prompt}"
        CYAN "\n\n        ###  ${nc}Tlp is a laptop battery power saving utility for Linux\n\n${cyan}        ###  ${nc}working out-of-the-box & easy to further configure"
        ask "Install & enable 'tlp' ? [y/N]"
        get "Enter [y/N]"
        read -r -p "==> " tlp
        tlp="${tlp:-n}"
        tlp="${tlp,,}"
    if [[ "${tlp}" == "y" ]]; then
        validpkgs+=(tlp)
        ack "'tlp' service will be enabled"
    elif [[ "${tlp}" == "n" ]]; then
        skip
    else
        invalid
        return 1
    fi
        ok
}
dsks_submn() {
        title "Disk Management"
        ask "Select a Submenu"
        NC "\n\n            [1]  GPT Manager\n\n            [2]  Partition Manager\n\n            [ ]  Return to Main Menu"
        get "Enter a number"
        read -r -p "==> " diskmenu
    case "${diskmenu}" in
        1)
            until gpt_mngr; do : ; done ;;
        2)
            until part_mngr; do : ; done ;;
       "")
            until main_menu; do : ; done ;;
        *)
            invalid
            return 1 ;;
    esac
}
gpt_mngr() {
        local prompt="GPT Manager"
        title "${prompt}"
        gpt_dsk_nmbr=" "
    while [[ -n "${gpt_dsk_nmbr}" ]]; do
        if [[ -z "${instl_drive}" ]]; then
            ask "Select a disk to manage its GPT"
            NC "\n\n${disks}"
            get "Enter a disk number ${bwhite}(empty to skip)"
            read -r -p "==> " gpt_dsk_nmbr
            if [[ -n "${gpt_dsk_nmbr}" ]]; then
                gptdrive="$(echo "${disks}" | awk "\$1 == ${gpt_dsk_nmbr} {print \$2}")"
            else
                skip
                ok
                if [[ "${install}" == "yes" ]]; then
                    until instl_dsk; do : ; done
                    return 0
                else
                    until dsks_submn; do : ; done
                    return 0
                fi
            fi
        fi
        if [[ -n "${instl_drive}" ]]; then
            gptdrive="${instl_drive}"
        fi
        if [[ -e "${gptdrive}" ]]; then
            parttable="$(fdisk -l "${gptdrive}" 2> "${void}" | grep '^Disklabel type' | awk "{print \$3}")"
            if [[ "${run_as}" != "root" ]]; then
                err "Root Privileges Missing.."
                reload
                until dsks_submn; do : ; done
            fi
            if [[ "${parttable}" == "gpt" ]]; then
                msg "Disk GPT OK"
            elif [[ "${parttable}" != "gpt" && -z "${install}" ]]; then
                err "No GPT detected on selected disk"
            fi
            ask "Make a Selection"
            NC "\n\n            [1]  Create new GPT on selected disk [Destroy any existing GPT/MBR structures]\n\n            [2]  Use the 'gdisk' program interactively [Expert Mode]\n\n            [ ]  Return to Previous Menu"
            get "Enter a number"
            read -r -p "==> " gptslct
            if [[ "${gptslct}" == "1" ]]; then
                sgdisk -Z "${gptdrive}" > "${void}" &&
                sgdisk -o "${gptdrive}" > "${void}" &&
                parttable="$(fdisk -l "${gptdrive}" 2> "${void}" | grep '^Disklabel type' | awk "{print \$3}")"
                if [[ "${parttable}" == "gpt" ]]; then
                    multibooting="n"
                    nowarning="y"
                    gptok="yes"
                    local prompt="GPT"
                    ok
                    if [[ "${install}" == "yes" ]]; then
                        until instl_dsk; do : ; done
                        return 0
                    else
                        until dsks_submn; do : ; done
                        return 0
                    fi
                else
                    gptok="no"
                    err "No GPT detected on selected disk"
                    reload
                    return 1
                fi
            elif [[ "${gptslct}" == "2" ]]; then
                ack "Type ${nc}'?'${yellow} for help, ${nc}'x'${yellow} for extra functionality or ${nc}'q'${yellow} to quit"
                NC "\n_______________________________________________\n"
                gdisk "${gptdrive}"
                parttable="$(fdisk -l "${gptdrive}" 2> "${void}" | grep '^Disklabel type' | awk "{print \$3}")"
                if [[ "${parttable}" == "gpt" ]]; then
                    multibooting="n"
                    nowarning="y"
                    gptok="yes"
                    local prompt="GPT"
                    ok
                    if [[ "${install}" == "yes" ]]; then
                        until instl_dsk; do : ; done
                        return 0
                    else
                        until dsks_submn; do : ; done
                        return 0
                    fi
                else
                    gptok="no"
                    err "No GPT detected on selected disk"
                    reload
                    return 1
                fi
            elif [[ -z "${gptslct}" ]]; then
                if [[ -n "${instl_drive}" ]]; then
                    gptabort="yes"
                    skip
                    ok
                    printf "\n\n"
                    until instl_dsk; do : ; done
                    return 0
                elif [[ -z "${instl_drive}" ]]; then
                    reload
                    return 1
                fi
            else
                invalid
                return 1
            fi
        else
            invalid
            return 1
        fi
    done
}
ask_multibooting() {
        [[ "${multibooting}" == "n" ]] && return 0
        local prompt="MultiBoot Status"
        title "${prompt}"
        ask "Are you ${nc}Dual${yellow}/${nc}Multi-Booting ${yellow}with other OS's ? [y/n]"
        CYAN "\n\n        * ${nc}If ${yellowl}[y]${nc}es, then:${cyan}\n\n        >>  ${nc}Your ${yellowl}EFI ${nc}System Partition (ESP) will stay ${yellowl}intact${nc}${cyan}\n\n        >>  ${nc}Only ${yellowl}Manual ${nc}Disk Partitioning will be available for ${yellowl}Disk Management"
        get "Enter [y/n]"
        read -r -p "==> " multibooting
        multibooting="${multibooting,,}"
    case "${multibooting}" in
        y)
            ack "Dual/Multi-Boot selected" ;;
        n)
            ack "No Dual/Multi-Boot" ;;
       "")
            y_n
            return 1 ;;
        *)
            invalid
            return 1 ;;
    esac
        ok
}
part_mngr() {
    if [[ "${multibooting}" == "y" ]]; then
        until manual_part; do : ; done
        return 0
    fi
        title "Partition Manager"
        ask "Select a Mode"
        NC "\n\n            [1]  Automatic Partitioning\n\n            [2]  Manual Partitioning"
        get "Enter a number"
        read -r -p "==> " part_mode
    case "${part_mode}" in
        1)
            until auto_part; do : ; done ;;
        2)
            until manual_part; do : ; done ;;
       "")
            err "Please select a Mode"
            reload
            return 1 ;;
        *)
            invalid
            return 1 ;;
    esac
}
auto_part() {
        title "Automatic Partitioning"
    if [[ -e "${instl_drive}" ]]; then
        if [[ -z "${nowarning}" ]]; then
            delete
        fi
        if [[ "${run_as}" != "root" ]]; then
            err "Root Privileges Missing.."
            reload
            until main_menu; do : ; done
            return 0
        fi
        sgdsk_nmbr="${instl_dsk_nmbr}"
        sgdrive="$(echo "${disks}" | awk "\$1 == ${sgdsk_nmbr} {print \$2}")"
        capacity="$(fdisk -l "${sgdrive}" | grep -E 'bytes' | grep -E 'Disk' | awk "{print \$5}")"
        cap_gib="$((capacity/1024000000))"
        rootsize="$((capacity*25/100/1024000000))"
        inf "${nc}Apply ${yellowl}'Smart Partitioning' ${nc}on disk ${bwhite}'${instl_drive}'${nc} ? ${cyan}[Y/n]"
        get "Enter [Y/n]"
        read -r -p "==> " smartpart
        smartpart="${smartpart:-y}"
        smartpart="${smartpart,,}"
        if [[ "${smartpart}" == "y" ]]; then
            until smart_presets; do : ; done
            until set_partsize; do : ; done
            until partitioner; do : ; done
            return 0
        elif [[ "${smartpart}" == "n" ]]; then
            inf "Providing ${yellowl}alternatives${nc}.."
            until manual_presets; do : ; done
            until set_partsize; do : ; done
            until partitioner; do : ; done
            return 0
        else
            y_n
            return 1
        fi
    else
        ask "Select a disk for Auto-Partitioning"
        NC "\n\n${disks}"
        get "Enter a disk number ${bwhite}(empty to skip)"
        read -r -p "==> " sgdsk_nmbr
        if [[ -n "${sgdsk_nmbr}" ]]; then
            if [[ "${run_as}" != "root" ]]; then
                err "Root Privileges Missing.."
                reload
                until dsks_submn; do : ; done
                return 0
            fi
            sgdrive="$(echo "${disks}" | awk "\$1 == ${sgdsk_nmbr} {print \$2}")"
            if [[ -e "${sgdrive}" ]]; then
                capacity="$(fdisk -l "${sgdrive}" | grep -E 'bytes' | grep -E 'Disk' | awk "{print \$5}")"
                cap_gib="$((capacity/1024000000))"
                rootsize="$((capacity*25/100/1024000000))"
                until manual_presets; do : ; done
                until set_partsize; do : ; done
                until partitioner; do : ; done
            else
                invalid
                return 1
            fi
        else
            skip
            local prompt="Partition Manager"
            ok
        fi
    fi
    if [[ -z "${sanity}" ]]; then
        until dsks_submn; do : ; done
        return 0
    fi
}
smart_presets() {
    if [[ "${fs}" == "1" ]] ; then
        if [[ "${sep_home}" == "y" && "${swapmode}" == "1" ]]; then
            preset="4"
        elif [[ "${sep_home}" == "y" && "${swapmode}" != "1" ]]; then
            preset="3"
        elif [[ "${sep_home}" == "n" && "${swapmode}" == "1" ]]; then
            preset="2"
        elif [[ "${sep_home}" == "n" && "${swapmode}" != "1" ]]; then
            preset="1"
        fi
    elif [[ "${fs}" == "2" ]]; then
        if [[ "${swapmode}" == "1" ]]; then
            preset="2"
        elif [[ "${swapmode}" != "1" ]]; then
            preset="1"
        fi
    fi
}
manual_presets() {
        preset=""
        title "Preset Selection"
    if [[ -z "${nowarning}" ]]; then
        delete
    fi
        ask "Select a Partition Layout Preset"
        NC "\n\n          ${cyan}* Ext4${nc} compatible layout\n\n          ${magenta}* Btrfs${nc} compatible layout"
        NC "\n\n            [1]  Create ESP & /Root                            (${cyan}Ext4${nc},${magenta}Btrfs${nc})\n\n            [2]  Create ESP, /Root & /Swap                     (${cyan}Ext4${nc},${magenta}Btrfs${nc})\n\n            [3]  Create ESP, /Root & /Home                     (${cyan}Ext4${nc})\n\n            [4]  Create ESP, /Root, /Home & /Swap              (${cyan}Ext4${nc})"
        get "Enter a Preset number ${bwhite}(empty to skip)"
        read -r -p "==> " preset
    if [[ "${preset}" =~ ^(1|2|3|4)$ ]]; then
        presetpart="y"
        return 0
    elif [[ -z "${preset}" && "${partok}" == "n" ]]; then
        inf "Providing ${yellowl}alternatives${nc}.."
        manual_part
        return 0
    elif [[ -z "${preset}" ]]; then
        skip
        return 0
    else
        invalid
        return 1
    fi
}
set_partsize() {
       [[ "${partok}" == "y" ]] && return 0
    if [[ "${preset}" =~ ^(3|4)$ ]]; then
        sleep 0.2
        CYAN "\n\n\n        ###  ${nc}Total detected capacity of disk ${yellowl}${sgdrive} ${nc}is ${bwhite}${cap_gib} ${nc}GiB${cyan}\n\n\n        ###  ${bwhite}Default ${nc}Root partition's size is set to aprox. ${yellowl}25%${nc} of total disk capacity${cyan}\n\n        ###  ${nc}Root partition's ${bwhite}current ${nc}size will be ${yellowl}[${rootsize} GiB]${nc}"
        ask "Adjust Root Partition's size (by setting a custom ${nc}% ${yellow}value) ?"
        get "Enter ${nc}% ${blue}value ${nc}eg. 40 ${bwhite}(empty to skip)"
        read -r -p "==> " prcnt
        if [[ "${prcnt}" =~ [[:alpha:]] ]]; then
            err "Please use only digits as a value"
            reload
            return 1
        elif [[ -z "${prcnt}" ]]; then
            ack "Default Root Partition's size selected  ${nc}[${rootsize} GiB]"
        elif [[ "${prcnt}" -gt "0" && "${prcnt}" -lt "100" ]]; then
            rootsize="$((capacity*"${prcnt}"/100/1024000000))"
            ack "Custom Root Partition's size selected  ${nc}[${rootsize} GiB]"
        elif [[ "${prcnt}" == "100" ]]; then
            err "${yellow}WARNING: ${nc}No space left for other partitions.."
            reload
            return 1
        else
            invalid
            return 1
        fi
    fi
}
partitioner() {
        [[ "${partok}" == "y" ]] && return 0
    if [[ -z "${preset}" && "${install}" == "yes" ]]; then
        until sanity_check; do : ; done
        return 0
    elif [[ -z "${preset}" ]]; then
        local prompt="Partition Manager"
        ok
        return 0
    fi
    if [[ "${smartpart}" == "y" ]]; then
        local prompt="Disk ${sgdrive} Smart-Partitioned"
    elif [[ "${presetpart}" == "y" ]]; then
        local prompt="Disk ${sgdrive} Preset-Partitioned"
    fi
        local stage_prompt="Partitioning Drive"
        wipefs -afq "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
    if [[ "${gptok}" != "yes" ]]; then
        sgdisk -Z "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
        sgdisk -o "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
        gptok="yes"
    fi
    if [[ "${preset}" == "1" ]]; then
        sgdisk -I -n1:0:+1024M -t1:ef00 -c1:ESP "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
        sgdisk -I -n2:0:0 -t2:8304 -c2:ROOT "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
        partprobe "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
    elif [[ "${preset}" == "2" ]]; then
        until set_swapsize; do : ; done
        sgdisk -I -n1:0:+1024M -t1:ef00 -c1:ESP "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
        sgdisk -I -n2:0:+"${swapsize}"G -t2:8200 -c2:SWAP "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
        sgdisk -I -n3:0:0 -t3:8304 -c3:ROOT "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
        partprobe "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
    elif [[ "${preset}" == "3" ]]; then
        sgdisk -I -n1:0:+1024M -t1:ef00 -c1:ESP "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
        sgdisk -I -n2:0:+"${rootsize}"G -t2:8304 -c2:ROOT "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
        sgdisk -I -n3:0:0 -t3:8302 -c3:HOME "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
        partprobe "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
    elif [[ "${preset}" == "4" ]]; then
        until set_swapsize; do : ; done
        sgdisk -I -n1:0:+1024M -t1:ef00 -c1:ESP "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
        sgdisk -I -n2:0:+"${swapsize}"G -t2:8200 -c2:SWAP "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
        sgdisk -I -n3:0:+"${rootsize}"G -t3:8304 -c3:ROOT "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
        sgdisk -I -n4:0:0 -t4:8302 -c4:HOME "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
        partprobe "${sgdrive}" > "${void}" 2> "${log}" || stage_fail
    fi
    if [[ "${install}" == "yes" ]]; then
        until sanity_check; do : ; done
    else
        ok
    fi
}
manual_part() {
        title "Manual Partitioning"
        cgdsk_nmbr=" "
    while [[ -n "${cgdsk_nmbr}" ]]; do
        printf "\n\n"
        NC "                           Supported Partition Types & Mountpoints: "
        printf "\n\n\n"
        RED     "    Linux Root x86-64 Partition  ${nc}    [ GUID Code: 8304 ]            ${red}Mountpoint:  ${nc}/\n"
        BLUE    "    EFI System Partition  ${nc}           [ GUID Code: ef00 ]            ${blue}Mountpoint:  ${nc}/efi or /boot\n"
        GREEN   "    Linux Home Partition  ${nc}           [ GUID Code: 8302 ]            ${green}Mountpoint:  ${nc}/home\n"
        YELLOW  "    Linux Swap Partition  ${nc}           [ GUID Code: 8200 ]            ${yellow}Mountpoint:  ${nc}/swap\n"
        MAGENTA "    Linux Extended Boot Partition  ${nc}  [ GUID Code: ea00 ]            ${magenta}Mountpoint:  ${nc}/boot\n"
        ask "Select a disk to Manage"
        NC "\n\n${disks}"
        get "Enter a disk number ${bwhite}(empty to skip)"
        read -r -p "==> " cgdsk_nmbr
        if [[ -n "${cgdsk_nmbr}" ]]; then
            cgdrive="$(echo "${disks}" | awk "\$1 == ${cgdsk_nmbr} {print \$2}")"
            if [[ -e "${cgdrive}" ]]; then
                local prompt="Disk ${cgdrive}"
                if [[ "${run_as}" != "root" ]]; then
                    err "Root Privileges Missing.."
                    reload
                    until dsks_submn; do : ; done
                fi
                cgdisk "${cgdrive}"
                clear
                ok
                partprobe "${cgdrive}" > "${void}"
            else
                invalid
                return 1
            fi
        else
            skip
            local prompt="Partition Manager"
            ok
            if [[ -z "${sanity}" ]]; then
                until dsks_submn; do : ; done
                return 0
            elif [[ "${sanity}" == "no" || "${partok}" == "n" ]]; then
                until sanity_check; do : ; done
                return 0
            fi
        fi
    done
}
instl_dsk() {
    if [[ ! -e "${instl_drive}" ]]; then
        title "Installation Disk Selection"
        ask "Select a disk to Install to"
        NC "\n\n${disks}"
        get "Enter a disk number"
        read -r -p "==> " instl_dsk_nmbr
    fi
    if [[ -n "${instl_dsk_nmbr}" ]]; then
        instl_drive="$(echo "${disks}" | awk "\$1 == ${instl_dsk_nmbr} {print \$2}")"
        if [[ -e "${instl_drive}" ]]; then
            if [[ "${run_as}" != "root" ]]; then
                err "Root Privileges Missing.."
                reload
                until main_menu; do : ; done
                return 0
            fi
            volumes="$(fdisk -l | grep '^/dev' | cat --number)"
            rota="$(lsblk "${instl_drive}" --nodeps --noheadings --output=rota | awk "{print \$1}")"
            if [[ "${rota}" == "0" ]]; then
                sbvl_mnt_opts="rw,noatime,compress=zstd:1,space_cache=v2"
                trim="fstrim.timer"
            else
                sbvl_mnt_opts="rw,noatime,compress=zstd,space_cache=v2"
            fi
            parttable="$(fdisk -l "${instl_drive}" | grep '^Disklabel type' | awk "{print \$3}")"
            if [[ "${parttable}" != "gpt" && -n "${gptabort}" ]]; then
                err "Please create GPT to continue"
                reload
                until gpt_mngr; do : ; done
                return 0
            elif [[ "${parttable}" != "gpt" ]]; then
                err "No GPT detected on selected disk"
                reload
                until gpt_mngr; do : ; done
                return 0
            fi
            if [[ -z "${multibooting}" ]]; then
                until ask_multibooting; do : ; done
            fi
            until sanity_check; do : ; done
            return 0
        else
            invalid
            return 1
        fi
    else
        err "Please select Installation Disk"
        reload
        return 1
    fi
}
sanity_check() {
        rootcount="$(fdisk -l "${instl_drive}" | grep -E -c 'root' | awk "{print \$1}")"
        root_dev="$(fdisk -l "${instl_drive}" | grep -E 'root' | awk "{print \$1}")"
        multi_root="$(fdisk -l "${instl_drive}" | grep -E 'root' | awk "{print \$1}" | cat --number)"
        root_comply="$(fdisk -l "${instl_drive}" | grep -E 'root' | awk "{print \$1}" | cat --number | grep -E '1[[:blank:]]' | awk "{print \$2}")"
        espcount="$(fdisk -l "${instl_drive}" | grep -E -c 'EFI' | awk "{print \$1}")"
        esp_dev="$(fdisk -l "${instl_drive}" | grep -E 'EFI' | awk "{print \$1}")"
        multi_esp="$(fdisk -l "${instl_drive}" | grep -E 'EFI' | awk "{print \$1}" | cat --number)"
        esp_comply="$(fdisk -l "${instl_drive}" | grep -E 'EFI' | awk "{print \$1}" | cat --number | grep -E '1[[:blank:]]' | awk "{print \$2}")"
        xbootcount="$(fdisk -l "${instl_drive}" | grep -E -c 'extended' | awk "{print \$1}")"
        xboot_dev="$(fdisk -l "${instl_drive}" | grep -E 'extended' | awk "{print \$1}")"
        multi_xboot="$(fdisk -l "${instl_drive}" | grep -E 'extended' | awk "{print \$1}" | cat --number)"
        xboot_comply="$(fdisk -l "${instl_drive}" | grep -E 'extended' | awk "{print \$1}" | cat --number | grep -E '1[[:blank:]]' | awk "{print \$2}")"
        homecount="$(fdisk -l "${instl_drive}" | grep -E -c 'home' | awk "{print \$1}")"
        home_dev="$(fdisk -l "${instl_drive}" | grep -E 'home' | awk "{print \$1}")"
        multi_home="$(fdisk -l "${instl_drive}" | grep -E 'home' | awk "{print \$1}" | cat --number)"
        home_comply="$(fdisk -l "${instl_drive}" | grep -E 'home' | awk "{print \$1}" | cat --number | grep -E '1[[:blank:]]' | awk "{print \$2}")"
        swapcount="$(fdisk -l "${instl_drive}" | grep -E -c 'swap' | awk "{print \$1}")"
        swap_dev="$(fdisk -l "${instl_drive}" | grep -E 'swap' | awk "{print \$1}")"
        multi_swap="$(fdisk -l "${instl_drive}" | grep -E 'swap' | awk "{print \$1}" | cat --number)"
        swap_comply="$(fdisk -l "${instl_drive}" | grep -E 'swap' | awk "{print \$1}" | cat --number | grep -E '1[[:blank:]]' | awk "{print \$2}")"
        rootprt=""
        espprt=""
        xbootprt=""
        homeprt=""
        swapprt=""
        title "Sanity Check"
        [[ "${rootcount}" == "1" || "${espcount}" == "1" || "${xbootcount}" == "1" || "${homecount}" == "1" || "${swapcount}" == "1" ]] && echo
        # ATTENTION: MULTI-ROOT
    if [[ "${rootcount}" -gt "1" ]]; then
        local color="${greenl}"
        local type="Linux x86-64 /Root"
        local multi_type="${multi_root}"
        local type_comply="${root_comply}"
        local length="${#root_dev}"
        dashes="$(printf '%*s' "$length" '' | tr ' ' '-')"
        local dashline="${nc}${dashes}"
        action="${red}[!] ${bwhite}FORMATTED ${nc}${red}[!]"
        multi_info
        get "Proceed ? [Y/n]"
        read -r -p "==> " autoroot
        autoroot="${autoroot:-y}"
        autoroot="${autoroot,,}"
        if [[ "${autoroot}" == "y" ]]; then
            root_dev="${root_comply}"
            multiroot_bootopts="root=PARTUUID=$(blkid -s PARTUUID -o value "${root_dev}")"
        elif [[ "${autoroot}" == "n" ]]; then
            until auto_part; do : ; done
            return 0
        else
            y_n
            return 1
        fi
    fi
        # ATTENTION: MULTI-ESP
    if [[ "${espcount}" -gt "1" ]]; then
        if [[ "${multibooting}" == "n" ]]; then
            action="${red}[!] ${bwhite}FORMATTED ${nc}${red}[!]"
        elif [[ "${multibooting}" == "y" ]]; then
            action="used in the installation"
        fi
        local color="${cyanl}"
        local type="EFI System"
        local multi_type="${multi_esp}"
        local type_comply="${esp_comply}"
        local length="${#esp_dev}"
        dashes="$(printf '%*s' "$length" '' | tr ' ' '-')"
        local dashline="${nc}${dashes}"
        multi_info
        get "Proceed ? [Y/n]"
        read -r -p "==> " autoesp
        autoesp="${autoesp:-y}"
        autoesp="${autoesp,,}"
        if [[ "${autoesp}" == "y" ]]; then
            esp_dev="${esp_comply}"
        elif [[ "${autoesp}" == "n" ]]; then
            until auto_part; do : ; done
            return 0
        else
            y_n
            return 1
        fi
    fi
        # ATTENTION: MULTI-XBOOTLDR
    if [[ "${xbootcount}" -gt "1" ]]; then
        espsize="$(lsblk -dno SIZE --bytes "${esp_dev}")"
        if [[ -e "${esp_dev}" && "${espsize}" -lt "209715200" ]]; then
            if [[ "${bootloader}" == "1" && "${multibooting}" == "y" ]]; then
                local color="${redl}"
                local type="Linux Extended Boot"
                local multi_type="${multi_xboot}"
                local type_comply="${xboot_comply}"
                local length="${#xboot_dev}"
                dashes="$(printf '%*s' "$length" '' | tr ' ' '-')"
                local dashline="${nc}${dashes}"
                action="${red}[!] ${bwhite}FORMATTED ${nc}${red}[!]"
                multi_info
                get "Proceed ? [Y/n]"
                read -r -p "==> " autoxboot
                autoxboot="${autoxboot:-y}"
                autoxboot="${autoxboot,,}"
                if [[ "${autoxboot}" == "y" ]]; then
                    xboot_dev="${xboot_comply}"
                elif [[ "${autoxboot}" == "n" ]]; then
                    until auto_part; do : ; done
                    return 0
                else
                    y_n
                    return 1
                fi
            fi
        fi
    fi
        # ATTENTION: MULTI-HOME
    if [[ "${fs}" == "1" && "${sep_home}" == "y" && "${homecount}" -gt "1" ]]; then
        local color="${magental}"
        local type="Linux /Home"
        local multi_type="${multi_home}"
        local type_comply="${home_comply}"
        local length="${#home_dev}"
        dashes="$(printf '%*s' "$length" '' | tr ' ' '-')"
        local dashline="${nc}${dashes}"
        action="used in the installation"
        multi_info
        get "Proceed ? [Y/n]"
        read -r -p "==> " autohome
        autohome="${autohome:-y}"
        autohome="${autohome,,}"
        if [[ "${autohome}" == "y" ]]; then
            home_dev="${home_comply}"
        elif [[ "${autohome}" == "n" ]]; then
            until auto_part; do : ; done
            return 0
        else
            y_n
            return 1
        fi
    fi
        # ATTENTION: MULTI-SWAP
    if [[ "${swapmode}" == "1" && "${swapcount}" -gt "1" ]]; then
        local color="${yellowl}"
        local type="Linux /Swap"
        local multi_type="${multi_swap}"
        local type_comply="${swap_comply}"
        local length="${#swap_dev}"
        dashes="$(printf '%*s' "$length" '' | tr ' ' '-')"
        local dashline="${nc}${dashes}"
        action="${red}[!] ${bwhite}FORMATTED ${nc}${red}[!]"
        multi_info
        get "Proceed ? [Y/n]"
        read -r -p "==> " autoswap
        autoswap="${autoswap:-y}"
        autoswap="${autoswap,,}"
        if [[ "${autoswap}" == "y" ]]; then
            swap_dev="${swap_comply}"
        elif [[ "${autoswap}" == "n" ]]; then
            until auto_part; do : ; done
            return 0
        else
            y_n
            return 1
        fi
    fi
        # ATTENTION: ROOT
    if [[ -e "${root_dev}" ]]; then
        rootpartsize="$(lsblk -dno SIZE --bytes "${root_dev}")"
        if [[ "${rootpartsize}" -ge "8589934592" ]]; then
            rootprt="ok"
        else
            rootprt="ok"
            sleep 0.2
            CYAN "\n        >>  ${yellowl}WARNING: ${nc}/Root's size might not be adequate"
            sleep 0.2
            CYAN "\n        >>  ${nc}Depending on the ${yellowl}size ${nc}of your setup, installation might ${yellowl}fail\n"
            keypress
        fi
        if [[ "${autoroot}" == "y" ]]; then
            if [[ "${presetpart}" == "y" || "${smartpart}" == "y" ]]; then
                rootprt="ok"
                sleep 0.2
                GREEN "\n        >>  ${nc}Linux x86-64 /Root partition ${green}OK"
            else
                rootprt="ok"
                sleep 0.2
                GREEN "\n        >>  ${yellowl}Confirmed ${nc}Linux x86-64 /Root partition ${green}OK"
            fi
        else
            sleep 0.2
            rootprt="ok"
            GREEN "\n        >>  ${nc}Linux x86-64 /Root partition ${green}OK"
        fi
    else
        rootprt="fail"
        sleep 0.2
        RED "\n        >>  ${yellowl}Linux x86-64 /Root ${nc}partition not detected"
    fi
        # ATTENTION: ESP
    if [[ ! -e "${esp_dev}" ]]; then
        espprt="fail"
        sleep 0.2
        RED "\n        >>  ${yellowl}/EFI System ${nc}partition not detected"
    fi
    if [[ -e "${esp_dev}" ]]; then
        espsize="$(lsblk -dno SIZE --bytes "${esp_dev}")"
    fi
    if [[ -e "${esp_dev}" && "${espsize}" -ge "209715200" ]]; then
        espprt="ok"
        xbootloader="no"
        if [[ "${autoesp}" == "y" ]]; then
            if [[ "${presetpart}" == "y" || "${smartpart}" == "y" ]]; then
                espprt="ok"
                sleep 0.2
                GREEN "\n        >>  ${nc}/EFI System partition ${green}OK"
            else
                espprt="ok"
                sleep 0.2
                GREEN "\n        >>  ${yellowl}Confirmed ${nc}/EFI System partition ${green}OK"
            fi
        else
            espprt="ok"
            sleep 0.2
            GREEN "\n        >>  ${nc}/EFI System partition ${green}OK"
        fi
    fi
    if [[ -e "${esp_dev}" && "${espsize}" -lt "209715200" ]]; then
        if [[ "${bootloader}" == "1" ]]; then
            if [[ "${multibooting}" == "y" ]]; then
                xbootloader="yes"
                if [[ -e "${xboot_dev}" ]]; then
                    xbootprt="ok"
                    espprt="ok"
                    if [[ "${autoesp}" == "y" ]]; then
                        if [[ "${presetpart}" == "y" || "${smartpart}" == "y" ]]; then
                            espprt="ok"
                            sleep 0.2
                            GREEN "\n        >>  ${nc}/EFI System partition ${green}OK"
                        else
                            espprt="ok"
                            sleep 0.2
                            GREEN "\n        >>  ${yellowl}Confirmed ${nc}/EFI System partition ${green}OK"
                        fi
                    else
                        espprt="ok"
                        sleep 0.2
                        GREEN "\n        >>  ${nc}/EFI System partition ${green}OK"
                    fi
                    if [[ "${autoxboot}" == "y" ]]; then
                        if [[ "${presetpart}" == "y" || "${smartpart}" == "y" ]]; then
                            sleep 0.2
                            GREEN "\n        >>  ${nc}Linux /Extended Boot partition ${green}OK"
                        else
                            sleep 0.2
                            GREEN "\n        >>  ${yellowl}Confirmed ${nc}Linux /Extended Boot partition ${green}OK"
                        fi
                    else
                        sleep 0.2
                        GREEN "\n        >>  ${nc}Linux /Extended Boot partition ${green}OK"
                    fi
                else
                    xbootprt="fail"
                    espprt="fail"
                    sleep 0.2
                    CYAN "\n        >>  ${yellowl}WARNING: ${nc}ESP's size is not ${bwhite}adequate"
                    sleep 0.2
                    RED "\n        >>  ${yellowl}Linux /Extended Boot ${nc}partition not detected"
                fi
            elif [[ "${multibooting}" == "n" ]]; then
                espprt="fail"
                xbootloader="no"
                sleep 0.2
                CYAN "\n        >>  ${yellowl}WARNING: ${nc}ESP's size is not ${bwhite}adequate"
            fi
        elif [[ "${bootloader}" == "2" ]]; then
            if [[ "${espmnt}" == "2" ]]; then
                espprt="fail"
                xbootloader="no"
                sleep 0.2
                CYAN "\n        >>  ${yellowl}WARNING: ${nc}ESP's size is not ${bwhite}adequate"
            elif [[ "${espmnt}" == "1" ]]; then
                espprt="ok"
                xbootloader="no"
                if [[ "${autoesp}" == "y" ]]; then
                    if [[ "${presetpart}" == "y" || "${smartpart}" == "y" ]]; then
                        sleep 0.2
                        GREEN "\n        >>  ${nc}/EFI System partition ${green}OK"
                    else
                        sleep 0.2
                        GREEN "\n        >>  ${yellowl}Confirmed ${nc}/EFI System partition ${green}OK"
                    fi
                else
                    sleep 0.2
                    GREEN "\n        >>  ${nc}/EFI System partition ${green}OK"
                fi
            fi
        fi
    fi
        # ATTENTION: HOME
    if [[ "${fs}" == "1" ]]; then
        if [[ "${sep_home}" == "y" ]]; then
            if [[ -e "${home_dev}" ]]; then
                homeprt="ok"
                if [[ "${autohome}" == "y" ]]; then
                    if [[ "${presetpart}" == "y" || "${smartpart}" == "y" ]]; then
                        sleep 0.2
                        GREEN "\n        >>  ${nc}Linux /Home partition ${green}OK"
                    else
                        sleep 0.2
                        GREEN "\n        >>  ${yellowl}Confirmed ${nc}Linux /Home partition ${green}OK"
                    fi
                else
                    GREEN "\n        >>  ${nc}Linux /Home partition ${green}OK"
                fi
            else
                homeprt="fail"
                sleep 0.2
                RED "\n        >>  ${yellowl}Linux /Home ${nc}partition not detected"
            fi
        fi
    fi
        # ATTENTION: SWAP
    if [[ "${swapmode}" == "1" ]]; then
        if [[ -e "${swap_dev}" ]]; then
            swapprt="ok"
            if [[ "${autoswap}" == "y" ]]; then
                if [[ "${presetpart}" == "y" || "${smartpart}" == "y" ]]; then
                    sleep 0.2
                    GREEN "\n        >>  ${nc}Linux /Swap partition ${green}OK"
                else
                    sleep 0.2
                    GREEN "\n        >>  ${yellowl}Confirmed ${nc}Linux /Swap partition ${green}OK"
                fi
            else
                sleep 0.2
                GREEN "\n        >>  ${nc}Linux /Swap partition ${green}OK"
            fi
        else
            swapprt="fail"
            sleep 0.2
            RED "\n        >>  ${yellowl}Linux /Swap ${nc}partition not detected"
        fi
    fi
    if [[ "${rootprt}" == "fail" || "${espprt}" == "fail" || "${xbootprt}" == "fail" || "${homeprt}" == "fail" || "${swapprt}" == "fail" ]]; then
        sanity="no"
    else
        sanity="ok"
    fi
        # ATTENTION: SANITY CHECK OK
    if [[ "${sanity}" == "ok" ]]; then
        if [[ "${smartpart}" == "y" ]]; then
            local prompt="Disk ${sgdrive} Smart-Partitioned"
            ok
        elif [[ "${presetpart}" == "y" ]]; then
            local prompt="Disk ${sgdrive} Preset-Partitioned"
            ok
        fi
        msg "SANITY CHECK OK"
        disk_overview
        get "Proceed using the ${nc}${cyan}current ${blue}partitioning layout ? [Y/n]"
        read -r -p "==> " partok
        partok="${partok:-y}"
        partok="${partok,,}"
        local prompt="Disk Partitioning"
        local stage_prompt="Partitioning"
        if [[ "${partok}" == "y" ]]; then
            ok
            return 0
        elif [[ "${partok}" == "n" ]]; then
            if [[ "${multibooting}" == "n" && "${hometype}" == "1" ]]; then
                reload
                until auto_part; do : ; done
                return 0
            elif [[ "${multibooting}" == "n" && "${hometype}" == "2" ]]; then
                reload
                until manual_part; do : ; done
                return 0
            elif [[ "${multibooting}" == "n" ]]; then
                reload
                until auto_part; do : ; done
                return 0
            elif [[ "${multibooting}" == "y" ]]; then
                reload
                until manual_part; do : ; done
                return 0
            fi
        else
            y_n
            return 1
        fi
        # ATTENTION; SANITY CHECK FAIL
    elif [[ "${sanity}" == "no" ]]; then
        err "SANITY CHECK FAILED"
        keypress
        if [[ "${multibooting}" == "y" ]]; then
            if [[ "${espprt}" == "fail" && -e "${esp_dev}" ]]; then
                sleep 0.2
                CYAN "\n        >>  ${yellowl}ESP: ${nc}Not all prerequisites are satisfied"
                if [[ "${espmnt}" == "2" ]]; then
                    sleep 0.2
                    CYAN "\n\n        >>  ${nc}Select ${yellowl}/mnt/efi ${nc}as the mountpoint for your ${yellowl}ESP"
                fi
                if [[ "${xbootprt}" == "fail" ]]; then
                    sleep 0.2
                    CYAN "\n\n        >>  ${yellowl}Systemd-boot:${nc}${cyan}\n\n        >>  ${nc}Create a ${yellowl}300M ${nc}(at minimum) Linux Extended Boot Partition ${bwhite}(XBOOTLDR) ${yellowl}[GUID CODE: ea00]\n"
                fi
                keypress
                if [[ "${espmnt}" == "2" ]]; then
                    until slct_espmnt; do : ; done
                fi
                if [[ "${xbootprt}" == "fail" ]]; then
                    until manual_part; do : ; done
                fi
            elif [[ "${espprt}" == "fail" && ! -e "${esp_dev}" ]]; then
                reload
                until manual_part; do : ; done
            elif [[ "${homeprt}" == "fail" || "${swapprt}" == "fail" ]]; then
                reload
                until manual_part; do : ; done
            fi
        elif [[ "${multibooting}" == "n" ]]; then
            if [[ -z "${hometype}" || "${hometype}" == "1" ]]; then
                reload
                until auto_part; do : ; done
            else
                reload
                until manual_part; do : ; done
            fi
        fi
    fi
}
ask_crypt() {
        local prompt="Encryption Setup"
        LuksArray=(Root)
        [[ "${hometype}" == "1" ]] && LuksArray+=(Home)
        [[ "${swapmode}" == "1" ]] && LuksArray+=(Swap)
        delimiter=""
        LuksParts=""
    for item in "${LuksArray[@]}"; do
        LuksParts="$LuksParts$delimiter$item"
        delimiter=","
    done
        title "Encryption Setup"
        ask "Utilize LUKS encryption for your system ?"
        NC "\n\n            * Type '${cyan}no${nc}' to proceed without encryption\n\n            * Type '${cyan}yes${nc}' to encrypt your ${yellowl}${LuksParts}\n"
        read -r -p "==> " encrypt
    if [[ "${encrypt}" == "no" ]]; then
        skip
        ok
        printf "\n\n"
        return 0
    elif [[ "${encrypt}" == "yes" ]]; then
        if [[ "${bootloader}" == "2" && "${espmnt}" == "1" ]]; then
            err "Incompatible Selection detected"
            ack "ESP cannot be mounted on ${nc}'/efi' ${yellow}when using Grub on a LUKS encrypted Root partition"
            ask "Change ESP mountpoint to ${nc}'/boot' ${yellow}instead ? [Y/n]"
            get "Enter [Y/n]"
            read -r -p "==> " cng_espmnt
            cng_espmnt="${cng_espmnt:-y}"
            cng_espmnt="${cng_espmnt,,}"
            if [[ "${cng_espmnt}" == "y" ]]; then
                espmnt="2"
                esp_mount="/mnt/boot"
                btldr_esp_mount="/boot"
                ack "'/mnt/boot' mountpoint has been selected"
            elif [[ "${cng_espmnt}" == "n" ]]; then
                failure
            else
                y_n
                return 1
            fi
        fi
        ask "Set your LUKS encryption password"
        get "Enter password"
        read -r -p "==> " CRYPTPASS
        sleep 0.2
        ask "Verify your LUKS encryption password"
        get "Re-enter password"
        read -r -p "==> " CRYPTPASS2
        if [[ "${CRYPTPASS}" != "${CRYPTPASS2}" ]]; then
            err "Passwords don't match. Please try again.."
            reload
            return 1
        fi
        ok
    else
        yes_no
        return 1
    fi
}
instl() {
        install="yes"
    if [[ -z "${lcl_slct}" ]]; then
        local stage_prompt="Locale & Keyboard Layout Selection"
        completion_err
        until slct_locale; do : ; done
        until slct_kbd; do : ; done
    fi
    if [[ -z "${USERNAME}" ]]; then
        local stage_prompt="User, Root User, Hostname & Shell Setup"
        completion_err
        until user_setup; do : ; done
        until rootuser_setup; do : ; done
        until slct_hostname; do : ; done
        until slct_shell; do : ; done
    fi
    if [[ -z "${kernelnmbr}" || "${revision}" == "y" ]]; then
        local stage_prompt="Kernel, Secure Boot Signing, Bootloader & ESP Mountpoint"
        completion_err
        until slct_krnl; do : ; done
        until ask_sign; do : ; done
        until slct_bootldr; do : ; done
        until slct_espmnt; do : ; done
    fi
    if [[ -z "${fs}" || "${revision}" == "y" ]]; then
        local stage_prompt="Filesystem & Swap Setup"
        completion_err
        until slct_fs; do : ; done
        until slct_swap; do : ; done
    fi
    if [[ "${vendor}" != "Virtual Machine" && -z "${gfx_slct}" ]] || [[ "${vendor}" != "Virtual Machine" && "${revision}" == "y" ]]; then
        local stage_prompt="Graphics Setup"
        completion_err
        until dtct_gfx; do : ; done
    fi
    if [[ -z "${desktop}" || "${revision}" == "y" ]]; then
        local stage_prompt="Desktop Setup"
        completion_err
        until dsktp_slct; do : ; done
    fi
    if [[ -z "${dev}" || "${revision}" == "y" ]]; then
        until base_devel; do : ; done
    fi
    if [[ -z "${web_slct}" || "${revision}" == "y" ]]; then
        if [[ ! "${desktop}" =~ ^(11|12)$ ]]; then
            until web_browser; do : ; done
        fi
    fi
    if [[ "${vendor}" != "Virtual Machine" ]]; then
        if [[ -z "${printer}" || "${revision}" == "y" ]]; then
            if [[ ! "${desktop}" =~ ^(11|12)$ ]]; then
                until print_scan; do : ; done
            fi
        fi
        if [[ -z "${efi_entr_del}" || "${revision}" == "y" ]]; then
            local stage_prompt="EFI Boot Entries Deletion"
            completion_err
            until boot_entr; do : ; done
        fi
    fi
    if [[ -z "${show_extopts}" ]]; then
        local stage_prompt="Extended Options"
        completion_err
        until display_ext_opt; do : ; done
        if [[ "${show_extopts}" == "y" ]]; then
            until cust_kern_param; do : ; done
            until sys_watchdog; do : ; done
            until sysoptm; do : ; done
            if [[ "${vendor}" != "Virtual Machine" ]]; then
                until ask_wireless_regdom; do : ; done
            fi
            until systemd_oomd; do : ; done
            until irqbalance; do : ; done
            until thermald; do : ; done
            until rngd; do : ; done
            until rtkit; do : ; done
            if [[ "${vendor}" != "Virtual Machine" ]]; then
                until tlp; do : ; done
            fi
        fi
    fi
        until instl_dsk; do : ; done
        until ask_crypt; do : ; done
    if [[ "${swapmode}" == "1" ]]; then
        until "${swaptype}"; do : ; done
    fi
    if [[ "${encrypt}" == "no" ]]; then
        until set_mode; do : ; done
    elif [[ "${encrypt}" == "yes" ]]; then
        until sec_erase; do : ; done
        until luks; do : ; done
    fi
        until opt_pcmn; do : ; done
        until pacstrap_system; do : ; done
        if [[ "${swapmode}" == "2" ]]; then
            until "${swaptype}"; do : ; done
        fi
        if [[ -n "${REGDOM}" ]]; then
            until set_wireless_regdom; do : ; done
        fi
        set_vars
        chroot_conf
}
swappart() {
    if [[ "${encrypt}" == "yes" ]]; then
        printf "\n\n"
    fi
        local prompt="Swap Partition Creation"
        local stage_prompt="Swap Partition Creation"
        sleep 0.2
        NC "\n${magenta}###${nc}----------------------------------${magenta}[ ${bwhite}Swap  Partition Setup${nc} ${magenta}]${nc}----------------------------------${magenta}###\n"
    if mkswap "${swap_dev}" > "${void}" 2> "${log}" ; then
        ok
    else
        stage_fail
    fi
}
set_mode() {
    if [[ "${rootcount}" -gt "1" || "${espcount}" -gt "1" || "${xbootcount}" -gt "1" || "${homecount}" -gt "1" || "${swapcount}" -gt "1" ]]; then
        until auto_mode; do : ; done
        local prompt="Filesystems"
        ok
        filesystem_overview
        return 0
    fi
        title "Mode Selection"
        ask "Select a Mode to continue"
        NC "\n\n            [1]  Auto     (Automatically Format, Label & Mount partitions)\n\n            [2]  Manual   (Manually Format, Label & Mount partitions)"
        get "Enter a Mode number"
        read -r -p "==> " setmode
    case "${setmode}" in
        1)
            until auto_mode; do : ; done ;;
        2)
            until manual_mode; do : ; done ;;
       "")
            err "Please select a Mode to continue"
            reload
            return 1 ;;
        *)
            invalid
            return 1 ;;
    esac
        local prompt="Filesystems"
        ok
        filesystem_overview
}
auto_mode() {
    if [[ "${swapmode}" == "1" ]]; then
        printf "\n\n"
    fi
        espfs="$(lsblk -dno FSTYPE "${esp_dev}")"
        sleep 0.2
        NC "\n${magenta}###${nc}----------------------------------------${magenta}[ ${bwhite}Auto Mode${nc} ${magenta}]${nc}----------------------------------------${magenta}###\n"
        sleep 0.2
        YELLOW "\n\n        >  Auto Mode Selected\n\n"
    if [[ "${fs}" == "1" ]]; then
        [[ "$revision" == "y" ]] && wipefs -t btrfs -f "${root_dev}" > "${void}" 2> "${log}"
        if mkfs.ext4 -F -L Root "${root_dev}" > "${void}" 2> "${log}" ; then
            tune2fs -O fast_commit "${root_dev}" > "${void}" 2> "${log}" || err_abort
            udevadm trigger --subsystem-match=block --action=change || err_abort
            mount "${root_dev}" /mnt > "${void}" 2> "${log}" || err_abort
            sleep 0.2
            NC "\n==> [${green}/Root OK${nc}]"
        else
            umount_manual
            until form_root; do : ; done
            until mount_mnt; do : ; done
        fi
    elif [[ "${fs}" == "2" ]]; then
        [[ "$revision" == "y" ]] && wipefs -t ext4 -f "${root_dev}" > "${void}" 2> "${log}"
        if mkfs.btrfs -f -L Root "${root_dev}" > "${void}" 2> "${log}" ; then
            udevadm trigger --subsystem-match=block --action=change || err_abort
            mount "${root_dev}" /mnt > "${void}" 2> "${log}" || err_abort
            btrfs subvolume create /mnt/@ > "${void}" 2> "${log}" || err_abort
            btrfs subvolume create /mnt/@home > "${void}" 2> "${log}" || err_abort
            btrfs subvolume create /mnt/@cache > "${void}" 2> "${log}" || err_abort
            btrfs subvolume create /mnt/@log > "${void}" 2> "${log}" || err_abort
            btrfs subvolume create /mnt/@tmp > "${void}" 2> "${log}" || err_abort
            btrfs subvolume create /mnt/@snapshots > "${void}" 2> "${log}" || err_abort
            if [[ "${swapmode}" == "2" ]]; then
                btrfs subvolume create /mnt/@swap > "${void}" 2> "${log}" || err_abort
            fi
            umount /mnt > "${void}" 2> "${log}" || err_abort
            mount -o "${sbvl_mnt_opts}",subvol=@ "${root_dev}" /mnt > "${void}" 2> "${log}" || err_abort
            mount --mkdir -o "${sbvl_mnt_opts}",subvol=@home "${root_dev}" /mnt/home > "${void}" 2> "${log}" || err_abort
            mount --mkdir -o "${sbvl_mnt_opts}",subvol=@cache "${root_dev}" /mnt/var/cache > "${void}" 2> "${log}" || err_abort
            mount --mkdir -o "${sbvl_mnt_opts}",subvol=@log "${root_dev}" /mnt/var/log > "${void}" 2> "${log}" || err_abort
            mount --mkdir -o "${sbvl_mnt_opts}",subvol=@tmp "${root_dev}" /mnt/var/tmp > "${void}" 2> "${log}" || err_abort
            mount --mkdir -o "${sbvl_mnt_opts}",subvol=@snapshots "${root_dev}" /mnt/"${snapname}" > "${void}" 2> "${log}" || err_abort
            if [[ "${swapmode}" == "2" ]]; then
                mount --mkdir -o "${sbvl_mnt_opts}",subvol=@swap "${root_dev}" /mnt/swap > "${void}" 2> "${log}" || err_abort
            fi
            sleep 0.2
            NC "\n==> [${green}/@ OK${nc}]"
        else
            umount_manual
            until form_root; do : ; done
            until mount_mnt; do : ; done
        fi
    fi
        sleep 0.2
    if [[ "${multibooting}" == "n" ]]; then
        if mkfs.fat -F 32 -n ESP "${esp_dev}" > "${void}" 2> "${log}" ; then
            mount --mkdir "${esp_dev}" "${esp_mount}" > "${void}" 2> "${log}" || err_abort
            sleep 0.2
            NC "\n==> [${green}/ESP OK${nc}]"
        else
            umount_manual
            until form_esp; do : ; done
            until mount_mnt; do : ; done
            until mount_esp; do : ; done
        fi
    elif [[ "${multibooting}" == "y" && "${espfs}" == "vfat" ]]; then
        if mount --mkdir "${esp_dev}" "${esp_mount}" > "${void}" 2> "${log}" ; then
            sleep 0.2
            NC "\n==> [${green}Unformatted /ESP Mounted OK${nc}]"
        else
            umount_manual
            until mount_mnt; do : ; done
            until mount_esp; do : ; done
        fi
    elif [[ "${multibooting}" == "y" && "${espfs}" != "vfat" ]]; then
        if mkfs.fat -F 32 -n ESP "${esp_dev}" > "${void}" 2> "${log}" ; then
            mount --mkdir "${esp_dev}" "${esp_mount}" > "${void}" 2> "${log}" || err_abort
            sleep 0.2
            NC "\n==> [${green}/ESP OK${nc}]"
        else
            umount_manual
            until form_esp; do : ; done
            until mount_mnt; do : ; done
            until mount_esp; do : ; done
        fi
    fi
        sleep 0.2
    if [[ "${xbootloader}" == "yes" ]]; then
        if mkfs.fat -F 32 -n XBOOTLDR "${xboot_dev}" > "${void}" 2> "${log}" ; then
            mount --mkdir "${xboot_dev}" /mnt/boot > "${void}" 2> "${log}" || err_abort
            sleep 0.2
            NC "\n==> [${green}/XBOOTLDR OK${nc}]"
        else
            umount_manual
            until form_xboot; do : ; done
            until mount_mnt; do : ; done
            until mount_esp; do : ; done
            until mount_xboot; do : ; done
        fi
    fi
        sleep 0.2
    if [[ "${fs}" == "1" && -e "${home_dev}" && "${sep_home}" == "y" ]]; then
        if [[ "${smartpart}" == "y" ]]; then
            homeform="y"
        elif [[ "${preset}" =~ ^(3|4)$ ]]; then
            homeform="y"
        elif [[ "${hometype}" == "1" ]]; then
            homeform="y"
        elif [[ "${hometype}" == "2" ]]; then
            homeform="n"
        fi
        if [[ "${homeform}" == "y" ]]; then
            [[ "$revision" == "y" ]] && wipefs -t btrfs -f "${home_dev}" > "${void}" 2> "${log}"
            if mkfs.ext4 -F -L Home "${home_dev}" > "${void}" 2> "${log}" ; then
                tune2fs -O fast_commit "${home_dev}" > "${void}" 2> "${log}" || err_abort
                udevadm trigger --subsystem-match=block --action=change || err_abort
                mount --mkdir "${home_dev}" /mnt/home > "${void}" 2> "${log}" || err_abort
                sleep 0.2
                NC "\n==> [${green}/Home OK${nc}]"
            else
                umount_manual
                until manual_part; do : ; done
                until form_home; do : ; done
                until mount_mnt; do : ; done
                until mount_esp; do : ; done
                if [[ "${xbootloader}" == "yes" ]]; then
                    until mount_xboot; do : ; done
                fi
                until mount_home; do : ; done
            fi
        elif [[ "${homeform}" == "n" ]]; then
            mount --mkdir "${home_dev}" /mnt/home > "${void}" 2> "${log}" || err_abort
            sleep 0.2
            NC "\n==> [${green}Unformatted /Home Mounted OK${nc}]"
        fi
    fi
        keypress
}
manual_mode() {
        volumes="$(fdisk -l | grep '^/dev' | cat --number)"
    if [[ "${multibooting}" == "no" ]]; then
        until form_esp; do : ; done
    fi
    if [[ "${xbootloader}" == "yes" ]]; then
        until form_xboot; do : ; done
    fi
        until form_root; do : ; done
    if [[ "${sep_home}" == "y" && "${hometype}" == "1" ]]; then
        until form_home; do : ; done
    fi
        until mount_mnt; do : ; done
        until mount_esp; do : ; done
    if [[ "${xbootloader}" == "yes" ]]; then
        until mount_xboot; do : ; done
    fi
    if [[ "${sep_home}" == "y" ]]; then
        until mount_home; do : ; done
    fi
}
form_esp() {
        title "Format EFI System Partition"
        form_esp_nmbr=" "
    while [[ -n "${form_esp_nmbr}" ]]; do
        ask "Select an EFI System Partition to format as ${nc}vfat"
        NC "\n\n\n${volumes}"
        get "Enter a partition number"
        read -r -p "==> " form_esp_nmbr
        if [[ -n "${form_esp_nmbr}" ]]; then
            esppart="$(echo "${volumes}" | awk "\$1 == ${form_esp_nmbr} {print \$2}")"
            manespfs="$(lsblk -dno FSTYPE "${esppart}" 2> "${void}")"
            if [[ -e "${esppart}" ]]; then
                if [[ "${multibooting}" == "n" ]]; then
                    if mkfs.fat -F 32 -n ESP "${esppart}" > "${void}" 2> "${log}" ; then
                        local prompt="Format & Label /ESP"
                        ok
                        return 0
                    else
                        do_umount
                        until manual_part; do : ; done
                        until form_esp; do : ; done
                        return 0
                    fi
                elif [[ "${multibooting}" == "y" && "${manespfs}" == "vfat" ]]; then
                    local prompt="Unformatted ESP"
                    ok
                    return 0
                elif [[ "${multibooting}" == "y" && "${manespfs}" != "vfat" ]]; then
                    if mkfs.fat -F 32 -n ESP "${esppart}" > "${void}" 2> "${log}" ; then
                        local prompt="Format & Label /ESP"
                        ok
                        return 0
                    else
                        do_umount
                        until manual_part; do : ; done
                        until form_esp; do : ; done
                        return 0
                    fi
                fi
            else
                invalid
                return 1
            fi
        else
            choice
            return 1
        fi
        blkid > "${void}" 2> "${log}"
    done
}
form_xboot() {
        title "Format Linux Extended Boot Partition"
        form_xboot_nmbr=" "
    while [[ -n "${form_xboot_nmbr}" ]]; do
        ask "Select a Linux Extended Boot Partition to format as ${nc}vfat"
        NC "\n\n\n${volumes}"
        get "Enter a partition number"
        read -r -p "==> " form_xboot_nmbr
        if [[ -n "${form_xboot_nmbr}" ]]; then
            xbootpart="$(echo "${volumes}" | awk "\$1 == ${form_xboot_nmbr} {print \$2}")"
            if [[ -e "${xbootpart}" ]]; then
                if mkfs.fat -F 32 -n XBOOTLDR "${xbootpart}" > "${void}" 2> "${log}" ; then
                    local prompt="Format & Label /XBOOTLDR"
                    ok
                else
                    do_umount
                    until manual_part; do : ; done
                    until form_xboot; do : ; done
                    return 0
                fi
            else
                invalid
                return 1
            fi
        else
            choice
            return 1
        fi
        blkid > "${void}" 2> "${log}"
    done
}
form_root() {
        title "Format Root Partition"
        form_root_nmbr=" "
    while [[ -n "${form_root_nmbr}" ]]; do
        ask "Select a ${roottype} Partition to format as ${nc}${fsname}"
        NC "\n\n\n${volumes}"
        get "Enter a partition number"
        read -r -p "==> " form_root_nmbr
        if [[ -n "${form_root_nmbr}" ]]; then
            rootpart="$(echo "${volumes}" | awk "\$1 == ${form_root_nmbr} {print \$2}")"
            if [[ -e "${rootpart}" ]]; then
                if [[ "${fs}" == "1" ]]; then
                    [[ "$revision" == "y" ]] && wipefs -t btrfs -f "${rootpart}"
                    if mkfs.ext4 -F "${rootpart}" > "${void}" 2> "${log}" ; then
                        tune2fs -O fast_commit "${rootpart}" > "${void}" 2> "${log}" || err_abort
                        udevadm trigger --subsystem-match=block --action=change || err_abort
                        local prompt="Format ${roottype}"
                        ok
                    else
                        do_umount
                        until manual_part; do : ; done
                        until form_root; do : ; done
                        return 0
                    fi
                elif [[ "${fs}" == "2" ]]; then
                    [[ "$revision" == "y" ]] && wipefs -t ext4 -f "${rootpart}"
                    if mkfs.btrfs -f "${rootpart}" > "${void}" 2> "${log}" ; then
                        udevadm trigger --subsystem-match=block --action=change || err_abort
                        mount "${rootpart}" /mnt > "${void}" 2> "${log}" || err_abort
                        btrfs subvolume create /mnt/@ > "${void}" 2> "${log}" || err_abort
                        btrfs subvolume create /mnt/@home > "${void}" 2> "${log}" || err_abort
                        btrfs subvolume create /mnt/@cache > "${void}" 2> "${log}" || err_abort
                        btrfs subvolume create /mnt/@log > "${void}" 2> "${log}" || err_abort
                        btrfs subvolume create /mnt/@tmp > "${void}" 2> "${log}" || err_abort
                        btrfs subvolume create /mnt/@snapshots > "${void}" 2> "${log}" || err_abort
                        if [[ "${swapmode}" == "2" ]]; then
                            btrfs subvolume create /mnt/@swap > "${void}" 2> "${log}" || err_abort
                        fi
                        umount /mnt > "${void}" 2> "${log}" || err_abort
                        local prompt="Format ${roottype}"
                        ok
                    else
                        do_umount
                        until manual_part; do : ; done
                        until form_root; do : ; done
                        return 0
                    fi
                fi
            else
                invalid
                return 1
            fi
            echo
            ask "Label the ${roottype} Partition"
            get "Enter a name"
            read -r -p "==> " rootpartname
            if [[ -n "${rootpartname}" ]]; then
                if [[ "${fs}" == "1" ]]; then
                    if e2label "${rootpart}" "${rootpartname}" > "${void}" 2> "${log}" ; then
                        local prompt="Label ${roottype}"
                        ok
                        return 0
                    else
                        err_try
                        return 1
                    fi
                elif [[ "${fs}" == "2" ]]; then
                    mount "${rootpart}" /mnt || err_abort
                    btrfs filesystem label /mnt "${rootpartname}" > "${void}" 2> "${log}" || err_abort
                    umount /mnt || err_abort
                    local prompt="Label ${roottype}"
                    ok
                    return 0
                fi
            else
                err "Please enter a name"
                reload
                return 1
            fi
        else
            choice
            return 1
        fi
        blkid > "${void}" 2> "${log}"
    done
}
form_home() {
        title "Format Home Partition"
        form_home_nmbr=" "
    while [[ -n "${form_home_nmbr}" ]]; do
        ask "Select a /Home Partition to format as ${nc}Ext4"
        NC "\n\n\n${volumes}"
        get "Enter a partition number ${bwhite}(empty to skip and proceed)"
        read -r -p "==> " form_home_nmbr
        if [[ -n "${form_home_nmbr}" ]]; then
            homepart="$(echo "${volumes}" | awk "\$1 == ${form_home_nmbr} {print \$2}")"
            if [[ -e "${homepart}" ]]; then
                [[ "$revision" == "y" ]] && wipefs -t btrfs -f "${homepart}"
                if mkfs.ext4 -F "${homepart}" > "${void}" 2> "${log}" ; then
                    tune2fs -O fast_commit "${homepart}" > "${void}" 2> "${log}" || err_abort
                    udevadm trigger --subsystem-match=block --action=change || err_abort
                    local prompt="Format /Home"
                    ok
                else
                    do_umount
                    until manual_part; do : ; done
                    until form_home; do : ; done
                    return 0
                fi
            else
                invalid
                return 1
            fi
            echo
            ask "Label the /Home Partition"
            get "Enter a name"
            read -r -p "==> " homepartname
            if [[ -n "${homepartname}" ]]; then
                if e2label "${homepart}" "${homepartname}" > "${void}" 2> "${log}" ;then
                    local prompt="Label /Home"
                    ok
                else
                    err_try
                    return 1
                fi
            else
                err "Please enter a name"
                reload
                return 1
            fi
        else
            err "${yellow}WARNING: ${nc}PARTITION HAS NOT BEEN FORMATTED"
            skip
        fi
        blkid > "${void}" 2> "${log}"
    done
}
mount_mnt() {
        local prompt="Mount ${roottype}"
        title "Mount Root Partition"
        ask "Select a ${roottype} Partition to mount to ${nc}/mnt"
        NC "\n\n\n${volumes}"
        get "Enter your${nc} ${cyan}${roottype} ${blue}partition number"
        read -r -p "==> " mntroot_nmbr
    if [[ -n "${mntroot_nmbr}" ]]; then
        rootpart="$(echo "${volumes}" | awk "\$1 == ${mntroot_nmbr} {print \$2}")"
        if [[ -e "${rootpart}" ]]; then
            if [[ "${fs}" == "1" ]]; then
                if mount "${rootpart}" /mnt > "${void}" 2> "${log}" ; then
                    ok
                    return 0
                else
                    do_umount
                    until mount_mnt; do : ; done
                fi                		
            elif [[ "${fs}" == "2" ]]; then
                if mount -o "${sbvl_mnt_opts}",subvol=@ "${rootpart}" /mnt > "${void}" 2> "${log}" ; then
                    mount --mkdir -o "${sbvl_mnt_opts}",subvol=@home "${rootpart}" /mnt/home > "${void}" 2> "${log}" || err_abort
                    mount --mkdir -o "${sbvl_mnt_opts}",subvol=@cache "${rootpart}" /mnt/var/cache > "${void}" 2> "${log}" || err_abort
                    mount --mkdir -o "${sbvl_mnt_opts}",subvol=@log "${rootpart}" /mnt/var/log > "${void}" 2> "${log}" || err_abort
                    mount --mkdir -o "${sbvl_mnt_opts}",subvol=@tmp "${rootpart}" /mnt/var/tmp > "${void}" 2> "${log}" || err_abort
                    mount --mkdir -o "${sbvl_mnt_opts}",subvol=@snapshots "${rootpart}" /mnt/"${snapname}" > "${void}" 2> "${log}" || err_abort
                    if [[ "${swapmode}" == "2" ]]; then
                        mount --mkdir -o "${sbvl_mnt_opts}",subvol=@swap "${rootpart}" /mnt/swap > "${void}" 2> "${log}" || err_abort
                    fi
                    ok
                    return 0
                else
                    do_umount
                    until mount_mnt; do : ; done
                fi
            fi
        else
            invalid
            return 1
        fi
    else
        choice
        return 1
    fi
}
mount_esp() {
        local prompt="Mount ESP Partition"
        title "${prompt}"
        ask "Select an EFI System Partition to mount to ${nc}${esp_mount}"
        NC "\n\n\n${volumes}"
        get "Enter your${nc} ${cyan}/ESP ${blue}partition number"
        read -r -p "==> " mntesp_nmbr
    if [[ -n "${mntesp_nmbr}" ]]; then
        esppart="$(echo "${volumes}" | awk "\$1 == ${mntesp_nmbr} {print \$2}")"
        if [[ -e "${esppart}" ]]; then
            if mount --mkdir "${esppart}" "${esp_mount}" > "${void}" 2> "${log}" ; then
                ok
                return 0
            else
                do_umount
                until mount_mnt; do : ; done
                until mount_esp; do : ; done
            fi
        else
            invalid
            return 1
        fi
    else
        choice
        return 1
    fi
}
mount_xboot() {
        local prompt="Mount XBOOTLDR Partition"
        title "${prompt}"
        ask "Select a Linux Extended Boot Partition to mount to ${nc}/mnt/boot"
        NC "\n\n\n${volumes}"
        get "Enter your${nc} ${cyan}/XBOOTLDR ${blue}partition number"
        read -r -p "==> " mntxboot_nmbr
    if [[ -n "${mntxboot_nmbr}" ]]; then
        xbootpart="$(echo "${volumes}" | awk "\$1 == ${mntxboot_nmbr} {print \$2}")"
        if [[ -e "${xbootpart}" ]]; then
            if mount --mkdir "${xbootpart}" /mnt/boot > "${void}" 2> "${log}" ; then
                ok
                return 0
            else
                do_umount
                until mount_mnt; do : ; done
                until mount_esp; do : ; done
                until mount_xboot; do : ; done
            fi
        else
            invalid
            return 1
        fi
    else
        choice
        return 1
    fi
}
mount_home() {
        local prompt="Mount Home Partition"
        title "${prompt}"
        ask "Select a /Home Partition to mount to ${nc}/mnt/home"
        NC "\n\n\n${volumes}"
        get "Enter your${nc} ${cyan}/Home ${blue}partition number"
        read -r -p "==> " mnthome_nmbr
    if [[ -n "${mnthome_nmbr}" ]]; then
        homepart="$(echo "${volumes}" | awk "\$1 == ${mnthome_nmbr} {print \$2}")"
        if [[ -e "${homepart}" ]]; then
            if mount --mkdir "${homepart}" /mnt/home > "${void}" 2> "${log}" ; then
                ok
                return 0
            else
                do_umount
                until mount_mnt; do : ; done
                until mount_esp; do : ; done
                until mount_xboot; do : ; done
                until mount_home; do : ; done
            fi
        else
            invalid
            return 1
        fi
    else
        choice
        return 1
    fi
}
confirm_status() {
        local prompt="System Ready"
        title "Confirm Installation Status"
        get ">  Proceed ?"
        NC "\n            * Type '${cyan}yes${nc}' to continue installation\n\n            * Type '${cyan}no${nc}' to revise installation\n\n"
        read -r -p "==> " agree
    if [[ "${agree}" == "yes" ]]; then
        ok
        printf "\n\n\n"
        return 0
    elif [[ "${agree}" == "no" ]]; then
        unmount
        until revise; do : ; done
    else
        yes_no
        return 1
    fi
}
revise() {
        revision="y"
        gfxpkgs=()
        validpkgs=()
        reset=(trg="" xbootloader="" desktop="" terminal="" custompkgs="" customservices="" cust_bootopts="" REGDOM="" autoroot="" autoxboot="" autohome="" autoswap="" lowlat="" nogsp="" sanity="" partok="" preset="" set_ext_opt="" ask_param="" kill_watchdog="" sys_optm="" desk_setup="" devel="" web="" web_pkg="" web_aur="" web_slct="" oomd="" irqbalance="" thermald="" rngd="" rtkit="" tlp="" CRYPTPASS="" CRYPTPASS2="" show_extopts="" gptslct="" gptok="" gptabort="" nvidiaprop="" nowarning="" hometype="" homeform="" smartpart="" LuksParts="" nvidia_aur="" web_aur_url="" session="" alt_session="" session_support="" alt_session_pack="" uki_use="" p="" k="")
        export "${reset[@]}"
        instl
}
sec_erase() {
        local prompt="Secure Disk Erasure"
        title "${prompt}"
        erase_dsk_nmbr=" "
    while [[ -n "${erase_dsk_nmbr}" ]]; do
        ask "Select a disk for Secure Erasure  ${red}[!] (CAUTION) [!]"
        inf "${nc}A reboot is mandatory and will take effect ${yellowl}immediately ${nc}when done"
        NC "\n\n\n${disks}"
        get "Enter a disk number ${bwhite}(empty to skip)"
        read -r -p "==> " erase_dsk_nmbr
        if [[ -n "${erase_dsk_nmbr}" ]]; then
            erasedrive="$(echo "${disks}" | awk "\$1 == ${erase_dsk_nmbr} {print \$2}")"
            if [[ -e "${erasedrive}" ]]; then
                cryptsetup open --type plain -d /dev/urandom "${erasedrive}" temp || err_abort
                dd if=/dev/zero of=/dev/mapper/temp status=progress bs=1M oflag=direct || err_abort
                cryptsetup close temp || err_abort
                local prompt="Drive ${erasedrive} Erased"
                ok
                local prompt="Rebooting"
                ok
                sleep 1
                systemctl reboot
            else
                invalid
                return 1
            fi
        else
            skip
            ok
        fi
    done
}
luks() {
        # NOTE: LUKS Root
        espfs="$(lsblk -f --noheadings "${esp_dev}" | awk "{print \$2}")"
        title "LUKS Encryption"
        BLUE "\n\n\n        >  Encrypting your ${yellowl}${LuksParts}${blue}:\n\n\n"
    if echo -n "${CRYPTPASS}" | cryptsetup luksFormat --label CRYPTROOT "${root_dev}" > "${void}"; then
        if [[ "${rota}" == "0" ]]; then
            echo -n "${CRYPTPASS}" | cryptsetup --perf-no_read_workqueue --perf-no_write_workqueue --persistent luksOpen "${root_dev}" root || err_abort
        else
            echo -n "${CRYPTPASS}" | cryptsetup luksOpen "${root_dev}" root || err_abort
        fi
        if [[ "${fs}" == "1" ]]; then
            mkfs.ext4 -F -L Root /dev/mapper/root > "${void}" 2> "${log}" || err_abort
            tune2fs -O fast_commit /dev/mapper/root > "${void}" 2> "${log}" || err_abort
            udevadm trigger --subsystem-match=block --action=change || err_abort
            mount /dev/mapper/root /mnt > "${void}" 2> "${log}" || err_abort
            sleep 0.2
            NC "\n==> [${green}Encrypted /Root OK${nc}]"
            luks_root="ok"
        elif [[ "${fs}" == "2" ]]; then
            mkfs.btrfs -f -L Root /dev/mapper/root > "${void}" 2> "${log}" || err_abort
            udevadm trigger --subsystem-match=block --action=change || err_abort
            mount /dev/mapper/root /mnt > "${void}" 2> "${log}" || err_abort
            btrfs subvolume create /mnt/@ > "${void}" 2> "${log}" || err_abort
            btrfs subvolume create /mnt/@home > "${void}" 2> "${log}" || err_abort
            btrfs subvolume create /mnt/@cache > "${void}" 2> "${log}" || err_abort
            btrfs subvolume create /mnt/@log > "${void}" 2> "${log}" || err_abort
            btrfs subvolume create /mnt/@tmp > "${void}" 2> "${log}" || err_abort
            btrfs subvolume create /mnt/@snapshots > "${void}" 2> "${log}" || err_abort
            if [[ "${swapmode}" == "2" ]]; then
                btrfs subvolume create /mnt/@swap > "${void}" 2> "${log}" || err_abort
            fi
            umount /mnt > "${void}" 2> "${log}" || err_abort
            mount -o "${sbvl_mnt_opts}",subvol=@ /dev/mapper/root /mnt > "${void}" 2> "${log}" || err_abort
            mount --mkdir -o "${sbvl_mnt_opts}",subvol=@home /dev/mapper/root /mnt/home > "${void}" 2> "${log}" || err_abort
            mount --mkdir -o "${sbvl_mnt_opts}",subvol=@cache /dev/mapper/root /mnt/var/cache > "${void}" 2> "${log}" || err_abort
            mount --mkdir -o "${sbvl_mnt_opts}",subvol=@log /dev/mapper/root /mnt/var/log > "${void}" 2> "${log}" || err_abort
            mount --mkdir -o "${sbvl_mnt_opts}",subvol=@tmp /dev/mapper/root /mnt/var/tmp > "${void}" 2> "${log}" || err_abort
            mount --mkdir -o "${sbvl_mnt_opts}",subvol=@snapshots /dev/mapper/root /mnt/"${snapname}" > "${void}" 2> "${log}" || err_abort
            if [[ "${swapmode}" == "2" ]]; then
                mount --mkdir -o "${sbvl_mnt_opts}",subvol=@swap /dev/mapper/root /mnt/swap > "${void}" 2> "${log}" || err_abort
            fi
            sleep 0.2
            NC "\n==> [${green}Encrypted /@ OK${nc}]"
            luks_root="ok"
        fi
    else
        printf "\n\n"
        err_try
        do_umount
        return 1
    fi
        # NOTE: LUKS Swap
    if [[ -e "${swap_dev}" && "${swapmode}" == "1" ]]; then
        printf "\n\n"
        if echo -n "${CRYPTPASS}" | cryptsetup luksFormat --label CRYPTSWAP "${swap_dev}" > "${void}"; then
            if [[ "${rota}" == "0" ]]; then
                echo -n "${CRYPTPASS}" | cryptsetup --perf-no_read_workqueue --perf-no_write_workqueue --persistent luksOpen "${swap_dev}" swap || err_abort
            else
                echo -n "${CRYPTPASS}" | cryptsetup luksOpen "${swap_dev}" swap || err_abort
            fi
            mkswap /dev/mapper/swap > "${void}" 2> "${log}" || err_abort
            udevadm trigger --subsystem-match=block --action=change || err_abort
            sleep 0.2
            NC "\n==> [${green}Encrypted /Swap OK${nc}]"
            luks_swap="ok"
        else
            printf "\n\n"
            err_try
            do_umount
            return 1
        fi
    fi
        # NOTE: LUKS Home
    if [[ "${sep_home}" == "y" && "${hometype}" == "1" ]]; then
        printf "\n\n"
        if echo -n "${CRYPTPASS}" | cryptsetup luksFormat --label CRYPTHOME "${home_dev}" > "${void}"; then
            if [[ "${rota}" == "0" ]]; then
                echo -n "${CRYPTPASS}" | cryptsetup --perf-no_read_workqueue --perf-no_write_workqueue --persistent luksOpen "${home_dev}" home || err_abort
            else
                echo -n "${CRYPTPASS}" | cryptsetup luksOpen "${home_dev}" home || err_abort
            fi
            mkfs.ext4 -F -L Home /dev/mapper/home > "${void}" 2> "${log}" || err_abort
            tune2fs -O fast_commit /dev/mapper/home > "${void}" 2> "${log}" || err_abort
            udevadm trigger --subsystem-match=block --action=change || err_abort
            mount --mkdir /dev/mapper/home /mnt/home > "${void}" 2> "${log}" || err_abort
            sleep 0.2
            NC "\n==> [${green}Encrypted /Home OK${nc}]\n"
            luks_home="ok"
        else
            printf "\n\n"
            err_try
            do_umount
            return 1
        fi
    elif [[ "${sep_home}" == "y" && "${hometype}" == "2" ]]; then
        ack "An existing /Home partition has been detected and will be utilized in this installation"
        keypress
        udevadm trigger --subsystem-match=block --action=change || err_abort
        mount --mkdir "${home_dev}" /mnt/home > "${void}" 2> "${log}" || err_abort
        sleep 0.2
        NC "\n==> [${green}Unformatted /Home Mounted OK${nc}]\n"
    fi
        # NOTE: Unencrypted ESP
    if [[ "${multibooting}" == "n" ]]; then
        if mkfs.fat -F 32 -n ESP "${esp_dev}" > "${void}" 2> "${log}" ; then
            mount --mkdir "${esp_dev}" "${esp_mount}" > "${void}" 2> "${log}" || err_abort
            local prompt="/ESP"
            ok
            echo
        else
            do_umount
            until luks; do : ; done
        fi
    elif [[ "${multibooting}" == "y" && "${espfs}" == "vfat" ]]; then
        if mount --mkdir "${esp_dev}" "${esp_mount}" > "${void}" 2> "${log}" ; then
            local prompt="Unformatted /ESP Mounted"
            ok
            echo
        else
            printf "\n\n"
            err_try
            do_umount
            return 1
        fi
    elif [[ "${multibooting}" == "y" && "${espfs}" != "vfat" ]]; then
        if mkfs.fat -F 32 -n ESP "${esp_dev}" > "${void}" 2> "${log}" ; then
            mount --mkdir "${esp_dev}" "${esp_mount}" > "${void}" 2> "${log}" || err_abort
            local prompt="/ESP"
            ok
            echo
        else
            do_umount
            until luks; do : ; done
        fi
    fi
        # NOTE: Unencrypted XBOOTLDR
    if [[ "${xbootloader}" == "yes" ]] ; then
        if mkfs.fat -F 32 -n XBOOTLDR "${xboot_dev}" > "${void}" 2> "${log}" ; then
            mount --mkdir "${xboot_dev}" /mnt/boot > "${void}" 2> "${log}" || err_abort
            sleep 0.2
            NC "\n==> [${green}/XBOOTLDR OK${nc}]\n"
        else
            printf "\n\n"
            err_try
            do_umount
            return 1
        fi
    fi
        sleep 0.2
        NC "\n==> [${green}Encryption Completed OK${nc}]"
        luks_encrypt="ok"
        local prompt="Filesystems"
        ok
        keypress
        filesystem_overview
}
opt_pcmn() {
        title "Pacman Optimization"
        ask "Select a Country for your Arch Mirrors"
        ack "[Enter ${nc}'l' ${yellow}to list Countries, then ${nc}'enter' ${yellow}to search or ${nc}'q' ${yellow}to quit]"
        get "Enter country name or country code ${bwhite}(Empty for Defaults)"
        read -r -p "==> " COUNTRY
        COUNTRY="${COUNTRY^^}"
    if [[ -z "${COUNTRY}" ]] ; then
        local prompt="Default Mirrors"
        ok
    elif [[ "${COUNTRY}" == "l" ]]; then
        reflector --list-countries | less
        return 1
    elif [[ -n "${COUNTRY}" ]]; then
        printf "\n\n"
        if reflector --verbose -c "${COUNTRY}" -l 10 -p https -f 10 --sort rate --save /etc/pacman.d/mirrorlist ; then
            local prompt="${COUNTRY}'s Mirrors"
            ok
        else
            err_try
            return 1
        fi
    fi
        ask "Enable Arch's 'Multilib' repository in the installed system ? [y/N]"
        get "Enter [y/N]"
        read -r -p "==> " multilib
        multilib="${multilib:-n}"
        multilib="${multilib,,}"
    if [[ "${multilib}" == "y" ]]; then
        local prompt="Multilib repository"
        ok
    elif [[ "${multilib}" == "n" ]]; then
        skip
    else
        y_n
        return 1
    fi
        local prompt="Pacman Optimization"
        ok
}
pkg_collection() {
        gfxpkgs_set
    if [[ "${bootloader}" == "2" ]]; then
        [[ "${fs}" == "1" ]] && bootldr_pkgs="grub os-prober"
        [[ "${fs}" == "2" ]] && bootldr_pkgs="grub-btrfs inotify-tools os-prober"
    fi
        basepkgs=(base efibootmgr nano networkmanager pkgstats sudo vim "${fstools}" "${kernel}" "${microcode}" "${shell_pkgs}")
        [[ -n "${shell}" ]] && basepkgs+=("${shell}")
        [[ -n "${nrg_plc}" ]] && basepkgs+=("${nrg_plc}")
        [[ -n "${bootldr_pkgs}" ]] && basepkgs+=("${bootldr_pkgs}")
        [[ -n "${ukify}" ]] && basepkgs+=("${ukify}")
        [[ -n "${zram}" ]] && basepkgs+=("${zram}")
        [[ -n "${gfxpkgs[*]}" ]] && basepkgs+=("${gfxpkgs[*]}")
        [[ -n "${devel}" ]] && basepkgs+=("${devel}")
        [[ -n "${wireless_reg}" ]] && basepkgs+=("${wireless_reg}")
        [[ -n "${print_pkgs}" ]] && basepkgs+=("${print_pkgs}")
        [[ -n "${web_pkg}" ]] && basepkgs+=("${web_pkg}")
        [[ "${vendor}" == "Virtual Machine" ]] && basepkgs+=("${vmpkgs}")
        [[ "${vendor}" != "Virtual Machine" ]] && basepkgs+=(alsa-firmware linux-firmware sof-firmware)
        [[ "${terminal}" == "y" ]] && basepkgs+=(gnome-terminal)
        [[ "${sb_sign}" == "y" ]] && basepkgs+=(sbctl)
        [[ "${nvidiaprop}" == "y" ]] && basepkgs+=("${kernel}-headers")
        [[ "${session_support}" == "y" ]] && basepkgs+=("${alt_session_pack}")
        [[ ! "${desktop}" =~ ^(11|12)$ ]] && basepkgs+=(7zip alsa-plugins alsa-utils bluez bluez-hid2hci bluez-obex bluez-utils exfatprogs git glibc-locales gst-libav gst-plugin-libcamera gst-plugin-pipewire gst-plugins-bad gst-plugins-good gst-plugins-ugly libfido2 man-db man-pages mesa-utils nano-syntax-highlighting pacman-contrib pipewire-alsa pipewire-libcamera pipewire-onnx pipewire-pulse pipewire-zeroconf reflector usb_modeswitch xdg-user-dirs)
    case "${desktop}" in
        1)  # Plasma Desktop:
            deskpkgs="${basepkgs[*]} dolphin-plugins konsole plasma qt6-multimedia-gstreamer"
            displaymanager="plasmalogin" ;;
        2)  # Plasma Lite Desktop:
            deskpkgs="${basepkgs[*]} ark bluedevil breeze-gtk colord-kde dolphin-plugins flatpak-kcm freerdp kate kcalc kclock kde-gtk-config kde-inotify-survey kdegraphics-mobipocket kdegraphics-thumbnailers kdenetwork-filesharing kdeplasma-addons kdf kdialog kdiff3 keditbookmarks kimageformats kio-admin kio-gdrive kio-zeroconf konsole krdc krfb kscreen kwayland-integration kwrited okular purpose ocean-sound-theme packagekit-qt6 partitionmanager plasma5-integration plasma-browser-integration plasma-desktop plasma-disks plasma-firewall plasma-keyboard plasma-login-manager plasma-nm plasma-pa plasma-systemmonitor plasma-wayland-protocols spectacle appmenu-gtk-module arj dosfstools ffmpegthumbs icoutils kvantum libappimage libappindicator lrzip lzop ntfs-3g power-profiles-daemon qrca qt5-xmlpatterns qt6-connectivity qt6-multimedia-gstreamer unarchiver unrar xdg-desktop-portal-gtk"
            displaymanager="plasmalogin" ;;
        3)  # Gnome Desktop:
            deskpkgs="${basepkgs[*]} gnome"
            displaymanager="gdm" ;;
        4)  # Gnome Lite Desktop:
            deskpkgs="${basepkgs[*]} dconf-editor file-roller gdm gnome-browser-connector gnome-calculator gnome-clocks gnome-console gnome-control-center gnome-disk-utility gnome-keyring gnome-menus gnome-shell-extensions gnome-system-monitor gnome-text-editor gnome-tweaks gnome-user-share gvfs gvfs-afc gvfs-mtp gvfs-smb loupe papers sushi dosfstools glib2-devel gparted ntfs-3g power-profiles-daemon unrar unzip xorg-xhost zip"
            displaymanager="gdm" ;;
        5)  # Xfce Desktop:
            deskpkgs="${basepkgs[*]} blueman catfish ffmpegthumbnailer gvfs gvfs-afc gvfs-mtp gvfs-smb libgsf libopenraw lightdm-gtk-greeter lightdm-gtk-greeter-settings mousepad mugshot network-manager-applet pavucontrol poppler-glib ristretto thunar-archive-plugin thunar-media-tags-plugin thunar-shares-plugin xfce4 xfce4-battery-plugin xfce4-clipman-plugin xfce4-indicator-plugin xfce4-mount-plugin xfce4-notifyd xfce4-power-manager xfce4-pulseaudio-plugin xfce4-screensaver xfce4-screenshooter xfce4-taskmanager xfce4-whiskermenu-plugin xfce4-power-manager xiccd"
            displaymanager="lightdm" ;;
        6)  # Cinnamon Desktop:
            deskpkgs="${basepkgs[*]} blueman cinnamon cinnamon-translations ffmpegthumbnailer gnome-color-manager gnome-keyring gnome-screenshot lightdm-slick-greeter touchegg wget xed xreader"
            displaymanager="lightdm" ;;
        7)  # Deepin Desktop:
            deskpkgs="${basepkgs[*]} adobe-source-han-sans-otc-fonts deepin deepin-calculator deepin-camera deepin-clipboard deepin-compressor deepin-device-formatter deepin-editor deepin-font-manager deepin-grand-search deepin-kwin deepin-movie deepin-printer deepin-screensaver deepin-screensaver-pp deepin-screen-recorder deepin-shortcut-viewer deepin-terminal iw proxychains-ng qt6-multimedia-gstreamer redshift zssh"
            displaymanager="lightdm" ;;
        8)  # Budgie Desktop:
            deskpkgs="${basepkgs[*]} blueman budgie gnome-user-share lightdm-gtk-greeter lightdm-gtk-greeter-settings nemo network-manager-applet openssh power-profiles-daemon rygel xdg-user-dirs"
            displaymanager="lightdm" ;;
        9)  # Lxqt Desktop:
            deskpkgs="${basepkgs[*]} blueman breeze-icons gvfs gvfs-mtp kimageformats libarchive libstatgrab libsysstat lxqt network-manager-applet oxygen-icons python-pyxdg qt6-imageformats qt6-multimedia-gstreamer sddm  xorg-xrdb xscreensaver xsettingsd"
            displaymanager="sddm" ;;
       10)  # Mate Desktop:
            deskpkgs="${basepkgs[*]} atril blueman caja-actions caja-audio-video-properties caja-open-terminal caja-sendto caja-share caja-wallpaper cpio engrampa eom gnome-keyring lightdm-gtk-greeter lightdm-gtk-greeter-settings mate mate-applets mate-calc mate-icon-theme-faenza mate-media mate-netbook mate-power-manager mate-screensaver mate-system-monitor mate-terminal mate-user-share mate-utils mozo network-manager-applet pluma python-gobject unace unrar webp-pixbuf-loader xdg-user-dirs-gtk"
            displaymanager="lightdm" ;;
       11)  # Base System:
            deskpkgs="${basepkgs[*]}" ;;
       12)  # Custom System:
            custarray=(base sudo "${custompkgs}" "${fstools}" "${kernel}" "${microcode}")
            [[ -n "${shell}" ]] && custarray+=("${shell}")
            [[ -n "${bootldr_pkgs}" ]] && custarray+=("${bootldr_pkgs}")
            [[ -n "${ukify}" ]] && custarray+=("${ukify}")
            [[ -n "${zram}" ]] && custarray+=("${zram}")
            [[ -n "${gfxpkgs[*]}" ]] && custarray+=("${gfxpkgs[*]}")
            [[ -n "${wireless_reg}" ]] && custarray+=("${wireless_reg}")
            [[ -n "${print_pkgs}" ]] && custarray+=("${print_pkgs}")
            [[ "${vendor}" == "Virtual Machine" ]] && custarray+=("${vmpkgs}")
            [[ "${vendor}" != "Virtual Machine" ]] && custarray+=(linux-firmware)
            [[ "${sb_sign}" == "y" ]] && custarray+=(sbctl)
            [[ "${nvidiaprop}" == "y" ]] && custarray+=("${kernel}-headers")
            deskpkgs="${custarray[*]}" ;;
       13)  # Cosmic Desktop:
            deskpkgs="${basepkgs[*]} cosmic dconf gnome-keyring gvfs gvfs-dnssd gvfs-nfs gvfs-smb packagekit power-profiles-daemon pulseaudio-alsa"
            displaymanager="cosmic-greeter" ;;
       14)  # Pantheon Desktop:
            deskpkgs="${basepkgs[*]} pantheon pantheon-print sound-theme-elementary"
            displaymanager="lightdm" ;;
    esac
}
pkg_validation() {
        local prompt="Arch Packages Validation"
        local stage_prompt="Arch Packages Validation"
        sleep 0.2
        YELLOWL "\n                            ------------------------------------------\n                            ###  ${bwhite}Validating Installation Packages  ${yellowl}###\n                            ------------------------------------------\n\n"
        validpkgs+=("${deskpkgs}")
        echo "${validpkgs[*]}"
        keypress
        valids="${validpkgs[*]}"
        printf "\n\n"
    if pacman -Syy > "${log}" 2>&1 && pacman -Spd ${valids} > "${log}" 2>&1; then
        ok
        if [[ -n "${web_aur}" ]]; then
            local prompt="${web_name} Package Validation"
            pacman -S --noconfirm wget > "${void}"
            if wget -4q --spider "${web_aur_url}" 2> "${log}"; then
                ok
            else
                err_try
                return 1
            fi
        fi
        if [[ -n "${nvidia_aur}" ]]; then
            local prompt="Nvidia 580xx Drivers Package Validation"
            if [[ ! -e /usr/bin/wget ]]; then
                pacman -S --noconfirm wget > "${void}"
            fi
            if wget -4q --spider https://aur.archlinux.org/cgit/aur.git/snapshot/nvidia-580xx-utils.tar.gz 2> "${log}" &&
                wget -4q --spider https://aur.archlinux.org/cgit/aur.git/snapshot/nvidia-580xx-settings.tar.gz 2> "${log}"; then
                ok
            else
                err_try
                return 1
            fi
        fi
    else
        err_try
        return 1
    fi
    if [[ "${encrypt}" == "no" ]]; then
        until confirm_status; do : ; done
    elif [[ "${encrypt}" == "yes" ]]; then
        keypress
    fi
}
pacstrap_system() {
        local prompt="Pacstrap System"
        title "${prompt}"
        installing
        pkg_collection
        pkg_validation
    if pacstrap -K /mnt ${deskpkgs} 2> "${log}" ; then
        if [[ -n "${nvidia_aur}" ]]; then
            YELLOWL "\n\n\n                            ---------------------------------------\n                            ###  ${nc}Building ${bwhite}Nvidia-580xx ${nc}Drivers  ${yellowl}###\n                            ---------------------------------------${nc}\n                                      ... Please Wait ...\n\n\n"
            if [[ "${dev}" != "y" ]]; then
                local stage_prompt="Base-devel Package Installation"
                if arch-chroot /mnt <<-BASE_DEVEL > "${log}" 2>&1 ; then
					pacman -S --noconfirm base-devel
					BASE_DEVEL
                    stage_ok
                else
                    stage_fail
                fi
            fi
            if [[ "${desktop}" =~ ^(11|12)$ ]]; then
                local stage_prompt="Git Package Installation"
                if arch-chroot /mnt <<-GIT > "${log}" 2>&1 ; then
					pacman -S --noconfirm git
					GIT
                    stage_ok
                else
                    stage_fail
                fi
            fi
            local stage_prompt="AUR Nvidia Packages Installation"
            if arch-chroot /mnt <<-AUR_NVIDIA_PKGS > "${log}" 2>&1 ; then
				sed -i 's|if (( EUID == 0 )); then|if (( EUID != 0 )); then|g' /usr/bin/makepkg
				git clone --branch nvidia-580xx-utils --single-branch https://github.com/archlinux/aur.git nvidia-580xx-utils && cd nvidia-580xx-utils && makepkg -s --noconfirm && sudo pacman -U --noconfirm *x86_64.pkg.tar.zst && cd .. && rm -rf nvidia-580xx-utils
				git clone --branch nvidia-580xx-settings --single-branch https://github.com/archlinux/aur.git nvidia-580xx-settings && cd nvidia-580xx-settings && makepkg -s --noconfirm && sudo pacman -U --noconfirm *x86_64.pkg.tar.zst && cd .. && rm -rf nvidia-580xx-settings
				sed -i 's|if (( EUID != 0 )); then|if (( EUID == 0 )); then|g' /usr/bin/makepkg
				AUR_NVIDIA_PKGS
                stage_ok
            else
                stage_fail
            fi
        fi
        ok
    else
        local stage_prompt="Pacstrap System"
        stage_fail
    fi
    exec </dev/console >/dev/console 2>&1
    if [[ "${fs}" == "2" ]]; then
        local prompt="Fstab"
        local stage_prompt="Fstab"
        genfstab -t PARTUUID /mnt >> /mnt/etc/fstab 2> "${log}" || stage_fail
        arch-chroot /mnt <<-FSTAB_SBVL_MNT_OPTS > "${log}" 2>&1 || stage_fail
			sed -i 's/^rw.*/${sbvl_mnt_opts}/' /etc/fstab
			FSTAB_SBVL_MNT_OPTS
        ok
    fi
}
swapfile() {
        local prompt="Swapfile Setup"
        local stage_prompt="Swapfile Setup"
        title "${prompt}"
    if arch-chroot /mnt <<-SWAPFILE > "${log}" 2>&1 ; then
		mkswap -U clear --size ${swapsize}G --file /swapfile
		SWAPFILE
        cat >> /mnt/etc/fstab <<-FSTAB || err_abort
			/swapfile none swap defaults 0 0
			FSTAB
        ok
    else
        stage_fail
    fi
}
swapfile_btrfs() {
        local prompt="Btrfs Swapfile Setup"
        local stage_prompt="Btrfs Swapfile Setup"
        title "${prompt}"
    if arch-chroot /mnt <<-SWAPFILE_BTRFS > "${log}" 2>&1 ; then
		btrfs filesystem mkswapfile --size ${swapsize}g --uuid clear /swap/swapfile
		SWAPFILE_BTRFS
        cat >> /mnt/etc/fstab <<-FSTAB || err_abort
			/swap/swapfile none swap defaults 0 0
			FSTAB
        ok
    else
        stage_fail
    fi
}
set_wireless_regdom() {
        local prompt="Wireless Regulatory Domain"
        local stage_prompt="Wireless Regulatory Domain"
        title "Setting Up Wireless Regulatory Domain"
    if sed -i "/^#WIRELESS_REGDOM=\"${REGDOM}\"/s/^#//" /mnt/etc/conf.d/wireless-regdom ; then
        ok
    else
        stage_fail
    fi
}
main_chroot() {
        local stage_prompt="Base System Configuration"
    if arch-chroot /mnt <<-CONF > "${log}" 2>&1 ; then
		sed -i "/^#${SETLOCALE}/s/^#//" /etc/locale.gen
		locale-gen
		echo LANG=${SETLOCALE} > /etc/locale.conf
		export LANG=${SETLOCALE}
		echo KEYMAP=${SETKBD} > /etc/vconsole.conf
		cat <<-MKINITCPIO > /etc/mkinitcpio.conf.d/mkinitcpiod.conf
			${mkinitcpio_mods}
			${mkinitcpio_bins}
			${mkinitcpio_hooks}
			MKINITCPIO
		mkinitcpio -P
		ln -sf /usr/share/zoneinfo/$(curl -s http://ip-api.com/line?fields=timezone) /etc/localtime
		hwclock --systohc
		echo ${HOSTNAME} > /etc/hostname
		cat <<-HOSTS > /etc/hosts
			127.0.0.1 localhost
			::1 localhost
			127.0.1.1 ${HOSTNAME}.localdomain ${HOSTNAME}
			HOSTS
		echo root:${ROOTPASSWD2} | chpasswd
		chsh -s /bin/${shellname}
		useradd -m -G wheel -s /bin/${shellname} ${USERNAME}
		echo ${USERNAME}:${USERPASSWD2} | chpasswd
		echo "%wheel ALL=(ALL) ALL" | tee /etc/sudoers.d/sudoersd
		visudo -c /etc/sudoers.d/sudoersd
		CONF
        stage_ok
    else
        stage_fail
    fi
}
mkinitcpio_preset() {
    if [[ "${uki}" == "y" ]]; then
        if [[ ! -d "${esp_mount}"/EFI/Linux ]]; then
            mkdir -p "${esp_mount}"/EFI/Linux
        fi
        if [[ "${setrescue}" == "y" ]]; then
            local stage_prompt="Uki + Rescue Uki Creation"
            if arch-chroot /mnt <<-UKI_RESCUE > "${log}" 2>&1 ; then
				mkdir /etc/cmdline.d
				echo "rw ${boot_opts[*]}" | tee /etc/cmdline.d/cmdlined.conf
				echo "systemd.unit=rescue.target rw ${boot_opts[*]}" | tee /etc/cmdline.d/rescued.conf
				cp /etc/mkinitcpio.d/${kernel}.preset /etc/mkinitcpio.d/${kernel}.preset.bak
				cat <<-MKINITCPIO_PRESET > /etc/mkinitcpio.d/${kernel}.preset
					# mkinitcpio preset file for the '${kernel}' package
					ALL_config="/etc/mkinitcpio.conf.d/mkinitcpiod.conf"
					ALL_kver="/boot/vmlinuz-${kernel}"
					PRESETS=('default' 'rescue')
					default_uki="${btldr_esp_mount}/EFI/Linux/arch-${kernel}.efi"
					default_options="--cmdline /etc/cmdline.d/cmdlined.conf"
					rescue_uki="${btldr_esp_mount}/EFI/Linux/rescue.efi"
					rescue_options="--cmdline /etc/cmdline.d/rescued.conf"
					MKINITCPIO_PRESET
				mkinitcpio -P
				UKI_RESCUE
                stage_ok
            else
                stage_fail
            fi
        elif [[ "${setrescue}" == "n" ]]; then
			local stage_prompt="Uki Creation"
			if arch-chroot /mnt <<-UKI > "${log}" 2>&1 ; then
				mkdir /etc/cmdline.d
				echo "rw ${boot_opts[*]}" | tee /etc/cmdline.d/cmdlined.conf
				cp /etc/mkinitcpio.d/${kernel}.preset /etc/mkinitcpio.d/${kernel}.preset.bak
				cat <<-MKINITCPIO_PRESET > /etc/mkinitcpio.d/${kernel}.preset
					# mkinitcpio preset file for the '${kernel}' package
					ALL_config="/etc/mkinitcpio.conf.d/mkinitcpiod.conf"
					ALL_kver="/boot/vmlinuz-${kernel}"
					PRESETS=('default')
					default_uki="${btldr_esp_mount}/EFI/Linux/arch-${kernel}.efi"
					default_options="--cmdline /etc/cmdline.d/cmdlined.conf"
					MKINITCPIO_PRESET
				mkinitcpio -P
				UKI
				stage_ok
			else
				stage_fail
			fi
		fi
        for file in /mnt/boot/*.img; do
            if [ -f "$file" ]; then
                rm "$file"
            fi
        done
    elif [[ "${uki}" == "n" ]]; then
        local stage_prompt="Initramfs Creation"
        if arch-chroot /mnt <<-INITRAMFS > "${log}" 2>&1 ; then
			cp /etc/mkinitcpio.d/${kernel}.preset /etc/mkinitcpio.d/${kernel}.preset.bak
			cat <<-MKINITCPIO_PRESET > /etc/mkinitcpio.d/${kernel}.preset
				# mkinitcpio preset file for the '${kernel}' package
				ALL_config="/etc/mkinitcpio.conf.d/mkinitcpiod.conf"
				ALL_kver="/boot/vmlinuz-${kernel}"
				PRESETS=('default')
				default_image="/boot/initramfs-${kernel}.img"
				MKINITCPIO_PRESET
			mkinitcpio -P
			INITRAMFS
            stage_ok
        else
            stage_fail
        fi
    fi
}
btldrcfg() {
    if [[ "${bootloader}" == "1" ]]; then
        local stage_prompt="Systemd-boot Configuration"
        if [[ "${xbootloader}" == "no" ]]; then
            if arch-chroot -S /mnt <<-SDBOOT_INSTL > "${log}" 2>&1 ; then
				bootctl install
				cat <<-LOADER_CFG > ${btldr_esp_mount}/loader/loader.conf
					timeout 3
					console-mode auto
					editor no
					LOADER_CFG
				systemctl enable systemd-boot-update
				SDBOOT_INSTL
                stage_ok
            else
                stage_fail
            fi
        elif [[ "${xbootloader}" == "yes" ]]; then
            if arch-chroot -S /mnt <<-SDBOOT_XBOOTLDR_INSTL > "${log}" 2>&1 ; then
				bootctl --esp-path=/efi --boot-path=/boot install
				cat <<-LOADER_CFG > ${btldr_esp_mount}/loader/loader.conf
					default arch.conf
					timeout 3
					console-mode auto
					editor no
					LOADER_CFG
				cat <<-ENTRY_CFG > /boot/loader/entries/arch.conf
					title   Arch Linux
					linux   /vmlinuz-${kernel}
					initrd  /initramfs-${kernel}.img
					options rw ${boot_opts[*]}
					ENTRY_CFG
				systemctl enable systemd-boot-update
				SDBOOT_XBOOTLDR_INSTL
                stage_ok
            else
                stage_fail
            fi
            if [[ "${setrescue}" == "y" ]]; then
                if arch-chroot -S /mnt <<-RESCUE_ENTRY > "${log}" 2>&1 ; then
					cat <<-XBOOTLDR_RESCUE_CONF > /boot/loader/entries/rescue.conf
						title   Arch Rescue
						linux   /vmlinuz-${kernel}
						initrd  /initramfs-${kernel}.img
						options rw systemd.unit=rescue.target ${boot_opts[*]}
						XBOOTLDR_RESCUE_CONF
					RESCUE_ENTRY
                    stage_ok
                else
                    stage_fail
                fi
            fi
        fi
    elif [[ "${bootloader}" == "2" ]]; then
        local stage_prompt="Grub Configuration"
        if arch-chroot /mnt <<-GRUB_CONF > "${log}" 2>&1 ; then
			cp /etc/default/grub /etc/default/grub.bak
			cat <<-CFG > /etc/default/grub
				GRUB_DEFAULT=0
				GRUB_TIMEOUT=5
				GRUB_DISTRIBUTOR="Arch"
				GRUB_CMDLINE_LINUX_DEFAULT="${boot_opts[*]}"
				GRUB_CMDLINE_LINUX=""
				GRUB_PRELOAD_MODULES="part_gpt part_msdos"
				GRUB_TIMEOUT_STYLE=menu
				GRUB_TERMINAL_INPUT=console
				GRUB_GFXMODE=auto
				GRUB_GFXPAYLOAD_LINUX=keep
				GRUB_DISABLE_RECOVERY=true
				GRUB_DISABLE_OS_PROBER=false
				GRUB_TERMINAL_OUTPUT=console
				CFG
			GRUB_CONF
            stage_ok
        else
            stage_fail
        fi
        local stage_prompt="Grub Installation"
        if [[ "${sb_sign}" == "y" && "${path}" == "1"  ]]; then
            if arch-chroot /mnt <<-SB_GRUB_INSTL > "${log}" 2>&1 ; then
				grub-install --target=${uefimode} --efi-directory=${btldr_esp_mount} --bootloader-id=GRUB --modules="tpm" --disable-shim-lock --recheck
				sed -i 's/SecureBoot/SecureB00t/' ${btldr_esp_mount}/EFI/GRUB/grubx${bitness}.efi
				grub-mkconfig -o /boot/grub/grub.cfg
				SB_GRUB_INSTL
                stage_ok
            else
                stage_fail
            fi
        elif [[ "${sb_sign}" == "y" && "${path}" == "2"  ]]; then
            if arch-chroot /mnt <<-SB_GRUB_INSTL_RMV > "${log}" 2>&1 ; then
				grub-install --target=${uefimode} --efi-directory=${btldr_esp_mount} --bootloader-id=GRUB --removable --modules="tpm" --disable-shim-lock --recheck
				sed -i 's/SecureBoot/SecureB00t/' ${btldr_esp_mount}/EFI/BOOT/${efiname}.EFI
				grub-mkconfig -o /boot/grub/grub.cfg
				SB_GRUB_INSTL_RMV
                stage_ok
            else
                stage_fail
            fi
        elif [[ "${sb_sign}" == "n" && "${path}" == "1" ]]; then
            if arch-chroot /mnt <<-GRUB_INSTL > "${log}" 2>&1 ; then
				grub-install --target=${uefimode} --efi-directory=${btldr_esp_mount} --bootloader-id=GRUB --recheck
				grub-mkconfig -o /boot/grub/grub.cfg
				GRUB_INSTL
                stage_ok
            else
                stage_fail
            fi
        elif [[ "${sb_sign}" == "n" && "${path}" == "2" ]]; then
            if arch-chroot /mnt <<-GRUB_INSTL_RMV > "${log}" 2>&1 ; then
				grub-install --target=${uefimode} --efi-directory=${btldr_esp_mount} --bootloader-id=GRUB --removable --recheck
				grub-mkconfig -o /boot/grub/grub.cfg
				GRUB_INSTL_RMV
                stage_ok
            else
                stage_fail
            fi
        fi
        if [[ "${setrescue}" == "y" ]]; then
            local stage_prompt="Rescue Entry Creation"
            if arch-chroot /mnt <<-GRUB_RESCUE_ENTRY > "${log}" 2>&1 ; then
				touch /boot/grub/custom.cfg
				grep -E -A 11 "'Arch Linux'" /boot/grub/grub.cfg > /boot/grub/custom.cfg
				sed -i 's/Arch Linux/Rescue Environment/' /boot/grub/custom.cfg
				sed -i '/vmlinuz/ s/$/ systemd.unit=rescue.target/' /boot/grub/custom.cfg
				GRUB_RESCUE_ENTRY
                stage_ok
            else
                stage_fail
            fi
        fi
        if [[ "${fs}" == "2" ]]; then
            local stage_prompt="Grub-Btrfsd Service Activation"
            if arch-chroot /mnt <<-GRUB_BTRFSD > "${log}" 2>&1 ; then
				systemctl enable grub-btrfsd
				GRUB_BTRFSD
                stage_ok
            else
                stage_fail
            fi
        fi
        if [[ "${nvidiaprop}" == "y" ]]; then
            local stage_prompt="Grub/Nvidia Configuration"
            if arch-chroot /mnt <<-NVIDIA_GRUB > "${log}" 2>&1 ; then
				sed -i "/^#GRUB_TERMINAL_OUTPUT=console/s/^#//" /etc/default/grub
				grub-mkconfig -o /boot/grub/grub.cfg
				NVIDIA_GRUB
                stage_ok
            else
                stage_fail
            fi
        fi
    fi
}
trimcfg() {
    if [[ -n "${trim}" ]]; then
        local stage_prompt="Trim Service Activation"
        if arch-chroot /mnt <<-TRIM > "${log}" 2>&1 ; then
			systemctl enable ${trim}
			TRIM
            stage_ok
        else
            stage_fail
        fi
    fi
}
vm_serv() {
    if [[ -n "${vm_services}" ]]; then
        local stage_prompt="VM Service(s) Activation"
        if arch-chroot /mnt <<-VM_SRVC > "${log}" 2>&1 ; then
			systemctl enable ${vm_services}
			VM_SRVC
            stage_ok
        else
            stage_fail
        fi
    fi
}
zramcfg() {
    if [[ -n "${zram}" ]]; then
        local stage_prompt="Zram Swap Activation"
        zram_service="systemd-zram-setup@zram0.service"
        if arch-chroot /mnt <<-ZRAM_CONF > "${log}" 2>&1 ; then
			mkdir -p /etc/systemd/zram-generator.conf.d
			cat <<-ZRAM_GEN > /etc/systemd/zram-generator.conf.d/zram.conf
				[zram0]
				zram-size = ram / 2
				compression-algorithm = zstd
				ZRAM_GEN
			cat <<-ZRAM_VM > /etc/sysctl.d/99-vm-zram-parameters.conf
				vm.swappiness = 180
				vm.watermark_boost_factor = 0
				vm.watermark_scale_factor = 125
				vm.page-cluster = 0
				ZRAM_VM
			systemctl daemon-reload
			systemctl start ${zram_service}
			ZRAM_CONF
            stage_ok
        else
            stage_fail
        fi
    fi
}
nvidia_hook() {
    if [[ "${nvidiaprop}" == "y" && -n "${nvname}" ]]; then
        local stage_prompt="Nvidia Hook Creation"
        if arch-chroot /mnt <<-NVIDIA_HOOK > "${log}" 2>&1 ; then
			mkdir -p /etc/pacman.d/hooks/
			cat <<-HOOK > /etc/pacman.d/hooks/nvidia.hook
				[Trigger]
				Operation=Install
				Operation=Upgrade
				Operation=Remove
				Type=Package
				Target=${nvname}
				Target=${kernel}

				[Action]
				Description=Updating NVIDIA module in initcpio
				Depends=mkinitcpio
				When=PostTransaction
				NeedsTargets
				Exec=/bin/sh -c 'while read -r trg; do case $trg in linux*) exit 0; esac; done; /usr/bin/mkinitcpio -P'
				HOOK
			NVIDIA_HOOK
            stage_ok
        else
            stage_fail
        fi
    fi
}
var_opts() {
    if [[ "${multilib}" == "y" ]]; then
        local stage_prompt="Multilib Configuration"
        if arch-chroot /mnt <<-MULTILIB > "${log}" 2>&1 ; then
			sed -i "/\[multilib\]/,/Include/"'s/^#//' /etc/pacman.conf
			pacman -Syy
			MULTILIB
            stage_ok
        else
            stage_fail
        fi
    fi
    if [[ "${CPU}" == *"GenuineIntel"* && "${kill_watchdog}" == "y" ]]; then
        local stage_prompt="Intel Watchdog Configuration"
        if arch-chroot /mnt <<-INTEL_WATCHDOG > "${log}" 2>&1 ; then
			echo "blacklist iTCO_wdt" | tee /etc/modprobe.d/blacklist.conf
			INTEL_WATCHDOG
            stage_ok
        else
            stage_fail
        fi
    elif [[ "${CPU}" == *"AuthenticAMD"* && "${kill_watchdog}" == "y" ]]; then
        local stage_prompt="AMD Watchdog Configuration"
        if arch-chroot /mnt <<-AMD_WATCHDOG > "${log}" 2>&1 ; then
			echo "blacklist sp5100_tco" | tee /etc/modprobe.d/blacklist.conf
			AMD_WATCHDOG
            stage_ok
        else
            stage_fail
        fi
    fi
    if [[ "${oomd}" == "y" ]]; then
        local stage_prompt="Systemd-oomd Service Activation"
        if arch-chroot /mnt <<-OOMD > "${log}" 2>&1 ; then
			mkdir -p /etc/systemd/system.conf.d > "${void}" 2>&1
			cat <<-OOMD_CONF > /etc/systemd/system.conf.d/00-oomd.conf
				[Manager]
				DefaultMemoryAccounting=yes
				OOMD_CONF
			systemctl enable systemd-oomd
			OOMD
            stage_ok
        else
            stage_fail
        fi
    fi
    if [[ "${irqbalance}" == "y" ]]; then
        local stage_prompt="Irqbalance Service Activation"
        if arch-chroot /mnt <<-IRQBALANCE > "${log}" 2>&1 ; then
			pacman -S --noconfirm irqbalance
			systemctl enable irqbalance
			IRQBALANCE
            stage_ok
        else
            stage_fail
        fi
    fi
    if [[ "${thermald}" == "y" ]]; then
        local stage_prompt="Thermald Service Activation"
        if arch-chroot /mnt <<-THERMALD > "${log}" 2>&1 ; then
			pacman -S --noconfirm thermald
			systemctl enable thermald
			THERMALD
            stage_ok
        else
            stage_fail
        fi
    fi
    if [[ "${rngd}" == "y" ]]; then
        local stage_prompt="Rngd Service Activation"
        if arch-chroot /mnt <<-RNGD > "${log}" 2>&1 ; then
			pacman -S --noconfirm rng-tools
			systemctl enable rngd
			RNGD
            stage_ok
        else
            stage_fail
        fi
    fi
    if [[ "${rtkit}" == "y" ]]; then
        local stage_prompt="Rtkit Service Activation"
        if arch-chroot /mnt <<-RTKIT > "${log}" 2>&1 ; then
			pacman -S --noconfirm realtime-privileges rtkit
			systemctl enable rtkit-daemon
			usermod -aG realtime ${USERNAME}
			RTKIT
            stage_ok
        else
            stage_fail
        fi
    fi
    if [[ "${tlp}" == "y" ]]; then
        local stage_prompt="Power-profiles-daemon Removal"
        if [[ -e usr/lib/power-profiles-daemon ]]; then
            if arch-chroot /mnt <<-PPD > "${log}" 2>&1 ; then
				pacman -Rns --noconfirm power-profiles-daemon
				PPD
                stage_ok
            else
                stage_fail
            fi
        fi
        local stage_prompt="Tlp Service Activation"
        if arch-chroot /mnt <<-TLP > "${log}" 2>&1 ; then
			pacman -S --noconfirm tlp
			systemctl enable tlp
			systemctl mask systemd-rfkill.service systemd-rfkill.socket
			TLP
            stage_ok
        else
            stage_fail
        fi
    fi
    if [[ "${printer}" == "y" ]]; then
        local stage_prompt="Print & Scan Services Activation"
        if arch-chroot /mnt <<-PRINT_CONF > "${log}" 2>&1 ; then
			systemctl enable avahi-daemon.socket cups.socket cups-browsed ipp-usb
			sed -i 's|^hosts.*|hosts: mymachines mdns_minimal resolve [!UNAVAIL=return] files myhostname dns|g' /etc/nsswitch.conf
			sed -i 's/ interface = [^ ]*/ interface = all/g' /etc/ipp-usb/ipp-usb.conf
			PRINT_CONF
            stage_ok
        else
            stage_fail
        fi
    fi
}
foreign() {
    if [[ -n "${web_aur}" ]]; then
        if [[ -z "${nvidia_aur}" ]]; then
            if [[ "${dev}" != "y" ]]; then
                local stage_prompt="Base-devel Package Installation"
                if arch-chroot /mnt <<-BASE_DEVEL > "${log}" 2>&1 ; then
					pacman -S --noconfirm base-devel
					BASE_DEVEL
                    stage_ok
                else
                    stage_fail
                fi
            fi
            if [[ "${desktop}" =~ ^(11|12)$ ]]; then
                local stage_prompt="Git Package Installation"
                if arch-chroot /mnt <<-GIT > "${log}" 2>&1 ; then
					pacman -S --noconfirm git
					GIT
                    stage_ok
                else
                    stage_fail
                fi
            fi
        fi
        local stage_prompt="${web_name} Package Installation"
        if arch-chroot /mnt <<-AUR_WEB_PKGS > "${log}" 2>&1 ; then
			sed -i 's|if (( EUID == 0 )); then|if (( EUID != 0 )); then|g' /usr/bin/makepkg
			git clone --branch ${web_aur} --single-branch https://github.com/archlinux/aur.git ${web_aur} && cd ${web_aur} && makepkg -s --noconfirm && sudo pacman -U --noconfirm *x86_64.pkg.tar.zst && cd .. && rm -rf ${web_aur}
			sed -i 's|if (( EUID != 0 )); then|if (( EUID == 0 )); then|g' /usr/bin/makepkg
			AUR_WEB_PKGS
            stage_ok
        else
            stage_fail
        fi
    fi
}
optimizations() {
    if [[ "${sys_optm}" == "y" ]]; then
        local stage_prompt="General System Optimizations"
        if arch-chroot /mnt <<-SYS_OPTM > "${log}" 2>&1 ; then
			pacman -S --noconfirm ccache ntfs-3g pbzip2 pigz
			sed -i 's/^#Color/Color\nILoveCandy/' /etc/pacman.conf
			update-pciids
			cat <<-MKINITCPIO >> /etc/mkinitcpio.conf.d/mkinitcpiod.conf
				COMPRESSION="zstd"
				COMPRESSION_OPTIONS=(-c -T$(nproc) --auto-threads=logical -)
				MKINITCPIO
			mkinitcpio -P
			cat <<-MAKEPKG > /etc/makepkg.conf.d/makepkgd.conf
				#!/hint/bash
				CFLAGS="-march=native -O2 -pipe -fno-plt -fexceptions \
				-Wp,-D_FORTIFY_SOURCE=3 -Wformat -Werror=format-security \
				-fstack-clash-protection -fcf-protection \
				-fno-omit-frame-pointer -mno-omit-leaf-frame-pointer"
				MAKEFLAGS="-j$(nproc)"
				BUILDENV=(!distcc color ccache check !sign)
				OPTIONS=(strip docs !libtool !staticlibs emptydirs zipman purge !debug lto)
				COMPRESSGZ=(pigz -c -f -n)
				COMPRESSBZ2=(pbzip2 -c -f)
				COMPRESSZST=(zstd -c -T0 --auto-threads=logical -)
				MAKEPKG
			cat <<-IO_SCHED > /etc/udev/rules.d/60-ioschedulers.rules
				# HDD
				ACTION=="add|change", KERNEL=="sd[a-z]*", ATTR{queue/rotational}=="1", ATTR{queue/scheduler}="bfq"
				# SSD
				ACTION=="add|change", KERNEL=="sd[a-z]*|mmcblk[0-9]*", ATTR{queue/rotational}=="0", ATTR{queue/scheduler}="bfq"
				# NVMe SSD
				ACTION=="add|change", KERNEL=="nvme[0-9]*", ATTR{queue/rotational}=="0", ATTR{queue/scheduler}="none"
				IO_SCHED
			cat <<-SYSCTL > /etc/sysctl.d/99-sysctld.conf
				net.core.netdev_max_backlog = 16384
				net.ipv4.tcp_fastopen = 3
				net.ipv4.tcp_tw_reuse = 1
				net.ipv4.tcp_slow_start_after_idle = 0
				net.ipv4.tcp_mtu_probing = 1
				net.ipv4.tcp_sack = 1
				net.core.default_qdisc = cake
				net.ipv4.tcp_congestion_control = bbr
				net.ipv4.ip_local_port_range = 30000 65535
				vm.vfs_cache_pressure = 50
				vm.mmap_min_addr = 65536
				kernel.printk = 0 0 0 0
				${perf_stream}
				SYSCTL
			cat <<-POLKIT > /etc/polkit-1/rules.d/99-udisks2.rules
				// Original rules: https://github.com/coldfix/udiskie/wiki/Permissions
				// Changes: Added org.freedesktop.udisks2.filesystem-mount-system, as this is used by Dolphin.
				polkit.addRule(function(action, subject) {
				var YES = polkit.Result.YES;
				var permission = {
				// required for udisks1:
				"org.freedesktop.udisks.filesystem-mount": YES,
				"org.freedesktop.udisks.luks-unlock": YES,
				"org.freedesktop.udisks.drive-eject": YES,
				"org.freedesktop.udisks.drive-detach": YES,
				// required for udisks2:
				"org.freedesktop.udisks2.filesystem-mount": YES,
				"org.freedesktop.udisks2.encrypted-unlock": YES,
				"org.freedesktop.udisks2.eject-media": YES,
				"org.freedesktop.udisks2.power-off-drive": YES,
				// Dolphin specific:
				"org.freedesktop.udisks2.filesystem-mount-system": YES,
				// required for udisks2 if using udiskie from another seat (e.g. systemd):
				"org.freedesktop.udisks2.filesystem-mount-other-seat": YES,
				"org.freedesktop.udisks2.filesystem-unmount-others": YES,
				"org.freedesktop.udisks2.encrypted-unlock-other-seat": YES,
				"org.freedesktop.udisks2.encrypted-unlock-system": YES,
				"org.freedesktop.udisks2.eject-media-other-seat": YES,
				"org.freedesktop.udisks2.power-off-drive-other-seat": YES
				};
					if (subject.isInGroup("wheel")) {
						return permission[action.id];
					}
				});
				POLKIT
			mkdir -p /etc/systemd/journald.conf.d > ${void} 2>&1
			cat <<-JOURNAL > /etc/systemd/journald.conf.d/00-journald.conf
				[Journal]
				SystemMaxUse=100M
				JOURNAL
			mkdir -p /etc/systemd/user.conf.d > ${void} 2>&1
			cat <<-TIMEOUT > /etc/systemd/user.conf.d/00-timeout.conf
				[Manager]
				DefaultTimeoutStopSec=5s
				DefaultTimeoutAbortSec=5s
				TIMEOUT
			sed -i \
				-e '/^# set linenumbers/s/^#//' \
				-e '/^# set minibar/s/^#//' \
				-e '/^# set mouse/s/^#//' /etc/nanorc
			echo " include /usr/share/nano/*.nanorc" | tee -a /etc/nanorc
			echo tcp_bbr | tee /etc/modules-load.d/modulesd.conf
			cat <<-SUDOERS > /etc/sudoers.d/sudoersd
				Defaults pwfeedback
				Defaults editor=/usr/bin/nano
				%wheel ALL=(ALL) ALL
				SUDOERS
			visudo -c /etc/sudoers.d/sudoersd
			SYS_OPTM
            stage_ok
        else
            stage_fail
        fi
        if [[ -d /mnt/etc/udisks2 ]]; then
            local stage_prompt="Udisks2 Mount Options"
            if arch-chroot /mnt <<-UDISKS2 > "${log}" 2>&1 ; then
				cat <<-UDISKS_CONF > /etc/udisks2/mount_options.conf
					[defaults]
					ntfs_drivers=ntfs3,ntfs
					ntfs:ntfs3_defaults=uid=*,gid=*,windows_names
					ntfs:ntfs_defaults=uid=*,gid=*,windows_names
					exfat_defaults=uid=*,gid=*,errors=remount-ro
					UDISKS_CONF
				UDISKS2
                stage_ok
            else
                stage_fail
            fi
        fi
        if [[ -n "${REGDOM}" ]]; then
            local stage_prompt="Wpa_Supplicant Configuration"
            if arch-chroot /mnt <<-WPA > "${log}" 2>&1 ; then
				cat <<-SUPPLICANT > /etc/wpa_supplicant/wpa_supplicant.conf
					country=${REGDOM}
					wps_cred_add_sae=1
					pmf=2
					SUPPLICANT
				WPA
                stage_ok
            else
                stage_fail
            fi
        fi
    fi
}
view_optm() {
    if [[ "${sys_optm}" == "v" ]]; then
        typeset -f optimizations | grep -E 'pacman|/pacman.conf|/pacman.d/hooks|update-pciids|usermod|systemctl|/etc|/mkinitcpio.conf.d|/makepkg.conf.d|/sysctl.d|/polkit-1/rules.d|/systemd/journald.conf.d|/systemd/user.conf.d|/nanorc|/modules-load.d|/sudoers.d|/udisks2|/wpa_supplicant|/udev/rules.d' | less
    fi
}
secboot_sign() {
    if [[ "${sb_sign}" == "y" ]]; then
        local stage_prompt="Secure Boot Signing"
        if arch-chroot /mnt <<-SECSIGN_MAIN > "${log}" 2>&1 ; then
			sbctl create-keys
			sbctl enroll-keys -m
			sbctl sign -s /boot/vmlinuz-${kernel}
			SECSIGN_MAIN
            :
        else
            stage_fail
        fi
        if [[ "${bootloader}" == "1" && "${uki}" == "y" ]]; then
            if arch-chroot /mnt <<-SDBOOT_SECSIGN > "${log}" 2>&1 ; then
				sbctl sign -s ${btldr_esp_mount}/EFI/BOOT/${efiname}.EFI
				sbctl sign -s ${btldr_esp_mount}/EFI/Linux/arch-${kernel}.efi
				sbctl sign -s ${btldr_esp_mount}/EFI/systemd/systemd-bootx${bitness}.efi
				sbctl sign -s -o /usr/lib/systemd/boot/efi/systemd-bootx${bitness}.efi.signed /usr/lib/systemd/boot/efi/systemd-bootx${bitness}.efi
				SDBOOT_SECSIGN
                stage_ok
            else
                stage_fail
            fi
            if [[ "${setrescue}" == "y" ]]; then
                    local stage_prompt="Rescue Entry Secure Boot Signing"
                if arch-chroot /mnt <<-SDBOOT_RESCUE_SECSIGN > "${log}" 2>&1 ; then
					sbctl sign -s ${btldr_esp_mount}/EFI/Linux/rescue.efi
					SDBOOT_RESCUE_SECSIGN
                    stage_ok
                else
                    stage_fail
                fi
            fi
        elif [[ "${bootloader}" == "1" && "${uki}" == "n" ]]; then
            if arch-chroot /mnt <<-SD_XBOOTLDR_SECSIGN > "${log}" 2>&1 ; then
				sbctl sign -s ${btldr_esp_mount}/EFI/BOOT/${efiname}.EFI
				sbctl sign -s ${btldr_esp_mount}/EFI/systemd/systemd-bootx${bitness}.efi
				sbctl sign -s -o /usr/lib/systemd/boot/efi/systemd-bootx${bitness}.efi.signed /usr/lib/systemd/boot/efi/systemd-bootx${bitness}.efi
				SD_XBOOTLDR_SECSIGN
                stage_ok
            else
                stage_fail
            fi
        elif [[ "${bootloader}" == "2" ]]; then
            if [[ "${path}" == "1" ]]; then
                if arch-chroot /mnt <<-GRUB_SECSIGN > "${log}" 2>&1 ; then
					sbctl sign -s ${btldr_esp_mount}/EFI/GRUB/grubx${bitness}.efi
					GRUB_SECSIGN
                    stage_ok
                else
                    stage_fail
                fi
            elif [[ "${path}" == "2" ]]; then
                if arch-chroot /mnt <<-GRUB_FALLBACK_SECSIGN > "${log}" 2>&1 ; then
					sbctl sign -s ${btldr_esp_mount}/EFI/BOOT/${efiname}.EFI
					GRUB_FALLBACK_SECSIGN
                    stage_ok
                else
                    stage_fail
                fi
            fi
        fi
    fi
}
uki_hook() {
        local stage_prompt="UKI Automation"
    if [[ "${uki_use}" == "y" ]]; then
        if arch-chroot /mnt <<-'UKIHOOK' > "${log}" 2>&1 ; then
			mkdir -p /etc/pacman.d/hooks
			cat > "/etc/pacman.d/hooks/uki.hook" <<'UKI_HOOK'
				[Trigger]
				Type = Package
				Operation = Install
				Target = linux
				Target = linux-lts
				Target = linux-hardened
				Target = linux-zen

				[Action]
				Description = Creating UKIs...
				When = PostTransaction
				Exec = /usr/bin/bash -c 'for p in /etc/mkinitcpio.d/*.preset; do k=$(basename "$p" .preset); case "$k" in linux|linux-lts|linux-hardened|linux-zen) sed -i -e "s|^#ALL_config=.*|ALL_config=\"/etc/mkinitcpio.conf.d/mkinitcpiod.conf\"|" -e "s|^default_image=|#default_image=|" -e "s|^#default_uki=.*|default_uki=\"/efi/EFI/Linux/arch-${k}.efi\"|" -e "s|^#default_options=.*|default_options=\"--cmdline /etc/cmdline.d/cmdlined.conf\"|" "$p";; esac; done; /usr/bin/mkinitcpio -P'
				UKI_HOOK
			UKIHOOK
            stage_ok
        else
            stage_fail
        fi
    fi
}
set_vars() {
    if [[ "${multibooting}" == "y" && "${xbootloader}" == "yes" ]]; then
        uki="n"
    fi
        boot_opts=() # ATTENTION Kernel Cmdline
        MODULES=() # ATTENTION Mkinitcpio Modules
        BINARIES=() # ATTENTION Mkinitcpio Binaries
        HOOKS=() # ATTENTION Mkinitcpio Hooks
        [[ "${fs}" == "2" ]] && BINARIES+=(/usr/bin/btrfs)
        # NOTE: Encrypted Setup
    if [[ "${encrypt}" == "yes" ]]; then
        MODULES+=("${fs_mod}")
        encr_root_dev="/dev/mapper/root"
        encr_root_opts="rd.luks.name=$(blkid -s UUID -o value "${root_dev}")=root"
        encr_root_bootopts="${encr_root_opts} root=${encr_root_dev}"
        if [[ "${swapmode}" == "1" ]]; then
            encr_swap_opts="rd.luks.name=$(blkid -s UUID -o value "${swap_dev}")=swap"
            encr_swap_bootopts="resume=/dev/mapper/swap ${encr_swap_opts}"
        elif [[ "${swapmode}" == "2" ]]; then
            if [[ "${fs}" == "1" ]]; then
                offst="$(filefrag -v /mnt/swapfile | awk '$1=="0:" {print substr($4, 1, length($4)-2)}')"
            elif [[ "${fs}" == "2" ]]; then
                offst="$(btrfs inspect-internal map-swapfile -r /mnt/swap/swapfile)"
            fi
            encr_swap_bootopts="resume=${encr_root_dev} resume_offset=${offst}"
        fi
        if [[ "${sep_home}" == "y" && "${hometype}" == "1" ]]; then
            encr_home_bootopts="rd.luks.name=$(blkid -s UUID -o value "${home_dev}")=home"
        fi
        if [[ "${nvidiaprop}" == "y" ]]; then
            HOOKS+=(systemd keyboard autodetect microcode modconf sd-vconsole block sd-encrypt filesystems)
        else
            HOOKS+=(systemd keyboard autodetect microcode modconf kms sd-vconsole block sd-encrypt filesystems)
        fi
        boot_opts+=("${encr_root_bootopts}")
        [[ -n "${encr_swap_bootopts}" ]] && boot_opts+=("${encr_swap_bootopts}")
        [[ -n "${encr_home_bootopts}" ]] && boot_opts+=("${encr_home_bootopts}")
        # NOTE: Unencrypted Setup
    elif [[ "${encrypt}" == "no" ]]; then
        if [[ "${nvidiaprop}" == "y" ]]; then
            HOOKS+=(systemd autodetect microcode modconf keyboard sd-vconsole block filesystems)
        else
            HOOKS+=(systemd autodetect microcode modconf kms keyboard sd-vconsole block filesystems)
        fi
        [[ "${autoroot}" == "y" ]] && boot_opts+=("${multiroot_bootopts}")
    fi
        # NOTE: Graphics
        gfx_bootopts=()
    if [[ "${nvidiaprop}" == "y" ]]; then
        if [[ -z "${swapmode}" ]]; then
            MODULES+=(nvidia nvidia_modeset nvidia_uvm nvidia_drm)
        fi
        gfx_bootopts+=(nvidia.NVreg_UsePageAttributeTable=1)
        [[ "${vendors}" =~ "Intel" ]] && MODULES+=(i915)
        [[ "${vendors}" =~ "AMD" ]] && MODULES+=(amdgpu radeon)
        [[ "${nogsp}" == "y" ]] && gfx_bootopts+=(nvidia.NVreg_EnableGpuFirmware=0)
        [[ "${lowlat}" == "y" ]] && gfx_bootopts+=(nvidia.NVreg_RegistryDwords=RMIntrLockingMode=1)
    fi
    if [[ "${vendor}" == "AMD" || "${vendors}" =~ "AMD" ]]; then
        if [[ -n "${islands}" && -z "${nvidiaprop}" ]]; then
            MODULES+=(amdgpu radeon)
        fi
        if [[ "${islands}" == "1" ]]; then
            gfx_bootopts+=(amdgpu.dc=1 radeon.si_support=0 amdgpu.si_support=1)
        elif [[ "${islands}" == "2" ]]; then
            gfx_bootopts+=(amdgpu.dc=1 radeon.cik_support=0 amdgpu.cik_support=1)
        fi
    fi
        # NOTE: Finalizing Configuration
        [[ "${fs}" == "1" ]] && HOOKS+=(fsck)
        [[ -n "${gfx_bootopts[*]}" ]] && boot_opts+=("${gfx_bootopts[*]}")
        [[ -n "${cust_bootopts}" ]] && boot_opts+=("${cust_bootopts}")
        [[ -n "${btrfs_bootopts}" ]] && boot_opts+=("${btrfs_bootopts}")
        [[ "${swapmode}" == "3" ]] && boot_opts+=(zswap.enabled=0)
        [[ "${kill_watchdog}" == "y" ]] && boot_opts+=(nowatchdog)
        mkinitcpio_mods="MODULES=(${MODULES[*]})"
        mkinitcpio_bins="BINARIES=(${BINARIES[*]})"
        mkinitcpio_hooks="HOOKS=(${HOOKS[*]})"
}
chroot_conf() {
        title "Chroot & Configure System"
        # NOTE: Desktops Configuration:
    if [[ "${desktop}" != "12" ]]; then
        cnfg
        main_chroot
        if [[ -f /mnt/etc/lightdm/lightdm.conf ]]; then
            if [[ "${desktop}" =~ ^(5|8|10)$ ]]; then
                local stage_prompt="GTK Greeter Configuration"
                if arch-chroot /mnt <<-GTK > "${log}" 2>&1 ; then
					sed -i 's|^#greeter-session=example-gtk-gnome|greeter-session=lightdm-gtk-greeter|g' /etc/lightdm/lightdm.conf
					GTK
                    stage_ok
                else
                    stage_fail
                fi
            elif [[ "${desktop}" == "6" ]]; then
                local stage_prompt="Slick Greeter Configuration"
                if arch-chroot /mnt <<-SLICK > "${log}" 2>&1 ; then
					sed -i 's|^#greeter-session=example-gtk-gnome|greeter-session=lightdm-slick-greeter|g' /etc/lightdm/lightdm.conf
					SLICK
                    stage_ok
                else
                    stage_fail
                fi
            elif [[ "${desktop}" == "7" ]]; then
                local stage_prompt="Deepin Greeter Configuration"
                if arch-chroot /mnt <<-DEEPIN > "${log}" 2>&1 ; then
					sed -i 's|^#greeter-session=example-gtk-gnome|greeter-session=lightdm-deepin-greeter|g' /etc/lightdm/lightdm.conf
					DEEPIN
                    stage_ok
                else
                    stage_fail
                fi
            elif [[ "${desktop}" == "14" ]]; then
                local stage_prompt="Pantheon Greeter Configuration"
                if arch-chroot /mnt <<-PANTHEON > "${log}" 2>&1 ; then
					sed -i 's|^#greeter-session=example-gtk-gnome|greeter-session=io.elementary.greeter|g' /etc/lightdm/lightdm.conf
					PANTHEON
                    stage_ok
                else
                    stage_fail
                fi
            fi
        fi
        if [[ "${vendor}" != "Virtual Machine" && "${desktop}" != "11" ]]; then
            local stage_prompt="Bluetooth Service Activation"
            if arch-chroot /mnt <<-BLUETOOTH > "${log}" 2>&1 ; then
				systemctl enable bluetooth
				BLUETOOTH
                stage_ok
            else
                stage_fail
            fi
        fi
        if [[ -n "${displaymanager}" ]]; then
            local stage_prompt="Display Manager Service Activation"
            if arch-chroot /mnt <<-DM > "${log}" 2>&1 ; then
				systemctl enable ${displaymanager}
				DM
                stage_ok
            else
                stage_fail
            fi
        fi
        if [[ "${desktop}" != "12" ]]; then
            local stage_prompt="Network Manager Service Activation"
            if arch-chroot /mnt <<-NETWORK > "${log}" 2>&1 ; then
				systemctl enable NetworkManager
				NETWORK
                stage_ok
            else
                stage_fail
            fi
        fi
    fi
        # NOTE: Custom System Configuration:
    if [[ "${desktop}" == "12" ]]; then
        cnfg
        main_chroot
        if [[ -n "${customservices}" ]]; then
            local stage_prompt="Custom Service(s) Activation"
            if arch-chroot /mnt <<-CUSTOM_SRVC > "${log}" 2>&1 ; then
				systemctl enable ${customservices}
				CUSTOM_SRVC
                stage_ok
            else
                stage_fail
            fi
        fi
    fi
        mkinitcpio_preset
        btldrcfg
        trimcfg
        vm_serv
        zramcfg
        nvidia_hook
        var_opts
        foreign
        optimizations
        secboot_sign
        uki_hook
        completion
        installation="ok"
        umount -R /mnt
        reboot
        exit
}
        nc="\e[0m"
        red="\e[31m"
        cyan="\e[36m"
        blue="\e[94m"
        green="\e[32m"
        redl="\e[1;31m"
        yellow="\e[33m"
        cyanl="\e[1;36m"
        redbg="\e[1;41m"
        magenta="\e[35m"
        bwhite="\e[0;97m"
        cyanbg="\e[1;46m"
        bluebg="\e[1;44m"
        greenl="\e[1;32m"
        greenbg="\e[1;42m"
        yellowl="\e[1;33m"
        magental="\e[1;35m"
        magentabg="\e[1;45m"
        run_as="$(whoami)"
        void="/dev/null"
        log="Amelia.log"
        tty="$(tty)"
        trg=""
        disks="$(lsblk --nodeps --paths --noheadings --output=name,size,model | cat --number)"
        vars=(LOCALESET="" SETLOCALE="" lcl_slct="" USERNAME="" kernelnmbr="" fs="" gfxcount="" gfxcard="" intelcount="" intelcards="" nvidiacount="" nvidiacards="" amdcount="" amdcards="" vendor="" vendors="" desktop="" terminal="" efi_entr_del="" sanity="" install="" bootldr_pkgs="" devel="" REGDOM="" gfx_bootopts="" btrfs_bootopts="" trim="" swapmode="" greeter="" cust_bootopts="" vmpkgs="" vm_services="" perf_stream="" displaymanager="" wireless_reg="" bitness="" bootloader="" gfx_slct="" espsize="" autoroot="" autoesp="" autoxboot="" autohome="" autoswap="" rootprt="" espprt="" xbootprt="" homeprt="" swapprt="" partok="" instl_drive="" sgdsk_nmbr="" part_mode="" preset="" capacity="" cap_gib="" rootsize="" sgdrive="" cgdrive="" smartpart="" presetpart="" prcnt="" roottype="" stage_prompt="" zram="" xbootloader="" multibooting="" hypervisor="" mkinitcpio_mods="" mkinitcpio_bins="" uki="" ukify="" cng_espmnt="" sep_home="" encr_swap_bootopts="" encr_home_bootopts="" uefimode="" luks_encrypt="" nrg_plc="" multilib="" nvname="" nogsp="" luks_root="" luks_swap="" luks_home="" installation="" kill_watchdog="" oomd="" setrescue="" lowlat="" dev="" web="" web_pkg="" web_aur="" web_slct="" printer="" print_pkgs="" shellnmbr="" shell="" shellname="" shellname2="" shell_pkgs="" sys_optm="" set_ext_opt="" ask_param="" desk_setup="" irqbalance="" thermald="" rngd="" rtkit="" tlp="" CRYPTPASS="" CRYPTPASS2="" show_extopts="" gptslct="" gptok="" gptabort="" nvidiaprop="" nowarning="" efiname="" path="" hometype="" homeform="" LuksParts="" nvidia_aur="" web_aur_url="" session="" alt_session="" session_support="" alt_session_pack="" revision="" uki_use="" p="" k="")
        export "${vars[@]}"
        validpkgs=()
        clear
        amelia
        mode_check
        keypress
        clear
        check_fonts
        banner
        uefi_check
        connection_check
        upd_clock
        machine_dtct
        until main_menu; do : ; done