#!/bin/sh

global PATH := ""/sbin:/usr/sbin:$PATH""

global BASE_LOG_FILENAME := '"nvidia-bug-report.log'"

# check if gzip is present
global GZIP_CMD := $[which gzip !2 > /dev/null | head -n 1]
if test $Status -eq 0 -a $GZIP_CMD {
    global GZIP_CMD := '"gzip -c'"
} else {
    global GZIP_CMD := '"cat'"
}

global DPY := $DISPLAY
test $DPY || global DPY := '":0'"

proc set_filename {
    if test $GZIP_CMD = "gzip -c" {
        global LOG_FILENAME := ""$BASE_LOG_FILENAME.gz""
        global OLD_LOG_FILENAME := ""$BASE_LOG_FILENAME.old.gz""
    } else {
        global LOG_FILENAME := $BASE_LOG_FILENAME
        global OLD_LOG_FILENAME := ""$BASE_LOG_FILENAME.old""
    }
}


if test -d /proc/driver/nvidia -a ! -f /proc/driver/nvidia/version {
    global proc_module_dirs := $[ls /proc/driver/nvidia/]
    global module_names := '"nvidia-frontend'"
    for instance in [$proc_module_dirs] {
        global module_names := ""$module_names nvidia$instance""
    }
} else {
    global proc_module_dirs := '".'"
    global module_names := '"nvidia'"
}

proc usage_bug_report_message {
    echo "Please include the '$LOG_FILENAME' log file when reporting"
    echo "your bug via the NVIDIA Linux forum (see devtalk.nvidia.com)"
    echo "or by sending email to 'linux-bugs@nvidia.com'."
}

proc usage {
    echo ""
    echo "$[basename $0]: NVIDIA Linux Graphics Driver bug reporting shell script."
    echo ""
    usage_bug_report_message
    echo ""
    echo "$[basename $0] [OPTION]..."
    echo "    -h / --help"
    echo "        Print this help output and exit."
    echo "    --output-file <file>"
    echo "        Write output to <file>. If gzip is available, the output file"
    echo "        will be automatically compressed, and \".gz\" will be appended"
    echo "        to the filename. Default: write to nvidia-bug-report.log(.gz)."
    echo "    --safe-mode"
    echo "        Disable some parts of the script that may hang the system."
    echo ""
}

global NVIDIA_BUG_REPORT_CHANGE := ''$Change: 21952224 $''
global NVIDIA_BUG_REPORT_VERSION := $[echo $NVIDIA_BUG_REPORT_CHANGE | tr -c -d "[:digit:]]

# Set the default filename so that it won't be empty in the usage message
set_filename

# Parse arguments: Optionally set output file, run in safe mode, or print help
global BUG_REPORT_SAFE_MODE := '0'
global SAVED_FLAGS := $ifsjoin(Argv)
while [ "$1" != "" ] {
    matchstr $1 {
        -o | --output-file  {    if test -z $2 {
                                    usage
                                    exit 1
                                } elif test $[echo $2 | cut -c 1] = "-" {
                                    echo "Warning: Questionable filename"\
                                         "\"$2\": possible missing argument?"
                                }
                                global BASE_LOG_FILENAME := $2
                                # override the default filename
                                set_filename
                                shift
                                }
        --safe-mode  {           global BUG_REPORT_SAFE_MODE := '1'
                                }
        -h | --help  {           usage
                                exit
                                }
        *  {                     usage
                                exit 1
        }
}
    shift
}

#
# echo_metadata() - echo metadata of specified file
#

proc echo_metadata {
    printf "*** ls: "
    /bin/ls -l --full-time $1 !2 > /dev/null

    if test $Status -ne 0 {
        # Run dumb ls -l. We might not get one-second mtime granularity, but
        # that is probably okay.
        ls -l $1
    }
}


#
# append() - append the contents of the specified file to the log
#

proc append {
    shell {
        echo "____________________________________________"
        echo ""

        if test ! -f $1 {
            echo "*** $1 does not exist"
        } elif test ! -r $1 {
            echo "*** $1 is not readable"
        } else {
            echo "*** $1"
            echo_metadata $1
            cat  $1
        }
        echo ""
    } | $GZIP_CMD >> $LOG_FILENAME
}

#
# append_silent() - same as append(), but don't print anything
# if the file does not exist
#

proc append_silent {
    shell {
        if test -f $1 -a -r $1 {
            echo "____________________________________________"
            echo ""
            echo "*** $1"
            echo_metadata $1
            cat  $1
            echo ""
        }
    } | $GZIP_CMD >> $LOG_FILENAME
}

#
# append_glob() - use the shell to expand a list of files, and invoke
# append() for each of them
#

proc append_glob {
    for i in [$[ls $1 !2 > /dev/null]] {
        append $i
    }
}

#
# append_file_or_dir_silent() - if $1 is a regular file, append it; otherwise,
# if $1 is a directory, append all files under it.  Don't print anything if the
# file does not exist.
#

proc append_file_or_dir_silent {
    if test -f $1 {
        append $1
    } elif test -d $1 {
        append_glob "$1/*"
    }
}

#
# append_binary_file() - Encode a binary file into a ascii string format
# using 'base64' and append the contents output to the log file
#

proc append_binary_file {
    shell {
        global base64 := $[which base64 !2 > /dev/null | head -n 1]

        if test $Status -eq 0 -a -x $base64 {
                if test -f $1 -a -r $1 {
                    echo "____________________________________________"
                    echo ""
                    echo "base64 \"$1\""
                    echo ""
                    base64 $1 !2 > /dev/null
                    echo ""
                }
        } else {
            echo "Skipping $1 output (base64 not found)"
            echo ""
        }

    } | $GZIP_CMD >> $LOG_FILENAME
}

#
# search_string_in_logs() - search for string $2 in log file $1
#

proc search_string_in_logs {
    if test -f $1 {
        echo ""
        if test -r $1 {
            echo "  $1:"
            grep $2 $1 !2 > /dev/null
            return 0
        } else {
            echo "$1 is not readable"
        }
    }
    return 1
}

#
# Start of script
#


# check that we are root (needed for `lspci -vxxx` and potentially for
# accessing kernel log files)

if test $[id -u] -ne 0 {
    echo "ERROR: Please run $[basename $0] as root."
    exit 1
}


# move any old log file (zipped) out of the way

if test -f $LOG_FILENAME {
    mv $LOG_FILENAME $OLD_LOG_FILENAME
}


# make sure what we can write to the log file

touch $LOG_FILENAME !2 > /dev/null

if test $Status -ne 0 {
    echo
    echo "ERROR: Working directory is not writable; please cd to a directory"
    echo "       where you have write permission so that the $LOG_FILENAME"
    echo "       file can be written."
    echo
    exit 1
}


# print a start message to stdout

echo ""
echo "nvidia-bug-report.sh will now collect information about your"
echo "system and create the file '$LOG_FILENAME' in the current"
echo "directory.  It may take several seconds to run.  In some"
echo "cases, it may hang trying to capture data generated dynamically"
echo "by the Linux kernel and/or the NVIDIA kernel module.  While"
echo "the bug report log file will be incomplete if this happens, it"
echo "may still contain enough data to diagnose your problem." 
echo ""
usage_bug_report_message
echo ""
echo -n "Running $[basename $0]...";


# print prologue to the log file

shell {
    echo "____________________________________________"
    echo ""
    echo "Start of NVIDIA bug report log file.  Please include this file, along"
    echo "with a detailed description of your problem, when reporting a graphics"
    echo "driver bug via the NVIDIA Linux forum (see devtalk.nvidia.com)"
    echo "or by sending email to 'linux-bugs@nvidia.com'."
    echo ""
    echo "nvidia-bug-report.sh Version: $NVIDIA_BUG_REPORT_VERSION"
    echo ""
    echo "Date: $[date]"
    echo "uname: $[uname -a]"
    echo "command line flags: $SAVED_FLAGS"
    echo ""
} | $GZIP_CMD >> $LOG_FILENAME

# append OPAL (IBM POWER system firmware) messages

append_silent "/sys/firmware/opal/msglog"

# append useful files

append "/etc/issue"

append_silent "/etc/redhat-release"
append_silent "/etc/redhat_version"
append_silent "/etc/fedora-release"
append_silent "/etc/slackware-release"
append_silent "/etc/slackware-version"
append_silent "/etc/debian_release"
append_silent "/etc/debian_version"
append_silent "/etc/mandrake-release"
append_silent "/etc/yellowdog-release"
append_silent "/etc/sun-release"
append_silent "/etc/release"
append_silent "/etc/gentoo-release"


append "/var/log/nvidia-installer.log"
append_silent "/var/log/nvidia-uninstall.log"

# find and append all make.log files in /var/lib/dkms for module nvidia
if test -d "/var/lib/dkms/nvidia" {
    for log in [$[find "/var/lib/dkms/nvidia" -name "make.log]] {
        append $log
    }
}

# use systemd's journalctl to capture X logs where applicable

global journalctl := $[which journalctl !2 > /dev/null | head -n 1]

if test $Status -eq 0 -a -x $journalctl {
    for comm in [Xorg Xorg.bin X] {
        for boot in [-0 -1 -2] {
            if journalctl -b $boot -n 1 _COMM=$comm >/dev/null !2 > !1 {
                shell {
                    echo "____________________________________________"
                    echo ""
                    echo "journalctl -b $boot _COMM=$comm"
                    echo ""
                    journalctl -b $boot _COMM=$comm
                    echo ""
                } 2> /dev/null | $GZIP_CMD >> $LOG_FILENAME
            }
        }
    }
}

# append the X log; also, extract the config file named in the X log
# and append it; look for X log files with names of the form:
# /var/log/{XFree86,Xorg}.{0,1,2,3,4,5,6,7}.{log,log.old}

global xconfig_file_list := ''
global svp_config_file_list := ''
global NEW_LINE := '"
'"

for log_basename in [/var/log/XFree86 /var/log/Xorg] {
    for i in [0 1 2 3 4 5 6 7] {
        for log_suffix in [log log.old] {
            global log_filename := ""$(log_basename).$(i).$(log_suffix)""
            append_silent $(log_filename)

            # look for the X configuration files/directories referenced by this X log
            if test -f $(log_filename) -a -r $(log_filename) {
                global config_file := $[grep "Using config file" $(log_filename) | cut -f 2 -d '"']
                global config_dir := $[grep "Using config directory" $(log_filename) | cut -f 2 -d '"']
                global sys_config_dir := $[grep "Using system config directory" $(log_filename) | cut -f 2 -d '"']
                for j in [$config_file $config_dir $sys_config_dir] {
                    if test $j {
                        # multiple of the logs we find above might reference the
                        # same X configuration file; keep a list of which X
                        # configuration files we find, and only append X
                        # configuration files we have not already appended
                        echo $(xconfig_file_list) | grep ":$(j):" > /dev/null
                        if test "$Status" != "0" {
                            global xconfig_file_list := ""$(xconfig_file_list):$(j):""
                            if test -d $j {
                                append_glob "$j/*.conf"
                            } else {
                                append $j
                            }
                        }
                    }
                }

                # append NVIDIA 3D Vision Pro configuration settings
                global svp_conf_files := $[grep "Option \"3DVisionProConfigFile\"" $(log_filename) | cut -f 4 -d '"']
                if test $(svp_conf_files) {
                    global OLD_IFS := $IFS
                    global IFS := $NEW_LINE
                    for svp_file in [$(svp_conf_files)] {
                        global IFS := $OLD_IFS
                        echo $(svp_config_file_list) | grep ":$(svp_file):" > /dev/null
                        if test "$Status" != "0" {
                            global svp_config_file_list := ""$(svp_config_file_list):$(svp_file):""
                            append_binary_file $(svp_file)
                        }
                        global IFS := $NEW_LINE
                    }
                    global IFS := $OLD_IFS
                }
            }

        }
    }
}

# Append any config files found in home directories
cat /etc/passwd \
    | cut -d : -f 6 \
    | sort | uniq \
    | while read DIR {
        append_file_or_dir_silent "$DIR/.nv/nvidia-application-profiles-rc"
        append_file_or_dir_silent "$DIR/.nv/nvidia-application-profiles-rc.backup"
        append_file_or_dir_silent "$DIR/.nv/nvidia-application-profiles-rc.d"
        append_file_or_dir_silent "$DIR/.nv/nvidia-application-profiles-rc.d.backup"
        append_silent "$DIR/.nv/nvidia-application-profile-globals-rc"
        append_silent "$DIR/.nv/nvidia-application-profile-globals-rc.backup"
        append_silent "$DIR/.nvidia-settings-rc"
    }

# Capture global app profile configs
append_file_or_dir_silent "/etc/nvidia/nvidia-application-profiles-rc"
append_file_or_dir_silent "/etc/nvidia/nvidia-application-profiles-rc.d"
append_file_or_dir_silent /usr/share/nvidia/nvidia-application-profiles-*-rc


# append ldd info

shell {
    echo "____________________________________________"
    echo ""

    global glxinfo := $[which glxinfo !2 > /dev/null | head -n 1]

    if test $Status -eq 0 -a -x $glxinfo {
        echo "ldd $glxinfo"
        echo ""
        ldd $glxinfo !2 > /dev/null
        echo ""
    } else {
        echo "Skipping ldd output (glxinfo not found)"
        echo ""
    }
} | $GZIP_CMD >> $LOG_FILENAME

# lspci information

shell {
    echo "____________________________________________"
    echo ""

    global lspci := $[which lspci !2 > /dev/null | head -n 1]

    if test $Status -eq 0 -a -x $lspci {
        # Capture NVIDIA devices
        echo "$lspci -d \"10de:*\" -v -xxx"
        echo ""
        $lspci -d "10de:*" -v -xxx !2 > /dev/null
        echo ""
        echo "____________________________________________"
        # Capture PLX devices
        echo "$lspci -d \"10b5:*\" -v -xxx"
        echo ""
        $lspci -d "10b5:*" -v -xxx !2 > /dev/null
        echo ""
        echo "____________________________________________"
        echo ""
        echo "$lspci -t"
        echo ""
        $lspci -t !2 > /dev/null
        echo ""
        echo "____________________________________________"
        echo ""
        echo "$lspci -nn"
        echo ""
        $lspci -nn !2 > /dev/null
    } else {
        echo "Skipping lspci output (lspci not found)"
        echo ""
    }
} | $GZIP_CMD >> $LOG_FILENAME

# lsusb information

shell {
    echo "____________________________________________"
    echo ""

    global lsusb := $[which lsusb !2 > /dev/null | head -n 1]

    if test $Status -eq 0 -a -x $lsusb {
        echo $lsusb
        echo ""
        $lsusb !2 > /dev/null
        echo ""
    } else {
        echo "Skipping lsusb output (lsusb not found)"
        echo ""
    }
} | $GZIP_CMD >> $LOG_FILENAME

# dmidecode

shell {
    echo "____________________________________________"
    echo ""

    global dmidecode := $[which dmidecode !2 > /dev/null | head -n 1]

    if test $Status -eq 0 -a -x $dmidecode {
        echo $dmidecode
        echo ""
        $dmidecode !2 > /dev/null
        echo ""
    } else {
        echo "Skipping dmidecode output (dmidecode not found)"
        echo ""
    }
} | $GZIP_CMD >> $LOG_FILENAME

# module version magic

shell {
    echo "____________________________________________"
    echo ""

    global modinfo := $[which modinfo !2 > /dev/null | head -n 1]

    if test $Status -eq 0 -a -x $modinfo {
        for name in [$module_names] {
            echo "$modinfo $name | grep vermagic"
            echo ""
            shell { $modinfo $name | grep vermagic } 2> /dev/null
            echo ""
        }
    } else {
        echo "Skipping modinfo output (modinfo not found)"
        echo ""
    }
} | $GZIP_CMD >> $LOG_FILENAME

# get any relevant kernel messages

shell {
    echo "____________________________________________"
    echo ""
    echo "Scanning kernel log files for NVIDIA kernel messages:"

    global grep_args := '"-e NVRM -e nvidia-'"
    global logfound := '0'
    search_string_in_logs /var/log/messages $grep_args && global logfound := '1'
    search_string_in_logs /var/log/kernel.log $grep_args && global logfound := '1'
    search_string_in_logs /var/log/dmesg $grep_args && global logfound := '1'

    global journalctl := $[which journalctl !2 > /dev/null | head -n 1]
    if test $Status -eq 0 -a -x $journalctl {
        global logfound := '1'
        global nvrmfound := '0'

        for boot in [-0 -1 -2] {
            if journalctl -b $boot | grep $(grep_args) > /dev/null !2 > !1 {
                echo ""
                echo "  journalctl -b $boot:"
                shell {journalctl -b $boot | grep $(grep_args)} 2> /dev/null
                global nvrmfound := '1'
            }
        }

        if test $nvrmfound -eq 0 {
            echo ""
            echo "No NVIDIA kernel messages found in recent systemd journal entries."
        }
    }

    if test $logfound -eq 0 {
        echo ""
        echo "No suitable log found."
    }

    echo ""
} | $GZIP_CMD >> $LOG_FILENAME


# append dmesg output

shell {
    echo "____________________________________________"
    echo ""
    echo "dmesg:"
    echo ""
    dmesg !2 > /dev/null
} | $GZIP_CMD >> $LOG_FILENAME

# print gcc & g++ version info

shell {
    which gcc >/dev/null !2 > !1
    if test $Status -eq 0 {
        echo "____________________________________________"
        echo ""
        gcc -v !2 > !1
    }

    which g++ >/dev/null !2 > !1
    if test $Status -eq 0 {
        echo "____________________________________________"
        echo ""
        g++ -v !2 > !1
    }
} | $GZIP_CMD >> $LOG_FILENAME

# In case of failure, if xset returns with delay, we print the
# message from check "$?" & if it returns error immediately before kill,
# we directly write the error to the log file.

shell {
    echo "____________________________________________"
    echo ""
    echo "xset -q:"
    echo ""

    xset -q !2 > !1 & sleep 1 ; kill -9 $BgPid > /dev/null !2 > !1

    if test $Status -eq 0 {
        # The xset process is still there.
        echo "xset could not connect to an X server"
    }
} | $GZIP_CMD >> $LOG_FILENAME

# In case of failure, if nvidia-settings returns with delay, we print the
# message from check "$?" & if it returns error immediately before kill,
# we directly write the error to the log file.

shell {
    echo "____________________________________________"
    echo ""
    echo "nvidia-settings -q all:"
    echo ""

    env DISPLAY= nvidia-settings -c $DPY -q all !2 > !1 & sleep 1 ; kill -9 $BgPid > /dev/null !2 > !1

    if test $Status -eq 0 {
        # The nvidia-settings process is still there.
        echo "nvidia-settings could not connect to an X server"
    }
} | $GZIP_CMD >> $LOG_FILENAME

# In case of failure, if xrandr returns with delay, we print the
# message from check "$?" & if it returns error immediately before kill,
# we directly write the error to the log file.

shell {
    if test -x $[which xrandr !2 >/dev/null]  {
         echo "____________________________________________"
         echo ""
         echo "xrandr --verbose:"
         echo ""

         xrandr -display $DPY --verbose !2 > !1 & sleep 1 ; kill -9 $BgPid > /dev/null !2 > !1
         if test $Status -eq 0 {
             # The xrandr process is still there.
             echo "xrandr could not connect to an X server"
         }
    } else {
        echo "Skipping xrandr output (xrandr not found)"
    }
} | $GZIP_CMD >> $LOG_FILENAME

shell {
    if test -x $[which xprop !2 >/dev/null]  {
        echo "____________________________________________"
        echo ""
        echo "Running window manager properties:"
        echo ""

        global TMP := $[xprop -root _NET_SUPPORTING_WM_CHECK !2 >/dev/null & sleep 1 ; kill -9 $BgPid > /dev/null !2 > !1]
        global WINDOW := $[echo $TMP | grep -o '0x[0-9a-z]\+]
        if test $WINDOW {
            xprop -id $WINDOW !2 > !1 & sleep 1 ; kill -9 $BgPid > /dev/null !2 > !1
        } else {
            echo "Unable to detect window manager properties"
        }
    }
} | $GZIP_CMD >> $LOG_FILENAME

sync > /dev/null !2 > !1
sync > /dev/null !2 > !1

# append useful /proc files

append "/proc/cmdline"
append "/proc/cpuinfo"
append "/proc/interrupts"
append "/proc/meminfo"
append "/proc/modules"
append "/proc/version"
append "/proc/pci"
append "/proc/iomem"
append "/proc/mtrr"

for subdir in [$proc_module_dirs] {
    append "/proc/driver/nvidia/$subdir/version"
    for GPU in [$[ls /proc/driver/nvidia/$subdir/gpus/]] {
        append "/proc/driver/nvidia/$subdir/gpus/$GPU/information"
        append "/proc/driver/nvidia/$subdir/gpus/$GPU/registry"
    }
    append_glob "/proc/driver/nvidia/$subdir/warnings/*"
    append "/proc/driver/nvidia/$subdir/params"
    append "/proc/driver/nvidia/$subdir/registry"
}

append_glob "/proc/acpi/video/*/*/info"

append "/proc/asound/cards"
append "/proc/asound/pcm"
append "/proc/asound/modules"
append "/proc/asound/devices"
append "/proc/asound/version"
append "/proc/asound/timers"
append "/proc/asound/hwdep"

for CARD in [/proc/asound/card[0-9]*] {
    for CODEC in [$CARD/codec*] {
        test -d $CODEC && append_glob "$CODEC/*"
        test -f $CODEC && append $CODEC
    }
    for ELD in [$CARD/eld*] {
        test -f $ELD && append $ELD
    }
}

# disable these when safemode is requested
if test $BUG_REPORT_SAFE_MODE -eq 0 {

    # Inform user about safemode
    shell {
        echo ""
        echo ""
        echo "If the bug report script hangs after this point consider running with"
        echo "--safe-mode command line argument."
        echo ""
    }
    
    # nvidia-smi

    shell {
        echo "____________________________________________"
        echo ""

        global nvidia_smi := $[which nvidia-smi !2 > /dev/null | head -n 1]

        if test $Status -eq 0 -a -x $nvidia_smi {
            for instance in [$proc_module_dirs] {
                if test $instance != '.' {
                    export __RM_MODULE_INSTANCE=$instance
                    echo "NVIDIA Kernel module instance $instance"
                }
                echo "$nvidia_smi -q"
                echo ""
                $nvidia_smi -q
                echo ""

                echo "$nvidia_smi -q -u"
                echo ""
                $nvidia_smi -q -u
                echo ""
                unset __RM_MODULE_INSTANCE
            }
        } else {
            echo "Skipping nvidia-smi output (nvidia-smi not found)"
            echo ""
        }
    } | $GZIP_CMD >> $LOG_FILENAME

    # nvidia-debugdump

    shell {
        echo "____________________________________________"
        echo ""

        global nvidia_debugdump := $[which nvidia-debugdump !2 > /dev/null | head -n 1]

        if test $Status -eq 0 -a -x $nvidia_debugdump {
        
            global base64 := $[which base64 !2 > /dev/null | head -n 1]
            
            if test $Status -eq 0 -a -x $base64 {
                # make sure what we can write to the temp file
                
                global NVDD_TEMP_FILENAME := ""nvidia-debugdump-temp$Pid.log""
                
                touch $NVDD_TEMP_FILENAME !2 > /dev/null

                if test $Status -ne 0 {
                    echo "Skipping nvidia-debugdump output (can't create temp file $NVDD_TEMP_FILENAME)"
                    echo ""
                    # don't fail here, continue
                } else {
                    for instance in [$proc_module_dirs] {
                        if test $instance != '.' {
                            export __RM_MODULE_INSTANCE=$instance
                            echo "NVIDIA Kernel module instance $instance"
                        }

                        echo "$nvidia_debugdump -D"
                        echo ""
                        $nvidia_debugdump -D -f $NVDD_TEMP_FILENAME !2 > /dev/null
                        $base64 $NVDD_TEMP_FILENAME !2 > /dev/null
                        echo ""

                        # remove the temporary file when complete
                        rm $NVDD_TEMP_FILENAME !2 > /dev/null
                        unset __RM_MODULE_INSTANCE
                    }
                }
            } else {
                echo "Skipping nvidia-debugdump output (base64 not found)"
                echo ""
            }
        } else {
            echo "Skipping nvidia-debugdump output (nvidia-debugdump not found)"
            echo ""
        }
    } | $GZIP_CMD >> $LOG_FILENAME

} else {
    shell {
        echo "Skipping nvidia-smi and nvidia-debugdump due to --safe-mode argument."
        echo ""
    } | $GZIP_CMD >> $LOG_FILENAME
}

shell {
    echo "____________________________________________"

    # print epilogue to log file

    echo ""
    echo "End of NVIDIA bug report log file."
} | $GZIP_CMD >> $LOG_FILENAME

# Done

echo " complete."
echo ""
(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:PATH)
          op: Equal
          rhs: {(DQ ("/sbin:/usr/sbin:") ($ VSub_Name "$PATH"))}
          spids: [4]
        )
      ]
      spids: [4]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:BASE_LOG_FILENAME)
          op: Equal
          rhs: {(DQ (nvidia-bug-report.log))}
          spids: [11]
        )
      ]
      spids: [11]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:GZIP_CMD)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (Pipeline
                        children: [
                          (SimpleCommand
                            words: [{(which)} {(gzip)}]
                            redirects: [
                              (Redir
                                op_id: Redir_Great
                                fd: 2
                                arg_word: {(/dev/null)}
                                spids: [26]
                              )
                            ]
                          )
                          (C {(head)} {(-n)} {(1)})
                        ]
                        negated: False
                      )
                    ]
                  )
                left_token: <Left_Backtick "`">
                spids: [21 37]
              )
            }
          spids: [20]
        )
      ]
      spids: [20]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (C {(Lit_Other "[")} {($ VSub_QMark "$?")} {(-eq)} {(0)} {(-a)} 
                  {(DQ ($ VSub_Name "$GZIP_CMD"))} {(Lit_Other "]")}
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:GZIP_CMD)
                  op: Equal
                  rhs: {(DQ ("gzip -c"))}
                  spids: [61]
                )
              ]
              spids: [61]
            )
          ]
          spids: [-1 58]
        )
      ]
      else_action: [
        (Assignment
          keyword: Assign_None
          pairs: [(assign_pair lhs:(LhsName name:GZIP_CMD) op:Equal rhs:{(DQ (cat))} spids:[69])]
          spids: [69]
        )
      ]
      spids: [66 74]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:DPY)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$DISPLAY"))}
          spids: [77]
        )
      ]
      spids: [77]
    )
    (AndOr
      children: [
        (C {(Lit_Other "[")} {(DQ ($ VSub_Name "$DPY"))} {(Lit_Other "]")})
        (Assignment
          keyword: Assign_None
          pairs: [(assign_pair lhs:(LhsName name:DPY) op:Equal rhs:{(DQ (":0"))} spids:[92])]
          spids: [92]
        )
      ]
      op_id: Op_DPipe
    )
    (FuncDef
      name: set_filename
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(DQ ($ VSub_Name "$GZIP_CMD"))} {(Lit_Other "=")} 
                          {(DQ ("gzip -c"))} {(Lit_Other "]")}
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:LOG_FILENAME)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$BASE_LOG_FILENAME") (.gz))}
                          spids: [125]
                        )
                      ]
                      spids: [125]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:OLD_LOG_FILENAME)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$BASE_LOG_FILENAME") (.old.gz))}
                          spids: [132]
                        )
                      ]
                      spids: [132]
                    )
                  ]
                  spids: [-1 122]
                )
              ]
              else_action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:LOG_FILENAME)
                      op: Equal
                      rhs: {($ VSub_Name "$BASE_LOG_FILENAME")}
                      spids: [142]
                    )
                  ]
                  spids: [142]
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:OLD_LOG_FILENAME)
                      op: Equal
                      rhs: {(DQ ($ VSub_Name "$BASE_LOG_FILENAME") (.old))}
                      spids: [146]
                    )
                  ]
                  spids: [146]
                )
              ]
              spids: [139 153]
            )
          ]
          spids: [102]
        )
      spids: [98 101]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (C {(Lit_Other "[")} {(-d)} {(/proc/driver/nvidia)} {(-a)} {(KW_Bang "!")} {(-f)} 
                  {(/proc/driver/nvidia/version)} {(Lit_Other "]")}
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:proc_module_dirs)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: (CommandList children:[(C {(ls)} {(/proc/driver/nvidia/)})])
                        left_token: <Left_Backtick "`">
                        spids: [182 186]
                      )
                    }
                  spids: [181]
                )
              ]
              spids: [181]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:module_names)
                  op: Equal
                  rhs: {(DQ (nvidia-frontend))}
                  spids: [189]
                )
              ]
              spids: [189]
            )
            (ForEach
              iter_name: instance
              iter_words: [{($ VSub_Name "$proc_module_dirs")}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:module_names)
                          op: Equal
                          rhs: 
                            {
                              (DQ ($ VSub_Name "$module_names") (" nvidia") ($ VSub_Name "$instance"))
                            }
                          spids: [207]
                        )
                      ]
                      spids: [207]
                    )
                  ]
                  spids: [204 215]
                )
              spids: [200 202]
            )
          ]
          spids: [-1 178]
        )
      ]
      else_action: [
        (Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (LhsName name:proc_module_dirs)
              op: Equal
              rhs: {(DQ (.))}
              spids: [220]
            )
          ]
          spids: [220]
        )
        (Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (LhsName name:module_names)
              op: Equal
              rhs: {(DQ (nvidia))}
              spids: [226]
            )
          ]
          spids: [226]
        )
      ]
      spids: [217 231]
    )
    (FuncDef
      name: usage_bug_report_message
      body: 
        (BraceGroup
          children: [
            (C {(echo)} 
              {
                (DQ ("Please include the '") ($ VSub_Name "$LOG_FILENAME") 
                  ("' log file when reporting")
                )
              }
            )
            (C {(echo)} {(DQ ("your bug via the NVIDIA Linux forum (see devtalk.nvidia.com)"))})
            (C {(echo)} {(DQ ("or by sending email to 'linux-bugs@nvidia.com'."))})
          ]
          spids: [238]
        )
      spids: [234 237]
    )
    (FuncDef
      name: usage
      body: 
        (BraceGroup
          children: [
            (C {(echo)} {(DQ )})
            (C {(echo)} 
              {
                (DQ 
                  (CommandSubPart
                    command_list: (CommandList children:[(C {(basename)} {($ VSub_Number "$0")})])
                    left_token: <Left_CommandSub "$(">
                    spids: [282 286]
                  ) (": NVIDIA Linux Graphics Driver bug reporting shell script.")
                )
              }
            )
            (C {(echo)} {(DQ )})
            (C {(usage_bug_report_message)})
            (C {(echo)} {(DQ )})
            (C {(echo)} 
              {
                (DQ 
                  (CommandSubPart
                    command_list: (CommandList children:[(C {(basename)} {($ VSub_Number "$0")})])
                    left_token: <Left_CommandSub "$(">
                    spids: [309 313]
                  ) (" [OPTION]...")
                )
              }
            )
            (C {(echo)} {(DQ ("    -h / --help"))})
            (C {(echo)} {(DQ ("        Print this help output and exit."))})
            (C {(echo)} {(DQ ("    --output-file <file>"))})
            (C {(echo)} {(DQ ("        Write output to <file>. If gzip is available, the output file"))})
            (C {(echo)} 
              {
                (DQ ("        will be automatically compressed, and ") 
                  (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (.gz) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" will be appended")
                )
              }
            )
            (C {(echo)} 
              {(DQ ("        to the filename. Default: write to nvidia-bug-report.log(.gz)."))}
            )
            (C {(echo)} {(DQ ("    --safe-mode"))})
            (C {(echo)} {(DQ ("        Disable some parts of the script that may hang the system."))})
            (C {(echo)} {(DQ )})
          ]
          spids: [270]
        )
      spids: [266 269]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:NVIDIA_BUG_REPORT_CHANGE)
          op: Equal
          rhs: {(SQ <"$Change: 21952224 $">)}
          spids: [386]
        )
      ]
      spids: [386]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:NVIDIA_BUG_REPORT_VERSION)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (Pipeline
                        children: [
                          (C {(echo)} {(DQ ($ VSub_Name "$NVIDIA_BUG_REPORT_CHANGE"))})
                          (C {(tr)} {(-c)} {(-d)} {(DQ ("[:digit:]"))})
                        ]
                        negated: False
                      )
                    ]
                  )
                left_token: <Left_Backtick "`">
                spids: [392 410]
              )
            }
          spids: [391]
        )
      ]
      spids: [391]
    )
    (C {(set_filename)})
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:BUG_REPORT_SAFE_MODE) op:Equal rhs:{(0)} spids:[422])]
      spids: [422]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:SAVED_FLAGS)
          op: Equal
          rhs: {($ VSub_At "$@")}
          spids: [425]
        )
      ]
      spids: [425]
    )
    (While
      cond: [
        (Sentence
          child: 
            (C {(Lit_Other "[")} {(DQ ($ VSub_Number "$1"))} {(KW_Bang "!") (Lit_Other "=")} {(DQ )} 
              {(Lit_Other "]")}
            )
          terminator: <Op_Semi ";">
        )
      ]
      body: 
        (DoGroup
          children: [
            (Case
              to_match: {($ VSub_Number "$1")}
              arms: [
                (case_arm
                  pat_list: [{(-o)} {(--output-file)}]
                  action: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(Lit_Other "[")} {(-z)} {($ VSub_Number "$2")} {(Lit_Other "]")})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [(C {(usage)}) (C {(exit)} {(1)})]
                          spids: [-1 474]
                        )
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(Lit_Other "[")} 
                                  {
                                    (DQ 
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (Pipeline
                                                children: [
                                                  (C {(echo)} {(DQ ($ VSub_Number "$2"))})
                                                  (C {(cut)} {(-c)} {(1)})
                                                ]
                                                negated: False
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub "$(">
                                        spids: [490 504]
                                      )
                                    )
                                  } {(Lit_Other "=")} {(DQ (-))} {(Lit_Other "]")}
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(echo)} {(DQ ("Warning: Questionable filename"))} 
                              {
                                (DQ (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                  ($ VSub_Number "$2") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (": possible missing argument?")
                                )
                              }
                            )
                          ]
                          spids: [485 516]
                        )
                      ]
                      spids: [-1 534]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:BASE_LOG_FILENAME)
                          op: Equal
                          rhs: {(DQ ($ VSub_Number "$2"))}
                          spids: [537]
                        )
                      ]
                      spids: [537]
                    )
                    (C {(set_filename)})
                    (C {(shift)})
                  ]
                  spids: [455 461 553 -1]
                )
                (case_arm
                  pat_list: [{(--safe-mode)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:BUG_REPORT_SAFE_MODE)
                          op: Equal
                          rhs: {(1)}
                          spids: [560]
                        )
                      ]
                      spids: [560]
                    )
                  ]
                  spids: [556 558 564 -1]
                )
                (case_arm
                  pat_list: [{(-h)} {(--help)}]
                  action: [(C {(usage)}) (C {(exit)})]
                  spids: [567 573 581 -1]
                )
                (case_arm
                  pat_list: [{(Lit_Other "*")}]
                  action: [(C {(usage)}) (C {(exit)} {(1)})]
                  spids: [584 586 -1 596]
                )
              ]
              spids: [448 452 596]
            )
            (C {(shift)})
          ]
          spids: [445 601]
        )
    )
    (FuncDef
      name: echo_metadata
      body: 
        (BraceGroup
          children: [
            (C {(printf)} {(DQ ("*** ls: "))})
            (SimpleCommand
              words: [{(/bin/ls)} {(-l)} {(--full-time)} {(DQ ($ VSub_Number "$1"))}]
              redirects: [(Redir op_id:Redir_Great fd:2 arg_word:{(/dev/null)} spids:[638])]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {($ VSub_QMark "$?")} {(-ne)} {(0)} {(Lit_Other "]")})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [(C {(ls)} {(-l)} {(DQ ($ VSub_Number "$1"))})]
                  spids: [-1 657]
                )
              ]
              spids: [-1 677]
            )
          ]
          spids: [618]
        )
      spids: [614 617]
    )
    (FuncDef
      name: append
      body: 
        (BraceGroup
          children: [
            (Pipeline
              children: [
                (Subshell
                  child: 
                    (CommandList
                      children: [
                        (C {(echo)} {(DQ (____________________________________________))})
                        (C {(echo)} {(DQ )})
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (Sentence
                                  child: 
                                    (C {(Lit_Other "[")} {(KW_Bang "!")} {(-f)} 
                                      {(DQ ($ VSub_Number "$1"))} {(Lit_Other "]")}
                                    )
                                  terminator: <Op_Semi ";">
                                )
                              ]
                              action: [
                                (C {(echo)} {(DQ ("*** ") ($ VSub_Number "$1") (" does not exist"))})
                              ]
                              spids: [-1 732]
                            )
                            (if_arm
                              cond: [
                                (Sentence
                                  child: 
                                    (C {(Lit_Other "[")} {(KW_Bang "!")} {(-r)} 
                                      {(DQ ($ VSub_Number "$1"))} {(Lit_Other "]")}
                                    )
                                  terminator: <Op_Semi ";">
                                )
                              ]
                              action: [
                                (C {(echo)} {(DQ ("*** ") ($ VSub_Number "$1") (" is not readable"))})
                              ]
                              spids: [744 759]
                            )
                          ]
                          else_action: [
                            (C {(echo)} {(DQ ("*** ") ($ VSub_Number "$1"))})
                            (C {(echo_metadata)} {(DQ ($ VSub_Number "$1"))})
                            (C {(cat)} {(DQ ($ VSub_Number "$1"))})
                          ]
                          spids: [771 796]
                        )
                        (C {(echo)} {(DQ )})
                      ]
                    )
                  spids: [700 805]
                )
                (SimpleCommand
                  words: [{($ VSub_Name "$GZIP_CMD")}]
                  redirects: [
                    (Redir
                      op_id: Redir_DGreat
                      fd: -1
                      arg_word: {($ VSub_Name "$LOG_FILENAME")}
                      spids: [811]
                    )
                  ]
                )
              ]
              negated: False
            )
          ]
          spids: [697]
        )
      spids: [693 696]
    )
    (FuncDef
      name: append_silent
      body: 
        (BraceGroup
          children: [
            (Pipeline
              children: [
                (Subshell
                  child: 
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(Lit_Other "[")} {(-f)} {(DQ ($ VSub_Number "$1"))} {(-a)} {(-r)} 
                                  {(DQ ($ VSub_Number "$1"))} {(Lit_Other "]")}
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(echo)} {(DQ (____________________________________________))})
                            (C {(echo)} {(DQ )})
                            (C {(echo)} {(DQ ("*** ") ($ VSub_Number "$1"))})
                            (C {(echo_metadata)} {(DQ ($ VSub_Number "$1"))})
                            (C {(cat)} {(DQ ($ VSub_Number "$1"))})
                            (C {(echo)} {(DQ )})
                          ]
                          spids: [-1 862]
                        )
                      ]
                      spids: [-1 906]
                    )
                  spids: [838 909]
                )
                (SimpleCommand
                  words: [{($ VSub_Name "$GZIP_CMD")}]
                  redirects: [
                    (Redir
                      op_id: Redir_DGreat
                      fd: -1
                      arg_word: {($ VSub_Name "$LOG_FILENAME")}
                      spids: [915]
                    )
                  ]
                )
              ]
              negated: False
            )
          ]
          spids: [835]
        )
      spids: [831 834]
    )
    (FuncDef
      name: append_glob
      body: 
        (BraceGroup
          children: [
            (ForEach
              iter_name: i
              iter_words: [
                {
                  (CommandSubPart
                    command_list: 
                      (CommandList
                        children: [
                          (Sentence
                            child: 
                              (SimpleCommand
                                words: [{(ls)} {($ VSub_Number "$1")}]
                                redirects: [
                                  (Redir
                                    op_id: Redir_Great
                                    fd: 2
                                    arg_word: {(/dev/null)}
                                    spids: [953]
                                  )
                                ]
                              )
                            terminator: <Op_Semi ";">
                          )
                        ]
                      )
                    left_token: <Left_Backtick "`">
                    spids: [948 957]
                  )
                }
              ]
              do_arg_iter: False
              body: (DoGroup children:[(C {(append)} {(DQ ($ VSub_Name "$i"))})] spids:[960970])
              spids: [947 958]
            )
          ]
          spids: [939]
        )
      spids: [935 938]
    )
    (FuncDef
      name: append_file_or_dir_silent
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: (C {(Lit_Other "[")} {(-f)} {(DQ ($ VSub_Number "$1"))} {(Lit_Other "]")})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [(C {(append)} {(DQ ($ VSub_Number "$1"))})]
                  spids: [-1 1011]
                )
                (if_arm
                  cond: [
                    (Sentence
                      child: (C {(Lit_Other "[")} {(-d)} {(DQ ($ VSub_Number "$1"))} {(Lit_Other "]")})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [(C {(append_glob)} {(DQ ($ VSub_Number "$1") ("/*"))})]
                  spids: [1021 1034]
                )
              ]
              spids: [-1 1045]
            )
          ]
          spids: [995]
        )
      spids: [991 994]
    )
    (FuncDef
      name: append_binary_file
      body: 
        (BraceGroup
          children: [
            (Pipeline
              children: [
                (Subshell
                  child: 
                    (CommandList
                      children: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:base64)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (Pipeline
                                            children: [
                                              (SimpleCommand
                                                words: [{(which)} {(base64)}]
                                                redirects: [
                                                  (Redir
                                                    op_id: Redir_Great
                                                    fd: 2
                                                    arg_word: {(/dev/null)}
                                                    spids: [1079]
                                                  )
                                                ]
                                              )
                                              (C {(head)} {(-n)} {(1)})
                                            ]
                                            negated: False
                                          )
                                        ]
                                      )
                                    left_token: <Left_Backtick "`">
                                    spids: [1074 1090]
                                  )
                                }
                              spids: [1073]
                            )
                          ]
                          spids: [1073]
                        )
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (Sentence
                                  child: 
                                    (C {(Lit_Other "[")} {($ VSub_QMark "$?")} {(-eq)} {(0)} {(-a)} {(-x)} 
                                      {(DQ ($ VSub_Name "$base64"))} {(Lit_Other "]")}
                                    )
                                  terminator: <Op_Semi ";">
                                )
                              ]
                              action: [
                                (If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (Sentence
                                          child: 
                                            (C {(Lit_Other "[")} {(-f)} {(DQ ($ VSub_Number "$1"))} 
                                              {(-a)} {(-r)} {(DQ ($ VSub_Number "$1"))} {(Lit_Other "]")}
                                            )
                                          terminator: <Op_Semi ";">
                                        )
                                      ]
                                      action: [
                                        (C {(echo)} 
                                          {(DQ (____________________________________________))}
                                        )
                                        (C {(echo)} {(DQ )})
                                        (C {(echo)} 
                                          {
                                            (DQ ("base64 ") 
                                              (EscapedLiteralPart
                                                token: <Lit_EscapedChar "\\\"">
                                              ) ($ VSub_Number "$1") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                            )
                                          }
                                        )
                                        (C {(echo)} {(DQ )})
                                        (SimpleCommand
                                          words: [{(base64)} {(DQ ($ VSub_Number "$1"))}]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_Great
                                              fd: 2
                                              arg_word: {(/dev/null)}
                                              spids: [1177]
                                            )
                                          ]
                                        )
                                        (C {(echo)} {(DQ )})
                                      ]
                                      spids: [-1 1139]
                                    )
                                  ]
                                  spids: [-1 1188]
                                )
                              ]
                              spids: [-1 1115]
                            )
                          ]
                          else_action: [
                            (C {(echo)} 
                              {
                                (DQ ("Skipping ") ($ VSub_Number "$1") (" output (base64 not found)"))
                              }
                            )
                            (C {(echo)} {(DQ )})
                          ]
                          spids: [1191 1209]
                        )
                      ]
                    )
                  spids: [1070 1213]
                )
                (SimpleCommand
                  words: [{($ VSub_Name "$GZIP_CMD")}]
                  redirects: [
                    (Redir
                      op_id: Redir_DGreat
                      fd: -1
                      arg_word: {($ VSub_Name "$LOG_FILENAME")}
                      spids: [1219]
                    )
                  ]
                )
              ]
              negated: False
            )
          ]
          spids: [1067]
        )
      spids: [1063 1066]
    )
    (FuncDef
      name: search_string_in_logs
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: (C {(Lit_Other "[")} {(-f)} {(DQ ($ VSub_Number "$1"))} {(Lit_Other "]")})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(echo)} {(DQ )})
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(Lit_Other "[")} {(-r)} {(DQ ($ VSub_Number "$1"))} {(Lit_Other "]")})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(echo)} {(DQ ("  ") ($ VSub_Number "$1") (":"))})
                            (SimpleCommand
                              words: [{(grep)} {($ VSub_Number "$2")} {(DQ ($ VSub_Number "$1"))}]
                              redirects: [
                                (Redir
                                  op_id: Redir_Great
                                  fd: 2
                                  arg_word: {(/dev/null)}
                                  spids: [1298]
                                )
                              ]
                            )
                            (ControlFlow
                              token: <ControlFlow_Return return>
                              arg_word: {(0)}
                            )
                          ]
                          spids: [-1 1278]
                        )
                      ]
                      else_action: [(C {(echo)} {(DQ ($ VSub_Number "$1") (" is not readable"))})]
                      spids: [1308 1319]
                    )
                  ]
                  spids: [-1 1256]
                )
              ]
              spids: [-1 1322]
            )
            (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
          ]
          spids: [1240]
        )
      spids: [1236 1239]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (C {(Lit_Other "[")} 
                  {
                    (CommandSubPart
                      command_list: (CommandList children:[(C {(id)} {(-u)})])
                      left_token: <Left_Backtick "`">
                      spids: [1354 1358]
                    )
                  } {(-ne)} {(0)} {(Lit_Other "]")}
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (C {(echo)} 
              {
                (DQ ("ERROR: Please run ") 
                  (CommandSubPart
                    command_list: (CommandList children:[(C {(basename)} {($ VSub_Number "$0")})])
                    left_token: <Left_CommandSub "$(">
                    spids: [1374 1378]
                  ) (" as root.")
                )
              }
            )
            (C {(exit)} {(1)})
          ]
          spids: [-1 1367]
        )
      ]
      spids: [-1 1387]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: (C {(Lit_Other "[")} {(-f)} {($ VSub_Name "$LOG_FILENAME")} {(Lit_Other "]")})
              terminator: <Op_Semi ";">
            )
          ]
          action: [(C {(mv)} {($ VSub_Name "$LOG_FILENAME")} {($ VSub_Name "$OLD_LOG_FILENAME")})]
          spids: [-1 1406]
        )
      ]
      spids: [-1 1415]
    )
    (SimpleCommand
      words: [{(touch)} {($ VSub_Name "$LOG_FILENAME")}]
      redirects: [(Redir op_id:Redir_Great fd:2 arg_word:{(/dev/null)} spids:[1427])]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: (C {(Lit_Other "[")} {($ VSub_QMark "$?")} {(-ne)} {(0)} {(Lit_Other "]")})
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (C {(echo)})
            (C {(echo)} {(DQ ("ERROR: Working directory is not writable; please cd to a directory"))})
            (C {(echo)} 
              {
                (DQ ("       where you have write permission so that the ") 
                  ($ VSub_Name "$LOG_FILENAME")
                )
              }
            )
            (C {(echo)} {(DQ ("       file can be written."))})
            (C {(echo)})
            (C {(exit)} {(1)})
          ]
          spids: [-1 1445]
        )
      ]
      spids: [-1 1480]
    )
    (C {(echo)} {(DQ )})
    (C {(echo)} {(DQ ("nvidia-bug-report.sh will now collect information about your"))})
    (C {(echo)} 
      {(DQ ("system and create the file '") ($ VSub_Name "$LOG_FILENAME") ("' in the current"))}
    )
    (C {(echo)} {(DQ ("directory.  It may take several seconds to run.  In some"))})
    (C {(echo)} {(DQ ("cases, it may hang trying to capture data generated dynamically"))})
    (C {(echo)} {(DQ ("by the Linux kernel and/or the NVIDIA kernel module.  While"))})
    (C {(echo)} {(DQ ("the bug report log file will be incomplete if this happens, it"))})
    (C {(echo)} {(DQ ("may still contain enough data to diagnose your problem."))})
    (C {(echo)} {(DQ )})
    (C {(usage_bug_report_message)})
    (C {(echo)} {(DQ )})
    (Sentence
      child: 
        (C {(echo)} {(-n)} 
          {
            (DQ ("Running ") 
              (CommandSubPart
                command_list: (CommandList children:[(C {(basename)} {($ VSub_Number "$0")})])
                left_token: <Left_CommandSub "$(">
                spids: [1556 1560]
              ) (...)
            )
          }
        )
      terminator: <Op_Semi ";">
    )
    (Pipeline
      children: [
        (Subshell
          child: 
            (CommandList
              children: [
                (C {(echo)} {(DQ (____________________________________________))})
                (C {(echo)} {(DQ )})
                (C {(echo)} 
                  {(DQ ("Start of NVIDIA bug report log file.  Please include this file, along"))}
                )
                (C {(echo)} 
                  {(DQ ("with a detailed description of your problem, when reporting a graphics"))}
                )
                (C {(echo)} {(DQ ("driver bug via the NVIDIA Linux forum (see devtalk.nvidia.com)"))})
                (C {(echo)} {(DQ ("or by sending email to 'linux-bugs@nvidia.com'."))})
                (C {(echo)} {(DQ )})
                (C {(echo)} 
                  {
                    (DQ ("nvidia-bug-report.sh Version: ") ($ VSub_Name "$NVIDIA_BUG_REPORT_VERSION"))
                  }
                )
                (C {(echo)} {(DQ )})
                (C {(echo)} 
                  {
                    (DQ ("Date: ") 
                      (CommandSubPart
                        command_list: (CommandList children:[(C {(date)})])
                        left_token: <Left_Backtick "`">
                        spids: [1639 1641]
                      )
                    )
                  }
                )
                (C {(echo)} 
                  {
                    (DQ ("uname: ") 
                      (CommandSubPart
                        command_list: (CommandList children:[(C {(uname)} {(-a)})])
                        left_token: <Left_Backtick "`">
                        spids: [1649 1653]
                      )
                    )
                  }
                )
                (C {(echo)} {(DQ ("command line flags: ") ($ VSub_Name "$SAVED_FLAGS"))})
                (C {(echo)} {(DQ )})
              ]
            )
          spids: [1571 1670]
        )
        (SimpleCommand
          words: [{($ VSub_Name "$GZIP_CMD")}]
          redirects: [
            (Redir
              op_id: Redir_DGreat
              fd: -1
              arg_word: {($ VSub_Name "$LOG_FILENAME")}
              spids: [1676]
            )
          ]
        )
      ]
      negated: False
    )
    (C {(append_silent)} {(DQ (/sys/firmware/opal/msglog))})
    (C {(append)} {(DQ (/etc/issue))})
    (C {(append_silent)} {(DQ (/etc/redhat-release))})
    (C {(append_silent)} {(DQ (/etc/redhat_version))})
    (C {(append_silent)} {(DQ (/etc/fedora-release))})
    (C {(append_silent)} {(DQ (/etc/slackware-release))})
    (C {(append_silent)} {(DQ (/etc/slackware-version))})
    (C {(append_silent)} {(DQ (/etc/debian_release))})
    (C {(append_silent)} {(DQ (/etc/debian_version))})
    (C {(append_silent)} {(DQ (/etc/mandrake-release))})
    (C {(append_silent)} {(DQ (/etc/yellowdog-release))})
    (C {(append_silent)} {(DQ (/etc/sun-release))})
    (C {(append_silent)} {(DQ (/etc/release))})
    (C {(append_silent)} {(DQ (/etc/gentoo-release))})
    (C {(append)} {(DQ (/var/log/nvidia-installer.log))})
    (C {(append_silent)} {(DQ (/var/log/nvidia-uninstall.log))})
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: (C {(Lit_Other "[")} {(-d)} {(DQ (/var/lib/dkms/nvidia))} {(Lit_Other "]")})
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (ForEach
              iter_name: log
              iter_words: [
                {
                  (CommandSubPart
                    command_list: 
                      (CommandList
                        children: [
                          (C {(find)} {(DQ (/var/lib/dkms/nvidia))} {(-name)} {(DQ (make.log))})
                        ]
                      )
                    left_token: <Left_Backtick "`">
                    spids: [1815 1827]
                  )
                }
              ]
              do_arg_iter: False
              body: (DoGroup children:[(C {(append)} {($ VSub_Name "$log")})] spids:[18301838])
              spids: [1814 1828]
            )
          ]
          spids: [-1 1806]
        )
      ]
      spids: [-1 1840]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:journalctl)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (Pipeline
                        children: [
                          (SimpleCommand
                            words: [{(which)} {(journalctl)}]
                            redirects: [
                              (Redir
                                op_id: Redir_Great
                                fd: 2
                                arg_word: {(/dev/null)}
                                spids: [1853]
                              )
                            ]
                          )
                          (C {(head)} {(-n)} {(1)})
                        ]
                        negated: False
                      )
                    ]
                  )
                left_token: <Left_Backtick "`">
                spids: [1848 1864]
              )
            }
          spids: [1847]
        )
      ]
      spids: [1847]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (C {(Lit_Other "[")} {($ VSub_QMark "$?")} {(-eq)} {(0)} {(-a)} {(-x)} 
                  {(DQ ($ VSub_Name "$journalctl"))} {(Lit_Other "]")}
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (ForEach
              iter_name: comm
              iter_words: [{(Xorg)} {(Xorg.bin)} {(X)}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (ForEach
                      iter_name: boot
                      iter_words: [{(-0)} {(-1)} {(-2)}]
                      do_arg_iter: False
                      body: 
                        (DoGroup
                          children: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (SimpleCommand
                                          words: [
                                            {(journalctl)}
                                            {(-b)}
                                            {($ VSub_Name "$boot")}
                                            {(-n)}
                                            {(1)}
                                            {(Lit_VarLike "_COMM=") ($ VSub_Name "$comm")}
                                          ]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_Great
                                              fd: -1
                                              arg_word: {(/dev/null)}
                                              spids: [1938]
                                            )
                                            (Redir
                                              op_id: Redir_GreatAnd
                                              fd: 2
                                              arg_word: {(1)}
                                              spids: [1941]
                                            )
                                          ]
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Pipeline
                                      children: [
                                        (Subshell
                                          child: 
                                            (CommandList
                                              children: [
                                                (C {(echo)} 
                                                  {
                                                    (DQ 
                                                      (
____________________________________________
                                                      )
                                                    )
                                                  }
                                                )
                                                (C {(echo)} {(DQ )})
                                                (C {(echo)} 
                                                  {
                                                    (DQ ("journalctl -b ") ($ VSub_Name "$boot") 
                                                      (" _COMM=") ($ VSub_Name "$comm")
                                                    )
                                                  }
                                                )
                                                (C {(echo)} {(DQ )})
                                                (C {(journalctl)} {(-b)} {($ VSub_Name "$boot")} 
                                                  {(Lit_VarLike "_COMM=") ($ VSub_Name "$comm")}
                                                )
                                                (C {(echo)} {(DQ )})
                                              ]
                                            )
                                          redirects: [
                                            (Redir
                                              op_id: Redir_Great
                                              fd: 2
                                              arg_word: {(/dev/null)}
                                              spids: [1998]
                                            )
                                          ]
                                          spids: [1948 1996]
                                        )
                                        (SimpleCommand
                                          words: [{($ VSub_Name "$GZIP_CMD")}]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_DGreat
                                              fd: -1
                                              arg_word: {($ VSub_Name "$LOG_FILENAME")}
                                              spids: [2006]
                                            )
                                          ]
                                        )
                                      ]
                                      negated: False
                                    )
                                  ]
                                  spids: [-1 1945]
                                )
                              ]
                              spids: [-1 2011]
                            )
                          ]
                          spids: [1920 2014]
                        )
                      spids: [1912 1918]
                    )
                  ]
                  spids: [1904 2017]
                )
              spids: [1896 1902]
            )
          ]
          spids: [-1 1888]
        )
      ]
      spids: [-1 2019]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:xconfig_file_list) op:Equal rhs:{(SQ )} spids:[2032])]
      spids: [2032]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:svp_config_file_list) op:Equal rhs:{(SQ )} spids:[2034])]
      spids: [2034]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:NEW_LINE) op:Equal rhs:{(DQ ("\n"))} spids:[2036])]
      spids: [2036]
    )
    (ForEach
      iter_name: log_basename
      iter_words: [{(/var/log/XFree86)} {(/var/log/Xorg)}]
      do_arg_iter: False
      body: 
        (DoGroup
          children: [
            (ForEach
              iter_name: i
              iter_words: [{(0)} {(1)} {(2)} {(3)} {(4)} {(5)} {(6)} {(7)}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (ForEach
                      iter_name: log_suffix
                      iter_words: [{(log)} {(log.old)}]
                      do_arg_iter: False
                      body: 
                        (DoGroup
                          children: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:log_filename)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ (${ VSub_Name log_basename) (.) (${ VSub_Name i) (.) 
                                        (${ VSub_Name log_suffix)
                                      )
                                    }
                                  spids: [2096]
                                )
                              ]
                              spids: [2096]
                            )
                            (C {(append_silent)} {(DQ (${ VSub_Name log_filename))})
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(Lit_Other "[")} {(-f)} {(${ VSub_Name log_filename)} {(-a)} 
                                          {(-r)} {(${ VSub_Name log_filename)} {(Lit_Other "]")}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:config_file)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {(grep)} {(DQ ("Using config file"))} 
                                                            {(${ VSub_Name log_filename)}
                                                          )
                                                          (C {(cut)} {(-f)} {(2)} {(-d)} 
                                                            {
                                                              (EscapedLiteralPart
                                                                token: <Lit_EscapedChar "\\\"">
                                                              )
                                                            }
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [2151 2173]
                                              )
                                            }
                                          spids: [2150]
                                        )
                                      ]
                                      spids: [2150]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:config_dir)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {(grep)} {(DQ ("Using config directory"))} 
                                                            {(${ VSub_Name log_filename)}
                                                          )
                                                          (C {(cut)} {(-f)} {(2)} {(-d)} 
                                                            {
                                                              (EscapedLiteralPart
                                                                token: <Lit_EscapedChar "\\\"">
                                                              )
                                                            }
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [2177 2199]
                                              )
                                            }
                                          spids: [2176]
                                        )
                                      ]
                                      spids: [2176]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:sys_config_dir)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {(grep)} 
                                                            {(DQ ("Using system config directory"))} {(${ VSub_Name log_filename)}
                                                          )
                                                          (C {(cut)} {(-f)} {(2)} {(-d)} 
                                                            {
                                                              (EscapedLiteralPart
                                                                token: <Lit_EscapedChar "\\\"">
                                                              )
                                                            }
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [2203 2225]
                                              )
                                            }
                                          spids: [2202]
                                        )
                                      ]
                                      spids: [2202]
                                    )
                                    (ForEach
                                      iter_name: j
                                      iter_words: [
                                        {(DQ ($ VSub_Name "$config_file"))}
                                        {(DQ ($ VSub_Name "$config_dir"))}
                                        {(DQ ($ VSub_Name "$sys_config_dir"))}
                                      ]
                                      do_arg_iter: False
                                      body: 
                                        (DoGroup
                                          children: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (Sentence
                                                      child: 
                                                        (C {(Lit_Other "[")} {(DQ ($ VSub_Name "$j"))} 
                                                          {(Lit_Other "]")}
                                                        )
                                                      terminator: <Op_Semi ";">
                                                    )
                                                  ]
                                                  action: [
                                                    (Pipeline
                                                      children: [
                                                        (C {(echo)} 
                                                          {(DQ (${ VSub_Name xconfig_file_list))}
                                                        )
                                                        (SimpleCommand
                                                          words: [
                                                            {(grep)}
                                                            {(DQ (":") (${ VSub_Name j) (":"))}
                                                          ]
                                                          redirects: [
                                                            (Redir
                                                              op_id: Redir_Great
                                                              fd: -1
                                                              arg_word: {(/dev/null)}
                                                              spids: [2300]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                      negated: False
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(Lit_Other "[")} 
                                                                  {(DQ ($ VSub_QMark "$?"))} {(KW_Bang "!") (Lit_Other "=")} {(DQ (0))} {(Lit_Other "]")}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (LhsName
                                                                      name: xconfig_file_list
                                                                    )
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ 
                                                                        (${ VSub_Name 
xconfig_file_list
                                                                        ) (":") (${ VSub_Name j) (":")
                                                                      )
                                                                    }
                                                                  spids: [2326]
                                                                )
                                                              ]
                                                              spids: [2326]
                                                            )
                                                            (If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (Sentence
                                                                      child: 
                                                                        (C {(Lit_Other "[")} {(-d)} 
                                                                          {(DQ ($ VSub_Name "$j"))} {(Lit_Other "]")}
                                                                        )
                                                                      terminator: <Op_Semi ";">
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (C {(append_glob)} 
                                                                      {
                                                                        (DQ ($ VSub_Name "$j") 
                                                                          ("/*.conf")
                                                                        )
                                                                      }
                                                                    )
                                                                  ]
                                                                  spids: [-1 2352]
                                                                )
                                                              ]
                                                              else_action: [
                                                                (C {(append)} {(DQ ($ VSub_Name "$j"))})
                                                              ]
                                                              spids: [2363 2373]
                                                            )
                                                          ]
                                                          spids: [-1 2323]
                                                        )
                                                      ]
                                                      spids: [-1 2376]
                                                    )
                                                  ]
                                                  spids: [-1 2261]
                                                )
                                              ]
                                              spids: [-1 2379]
                                            )
                                          ]
                                          spids: [2247 2382]
                                        )
                                      spids: [2233 2245]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:svp_conf_files)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Pipeline
                                                        children: [
                                                          (C {(grep)} 
                                                            {
                                                              (DQ ("Option ") 
                                                                (EscapedLiteralPart
                                                                  token: <Lit_EscapedChar "\\\"">
                                                                ) (3DVisionProConfigFile) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                                              )
                                                            } {(${ VSub_Name log_filename)}
                                                          )
                                                          (C {(cut)} {(-f)} {(4)} {(-d)} 
                                                            {
                                                              (EscapedLiteralPart
                                                                token: <Lit_EscapedChar "\\\"">
                                                              )
                                                            }
                                                          )
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_Backtick "`">
                                                spids: [2391 2416]
                                              )
                                            }
                                          spids: [2390]
                                        )
                                      ]
                                      spids: [2390]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: 
                                                (C {(Lit_Other "[")} 
                                                  {(DQ (${ VSub_Name svp_conf_files))} {(Lit_Other "]")}
                                                )
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:OLD_IFS)
                                                  op: Equal
                                                  rhs: {(DQ ($ VSub_Name "$IFS"))}
                                                  spids: [2435]
                                                )
                                              ]
                                              spids: [2435]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:IFS)
                                                  op: Equal
                                                  rhs: {($ VSub_Name "$NEW_LINE")}
                                                  spids: [2441]
                                                )
                                              ]
                                              spids: [2441]
                                            )
                                            (ForEach
                                              iter_name: svp_file
                                              iter_words: [{(${ VSub_Name svp_conf_files)}]
                                              do_arg_iter: False
                                              body: 
                                                (DoGroup
                                                  children: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:IFS)
                                                          op: Equal
                                                          rhs: {(DQ ($ VSub_Name "$OLD_IFS"))}
                                                          spids: [2459]
                                                        )
                                                      ]
                                                      spids: [2459]
                                                    )
                                                    (Pipeline
                                                      children: [
                                                        (C {(echo)} 
                                                          {(DQ (${ VSub_Name svp_config_file_list))}
                                                        )
                                                        (SimpleCommand
                                                          words: [
                                                            {(grep)}
                                                            {
                                                              (DQ (":") (${ VSub_Name svp_file) (":"))
                                                            }
                                                          ]
                                                          redirects: [
                                                            (Redir
                                                              op_id: Redir_Great
                                                              fd: -1
                                                              arg_word: {(/dev/null)}
                                                              spids: [2485]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                      negated: False
                                                    )
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(Lit_Other "[")} 
                                                                  {(DQ ($ VSub_QMark "$?"))} {(KW_Bang "!") (Lit_Other "=")} {(DQ (0))} {(Lit_Other "]")}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (Assignment
                                                              keyword: Assign_None
                                                              pairs: [
                                                                (assign_pair
                                                                  lhs: 
                                                                    (LhsName
                                                                      name: svp_config_file_list
                                                                    )
                                                                  op: Equal
                                                                  rhs: 
                                                                    {
                                                                      (DQ 
                                                                        (${ VSub_Name 
svp_config_file_list
                                                                        ) (":") (${ VSub_Name svp_file) (":")
                                                                      )
                                                                    }
                                                                  spids: [2511]
                                                                )
                                                              ]
                                                              spids: [2511]
                                                            )
                                                            (C {(append_binary_file)} 
                                                              {(DQ (${ VSub_Name svp_file))}
                                                            )
                                                          ]
                                                          spids: [-1 2508]
                                                        )
                                                      ]
                                                      spids: [-1 2533]
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:IFS)
                                                          op: Equal
                                                          rhs: {($ VSub_Name "$NEW_LINE")}
                                                          spids: [2536]
                                                        )
                                                      ]
                                                      spids: [2536]
                                                    )
                                                  ]
                                                  spids: [2456 2540]
                                                )
                                              spids: [2450 2454]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:IFS)
                                                  op: Equal
                                                  rhs: {(DQ ($ VSub_Name "$OLD_IFS"))}
                                                  spids: [2543]
                                                )
                                              ]
                                              spids: [2543]
                                            )
                                          ]
                                          spids: [-1 2432]
                                        )
                                      ]
                                      spids: [-1 2549]
                                    )
                                  ]
                                  spids: [-1 2147]
                                )
                              ]
                              spids: [-1 2552]
                            )
                          ]
                          spids: [2093 2556]
                        )
                      spids: [2087 2091]
                    )
                  ]
                  spids: [2079 2559]
                )
              spids: [2061 2077]
            )
          ]
          spids: [2053 2561]
        )
      spids: [2047 2051]
    )
    (Pipeline
      children: [
        (C {(cat)} {(/etc/passwd)})
        (C {(cut)} {(-d)} {(Lit_Other ":")} {(-f)} {(6)})
        (C {(sort)})
        (C {(uniq)})
        (While
          cond: [(Sentence child:(C {(read)} {(DIR)}) terminator:<Op_Semi ";">)]
          body: 
            (DoGroup
              children: [
                (C {(append_file_or_dir_silent)} 
                  {(DQ ($ VSub_Name "$DIR") (/.nv/nvidia-application-profiles-rc))}
                )
                (C {(append_file_or_dir_silent)} 
                  {(DQ ($ VSub_Name "$DIR") (/.nv/nvidia-application-profiles-rc.backup))}
                )
                (C {(append_file_or_dir_silent)} 
                  {(DQ ($ VSub_Name "$DIR") (/.nv/nvidia-application-profiles-rc.d))}
                )
                (C {(append_file_or_dir_silent)} 
                  {(DQ ($ VSub_Name "$DIR") (/.nv/nvidia-application-profiles-rc.d.backup))}
                )
                (C {(append_silent)} 
                  {(DQ ($ VSub_Name "$DIR") (/.nv/nvidia-application-profile-globals-rc))}
                )
                (C {(append_silent)} 
                  {(DQ ($ VSub_Name "$DIR") (/.nv/nvidia-application-profile-globals-rc.backup))}
                )
                (C {(append_silent)} {(DQ ($ VSub_Name "$DIR") (/.nvidia-settings-rc))})
              ]
              spids: [2606 2665]
            )
        )
      ]
      negated: False
    )
    (C {(append_file_or_dir_silent)} {(DQ (/etc/nvidia/nvidia-application-profiles-rc))})
    (C {(append_file_or_dir_silent)} {(DQ (/etc/nvidia/nvidia-application-profiles-rc.d))})
    (C {(append_file_or_dir_silent)} 
      {(/usr/share/nvidia/nvidia-application-profiles-) (Lit_Other "*") (-rc)}
    )
    (Pipeline
      children: [
        (Subshell
          child: 
            (CommandList
              children: [
                (C {(echo)} {(DQ (____________________________________________))})
                (C {(echo)} {(DQ )})
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:glxinfo)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (Pipeline
                                    children: [
                                      (SimpleCommand
                                        words: [{(which)} {(glxinfo)}]
                                        redirects: [
                                          (Redir
                                            op_id: Redir_Great
                                            fd: 2
                                            arg_word: {(/dev/null)}
                                            spids: [2718]
                                          )
                                        ]
                                      )
                                      (C {(head)} {(-n)} {(1)})
                                    ]
                                    negated: False
                                  )
                                ]
                              )
                            left_token: <Left_Backtick "`">
                            spids: [2713 2729]
                          )
                        }
                      spids: [2712]
                    )
                  ]
                  spids: [2712]
                )
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (C {(Lit_Other "[")} {($ VSub_QMark "$?")} {(-eq)} {(0)} {(-a)} {(-x)} 
                              {(DQ ($ VSub_Name "$glxinfo"))} {(Lit_Other "]")}
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (C {(echo)} {(DQ ("ldd ") ($ VSub_Name "$glxinfo"))})
                        (C {(echo)} {(DQ )})
                        (SimpleCommand
                          words: [{(ldd)} {($ VSub_Name "$glxinfo")}]
                          redirects: [
                            (Redir
                              op_id: Redir_Great
                              fd: 2
                              arg_word: {(/dev/null)}
                              spids: [2775]
                            )
                          ]
                        )
                        (C {(echo)} {(DQ )})
                      ]
                      spids: [-1 2754]
                    )
                  ]
                  else_action: [
                    (C {(echo)} {(DQ ("Skipping ldd output (glxinfo not found)"))})
                    (C {(echo)} {(DQ )})
                  ]
                  spids: [2786 2802]
                )
              ]
            )
          spids: [2695 2804]
        )
        (SimpleCommand
          words: [{($ VSub_Name "$GZIP_CMD")}]
          redirects: [
            (Redir
              op_id: Redir_DGreat
              fd: -1
              arg_word: {($ VSub_Name "$LOG_FILENAME")}
              spids: [2810]
            )
          ]
        )
      ]
      negated: False
    )
    (Pipeline
      children: [
        (Subshell
          child: 
            (CommandList
              children: [
                (C {(echo)} {(DQ (____________________________________________))})
                (C {(echo)} {(DQ )})
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:lspci)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (Pipeline
                                    children: [
                                      (SimpleCommand
                                        words: [{(which)} {(lspci)}]
                                        redirects: [
                                          (Redir
                                            op_id: Redir_Great
                                            fd: 2
                                            arg_word: {(/dev/null)}
                                            spids: [2842]
                                          )
                                        ]
                                      )
                                      (C {(head)} {(-n)} {(1)})
                                    ]
                                    negated: False
                                  )
                                ]
                              )
                            left_token: <Left_Backtick "`">
                            spids: [2837 2853]
                          )
                        }
                      spids: [2836]
                    )
                  ]
                  spids: [2836]
                )
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (C {(Lit_Other "[")} {($ VSub_QMark "$?")} {(-eq)} {(0)} {(-a)} {(-x)} 
                              {(DQ ($ VSub_Name "$lspci"))} {(Lit_Other "]")}
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (C {(echo)} 
                          {
                            (DQ ($ VSub_Name "$lspci") (" -d ") 
                              (EscapedLiteralPart
                                token: <Lit_EscapedChar "\\\"">
                              ) ("10de:*") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" -v -xxx")
                            )
                          }
                        )
                        (C {(echo)} {(DQ )})
                        (SimpleCommand
                          words: [{($ VSub_Name "$lspci")} {(-d)} {(DQ ("10de:*"))} {(-v)} {(-xxx)}]
                          redirects: [
                            (Redir
                              op_id: Redir_Great
                              fd: 2
                              arg_word: {(/dev/null)}
                              spids: [2915]
                            )
                          ]
                        )
                        (C {(echo)} {(DQ )})
                        (C {(echo)} {(DQ (____________________________________________))})
                        (C {(echo)} 
                          {
                            (DQ ($ VSub_Name "$lspci") (" -d ") 
                              (EscapedLiteralPart
                                token: <Lit_EscapedChar "\\\"">
                              ) ("10b5:*") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" -v -xxx")
                            )
                          }
                        )
                        (C {(echo)} {(DQ )})
                        (SimpleCommand
                          words: [{($ VSub_Name "$lspci")} {(-d)} {(DQ ("10b5:*"))} {(-v)} {(-xxx)}]
                          redirects: [
                            (Redir
                              op_id: Redir_Great
                              fd: 2
                              arg_word: {(/dev/null)}
                              spids: [2967]
                            )
                          ]
                        )
                        (C {(echo)} {(DQ )})
                        (C {(echo)} {(DQ (____________________________________________))})
                        (C {(echo)} {(DQ )})
                        (C {(echo)} {(DQ ($ VSub_Name "$lspci") (" -t"))})
                        (C {(echo)} {(DQ )})
                        (SimpleCommand
                          words: [{($ VSub_Name "$lspci")} {(-t)}]
                          redirects: [
                            (Redir
                              op_id: Redir_Great
                              fd: 2
                              arg_word: {(/dev/null)}
                              spids: [3009]
                            )
                          ]
                        )
                        (C {(echo)} {(DQ )})
                        (C {(echo)} {(DQ (____________________________________________))})
                        (C {(echo)} {(DQ )})
                        (C {(echo)} {(DQ ($ VSub_Name "$lspci") (" -nn"))})
                        (C {(echo)} {(DQ )})
                        (SimpleCommand
                          words: [{($ VSub_Name "$lspci")} {(-nn)}]
                          redirects: [
                            (Redir
                              op_id: Redir_Great
                              fd: 2
                              arg_word: {(/dev/null)}
                              spids: [3051]
                            )
                          ]
                        )
                      ]
                      spids: [-1 2878]
                    )
                  ]
                  else_action: [
                    (C {(echo)} {(DQ ("Skipping lspci output (lspci not found)"))})
                    (C {(echo)} {(DQ )})
                  ]
                  spids: [3056 3072]
                )
              ]
            )
          spids: [2819 3074]
        )
        (SimpleCommand
          words: [{($ VSub_Name "$GZIP_CMD")}]
          redirects: [
            (Redir
              op_id: Redir_DGreat
              fd: -1
              arg_word: {($ VSub_Name "$LOG_FILENAME")}
              spids: [3080]
            )
          ]
        )
      ]
      negated: False
    )
    (Pipeline
      children: [
        (Subshell
          child: 
            (CommandList
              children: [
                (C {(echo)} {(DQ (____________________________________________))})
                (C {(echo)} {(DQ )})
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:lsusb)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (Pipeline
                                    children: [
                                      (SimpleCommand
                                        words: [{(which)} {(lsusb)}]
                                        redirects: [
                                          (Redir
                                            op_id: Redir_Great
                                            fd: 2
                                            arg_word: {(/dev/null)}
                                            spids: [3112]
                                          )
                                        ]
                                      )
                                      (C {(head)} {(-n)} {(1)})
                                    ]
                                    negated: False
                                  )
                                ]
                              )
                            left_token: <Left_Backtick "`">
                            spids: [3107 3123]
                          )
                        }
                      spids: [3106]
                    )
                  ]
                  spids: [3106]
                )
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (C {(Lit_Other "[")} {($ VSub_QMark "$?")} {(-eq)} {(0)} {(-a)} {(-x)} 
                              {(DQ ($ VSub_Name "$lsusb"))} {(Lit_Other "]")}
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (C {(echo)} {(DQ ($ VSub_Name "$lsusb"))})
                        (C {(echo)} {(DQ )})
                        (SimpleCommand
                          words: [{($ VSub_Name "$lsusb")}]
                          redirects: [
                            (Redir
                              op_id: Redir_Great
                              fd: 2
                              arg_word: {(/dev/null)}
                              spids: [3166]
                            )
                          ]
                        )
                        (C {(echo)} {(DQ )})
                      ]
                      spids: [-1 3148]
                    )
                  ]
                  else_action: [
                    (C {(echo)} {(DQ ("Skipping lsusb output (lsusb not found)"))})
                    (C {(echo)} {(DQ )})
                  ]
                  spids: [3177 3193]
                )
              ]
            )
          spids: [3089 3195]
        )
        (SimpleCommand
          words: [{($ VSub_Name "$GZIP_CMD")}]
          redirects: [
            (Redir
              op_id: Redir_DGreat
              fd: -1
              arg_word: {($ VSub_Name "$LOG_FILENAME")}
              spids: [3201]
            )
          ]
        )
      ]
      negated: False
    )
    (Pipeline
      children: [
        (Subshell
          child: 
            (CommandList
              children: [
                (C {(echo)} {(DQ (____________________________________________))})
                (C {(echo)} {(DQ )})
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:dmidecode)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (Pipeline
                                    children: [
                                      (SimpleCommand
                                        words: [{(which)} {(dmidecode)}]
                                        redirects: [
                                          (Redir
                                            op_id: Redir_Great
                                            fd: 2
                                            arg_word: {(/dev/null)}
                                            spids: [3233]
                                          )
                                        ]
                                      )
                                      (C {(head)} {(-n)} {(1)})
                                    ]
                                    negated: False
                                  )
                                ]
                              )
                            left_token: <Left_Backtick "`">
                            spids: [3228 3244]
                          )
                        }
                      spids: [3227]
                    )
                  ]
                  spids: [3227]
                )
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (C {(Lit_Other "[")} {($ VSub_QMark "$?")} {(-eq)} {(0)} {(-a)} {(-x)} 
                              {(DQ ($ VSub_Name "$dmidecode"))} {(Lit_Other "]")}
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (C {(echo)} {(DQ ($ VSub_Name "$dmidecode"))})
                        (C {(echo)} {(DQ )})
                        (SimpleCommand
                          words: [{($ VSub_Name "$dmidecode")}]
                          redirects: [
                            (Redir
                              op_id: Redir_Great
                              fd: 2
                              arg_word: {(/dev/null)}
                              spids: [3287]
                            )
                          ]
                        )
                        (C {(echo)} {(DQ )})
                      ]
                      spids: [-1 3269]
                    )
                  ]
                  else_action: [
                    (C {(echo)} {(DQ ("Skipping dmidecode output (dmidecode not found)"))})
                    (C {(echo)} {(DQ )})
                  ]
                  spids: [3298 3314]
                )
              ]
            )
          spids: [3210 3316]
        )
        (SimpleCommand
          words: [{($ VSub_Name "$GZIP_CMD")}]
          redirects: [
            (Redir
              op_id: Redir_DGreat
              fd: -1
              arg_word: {($ VSub_Name "$LOG_FILENAME")}
              spids: [3322]
            )
          ]
        )
      ]
      negated: False
    )
    (Pipeline
      children: [
        (Subshell
          child: 
            (CommandList
              children: [
                (C {(echo)} {(DQ (____________________________________________))})
                (C {(echo)} {(DQ )})
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:modinfo)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (Pipeline
                                    children: [
                                      (SimpleCommand
                                        words: [{(which)} {(modinfo)}]
                                        redirects: [
                                          (Redir
                                            op_id: Redir_Great
                                            fd: 2
                                            arg_word: {(/dev/null)}
                                            spids: [3354]
                                          )
                                        ]
                                      )
                                      (C {(head)} {(-n)} {(1)})
                                    ]
                                    negated: False
                                  )
                                ]
                              )
                            left_token: <Left_Backtick "`">
                            spids: [3349 3365]
                          )
                        }
                      spids: [3348]
                    )
                  ]
                  spids: [3348]
                )
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (C {(Lit_Other "[")} {($ VSub_QMark "$?")} {(-eq)} {(0)} {(-a)} {(-x)} 
                              {(DQ ($ VSub_Name "$modinfo"))} {(Lit_Other "]")}
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (ForEach
                          iter_name: name
                          iter_words: [{($ VSub_Name "$module_names")}]
                          do_arg_iter: False
                          body: 
                            (DoGroup
                              children: [
                                (C {(echo)} 
                                  {
                                    (DQ ($ VSub_Name "$modinfo") (" ") ($ VSub_Name "$name") 
                                      (" | grep vermagic")
                                    )
                                  }
                                )
                                (C {(echo)} {(DQ )})
                                (Subshell
                                  child: 
                                    (Pipeline
                                      children: [
                                        (C {($ VSub_Name "$modinfo")} {($ VSub_Name "$name")})
                                        (C {(grep)} {(vermagic)})
                                      ]
                                      negated: False
                                    )
                                  redirects: [
                                    (Redir
                                      op_id: Redir_Great
                                      fd: 2
                                      arg_word: {(/dev/null)}
                                      spids: [3435]
                                    )
                                  ]
                                  spids: [3421 3433]
                                )
                                (C {(echo)} {(DQ )})
                              ]
                              spids: [3402 3446]
                            )
                          spids: [3398 3400]
                        )
                      ]
                      spids: [-1 3390]
                    )
                  ]
                  else_action: [
                    (C {(echo)} {(DQ ("Skipping modinfo output (modinfo not found)"))})
                    (C {(echo)} {(DQ )})
                  ]
                  spids: [3449 3465]
                )
              ]
            )
          spids: [3331 3467]
        )
        (SimpleCommand
          words: [{($ VSub_Name "$GZIP_CMD")}]
          redirects: [
            (Redir
              op_id: Redir_DGreat
              fd: -1
              arg_word: {($ VSub_Name "$LOG_FILENAME")}
              spids: [3473]
            )
          ]
        )
      ]
      negated: False
    )
    (Pipeline
      children: [
        (Subshell
          child: 
            (CommandList
              children: [
                (C {(echo)} {(DQ (____________________________________________))})
                (C {(echo)} {(DQ )})
                (C {(echo)} {(DQ ("Scanning kernel log files for NVIDIA kernel messages:"))})
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:grep_args)
                      op: Equal
                      rhs: {(DQ ("-e NVRM -e nvidia-"))}
                      spids: [3506]
                    )
                  ]
                  spids: [3506]
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [(assign_pair lhs:(LhsName name:logfound) op:Equal rhs:{(0)} spids:[3512])]
                  spids: [3512]
                )
                (AndOr
                  children: [
                    (C {(search_string_in_logs)} {(/var/log/messages)} {(DQ ($ VSub_Name "$grep_args"))})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:logfound)
                          op: Equal
                          rhs: {(1)}
                          spids: [3526]
                        )
                      ]
                      spids: [3526]
                    )
                  ]
                  op_id: Op_DAmp
                )
                (AndOr
                  children: [
                    (C {(search_string_in_logs)} {(/var/log/kernel.log)} 
                      {(DQ ($ VSub_Name "$grep_args"))}
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:logfound)
                          op: Equal
                          rhs: {(1)}
                          spids: [3540]
                        )
                      ]
                      spids: [3540]
                    )
                  ]
                  op_id: Op_DAmp
                )
                (AndOr
                  children: [
                    (C {(search_string_in_logs)} {(/var/log/dmesg)} {(DQ ($ VSub_Name "$grep_args"))})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:logfound)
                          op: Equal
                          rhs: {(1)}
                          spids: [3554]
                        )
                      ]
                      spids: [3554]
                    )
                  ]
                  op_id: Op_DAmp
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:journalctl)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (Pipeline
                                    children: [
                                      (SimpleCommand
                                        words: [{(which)} {(journalctl)}]
                                        redirects: [
                                          (Redir
                                            op_id: Redir_Great
                                            fd: 2
                                            arg_word: {(/dev/null)}
                                            spids: [3565]
                                          )
                                        ]
                                      )
                                      (C {(head)} {(-n)} {(1)})
                                    ]
                                    negated: False
                                  )
                                ]
                              )
                            left_token: <Left_Backtick "`">
                            spids: [3560 3576]
                          )
                        }
                      spids: [3559]
                    )
                  ]
                  spids: [3559]
                )
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (C {(Lit_Other "[")} {($ VSub_QMark "$?")} {(-eq)} {(0)} {(-a)} {(-x)} 
                              {(DQ ($ VSub_Name "$journalctl"))} {(Lit_Other "]")}
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:logfound)
                              op: Equal
                              rhs: {(1)}
                              spids: [3603]
                            )
                          ]
                          spids: [3603]
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:nvrmfound)
                              op: Equal
                              rhs: {(0)}
                              spids: [3607]
                            )
                          ]
                          spids: [3607]
                        )
                        (ForEach
                          iter_name: boot
                          iter_words: [{(-0)} {(-1)} {(-2)}]
                          do_arg_iter: False
                          body: 
                            (DoGroup
                              children: [
                                (If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (Sentence
                                          child: 
                                            (Pipeline
                                              children: [
                                                (C {(journalctl)} {(-b)} {($ VSub_Name "$boot")})
                                                (SimpleCommand
                                                  words: [{(grep)} {(${ VSub_Name grep_args)}]
                                                  redirects: [
                                                    (Redir
                                                      op_id: Redir_Great
                                                      fd: -1
                                                      arg_word: {(/dev/null)}
                                                      spids: [3644]
                                                    )
                                                    (Redir
                                                      op_id: Redir_GreatAnd
                                                      fd: 2
                                                      arg_word: {(1)}
                                                      spids: [3648]
                                                    )
                                                  ]
                                                )
                                              ]
                                              negated: False
                                            )
                                          terminator: <Op_Semi ";">
                                        )
                                      ]
                                      action: [
                                        (C {(echo)} {(DQ )})
                                        (C {(echo)} 
                                          {(DQ ("  journalctl -b ") ($ VSub_Name "$boot") (":"))}
                                        )
                                        (Subshell
                                          child: 
                                            (Pipeline
                                              children: [
                                                (C {(journalctl)} {(-b)} {($ VSub_Name "$boot")})
                                                (C {(grep)} {(${ VSub_Name grep_args)})
                                              ]
                                              negated: False
                                            )
                                          redirects: [
                                            (Redir
                                              op_id: Redir_Great
                                              fd: 2
                                              arg_word: {(/dev/null)}
                                              spids: [3686]
                                            )
                                          ]
                                          spids: [3670 3684]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:nvrmfound)
                                              op: Equal
                                              rhs: {(1)}
                                              spids: [3691]
                                            )
                                          ]
                                          spids: [3691]
                                        )
                                      ]
                                      spids: [-1 3652]
                                    )
                                  ]
                                  spids: [-1 3695]
                                )
                              ]
                              spids: [3625 3698]
                            )
                          spids: [3617 3623]
                        )
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (Sentence
                                  child: 
                                    (C {(Lit_Other "[")} {($ VSub_Name "$nvrmfound")} {(-eq)} {(0)} 
                                      {(Lit_Other "]")}
                                    )
                                  terminator: <Op_Semi ";">
                                )
                              ]
                              action: [
                                (C {(echo)} {(DQ )})
                                (C {(echo)} 
                                  {
                                    (DQ 
                                      (
"No NVIDIA kernel messages found in recent systemd journal entries."
                                      )
                                    )
                                  }
                                )
                              ]
                              spids: [-1 3715]
                            )
                          ]
                          spids: [-1 3731]
                        )
                      ]
                      spids: [-1 3600]
                    )
                  ]
                  spids: [-1 3734]
                )
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (C {(Lit_Other "[")} {($ VSub_Name "$logfound")} {(-eq)} {(0)} 
                              {(Lit_Other "]")}
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [(C {(echo)} {(DQ )}) (C {(echo)} {(DQ ("No suitable log found."))})]
                      spids: [-1 3751]
                    )
                  ]
                  spids: [-1 3767]
                )
                (C {(echo)} {(DQ )})
              ]
            )
          spids: [3482 3776]
        )
        (SimpleCommand
          words: [{($ VSub_Name "$GZIP_CMD")}]
          redirects: [
            (Redir
              op_id: Redir_DGreat
              fd: -1
              arg_word: {($ VSub_Name "$LOG_FILENAME")}
              spids: [3782]
            )
          ]
        )
      ]
      negated: False
    )
    (Pipeline
      children: [
        (Subshell
          child: 
            (CommandList
              children: [
                (C {(echo)} {(DQ (____________________________________________))})
                (C {(echo)} {(DQ )})
                (C {(echo)} {(DQ ("dmesg:"))})
                (C {(echo)} {(DQ )})
                (SimpleCommand
                  words: [{(dmesg)}]
                  redirects: [(Redir op_id:Redir_Great fd:2 arg_word:{(/dev/null)} spids:[3823])]
                )
              ]
            )
          spids: [3792 3827]
        )
        (SimpleCommand
          words: [{($ VSub_Name "$GZIP_CMD")}]
          redirects: [
            (Redir
              op_id: Redir_DGreat
              fd: -1
              arg_word: {($ VSub_Name "$LOG_FILENAME")}
              spids: [3833]
            )
          ]
        )
      ]
      negated: False
    )
    (Pipeline
      children: [
        (Subshell
          child: 
            (CommandList
              children: [
                (SimpleCommand
                  words: [{(which)} {(gcc)}]
                  redirects: [
                    (Redir
                      op_id: Redir_Great
                      fd: -1
                      arg_word: {(/dev/null)}
                      spids: [3849]
                    )
                    (Redir op_id:Redir_GreatAnd fd:2 arg_word:{(1)} spids:[3852])
                  ]
                )
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (C {(Lit_Other "[")} {($ VSub_QMark "$?")} {(-eq)} {(0)} {(Lit_Other "]")})
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (C {(echo)} {(DQ (____________________________________________))})
                        (C {(echo)} {(DQ )})
                        (SimpleCommand
                          words: [{(gcc)} {(-v)}]
                          redirects: [(Redir op_id:Redir_GreatAnd fd:2 arg_word:{(1)} spids:[3889])]
                        )
                      ]
                      spids: [-1 3869]
                    )
                  ]
                  spids: [-1 3893]
                )
                (SimpleCommand
                  words: [{(which)} {(g) (Lit_Other "+") (Lit_Other "+")}]
                  redirects: [
                    (Redir
                      op_id: Redir_Great
                      fd: -1
                      arg_word: {(/dev/null)}
                      spids: [3903]
                    )
                    (Redir op_id:Redir_GreatAnd fd:2 arg_word:{(1)} spids:[3906])
                  ]
                )
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (C {(Lit_Other "[")} {($ VSub_QMark "$?")} {(-eq)} {(0)} {(Lit_Other "]")})
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (C {(echo)} {(DQ (____________________________________________))})
                        (C {(echo)} {(DQ )})
                        (SimpleCommand
                          words: [{(g) (Lit_Other "+") (Lit_Other "+")} {(-v)}]
                          redirects: [(Redir op_id:Redir_GreatAnd fd:2 arg_word:{(1)} spids:[3945])]
                        )
                      ]
                      spids: [-1 3923]
                    )
                  ]
                  spids: [-1 3949]
                )
              ]
            )
          spids: [3842 3951]
        )
        (SimpleCommand
          words: [{($ VSub_Name "$GZIP_CMD")}]
          redirects: [
            (Redir
              op_id: Redir_DGreat
              fd: -1
              arg_word: {($ VSub_Name "$LOG_FILENAME")}
              spids: [3957]
            )
          ]
        )
      ]
      negated: False
    )
    (Pipeline
      children: [
        (Subshell
          child: 
            (CommandList
              children: [
                (C {(echo)} {(DQ (____________________________________________))})
                (C {(echo)} {(DQ )})
                (C {(echo)} {(DQ ("xset -q:"))})
                (C {(echo)} {(DQ )})
                (Sentence
                  child: 
                    (SimpleCommand
                      words: [{(xset)} {(-q)}]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:2 arg_word:{(1)} spids:[4006])]
                    )
                  terminator: <Op_Amp "&">
                )
                (Sentence child:(C {(sleep)} {(1)}) terminator:<Op_Semi ";">)
                (SimpleCommand
                  words: [{(kill)} {(-9)} {($ VSub_Bang "$!")}]
                  redirects: [
                    (Redir
                      op_id: Redir_Great
                      fd: -1
                      arg_word: {(/dev/null)}
                      spids: [4023]
                    )
                    (Redir op_id:Redir_GreatAnd fd:2 arg_word:{(1)} spids:[4027])
                  ]
                )
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (C {(Lit_Other "[")} {($ VSub_QMark "$?")} {(-eq)} {(0)} {(Lit_Other "]")})
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [(C {(echo)} {(DQ ("xset could not connect to an X server"))})]
                      spids: [-1 4045]
                    )
                  ]
                  spids: [-1 4059]
                )
              ]
            )
          spids: [3972 4061]
        )
        (SimpleCommand
          words: [{($ VSub_Name "$GZIP_CMD")}]
          redirects: [
            (Redir
              op_id: Redir_DGreat
              fd: -1
              arg_word: {($ VSub_Name "$LOG_FILENAME")}
              spids: [4067]
            )
          ]
        )
      ]
      negated: False
    )
    (Pipeline
      children: [
        (Subshell
          child: 
            (CommandList
              children: [
                (C {(echo)} {(DQ (____________________________________________))})
                (C {(echo)} {(DQ )})
                (C {(echo)} {(DQ ("nvidia-settings -q all:"))})
                (C {(echo)} {(DQ )})
                (Sentence
                  child: 
                    (SimpleCommand
                      words: [{(nvidia-settings)} {(-c)} {(DQ ($ VSub_Name "$DPY"))} {(-q)} {(all)}]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:2 arg_word:{(1)} spids:[4126])]
                      more_env: [(env_pair name:DISPLAY val:{(SQ )} spids:[4112])]
                    )
                  terminator: <Op_Amp "&">
                )
                (Sentence child:(C {(sleep)} {(1)}) terminator:<Op_Semi ";">)
                (SimpleCommand
                  words: [{(kill)} {(-9)} {($ VSub_Bang "$!")}]
                  redirects: [
                    (Redir
                      op_id: Redir_Great
                      fd: -1
                      arg_word: {(/dev/null)}
                      spids: [4143]
                    )
                    (Redir op_id:Redir_GreatAnd fd:2 arg_word:{(1)} spids:[4147])
                  ]
                )
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (C {(Lit_Other "[")} {($ VSub_QMark "$?")} {(-eq)} {(0)} {(Lit_Other "]")})
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [(C {(echo)} {(DQ ("nvidia-settings could not connect to an X server"))})]
                      spids: [-1 4165]
                    )
                  ]
                  spids: [-1 4179]
                )
              ]
            )
          spids: [4082 4181]
        )
        (SimpleCommand
          words: [{($ VSub_Name "$GZIP_CMD")}]
          redirects: [
            (Redir
              op_id: Redir_DGreat
              fd: -1
              arg_word: {($ VSub_Name "$LOG_FILENAME")}
              spids: [4187]
            )
          ]
        )
      ]
      negated: False
    )
    (Pipeline
      children: [
        (Subshell
          child: 
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(-x)} 
                          {
                            (DQ 
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (SimpleCommand
                                        words: [{(which)} {(xrandr)}]
                                        redirects: [
                                          (Redir
                                            op_id: Redir_Great
                                            fd: 2
                                            arg_word: {(/dev/null)}
                                            spids: [4217]
                                          )
                                        ]
                                      )
                                    ]
                                  )
                                left_token: <Left_Backtick "`">
                                spids: [4212 4219]
                              )
                            )
                          } {(Lit_Other "]")}
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(echo)} {(DQ (____________________________________________))})
                    (C {(echo)} {(DQ )})
                    (C {(echo)} {(DQ ("xrandr --verbose:"))})
                    (C {(echo)} {(DQ )})
                    (Sentence
                      child: 
                        (SimpleCommand
                          words: [{(xrandr)} {(-display)} {($ VSub_Name "$DPY")} {(--verbose)}]
                          redirects: [(Redir op_id:Redir_GreatAnd fd:2 arg_word:{(1)} spids:[4264])]
                        )
                      terminator: <Op_Amp "&">
                    )
                    (Sentence child:(C {(sleep)} {(1)}) terminator:<Op_Semi ";">)
                    (SimpleCommand
                      words: [{(kill)} {(-9)} {($ VSub_Bang "$!")}]
                      redirects: [
                        (Redir
                          op_id: Redir_Great
                          fd: -1
                          arg_word: {(/dev/null)}
                          spids: [4281]
                        )
                        (Redir
                          op_id: Redir_GreatAnd
                          fd: 2
                          arg_word: {(1)}
                          spids: [4285]
                        )
                      ]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(Lit_Other "[")} {($ VSub_QMark "$?")} {(-eq)} {(0)} {(Lit_Other "]")})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [(C {(echo)} {(DQ ("xrandr could not connect to an X server"))})]
                          spids: [-1 4302]
                        )
                      ]
                      spids: [-1 4316]
                    )
                  ]
                  spids: [-1 4226]
                )
              ]
              else_action: [(C {(echo)} {(DQ ("Skipping xrandr output (xrandr not found)"))})]
              spids: [4319 4329]
            )
          spids: [4202 4331]
        )
        (SimpleCommand
          words: [{($ VSub_Name "$GZIP_CMD")}]
          redirects: [
            (Redir
              op_id: Redir_DGreat
              fd: -1
              arg_word: {($ VSub_Name "$LOG_FILENAME")}
              spids: [4337]
            )
          ]
        )
      ]
      negated: False
    )
    (Pipeline
      children: [
        (Subshell
          child: 
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(-x)} 
                          {
                            (DQ 
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (SimpleCommand
                                        words: [{(which)} {(xprop)}]
                                        redirects: [
                                          (Redir
                                            op_id: Redir_Great
                                            fd: 2
                                            arg_word: {(/dev/null)}
                                            spids: [4357]
                                          )
                                        ]
                                      )
                                    ]
                                  )
                                left_token: <Left_Backtick "`">
                                spids: [4352 4359]
                              )
                            )
                          } {(Lit_Other "]")}
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(echo)} {(DQ (____________________________________________))})
                    (C {(echo)} {(DQ )})
                    (C {(echo)} {(DQ ("Running window manager properties:"))})
                    (C {(echo)} {(DQ )})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:TMP)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (Sentence
                                        child: 
                                          (SimpleCommand
                                            words: [{(xprop)} {(-root)} {(_NET_SUPPORTING_WM_CHECK)}]
                                            redirects: [
                                              (Redir
                                                op_id: Redir_Great
                                                fd: 2
                                                arg_word: {(/dev/null)}
                                                spids: [4404]
                                              )
                                            ]
                                          )
                                        terminator: <Op_Amp "&">
                                      )
                                      (Sentence
                                        child: (C {(sleep)} {(1)})
                                        terminator: <Op_Semi ";">
                                      )
                                      (SimpleCommand
                                        words: [{(kill)} {(-9)} {($ VSub_Bang "$!")}]
                                        redirects: [
                                          (Redir
                                            op_id: Redir_Great
                                            fd: -1
                                            arg_word: {(/dev/null)}
                                            spids: [4421]
                                          )
                                          (Redir
                                            op_id: Redir_GreatAnd
                                            fd: 2
                                            arg_word: {(1)}
                                            spids: [4425]
                                          )
                                        ]
                                      )
                                    ]
                                  )
                                left_token: <Left_Backtick "`">
                                spids: [4397 4427]
                              )
                            }
                          spids: [4396]
                        )
                      ]
                      spids: [4396]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:WINDOW)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (Pipeline
                                        children: [
                                          (C {(echo)} {($ VSub_Name "$TMP")})
                                          (C {(grep)} {(-o)} {(SQ <"0x[0-9a-z]\\+">)})
                                        ]
                                        negated: False
                                      )
                                    ]
                                  )
                                left_token: <Left_Backtick "`">
                                spids: [4431 4445]
                              )
                            }
                          spids: [4430]
                        )
                      ]
                      spids: [4430]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(Lit_Other "[")} {(DQ ($ VSub_Name "$WINDOW"))} {(Lit_Other "]")})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (Sentence
                              child: 
                                (SimpleCommand
                                  words: [{(xprop)} {(-id)} {(DQ ($ VSub_Name "$WINDOW"))}]
                                  redirects: [
                                    (Redir
                                      op_id: Redir_GreatAnd
                                      fd: 2
                                      arg_word: {(1)}
                                      spids: [4470]
                                    )
                                  ]
                                )
                              terminator: <Op_Amp "&">
                            )
                            (Sentence
                              child: (C {(sleep)} {(1)})
                              terminator: <Op_Semi ";">
                            )
                            (SimpleCommand
                              words: [{(kill)} {(-9)} {($ VSub_Bang "$!")}]
                              redirects: [
                                (Redir
                                  op_id: Redir_Great
                                  fd: -1
                                  arg_word: {(/dev/null)}
                                  spids: [4487]
                                )
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: 2
                                  arg_word: {(1)}
                                  spids: [4491]
                                )
                              ]
                            )
                          ]
                          spids: [-1 4459]
                        )
                      ]
                      else_action: [(C {(echo)} {(DQ ("Unable to detect window manager properties"))})]
                      spids: [4495 4505]
                    )
                  ]
                  spids: [-1 4366]
                )
              ]
              spids: [-1 4508]
            )
          spids: [4342 4510]
        )
        (SimpleCommand
          words: [{($ VSub_Name "$GZIP_CMD")}]
          redirects: [
            (Redir
              op_id: Redir_DGreat
              fd: -1
              arg_word: {($ VSub_Name "$LOG_FILENAME")}
              spids: [4516]
            )
          ]
        )
      ]
      negated: False
    )
    (SimpleCommand
      words: [{(sync)}]
      redirects: [
        (Redir op_id:Redir_Great fd:-1 arg_word:{(/dev/null)} spids:[4523])
        (Redir op_id:Redir_GreatAnd fd:2 arg_word:{(1)} spids:[4527])
      ]
    )
    (SimpleCommand
      words: [{(sync)}]
      redirects: [
        (Redir op_id:Redir_Great fd:-1 arg_word:{(/dev/null)} spids:[4532])
        (Redir op_id:Redir_GreatAnd fd:2 arg_word:{(1)} spids:[4536])
      ]
    )
    (C {(append)} {(DQ (/proc/cmdline))})
    (C {(append)} {(DQ (/proc/cpuinfo))})
    (C {(append)} {(DQ (/proc/interrupts))})
    (C {(append)} {(DQ (/proc/meminfo))})
    (C {(append)} {(DQ (/proc/modules))})
    (C {(append)} {(DQ (/proc/version))})
    (C {(append)} {(DQ (/proc/pci))})
    (C {(append)} {(DQ (/proc/iomem))})
    (C {(append)} {(DQ (/proc/mtrr))})
    (ForEach
      iter_name: subdir
      iter_words: [{($ VSub_Name "$proc_module_dirs")}]
      do_arg_iter: False
      body: 
        (DoGroup
          children: [
            (C {(append)} {(DQ (/proc/driver/nvidia/) ($ VSub_Name "$subdir") (/version))})
            (ForEach
              iter_name: GPU
              iter_words: [
                {
                  (CommandSubPart
                    command_list: 
                      (CommandList
                        children: [(C {(ls)} {(/proc/driver/nvidia/) ($ VSub_Name "$subdir") (/gpus/)})]
                      )
                    left_token: <Left_Backtick "`">
                    spids: [4626 4632]
                  )
                }
              ]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (C {(append)} 
                      {
                        (DQ (/proc/driver/nvidia/) ($ VSub_Name "$subdir") (/gpus/) ($ VSub_Name "$GPU") 
                          (/information)
                        )
                      }
                    )
                    (C {(append)} 
                      {
                        (DQ (/proc/driver/nvidia/) ($ VSub_Name "$subdir") (/gpus/) ($ VSub_Name "$GPU") 
                          (/registry)
                        )
                      }
                    )
                  ]
                  spids: [4635 4660]
                )
              spids: [4625 4633]
            )
            (C {(append_glob)} {(DQ (/proc/driver/nvidia/) ($ VSub_Name "$subdir") ("/warnings/*"))})
            (C {(append)} {(DQ (/proc/driver/nvidia/) ($ VSub_Name "$subdir") (/params))})
            (C {(append)} {(DQ (/proc/driver/nvidia/) ($ VSub_Name "$subdir") (/registry))})
          ]
          spids: [4608 4689]
        )
      spids: [4604 4606]
    )
    (C {(append_glob)} {(DQ ("/proc/acpi/video/*/*/info"))})
    (C {(append)} {(DQ (/proc/asound/cards))})
    (C {(append)} {(DQ (/proc/asound/pcm))})
    (C {(append)} {(DQ (/proc/asound/modules))})
    (C {(append)} {(DQ (/proc/asound/devices))})
    (C {(append)} {(DQ (/proc/asound/version))})
    (C {(append)} {(DQ (/proc/asound/timers))})
    (C {(append)} {(DQ (/proc/asound/hwdep))})
    (ForEach
      iter_name: CARD
      iter_words: [{(/proc/asound/card) (Lit_Other "[") (0-9) (Lit_Other "]") (Lit_Other "*")}]
      do_arg_iter: False
      body: 
        (DoGroup
          children: [
            (ForEach
              iter_name: CODEC
              iter_words: [{($ VSub_Name "$CARD") (/codec) (Lit_Other "*")}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (AndOr
                      children: [
                        (C {(Lit_Other "[")} {(-d)} {($ VSub_Name "$CODEC")} {(Lit_Other "]")})
                        (C {(append_glob)} {(DQ ($ VSub_Name "$CODEC") ("/*"))})
                      ]
                      op_id: Op_DAmp
                    )
                    (AndOr
                      children: [
                        (C {(Lit_Other "[")} {(-f)} {($ VSub_Name "$CODEC")} {(Lit_Other "]")})
                        (C {(append)} {(DQ ($ VSub_Name "$CODEC"))})
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  spids: [4769 4807]
                )
              spids: [4763 4767]
            )
            (ForEach
              iter_name: ELD
              iter_words: [{($ VSub_Name "$CARD") (/eld) (Lit_Other "*")}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (AndOr
                      children: [
                        (C {(Lit_Other "[")} {(-f)} {($ VSub_Name "$ELD")} {(Lit_Other "]")})
                        (C {(append)} {(DQ ($ VSub_Name "$ELD"))})
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  spids: [4821 4841]
                )
              spids: [4815 4819]
            )
          ]
          spids: [4755 4843]
        )
      spids: [4747 4753]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (C {(Lit_Other "[")} {($ VSub_Name "$BUG_REPORT_SAFE_MODE")} {(-eq)} {(0)} 
                  {(Lit_Other "]")}
                )
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (Subshell
              child: 
                (CommandList
                  children: [
                    (C {(echo)} {(DQ )})
                    (C {(echo)} {(DQ )})
                    (C {(echo)} 
                      {
                        (DQ ("If the bug report script hangs after this point consider running with"))
                      }
                    )
                    (C {(echo)} {(DQ ("--safe-mode command line argument."))})
                    (C {(echo)} {(DQ )})
                  ]
                )
              spids: [4870 4905]
            )
            (Pipeline
              children: [
                (Subshell
                  child: 
                    (CommandList
                      children: [
                        (C {(echo)} {(DQ (____________________________________________))})
                        (C {(echo)} {(DQ )})
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:nvidia_smi)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (Pipeline
                                            children: [
                                              (SimpleCommand
                                                words: [{(which)} {(nvidia-smi)}]
                                                redirects: [
                                                  (Redir
                                                    op_id: Redir_Great
                                                    fd: 2
                                                    arg_word: {(/dev/null)}
                                                    spids: [4938]
                                                  )
                                                ]
                                              )
                                              (C {(head)} {(-n)} {(1)})
                                            ]
                                            negated: False
                                          )
                                        ]
                                      )
                                    left_token: <Left_Backtick "`">
                                    spids: [4933 4949]
                                  )
                                }
                              spids: [4932]
                            )
                          ]
                          spids: [4932]
                        )
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (Sentence
                                  child: 
                                    (C {(Lit_Other "[")} {($ VSub_QMark "$?")} {(-eq)} {(0)} {(-a)} {(-x)} 
                                      {(DQ ($ VSub_Name "$nvidia_smi"))} {(Lit_Other "]")}
                                    )
                                  terminator: <Op_Semi ";">
                                )
                              ]
                              action: [
                                (ForEach
                                  iter_name: instance
                                  iter_words: [{($ VSub_Name "$proc_module_dirs")}]
                                  do_arg_iter: False
                                  body: 
                                    (DoGroup
                                      children: [
                                        (If
                                          arms: [
                                            (if_arm
                                              cond: [
                                                (Sentence
                                                  child: 
                                                    (C {(Lit_Other "[")} {($ VSub_Name "$instance")} 
                                                      {(KW_Bang "!") (Lit_Other "=")} {(SQ <.>)} {(Lit_Other "]")}
                                                    )
                                                  terminator: <Op_Semi ";">
                                                )
                                              ]
                                              action: [
                                                (C {(export)} 
                                                  {(Lit_VarLike "__RM_MODULE_INSTANCE=") 
                                                    ($ VSub_Name "$instance")
                                                  }
                                                )
                                                (C {(echo)} 
                                                  {
                                                    (DQ ("NVIDIA Kernel module instance ") 
                                                      ($ VSub_Name "$instance")
                                                    )
                                                  }
                                                )
                                              ]
                                              spids: [-1 5005]
                                            )
                                          ]
                                          spids: [-1 5022]
                                        )
                                        (C {(echo)} {(DQ ($ VSub_Name "$nvidia_smi") (" -q"))})
                                        (C {(echo)} {(DQ )})
                                        (C {($ VSub_Name "$nvidia_smi")} {(-q)})
                                        (C {(echo)} {(DQ )})
                                        (C {(echo)} {(DQ ($ VSub_Name "$nvidia_smi") (" -q -u"))})
                                        (C {(echo)} {(DQ )})
                                        (C {($ VSub_Name "$nvidia_smi")} {(-q)} {(-u)})
                                        (C {(echo)} {(DQ )})
                                        (C {(unset)} {(__RM_MODULE_INSTANCE)})
                                      ]
                                      spids: [4986 5083]
                                    )
                                  spids: [4982 4984]
                                )
                              ]
                              spids: [-1 4974]
                            )
                          ]
                          else_action: [
                            (C {(echo)} {(DQ ("Skipping nvidia-smi output (nvidia-smi not found)"))})
                            (C {(echo)} {(DQ )})
                          ]
                          spids: [5086 5102]
                        )
                      ]
                    )
                  spids: [4915 5105]
                )
                (SimpleCommand
                  words: [{($ VSub_Name "$GZIP_CMD")}]
                  redirects: [
                    (Redir
                      op_id: Redir_DGreat
                      fd: -1
                      arg_word: {($ VSub_Name "$LOG_FILENAME")}
                      spids: [5111]
                    )
                  ]
                )
              ]
              negated: False
            )
            (Pipeline
              children: [
                (Subshell
                  child: 
                    (CommandList
                      children: [
                        (C {(echo)} {(DQ (____________________________________________))})
                        (C {(echo)} {(DQ )})
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:nvidia_debugdump)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (Pipeline
                                            children: [
                                              (SimpleCommand
                                                words: [{(which)} {(nvidia-debugdump)}]
                                                redirects: [
                                                  (Redir
                                                    op_id: Redir_Great
                                                    fd: 2
                                                    arg_word: {(/dev/null)}
                                                    spids: [5145]
                                                  )
                                                ]
                                              )
                                              (C {(head)} {(-n)} {(1)})
                                            ]
                                            negated: False
                                          )
                                        ]
                                      )
                                    left_token: <Left_Backtick "`">
                                    spids: [5140 5156]
                                  )
                                }
                              spids: [5139]
                            )
                          ]
                          spids: [5139]
                        )
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (Sentence
                                  child: 
                                    (C {(Lit_Other "[")} {($ VSub_QMark "$?")} {(-eq)} {(0)} {(-a)} {(-x)} 
                                      {(DQ ($ VSub_Name "$nvidia_debugdump"))} {(Lit_Other "]")}
                                    )
                                  terminator: <Op_Semi ";">
                                )
                              ]
                              action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:base64)
                                      op: Equal
                                      rhs: 
                                        {
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (Pipeline
                                                    children: [
                                                      (SimpleCommand
                                                        words: [{(which)} {(base64)}]
                                                        redirects: [
                                                          (Redir
                                                            op_id: Redir_Great
                                                            fd: 2
                                                            arg_word: {(/dev/null)}
                                                            spids: [5192]
                                                          )
                                                        ]
                                                      )
                                                      (C {(head)} {(-n)} {(1)})
                                                    ]
                                                    negated: False
                                                  )
                                                ]
                                              )
                                            left_token: <Left_Backtick "`">
                                            spids: [5187 5203]
                                          )
                                        }
                                      spids: [5186]
                                    )
                                  ]
                                  spids: [5186]
                                )
                                (If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (Sentence
                                          child: 
                                            (C {(Lit_Other "[")} {($ VSub_QMark "$?")} {(-eq)} {(0)} 
                                              {(-a)} {(-x)} {(DQ ($ VSub_Name "$base64"))} {(Lit_Other "]")}
                                            )
                                          terminator: <Op_Semi ";">
                                        )
                                      ]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:NVDD_TEMP_FILENAME)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ (nvidia-debugdump-temp) ($ VSub_Dollar "$$") 
                                                    (.log)
                                                  )
                                                }
                                              spids: [5238]
                                            )
                                          ]
                                          spids: [5238]
                                        )
                                        (SimpleCommand
                                          words: [{(touch)} {($ VSub_Name "$NVDD_TEMP_FILENAME")}]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_Great
                                              fd: 2
                                              arg_word: {(/dev/null)}
                                              spids: [5252]
                                            )
                                          ]
                                        )
                                        (If
                                          arms: [
                                            (if_arm
                                              cond: [
                                                (Sentence
                                                  child: 
                                                    (C {(Lit_Other "[")} {($ VSub_QMark "$?")} {(-ne)} 
                                                      {(0)} {(Lit_Other "]")}
                                                    )
                                                  terminator: <Op_Semi ";">
                                                )
                                              ]
                                              action: [
                                                (C {(echo)} 
                                                  {
                                                    (DQ 
                                                      (
"Skipping nvidia-debugdump output (can't create temp file "
                                                      ) ($ VSub_Name "$NVDD_TEMP_FILENAME") (")")
                                                    )
                                                  }
                                                )
                                                (C {(echo)} {(DQ )})
                                              ]
                                              spids: [-1 5271]
                                            )
                                          ]
                                          else_action: [
                                            (ForEach
                                              iter_name: instance
                                              iter_words: [{($ VSub_Name "$proc_module_dirs")}]
                                              do_arg_iter: False
                                              body: 
                                                (DoGroup
                                                  children: [
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (C {(Lit_Other "[")} 
                                                                  {($ VSub_Name "$instance")} {(KW_Bang "!") (Lit_Other "=")} {(SQ <.>)} {(Lit_Other "]")}
                                                                )
                                                              terminator: <Op_Semi ";">
                                                            )
                                                          ]
                                                          action: [
                                                            (C {(export)} 
                                                              {
                                                                (Lit_VarLike 
"__RM_MODULE_INSTANCE="
                                                                ) ($ VSub_Name "$instance")
                                                              }
                                                            )
                                                            (C {(echo)} 
                                                              {
                                                                (DQ 
                                                                  (
"NVIDIA Kernel module instance "
                                                                  ) ($ VSub_Name "$instance")
                                                                )
                                                              }
                                                            )
                                                          ]
                                                          spids: [-1 5324]
                                                        )
                                                      ]
                                                      spids: [-1 5341]
                                                    )
                                                    (C {(echo)} 
                                                      {
                                                        (DQ ($ VSub_Name "$nvidia_debugdump") (" -D"))
                                                      }
                                                    )
                                                    (C {(echo)} {(DQ )})
                                                    (SimpleCommand
                                                      words: [
                                                        {($ VSub_Name "$nvidia_debugdump")}
                                                        {(-D)}
                                                        {(-f)}
                                                        {($ VSub_Name "$NVDD_TEMP_FILENAME")}
                                                      ]
                                                      redirects: [
                                                        (Redir
                                                          op_id: Redir_Great
                                                          fd: 2
                                                          arg_word: {(/dev/null)}
                                                          spids: [5367]
                                                        )
                                                      ]
                                                    )
                                                    (SimpleCommand
                                                      words: [
                                                        {($ VSub_Name "$base64")}
                                                        {($ VSub_Name "$NVDD_TEMP_FILENAME")}
                                                      ]
                                                      redirects: [
                                                        (Redir
                                                          op_id: Redir_Great
                                                          fd: 2
                                                          arg_word: {(/dev/null)}
                                                          spids: [5376]
                                                        )
                                                      ]
                                                    )
                                                    (C {(echo)} {(DQ )})
                                                    (SimpleCommand
                                                      words: [
                                                        {(rm)}
                                                        {($ VSub_Name "$NVDD_TEMP_FILENAME")}
                                                      ]
                                                      redirects: [
                                                        (Redir
                                                          op_id: Redir_Great
                                                          fd: 2
                                                          arg_word: {(/dev/null)}
                                                          spids: [5396]
                                                        )
                                                      ]
                                                    )
                                                    (C {(unset)} {(__RM_MODULE_INSTANCE)})
                                                  ]
                                                  spids: [5305 5406]
                                                )
                                              spids: [5301 5303]
                                            )
                                          ]
                                          spids: [5293 5409]
                                        )
                                      ]
                                      spids: [-1 5229]
                                    )
                                  ]
                                  else_action: [
                                    (C {(echo)} 
                                      {(DQ ("Skipping nvidia-debugdump output (base64 not found)"))}
                                    )
                                    (C {(echo)} {(DQ )})
                                  ]
                                  spids: [5412 5428]
                                )
                              ]
                              spids: [-1 5181]
                            )
                          ]
                          else_action: [
                            (C {(echo)} 
                              {
                                (DQ ("Skipping nvidia-debugdump output (nvidia-debugdump not found)"))
                              }
                            )
                            (C {(echo)} {(DQ )})
                          ]
                          spids: [5431 5447]
                        )
                      ]
                    )
                  spids: [5122 5450]
                )
                (SimpleCommand
                  words: [{($ VSub_Name "$GZIP_CMD")}]
                  redirects: [
                    (Redir
                      op_id: Redir_DGreat
                      fd: -1
                      arg_word: {($ VSub_Name "$LOG_FILENAME")}
                      spids: [5456]
                    )
                  ]
                )
              ]
              negated: False
            )
          ]
          spids: [-1 4862]
        )
      ]
      else_action: [
        (Pipeline
          children: [
            (Subshell
              child: 
                (CommandList
                  children: [
                    (C {(echo)} 
                      {
                        (DQ ("Skipping nvidia-smi and nvidia-debugdump due to --safe-mode argument."))
                      }
                    )
                    (C {(echo)} {(DQ )})
                  ]
                )
              spids: [5464 5480]
            )
            (SimpleCommand
              words: [{($ VSub_Name "$GZIP_CMD")}]
              redirects: [
                (Redir
                  op_id: Redir_DGreat
                  fd: -1
                  arg_word: {($ VSub_Name "$LOG_FILENAME")}
                  spids: [5486]
                )
              ]
            )
          ]
          negated: False
        )
      ]
      spids: [5461 5490]
    )
    (Pipeline
      children: [
        (Subshell
          child: 
            (CommandList
              children: [
                (C {(echo)} {(DQ (____________________________________________))})
                (C {(echo)} {(DQ )})
                (C {(echo)} {(DQ ("End of NVIDIA bug report log file."))})
              ]
            )
          spids: [5493 5521]
        )
        (SimpleCommand
          words: [{($ VSub_Name "$GZIP_CMD")}]
          redirects: [
            (Redir
              op_id: Redir_DGreat
              fd: -1
              arg_word: {($ VSub_Name "$LOG_FILENAME")}
              spids: [5527]
            )
          ]
        )
      ]
      negated: False
    )
    (C {(echo)} {(DQ (" complete."))})
    (C {(echo)} {(DQ )})
  ]
)